@bitgo-beta/sdk-coin-flrp 1.0.1-beta.40 → 1.0.1-beta.401

package/dist/src/lib/ExportInCTxBuilder.js

@@ -0,0 +1,150 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExportInCTxBuilder = void 0;
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const atomicInCTransactionBuilder_1 = require("./atomicInCTransactionBuilder");
+const flarejs_1 = require("@flarenetwork/flarejs");
+const utils_1 = __importDefault(require("./utils"));
+const iface_1 = require("./iface");
+class ExportInCTxBuilder extends atomicInCTransactionBuilder_1.AtomicInCTransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+    }
+    /**
+     * UTXOs are not required for Export Tx from C-Chain (uses EVM balance instead).
+     * Override to prevent usage by throwing an error.
+     *
+     * @throws {BuildTransactionError} always throws as UTXOs are not applicable
+     */
+    decodedUtxos(_decodedUtxos) {
+        throw new sdk_core_1.BuildTransactionError('UTXOs are not required for Export Tx from C-Chain');
+    }
+    /**
+     * Set the nonce of C-Chain sender address
+     *
+     * @param {number | string} nonce - number that can be only used once
+     */
+    nonce(nonce) {
+        const nonceBigInt = BigInt(nonce);
+        this.validateNonce(nonceBigInt);
+        this._nonce = nonceBigInt;
+        return this;
+    }
+    /**
+     * Export tx target P wallet.
+     *
+     * @param pAddresses
+     */
+    to(pAddresses) {
+        const pubKeys = Array.isArray(pAddresses) ? pAddresses : pAddresses.split('~');
+        this.transaction._to = pubKeys.map((addr) => utils_1.default.parseAddress(addr));
+        return this;
+    }
+    get transactionType() {
+        return sdk_core_1.TransactionType.Export;
+    }
+    initBuilder(tx, rawBytes, parsedCredentials) {
+        const baseTx = tx;
+        if (!this.verifyTxType(baseTx._type)) {
+            throw new sdk_core_1.NotSupported('Transaction cannot be parsed or has an unsupported transaction type');
+        }
+        const outputs = baseTx.exportedOutputs;
+        if (outputs.length !== 1) {
+            throw new sdk_core_1.BuildTransactionError('Transaction can have one output');
+        }
+        const output = outputs[0];
+        if (Buffer.from(output.assetId.toBytes()).toString('hex') !== this.transaction._assetId) {
+            throw new sdk_core_1.BuildTransactionError('AssetID mismatch');
+        }
+        const inputs = baseTx.ins;
+        if (inputs.length !== 1) {
+            throw new sdk_core_1.BuildTransactionError('Transaction can have one input');
+        }
+        const input = inputs[0];
+        const transferOutput = output.output;
+        const owners = transferOutput.getOwners();
+        this.transaction._to = owners;
+        const inputAmount = input.amount.value();
+        const outputAmount = transferOutput.amount();
+        const fee = inputAmount - outputAmount;
+        this.transaction._amount = outputAmount;
+        this.transaction._fee.fee = fee.toString();
+        this.transaction._fromAddresses = [Buffer.from(input.address.toBytes())];
+        this.transaction._locktime = transferOutput.getLocktime();
+        this._nonce = input.nonce.value();
+        const credentials = parsedCredentials || [];
+        const hasCredentials = credentials.length > 0;
+        if (hasCredentials && rawBytes) {
+            this.transaction._rawSignedBytes = rawBytes;
+        }
+        const fromAddress = new flarejs_1.Address(this.transaction._fromAddresses[0]);
+        const addressMap = new flarejs_1.utils.AddressMap([
+            [fromAddress, 0],
+            [fromAddress, 1],
+        ]);
+        const addressMaps = new flarejs_1.utils.AddressMaps([addressMap]);
+        const unsignedTx = new flarejs_1.UnsignedTx(baseTx, [], addressMaps, credentials.length > 0 ? credentials : [new flarejs_1.Credential([utils_1.default.createNewSig('')])]);
+        this.transaction.setTransaction(unsignedTx);
+        return this;
+    }
+    static verifyTxType(txnType) {
+        return txnType === iface_1.FlareTransactionType.EvmExportTx;
+    }
+    verifyTxType(txnType) {
+        return ExportInCTxBuilder.verifyTxType(txnType);
+    }
+    /**
+     * Build the export in C-chain transaction
+     * @protected
+     */
+    buildFlareTransaction() {
+        if (this.transaction.hasCredentials)
+            return;
+        if (this.transaction._amount === undefined) {
+            throw new sdk_core_1.BuildTransactionError('amount is required');
+        }
+        if (this.transaction._fromAddresses.length !== 1) {
+            throw new sdk_core_1.BuildTransactionError('sender is one and required');
+        }
+        if (this.transaction._to.length === 0) {
+            throw new sdk_core_1.BuildTransactionError('to is required');
+        }
+        if (!this.transaction._fee.fee) {
+            throw new sdk_core_1.BuildTransactionError('fee rate is required');
+        }
+        if (this._nonce === undefined) {
+            throw new sdk_core_1.BuildTransactionError('nonce is required');
+        }
+        if (!this.transaction._context) {
+            throw new sdk_core_1.BuildTransactionError('context is required');
+        }
+        const fee = BigInt(this.transaction._fee.fee);
+        const fromAddressBytes = this.transaction._fromAddresses[0];
+        const sortedToAddresses = [...this.transaction._to].sort((a, b) => {
+            const aHex = Buffer.from(a).toString('hex');
+            const bHex = Buffer.from(b).toString('hex');
+            return aHex.localeCompare(bHex);
+        });
+        const toAddresses = sortedToAddresses.map((addr) => new flarejs_1.Address(addr));
+        const exportEVMOptions = {
+            threshold: this.transaction._threshold,
+            locktime: this.transaction._locktime,
+        };
+        const exportTx = flarejs_1.evm.newExportTxFromBaseFee(this.transaction._context, fee, this.transaction._amount, this.transaction._context.pBlockchainID, fromAddressBytes, toAddresses.map((addr) => Buffer.from(addr.toBytes())), BigInt(this._nonce), utils_1.default.flareIdString(this.transaction._assetId).toString(), exportEVMOptions);
+        this.transaction.setTransaction(exportTx);
+    }
+    /**
+     * Check the nonce is non-negative.
+     * @param nonce
+     */
+    validateNonce(nonce) {
+        if (nonce < BigInt(0)) {
+            throw new sdk_core_1.BuildTransactionError('Nonce must be greater or equal than 0');
+        }
+    }
+}
+exports.ExportInCTxBuilder = ExportInCTxBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ExportInCTxBuilder.js","sourceRoot":"","sources":["../../../src/lib/ExportInCTxBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { BuildTransactionError, NotSupported, TransactionType } from '@bitgo-beta/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { AtomicInCTransactionBuilder } from './atomicInCTransactionBuilder';\nimport {\n  evmSerial,\n  UnsignedTx,\n  Credential,\n  Address,\n  TransferOutput,\n  utils as FlareUtils,\n  evm,\n} from '@flarenetwork/flarejs';\nimport utils from './utils';\nimport { Tx, FlareTransactionType, ExportEVMOptions, DecodedUtxoObj } from './iface';\n\nexport class ExportInCTxBuilder extends AtomicInCTransactionBuilder {\n  private _nonce: bigint;\n\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n  }\n\n  /**\n   * UTXOs are not required for Export Tx from C-Chain (uses EVM balance instead).\n   * Override to prevent usage by throwing an error.\n   *\n   * @throws {BuildTransactionError} always throws as UTXOs are not applicable\n   */\n  decodedUtxos(_decodedUtxos: DecodedUtxoObj[]): this {\n    throw new BuildTransactionError('UTXOs are not required for Export Tx from C-Chain');\n  }\n\n  /**\n   * Set the nonce of C-Chain sender address\n   *\n   * @param {number | string} nonce - number that can be only used once\n   */\n  nonce(nonce: number | string): this {\n    const nonceBigInt = BigInt(nonce);\n    this.validateNonce(nonceBigInt);\n    this._nonce = nonceBigInt;\n    return this;\n  }\n\n  /**\n   * Export tx target P wallet.\n   *\n   * @param pAddresses\n   */\n  to(pAddresses: string | string[]): this {\n    const pubKeys = Array.isArray(pAddresses) ? pAddresses : pAddresses.split('~');\n    this.transaction._to = pubKeys.map((addr) => utils.parseAddress(addr));\n    return this;\n  }\n\n  protected get transactionType(): TransactionType {\n    return TransactionType.Export;\n  }\n\n  initBuilder(tx: Tx, rawBytes?: Buffer, parsedCredentials?: Credential[]): this {\n    const baseTx = tx as evmSerial.ExportTx;\n    if (!this.verifyTxType(baseTx._type)) {\n      throw new NotSupported('Transaction cannot be parsed or has an unsupported transaction type');\n    }\n\n    const outputs = baseTx.exportedOutputs;\n    if (outputs.length !== 1) {\n      throw new BuildTransactionError('Transaction can have one output');\n    }\n    const output = outputs[0];\n\n    if (Buffer.from(output.assetId.toBytes()).toString('hex') !== this.transaction._assetId) {\n      throw new BuildTransactionError('AssetID mismatch');\n    }\n\n    const inputs = baseTx.ins;\n    if (inputs.length !== 1) {\n      throw new BuildTransactionError('Transaction can have one input');\n    }\n    const input = inputs[0];\n\n    const transferOutput = output.output as TransferOutput;\n    const owners = transferOutput.getOwners();\n    this.transaction._to = owners;\n    const inputAmount = input.amount.value();\n    const outputAmount = transferOutput.amount();\n    const fee = inputAmount - outputAmount;\n    this.transaction._amount = outputAmount;\n    this.transaction._fee.fee = fee.toString();\n    this.transaction._fromAddresses = [Buffer.from(input.address.toBytes())];\n    this.transaction._locktime = transferOutput.getLocktime();\n    this._nonce = input.nonce.value();\n    const credentials = parsedCredentials || [];\n    const hasCredentials = credentials.length > 0;\n    if (hasCredentials && rawBytes) {\n      this.transaction._rawSignedBytes = rawBytes;\n    }\n\n    const fromAddress = new Address(this.transaction._fromAddresses[0]);\n    const addressMap = new FlareUtils.AddressMap([\n      [fromAddress, 0],\n      [fromAddress, 1],\n    ]);\n    const addressMaps = new FlareUtils.AddressMaps([addressMap]);\n\n    const unsignedTx = new UnsignedTx(\n      baseTx,\n      [],\n      addressMaps,\n      credentials.length > 0 ? credentials : [new Credential([utils.createNewSig('')])]\n    );\n\n    this.transaction.setTransaction(unsignedTx);\n    return this;\n  }\n\n  static verifyTxType(txnType: string): boolean {\n    return txnType === FlareTransactionType.EvmExportTx;\n  }\n\n  verifyTxType(txnType: string): boolean {\n    return ExportInCTxBuilder.verifyTxType(txnType);\n  }\n\n  /**\n   * Build the export in C-chain transaction\n   * @protected\n   */\n  protected buildFlareTransaction(): void {\n    if (this.transaction.hasCredentials) return;\n    if (this.transaction._amount === undefined) {\n      throw new BuildTransactionError('amount is required');\n    }\n    if (this.transaction._fromAddresses.length !== 1) {\n      throw new BuildTransactionError('sender is one and required');\n    }\n    if (this.transaction._to.length === 0) {\n      throw new BuildTransactionError('to is required');\n    }\n    if (!this.transaction._fee.fee) {\n      throw new BuildTransactionError('fee rate is required');\n    }\n    if (this._nonce === undefined) {\n      throw new BuildTransactionError('nonce is required');\n    }\n    if (!this.transaction._context) {\n      throw new BuildTransactionError('context is required');\n    }\n\n    const fee = BigInt(this.transaction._fee.fee);\n    const fromAddressBytes = this.transaction._fromAddresses[0];\n    const sortedToAddresses = [...this.transaction._to].sort((a, b) => {\n      const aHex = Buffer.from(a).toString('hex');\n      const bHex = Buffer.from(b).toString('hex');\n      return aHex.localeCompare(bHex);\n    });\n    const toAddresses = sortedToAddresses.map((addr) => new Address(addr));\n\n    const exportEVMOptions: ExportEVMOptions = {\n      threshold: this.transaction._threshold,\n      locktime: this.transaction._locktime,\n    };\n\n    const exportTx = evm.newExportTxFromBaseFee(\n      this.transaction._context,\n      fee,\n      this.transaction._amount,\n      this.transaction._context.pBlockchainID,\n      fromAddressBytes,\n      toAddresses.map((addr) => Buffer.from(addr.toBytes())),\n      BigInt(this._nonce),\n      utils.flareIdString(this.transaction._assetId).toString(),\n      exportEVMOptions\n    );\n\n    this.transaction.setTransaction(exportTx);\n  }\n\n  /**\n   * Check the nonce is non-negative.\n   * @param nonce\n   */\n  validateNonce(nonce: bigint): void {\n    if (nonce < BigInt(0)) {\n      throw new BuildTransactionError('Nonce must be greater or equal than 0');\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,28 @@
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { TransactionType } from '@bitgo-beta/sdk-core';
+import { AtomicTransactionBuilder } from './atomicTransactionBuilder';
+import { Credential } from '@flarenetwork/flarejs';
+import { Tx } from './iface';
+export declare class ExportInPTxBuilder extends AtomicTransactionBuilder {
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    protected get transactionType(): TransactionType;
+    initBuilder(tx: Tx, rawBytes?: Buffer, parsedCredentials?: Credential[]): this;
+    static verifyTxType(txnType: string): boolean;
+    verifyTxType(txnType: string): boolean;
+    /**
+     * Build the export transaction for P-chain
+     * Following AVAX P approach for UTXO handling and signature slot assignment.
+     * @protected
+     */
+    protected buildFlareTransaction(): Promise<void>;
+    /**
+     * Recover UTXOs from inputs.
+     * Uses output addresses as proxy for UTXO addresses.
+     *
+     * @param inputs Array of TransferableInput
+     * @param outputAddrs Output owner addresses to use as proxy
+     * @returns Array of decoded UTXO objects
+     */
+    private recoverUtxos;
+}
+//# sourceMappingURL=ExportInPTxBuilder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ExportInPTxBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/ExportInPTxBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAuC,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5F,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AACtE,OAAO,EAQL,UAAU,EAEX,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAmE,EAAE,EAAE,MAAM,SAAS,CAAC;AAE9F,qBAAa,kBAAmB,SAAQ,wBAAwB;gBAClD,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAY7C,SAAS,KAAK,eAAe,IAAI,eAAe,CAE/C;IAED,WAAW,CAAC,EAAE,EAAE,EAAE,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,iBAAiB,CAAC,EAAE,UAAU,EAAE,GAAG,IAAI;IA2E9E,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAI7C,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAItC;;;;OAIG;cACa,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC;IAkGtD;;;;;;;OAOG;IACH,OAAO,CAAC,YAAY;CA4BrB"}

