@bitgo/sdk-coin-icp 1.11.0 → 1.13.0

package/dist/src/icp.d.ts

@@ -1,5 +1,8 @@
-import { BaseCoin, BitGoBase, MPCAlgorithm, VerifyTransactionOptions, TssVerifyAddressOptions, ParseTransactionOptions, ParsedTransaction, KeyPair, SignTransactionOptions, SignedTransaction, MultisigType } from '@bitgo/sdk-core';
+import { BaseBroadcastTransactionOptions, BaseBroadcastTransactionResult, BaseCoin, BitGoBase, KeyPair, MPCAlgorithm, MultisigType, ParsedTransaction, ParseTransactionOptions, SignedTransaction, SignTransactionOptions, TssVerifyAddressOptions, VerifyTransactionOptions } from '@bitgo/sdk-core';
 import { BaseCoin as StaticsBaseCoin } from '@bitgo/statics';
+import { Hash } from 'crypto';
+import * as request from 'superagent';
+import { PayloadsData, RecoveryOptions, Signatures, IcpTransactionExplanation } from './lib/iface';
 /**
  * Class representing the Internet Computer (ICP) coin.
  * Extends the BaseCoin class and provides specific implementations for ICP.
@@ -16,6 +19,9 @@ export declare class Icp extends BaseCoin {
     getFamily(): string;
     getFullName(): string;
     getBaseFactor(): number;
+    explainTransaction(params: {
+        txHex: string;
+    }): Promise<IcpTransactionExplanation>;
     verifyTransaction(params: VerifyTransactionOptions): Promise<boolean>;
     isWalletAddress(params: TssVerifyAddressOptions): Promise<boolean>;
     parseTransaction(params: ParseTransactionOptions): Promise<ParsedTransaction>;
@@ -25,7 +31,12 @@ export declare class Icp extends BaseCoin {
      */
     generateKeyPair(seed?: Buffer): KeyPair;
     isValidAddress(address: string): boolean;
-    signTransaction(_: SignTransactionOptions): Promise<SignedTransaction>;
+    signTransaction(params: SignTransactionOptions & {
+        txPrebuild: {
+            txHex: string;
+        };
+        prv: string;
+    }): Promise<SignedTransaction>;
     isValidPub(key: string): boolean;
     isValidPrv(key: string): boolean;
     /** @inheritDoc */
@@ -34,8 +45,48 @@ export declare class Icp extends BaseCoin {
     getDefaultMultisigType(): MultisigType;
     /** @inheritDoc */
     getMPCAlgorithm(): MPCAlgorithm;
+    /** @inheritDoc **/
+    getHashFunction(): Hash;
     private getAddressFromPublicKey;
     /** @inheritDoc **/
     protected getPublicNodeUrl(): string;
+    protected getRosettaNodeUrl(): string;
+    /**
+     * Sends a POST request to the Rosetta node with the specified payload and endpoint.
+     *
+     * @param payload - A JSON string representing the request payload to be sent to the Rosetta node.
+     * @param endpoint - The endpoint path to append to the Rosetta node URL.
+     * @returns A promise that resolves to the HTTP response from the Rosetta node.
+     * @throws An error if the HTTP request fails or if the response status is not 200.
+     */
+    protected getRosettaNodeResponse(payload: string, endpoint: string): Promise<request.Response>;
+    broadcastTransaction(payload: BaseBroadcastTransactionOptions): Promise<BaseBroadcastTransactionResult>;
+    private getPublicNodeBroadcastEndpoint;
+    private extractTransactionId;
+    /**
+     * Helper to fetch account balance
+     * @param senderAddress - The address of the account to fetch the balance for
+     * @returns The balance of the account as a string
+     * @throws If the account is not found or there is an error fetching the balance
+     */
+    protected getAccountBalance(address: string): Promise<string>;
+    private getBuilderFactory;
+    /**
+     * Generates an array of signatures for the provided payloads using MPC
+     *
+     * @param payloadsData - The data containing the payloads to be signed.
+     * @param senderPublicKey - The public key of the sender in hexadecimal format.
+     * @param userKeyShare - The user's key share as a Buffer.
+     * @param backupKeyShare - The backup key share as a Buffer.
+     * @param commonKeyChain - The common key chain identifier used for MPC signing.
+     * @returns A promise that resolves to an array of `Signatures` objects, each containing the signing payload,
+     *          signature type, public key, and the generated signature in hexadecimal format.
+     */
+    signatures(payloadsData: PayloadsData, senderPublicKey: string, userKeyShare: Buffer<ArrayBufferLike>, backupKeyShare: Buffer<ArrayBufferLike>, commonKeyChain: string): Promise<Signatures[]>;
+    /**
+     * Builds a funds recovery transaction without BitGo
+     * @param params
+     */
+    recover(params: RecoveryOptions): Promise<string>;
 }
 //# sourceMappingURL=icp.d.ts.map

