@bitgo-beta/sdk-coin-flrp 1.0.1-beta.3 → 1.0.1-beta.300

package/dist/src/lib/transactionBuilder.js

@@ -0,0 +1,210 @@
+"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 flarejs_1 = require("@flarenetwork/flarejs");
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const keyPair_1 = require("./keyPair");
+const transaction_1 = require("./transaction");
+const utils_1 = __importDefault(require("./utils"));
+class TransactionBuilder extends sdk_core_1.BaseTransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this.recoverSigner = false;
+        this._signer = [];
+        this._transaction = new transaction_1.Transaction(_coinConfig);
+    }
+    /**
+     * Initialize the transaction builder fields using the decoded transaction data
+     *
+     * @param {Transaction} tx the transaction data
+     * @returns itself
+     */
+    initBuilder(tx) {
+        const baseTx = tx.tx.baseTx;
+        // Validate network and blockchain IDs match
+        if (baseTx.NetworkId.value() !== this._transaction._networkID ||
+            baseTx.BlockchainId.value() !== this._transaction._blockchainID) {
+            throw new Error('Network or blockchain ID mismatch');
+        }
+        this._transaction.setTransaction(tx);
+        return this;
+    }
+    // region Validators
+    /**
+     * Validates the threshold for multi-signature transactions
+     * @param threshold - Number of required signatures
+     */
+    validateThreshold(threshold) {
+        if (!threshold || threshold !== 2) {
+            throw new sdk_core_1.BuildTransactionError('Invalid transaction: threshold must be set to 2');
+        }
+    }
+    /**
+     * Validates a single UTXO object
+     * @param value - UTXO to validate
+     */
+    validateUtxo(value) {
+        const requiredFields = ['outputID', 'amount', 'txid', 'outputidx'];
+        for (const field of requiredFields) {
+            if (!value.hasOwnProperty(field)) {
+                throw new sdk_core_1.BuildTransactionError(`UTXO missing required field: ${field}`);
+            }
+        }
+    }
+    /**
+     * Validates an array of UTXOs
+     * @param values - Array of UTXOs to validate
+     */
+    validateUtxos(values) {
+        if (values.length === 0) {
+            throw new sdk_core_1.BuildTransactionError('UTXOs array cannot be empty');
+        }
+        values.forEach(this.validateUtxo);
+    }
+    /**
+     * Validates the locktime value
+     * @param locktime - Timestamp after which the output can be spent
+     */
+    validateLocktime(locktime) {
+        if (locktime < BigInt(0)) {
+            throw new sdk_core_1.BuildTransactionError('Invalid transaction: locktime must be 0 or higher');
+        }
+    }
+    // endregion
+    /**
+     * Sets the threshold for multi-signature transactions
+     * @param value - Number of required signatures
+     */
+    threshold(value) {
+        this.validateThreshold(value);
+        this._transaction._threshold = value;
+        return this;
+    }
+    /**
+     * Sets the locktime for the transaction
+     * @param value - Timestamp after which the output can be spent
+     */
+    locktime(value) {
+        this.validateLocktime(BigInt(value));
+        this._transaction._locktime = BigInt(value);
+        return this;
+    }
+    /**
+     * Enables recovery mode for the transaction
+     * @param recoverSigner - Whether to use recovery signing
+     */
+    recoverMode(recoverSigner = true) {
+        this.recoverSigner = recoverSigner;
+        return this;
+    }
+    /**
+     * Sets the sender's public key(s)
+     * @param senderPubKey - Public key or array of public keys
+     */
+    fromPubKey(senderPubKey) {
+        const pubKeys = Array.isArray(senderPubKey) ? senderPubKey : [senderPubKey];
+        this._transaction._fromAddresses = pubKeys.map((addr) => utils_1.default.parseAddress(addr));
+        return this;
+    }
+    /**
+     * Sets the UTXOs for the transaction
+     * @param value - Array of UTXOs to use
+     */
+    utxos(value) {
+        this.validateUtxos(value);
+        this._transaction._utxos = value;
+        return this;
+    }
+    /** @inheritdoc */
+    fromImplementation(rawTransaction) {
+        try {
+            // Parse the raw transaction using Flare's PVM serialization
+            const [tx] = flarejs_1.pvmSerial.AddPermissionlessValidatorTx.fromBytes(Buffer.from(rawTransaction, 'hex'), flarejs_1.avmSerial.getAVMManager().getDefaultCodec());
+            this.initBuilder(tx);
+            return this._transaction;
+        }
+        catch (e) {
+            throw new sdk_core_1.BuildTransactionError(`Failed to parse raw transaction: ${e.message}`);
+        }
+    }
+    /**
+     * Check the buffer has 32 byte long.
+     * @param chainID
+     */
+    validateChainId(chainID) {
+        if (chainID.length !== 32) {
+            throw new sdk_core_1.BuildTransactionError('Chain id are 32 byte size');
+        }
+    }
+    /** @inheritdoc */
+    get transaction() {
+        return this._transaction;
+    }
+    set transaction(transaction) {
+        this._transaction = transaction;
+    }
+    /**
+     * Check that fee is greater than 0.
+     * @param {bigint} fee
+     */
+    validateFee(fee) {
+        if (fee <= BigInt(0)) {
+            throw new sdk_core_1.BuildTransactionError('Fee must be greater than 0');
+        }
+    }
+    /** @inheritdoc */
+    validateKey({ key }) {
+        try {
+            new keyPair_1.KeyPair({ prv: key });
+        }
+        catch (e) {
+            throw new sdk_core_1.BuildTransactionError('Invalid key');
+        }
+    }
+    /** @inheritdoc */
+    validateTransaction(transaction) {
+        // throw new NotImplementedError('validateTransaction not implemented');
+    }
+    /** @inheritdoc */
+    validateValue(value) {
+        if (value.isLessThan(0)) {
+            throw new sdk_core_1.BuildTransactionError('Value cannot be less than zero');
+        }
+    }
+    /** @inheritdoc */
+    validateAddress(address, addressFormat) {
+        if (!utils_1.default.isValidAddress(address.address)) {
+            throw new sdk_core_1.BuildTransactionError('Invalid address');
+        }
+    }
+    /**
+     * Check the raw transaction has a valid format in the blockchain context, throw otherwise.
+     *
+     * @param rawTransaction Transaction in any format
+     */
+    validateRawTransaction(rawTransaction) {
+        utils_1.default.validateRawTransaction(rawTransaction);
+    }
+    /** @inheritdoc */
+    signImplementation({ key }) {
+        this._signer.push(new keyPair_1.KeyPair({ prv: key }));
+        return this.transaction;
+    }
+    hasSigner() {
+        return this._signer !== undefined && this._signer.length > 0;
+    }
+    /**
+     * Check the amount is positive.
+     * @param amount
+     */
+    validateAmount(amount) {
+        if (amount <= BigInt(0)) {
+            throw new sdk_core_1.BuildTransactionError('Amount must be greater than 0');
+        }
+    }
+}
+exports.TransactionBuilder = TransactionBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transactionBuilder.js","sourceRoot":"","sources":["../../../src/lib/transactionBuilder.ts"],"names":[],"mappings":";;;;;;AAAA,mDAAyE;AACzE,mDAA2G;AAG3G,uCAAoC;AACpC,+CAA4C;AAC5C,oDAA4B;AAG5B,MAAsB,kBAAmB,SAAQ,iCAAsB;IAKrE,YAAY,WAAiC;QAC3C,KAAK,CAAC,WAAW,CAAC,CAAC;QAJX,kBAAa,GAAG,KAAK,CAAC;QACzB,YAAO,GAAc,EAAE,CAAC;QAI7B,IAAI,CAAC,YAAY,GAAG,IAAI,yBAAW,CAAC,WAAW,CAAC,CAAC;IACnD,CAAC;IAED;;;;;OAKG;IACH,WAAW,CAAC,EAAM;QAChB,MAAM,MAAM,GAAK,EAAiB,CAAC,EAA6C,CAAC,MAAM,CAAC;QAExF,4CAA4C;QAC5C,IACE,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,KAAK,IAAI,CAAC,YAAY,CAAC,UAAU;YACzD,MAAM,CAAC,YAAY,CAAC,KAAK,EAAE,KAAK,IAAI,CAAC,YAAY,CAAC,aAAa,EAC/D,CAAC;YACD,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAC;QACvD,CAAC;QAED,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC;QACrC,OAAO,IAAI,CAAC;IACd,CAAC;IAED,oBAAoB;IACpB;;;OAGG;IACH,iBAAiB,CAAC,SAAiB;QACjC,IAAI,CAAC,SAAS,IAAI,SAAS,KAAK,CAAC,EAAE,CAAC;YAClC,MAAM,IAAI,gCAAqB,CAAC,iDAAiD,CAAC,CAAC;QACrF,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,YAAY,CAAC,KAAqB;QAChC,MAAM,cAAc,GAAG,CAAC,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC;QACnE,KAAK,MAAM,KAAK,IAAI,cAAc,EAAE,CAAC;YACnC,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,KAAK,CAAC,EAAE,CAAC;gBACjC,MAAM,IAAI,gCAAqB,CAAC,gCAAgC,KAAK,EAAE,CAAC,CAAC;YAC3E,CAAC;QACH,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,aAAa,CAAC,MAAwB;QACpC,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACxB,MAAM,IAAI,gCAAqB,CAAC,6BAA6B,CAAC,CAAC;QACjE,CAAC;QACD,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;IACpC,CAAC;IAED;;;OAGG;IACH,gBAAgB,CAAC,QAAgB;QAC/B,IAAI,QAAQ,GAAG,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;YACzB,MAAM,IAAI,gCAAqB,CAAC,mDAAmD,CAAC,CAAC;QACvF,CAAC;IACH,CAAC;IACD,YAAY;IAEZ;;;OAGG;IACH,SAAS,CAAC,KAAa;QACrB,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC;QAC9B,IAAI,CAAC,YAAY,CAAC,UAAU,GAAG,KAAK,CAAC;QACrC,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;OAGG;IACH,QAAQ,CAAC,KAAsB;QAC7B,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;QACrC,IAAI,CAAC,YAAY,CAAC,SAAS,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;QAC5C,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;OAGG;IACH,WAAW,CAAC,aAAa,GAAG,IAAI;QAC9B,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;QACnC,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;OAGG;IACH,UAAU,CAAC,YAA+B;QACxC,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC;QAC5E,IAAI,CAAC,YAAY,CAAC,cAAc,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,eAAK,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC;QACnF,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,KAAuB;QAC3B,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QAC1B,IAAI,CAAC,YAAY,CAAC,MAAM,GAAG,KAAK,CAAC;QACjC,OAAO,IAAI,CAAC;IACd,CAAC;IAED,kBAAkB;IACR,kBAAkB,CAAC,cAAsB;QACjD,IAAI,CAAC;YACH,4DAA4D;YAC5D,MAAM,CAAC,EAAE,CAAC,GAAG,mBAAS,CAAC,4BAA4B,CAAC,SAAS,CAC3D,MAAM,CAAC,IAAI,CAAC,cAAc,EAAE,KAAK,CAAC,EAClC,mBAAS,CAAC,aAAa,EAAE,CAAC,eAAe,EAAE,CAC5C,CAAC;YACF,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC;YACrB,OAAO,IAAI,CAAC,YAAY,CAAC;QAC3B,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,MAAM,IAAI,gCAAqB,CAAC,oCAAoC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC;QACnF,CAAC;IACH,CAAC;IAQD;;;OAGG;IACH,eAAe,CAAC,OAAe;QAC7B,IAAI,OAAO,CAAC,MAAM,KAAK,EAAE,EAAE,CAAC;YAC1B,MAAM,IAAI,gCAAqB,CAAC,2BAA2B,CAAC,CAAC;QAC/D,CAAC;IACH,CAAC;IAED,kBAAkB;IAClB,IAAc,WAAW;QACvB,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;IAED,IAAc,WAAW,CAAC,WAAwB;QAChD,IAAI,CAAC,YAAY,GAAG,WAAW,CAAC;IAClC,CAAC;IAED;;;OAGG;IACH,WAAW,CAAC,GAAW;QACrB,IAAI,GAAG,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;YACrB,MAAM,IAAI,gCAAqB,CAAC,4BAA4B,CAAC,CAAC;QAChE,CAAC;IACH,CAAC;IAED,kBAAkB;IAClB,WAAW,CAAC,EAAE,GAAG,EAAW;QAC1B,IAAI,CAAC;YACH,IAAI,iBAAO,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC;QAC5B,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,MAAM,IAAI,gCAAqB,CAAC,aAAa,CAAC,CAAC;QACjD,CAAC;IACH,CAAC;IAED,kBAAkB;IAClB,mBAAmB,CAAC,WAAyB;QAC3C,wEAAwE;IAC1E,CAAC;IAED,kBAAkB;IAClB,aAAa,CAAC,KAAgB;QAC5B,IAAI,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC;YACxB,MAAM,IAAI,gCAAqB,CAAC,gCAAgC,CAAC,CAAC;QACpE,CAAC;IACH,CAAC;IAED,kBAAkB;IAClB,eAAe,CAAC,OAAoB,EAAE,aAAsB;QAC1D,IAAI,CAAC,eAAK,CAAC,cAAc,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;YAC3C,MAAM,IAAI,gCAAqB,CAAC,iBAAiB,CAAC,CAAC;QACrD,CAAC;IACH,CAAC;IAED;;;;OAIG;IACH,sBAAsB,CAAC,cAAsB;QAC3C,eAAK,CAAC,sBAAsB,CAAC,cAAc,CAAC,CAAC;IAC/C,CAAC;IAED,kBAAkB;IACR,kBAAkB,CAAC,EAAE,GAAG,EAAW;QAC3C,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,iBAAO,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;QAC7C,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IAED,SAAS;QACP,OAAO,IAAI,CAAC,OAAO,KAAK,SAAS,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC;IAC/D,CAAC;IAED;;;OAGG;IACH,cAAc,CAAC,MAAc;QAC3B,IAAI,MAAM,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;YACxB,MAAM,IAAI,gCAAqB,CAAC,+BAA+B,CAAC,CAAC;QACnE,CAAC;IACH,CAAC;CACF;AAxOD,gDAwOC","sourcesContent":["import { avmSerial, pvmSerial, UnsignedTx } from '@flarenetwork/flarejs';\nimport { BaseTransactionBuilder, BuildTransactionError, BaseKey, BaseAddress } from '@bitgo-beta/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { DecodedUtxoObj, Tx } from './iface';\nimport { KeyPair } from './keyPair';\nimport { Transaction } from './transaction';\nimport utils from './utils';\nimport BigNumber from 'bignumber.js';\n\nexport abstract class TransactionBuilder extends BaseTransactionBuilder {\n  protected _transaction: Transaction;\n  protected recoverSigner = false;\n  public _signer: KeyPair[] = [];\n\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n    this._transaction = new Transaction(_coinConfig);\n  }\n\n  /**\n   * Initialize the transaction builder fields using the decoded transaction data\n   *\n   * @param {Transaction} tx the transaction data\n   * @returns itself\n   */\n  initBuilder(tx: Tx): this {\n    const baseTx = ((tx as UnsignedTx).tx as pvmSerial.AddPermissionlessValidatorTx).baseTx;\n\n    // Validate network and blockchain IDs match\n    if (\n      baseTx.NetworkId.value() !== this._transaction._networkID ||\n      baseTx.BlockchainId.value() !== this._transaction._blockchainID\n    ) {\n      throw new Error('Network or blockchain ID mismatch');\n    }\n\n    this._transaction.setTransaction(tx);\n    return this;\n  }\n\n  // region Validators\n  /**\n   * Validates the threshold for multi-signature transactions\n   * @param threshold - Number of required signatures\n   */\n  validateThreshold(threshold: number): void {\n    if (!threshold || threshold !== 2) {\n      throw new BuildTransactionError('Invalid transaction: threshold must be set to 2');\n    }\n  }\n\n  /**\n   * Validates a single UTXO object\n   * @param value - UTXO to validate\n   */\n  validateUtxo(value: DecodedUtxoObj): void {\n    const requiredFields = ['outputID', 'amount', 'txid', 'outputidx'];\n    for (const field of requiredFields) {\n      if (!value.hasOwnProperty(field)) {\n        throw new BuildTransactionError(`UTXO missing required field: ${field}`);\n      }\n    }\n  }\n\n  /**\n   * Validates an array of UTXOs\n   * @param values - Array of UTXOs to validate\n   */\n  validateUtxos(values: DecodedUtxoObj[]): void {\n    if (values.length === 0) {\n      throw new BuildTransactionError('UTXOs array cannot be empty');\n    }\n    values.forEach(this.validateUtxo);\n  }\n\n  /**\n   * Validates the locktime value\n   * @param locktime - Timestamp after which the output can be spent\n   */\n  validateLocktime(locktime: bigint): void {\n    if (locktime < BigInt(0)) {\n      throw new BuildTransactionError('Invalid transaction: locktime must be 0 or higher');\n    }\n  }\n  // endregion\n\n  /**\n   * Sets the threshold for multi-signature transactions\n   * @param value - Number of required signatures\n   */\n  threshold(value: number): this {\n    this.validateThreshold(value);\n    this._transaction._threshold = value;\n    return this;\n  }\n\n  /**\n   * Sets the locktime for the transaction\n   * @param value - Timestamp after which the output can be spent\n   */\n  locktime(value: string | number): this {\n    this.validateLocktime(BigInt(value));\n    this._transaction._locktime = BigInt(value);\n    return this;\n  }\n\n  /**\n   * Enables recovery mode for the transaction\n   * @param recoverSigner - Whether to use recovery signing\n   */\n  recoverMode(recoverSigner = true): this {\n    this.recoverSigner = recoverSigner;\n    return this;\n  }\n\n  /**\n   * Sets the sender's public key(s)\n   * @param senderPubKey - Public key or array of public keys\n   */\n  fromPubKey(senderPubKey: string | string[]): this {\n    const pubKeys = Array.isArray(senderPubKey) ? senderPubKey : [senderPubKey];\n    this._transaction._fromAddresses = pubKeys.map((addr) => utils.parseAddress(addr));\n    return this;\n  }\n\n  /**\n   * Sets the UTXOs for the transaction\n   * @param value - Array of UTXOs to use\n   */\n  utxos(value: DecodedUtxoObj[]): this {\n    this.validateUtxos(value);\n    this._transaction._utxos = value;\n    return this;\n  }\n\n  /** @inheritdoc */\n  protected fromImplementation(rawTransaction: string): Transaction {\n    try {\n      // Parse the raw transaction using Flare's PVM serialization\n      const [tx] = pvmSerial.AddPermissionlessValidatorTx.fromBytes(\n        Buffer.from(rawTransaction, 'hex'),\n        avmSerial.getAVMManager().getDefaultCodec()\n      );\n      this.initBuilder(tx);\n      return this._transaction;\n    } catch (e) {\n      throw new BuildTransactionError(`Failed to parse raw transaction: ${e.message}`);\n    }\n  }\n\n  /**\n   * Abstract method to be implemented by specific transaction builders\n   * Builds the actual transaction based on the builder's configuration\n   */\n  protected abstract buildImplementation(): Promise<Transaction>;\n\n  /**\n   * Check the buffer has 32 byte long.\n   * @param chainID\n   */\n  validateChainId(chainID: Buffer): void {\n    if (chainID.length !== 32) {\n      throw new BuildTransactionError('Chain id are 32 byte size');\n    }\n  }\n\n  /** @inheritdoc */\n  protected get transaction(): Transaction {\n    return this._transaction;\n  }\n\n  protected set transaction(transaction: Transaction) {\n    this._transaction = transaction;\n  }\n\n  /**\n   * Check that fee is greater than 0.\n   * @param {bigint} fee\n   */\n  validateFee(fee: bigint): void {\n    if (fee <= BigInt(0)) {\n      throw new BuildTransactionError('Fee must be greater than 0');\n    }\n  }\n\n  /** @inheritdoc */\n  validateKey({ key }: BaseKey): void {\n    try {\n      new KeyPair({ prv: key });\n    } catch (e) {\n      throw new BuildTransactionError('Invalid key');\n    }\n  }\n\n  /** @inheritdoc */\n  validateTransaction(transaction?: Transaction): void {\n    // throw new NotImplementedError('validateTransaction not implemented');\n  }\n\n  /** @inheritdoc */\n  validateValue(value: BigNumber): void {\n    if (value.isLessThan(0)) {\n      throw new BuildTransactionError('Value cannot be less than zero');\n    }\n  }\n\n  /** @inheritdoc */\n  validateAddress(address: BaseAddress, addressFormat?: string): void {\n    if (!utils.isValidAddress(address.address)) {\n      throw new BuildTransactionError('Invalid address');\n    }\n  }\n\n  /**\n   * Check the raw transaction has a valid format in the blockchain context, throw otherwise.\n   *\n   * @param rawTransaction Transaction in any format\n   */\n  validateRawTransaction(rawTransaction: string): void {\n    utils.validateRawTransaction(rawTransaction);\n  }\n\n  /** @inheritdoc */\n  protected signImplementation({ key }: BaseKey): Transaction {\n    this._signer.push(new KeyPair({ prv: key }));\n    return this.transaction;\n  }\n\n  hasSigner(): boolean {\n    return this._signer !== undefined && this._signer.length > 0;\n  }\n\n  /**\n   * Check the amount is positive.\n   * @param amount\n   */\n  validateAmount(amount: bigint): void {\n    if (amount <= BigInt(0)) {\n      throw new BuildTransactionError('Amount must be greater than 0');\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,57 @@
+import { BaseTransactionBuilderFactory } from '@bitgo-beta/sdk-core';
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { TransactionBuilder } from './transactionBuilder';
+import { ExportInPTxBuilder } from './ExportInPTxBuilder';
+import { ImportInPTxBuilder } from './ImportInPTxBuilder';
+import { ExportInCTxBuilder } from './ExportInCTxBuilder';
+import { ImportInCTxBuilder } from './ImportInCTxBuilder';
+export declare class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    /**
+     * Extract credentials from remaining bytes after transaction using FlareJS codec.
+     * This is the proper way to parse credentials - using the codec's UnpackPrefix method.
+     * @param credentialBytes Remaining bytes after the transaction (starts with numCredentials)
+     * @param codec The FlareJS codec to use for unpacking
+     * @returns Array of parsed credentials
+     */
+    private extractCredentialsWithCodec;
+    /**
+     * Parse a raw transaction buffer using the specified VM manager.
+     * @param rawBuffer The raw transaction buffer
+     * @param vmType The VM type to use for parsing ('EVM' or 'PVM')
+     * @returns Parsed transaction and credentials, or null if parsing fails
+     */
+    private parseWithVM;
+    /**
+     * Create the appropriate transaction builder based on transaction type.
+     * @param tx The parsed transaction
+     * @param rawBuffer The raw transaction buffer
+     * @param credentials The extracted credentials
+     * @param isEVM Whether this is an EVM transaction
+     * @returns The appropriate transaction builder
+     */
+    private createBuilder;
+    /** @inheritdoc */
+    from(raw: string): TransactionBuilder;
+    /** @inheritdoc */
+    getTransferBuilder(): TransactionBuilder;
+    /**
+     * Export Cross chain transfer
+     */
+    getExportInPBuilder(): ExportInPTxBuilder;
+    /**
+     * Import Cross chain transfer
+     */
+    getImportInPBuilder(): ImportInPTxBuilder;
+    /**
+     * Import in C chain Cross chain transfer
+     */
+    getImportInCBuilder(): ImportInCTxBuilder;
+    /**
+     * Export in C chain Cross chain transfer
+     */
+    getExportInCBuilder(): ExportInCTxBuilder;
+    /** @inheritdoc */
+    getWalletInitializationBuilder(): TransactionBuilder;
+}
+//# sourceMappingURL=transactionBuilderFactory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transactionBuilderFactory.d.ts","sourceRoot":"","sources":["../../../src/lib/transactionBuilderFactory.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,6BAA6B,EAAgB,MAAM,sBAAsB,CAAC;AACnF,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAQ1D,qBAAa,yBAA0B,SAAQ,6BAA6B;gBAC9D,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C;;;;;;OAMG;IACH,OAAO,CAAC,2BAA2B;IAwBnC;;;;;OAKG;IACH,OAAO,CAAC,WAAW;IAkBnB;;;;;;;OAOG;IACH,OAAO,CAAC,aAAa;IAgCrB,kBAAkB;IAClB,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,kBAAkB;IAkBrC,kBAAkB;IAClB,kBAAkB,IAAI,kBAAkB;IAIxC;;OAEG;IACH,mBAAmB,IAAI,kBAAkB;IAIzC;;OAEG;IACH,mBAAmB,IAAI,kBAAkB;IAIzC;;OAEG;IACH,mBAAmB,IAAI,kBAAkB;IAIzC;;OAEG;IACH,mBAAmB,IAAI,kBAAkB;IAIzC,kBAAkB;IAClB,8BAA8B,IAAI,kBAAkB;CAGrD"}

package/dist/src/lib/transactionBuilderFactory.js

@@ -0,0 +1,148 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionBuilderFactory = void 0;
+const flarejs_1 = require("@flarenetwork/flarejs");
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const ExportInPTxBuilder_1 = require("./ExportInPTxBuilder");
+const ImportInPTxBuilder_1 = require("./ImportInPTxBuilder");
+const ExportInCTxBuilder_1 = require("./ExportInCTxBuilder");
+const ImportInCTxBuilder_1 = require("./ImportInCTxBuilder");
+const utils_1 = __importDefault(require("./utils"));
+class TransactionBuilderFactory extends sdk_core_1.BaseTransactionBuilderFactory {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+    }
+    /**
+     * Extract credentials from remaining bytes after transaction using FlareJS codec.
+     * This is the proper way to parse credentials - using the codec's UnpackPrefix method.
+     * @param credentialBytes Remaining bytes after the transaction (starts with numCredentials)
+     * @param codec The FlareJS codec to use for unpacking
+     * @returns Array of parsed credentials
+     */
+    extractCredentialsWithCodec(credentialBytes, codec) {
+        const credentials = [];
+        if (credentialBytes.length < 4) {
+            return credentials;
+        }
+        // Skip the first 4 bytes (numCredentials as Int type)
+        // The codec doesn't know about this Int, so we skip it manually
+        let remainingBytes = credentialBytes.slice(4);
+        let moreCredentials = true;
+        do {
+            try {
+                const [credential, rest] = codec.UnpackPrefix(remainingBytes);
+                credentials.push(credential);
+                remainingBytes = rest;
+            }
+            catch {
+                moreCredentials = false;
+            }
+        } while (remainingBytes.length > 0 && moreCredentials);
+        return credentials;
+    }
+    /**
+     * Parse a raw transaction buffer using the specified VM manager.
+     * @param rawBuffer The raw transaction buffer
+     * @param vmType The VM type to use for parsing ('EVM' or 'PVM')
+     * @returns Parsed transaction and credentials, or null if parsing fails
+     */
+    parseWithVM(rawBuffer, vmType) {
+        try {
+            const manager = flarejs_1.utils.getManagerForVM(vmType);
+            const [codec, txBytes] = manager.getCodecFromBuffer(rawBuffer);
+            const [tx, credentialBytes] = codec.UnpackPrefix(txBytes);
+            const credentials = credentialBytes.length > 4 ? this.extractCredentialsWithCodec(credentialBytes, codec) : [];
+            return { tx, credentials };
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Create the appropriate transaction builder based on transaction type.
+     * @param tx The parsed transaction
+     * @param rawBuffer The raw transaction buffer
+     * @param credentials The extracted credentials
+     * @param isEVM Whether this is an EVM transaction
+     * @returns The appropriate transaction builder
+     */
+    createBuilder(tx, rawBuffer, credentials, isEVM) {
+        if (isEVM) {
+            if (ExportInCTxBuilder_1.ExportInCTxBuilder.verifyTxType(tx._type)) {
+                const builder = this.getExportInCBuilder();
+                builder.initBuilder(tx, rawBuffer, credentials);
+                return builder;
+            }
+            if (ImportInCTxBuilder_1.ImportInCTxBuilder.verifyTxType(tx._type)) {
+                const builder = this.getImportInCBuilder();
+                builder.initBuilder(tx, rawBuffer, credentials);
+                return builder;
+            }
+        }
+        else {
+            if (ImportInPTxBuilder_1.ImportInPTxBuilder.verifyTxType(tx._type)) {
+                const builder = this.getImportInPBuilder();
+                builder.initBuilder(tx, rawBuffer, credentials);
+                return builder;
+            }
+            if (ExportInPTxBuilder_1.ExportInPTxBuilder.verifyTxType(tx._type)) {
+                const builder = this.getExportInPBuilder();
+                builder.initBuilder(tx, rawBuffer, credentials);
+                return builder;
+            }
+        }
+        throw new sdk_core_1.NotSupported('Transaction type not supported');
+    }
+    /** @inheritdoc */
+    from(raw) {
+        utils_1.default.validateRawTransaction(raw);
+        const rawBuffer = Buffer.from(utils_1.default.removeHexPrefix(raw), 'hex');
+        // Try EVM first, then fall back to PVM
+        const evmResult = this.parseWithVM(rawBuffer, 'EVM');
+        if (evmResult) {
+            return this.createBuilder(evmResult.tx, rawBuffer, evmResult.credentials, true);
+        }
+        const pvmResult = this.parseWithVM(rawBuffer, 'PVM');
+        if (pvmResult) {
+            return this.createBuilder(pvmResult.tx, rawBuffer, pvmResult.credentials, false);
+        }
+        throw new sdk_core_1.NotSupported('Transaction type not supported');
+    }
+    /** @inheritdoc */
+    getTransferBuilder() {
+        throw new sdk_core_1.NotSupported('Transfer is not supported in P Chain');
+    }
+    /**
+     * Export Cross chain transfer
+     */
+    getExportInPBuilder() {
+        return new ExportInPTxBuilder_1.ExportInPTxBuilder(this._coinConfig);
+    }
+    /**
+     * Import Cross chain transfer
+     */
+    getImportInPBuilder() {
+        return new ImportInPTxBuilder_1.ImportInPTxBuilder(this._coinConfig);
+    }
+    /**
+     * Import in C chain Cross chain transfer
+     */
+    getImportInCBuilder() {
+        return new ImportInCTxBuilder_1.ImportInCTxBuilder(this._coinConfig);
+    }
+    /**
+     * Export in C chain Cross chain transfer
+     */
+    getExportInCBuilder() {
+        return new ExportInCTxBuilder_1.ExportInCTxBuilder(this._coinConfig);
+    }
+    /** @inheritdoc */
+    getWalletInitializationBuilder() {
+        throw new sdk_core_1.NotSupported('Wallet initialization is not needed');
+    }
+}
+exports.TransactionBuilderFactory = TransactionBuilderFactory;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transactionBuilderFactory.js","sourceRoot":"","sources":["../../../src/lib/transactionBuilderFactory.ts"],"names":[],"mappings":"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","sourcesContent":["import { utils as FlareUtils, evmSerial, pvmSerial, Credential } from '@flarenetwork/flarejs';\nimport { BaseTransactionBuilderFactory, NotSupported } from '@bitgo-beta/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { TransactionBuilder } from './transactionBuilder';\nimport { ExportInPTxBuilder } from './ExportInPTxBuilder';\nimport { ImportInPTxBuilder } from './ImportInPTxBuilder';\nimport { ExportInCTxBuilder } from './ExportInCTxBuilder';\nimport { ImportInCTxBuilder } from './ImportInCTxBuilder';\nimport { SerializedTx } from './iface';\nimport utils from './utils';\n\ninterface Codec {\n  UnpackPrefix<T>(bytes: Uint8Array): [T, Uint8Array];\n}\n\nexport class TransactionBuilderFactory extends BaseTransactionBuilderFactory {\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n  }\n\n  /**\n   * Extract credentials from remaining bytes after transaction using FlareJS codec.\n   * This is the proper way to parse credentials - using the codec's UnpackPrefix method.\n   * @param credentialBytes Remaining bytes after the transaction (starts with numCredentials)\n   * @param codec The FlareJS codec to use for unpacking\n   * @returns Array of parsed credentials\n   */\n  private extractCredentialsWithCodec(credentialBytes: Uint8Array, codec: Codec): Credential[] {\n    const credentials: Credential[] = [];\n    if (credentialBytes.length < 4) {\n      return credentials;\n    }\n\n    // Skip the first 4 bytes (numCredentials as Int type)\n    // The codec doesn't know about this Int, so we skip it manually\n    let remainingBytes: Uint8Array = credentialBytes.slice(4);\n    let moreCredentials = true;\n\n    do {\n      try {\n        const [credential, rest] = codec.UnpackPrefix<Credential>(remainingBytes);\n        credentials.push(credential);\n        remainingBytes = rest;\n      } catch {\n        moreCredentials = false;\n      }\n    } while (remainingBytes.length > 0 && moreCredentials);\n\n    return credentials;\n  }\n\n  /**\n   * Parse a raw transaction buffer using the specified VM manager.\n   * @param rawBuffer The raw transaction buffer\n   * @param vmType The VM type to use for parsing ('EVM' or 'PVM')\n   * @returns Parsed transaction and credentials, or null if parsing fails\n   */\n  private parseWithVM(\n    rawBuffer: Buffer,\n    vmType: 'EVM' | 'PVM'\n  ): { tx: SerializedTx; credentials: Credential[] } | null {\n    try {\n      const manager = FlareUtils.getManagerForVM(vmType);\n      const [codec, txBytes] = manager.getCodecFromBuffer(rawBuffer);\n      const [tx, credentialBytes] = (codec as Codec).UnpackPrefix<SerializedTx>(txBytes);\n\n      const credentials =\n        credentialBytes.length > 4 ? this.extractCredentialsWithCodec(credentialBytes, codec as Codec) : [];\n\n      return { tx, credentials };\n    } catch {\n      return null;\n    }\n  }\n\n  /**\n   * Create the appropriate transaction builder based on transaction type.\n   * @param tx The parsed transaction\n   * @param rawBuffer The raw transaction buffer\n   * @param credentials The extracted credentials\n   * @param isEVM Whether this is an EVM transaction\n   * @returns The appropriate transaction builder\n   */\n  private createBuilder(\n    tx: SerializedTx,\n    rawBuffer: Buffer,\n    credentials: Credential[],\n    isEVM: boolean\n  ): TransactionBuilder {\n    if (isEVM) {\n      if (ExportInCTxBuilder.verifyTxType(tx._type)) {\n        const builder = this.getExportInCBuilder();\n        builder.initBuilder(tx as evmSerial.ExportTx, rawBuffer, credentials);\n        return builder;\n      }\n      if (ImportInCTxBuilder.verifyTxType(tx._type)) {\n        const builder = this.getImportInCBuilder();\n        builder.initBuilder(tx as evmSerial.ImportTx, rawBuffer, credentials);\n        return builder;\n      }\n    } else {\n      if (ImportInPTxBuilder.verifyTxType(tx._type)) {\n        const builder = this.getImportInPBuilder();\n        builder.initBuilder(tx as pvmSerial.ImportTx, rawBuffer, credentials);\n        return builder;\n      }\n      if (ExportInPTxBuilder.verifyTxType(tx._type)) {\n        const builder = this.getExportInPBuilder();\n        builder.initBuilder(tx as pvmSerial.ExportTx, rawBuffer, credentials);\n        return builder;\n      }\n    }\n    throw new NotSupported('Transaction type not supported');\n  }\n\n  /** @inheritdoc */\n  from(raw: string): TransactionBuilder {\n    utils.validateRawTransaction(raw);\n    const rawBuffer = Buffer.from(utils.removeHexPrefix(raw), 'hex');\n\n    // Try EVM first, then fall back to PVM\n    const evmResult = this.parseWithVM(rawBuffer, 'EVM');\n    if (evmResult) {\n      return this.createBuilder(evmResult.tx, rawBuffer, evmResult.credentials, true);\n    }\n\n    const pvmResult = this.parseWithVM(rawBuffer, 'PVM');\n    if (pvmResult) {\n      return this.createBuilder(pvmResult.tx, rawBuffer, pvmResult.credentials, false);\n    }\n\n    throw new NotSupported('Transaction type not supported');\n  }\n\n  /** @inheritdoc */\n  getTransferBuilder(): TransactionBuilder {\n    throw new NotSupported('Transfer is not supported in P Chain');\n  }\n\n  /**\n   * Export Cross chain transfer\n   */\n  getExportInPBuilder(): ExportInPTxBuilder {\n    return new ExportInPTxBuilder(this._coinConfig);\n  }\n\n  /**\n   * Import Cross chain transfer\n   */\n  getImportInPBuilder(): ImportInPTxBuilder {\n    return new ImportInPTxBuilder(this._coinConfig);\n  }\n\n  /**\n   * Import in C chain Cross chain transfer\n   */\n  getImportInCBuilder(): ImportInCTxBuilder {\n    return new ImportInCTxBuilder(this._coinConfig);\n  }\n\n  /**\n   * Export in C chain Cross chain transfer\n   */\n  getExportInCBuilder(): ExportInCTxBuilder {\n    return new ExportInCTxBuilder(this._coinConfig);\n  }\n\n  /** @inheritdoc */\n  getWalletInitializationBuilder(): TransactionBuilder {\n    throw new NotSupported('Wallet initialization is not needed');\n  }\n}\n"]}