package/dist/src/lib/ExportInPTxBuilder.js

@@ -0,0 +1,190 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExportInPTxBuilder = void 0;
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const atomicTransactionBuilder_1 = require("./atomicTransactionBuilder");
+const flarejs_1 = require("@flarenetwork/flarejs");
+const utils_1 = __importDefault(require("./utils"));
+const iface_1 = require("./iface");
+class ExportInPTxBuilder extends atomicTransactionBuilder_1.AtomicTransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        // For Export FROM P-chain:
+        // - external chain (destination) is C-chain
+        // - blockchain ID (source) is P-chain
+        this._externalChainId = utils_1.default.cb58Decode(this.transaction._network.cChainBlockchainID);
+        // P-chain blockchain ID (from network config - decode from cb58 to hex)
+        this.transaction._blockchainID = Buffer.from(utils_1.default.cb58Decode(this.transaction._network.blockchainID)).toString('hex');
+    }
+    get transactionType() {
+        return sdk_core_1.TransactionType.Export;
+    }
+    initBuilder(tx, rawBytes, parsedCredentials) {
+        const exportTx = tx;
+        if (!this.verifyTxType(exportTx._type)) {
+            throw new sdk_core_1.NotSupported('Transaction cannot be parsed or has an unsupported transaction type');
+        }
+        const outputs = exportTx.outs;
+        if (outputs.length !== 1) {
+            throw new sdk_core_1.BuildTransactionError('Transaction can have one external output');
+        }
+        const output = outputs[0];
+        const outputTransfer = output.output;
+        const assetId = output.assetId.toBytes();
+        if (Buffer.compare(Buffer.from(assetId), Buffer.from(this.transaction._assetId, 'hex')) !== 0) {
+            throw new Error('The Asset ID of the output does not match the transaction');
+        }
+        const outputOwners = outputTransfer.outputOwners;
+        this.transaction._locktime = outputOwners.locktime.value();
+        this.transaction._threshold = outputOwners.threshold.value();
+        this.transaction._fromAddresses = outputOwners.addrs.map((addr) => Buffer.from(addr.toBytes()));
+        this._externalChainId = Buffer.from(exportTx.destination.toBytes());
+        this.transaction._amount = outputTransfer.amount();
+        this.transaction._utxos = this.recoverUtxos([...exportTx.baseTx.inputs], outputOwners.addrs);
+        const totalInputAmount = exportTx.baseTx.inputs.reduce((sum, input) => sum + input.amount(), BigInt(0));
+        const changeOutputAmount = exportTx.baseTx.outputs.reduce((sum, out) => {
+            const transferOut = out.output;
+            return sum + transferOut.amount();
+        }, BigInt(0));
+        const fee = totalInputAmount - changeOutputAmount - this.transaction._amount;
+        this.transaction._fee.fee = fee.toString();
+        const credentials = parsedCredentials || [];
+        const hasCredentials = credentials.length > 0;
+        if (rawBytes && hasCredentials) {
+            this.transaction._rawSignedBytes = rawBytes;
+        }
+        this.computeAddressesIndexFromParsed();
+        // Use parsed credentials if available, otherwise create new ones based on sigIndices
+        // The sigIndices from the parsed transaction (stored in addressesIndex) determine
+        // the correct credential ordering for on-chain verification
+        const txCredentials = credentials.length > 0
+            ? credentials
+            : this.transaction._utxos.map((utxo) => {
+                const utxoThreshold = utxo.threshold || this.transaction._threshold;
+                const sigIndices = utxo.addressesIndex ?? [];
+                // Use sigIndices-based method if we have valid sigIndices from parsed transaction
+                if (sigIndices.length >= utxoThreshold && sigIndices.every((idx) => idx >= 0)) {
+                    return this.createCredentialForUtxoWithSigIndices(utxo, utxoThreshold, sigIndices);
+                }
+                return this.createCredentialForUtxo(utxo, utxoThreshold);
+            });
+        // Create addressMaps using sigIndices from parsed transaction for consistency
+        const addressMaps = this.transaction._utxos.map((utxo) => {
+            const utxoThreshold = utxo.threshold || this.transaction._threshold;
+            const sigIndices = utxo.addressesIndex ?? [];
+            if (sigIndices.length >= utxoThreshold && sigIndices.every((idx) => idx >= 0)) {
+                return this.createAddressMapForUtxoWithSigIndices(utxo, utxoThreshold, sigIndices);
+            }
+            return this.createAddressMapForUtxo(utxo, utxoThreshold);
+        });
+        const unsignedTx = new flarejs_1.UnsignedTx(exportTx, [], new flarejs_1.utils.AddressMaps(addressMaps), txCredentials);
+        this.transaction.setTransaction(unsignedTx);
+        return this;
+    }
+    static verifyTxType(txnType) {
+        return txnType === iface_1.FlareTransactionType.PvmExportTx;
+    }
+    verifyTxType(txnType) {
+        return ExportInPTxBuilder.verifyTxType(txnType);
+    }
+    /**
+     * Build the export transaction for P-chain
+     * Following AVAX P approach for UTXO handling and signature slot assignment.
+     * @protected
+     */
+    async buildFlareTransaction() {
+        if (this.transaction.hasCredentials)
+            return;
+        const feeState = this.transaction._feeState;
+        if (!feeState) {
+            throw new sdk_core_1.BuildTransactionError('Fee state is required');
+        }
+        if (!this.transaction._context) {
+            throw new sdk_core_1.BuildTransactionError('context is required');
+        }
+        if (this.transaction._amount === undefined) {
+            throw new sdk_core_1.BuildTransactionError('amount is required');
+        }
+        if (!this.transaction._utxos || this.transaction._utxos.length === 0) {
+            throw new sdk_core_1.BuildTransactionError('UTXOs are required');
+        }
+        this.computeAddressesIndex();
+        this.validateUtxoAddresses();
+        const assetIdCb58 = utils_1.default.cb58Encode(Buffer.from(this.transaction._assetId, 'hex'));
+        const nativeUtxos = utils_1.default.decodedToUtxos(this.transaction._utxos, assetIdCb58);
+        const totalUtxoAmount = nativeUtxos.reduce((sum, utxo) => {
+            const output = utxo.output;
+            return sum + output.amount();
+        }, BigInt(0));
+        if (totalUtxoAmount < this.transaction._amount) {
+            throw new sdk_core_1.BuildTransactionError(`Insufficient UTXO balance: have ${totalUtxoAmount.toString()} nFLR, need at least ${this.transaction._amount.toString()} nFLR (plus fee)`);
+        }
+        const assetId = utils_1.default.flareIdString(this.transaction._assetId).toString();
+        const fromAddresses = this.transaction._fromAddresses.map((addr) => Buffer.from(addr));
+        const transferableOutput = flarejs_1.TransferableOutput.fromNative(assetId, this.transaction._amount, fromAddresses, this.transaction._locktime, this.transaction._threshold);
+        const exportTx = flarejs_1.pvm.e.newExportTx({
+            feeState,
+            fromAddressesBytes: this.transaction._fromAddresses.map((addr) => Buffer.from(addr)),
+            destinationChainId: this.transaction._network.cChainBlockchainID,
+            outputs: [transferableOutput],
+            utxos: nativeUtxos,
+        }, this.transaction._context);
+        const flareUnsignedTx = exportTx;
+        const innerTx = flareUnsignedTx.getTx();
+        const utxosWithIndex = innerTx.baseTx.inputs.map((input) => {
+            const inputTxid = utils_1.default.cb58Encode(Buffer.from(input.utxoID.txID.toBytes()));
+            const inputOutputIdx = input.utxoID.outputIdx.value().toString();
+            const originalUtxo = this.transaction._utxos.find((utxo) => utxo.txid === inputTxid && utxo.outputidx === inputOutputIdx);
+            if (!originalUtxo) {
+                throw new sdk_core_1.BuildTransactionError(`Could not find matching UTXO for input ${inputTxid}:${inputOutputIdx}`);
+            }
+            const transferInput = input.input;
+            const actualSigIndices = transferInput.sigIndicies();
+            return {
+                ...originalUtxo,
+                addressesIndex: originalUtxo.addressesIndex,
+                addresses: originalUtxo.addresses,
+                threshold: originalUtxo.threshold || this.transaction._threshold,
+                actualSigIndices,
+            };
+        });
+        this.transaction._utxos = utxosWithIndex;
+        const txCredentials = utxosWithIndex.map((utxo) => this.createCredentialForUtxoWithSigIndices(utxo, utxo.threshold, utxo.actualSigIndices));
+        const addressMaps = utxosWithIndex.map((utxo) => this.createAddressMapForUtxoWithSigIndices(utxo, utxo.threshold, utxo.actualSigIndices));
+        const fixedUnsignedTx = new flarejs_1.UnsignedTx(innerTx, [], new flarejs_1.utils.AddressMaps(addressMaps), txCredentials);
+        this.transaction.setTransaction(fixedUnsignedTx);
+    }
+    /**
+     * Recover UTXOs from inputs.
+     * Uses output addresses as proxy for UTXO addresses.
+     *
+     * @param inputs Array of TransferableInput
+     * @param outputAddrs Output owner addresses to use as proxy
+     * @returns Array of decoded UTXO objects
+     */
+    recoverUtxos(inputs, outputAddrs) {
+        const proxyAddresses = outputAddrs
+            ? outputAddrs.map((addr) => utils_1.default.addressToString(this.transaction._network.hrp, this.transaction._network.alias, Buffer.from(addr.toBytes())))
+            : [];
+        return inputs.map((input) => {
+            const utxoId = input.utxoID;
+            const transferInput = input.input;
+            const sigIndicies = transferInput.sigIndicies();
+            const utxo = {
+                outputID: iface_1.SECP256K1_Transfer_Output,
+                amount: input.amount().toString(),
+                txid: utils_1.default.cb58Encode(Buffer.from(utxoId.txID.toBytes())),
+                outputidx: utxoId.outputIdx.value().toString(),
+                threshold: sigIndicies.length || this.transaction._threshold,
+                addresses: proxyAddresses,
+                addressesIndex: sigIndicies,
+            };
+            return utxo;
+        });
+    }
+}
+exports.ExportInPTxBuilder = ExportInPTxBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ExportInPTxBuilder.js","sourceRoot":"","sources":["../../../src/lib/ExportInPTxBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { BuildTransactionError, NotSupported, TransactionType } from '@bitgo-beta/sdk-core';\nimport { AtomicTransactionBuilder } from './atomicTransactionBuilder';\nimport {\n  pvmSerial,\n  UnsignedTx,\n  TransferableInput,\n  TransferableOutput,\n  TransferInput,\n  utils as FlareUtils,\n  TransferOutput,\n  Credential,\n  pvm,\n} from '@flarenetwork/flarejs';\nimport utils from './utils';\nimport { DecodedUtxoObj, SECP256K1_Transfer_Output, FlareTransactionType, Tx } from './iface';\n\nexport class ExportInPTxBuilder extends AtomicTransactionBuilder {\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n    // For Export FROM P-chain:\n    // - external chain (destination) is C-chain\n    // - blockchain ID (source) is P-chain\n    this._externalChainId = utils.cb58Decode(this.transaction._network.cChainBlockchainID);\n    // P-chain blockchain ID (from network config - decode from cb58 to hex)\n    this.transaction._blockchainID = Buffer.from(utils.cb58Decode(this.transaction._network.blockchainID)).toString(\n      'hex'\n    );\n  }\n\n  protected get transactionType(): TransactionType {\n    return TransactionType.Export;\n  }\n\n  initBuilder(tx: Tx, rawBytes?: Buffer, parsedCredentials?: Credential[]): this {\n    const exportTx = tx as pvmSerial.ExportTx;\n\n    if (!this.verifyTxType(exportTx._type)) {\n      throw new NotSupported('Transaction cannot be parsed or has an unsupported transaction type');\n    }\n    const outputs = exportTx.outs;\n    if (outputs.length !== 1) {\n      throw new BuildTransactionError('Transaction can have one external output');\n    }\n\n    const output = outputs[0];\n    const outputTransfer = output.output as TransferOutput;\n    const assetId = output.assetId.toBytes();\n    if (Buffer.compare(Buffer.from(assetId), Buffer.from(this.transaction._assetId, 'hex')) !== 0) {\n      throw new Error('The Asset ID of the output does not match the transaction');\n    }\n\n    const outputOwners = outputTransfer.outputOwners;\n    this.transaction._locktime = outputOwners.locktime.value();\n    this.transaction._threshold = outputOwners.threshold.value();\n    this.transaction._fromAddresses = outputOwners.addrs.map((addr) => Buffer.from(addr.toBytes()));\n    this._externalChainId = Buffer.from(exportTx.destination.toBytes());\n    this.transaction._amount = outputTransfer.amount();\n\n    this.transaction._utxos = this.recoverUtxos([...exportTx.baseTx.inputs], outputOwners.addrs);\n\n    const totalInputAmount = exportTx.baseTx.inputs.reduce((sum, input) => sum + input.amount(), BigInt(0));\n    const changeOutputAmount = exportTx.baseTx.outputs.reduce((sum, out) => {\n      const transferOut = out.output as TransferOutput;\n      return sum + transferOut.amount();\n    }, BigInt(0));\n    const fee = totalInputAmount - changeOutputAmount - this.transaction._amount;\n    this.transaction._fee.fee = fee.toString();\n\n    const credentials = parsedCredentials || [];\n    const hasCredentials = credentials.length > 0;\n\n    if (rawBytes && hasCredentials) {\n      this.transaction._rawSignedBytes = rawBytes;\n    }\n\n    this.computeAddressesIndexFromParsed();\n\n    // Use parsed credentials if available, otherwise create new ones based on sigIndices\n    // The sigIndices from the parsed transaction (stored in addressesIndex) determine\n    // the correct credential ordering for on-chain verification\n    const txCredentials =\n      credentials.length > 0\n        ? credentials\n        : this.transaction._utxos.map((utxo) => {\n            const utxoThreshold = utxo.threshold || this.transaction._threshold;\n            const sigIndices = utxo.addressesIndex ?? [];\n            // Use sigIndices-based method if we have valid sigIndices from parsed transaction\n            if (sigIndices.length >= utxoThreshold && sigIndices.every((idx) => idx >= 0)) {\n              return this.createCredentialForUtxoWithSigIndices(utxo, utxoThreshold, sigIndices);\n            }\n            return this.createCredentialForUtxo(utxo, utxoThreshold);\n          });\n\n    // Create addressMaps using sigIndices from parsed transaction for consistency\n    const addressMaps = this.transaction._utxos.map((utxo) => {\n      const utxoThreshold = utxo.threshold || this.transaction._threshold;\n      const sigIndices = utxo.addressesIndex ?? [];\n      if (sigIndices.length >= utxoThreshold && sigIndices.every((idx) => idx >= 0)) {\n        return this.createAddressMapForUtxoWithSigIndices(utxo, utxoThreshold, sigIndices);\n      }\n      return this.createAddressMapForUtxo(utxo, utxoThreshold);\n    });\n\n    const unsignedTx = new UnsignedTx(exportTx, [], new FlareUtils.AddressMaps(addressMaps), txCredentials);\n    this.transaction.setTransaction(unsignedTx);\n    return this;\n  }\n\n  static verifyTxType(txnType: string): boolean {\n    return txnType === FlareTransactionType.PvmExportTx;\n  }\n\n  verifyTxType(txnType: string): boolean {\n    return ExportInPTxBuilder.verifyTxType(txnType);\n  }\n\n  /**\n   * Build the export transaction for P-chain\n   * Following AVAX P approach for UTXO handling and signature slot assignment.\n   * @protected\n   */\n  protected async buildFlareTransaction(): Promise<void> {\n    if (this.transaction.hasCredentials) return;\n\n    const feeState = this.transaction._feeState;\n    if (!feeState) {\n      throw new BuildTransactionError('Fee state is required');\n    }\n    if (!this.transaction._context) {\n      throw new BuildTransactionError('context is required');\n    }\n    if (this.transaction._amount === undefined) {\n      throw new BuildTransactionError('amount is required');\n    }\n    if (!this.transaction._utxos || this.transaction._utxos.length === 0) {\n      throw new BuildTransactionError('UTXOs are required');\n    }\n\n    this.computeAddressesIndex();\n\n    this.validateUtxoAddresses();\n\n    const assetIdCb58 = utils.cb58Encode(Buffer.from(this.transaction._assetId, 'hex'));\n    const nativeUtxos = utils.decodedToUtxos(this.transaction._utxos, assetIdCb58);\n\n    const totalUtxoAmount = nativeUtxos.reduce((sum, utxo) => {\n      const output = utxo.output as TransferOutput;\n      return sum + output.amount();\n    }, BigInt(0));\n\n    if (totalUtxoAmount < this.transaction._amount) {\n      throw new BuildTransactionError(\n        `Insufficient UTXO balance: have ${totalUtxoAmount.toString()} nFLR, need at least ${this.transaction._amount.toString()} nFLR (plus fee)`\n      );\n    }\n\n    const assetId = utils.flareIdString(this.transaction._assetId).toString();\n    const fromAddresses = this.transaction._fromAddresses.map((addr) => Buffer.from(addr));\n    const transferableOutput = TransferableOutput.fromNative(\n      assetId,\n      this.transaction._amount,\n      fromAddresses,\n      this.transaction._locktime,\n      this.transaction._threshold\n    );\n\n    const exportTx = pvm.e.newExportTx(\n      {\n        feeState,\n        fromAddressesBytes: this.transaction._fromAddresses.map((addr) => Buffer.from(addr)),\n        destinationChainId: this.transaction._network.cChainBlockchainID,\n        outputs: [transferableOutput],\n        utxos: nativeUtxos,\n      },\n      this.transaction._context\n    );\n\n    const flareUnsignedTx = exportTx as UnsignedTx;\n    const innerTx = flareUnsignedTx.getTx() as pvmSerial.ExportTx;\n\n    const utxosWithIndex = innerTx.baseTx.inputs.map((input) => {\n      const inputTxid = utils.cb58Encode(Buffer.from(input.utxoID.txID.toBytes()));\n      const inputOutputIdx = input.utxoID.outputIdx.value().toString();\n\n      const originalUtxo = this.transaction._utxos.find(\n        (utxo) => utxo.txid === inputTxid && utxo.outputidx === inputOutputIdx\n      );\n\n      if (!originalUtxo) {\n        throw new BuildTransactionError(`Could not find matching UTXO for input ${inputTxid}:${inputOutputIdx}`);\n      }\n\n      const transferInput = input.input as TransferInput;\n      const actualSigIndices = transferInput.sigIndicies();\n\n      return {\n        ...originalUtxo,\n        addressesIndex: originalUtxo.addressesIndex,\n        addresses: originalUtxo.addresses,\n        threshold: originalUtxo.threshold || this.transaction._threshold,\n        actualSigIndices,\n      };\n    });\n\n    this.transaction._utxos = utxosWithIndex;\n\n    const txCredentials = utxosWithIndex.map((utxo) =>\n      this.createCredentialForUtxoWithSigIndices(utxo, utxo.threshold, utxo.actualSigIndices)\n    );\n\n    const addressMaps = utxosWithIndex.map((utxo) =>\n      this.createAddressMapForUtxoWithSigIndices(utxo, utxo.threshold, utxo.actualSigIndices)\n    );\n\n    const fixedUnsignedTx = new UnsignedTx(innerTx, [], new FlareUtils.AddressMaps(addressMaps), txCredentials);\n\n    this.transaction.setTransaction(fixedUnsignedTx);\n  }\n\n  /**\n   * Recover UTXOs from inputs.\n   * Uses output addresses as proxy for UTXO addresses.\n   *\n   * @param inputs Array of TransferableInput\n   * @param outputAddrs Output owner addresses to use as proxy\n   * @returns Array of decoded UTXO objects\n   */\n  private recoverUtxos(inputs: TransferableInput[], outputAddrs?: { toBytes(): Uint8Array }[]): DecodedUtxoObj[] {\n    const proxyAddresses = outputAddrs\n      ? outputAddrs.map((addr) =>\n          utils.addressToString(\n            this.transaction._network.hrp,\n            this.transaction._network.alias,\n            Buffer.from(addr.toBytes())\n          )\n        )\n      : [];\n\n    return inputs.map((input) => {\n      const utxoId = input.utxoID;\n      const transferInput = input.input as TransferInput;\n      const sigIndicies = transferInput.sigIndicies();\n\n      const utxo: DecodedUtxoObj = {\n        outputID: SECP256K1_Transfer_Output,\n        amount: input.amount().toString(),\n        txid: utils.cb58Encode(Buffer.from(utxoId.txID.toBytes())),\n        outputidx: utxoId.outputIdx.value().toString(),\n        threshold: sigIndicies.length || this.transaction._threshold,\n        addresses: proxyAddresses,\n        addressesIndex: sigIndicies,\n      };\n      return utxo;\n    });\n  }\n}\n"]}

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

@@ -0,0 +1,34 @@
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { TransactionType } from '@bitgo-beta/sdk-core';
+import { AtomicInCTransactionBuilder } from './atomicInCTransactionBuilder';
+import { Credential } from '@flarenetwork/flarejs';
+import { Tx } from './iface';
+export declare class ImportInCTxBuilder extends AtomicInCTransactionBuilder {
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    /**
+     * C-chain address who is target of the import.
+     * Address format is eth like
+     * @param {string} cAddress
+     */
+    to(cAddress: string): this;
+    protected get transactionType(): TransactionType;
+    initBuilder(tx: Tx, rawBytes?: Buffer, parsedCredentials?: Credential[]): this;
+    static verifyTxType(txnType: string): boolean;
+    verifyTxType(txnType: string): boolean;
+    /**
+     * Build the import in C-chain transaction
+     * Following AVAX P approach for UTXO handling and signature slot assignment.
+     * @protected
+     */
+    protected buildFlareTransaction(): void;
+    /**
+     * Recover UTXOs from imported inputs.
+     * Uses fromAddresses as proxy for UTXO addresses since they should be the same
+     * addresses controlling the multisig.
+     *
+     * @param importedInputs Array of transferable inputs
+     * @returns Array of decoded UTXO objects
+     */
+    private recoverUtxos;
+}
+//# sourceMappingURL=ImportInCTxBuilder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ImportInCTxBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/ImportInCTxBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAuC,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5F,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAGL,UAAU,EAMX,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAmE,EAAE,EAAE,MAAM,SAAS,CAAC;AAE9F,qBAAa,kBAAmB,SAAQ,2BAA2B;gBACrD,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C;;;;OAIG;IACH,EAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAK1B,SAAS,KAAK,eAAe,IAAI,eAAe,CAE/C;IAED,WAAW,CAAC,EAAE,EAAE,EAAE,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,iBAAiB,CAAC,EAAE,UAAU,EAAE,GAAG,IAAI;IA4E9E,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAI7C,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAItC;;;;OAIG;IACH,SAAS,CAAC,qBAAqB,IAAI,IAAI;IA8FvC;;;;;;;OAOG;IACH,OAAO,CAAC,YAAY;CAyBrB"}