Revert "feat(sdk-coin-icp): Added txn hash generation logic"

Author: DinshawKothari

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

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

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

@@ -34,7 +34,6 @@ 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) {
@@ -90,14 +89,6 @@ 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);
@@ -124,7 +115,7 @@ export class Transaction extends BaseTransaction {
           throw new Error('Invalid transaction type');
       }
     } catch (error) {
-      throw new InvalidTransactionError(`Invalid raw transaction: ${error.message}`);
+      throw new InvalidTransactionError('Invalid raw transaction');
     }
   }
 
@@ -146,7 +137,7 @@ export class Transaction extends BaseTransaction {
     switch (this._icpTransactionData.transactionType) {
       case OperationType.TRANSACTION:
         const txData: TxData = {
-          id: this._id, //TODO set transaction ID
+          id: this._id,
           sender: this._icpTransactionData.senderAddress,
           senderPublicKey: this._icpTransactionData.senderPublicKeyHex,
           recipient: this._icpTransactionData.receiverAddress,

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

@@ -13,7 +13,6 @@ 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);
@@ -170,10 +169,5 @@ 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,25 +19,15 @@ import {
   SendArgs,
   PayloadsData,
   CurveType,
-  AccountIdentifierHex,
-  CborUnsignedTransaction,
 } from './iface';
 import { KeyPair as IcpKeyPair } from './keyPair';
-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 { 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 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 {
@@ -613,18 +603,18 @@ export class Utils implements BaseUtils {
     return principalBytes;
   }
 
-  fromArgs(arg: Uint8Array): SendArgs {
+  async fromArgs(arg: Uint8Array): Promise<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: Number(args.payment.receiverGets.e8s) } },
-      maxFee: { e8s: Number(args.maxFee.e8s) },
+      payment: { receiverGets: { e8s: args.payment.receiverGets.e8s } },
+      maxFee: { e8s: 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: Number(args.memo?.memo?.toString()) };
+      transformedArgs.memo = { memo: BigInt(args.memo?.memo?.toString()) };
     }
     return transformedArgs;
   }
@@ -683,81 +673,6 @@ 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,8 +195,6 @@ export const payloadsData = {
     'b90002677570646174657381826b5452414e53414354494f4eb900056b63616e69737465725f69644a000000000000000201016b6d6574686f645f6e616d656773656e645f70626361726758400a0308d20912040a02080a1a0308904e2a220a20c3d30f404955975adaba89f2e1ebc75c1f44a6a204578afce8f3780d64fe252e3a0a0880a48596eb92b599186673656e646572581dd5fc1dc4d74d4aa35d81cf345533d20548113412d32fffdcece2f68a026e696e67726573735f6578706972791b000000000000000070696e67726573735f6578706972696573811b1832d4ce93deb200',
 };
 
-export const transactionHash = '87f2e7ca80961bdc3a1fe761553a8a7f8ac5bf28b71f4e1fba807cf352a27f52';
-
 export const payloadsDataWithoutMemo = {
   payloads: [
     {

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

@@ -92,8 +92,6 @@ 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);