package/dist/src/icp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"icp.d.ts","sourceRoot":"","sources":["../../src/icp.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,SAAS,EACT,YAAY,EAEZ,wBAAwB,EACxB,uBAAuB,EACvB,uBAAuB,EACvB,iBAAiB,EACjB,OAAO,EACP,sBAAsB,EACtB,iBAAiB,EAEjB,YAAY,EAEb,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,QAAQ,IAAI,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAG7D;;;;;;GAMG;AACH,qBAAa,GAAI,SAAQ,QAAQ;IAC/B,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,QAAQ,CAAC,eAAe,CAAC,CAAC;IAC3D,SAAS,aAAa,KAAK,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,QAAQ,CAAC,eAAe,CAAC;IAU/E,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,QAAQ,CAAC,eAAe,CAAC,GAAG,QAAQ;IAI1F,QAAQ,IAAI,MAAM;IAIlB,YAAY,IAAI,MAAM;IAItB,SAAS,IAAI,MAAM;IAInB,WAAW,IAAI,MAAM;IAIrB,aAAa,IAAI,MAAM;IAIjB,iBAAiB,CAAC,MAAM,EAAE,wBAAwB,GAAG,OAAO,CAAC,OAAO,CAAC;IAIrE,eAAe,CAAC,MAAM,EAAE,uBAAuB,GAAG,OAAO,CAAC,OAAO,CAAC;IAIlE,gBAAgB,CAAC,MAAM,EAAE,uBAAuB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAInF;;;OAGG;IACI,eAAe,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO;IAI9C,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAIxC,eAAe,CAAC,CAAC,EAAE,sBAAsB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAItE,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIhC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIhC,kBAAkB;IAClB,WAAW,IAAI,OAAO;IAItB,oBAAoB;IACpB,sBAAsB,IAAI,YAAY;IAItC,kBAAkB;IAClB,eAAe,IAAI,YAAY;YAIjB,uBAAuB;IAIrC,mBAAmB;IACnB,SAAS,CAAC,gBAAgB,IAAI,MAAM;CAGrC"}
+{"version":3,"file":"icp.d.ts","sourceRoot":"","sources":["../../src/icp.ts"],"names":[],"mappings":"AACA,OAAO,EACL,+BAA+B,EAC/B,8BAA8B,EAC9B,QAAQ,EACR,SAAS,EAIT,OAAO,EACP,YAAY,EACZ,YAAY,EAEZ,iBAAiB,EACjB,uBAAuB,EACvB,iBAAiB,EAEjB,sBAAsB,EACtB,uBAAuB,EACvB,wBAAwB,EACzB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAS,QAAQ,IAAI,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAIpE,OAAO,EAAc,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC1C,OAAO,KAAK,OAAO,MAAM,YAAY,CAAC;AACtC,OAAO,EAKL,YAAY,EAGZ,eAAe,EAEf,UAAU,EAEV,yBAAyB,EAC1B,MAAM,aAAa,CAAC;AAIrB;;;;;;GAMG;AACH,qBAAa,GAAI,SAAQ,QAAQ;IAC/B,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,QAAQ,CAAC,eAAe,CAAC,CAAC;IAC3D,SAAS,aAAa,KAAK,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,QAAQ,CAAC,eAAe,CAAC;IAU/E,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,QAAQ,CAAC,eAAe,CAAC,GAAG,QAAQ;IAI1F,QAAQ,IAAI,MAAM;IAIlB,YAAY,IAAI,MAAM;IAItB,SAAS,IAAI,MAAM;IAInB,WAAW,IAAI,MAAM;IAIrB,aAAa,IAAI,MAAM;IAIjB,kBAAkB,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,yBAAyB,CAAC;IAOjF,iBAAiB,CAAC,MAAM,EAAE,wBAAwB,GAAG,OAAO,CAAC,OAAO,CAAC;IA6BrE,eAAe,CAAC,MAAM,EAAE,uBAAuB,GAAG,OAAO,CAAC,OAAO,CAAC;IAIlE,gBAAgB,CAAC,MAAM,EAAE,uBAAuB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAInF;;;OAGG;IACI,eAAe,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO;IAI9C,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAIlC,eAAe,CACnB,MAAM,EAAE,sBAAsB,GAAG;QAAE,UAAU,EAAE;YAAE,KAAK,EAAE,MAAM,CAAA;SAAE,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,GAC9E,OAAO,CAAC,iBAAiB,CAAC;IAmB7B,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIhC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIhC,kBAAkB;IAClB,WAAW,IAAI,OAAO;IAItB,oBAAoB;IACpB,sBAAsB,IAAI,YAAY;IAItC,kBAAkB;IAClB,eAAe,IAAI,YAAY;IAI/B,mBAAmB;IACnB,eAAe,IAAI,IAAI;YAIT,uBAAuB;IAIrC,mBAAmB;IACnB,SAAS,CAAC,gBAAgB,IAAI,MAAM;IAIpC,SAAS,CAAC,iBAAiB,IAAI,MAAM;IAIrC;;;;;;;OAOG;cACa,sBAAsB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC;IAwBvF,oBAAoB,CAAC,OAAO,EAAE,+BAA+B,GAAG,OAAO,CAAC,8BAA8B,CAAC;IA4BpH,OAAO,CAAC,8BAA8B;IAStC,OAAO,CAAC,oBAAoB;IAI5B;;;;;OAKG;cACa,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAoBnE,OAAO,CAAC,iBAAiB;IAIzB;;;;;;;;;;OAUG;IACG,UAAU,CACd,YAAY,EAAE,YAAY,EAC1B,eAAe,EAAE,MAAM,EACvB,YAAY,EAAE,MAAM,CAAC,eAAe,CAAC,EACrC,cAAc,EAAE,MAAM,CAAC,eAAe,CAAC,EACvC,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,UAAU,EAAE,CAAC;IAsBxB;;;OAGG;IACG,OAAO,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC;CAwExD"}

package/dist/src/icp.js

@@ -1,10 +1,52 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Icp = void 0;
+const assert_1 = __importDefault(require("assert"));
 const sdk_core_1 = require("@bitgo/sdk-core");
