Merge pull request #5980 from BitGo/WIN-5199

feat(sdk-coin-icp): added txn hash generation logic

Author: DinshawKothari

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

@@ -194,3 +194,7 @@ export interface RecoveryOptions {
 export interface PublicNodeSubmitResponse {
   status: string;
 }
+
+export interface AccountIdentifierHash {
+  hash: Buffer<ArrayBuffer>;
+}

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

@@ -95,6 +95,7 @@ export class Transaction extends BaseTransaction {
       const serializedTxFormatJsonString = serializedTxFormatBuffer.toString('utf-8');
       const jsonRawTransaction: RawTransaction = JSON.parse(serializedTxFormatJsonString);
       const payloadsData = jsonRawTransaction.serializedTxHex;
+      this._payloadsData = payloadsData;
       const parsedTx = await this.parseUnsignedTransaction(payloadsData.unsigned_transaction);
       const senderPublicKeyHex = jsonRawTransaction.publicKey;
       const transactionType = parsedTx.operations[0].type;
@@ -113,12 +114,13 @@ export class Transaction extends BaseTransaction {
             this._icpTransactionData.memo = parsedTx.metadata.memo;
           }
           this._utils.validateRawTransaction(this._icpTransactionData);
+          this._id = this.generateTransactionId();
           break;
         default:
           throw new Error('Invalid transaction type');
       }
     } catch (error) {
-      throw new InvalidTransactionError(`Invalid transaction type: ${error.message}`);
+      throw new InvalidTransactionError(`Invalid transaction: ${error.message}`);
     }
   }
 
@@ -130,6 +132,9 @@ export class Transaction extends BaseTransaction {
       throw new Error('signatures length is not matching');
     }
     this._signaturePayload = signaturePayloads;
+    if (this._id === undefined || this._id === null) {
+      this._id = this.generateTransactionId();
+    }
   }
 
   /** @inheritdoc */
@@ -299,4 +304,20 @@ export class Transaction extends BaseTransaction {
   canSign(key: BaseKey): boolean {
     return true;
   }
+
+  /**
+   * Generates a unique transaction ID for the current transaction.
+   * The transaction ID is derived using the unsigned transaction data,
+   * the sender's address, and the receiver's address.
+   *
+   * @returns {string} The generated transaction ID.
+   */
+  private generateTransactionId(): string {
+    const id = this._utils.getTransactionId(
+      this.unsignedTransaction,
+      this.icpTransactionData.senderAddress,
+      this.icpTransactionData.receiverAddress
+    );
+    return id;
+  }
 }

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

@@ -20,14 +20,24 @@ import {
   SendArgs,
   PayloadsData,
   CurveType,
+  AccountIdentifierHash,
+  CborUnsignedTransaction,
 } from './iface';
 import { KeyPair as IcpKeyPair } from './keyPair';
-const { encode, decode } = require('cbor-x/index-no-eval'); // The "cbor-x" library is used here because it supports modern features like BigInt. do not replace it with "cbor as "cbor" is not compatible with Rust's serde_cbor when handling big numbers.
+const { encode, decode, Encoder } = require('cbor-x/index-no-eval'); // The "cbor-x" library is used here because it supports modern features like BigInt. do not replace it with "cbor as "cbor" is not compatible with Rust's serde_cbor when handling big numbers.
 import js_sha256 from 'js-sha256';
 import BigNumber from 'bignumber.js';
 import { secp256k1 } from '@noble/curves/secp256k1';
 import protobuf from 'protobufjs';
 
