Merge pull request #5952 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 AccountIdentifierHex {
+  hash: Buffer<ArrayBuffer>;
+}

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

@@ -34,6 +34,7 @@ export class Transaction extends BaseTransaction {
   protected _signedTransaction: string;
   protected _signaturePayload: Signatures[];
   protected _createdTimestamp: number | bigint | undefined;
+  protected _txnId: string | undefined;
   protected _utils: Utils;
 
   constructor(_coinConfig: Readonly<CoinConfig>, utils: Utils) {
@@ -89,6 +90,14 @@ export class Transaction extends BaseTransaction {
     return this._createdTimestamp;
   }
 
+  set txnId(txnId: string) {
+    this._txnId = txnId;
+  }
+
+  get txnId(): string | undefined {
+    return this._txnId;
+  }
+
   async fromRawTransaction(rawTransaction: string): Promise<void> {
     try {
       const jsonRawTransaction: RawTransaction = JSON.parse(rawTransaction);
@@ -115,7 +124,7 @@ export class Transaction extends BaseTransaction {
           throw new Error('Invalid transaction type');
       }
     } catch (error) {
-      throw new InvalidTransactionError('Invalid raw transaction');
+      throw new InvalidTransactionError(`Invalid raw transaction: ${error.message}`);
     }
   }
 
@@ -137,7 +146,7 @@ export class Transaction extends BaseTransaction {
     switch (this._icpTransactionData.transactionType) {
       case OperationType.TRANSACTION:
         const txData: TxData = {
-          id: this._id,
+          id: this._id, //TODO set transaction ID
           sender: this._icpTransactionData.senderAddress,
           senderPublicKey: this._icpTransactionData.senderPublicKeyHex,
           recipient: this._icpTransactionData.receiverAddress,

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

@@ -13,6 +13,7 @@ export abstract class TransactionBuilder extends BaseTransactionBuilder {
   protected _memo: number | BigInt;
   protected _receiverId: string;
   protected _amount: string;
+  protected _txnId: string | undefined;
 
   constructor(_coinConfig: Readonly<CoinConfig>) {
     super(_coinConfig);
@@ -169,5 +170,10 @@ export abstract class TransactionBuilder extends BaseTransactionBuilder {
       this._transaction.signaturePayload
     );
     this._transaction.signedTransaction = signedTransactionBuilder.getSignTransaction();
+    this._transaction.txnId = utils.getTransactionId(
+      this._transaction.unsignedTransaction,
+      this._sender,
+      this._receiverId
+    );
   }
 }

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

@@ -19,15 +19,25 @@ import {
   SendArgs,
   PayloadsData,
   CurveType,
+  AccountIdentifierHex,
+  CborUnsignedTransaction,
 } from './iface';
 import { KeyPair as IcpKeyPair } from './keyPair';
-import { decode, encode } from 'cbor-x'; // 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 { decode, encode, Encoder } from 'cbor-x'; // 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';
 import { protoDefinition } from './protoDefinition';
 
+// Create a 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.parse(protoDefinition).root;
     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,81 @@ 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(encodedUnsignedTransaction: string, sender: string, receiver: string): string {
+    const unsignedTransaction = utils.cborDecode(
+      utils.blobFromHex(encodedUnsignedTransaction)
+    ) as CborUnsignedTransaction;
+    for (const [, update] of unsignedTransaction.updates as unknown as [string, HttpCanisterUpdate][]) {
+      const args = update.arg;
+      const sendArgs = utils.fromArgs(args);
+      const hash = this.generateTransactionHash(sendArgs, sender, receiver);
+      return hash;
+    }
+    throw new Error('Unable to compute transaction ID: no updates found in the unsigned transaction.');
+  }
+
+  safeBigInt(val: unknown): number | bigint {
+    if (typeof val === 'bigint') return val;
+    if (typeof val !== 'number') throw new Error('Expected number or bigint');
+
+    if (val > Number.MAX_SAFE_INTEGER || val < Number.MIN_SAFE_INTEGER) {
+      return BigInt(val);
+    }
+    return val;
+  }
+
+  generateTransactionHash(sendArgs: SendArgs, sender: string, receiver: string): string {
+    const from = this.accountIdentifier(sender);
+    const to = this.accountIdentifier(receiver);
+
+    const transferMap = new Map<any, any>([
+      [0, from],
+      [1, to],
+      [2, new Map([[0, this.safeBigInt(Number(sendArgs.payment.receiverGets.e8s))]])],
+      [3, new Map([[0, sendArgs.maxFee.e8s]])],
+    ]);
+
+    const operationMap = new Map([[2, transferMap]]);
+    const txnMap = new Map<any, any>([
+      [0, operationMap],
+      [1, this.safeBigInt(sendArgs.memo?.memo ?? 0)], //TODO need to make memo as optional, ticket: WIN-5209
+      [2, new Map([[0, BigInt(sendArgs.createdAtTime.timestampNanos)]])],
+    ]);
+
+    const transactionMap = this.getProcessedTransactionMap(txnMap);
+    const serializedTxn = encoder.encode(transactionMap);
+    return crypto.createHash('sha256').update(serializedTxn).digest('hex');
+  }
+
+  accountIdentifier(hexStr: string): AccountIdentifierHex {
+    const bytes = Buffer.from(hexStr, 'hex');
+    if (bytes.length === 28) {
+      return { hash: bytes };
+    }
+    if (bytes.length === 32) {
+      return { hash: bytes.slice(4) };
+    }
+    throw new Error(`Invalid AccountIdentifier: expected 56 or 64 hex chars, got ${hexStr.length}`);
+  }
+
+  getProcessedTransactionMap(txn: Map<any, any>): Map<any, any> {
+    const operationMap = txn.get(0);
+    const transferMap = operationMap.get(2);
+    transferMap.set(0, this.serializeAccountIdentifier(transferMap.get(0)));
+    transferMap.set(1, this.serializeAccountIdentifier(transferMap.get(1)));
+    return txn;
+  }
+
+  serializeAccountIdentifier(accountHex: AccountIdentifierHex): string {
+    if (accountHex && accountHex.hash) {
+      const hash = accountHex.hash;
+      const checksum = Buffer.alloc(4);
+      checksum.writeUInt32BE(crc32.buf(hash) >>> 0, 0);
+      return Buffer.concat([checksum, hash]).toString('hex').toLowerCase();
+    }
+    throw new Error('Invalid accountHex format');
+  }
 }
 
 const utils = new Utils();

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

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

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

@@ -92,6 +92,8 @@ describe('ICP Transaction Builder', async () => {
     const signedTxn = txBuilder.transaction.signedTransaction;
     signedTxn.should.be.a.String();
     should.equal(signedTxn, testData.SignedTransaction);
+    const transactionHash = txBuilder.transaction.txnId;
+    should.equal(transactionHash, testData.transactionHash);
     const broadcastTxn = txBuilder.transaction.toBroadcastFormat();
     broadcastTxn.should.be.a.String();
     should.equal(broadcastTxn, signedTxn);