+const statics_1 = require("@bitgo/statics");
+const principal_1 = require("@dfinity/principal");
+const axios_1 = __importDefault(require("axios"));
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const crypto_1 = require("crypto");
+const request = __importStar(require("superagent"));
+const iface_1 = require("./lib/iface");
+const transactionBuilderFactory_1 = require("./lib/transactionBuilderFactory");
 const utils_1 = __importDefault(require("./lib/utils"));
 /**
  * Class representing the Internet Computer (ICP) coin.
@@ -39,14 +81,38 @@ class Icp extends sdk_core_1.BaseCoin {
     getBaseFactor() {
         return Math.pow(10, this._staticsCoin.decimalPlaces);
     }
+    async explainTransaction(params) {
+        const factory = this.getBuilderFactory();
+        const txBuilder = await factory.from(params.txHex);
+        const transaction = await txBuilder.build();
+        return transaction.explainTransaction();
+    }
     async verifyTransaction(params) {
-        throw new sdk_core_1.MethodNotImplementedError();
+        const { txParams, txPrebuild } = params;
+        const txHex = txPrebuild?.txHex;
+        if (!txHex) {
+            throw new Error('txHex is required');
+        }
+        const explainedTx = await this.explainTransaction({ txHex });
+        if (Array.isArray(txParams.recipients) && txParams.recipients.length > 0) {
+            if (txParams.recipients.length > 1) {
+                throw new Error(`${this.getChain()} doesn't support sending to more than 1 destination address within a single transaction. Try again, using only a single recipient.`);
+            }
+            (0, assert_1.default)(explainedTx.outputs.length === 1, 'Tx outputs does not match with expected txParams recipients');
+            const output = explainedTx.outputs[0];
+            const recipient = txParams.recipients[0];
+            (0, assert_1.default)(typeof recipient.address === 'string' &&
+                typeof output.address === 'string' &&
+                output.address === recipient.address &&
+                (0, bignumber_js_1.default)(output.amount).eq((0, bignumber_js_1.default)(recipient.amount)), 'Tx outputs does not match with expected txParams recipients');
+        }
+        return true;
     }
     async isWalletAddress(params) {
-        throw new sdk_core_1.MethodNotImplementedError();
+        return this.isValidAddress(params.address);
     }
     async parseTransaction(params) {
-        throw new sdk_core_1.MethodNotImplementedError();
+        return {};
     }
     /**
      * Generate a new keypair for this coin.
@@ -58,8 +124,23 @@ class Icp extends sdk_core_1.BaseCoin {
     isValidAddress(address) {
         return utils_1.default.isValidAddress(address);
     }
-    signTransaction(_) {
-        throw new sdk_core_1.MethodNotImplementedError();
+    async signTransaction(params) {
+        const txHex = params?.txPrebuild?.txHex;
+        const privateKey = params?.prv;
+        if (!txHex) {
+            throw new sdk_core_1.SigningError('missing required txPrebuild parameter: params.txPrebuild.txHex');
+        }
+        if (!privateKey) {
+            throw new sdk_core_1.SigningError('missing required prv parameter: params.prv');
+        }
+        const factory = this.getBuilderFactory();
+        const txBuilder = await factory.from(params.txPrebuild.txHex);
+        txBuilder.sign({ key: params.prv });
+        txBuilder.combine();
+        const serializedTx = txBuilder.transaction.toBroadcastFormat();
+        return {
+            txHex: serializedTx,
+        };
     }
     isValidPub(key) {
         return utils_1.default.isValidPublicKey(key);
@@ -79,13 +160,205 @@ class Icp extends sdk_core_1.BaseCoin {
     getMPCAlgorithm() {
         return 'ecdsa';
     }
+    /** @inheritDoc **/
+    getHashFunction() {
+        return (0, crypto_1.createHash)('sha256');
+    }
     async getAddressFromPublicKey(hexEncodedPublicKey) {
         return utils_1.default.getAddressFromPublicKey(hexEncodedPublicKey);
     }
     /** @inheritDoc **/
     getPublicNodeUrl() {
-        return sdk_core_1.Environments[this.bitgo.getEnv()].rosettaNodeURL;
+        return sdk_core_1.Environments[this.bitgo.getEnv()].icpNodeUrl;
+    }
+    getRosettaNodeUrl() {
+        return sdk_core_1.Environments[this.bitgo.getEnv()].icpRosettaNodeUrl;
+    }
+    /**
+     * Sends a POST request to the Rosetta node with the specified payload and endpoint.
+     *
+     * @param payload - A JSON string representing the request payload to be sent to the Rosetta node.
+     * @param endpoint - The endpoint path to append to the Rosetta node URL.
+     * @returns A promise that resolves to the HTTP response from the Rosetta node.
+     * @throws An error if the HTTP request fails or if the response status is not 200.
+     */
+    async getRosettaNodeResponse(payload, endpoint) {
+        const nodeUrl = this.getRosettaNodeUrl();
+        const fullEndpoint = `${nodeUrl}${endpoint}`;
+        const body = {
+            network_identifier: {
+                blockchain: this.getFullName(),
+                network: iface_1.Network.ID,
+            },
+            ...JSON.parse(payload),
+        };
+        try {
+            const response = await request.post(fullEndpoint).set('Content-Type', 'application/json').send(body);
+            if (response.status !== 200) {
+                throw new Error(`Call to Rosetta node failed, got HTTP Status: ${response.status} with body: ${response.body}`);
+            }
+            return response;
+        }
+        catch (error) {
+            throw new Error(`Unable to call rosetta node: ${error.message || error}`);
+        }
+    }
+    /* inheritDoc */
+    // this method calls the public node to broadcast the transaction and not the rosetta node
+    async broadcastTransaction(payload) {
+        const endpoint = this.getPublicNodeBroadcastEndpoint();
+        try {
+            const response = await axios_1.default.post(endpoint, payload.serializedSignedTransaction, {
+                responseType: 'arraybuffer', // This ensures you get a Buffer, not a string
+                headers: {
+                    'Content-Type': 'application/cbor',
+                },
+            });
+            if (response.status !== 200) {
+                throw new Error(`Transaction broadcast failed with status: ${response.status} - ${response.statusText}`);
+            }
+            const decodedResponse = utils_1.default.cborDecode(response.data);
+            if (decodedResponse.status === 'replied') {
+                const txnId = this.extractTransactionId(decodedResponse);
+                return { txId: txnId };
+            }
+            else {
+                throw new Error(`Unexpected response status from node: ${decodedResponse.status}`);
+            }
+        }
+        catch (error) {
+            throw new Error(`Transaction broadcast error: ${error?.message || JSON.stringify(error)}`);
+        }
+    }
+    getPublicNodeBroadcastEndpoint() {
+        const nodeUrl = this.getPublicNodeUrl();
+        const principal = principal_1.Principal.fromUint8Array(iface_1.LEDGER_CANISTER_ID);
+        const canisterIdHex = principal.toText();
+        const endpoint = `${nodeUrl}${iface_1.PUBLIC_NODE_REQUEST_ENDPOINT}${canisterIdHex}/call`;
+        return endpoint;
+    }
+    // TODO: Implement the real logic to extract the transaction ID, Ticket: https://bitgoinc.atlassian.net/browse/WIN-5075
+    extractTransactionId(decodedResponse) {
+        return '4c10cf22a768a20e7eebc86e49c031d0e22895a39c6355b5f7455b2acad59c1e';
+    }
+    /**
+     * Helper to fetch account balance
+     * @param senderAddress - The address of the account to fetch the balance for
+     * @returns The balance of the account as a string
+     * @throws If the account is not found or there is an error fetching the balance
+     */
+    async getAccountBalance(address) {
+        try {
+            const payload = {
+                account_identifier: {
+                    address: address,
+                },
+            };
+            const response = await this.getRosettaNodeResponse(JSON.stringify(payload), iface_1.ACCOUNT_BALANCE_ENDPOINT);
+            const coinName = this._staticsCoin.name.toUpperCase();
+            const balanceEntry = response.body.balances.find((b) => b.currency?.symbol === coinName);
+            if (!balanceEntry) {
+                throw new Error(`No balance found for ICP account ${address}.`);
+            }
+            const balance = balanceEntry.value;
+            return balance;
+        }
+        catch (error) {
+            throw new Error(`Unable to fetch account balance: ${error.message || error}`);
+        }
+    }
+    getBuilderFactory() {
+        return new transactionBuilderFactory_1.TransactionBuilderFactory(statics_1.coins.get(this.getBaseChain()));
+    }
+    /**
+     * Generates an array of signatures for the provided payloads using MPC
+     *
+     * @param payloadsData - The data containing the payloads to be signed.
+     * @param senderPublicKey - The public key of the sender in hexadecimal format.
+     * @param userKeyShare - The user's key share as a Buffer.
+     * @param backupKeyShare - The backup key share as a Buffer.
+     * @param commonKeyChain - The common key chain identifier used for MPC signing.
+     * @returns A promise that resolves to an array of `Signatures` objects, each containing the signing payload,
+     *          signature type, public key, and the generated signature in hexadecimal format.
+     */
+    async signatures(payloadsData, senderPublicKey, userKeyShare, backupKeyShare, commonKeyChain) {
+        try {
+            const payload = payloadsData.payloads[0];
+            const message = Buffer.from(payload.hex_bytes, 'hex');
+            const messageHash = (0, crypto_1.createHash)('sha256').update(message).digest();
+            const signature = await sdk_core_1.ECDSAUtils.signRecoveryMpcV2(messageHash, userKeyShare, backupKeyShare, commonKeyChain);
+            const signaturePayload = {
+                signing_payload: payload,
+                signature_type: payload.signature_type,
+                public_key: {
+                    hex_bytes: senderPublicKey,
+                    curve_type: iface_1.CurveType.SECP256K1,
+                },
+                hex_bytes: signature.r + signature.s,
+            };
+            return [signaturePayload];
+        }
+        catch (error) {
+            throw new Error(`Error generating signatures: ${error.message || error}`);
+        }
+    }
+    /**
+     * Builds a funds recovery transaction without BitGo
+     * @param params
+     */
+    async recover(params) {
+        if (!params.recoveryDestination || !this.isValidAddress(params.recoveryDestination)) {
+            throw new Error('invalid recoveryDestination');
+        }
+        if (!params.userKey) {
+            throw new Error('missing userKey');
+        }
+        if (!params.backupKey) {
+            throw new Error('missing backupKey');
+        }
+        if (!params.walletPassphrase) {
+            throw new Error('missing wallet passphrase');
+        }
+        const userKey = params.userKey.replace(/\s/g, '');
+        const backupKey = params.backupKey.replace(/\s/g, '');
+        const { userKeyShare, backupKeyShare, commonKeyChain } = await sdk_core_1.ECDSAUtils.getMpcV2RecoveryKeyShares(userKey, backupKey, params.walletPassphrase);
+        const MPC = new sdk_core_1.Ecdsa();
+        const publicKey = MPC.deriveUnhardened(commonKeyChain, iface_1.ROOT_PATH).slice(0, 66);
+        if (!publicKey || !backupKeyShare) {
+            throw new Error('Missing publicKey or backupKeyShare');
+        }
+        const senderAddress = await this.getAddressFromPublicKey(publicKey);
+        const balance = new bignumber_js_1.default(await this.getAccountBalance(senderAddress));
+        const feeData = new bignumber_js_1.default(utils_1.default.feeData());
+        const actualBalance = balance.plus(feeData); // gas amount returned from gasData is negative so we add it
+        if (actualBalance.isLessThanOrEqualTo(0)) {
+            throw new Error('Did not have enough funds to recover');
+        }
+        const factory = this.getBuilderFactory();
+        const txBuilder = factory.getTransferBuilder();
+        txBuilder.sender(senderAddress, publicKey);
+        txBuilder.receiverId(params.recoveryDestination);
+        txBuilder.amount(actualBalance.toString());
+        if (params.memo !== undefined && utils_1.default.validateMemo(params.memo)) {
+            txBuilder.memo(Number(params.memo));
+        }
+        await txBuilder.build();
+        if (txBuilder.transaction.payloadsData.payloads.length === 0) {
+            throw new Error('Missing payloads to generate signatures');
+        }
+        const signatures = await this.signatures(txBuilder.transaction.payloadsData, publicKey, userKeyShare, backupKeyShare, commonKeyChain);
+        if (!signatures || signatures.length === 0) {
+            throw new Error('Failed to generate signatures');
+        }
+        txBuilder.transaction.addSignature(signatures);
+        txBuilder.combine();
+        const broadcastableTxn = txBuilder.transaction.toBroadcastFormat();
+        const result = await this.broadcastTransaction({ serializedSignedTransaction: broadcastableTxn });
+        if (!result.txId) {
+            throw new Error('Transaction failed to broadcast');
+        }
+        return result.txId;
     }
 }
 exports.Icp = Icp;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"icp.js","sourceRoot":"","sources":["../../src/icp.ts"],"names":[],"mappings":"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","sourcesContent":["import assert from 'assert';\nimport {\n  BaseBroadcastTransactionOptions,\n  BaseBroadcastTransactionResult,\n  BaseCoin,\n  BitGoBase,\n  Ecdsa,\n  ECDSAUtils,\n  Environments,\n  KeyPair,\n  MPCAlgorithm,\n  MultisigType,\n  multisigTypes,\n  ParsedTransaction,\n  ParseTransactionOptions,\n  SignedTransaction,\n  SigningError,\n  SignTransactionOptions,\n  TssVerifyAddressOptions,\n  VerifyTransactionOptions,\n} from '@bitgo/sdk-core';\nimport { coins, BaseCoin as StaticsBaseCoin } from '@bitgo/statics';\nimport { Principal } from '@dfinity/principal';\nimport axios from 'axios';\nimport BigNumber from 'bignumber.js';\nimport { createHash, Hash } from 'crypto';\nimport * as request from 'superagent';\nimport {\n  ACCOUNT_BALANCE_ENDPOINT,\n  CurveType,\n  LEDGER_CANISTER_ID,\n  Network,\n  PayloadsData,\n  PUBLIC_NODE_REQUEST_ENDPOINT,\n  PublicNodeSubmitResponse,\n  RecoveryOptions,\n  ROOT_PATH,\n  Signatures,\n  SigningPayload,\n  IcpTransactionExplanation,\n} from './lib/iface';\nimport { TransactionBuilderFactory } from './lib/transactionBuilderFactory';\nimport utils from './lib/utils';\n\n/**\n * Class representing the Internet Computer (ICP) coin.\n * Extends the BaseCoin class and provides specific implementations for ICP.\n *\n * @see {@link https://internetcomputer.org/}\n * @see {@link https://internetcomputer.org/docs/current/developer-docs/defi/rosetta/icp_rosetta/data_api/}\n */\nexport class Icp extends BaseCoin {\n  protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;\n  protected constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>) {\n    super(bitgo);\n\n    if (!staticsCoin) {\n      throw new Error('missing required constructor parameter staticsCoin');\n    }\n\n    this._staticsCoin = staticsCoin;\n  }\n\n  static createInstance(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>): BaseCoin {\n    return new Icp(bitgo, staticsCoin);\n  }\n\n  getChain(): string {\n    return 'icp';\n  }\n\n  getBaseChain(): string {\n    return 'icp';\n  }\n\n  getFamily(): string {\n    return this._staticsCoin.family;\n  }\n\n  getFullName(): string {\n    return 'Internet Computer';\n  }\n\n  getBaseFactor(): number {\n    return Math.pow(10, this._staticsCoin.decimalPlaces);\n  }\n\n  async explainTransaction(params: { txHex: string }): Promise<IcpTransactionExplanation> {\n    const factory = this.getBuilderFactory();\n    const txBuilder = await factory.from(params.txHex);\n    const transaction = await txBuilder.build();\n    return transaction.explainTransaction();\n  }\n\n  async verifyTransaction(params: VerifyTransactionOptions): Promise<boolean> {\n    const { txParams, txPrebuild } = params;\n    const txHex = txPrebuild?.txHex;\n    if (!txHex) {\n      throw new Error('txHex is required');\n    }\n    const explainedTx = await this.explainTransaction({ txHex });\n\n    if (Array.isArray(txParams.recipients) && txParams.recipients.length > 0) {\n      if (txParams.recipients.length > 1) {\n        throw new Error(\n          `${this.getChain()} doesn't support sending to more than 1 destination address within a single transaction. Try again, using only a single recipient.`\n        );\n      }\n      assert(explainedTx.outputs.length === 1, 'Tx outputs does not match with expected txParams recipients');\n\n      const output = explainedTx.outputs[0];\n      const recipient = txParams.recipients[0];\n      assert(\n        typeof recipient.address === 'string' &&\n          typeof output.address === 'string' &&\n          output.address === recipient.address &&\n          BigNumber(output.amount).eq(BigNumber(recipient.amount)),\n        'Tx outputs does not match with expected txParams recipients'\n      );\n    }\n    return true;\n  }\n\n  async isWalletAddress(params: TssVerifyAddressOptions): Promise<boolean> {\n    return this.isValidAddress(params.address);\n  }\n\n  async parseTransaction(params: ParseTransactionOptions): Promise<ParsedTransaction> {\n    return {};\n  }\n\n  /**\n   * Generate a new keypair for this coin.\n   * @param seed Seed from which the new keypair should be generated, otherwise a random seed is used\n   */\n  public generateKeyPair(seed?: Buffer): KeyPair {\n    return utils.generateKeyPair(seed);\n  }\n\n  isValidAddress(address: string): boolean {\n    return utils.isValidAddress(address);\n  }\n\n  async signTransaction(\n    params: SignTransactionOptions & { txPrebuild: { txHex: string }; prv: string }\n  ): Promise<SignedTransaction> {\n    const txHex = params?.txPrebuild?.txHex;\n    const privateKey = params?.prv;\n    if (!txHex) {\n      throw new SigningError('missing required txPrebuild parameter: params.txPrebuild.txHex');\n    }\n    if (!privateKey) {\n      throw new SigningError('missing required prv parameter: params.prv');\n    }\n    const factory = this.getBuilderFactory();\n    const txBuilder = await factory.from(params.txPrebuild.txHex);\n    txBuilder.sign({ key: params.prv });\n    txBuilder.combine();\n    const serializedTx = txBuilder.transaction.toBroadcastFormat();\n    return {\n      txHex: serializedTx,\n    };\n  }\n\n  isValidPub(key: string): boolean {\n    return utils.isValidPublicKey(key);\n  }\n\n  isValidPrv(key: string): boolean {\n    return utils.isValidPrivateKey(key);\n  }\n\n  /** @inheritDoc */\n  supportsTss(): boolean {\n    return true;\n  }\n\n  /** inherited doc */\n  getDefaultMultisigType(): MultisigType {\n    return multisigTypes.tss;\n  }\n\n  /** @inheritDoc */\n  getMPCAlgorithm(): MPCAlgorithm {\n    return 'ecdsa';\n  }\n\n  /** @inheritDoc **/\n  getHashFunction(): Hash {\n    return createHash('sha256');\n  }\n\n  private async getAddressFromPublicKey(hexEncodedPublicKey: string) {\n    return utils.getAddressFromPublicKey(hexEncodedPublicKey);\n  }\n\n  /** @inheritDoc **/\n  protected getPublicNodeUrl(): string {\n    return Environments[this.bitgo.getEnv()].icpNodeUrl;\n  }\n\n  protected getRosettaNodeUrl(): string {\n    return Environments[this.bitgo.getEnv()].icpRosettaNodeUrl;\n  }\n\n  /**\n   * Sends a POST request to the Rosetta node with the specified payload and endpoint.\n   *\n   * @param payload - A JSON string representing the request payload to be sent to the Rosetta node.\n   * @param endpoint - The endpoint path to append to the Rosetta node URL.\n   * @returns A promise that resolves to the HTTP response from the Rosetta node.\n   * @throws An error if the HTTP request fails or if the response status is not 200.\n   */\n  protected async getRosettaNodeResponse(payload: string, endpoint: string): Promise<request.Response> {\n    const nodeUrl = this.getRosettaNodeUrl();\n    const fullEndpoint = `${nodeUrl}${endpoint}`;\n    const body = {\n      network_identifier: {\n        blockchain: this.getFullName(),\n        network: Network.ID,\n      },\n      ...JSON.parse(payload),\n    };\n\n    try {\n      const response = await request.post(fullEndpoint).set('Content-Type', 'application/json').send(body);\n      if (response.status !== 200) {\n        throw new Error(`Call to Rosetta node failed, got HTTP Status: ${response.status} with body: ${response.body}`);\n      }\n      return response;\n    } catch (error) {\n      throw new Error(`Unable to call rosetta node: ${error.message || error}`);\n    }\n  }\n\n  /* inheritDoc */\n  // this method calls the public node to broadcast the transaction and not the rosetta node\n  public async broadcastTransaction(payload: BaseBroadcastTransactionOptions): Promise<BaseBroadcastTransactionResult> {\n    const endpoint = this.getPublicNodeBroadcastEndpoint();\n\n    try {\n      const response = await axios.post(endpoint, payload.serializedSignedTransaction, {\n        responseType: 'arraybuffer', // This ensures you get a Buffer, not a string\n        headers: {\n          'Content-Type': 'application/cbor',\n        },\n      });\n\n      if (response.status !== 200) {\n        throw new Error(`Transaction broadcast failed with status: ${response.status} - ${response.statusText}`);\n      }\n\n      const decodedResponse = utils.cborDecode(response.data) as PublicNodeSubmitResponse;\n\n      if (decodedResponse.status === 'replied') {\n        const txnId = this.extractTransactionId(decodedResponse);\n        return { txId: txnId };\n      } else {\n        throw new Error(`Unexpected response status from node: ${decodedResponse.status}`);\n      }\n    } catch (error) {\n      throw new Error(`Transaction broadcast error: ${error?.message || JSON.stringify(error)}`);\n    }\n  }\n\n  private getPublicNodeBroadcastEndpoint(): string {\n    const nodeUrl = this.getPublicNodeUrl();\n    const principal = Principal.fromUint8Array(LEDGER_CANISTER_ID);\n    const canisterIdHex = principal.toText();\n    const endpoint = `${nodeUrl}${PUBLIC_NODE_REQUEST_ENDPOINT}${canisterIdHex}/call`;\n    return endpoint;\n  }\n\n  // TODO: Implement the real logic to extract the transaction ID, Ticket: https://bitgoinc.atlassian.net/browse/WIN-5075\n  private extractTransactionId(decodedResponse: PublicNodeSubmitResponse): string {\n    return '4c10cf22a768a20e7eebc86e49c031d0e22895a39c6355b5f7455b2acad59c1e';\n  }\n\n  /**\n   * Helper to fetch account balance\n   * @param senderAddress - The address of the account to fetch the balance for\n   * @returns The balance of the account as a string\n   * @throws If the account is not found or there is an error fetching the balance\n   */\n  protected async getAccountBalance(address: string): Promise<string> {\n    try {\n      const payload = {\n        account_identifier: {\n          address: address,\n        },\n      };\n      const response = await this.getRosettaNodeResponse(JSON.stringify(payload), ACCOUNT_BALANCE_ENDPOINT);\n      const coinName = this._staticsCoin.name.toUpperCase();\n      const balanceEntry = response.body.balances.find((b) => b.currency?.symbol === coinName);\n      if (!balanceEntry) {\n        throw new Error(`No balance found for ICP account ${address}.`);\n      }\n      const balance = balanceEntry.value;\n      return balance;\n    } catch (error) {\n      throw new Error(`Unable to fetch account balance: ${error.message || error}`);\n    }\n  }\n\n  private getBuilderFactory(): TransactionBuilderFactory {\n    return new TransactionBuilderFactory(coins.get(this.getBaseChain()));\n  }\n\n  /**\n   * Generates an array of signatures for the provided payloads using MPC\n   *\n   * @param payloadsData - The data containing the payloads to be signed.\n   * @param senderPublicKey - The public key of the sender in hexadecimal format.\n   * @param userKeyShare - The user's key share as a Buffer.\n   * @param backupKeyShare - The backup key share as a Buffer.\n   * @param commonKeyChain - The common key chain identifier used for MPC signing.\n   * @returns A promise that resolves to an array of `Signatures` objects, each containing the signing payload,\n   *          signature type, public key, and the generated signature in hexadecimal format.\n   */\n  async signatures(\n    payloadsData: PayloadsData,\n    senderPublicKey: string,\n    userKeyShare: Buffer<ArrayBufferLike>,\n    backupKeyShare: Buffer<ArrayBufferLike>,\n    commonKeyChain: string\n  ): Promise<Signatures[]> {\n    try {\n      const payload = payloadsData.payloads[0] as SigningPayload;\n      const message = Buffer.from(payload.hex_bytes, 'hex');\n      const messageHash = createHash('sha256').update(message).digest();\n      const signature = await ECDSAUtils.signRecoveryMpcV2(messageHash, userKeyShare, backupKeyShare, commonKeyChain);\n      const signaturePayload: Signatures = {\n        signing_payload: payload,\n        signature_type: payload.signature_type,\n        public_key: {\n          hex_bytes: senderPublicKey,\n          curve_type: CurveType.SECP256K1,\n        },\n        hex_bytes: signature.r + signature.s,\n      };\n\n      return [signaturePayload];\n    } catch (error) {\n      throw new Error(`Error generating signatures: ${error.message || error}`);\n    }\n  }\n\n  /**\n   * Builds a funds recovery transaction without BitGo\n   * @param params\n   */\n  async recover(params: RecoveryOptions): Promise<string> {\n    if (!params.recoveryDestination || !this.isValidAddress(params.recoveryDestination)) {\n      throw new Error('invalid recoveryDestination');\n    }\n\n    if (!params.userKey) {\n      throw new Error('missing userKey');\n    }\n\n    if (!params.backupKey) {\n      throw new Error('missing backupKey');\n    }\n\n    if (!params.walletPassphrase) {\n      throw new Error('missing wallet passphrase');\n    }\n\n    const userKey = params.userKey.replace(/\\s/g, '');\n    const backupKey = params.backupKey.replace(/\\s/g, '');\n\n    const { userKeyShare, backupKeyShare, commonKeyChain } = await ECDSAUtils.getMpcV2RecoveryKeyShares(\n      userKey,\n      backupKey,\n      params.walletPassphrase\n    );\n    const MPC = new Ecdsa();\n    const publicKey = MPC.deriveUnhardened(commonKeyChain, ROOT_PATH).slice(0, 66);\n\n    if (!publicKey || !backupKeyShare) {\n      throw new Error('Missing publicKey or backupKeyShare');\n    }\n\n    const senderAddress = await this.getAddressFromPublicKey(publicKey);\n\n    const balance = new BigNumber(await this.getAccountBalance(senderAddress));\n    const feeData = new BigNumber(utils.feeData());\n    const actualBalance = balance.plus(feeData); // gas amount returned from gasData is negative so we add it\n    if (actualBalance.isLessThanOrEqualTo(0)) {\n      throw new Error('Did not have enough funds to recover');\n    }\n\n    const factory = this.getBuilderFactory();\n    const txBuilder = factory.getTransferBuilder();\n    txBuilder.sender(senderAddress, publicKey as string);\n    txBuilder.receiverId(params.recoveryDestination);\n    txBuilder.amount(actualBalance.toString());\n    if (params.memo !== undefined && utils.validateMemo(params.memo)) {\n      txBuilder.memo(Number(params.memo));\n    }\n    await txBuilder.build();\n    if (txBuilder.transaction.payloadsData.payloads.length === 0) {\n      throw new Error('Missing payloads to generate signatures');\n    }\n    const signatures = await this.signatures(\n      txBuilder.transaction.payloadsData,\n      publicKey,\n      userKeyShare,\n      backupKeyShare,\n      commonKeyChain\n    );\n    if (!signatures || signatures.length === 0) {\n      throw new Error('Failed to generate signatures');\n    }\n    txBuilder.transaction.addSignature(signatures);\n    txBuilder.combine();\n    const broadcastableTxn = txBuilder.transaction.toBroadcastFormat();\n    const result = await this.broadcastTransaction({ serializedSignedTransaction: broadcastableTxn });\n    if (!result.txId) {\n      throw new Error('Transaction failed to broadcast');\n    }\n    return result.txId;\n  }\n}\n"]}