+//custom encoder that avoids tagging
+const encoder = new Encoder({
+  structuredClone: false,
+  useToJSON: false,
+  mapsAsObjects: false,
+  largeBigIntToFloat: false,
+});
+
 export class Utils implements BaseUtils {
   /** @inheritdoc */
   isValidSignature(signature: string): boolean {
@@ -603,18 +613,18 @@ export class Utils implements BaseUtils {
     return principalBytes;
   }
 
-  async fromArgs(arg: Uint8Array): Promise<SendArgs> {
+  fromArgs(arg: Uint8Array): SendArgs {
     const root = protobuf.Root.fromJSON(require(path.resolve(__dirname, './staticProtoDefinition.json')));
     const SendRequestMessage = root.lookupType('SendRequest');
     const args = SendRequestMessage.decode(arg) as unknown as SendArgs;
     const transformedArgs: SendArgs = {
-      payment: { receiverGets: { e8s: args.payment.receiverGets.e8s } },
-      maxFee: { e8s: args.maxFee.e8s },
+      payment: { receiverGets: { e8s: Number(args.payment.receiverGets.e8s) } },
+      maxFee: { e8s: Number(args.maxFee.e8s) },
       to: { hash: Buffer.from(args.to.hash) },
       createdAtTime: { timestampNanos: BigNumber(args.createdAtTime.timestampNanos.toString()).toNumber() },
     };
     if (args.memo !== undefined && args.memo !== null) {
-      transformedArgs.memo = { memo: BigInt(args.memo?.memo?.toString()) };
+      transformedArgs.memo = { memo: Number(args.memo?.memo?.toString()) };
     }
     return transformedArgs;
   }
@@ -673,6 +683,84 @@ export class Utils implements BaseUtils {
     const s = Buffer.from(signature.s.toString(16).padStart(64, '0'), 'hex');
     return Buffer.concat([r, s]).toString('hex');
   };
+
+  getTransactionId(unsignedTransaction: string, senderAddress: string, receiverAddress: string): string {
+    try {
+      const decodedTxn = utils.cborDecode(utils.blobFromHex(unsignedTransaction)) as CborUnsignedTransaction;
+      const updates = decodedTxn.updates as unknown as [string, HttpCanisterUpdate][];
+      for (const [, update] of updates) {
+        const updateArgs = update.arg;
+        const sendArgs = utils.fromArgs(updateArgs);
+        const transactionHash = this.generateTransactionHash(sendArgs, senderAddress, receiverAddress);
+        return transactionHash;
+      }
+      throw new Error('No updates found in the unsigned transaction.');
+    } catch (error) {
+      throw new Error(`Unable to compute transaction ID: ${error.message}`);
+    }
+  }
+
+  safeBigInt(value: unknown): number | bigint {
+    if (typeof value === 'bigint') {
+      return value;
+    }
+
+    if (typeof value === 'number') {
+      const isUnsafe = value > Number.MAX_SAFE_INTEGER || value < Number.MIN_SAFE_INTEGER;
+      return isUnsafe ? BigInt(value) : value;
+    }
+
+    throw new Error(`Invalid type: expected a number or bigint, but received ${typeof value}`);
+  }
+
+  generateTransactionHash(sendArgs: SendArgs, senderAddress: string, receiverAddress: string): string {
+    const senderAccount = this.accountIdentifier(senderAddress);
+    const receiverAccount = this.accountIdentifier(receiverAddress);
+
+    const transferFields = new Map<any, any>([
+      [0, senderAccount],
+      [1, receiverAccount],
+      [2, new Map([[0, this.safeBigInt(Number(sendArgs.payment.receiverGets.e8s))]])],
+      [3, new Map([[0, sendArgs.maxFee.e8s]])],
+    ]);
+
+    const operationMap = new Map([[2, transferFields]]);
+    const txnFields = new Map<any, any>([
+      [0, operationMap],
+      [1, this.safeBigInt(sendArgs.memo?.memo || 0)], // TODO: remove 0 value as memo will always be set, WIN-5232
+      [2, new Map([[0, BigInt(sendArgs.createdAtTime.timestampNanos)]])],
+    ]);
+
+    const processedTxn = this.getProcessedTransactionMap(txnFields);
+    const serializedTxn = encoder.encode(processedTxn);
+    return crypto.createHash('sha256').update(serializedTxn).digest('hex');
+  }
+
+  accountIdentifier(accountAddress: string): AccountIdentifierHash {
+    const bytes = Buffer.from(accountAddress, 'hex');
+    if (bytes.length === 32) {
+      return { hash: bytes.slice(4) };
+    }
+    throw new Error(`Invalid AccountIdentifier: 64 hex chars, got ${accountAddress.length}`);
+  }
+
+  getProcessedTransactionMap(txnMap: Map<any, any>): Map<any, any> {
+    const operationMap = txnMap.get(0);
+    const transferMap = operationMap.get(2);
+    transferMap.set(0, this.serializeAccountIdentifier(transferMap.get(0)));
+    transferMap.set(1, this.serializeAccountIdentifier(transferMap.get(1)));
+    return txnMap;
+  }
+
+  serializeAccountIdentifier(accountHash: AccountIdentifierHash): string {
+    if (accountHash && accountHash.hash) {
+      const hashBuffer = accountHash.hash;
+      const checksum = Buffer.alloc(4);
+      checksum.writeUInt32BE(crc32.buf(hashBuffer) >>> 0, 0);
+      return Buffer.concat([checksum, hashBuffer]).toString('hex').toLowerCase();
+    }
+    throw new Error('Invalid accountHash format');
+  }
 }
 
 const utils = new Utils();

modules/sdk-coin-icp/test/resources/icp.ts

@@ -195,6 +195,8 @@ export const payloadsData = {
     'b90002677570646174657381826b5452414e53414354494f4eb900056b63616e69737465725f69644a000000000000000201016b6d6574686f645f6e616d656773656e645f70626361726758400a0308d20912040a02080a1a0308904e2a220a20c3d30f404955975adaba89f2e1ebc75c1f44a6a204578afce8f3780d64fe252e3a0a0880a48596eb92b599186673656e646572581dd5fc1dc4d74d4aa35d81cf345533d20548113412d32fffdcece2f68a026e696e67726573735f6578706972791b000000000000000070696e67726573735f6578706972696573811b1832d4ce93deb200',
 };
 
+export const OnChainTransactionHash = '87f2e7ca80961bdc3a1fe761553a8a7f8ac5bf28b71f4e1fba807cf352a27f52';
+
 export const payloadsDataWithoutMemo = {
   payloads: [
     {

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

@@ -92,11 +92,29 @@ describe('ICP Transaction Builder', async () => {
     const signedTxn = txBuilder.transaction.signedTransaction;
     signedTxn.should.be.a.String();
     should.equal(signedTxn, testData.SignedTransaction);
+    const transactionHash = txBuilder.transaction.id;
+    should.equal(transactionHash, testData.OnChainTransactionHash);
     const broadcastTxn = txBuilder.transaction.toBroadcastFormat();
     broadcastTxn.should.be.a.String();
     should.equal(broadcastTxn, signedTxn);
   });
 
+  it('should generate a correct txn hash', async () => {
+    sinon.stub(txn._utils, 'validateExpireTime').returns(true);
+    const unsignedTxn = txBuilder.transaction.unsignedTransaction;
+    unsignedTxn.should.be.a.String();
+    const payloadsData = txBuilder.transaction.payloadsData;
+    const serializedTxFormat = {
+      serializedTxHex: payloadsData,
+      publicKey: testData.accounts.account1.publicKey,
+    };
+    const serializedTxHex = Buffer.from(JSON.stringify(serializedTxFormat), 'utf-8').toString('hex');
+    await txn.fromRawTransaction(serializedTxHex);
+    const transactionHash = txBuilder.transaction.id;
+    should.equal(transactionHash, testData.OnChainTransactionHash);
+    sinon.restore();
+  });
+
   it('should build a txn then parse it and then again build', async () => {
     sinon.restore(); // do not stub getMetaData
     txBuilder = factory.getTransferBuilder();