feat(sdk-coin-icp): improve transaction signature validation

TICKET: WIN-4908

Author: mohd-kashif

modules/sdk-coin-icp/src/lib/signedTransactionBuilder.ts

@@ -51,12 +51,12 @@ export class SignedTransactionBuilder {
         const readState = utils.makeReadStateFromUpdate(update);
         const transactionSignature = utils.getTransactionSignature(signatureMap, update);
         if (!transactionSignature) {
-          throw new Error('Transaction signature is undefined');
+          throw new Error('Transaction signature is invalid');
         }
 
         const readStateSignature = utils.getReadStateSignature(signatureMap, readState);
         if (!readStateSignature) {
-          throw new Error('read state signature is undefined');
+          throw new Error('read state signature is invalid');
         }
 
         const pk_der = utils.getPublicKeyInDERFormat(transactionSignature.public_key.hex_bytes);

modules/sdk-coin-icp/src/lib/transaction.ts

@@ -34,6 +34,7 @@ export class Transaction extends BaseTransaction {
   protected _payloadsData: PayloadsData;
   protected _signedTransaction: string;
   protected _signaturePayload: Signatures[];
+  protected _createdTimestamp: number | bigint | undefined;
   protected _utils: Utils;
 
   constructor(_coinConfig: Readonly<CoinConfig>, utils: Utils) {
@@ -81,6 +82,14 @@ export class Transaction extends BaseTransaction {
     return this._payloadsData;
   }
 
+  set createdTimestamp(createdTimestamp: number) {
+    this._createdTimestamp = createdTimestamp;
+  }
+
+  get createdTimestamp(): number | bigint | undefined {
+    return this._createdTimestamp;
+  }
+
   async fromRawTransaction(rawTransaction: string): Promise<void> {
     try {
       const jsonRawTransaction: RawTransaction = JSON.parse(rawTransaction);
@@ -273,6 +282,7 @@ export class Transaction extends BaseTransaction {
       },
       account_identifier_signers: accountIdentifierSigners,
     };
+    this.createdTimestamp = args.createdAtTime.timestampNanos;
     return parsedTxn;
   }
 

modules/sdk-coin-icp/src/lib/transferBuilder.ts

@@ -48,7 +48,7 @@ export class TransferBuilder extends TransactionBuilder {
     assert(this._publicKey, new BuildTransactionError('sender public key is required before building'));
     assert(this._amount, new BuildTransactionError('amount is required before building'));
     assert(this._receiverId, new BuildTransactionError('receiver is required before building'));
-    assert(this._memo, new BuildTransactionError('memo is required before building'));
+    this._utils.validateMemo(this._memo);
     const publicKey: IcpPublicKey = {
       hex_bytes: this._publicKey,
       curve_type: CurveType.SECP256K1,
@@ -90,8 +90,9 @@ export class TransferBuilder extends TransactionBuilder {
       },
     };
 
+    const createdTimestamp = this._transaction.createdTimestamp;
     const { metaData, ingressEndTime }: { metaData: IcpMetadata; ingressEndTime: number | BigInt } =
-      this._utils.getMetaData(this._memo);
+      this._utils.getMetaData(this._memo, createdTimestamp);
 
     const icpTransaction: IcpTransaction = {
       public_keys: [publicKey],

modules/sdk-coin-icp/src/lib/utils.ts

@@ -608,8 +608,14 @@ export class Utils implements BaseUtils {
     );
   }
 
-  getMetaData(memo: number | BigInt): { metaData: IcpMetadata; ingressEndTime: number | BigInt } {
-    const currentTime = Date.now() * 1000000;
+  getMetaData(
+    memo: number | BigInt,
+    timestamp: number | bigint | undefined
+  ): { metaData: IcpMetadata; ingressEndTime: number | BigInt } {
+    let currentTime = Date.now() * 1000000;
+    if (timestamp) {
+      currentTime = Number(timestamp);
+    }
     const ingressStartTime = currentTime;
     const ingressEndTime = ingressStartTime + 5 * 60 * 1000000000; // 5 mins in nanoseconds
     const metaData: IcpMetadata = {

modules/sdk-coin-icp/test/unit/transactionBuilder/transactionBuilder.ts

@@ -101,4 +101,28 @@ describe('ICP Transaction Builder', async () => {
     should.equal(broadcastTxnObj.signed_transaction, signedTxn);
     should.equal(broadcastTxnObj.network_identifier.network, '00000000000000020101');
   });
+
+  it('should build a txn then parse it and then again build', async () => {
+    sinon.restore(); // do not stub getMetaData
+    txBuilder = factory.getTransferBuilder();
+    txBuilder.sender(testData.accounts.account1.address, testData.accounts.account1.publicKey);
+    txBuilder.receiverId(testData.accounts.account2.address);
+    txBuilder.amount('10');
+    txBuilder.memo(testData.metaData.memo);
+
+    await txBuilder.build();
+    txn = txBuilder.transaction;
+    const unsignedTxn = txBuilder.transaction.unsignedTransaction;
+    unsignedTxn.should.be.a.String();
+    const rawTransaction = {
+      serializedTxHex: unsignedTxn,
+      publicKey: testData.accounts.account1.publicKey,
+    };
+    await txn.fromRawTransaction(JSON.stringify(rawTransaction));
+    const baseKey: BaseKey = { key: testData.accounts.account1.secretKey };
+    txBuilder.sign(baseKey);
+    txBuilder.combine();
+    const signedTxn = txBuilder.transaction.signedTransaction;
+    signedTxn.should.be.a.String();
+  });
 });