Merge pull request #5784 from BitGo/WIN-4880

feat(sdk-coin-icp): implement signing functionality and improve transaction validation

Author: mohd-kashif

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

@@ -4,7 +4,6 @@ import {
   TransactionRecipient,
   TransactionType,
   InvalidTransactionError,
-  MethodNotImplementedError,
   TransactionType as BitGoTransactionType,
 } from '@bitgo/sdk-core';
 import { BaseCoin as CoinConfig } from '@bitgo/statics';
@@ -200,11 +199,6 @@ export class Transaction extends BaseTransaction {
     return JSON.stringify(transaction);
   }
 
-  /** @inheritdoc */
-  canSign(key: BaseKey): boolean {
-    throw new MethodNotImplementedError();
-  }
-
   async parseUnsignedTransaction(rawTransaction: string): Promise<ParsedTransaction> {
     const unsignedTransaction = this._utils.cborDecode(
       this._utils.blobFromHex(rawTransaction)
@@ -284,4 +278,9 @@ export class Transaction extends BaseTransaction {
     const httpCanisterUpdate = updates[0].content as HttpCanisterUpdate;
     return await this.getParsedTransactionFromUpdate(httpCanisterUpdate, true);
   }
+
+  /** @inheritdoc */
+  canSign(key: BaseKey): boolean {
+    return true;
+  }
 }

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

@@ -1,12 +1,6 @@
 import { BaseCoin as CoinConfig } from '@bitgo/statics';
 import BigNumber from 'bignumber.js';
-import {
-  BaseTransactionBuilder,
-  BuildTransactionError,
-  BaseAddress,
-  MethodNotImplementedError,
-  BaseKey,
-} from '@bitgo/sdk-core';
+import { BaseTransactionBuilder, BuildTransactionError, BaseAddress, SigningError, BaseKey } from '@bitgo/sdk-core';
 import { Transaction } from './transaction';
 import utils from './utils';
 import { IcpTransactionData } from './iface';
@@ -24,10 +18,6 @@ export abstract class TransactionBuilder extends BaseTransactionBuilder {
     this._transaction = new Transaction(_coinConfig, utils);
   }
 
-  validateKey(key: BaseKey): void {
-    throw new MethodNotImplementedError();
-  }
-
   /**
    * Sets the public key and the address of the sender of this transaction.
    *
@@ -144,4 +134,14 @@ export abstract class TransactionBuilder extends BaseTransactionBuilder {
   validateRawTransaction(rawTransaction: IcpTransactionData): void {
     utils.validateRawTransaction(rawTransaction);
   }
+
+  /** @inheritdoc */
+  validateKey(key: BaseKey): void {
+    if (!key || !key.key) {
+      throw new SigningError('Key is required');
+    }
+    if (!utils.isValidPrivateKey(key.key)) {
+      throw new SigningError('Invalid private key');
+    }
+  }
 }

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

@@ -1,6 +1,6 @@
 import { BaseCoin as CoinConfig } from '@bitgo/statics';
 import { TransactionBuilder } from './transactionBuilder';
-import { BaseTransaction, BuildTransactionError, MethodNotImplementedError } from '@bitgo/sdk-core';
+import { BaseTransaction, BuildTransactionError, BaseKey } from '@bitgo/sdk-core';
 import { Utils } from './utils';
 import { Transaction } from './transaction';
 import { UnsignedTransactionBuilder } from './unsignedTransactionBuilder';
@@ -123,7 +123,9 @@ export class TransferBuilder extends TransactionBuilder {
   }
 
   /** @inheritdoc */
-  protected signImplementation(): BaseTransaction {
-    throw new MethodNotImplementedError();
+  protected signImplementation(key: BaseKey): BaseTransaction {
+    const signatures = this._utils.getSignatures(this._transaction.payloadsData, this._publicKey, key.key);
+    this._transaction.addSignature(signatures);
+    return this._transaction;
   }
 }

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

@@ -18,6 +18,8 @@ import {
   Signatures,
   IcpMetadata,
   SendArgs,
+  PayloadsData,
+  CurveType,
 } 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.
@@ -676,6 +678,27 @@ export class Utils implements BaseUtils {
   isValidTransactionId(txId: string): boolean {
     return this.isValidHash(txId);
   }
+
+  getSignatures(payloadsData: PayloadsData, senderPublicKey: string, senderPrivateKey: string): Signatures[] {
+    return payloadsData.payloads.map((payload) => ({
+      signing_payload: payload,
+      signature_type: payload.signature_type,
+      public_key: {
+        hex_bytes: senderPublicKey,
+        curve_type: CurveType.SECP256K1,
+      },
+      hex_bytes: this.signPayload(senderPrivateKey, payload.hex_bytes),
+    }));
+  }
+
+  signPayload = (privateKey: string, payloadHex: string): string => {
+    const privateKeyBytes = Buffer.from(privateKey, 'hex');
+    const payloadHash = crypto.createHash('sha256').update(Buffer.from(payloadHex, 'hex')).digest('hex');
+    const signature = secp256k1.sign(payloadHash, privateKeyBytes);
+    const r = Buffer.from(signature.r.toString(16).padStart(64, '0'), 'hex');
+    const s = Buffer.from(signature.s.toString(16).padStart(64, '0'), 'hex');
+    return Buffer.concat([r, s]).toString('hex');
+  };
 }
 
 const utils = new Utils();

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

@@ -1,5 +1,6 @@
 import should from 'should';
 import { getBuilderFactory } from '../getBuilderFactory';
+import { BaseKey } from '@bitgo/sdk-core';
 import * as testData from '../../resources/icp';
 import sinon from 'sinon';
 
@@ -85,4 +86,19 @@ describe('ICP Transaction Builder', async () => {
     should.equal(broadcastTxnObj.signed_transaction, signedTxn);
     should.equal(broadcastTxnObj.network_identifier.network, '00000000000000020101');
   });
+
+  it('should sign a txn and then give txn in broadcast format', async () => {
+    const baseKey: BaseKey = { key: testData.accounts.account1.secretKey };
+    txBuilder.sign(baseKey);
+    should.deepEqual(txn.signaturePayload, testData.signatures);
+    txBuilder.combine();
+    const signedTxn = txBuilder.transaction.signedTransaction;
+    signedTxn.should.be.a.String();
+    should.equal(signedTxn, testData.signedTransaction);
+    const broadcastTxn = txBuilder.transaction.toBroadcastFormat();
+    broadcastTxn.should.be.a.String();
+    const broadcastTxnObj = JSON.parse(broadcastTxn);
+    should.equal(broadcastTxnObj.signed_transaction, signedTxn);
+    should.equal(broadcastTxnObj.network_identifier.network, '00000000000000020101');
+  });
 });