package/dist/src/lib/iface.d.ts

@@ -2,6 +2,10 @@ import { TransactionExplanation as BaseTransactionExplanation, TransactionType a
 export declare const MAX_INGRESS_TTL: number;
 export declare const PERMITTED_DRIFT: number;
 export declare const LEDGER_CANISTER_ID: Uint8Array<ArrayBuffer>;
+export declare const ROOT_PATH = "m/0";
+export declare const ACCOUNT_BALANCE_ENDPOINT = "/account/balance";
+export declare const PUBLIC_NODE_REQUEST_ENDPOINT = "/api/v3/canister/";
+export declare const DEFAULT_MEMO = 0;
 export declare enum RequestType {
     CALL = "call"
 }
@@ -51,7 +55,7 @@ export interface IcpOperation {
     account: IcpAccount;
     amount: IcpAmount;
 }
-export interface IcpMetadata {
+export interface MetaData {
     created_at_time: number;
     memo: number | BigInt;
     ingress_start?: number | BigInt;
@@ -60,12 +64,12 @@ export interface IcpMetadata {
 export interface IcpTransaction {
     public_keys: IcpPublicKey[];
     operations: IcpOperation[];
-    metadata: IcpMetadata;
+    metadata: MetaData;
 }
 export interface ParsedTransaction {
     operations: IcpOperation[];
     account_identifier_signers: IcpAccount[];
-    metadata: IcpMetadata;
+    metadata: MetaData;
 }
 export interface IcpAccountIdentifier {
     address: string;
@@ -133,7 +137,7 @@ export interface TxData {
     sender: string;
     senderPublicKey: string;
     recipient: string;
-    memo: number | BigInt;
+    memo?: number | BigInt;
     feeAmount: string;
     expirationTime: number | BigInt;
     type?: BitGoTransactionType;
@@ -147,7 +151,21 @@ export interface NetworkIdentifier {
     network: string;
 }
 export interface RawTransaction {
-    serializedTxHex: string;
+    serializedTxHex: PayloadsData;
     publicKey: string;
 }
+export interface RecoveryOptions {
+    userKey: string;
+    backupKey: string;
+    bitgoKey?: string;
+    recoveryDestination: string;
+    walletPassphrase: string;
+    memo?: number | BigInt;
+}
+export interface PublicNodeSubmitResponse {
+    status: string;
+}
+export interface AccountIdentifierHash {
+    hash: Buffer<ArrayBuffer>;
+}
 //# sourceMappingURL=iface.d.ts.map

package/dist/src/lib/iface.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"iface.d.ts","sourceRoot":"","sources":["../../../src/lib/iface.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"iface.d.ts","sourceRoot":"","sources":["../../../src/lib/iface.ts"],"names":[],"mappings":"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"}

package/dist/src/lib/iface.js

@@ -1,9 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Network = exports.MethodName = exports.OperationType = exports.CurveType = exports.SignatureType = exports.RequestType = exports.LEDGER_CANISTER_ID = exports.PERMITTED_DRIFT = exports.MAX_INGRESS_TTL = void 0;
+exports.Network = exports.MethodName = exports.OperationType = exports.CurveType = exports.SignatureType = exports.RequestType = exports.DEFAULT_MEMO = exports.PUBLIC_NODE_REQUEST_ENDPOINT = exports.ACCOUNT_BALANCE_ENDPOINT = exports.ROOT_PATH = exports.LEDGER_CANISTER_ID = exports.PERMITTED_DRIFT = exports.MAX_INGRESS_TTL = void 0;
 exports.MAX_INGRESS_TTL = 5 * 60 * 1000000000; // 5 minutes in nanoseconds
 exports.PERMITTED_DRIFT = 60 * 1000000000; // 60 seconds in nanoseconds
 exports.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"
+exports.ROOT_PATH = 'm/0';
+exports.ACCOUNT_BALANCE_ENDPOINT = '/account/balance';
+exports.PUBLIC_NODE_REQUEST_ENDPOINT = '/api/v3/canister/';
+exports.DEFAULT_MEMO = 0; // default memo value is 0
 var RequestType;
 (function (RequestType) {
     RequestType["CALL"] = "call";
@@ -29,4 +33,4 @@ var Network;
 (function (Network) {
     Network["ID"] = "00000000000000020101";
 })(Network || (exports.Network = Network = {}));
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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