feat(sdk-coin-icp): enhance raw transaction handling

TICKET: WIN-4908

Author: mohd-kashif

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

@@ -4,6 +4,9 @@ import {
 } from '@bitgo/sdk-core';
 
 export const REQUEST_STATUS = 'request_status';
+export const MAX_INGRESS_TTL = 5 * 60 * 1000_000_000; // 5 minutes in nanoseconds
+export const PERMITTED_DRIFT = 60 * 1000_000_000; // 60 seconds in nanoseconds
+export const LEDGER_CANISTER_ID = new Uint8Array([0, 0, 0, 0, 0, 0, 0, 2, 1, 1]); // Uint8Array value for "00000000000000020101" and the string value is "ryjl3-tyaaa-aaaaa-aaaba-cai"
 
 export enum RequestType {
   CALL = 'call',
@@ -189,3 +192,8 @@ export interface SignedTransactionRequest {
   network_identifier: NetworkIdentifier;
   signed_transaction: string;
 }
+
+export interface RawTransaction {
+  serializedTxHex: string;
+  publicKey: string;
+}

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

@@ -22,6 +22,9 @@ import {
   ParsedTransaction,
   IcpOperation,
   IcpAccount,
+  MAX_INGRESS_TTL,
+  PERMITTED_DRIFT,
+  RawTransaction,
 } from './iface';
 import { Utils } from './utils';
 
@@ -78,20 +81,23 @@ export class Transaction extends BaseTransaction {
     return this._payloadsData;
   }
 
-  fromRawTransaction(rawTransaction: string): void {
+  async fromRawTransaction(rawTransaction: string): Promise<void> {
     try {
-      const parsedTx = JSON.parse(rawTransaction);
-      switch (parsedTx.type) {
+      const jsonRawTransaction: RawTransaction = JSON.parse(rawTransaction);
+      const parsedTx = await this.parseUnsignedTransaction(jsonRawTransaction.serializedTxHex);
+      const senderPublicKeyHex = jsonRawTransaction.publicKey;
+      const transactionType = parsedTx.operations[0].type;
+      switch (transactionType) {
         case OperationType.TRANSACTION:
           this._icpTransactionData = {
-            senderAddress: parsedTx.address,
-            receiverAddress: parsedTx.externalOutputs[0].address,
-            amount: parsedTx.spendAmountString,
-            fee: parsedTx.fee,
-            senderPublicKeyHex: parsedTx.senderKey,
-            memo: parsedTx.seqno,
-            transactionType: parsedTx.type,
-            expiryTime: parsedTx.expiryTime,
+            senderAddress: parsedTx.operations[0].account.address,
+            receiverAddress: parsedTx.operations[1].account.address,
+            amount: parsedTx.operations[1].amount.value,
+            fee: parsedTx.operations[2].amount.value,
+            senderPublicKeyHex: senderPublicKeyHex,
+            memo: parsedTx.metadata.memo,
+            transactionType: transactionType,
+            expiryTime: Number(parsedTx.metadata.created_at_time + (MAX_INGRESS_TTL - PERMITTED_DRIFT)),
           };
           this._utils.validateRawTransaction(this._icpTransactionData);
           break;

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

@@ -7,13 +7,12 @@ import {
   SignatureType,
   OperationType,
   MethodName,
+  MAX_INGRESS_TTL,
+  PERMITTED_DRIFT,
+  LEDGER_CANISTER_ID,
 } from './iface';
 import utils from './utils';
 
-const MAX_INGRESS_TTL = 5 * 60 * 1000_000_000; // 5 minutes in nanoseconds
-const PERMITTED_DRIFT = 60 * 1000_000_000; // 60 seconds in nanoseconds
-const LEDGER_CANISTER_ID = new Uint8Array([0, 0, 0, 0, 0, 0, 0, 2, 1, 1]); // Uint8Array value for "00000000000000020101" and the string value is "ryjl3-tyaaa-aaaaa-aaaba-cai"
-
 export class UnsignedTransactionBuilder {
   private _icpTransactionPayload: IcpTransaction;
   constructor(icpTransactionPayload: IcpTransaction) {

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

@@ -98,23 +98,71 @@ export const IcpTransactionData = {
 };
 
 export const rawTransaction = {
-  outputAmount: '10',
-  inputAmount: '10',
-  spendAmount: '10',
-  fee: '-10000',
-  externalOutputs: [
+  serializedTxHex:
+    'b90002677570646174657381826b5452414e53414354494f4eb900056b63616e69737465725f69644a000000000000000201016b6d6574686f645f6e616d656773656e645f70626361726758410a02080112060a0408c0843d1a0308904e2a220a20c3d30f404955975adaba89f2e1ebc75c1f44a6a204578afce8f3780d64fe252e3a0a0880ecbac5bfcc9d97186673656e646572581dd5fc1dc4d74d4aa35d81cf345533d20548113412d32fffdcece2f68a026e696e67726573735f6578706972791b000000000000000070696e67726573735f6578706972696573811b182e769bd9cc1600',
+  publicKey:
+    '042ab77b959e28c4fa47fa8fb9e57cec3d66df5684d076ac2e4c5f28fd69a23dd31a59f908c8add51eab3530b4ac5d015166eaf2198c52fa9a8df7cfaeb8fdb7d4',
+};
+
+export const parsedRawTransaction = {
+  operations: [
+    {
+      operation_identifier: {
+        index: 0,
+      },
+      type: 'TRANSACTION',
+      status: null,
+      account: {
+        address: '0af815da8259ba8bb3d34fbfb2ac730f07a1adc81438d40d667d91b408b25f2f',
+      },
+      amount: {
+        value: '-1000000',
+        currency: {
+          symbol: 'ICP',
+          decimals: 8,
+        },
+      },
+    },
+    {
+      operation_identifier: {
+        index: 1,
+      },
+      type: 'TRANSACTION',
+      status: null,
+      account: {
+        address: 'c3d30f404955975adaba89f2e1ebc75c1f44a6a204578afce8f3780d64fe252e',
+      },
+      amount: {
+        value: '1000000',
+        currency: {
+          symbol: 'ICP',
+          decimals: 8,
+        },
+      },
+    },
     {
-      amount: '10',
-      address: accounts.account2.address,
+      operation_identifier: {
+        index: 2,
+      },
+      type: 'FEE',
+      status: null,
+      account: {
+        address: '0af815da8259ba8bb3d34fbfb2ac730f07a1adc81438d40d667d91b408b25f2f',
+      },
+      amount: {
+        value: '-10000',
+        currency: {
+          symbol: 'ICP',
+          decimals: 8,
+        },
+      },
     },
   ],
-  type: OperationType.TRANSACTION,
-  address: accounts.account1.address,
-  senderKey: accounts.account1.publicKey,
-  seqno: 1740638136656000000,
-  spendAmountString: '10',
-  id: '5jTEPuDcMCeEgp1iyEbNBKsnhYz4F4c1EPDtRmxm3wCw',
-  expiryTime: Date.now() * 1000_000 + 5 * 60 * 1000_000_000,
+  account_identifier_signers: [],
+  metadata: {
+    created_at_time: 1742457444920999936,
+    memo: 1,
+  },
 };
 
 export const metaData: IcpMetadata = {

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

@@ -4,7 +4,8 @@ import assert from 'assert';
 import should from 'should';
 import { Utils } from '../../src/lib/utils';
 import { InvalidTransactionError, TransactionType as BitGoTransactionType } from '@bitgo/sdk-core';
-import { rawTransaction, accounts } from '../resources/icp';
+import { rawTransaction, accounts, parsedRawTransaction } from '../resources/icp';
+import sinon from 'sinon';
 
 describe('ICP Transaction', () => {
   let tx: Transaction;
@@ -15,7 +16,8 @@ describe('ICP Transaction', () => {
   beforeEach(() => {
     utils = new Utils();
     tx = new Transaction(config, utils);
-    localRawTransaction = JSON.parse(JSON.stringify(rawTransaction));
+    localRawTransaction = JSON.stringify(rawTransaction);
+    sinon.stub(utils, 'validateExpireTime').returns(true);
   });
 
   describe('empty transaction', () => {
@@ -35,43 +37,24 @@ describe('ICP Transaction', () => {
 
   describe('from raw transaction', () => {
     it('build a json transaction from raw hex', async () => {
-      tx.fromRawTransaction(JSON.stringify(localRawTransaction));
+      await tx.fromRawTransaction(localRawTransaction);
       const json = tx.toJson();
-      should.equal(json.expirationTime, localRawTransaction.expiryTime);
-      should.equal(json.memo, localRawTransaction.seqno);
-      should.equal(json.feeAmount, '-10000');
-      should.equal(json.sender, localRawTransaction.address);
-      should.equal(json.recipient, localRawTransaction.externalOutputs[0].address);
+      should.equal(json.memo, parsedRawTransaction.metadata.memo);
+      should.equal(json.feeAmount, parsedRawTransaction.operations[2].amount.value);
+      should.equal(json.sender, parsedRawTransaction.operations[0].account.address);
+      should.equal(json.recipient, parsedRawTransaction.operations[1].account.address);
       should.equal(json.type, BitGoTransactionType.Send);
       should.equal(json.senderPublicKey, accounts.account1.publicKey);
     });
-
-    it('should fail when memo is passed as alphanumeric', async () => {
-      (localRawTransaction as any).seqno = 'abc123';
-      assert.throws(
-        () => tx.fromRawTransaction(JSON.stringify(localRawTransaction)),
-        (err) => err instanceof InvalidTransactionError && err.message === 'Invalid raw transaction',
-        'Expected an InvalidTransactionError with message "Invalid raw transaction"'
-      );
-    });
-
-    it('should fail when memo is passed as string', async () => {
-      (localRawTransaction as any).seqno = 'abc';
-      assert.throws(
-        () => tx.fromRawTransaction(JSON.stringify(localRawTransaction)),
-        (err) => err instanceof InvalidTransactionError && err.message === 'Invalid raw transaction',
-        'Expected an InvalidTransactionError with message "Invalid raw transaction"'
-      );
-    });
   });
 
   describe('Explain', () => {
     it('explain transaction', async () => {
-      tx.fromRawTransaction(JSON.stringify(localRawTransaction));
+      await tx.fromRawTransaction(localRawTransaction);
       const explain = tx.explainTransaction();
 
-      explain.outputAmount.should.equal('10');
-      explain.outputs[0].amount.should.equal('10');
+      explain.outputAmount.should.equal('1000000');
+      explain.outputs[0].amount.should.equal('1000000');
       explain.outputs[0].address.should.equal(accounts.account2.address);
       explain.fee.fee.should.equal('-10000');
       explain.changeAmount.should.equal('0');