@bitgo-beta/sdk-coin-icp 1.0.1-beta.84 → 1.0.1-beta.840

package/dist/src/lib/transactionBuilder.js

@@ -1,77 +1,164 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransactionBuilder = void 0;
 const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const iface_1 = require("./iface");
+const signedTransactionBuilder_1 = require("./signedTransactionBuilder");
+const transaction_1 = require("./transaction");
+const utils_1 = __importDefault(require("./utils"));
 class TransactionBuilder extends sdk_core_1.BaseTransactionBuilder {
     constructor(_coinConfig) {
         super(_coinConfig);
+        this._transaction = new transaction_1.Transaction(_coinConfig);
     }
-    /** @inheritdoc */
-    signImplementation(key) {
-        throw new Error('method not implemented');
+    signaturePayload() {
+        return this._transaction.signaturePayload;
+    }
+    payloadData() {
+        return this._transaction.payloadsData;
+    }
+    icpTransaction() {
+        return this._transaction.icpTransaction;
     }
     /**
-     * add a signature to the transaction
+     * Sets the public key and the address of the sender of this transaction.
+     *
+     * @param {string} address the account that is sending this transaction
+     * @param {string} pubKey the public key that is sending this transaction
+     * @returns {TransactionBuilder} This transaction builder
      */
-    addSignature(publicKey, signature) {
-        throw new Error('method not implemented');
+    sender(address, pubKey) {
+        if (!address || !utils_1.default.isValidAddress(address.toString())) {
+            throw new sdk_core_1.BuildTransactionError('Invalid or missing address, got: ' + address);
+        }
+        if (!pubKey || !utils_1.default.isValidPublicKey(pubKey)) {
+            throw new sdk_core_1.BuildTransactionError('Invalid or missing pubKey, got: ' + pubKey);
+        }
+        this._sender = address;
+        this._publicKey = pubKey;
+        return this;
     }
     /**
-     * Sets the sender of this transaction.
+     * Set the memo
+     *
+     * @param {number} memo - number that to be used as memo
+     * @returns {TransactionBuilder} This transaction builder
      */
-    sender(senderAddress) {
-        throw new Error('method not implemented');
+    memo(memo) {
+        if (typeof memo !== 'number' || Number.isNaN(memo) || memo < 0) {
+            throw new sdk_core_1.BuildTransactionError(`Invalid memo: ${memo}`);
+        }
+        this._memo = memo;
+        return this;
     }
     /**
-     * gets the gas data of this transaction.
+     * Set the ingressEnd timestamp
+     * @param {number} ingressEnd - timestamp in nanoseconds
+     * @returns {TransactionBuilder} This transaction builder
      */
-    gasData() {
-        throw new Error('method not implemented');
-    }
-    /** @inheritdoc */
-    validateAddress(address, addressFormat) {
-        throw new Error('method not implemented');
+    ingressEnd(ingressEnd) {
+        if (BigInt(ingressEnd.toString()) < 0n) {
+            throw new sdk_core_1.BuildTransactionError(`Invalid timestamp: ${ingressEnd}`);
+        }
+        this._ingressEnd = ingressEnd;
+        return this;
     }
     /**
-     * validates the recipients of the transaction
+     * Sets the account Id of the receiver of this transaction.
+     *
+     * @param {string} accountId the account id of the account that is receiving this transaction
+     * @returns {TransactionBuilder} This transaction builder
      */
-    validateRecipients(recipients) {
-        throw new Error('method not implemented');
+    receiverId(accountId) {
+        if (!accountId || !utils_1.default.isValidAddress(accountId)) {
+            throw new sdk_core_1.BuildTransactionError('Invalid or missing accountId for receiver, got: ' + accountId);
+        }
+        this._receiverId = accountId;
+        return this;
+    }
+    /** @inheritdoc */
+    get transaction() {
+        return this._transaction;
+    }
+    /** @inheritdoc */
+    set transaction(transaction) {
+        this._transaction = transaction;
+    }
+    get transactionType() {
+        return this._transaction.icpTransactionData.transactionType;
+    }
+    /** @inheritdoc */
+    fromImplementation(rawTransaction) {
+        this.transaction.fromRawTransaction(rawTransaction);
+        const icpTransactionData = this.transaction.icpTransactionData;
+        this.validateRawTransaction(icpTransactionData);
+        this.buildImplementation();
+        return this.transaction;
+    }
+    /** @inheritdoc */
+    validateTransaction(transaction) {
+        if (!transaction || !transaction.icpTransactionData) {
+            return;
+        }
+        utils_1.default.validateRawTransaction(transaction.icpTransactionData);
     }
     /**
-     * validates the gas data of the transaction
+     * Sets the amount of this transaction.
+     *
+     * @param {string} value the amount to be sent in e8s (1 ICP = 1e8 e8s)
+     * @returns {TransactionBuilder} This transaction builder
      */
-    validateGasData() {
-        throw new Error('method not implemented');
+    amount(value) {
+        utils_1.default.validateValue(new bignumber_js_1.default(value));
+        this._amount = value;
+        return this;
+    }
+    validateValue(value) {
+        utils_1.default.validateValue(new bignumber_js_1.default(value));
     }
     /**
-     * validates the gas price of the transaction
+     * Initialize the transaction builder fields using the decoded transaction data
+     *
+     * @param {Transaction} tx the transaction data
      */
-    validateGasPrice(gasPrice) {
-        throw new Error('method not implemented');
+    initBuilder(tx) {
+        this._transaction = tx;
+        const icpTransactionData = tx.icpTransactionData;
+        this._sender = icpTransactionData.senderAddress;
+        this._receiverId = icpTransactionData.receiverAddress;
+        this._publicKey = icpTransactionData.senderPublicKeyHex;
+        this._amount = icpTransactionData.amount;
+        this._memo = icpTransactionData.memo ?? iface_1.DEFAULT_MEMO;
+        this._ingressEnd = Number(icpTransactionData.expiryTime);
     }
-    /** @inheritdoc */
-    validateKey(key) {
-        throw new Error('method not implemented');
+    validateAddress(address) {
+        if (!utils_1.default.isValidAddress(address.address)) {
+            throw new sdk_core_1.BuildTransactionError('Invalid address');
+        }
     }
-    /** @inheritdoc */
     validateRawTransaction(rawTransaction) {
-        throw new Error('method not implemented');
+        utils_1.default.validateRawTransaction(rawTransaction);
     }
     /** @inheritdoc */
-    validateValue() {
-        throw new Error('method not implemented');
+    validateKey(key) {
+        if (!key || !key.key) {
+            throw new sdk_core_1.SigningError('Key is required');
+        }
+        if (!utils_1.default.isValidPrivateKey(key.key)) {
+            throw new sdk_core_1.SigningError('Invalid private key');
+        }
     }
     /**
-     * Validates the specific transaction builder internally
+     * Combines the unsigned transaction and the signature payload to create a signed transaction.
      */
-    validateDecodedTransaction() {
-        throw new Error('method not implemented');
-    }
-    /** @inheritdoc */
-    validateTransaction() {
-        throw new Error('method not implemented');
+    combine() {
+        const signedTransactionBuilder = new signedTransactionBuilder_1.SignedTransactionBuilder(this._transaction.unsignedTransaction, this._transaction.signaturePayload);
+        this._transaction.signedTransaction = signedTransactionBuilder.getSignTransaction();
     }
 }
 exports.TransactionBuilder = TransactionBuilder;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transactionBuilder.js","sourceRoot":"","sources":["../../../src/lib/transactionBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseAddress, BaseKey, BaseTransactionBuilder, BuildTransactionError, SigningError } from '@bitgo-beta/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport BigNumber from 'bignumber.js';\nimport { DEFAULT_MEMO, IcpTransaction, IcpTransactionData, PayloadsData, Signatures } from './iface';\nimport { SignedTransactionBuilder } from './signedTransactionBuilder';\nimport { Transaction } from './transaction';\nimport utils from './utils';\n\nexport abstract class TransactionBuilder extends BaseTransactionBuilder {\n  protected _transaction: Transaction;\n  protected _sender: string;\n  protected _publicKey: string;\n  protected _memo: number | BigInt;\n  protected _ingressEnd: number | BigInt;\n  protected _receiverId: string;\n  protected _amount: string;\n\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n    this._transaction = new Transaction(_coinConfig);\n  }\n\n  public signaturePayload(): Signatures[] {\n    return this._transaction.signaturePayload;\n  }\n\n  public payloadData(): PayloadsData {\n    return this._transaction.payloadsData;\n  }\n\n  public icpTransaction(): IcpTransaction {\n    return this._transaction.icpTransaction;\n  }\n\n  /**\n   * Sets the public key and the address of the sender of this transaction.\n   *\n   * @param {string} address the account that is sending this transaction\n   * @param {string} pubKey the public key that is sending this transaction\n   * @returns {TransactionBuilder} This transaction builder\n   */\n  public sender(address: string, pubKey: string): this {\n    if (!address || !utils.isValidAddress(address.toString())) {\n      throw new BuildTransactionError('Invalid or missing address, got: ' + address);\n    }\n    if (!pubKey || !utils.isValidPublicKey(pubKey)) {\n      throw new BuildTransactionError('Invalid or missing pubKey, got: ' + pubKey);\n    }\n    this._sender = address;\n    this._publicKey = pubKey;\n    return this;\n  }\n\n  /**\n   * Set the memo\n   *\n   * @param {number} memo - number that to be used as memo\n   * @returns {TransactionBuilder} This transaction builder\n   */\n  public memo(memo: number): this {\n    if (typeof memo !== 'number' || Number.isNaN(memo) || memo < 0) {\n      throw new BuildTransactionError(`Invalid memo: ${memo}`);\n    }\n    this._memo = memo;\n    return this;\n  }\n\n  /**\n   * Set the ingressEnd timestamp\n   * @param {number} ingressEnd - timestamp in nanoseconds\n   * @returns {TransactionBuilder} This transaction builder\n   */\n  public ingressEnd(ingressEnd: number | BigInt): this {\n    if (BigInt(ingressEnd.toString()) < 0n) {\n      throw new BuildTransactionError(`Invalid timestamp: ${ingressEnd}`);\n    }\n    this._ingressEnd = ingressEnd;\n    return this;\n  }\n\n  /**\n   * Sets the account Id of the receiver of this transaction.\n   *\n   * @param {string} accountId the account id of the account that is receiving this transaction\n   * @returns {TransactionBuilder} This transaction builder\n   */\n  public receiverId(accountId: string): this {\n    if (!accountId || !utils.isValidAddress(accountId)) {\n      throw new BuildTransactionError('Invalid or missing accountId for receiver, got: ' + accountId);\n    }\n    this._receiverId = accountId;\n    return this;\n  }\n\n  /** @inheritdoc */\n  get transaction(): Transaction {\n    return this._transaction;\n  }\n\n  /** @inheritdoc */\n  set transaction(transaction: Transaction) {\n    this._transaction = transaction;\n  }\n\n  get transactionType(): string {\n    return this._transaction.icpTransactionData.transactionType;\n  }\n\n  /** @inheritdoc */\n  fromImplementation(rawTransaction: string): Transaction {\n    this.transaction.fromRawTransaction(rawTransaction);\n    const icpTransactionData = this.transaction.icpTransactionData;\n    this.validateRawTransaction(icpTransactionData);\n    this.buildImplementation();\n    return this.transaction;\n  }\n\n  /** @inheritdoc */\n  validateTransaction(transaction: Transaction): void {\n    if (!transaction || !transaction.icpTransactionData) {\n      return;\n    }\n    utils.validateRawTransaction(transaction.icpTransactionData);\n  }\n\n  /**\n   * Sets the amount of this transaction.\n   *\n   * @param {string} value the amount to be sent in e8s (1 ICP = 1e8 e8s)\n   * @returns {TransactionBuilder} This transaction builder\n   */\n  public amount(value: string): this {\n    utils.validateValue(new BigNumber(value));\n    this._amount = value;\n    return this;\n  }\n\n  validateValue(value: BigNumber): void {\n    utils.validateValue(new BigNumber(value));\n  }\n\n  /**\n   * Initialize the transaction builder fields using the decoded transaction data\n   *\n   * @param {Transaction} tx the transaction data\n   */\n  initBuilder(tx: Transaction): void {\n    this._transaction = tx;\n    const icpTransactionData = tx.icpTransactionData;\n    this._sender = icpTransactionData.senderAddress;\n    this._receiverId = icpTransactionData.receiverAddress;\n    this._publicKey = icpTransactionData.senderPublicKeyHex;\n    this._amount = icpTransactionData.amount;\n    this._memo = icpTransactionData.memo ?? DEFAULT_MEMO;\n    this._ingressEnd = Number(icpTransactionData.expiryTime);\n  }\n\n  validateAddress(address: BaseAddress): void {\n    if (!utils.isValidAddress(address.address)) {\n      throw new BuildTransactionError('Invalid address');\n    }\n  }\n\n  validateRawTransaction(rawTransaction: IcpTransactionData): void {\n    utils.validateRawTransaction(rawTransaction);\n  }\n\n  /** @inheritdoc */\n  validateKey(key: BaseKey): void {\n    if (!key || !key.key) {\n      throw new SigningError('Key is required');\n    }\n    if (!utils.isValidPrivateKey(key.key)) {\n      throw new SigningError('Invalid private key');\n    }\n  }\n\n  /**\n   * Combines the unsigned transaction and the signature payload to create a signed transaction.\n   */\n  public combine(): void {\n    const signedTransactionBuilder = new SignedTransactionBuilder(\n      this._transaction.unsignedTransaction,\n      this._transaction.signaturePayload\n    );\n    this._transaction.signedTransaction = signedTransactionBuilder.getSignTransaction();\n  }\n}\n"]}

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

@@ -1,24 +1,25 @@
 import { BaseTransactionBuilderFactory } from '@bitgo-beta/sdk-core';
 import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { Transaction } from './transaction';
+import { TransactionBuilder } from './transactionBuilder';
+import { TransferBuilder } from './transferBuilder';
+import { ParsedTransaction } from './iface';
 export declare class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
     constructor(_coinConfig: Readonly<CoinConfig>);
     /** @inheritdoc */
-    from(): void;
-    /** @inheritdoc */
-    getTransferBuilder(): void;
-    /** @inheritdoc */
-    getStakingBuilder(): void;
-    /** @inheritdoc */
-    getUnstakingBuilder(): void;
-    /** @inheritdoc */
-    getCustomTransactionBuilder(): void;
+    from(rawTransaction: string): Promise<TransactionBuilder>;
+    /**
+     * Initialize the builder with the given transaction
+     *
+     * @param {Transaction | undefined} tx - the transaction used to initialize the builder
+     * @param {TransactionBuilder} builder - the builder to be initialized
+     * @returns {TransactionBuilder} the builder initialized
+     */
+    private static initializeBuilder;
     /** @inheritdoc */
-    getTokenTransferBuilder(): void;
+    getTransferBuilder(tx?: Transaction): TransferBuilder;
+    parseTransaction(rawTransaction: string, isSigned: boolean): Promise<ParsedTransaction>;
     /** @inheritdoc */
     getWalletInitializationBuilder(): void;
-    /**
-     * Parse the transaction from a raw transaction
-     */
-    private parseTransaction;
 }
 //# sourceMappingURL=transactionBuilderFactory.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"transactionBuilderFactory.d.ts","sourceRoot":"","sources":["../../../src/lib/transactionBuilderFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAAE,MAAM,sBAAsB,CAAC;AACrE,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAE7D,qBAAa,yBAA0B,SAAQ,6BAA6B;gBAC9D,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C,kBAAkB;IAClB,IAAI,IAAI,IAAI;IAIZ,kBAAkB;IAClB,kBAAkB,IAAI,IAAI;IAI1B,kBAAkB;IAClB,iBAAiB,IAAI,IAAI;IAIzB,kBAAkB;IAClB,mBAAmB,IAAI,IAAI;IAI3B,kBAAkB;IAClB,2BAA2B,IAAI,IAAI;IAInC,kBAAkB;IAClB,uBAAuB,IAAI,IAAI;IAI/B,kBAAkB;IAClB,8BAA8B,IAAI,IAAI;IAItC;;OAEG;IACH,OAAO,CAAC,gBAAgB;CAGzB"}
+{"version":3,"file":"transactionBuilderFactory.d.ts","sourceRoot":"","sources":["../../../src/lib/transactionBuilderFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAAsD,MAAM,sBAAsB,CAAC;AACzH,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAiB,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAE3D,qBAAa,yBAA0B,SAAQ,6BAA6B;gBAC9D,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C,kBAAkB;IACZ,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAe/D;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,iBAAiB;IAOhC,kBAAkB;IAClB,kBAAkB,CAAC,EAAE,CAAC,EAAE,WAAW,GAAG,eAAe;IAIrD,gBAAgB,CAAC,cAAc,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAWvF,kBAAkB;IAClB,8BAA8B,IAAI,IAAI;CAGvC"}

package/dist/src/lib/transactionBuilderFactory.js

@@ -2,44 +2,60 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransactionBuilderFactory = void 0;
 const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const transaction_1 = require("./transaction");
+const transferBuilder_1 = require("./transferBuilder");
+const iface_1 = require("./iface");
 class TransactionBuilderFactory extends sdk_core_1.BaseTransactionBuilderFactory {
     constructor(_coinConfig) {
         super(_coinConfig);
     }
     /** @inheritdoc */
-    from() {
-        throw new Error('method not implemented');
+    async from(rawTransaction) {
+        const transaction = new transaction_1.Transaction(this._coinConfig);
+        await transaction.fromRawTransaction(rawTransaction);
+        try {
+            switch (transaction.icpTransactionData.transactionType) {
+                case iface_1.OperationType.TRANSACTION:
+                    return this.getTransferBuilder(transaction);
+                default:
+                    throw new sdk_core_1.InvalidTransactionError('Invalid transaction');
+            }
+        }
+        catch (e) {
+            throw new sdk_core_1.InvalidTransactionError('Invalid transaction: ' + e.message);
+        }
     }
-    /** @inheritdoc */
-    getTransferBuilder() {
-        throw new Error('method not implemented');
-    }
-    /** @inheritdoc */
-    getStakingBuilder() {
-        throw new Error('method not implemented');
-    }
-    /** @inheritdoc */
-    getUnstakingBuilder() {
-        throw new Error('method not implemented');
-    }
-    /** @inheritdoc */
-    getCustomTransactionBuilder() {
-        throw new Error('method not implemented');
+    /**
+     * Initialize the builder with the given transaction
+     *
+     * @param {Transaction | undefined} tx - the transaction used to initialize the builder
+     * @param {TransactionBuilder} builder - the builder to be initialized
+     * @returns {TransactionBuilder} the builder initialized
+     */
+    static initializeBuilder(tx, builder) {
+        if (tx) {
+            builder.initBuilder(tx);
+        }
+        return builder;
     }
     /** @inheritdoc */
-    getTokenTransferBuilder() {
-        throw new Error('method not implemented');
+    getTransferBuilder(tx) {
+        return TransactionBuilderFactory.initializeBuilder(tx, new transferBuilder_1.TransferBuilder(this._coinConfig));
+    }
+    parseTransaction(rawTransaction, isSigned) {
+        if (!rawTransaction) {
+            throw new sdk_core_1.InvalidTransactionError('Transaction is empty');
+        }
+        const transaction = new transaction_1.Transaction(this._coinConfig);
+        if (isSigned) {
+            return transaction.parseSignedTransaction(rawTransaction);
+        }
+        return transaction.parseUnsignedTransaction(rawTransaction);
     }
     /** @inheritdoc */
     getWalletInitializationBuilder() {
-        throw new Error('method not implemented');
-    }
-    /**
-     * Parse the transaction from a raw transaction
-     */
-    parseTransaction(rawTransaction) {
-        throw new Error('method not implemented');
+        throw new sdk_core_1.MethodNotImplementedError();
     }
 }
 exports.TransactionBuilderFactory = TransactionBuilderFactory;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNhY3Rpb25CdWlsZGVyRmFjdG9yeS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9saWIvdHJhbnNhY3Rpb25CdWlsZGVyRmFjdG9yeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxtREFBcUU7QUFHckUsTUFBYSx5QkFBMEIsU0FBUSx3Q0FBNkI7SUFDMUUsWUFBWSxXQUFpQztRQUMzQyxLQUFLLENBQUMsV0FBVyxDQUFDLENBQUM7SUFDckIsQ0FBQztJQUVELGtCQUFrQjtJQUNsQixJQUFJO1FBQ0YsTUFBTSxJQUFJLEtBQUssQ0FBQyx3QkFBd0IsQ0FBQyxDQUFDO0lBQzVDLENBQUM7SUFFRCxrQkFBa0I7SUFDbEIsa0JBQWtCO1FBQ2hCLE1BQU0sSUFBSSxLQUFLLENBQUMsd0JBQXdCLENBQUMsQ0FBQztJQUM1QyxDQUFDO0lBRUQsa0JBQWtCO0lBQ2xCLGlCQUFpQjtRQUNmLE1BQU0sSUFBSSxLQUFLLENBQUMsd0JBQXdCLENBQUMsQ0FBQztJQUM1QyxDQUFDO0lBRUQsa0JBQWtCO0lBQ2xCLG1CQUFtQjtRQUNqQixNQUFNLElBQUksS0FBSyxDQUFDLHdCQUF3QixDQUFDLENBQUM7SUFDNUMsQ0FBQztJQUVELGtCQUFrQjtJQUNsQiwyQkFBMkI7UUFDekIsTUFBTSxJQUFJLEtBQUssQ0FBQyx3QkFBd0IsQ0FBQyxDQUFDO0lBQzVDLENBQUM7SUFFRCxrQkFBa0I7SUFDbEIsdUJBQXVCO1FBQ3JCLE1BQU0sSUFBSSxLQUFLLENBQUMsd0JBQXdCLENBQUMsQ0FBQztJQUM1QyxDQUFDO0lBRUQsa0JBQWtCO0lBQ2xCLDhCQUE4QjtRQUM1QixNQUFNLElBQUksS0FBSyxDQUFDLHdCQUF3QixDQUFDLENBQUM7SUFDNUMsQ0FBQztJQUVEOztPQUVHO0lBQ0ssZ0JBQWdCLENBQUMsY0FBc0I7UUFDN0MsTUFBTSxJQUFJLEtBQUssQ0FBQyx3QkFBd0IsQ0FBQyxDQUFDO0lBQzVDLENBQUM7Q0FDRjtBQTlDRCw4REE4Q0MiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBCYXNlVHJhbnNhY3Rpb25CdWlsZGVyRmFjdG9yeSB9IGZyb20gJ0BiaXRnby1iZXRhL3Nkay1jb3JlJztcbmltcG9ydCB7IEJhc2VDb2luIGFzIENvaW5Db25maWcgfSBmcm9tICdAYml0Z28tYmV0YS9zdGF0aWNzJztcblxuZXhwb3J0IGNsYXNzIFRyYW5zYWN0aW9uQnVpbGRlckZhY3RvcnkgZXh0ZW5kcyBCYXNlVHJhbnNhY3Rpb25CdWlsZGVyRmFjdG9yeSB7XG4gIGNvbnN0cnVjdG9yKF9jb2luQ29uZmlnOiBSZWFkb25seTxDb2luQ29uZmlnPikge1xuICAgIHN1cGVyKF9jb2luQ29uZmlnKTtcbiAgfVxuXG4gIC8qKiBAaW5oZXJpdGRvYyAqL1xuICBmcm9tKCk6IHZvaWQge1xuICAgIHRocm93IG5ldyBFcnJvcignbWV0aG9kIG5vdCBpbXBsZW1lbnRlZCcpO1xuICB9XG5cbiAgLyoqIEBpbmhlcml0ZG9jICovXG4gIGdldFRyYW5zZmVyQnVpbGRlcigpOiB2b2lkIHtcbiAgICB0aHJvdyBuZXcgRXJyb3IoJ21ldGhvZCBub3QgaW1wbGVtZW50ZWQnKTtcbiAgfVxuXG4gIC8qKiBAaW5oZXJpdGRvYyAqL1xuICBnZXRTdGFraW5nQnVpbGRlcigpOiB2b2lkIHtcbiAgICB0aHJvdyBuZXcgRXJyb3IoJ21ldGhvZCBub3QgaW1wbGVtZW50ZWQnKTtcbiAgfVxuXG4gIC8qKiBAaW5oZXJpdGRvYyAqL1xuICBnZXRVbnN0YWtpbmdCdWlsZGVyKCk6IHZvaWQge1xuICAgIHRocm93IG5ldyBFcnJvcignbWV0aG9kIG5vdCBpbXBsZW1lbnRlZCcpO1xuICB9XG5cbiAgLyoqIEBpbmhlcml0ZG9jICovXG4gIGdldEN1c3RvbVRyYW5zYWN0aW9uQnVpbGRlcigpOiB2b2lkIHtcbiAgICB0aHJvdyBuZXcgRXJyb3IoJ21ldGhvZCBub3QgaW1wbGVtZW50ZWQnKTtcbiAgfVxuXG4gIC8qKiBAaW5oZXJpdGRvYyAqL1xuICBnZXRUb2tlblRyYW5zZmVyQnVpbGRlcigpOiB2b2lkIHtcbiAgICB0aHJvdyBuZXcgRXJyb3IoJ21ldGhvZCBub3QgaW1wbGVtZW50ZWQnKTtcbiAgfVxuXG4gIC8qKiBAaW5oZXJpdGRvYyAqL1xuICBnZXRXYWxsZXRJbml0aWFsaXphdGlvbkJ1aWxkZXIoKTogdm9pZCB7XG4gICAgdGhyb3cgbmV3IEVycm9yKCdtZXRob2Qgbm90IGltcGxlbWVudGVkJyk7XG4gIH1cblxuICAvKipcbiAgICogUGFyc2UgdGhlIHRyYW5zYWN0aW9uIGZyb20gYSByYXcgdHJhbnNhY3Rpb25cbiAgICovXG4gIHByaXZhdGUgcGFyc2VUcmFuc2FjdGlvbihyYXdUcmFuc2FjdGlvbjogc3RyaW5nKTogdm9pZCB7XG4gICAgdGhyb3cgbmV3IEVycm9yKCdtZXRob2Qgbm90IGltcGxlbWVudGVkJyk7XG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,36 +1,19 @@
 import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
 import { TransactionBuilder } from './transactionBuilder';
-import { BaseKey, Recipient, TransactionType, BaseTransaction } from '@bitgo-beta/sdk-core';
+import { BaseTransaction, BaseKey } from '@bitgo-beta/sdk-core';
+import { Transaction } from './transaction';
 export declare class TransferBuilder extends TransactionBuilder {
-    protected _recipients: Recipient[];
     constructor(_coinConfig: Readonly<CoinConfig>);
-    protected get transactionType(): TransactionType;
-    send(recipients: Recipient[]): this;
-    /** @inheritdoc */
-    validateTransaction(): void;
-    /** @inheritdoc */
-    sign(key: BaseKey): void;
-    /** @inheritdoc */
-    protected buildImplementation(): Promise<BaseTransaction>;
     /**
      * Initialize the transaction builder fields using the decoded transaction data
-     */
-    initBuilder(): void;
-    /**
-     * Validates all fields are defined
-     */
-    private validateTransactionFields;
-    /**
-     * Build transfer programmable transaction
      *
-     * @protected
+     * @param {Transaction} tx the transaction data
      */
-    protected buildIcpTransaction(): void;
-    /** @inheritdoc */
-    TransactionBuilder(): void;
+    initBuilder(tx: Transaction): void;
     /** @inheritdoc */
-    fromImplementation(): BaseTransaction;
+    protected buildImplementation(): Promise<Transaction>;
+    protected buildIcpTransactionData(): void;
     /** @inheritdoc */
-    get transaction(): BaseTransaction;
+    protected signImplementation(key: BaseKey): BaseTransaction;
 }
 //# sourceMappingURL=transferBuilder.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"transferBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/transferBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAE5F,qBAAa,eAAgB,SAAQ,kBAAkB;IACrD,SAAS,CAAC,WAAW,EAAE,SAAS,EAAE,CAAC;gBAEvB,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C,SAAS,KAAK,eAAe,IAAI,eAAe,CAE/C;IAED,IAAI,CAAC,UAAU,EAAE,SAAS,EAAE,GAAG,IAAI;IAMnC,kBAAkB;IAClB,mBAAmB,IAAI,IAAI;IAI3B,kBAAkB;IAClB,IAAI,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI;IAIxB,kBAAkB;cACF,mBAAmB,IAAI,OAAO,CAAC,eAAe,CAAC;IAI/D;;OAEG;IACH,WAAW,IAAI,IAAI;IAInB;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAIjC;;;;OAIG;IACH,SAAS,CAAC,mBAAmB,IAAI,IAAI;IAIrC,kBAAkB;IAClB,kBAAkB,IAAI,IAAI;IAI1B,kBAAkB;IAClB,kBAAkB,IAAI,eAAe;IAIrC,kBAAkB;IAClB,IAAI,WAAW,IAAI,eAAe,CAEjC;CACF"}
+{"version":3,"file":"transferBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/transferBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,eAAe,EAAyB,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAEvF,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAa5C,qBAAa,eAAgB,SAAQ,kBAAkB;gBACzC,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C;;;;OAIG;IACH,WAAW,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI;IAIlC,kBAAkB;cACF,mBAAmB,IAAI,OAAO,CAAC,WAAW,CAAC;IAiB3D,SAAS,CAAC,uBAAuB,IAAI,IAAI;IAsEzC,kBAAkB;IAClB,SAAS,CAAC,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,eAAe;CAK5D"}

package/dist/src/lib/transferBuilder.js

@@ -1,64 +1,109 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransferBuilder = void 0;
 const transactionBuilder_1 = require("./transactionBuilder");
 const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const utils_1 = __importDefault(require("./utils"));
+const unsignedTransactionBuilder_1 = require("./unsignedTransactionBuilder");
+const iface_1 = require("./iface");
+const assert_1 = __importDefault(require("assert"));
 class TransferBuilder extends transactionBuilder_1.TransactionBuilder {
     constructor(_coinConfig) {
         super(_coinConfig);
     }
-    get transactionType() {
-        return sdk_core_1.TransactionType.Send;
-    }
-    send(recipients) {
-        this.validateRecipients(recipients);
-        this._recipients = recipients;
-        return this;
-    }
-    /** @inheritdoc */
-    validateTransaction() {
-        throw new Error('method not implemented');
-    }
-    /** @inheritdoc */
-    sign(key) {
-        throw new Error('method not implemented');
-    }
-    /** @inheritdoc */
-    async buildImplementation() {
-        throw new Error('method not implemented');
-    }
     /**
      * Initialize the transaction builder fields using the decoded transaction data
-     */
-    initBuilder() {
-        throw new Error('method not implemented');
-    }
-    /**
-     * Validates all fields are defined
-     */
-    validateTransactionFields() {
-        throw new Error('method not implemented');
-    }
-    /**
-     * Build transfer programmable transaction
      *
-     * @protected
+     * @param {Transaction} tx the transaction data
      */
-    buildIcpTransaction() {
-        throw new Error('method not implemented');
+    initBuilder(tx) {
+        super.initBuilder(tx);
     }
     /** @inheritdoc */
-    TransactionBuilder() {
-        throw new Error('method not implemented');
+    async buildImplementation() {
+        // The ICP chain sets a memo field with a default value of 0. This ensures compatibility
+        // by setting the memo to 0 if it's not explicitly provided.
+        if (!this._memo || this._memo === undefined || this._memo === null) {
+            this._memo = iface_1.DEFAULT_MEMO;
+        }
+        this.validateTransaction(this._transaction);
+        this.buildIcpTransactionData();
+        const unsignedTransactionBuilder = new unsignedTransactionBuilder_1.UnsignedTransactionBuilder(this._transaction.icpTransaction, this._coinConfig);
+        const payloadsData = await unsignedTransactionBuilder.getUnsignedTransaction();
+        this._transaction.payloadsData = payloadsData;
+        return this._transaction;
     }
-    /** @inheritdoc */
-    fromImplementation() {
-        throw new Error('method not implemented');
+    buildIcpTransactionData() {
+        (0, assert_1.default)(this._sender, new sdk_core_1.BuildTransactionError('sender is required before building'));
+        (0, assert_1.default)(this._publicKey, new sdk_core_1.BuildTransactionError('sender public key is required before building'));
+        (0, assert_1.default)(this._amount, new sdk_core_1.BuildTransactionError('amount is required before building'));
+        (0, assert_1.default)(this._receiverId, new sdk_core_1.BuildTransactionError('receiver is required before building'));
+        const publicKey = {
+            hex_bytes: this._publicKey,
+            curve_type: iface_1.CurveType.SECP256K1,
+        };
+        const senderOperation = {
+            type: iface_1.OperationType.TRANSACTION,
+            account: { address: this._sender },
+            amount: {
+                value: `-${this._amount}`,
+                currency: {
+                    symbol: this._coinConfig.family,
+                    decimals: this._coinConfig.decimalPlaces,
+                },
+            },
+        };
+        const receiverOperation = {
+            type: iface_1.OperationType.TRANSACTION,
+            account: { address: this._receiverId },
+            amount: {
+                value: this._amount,
+                currency: {
+                    symbol: this._coinConfig.family,
+                    decimals: this._coinConfig.decimalPlaces,
+                },
+            },
+        };
+        const feeOperation = {
+            type: iface_1.OperationType.FEE,
+            account: { address: this._sender },
+            amount: {
+                value: utils_1.default.feeData(),
+                currency: {
+                    symbol: this._coinConfig.family,
+                    decimals: this._coinConfig.decimalPlaces,
+                },
+            },
+        };
+        const createdTimestamp = this._transaction.createdTimestamp;
+        const { metaData, ingressEndTime } = utils_1.default.getMetaData(this._memo, createdTimestamp, this._ingressEnd);
+        const icpTransaction = {
+            public_keys: [publicKey],
+            operations: [senderOperation, receiverOperation, feeOperation],
+            metadata: metaData,
+        };
+        const icpTransactionData = {
+            senderAddress: this._sender,
+            receiverAddress: this._receiverId,
+            amount: this._amount,
+            fee: utils_1.default.feeData(),
+            senderPublicKeyHex: this._publicKey,
+            transactionType: iface_1.OperationType.TRANSACTION,
+            expiryTime: ingressEndTime,
+            memo: this._memo,
+        };
+        this._transaction.icpTransactionData = icpTransactionData;
+        this._transaction.icpTransaction = icpTransaction;
     }
     /** @inheritdoc */
-    get transaction() {
-        throw new Error('method not implemented');
+    signImplementation(key) {
+        const signatures = utils_1.default.getSignatures(this._transaction.payloadsData, this._publicKey, key.key);
+        this._transaction.addSignature(signatures);
+        return this._transaction;
     }
 }
 exports.TransferBuilder = TransferBuilder;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transferBuilder.js","sourceRoot":"","sources":["../../../src/lib/transferBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { TransactionBuilder } from './transactionBuilder';\nimport { BaseTransaction, BuildTransactionError, BaseKey } from '@bitgo-beta/sdk-core';\nimport utils from './utils';\nimport { Transaction } from './transaction';\nimport { UnsignedTransactionBuilder } from './unsignedTransactionBuilder';\nimport {\n  CurveType,\n  IcpOperation,\n  IcpPublicKey,\n  IcpTransaction,\n  IcpTransactionData,\n  OperationType,\n  DEFAULT_MEMO,\n} from './iface';\nimport assert from 'assert';\n\nexport class TransferBuilder extends TransactionBuilder {\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n  }\n\n  /**\n   * Initialize the transaction builder fields using the decoded transaction data\n   *\n   * @param {Transaction} tx the transaction data\n   */\n  initBuilder(tx: Transaction): void {\n    super.initBuilder(tx);\n  }\n\n  /** @inheritdoc */\n  protected async buildImplementation(): Promise<Transaction> {\n    // The ICP chain sets a memo field with a default value of 0. This ensures compatibility\n    // by setting the memo to 0 if it's not explicitly provided.\n    if (!this._memo || this._memo === undefined || this._memo === null) {\n      this._memo = DEFAULT_MEMO;\n    }\n    this.validateTransaction(this._transaction);\n    this.buildIcpTransactionData();\n    const unsignedTransactionBuilder = new UnsignedTransactionBuilder(\n      this._transaction.icpTransaction,\n      this._coinConfig\n    );\n    const payloadsData = await unsignedTransactionBuilder.getUnsignedTransaction();\n    this._transaction.payloadsData = payloadsData;\n    return this._transaction;\n  }\n\n  protected buildIcpTransactionData(): void {\n    assert(this._sender, new BuildTransactionError('sender is required before building'));\n    assert(this._publicKey, new BuildTransactionError('sender public key is required before building'));\n    assert(this._amount, new BuildTransactionError('amount is required before building'));\n    assert(this._receiverId, new BuildTransactionError('receiver is required before building'));\n\n    const publicKey: IcpPublicKey = {\n      hex_bytes: this._publicKey,\n      curve_type: CurveType.SECP256K1,\n    };\n\n    const senderOperation: IcpOperation = {\n      type: OperationType.TRANSACTION,\n      account: { address: this._sender },\n      amount: {\n        value: `-${this._amount}`,\n        currency: {\n          symbol: this._coinConfig.family,\n          decimals: this._coinConfig.decimalPlaces,\n        },\n      },\n    };\n\n    const receiverOperation: IcpOperation = {\n      type: OperationType.TRANSACTION,\n      account: { address: this._receiverId },\n      amount: {\n        value: this._amount,\n        currency: {\n          symbol: this._coinConfig.family,\n          decimals: this._coinConfig.decimalPlaces,\n        },\n      },\n    };\n\n    const feeOperation: IcpOperation = {\n      type: OperationType.FEE,\n      account: { address: this._sender },\n      amount: {\n        value: utils.feeData(),\n        currency: {\n          symbol: this._coinConfig.family,\n          decimals: this._coinConfig.decimalPlaces,\n        },\n      },\n    };\n\n    const createdTimestamp = this._transaction.createdTimestamp;\n    const { metaData, ingressEndTime } = utils.getMetaData(this._memo, createdTimestamp, this._ingressEnd);\n\n    const icpTransaction: IcpTransaction = {\n      public_keys: [publicKey],\n      operations: [senderOperation, receiverOperation, feeOperation],\n      metadata: metaData,\n    };\n    const icpTransactionData: IcpTransactionData = {\n      senderAddress: this._sender,\n      receiverAddress: this._receiverId,\n      amount: this._amount,\n      fee: utils.feeData(),\n      senderPublicKeyHex: this._publicKey,\n      transactionType: OperationType.TRANSACTION,\n      expiryTime: ingressEndTime,\n      memo: this._memo,\n    };\n\n    this._transaction.icpTransactionData = icpTransactionData;\n    this._transaction.icpTransaction = icpTransaction;\n  }\n\n  /** @inheritdoc */\n  protected signImplementation(key: BaseKey): BaseTransaction {\n    const signatures = utils.getSignatures(this._transaction.payloadsData, this._publicKey, key.key);\n    this._transaction.addSignature(signatures);\n    return this._transaction;\n  }\n}\n"]}