@bitgo-beta/sdk-coin-flrp 1.0.1-beta.35 → 1.0.1-beta.350

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

@@ -0,0 +1,63 @@
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { TransactionType } from '@bitgo-beta/sdk-core';
+import { AtomicInCTransactionBuilder } from './atomicInCTransactionBuilder';
+import { Credential, TransferableInput } 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
+     * @protected
+     */
+    protected buildFlareTransaction(): void;
+    /**
+     * Create inputs from UTXOs
+     * @return {
+     *     inputs: TransferableInput[];
+     *     credentials: Credential[];
+     *     amount: bigint;
+     * }
+     */
+    protected createInputs(): {
+        inputs: TransferableInput[];
+        credentials: Credential[];
+        amount: bigint;
+    };
+    /**
+     * Calculate the import cost for C-chain import transactions
+     * Matches AVAXP's costImportTx formula:
+     * - Base byte cost: transactionSize * txBytesGas (1 gas per byte)
+     * - Per-input cost: numInputs * costPerSignature (1000 per signature) * threshold
+     * - Fixed fee: 10000
+     *
+     * This returns cost "units" to be multiplied by feeRate, matching AVAXP's approach:
+     * AVAXP: fee = feeRate.muln(costImportTx(tx))
+     * FLRP:  fee = feeRate * calculateImportCost(tx)
+     *
+     * @param tx The ImportTx to calculate the cost for
+     * @returns The total cost units
+     */
+    private calculateImportCost;
+    /**
+     * Calculate the fee size for the transaction (for backwards compatibility)
+     * For C-chain imports, the feeRate is treated as an absolute fee value
+     */
+    private calculateFeeSize;
+    /**
+     * Recover UTXOs from imported inputs
+     * @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,EAIV,iBAAiB,EAIlB,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;IAyG9E,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAI7C,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAItC;;;OAGG;IACH,SAAS,CAAC,qBAAqB,IAAI,IAAI;IA0EvC;;;;;;;OAOG;IACH,SAAS,CAAC,YAAY,IAAI;QACxB,MAAM,EAAE,iBAAiB,EAAE,CAAC;QAC5B,WAAW,EAAE,UAAU,EAAE,CAAC;QAC1B,MAAM,EAAE,MAAM,CAAC;KAChB;IAqDD;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,mBAAmB;IAsB3B;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAWxB;;;;OAIG;IACH,OAAO,CAAC,YAAY;CAiBrB"}

package/dist/src/lib/ImportInCTxBuilder.js

@@ -0,0 +1,280 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportInCTxBuilder = 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 ImportInCTxBuilder extends atomicInCTransactionBuilder_1.AtomicInCTransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+    }
+    /**
+     * C-chain address who is target of the import.
+     * Address format is eth like
+     * @param {string} cAddress
+     */
+    to(cAddress) {
+        this.transaction._to = [utils_1.default.parseAddress(cAddress)];
+        return this;
+    }
+    get transactionType() {
+        return sdk_core_1.TransactionType.Import;
+    }
+    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');
+        }
+        // The outputs is a single C-Chain address result.
+        // It's expected to have only one output to the destination C-Chain address.
+        const outputs = baseTx.Outs;
+        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 Error('AssetID are not equals');
+        }
+        this.transaction._to = [Buffer.from(output.address.toBytes())];
+        const inputs = baseTx.importedInputs;
+        this.transaction._utxos = this.recoverUtxos(inputs);
+        // Calculate total input and output amounts
+        const totalInputAmount = inputs.reduce((t, i) => t + i.amount(), BigInt(0));
+        const totalOutputAmount = output.amount.value();
+        // Calculate fee based on input/output difference
+        const fee = totalInputAmount - totalOutputAmount;
+        const feeSize = this.calculateFeeSize(baseTx);
+        // Use integer division to ensure feeRate can be converted back to BigInt
+        const feeRate = Math.floor(Number(fee) / feeSize);
+        this.transaction._fee = {
+            fee: fee.toString(),
+            feeRate: feeRate,
+            size: feeSize,
+        };
+        // Use credentials passed from TransactionBuilderFactory (properly extracted using codec)
+        const credentials = parsedCredentials || [];
+        const hasCredentials = credentials.length > 0;
+        // If it's a signed transaction, store the original raw bytes to preserve exact format
+        if (hasCredentials && rawBytes) {
+            this.transaction._rawSignedBytes = rawBytes;
+        }
+        // Extract threshold from first input's sigIndicies (number of required signatures)
+        const firstInput = inputs[0];
+        const inputThreshold = firstInput.sigIndicies().length || this.transaction._threshold;
+        this.transaction._threshold = inputThreshold;
+        // Create AddressMaps based on signature slot order (matching credential order), not sorted addresses
+        // This matches the approach used in credentials: addressesIndex determines signature order
+        // AddressMaps should map addresses to signature slots in the same order as credentials
+        // If _fromAddresses is available, create AddressMap based on UTXO order (matching credential order)
+        // Otherwise, fall back to mapping just the output address
+        const firstUtxo = this.transaction._utxos[0];
+        let addressMap;
+        if (firstUtxo &&
+            firstUtxo.addresses &&
+            firstUtxo.addresses.length > 0 &&
+            this.transaction._fromAddresses &&
+            this.transaction._fromAddresses.length >= this.transaction._threshold) {
+            // Use centralized method for AddressMap creation
+            addressMap = this.createAddressMapForUtxo(firstUtxo, this.transaction._threshold);
+        }
+        else {
+            // Fallback: map output address to slot 0 (for C-chain imports, output is the destination)
+            // Or map addresses sequentially if _fromAddresses is available but UTXO addresses are not
+            addressMap = new flarejs_1.utils.AddressMap();
+            if (this.transaction._fromAddresses && this.transaction._fromAddresses.length >= this.transaction._threshold) {
+                this.transaction._fromAddresses.slice(0, this.transaction._threshold).forEach((addr, i) => {
+                    addressMap.set(new flarejs_1.Address(addr), i);
+                });
+            }
+            else {
+                // Last resort: map output address
+                const toAddress = new flarejs_1.Address(output.address.toBytes());
+                addressMap.set(toAddress, 0);
+            }
+        }
+        const addressMaps = new flarejs_1.utils.AddressMaps([addressMap]);
+        // When credentials were extracted, use them directly to preserve existing signatures
+        // For initBuilder, _fromAddresses may not be set yet, so use all zeros for credential slots
+        let txCredentials;
+        if (credentials.length > 0) {
+            txCredentials = credentials;
+        }
+        else {
+            // Create empty credential with threshold number of signature slots (all zeros)
+            const emptySignatures = [];
+            for (let i = 0; i < inputThreshold; i++) {
+                emptySignatures.push(utils_1.default.createNewSig(''));
+            }
+            txCredentials = [new flarejs_1.Credential(emptySignatures)];
+        }
+        const unsignedTx = new flarejs_1.UnsignedTx(baseTx, [], addressMaps, txCredentials);
+        this.transaction.setTransaction(unsignedTx);
+        return this;
+    }
+    static verifyTxType(txnType) {
+        return txnType === iface_1.FlareTransactionType.EvmImportTx;
+    }
+    verifyTxType(txnType) {
+        return ImportInCTxBuilder.verifyTxType(txnType);
+    }
+    /**
+     * Build the import in C-chain transaction
+     * @protected
+     */
+    buildFlareTransaction() {
+        // if tx has credentials or was already recovered from raw, tx shouldn't change
+        if (this.transaction.hasCredentials)
+            return;
+        if (this.transaction._to.length !== 1) {
+            throw new Error('to is required');
+        }
+        if (!this.transaction._fee.feeRate) {
+            throw new Error('fee rate is required');
+        }
+        const { inputs, amount, credentials } = this.createInputs();
+        // Calculate import cost units (matching AVAXP's costImportTx approach)
+        // Create a temporary transaction to calculate the actual cost units
+        const tempOutput = new flarejs_1.evmSerial.Output(new flarejs_1.Address(this.transaction._to[0]), new flarejs_1.BigIntPr(amount), new flarejs_1.Id(new Uint8Array(Buffer.from(this.transaction._assetId, 'hex'))));
+        const tempImportTx = new flarejs_1.evmSerial.ImportTx(new flarejs_1.Int(this.transaction._networkID), new flarejs_1.Id(new Uint8Array(Buffer.from(this.transaction._blockchainID, 'hex'))), new flarejs_1.Id(new Uint8Array(this._externalChainId)), inputs, [tempOutput]);
+        // Calculate the import cost units (matches AVAXP's feeSize from costImportTx)
+        const feeSize = this.calculateImportCost(tempImportTx);
+        // Multiply feeRate by cost units (matching AVAXP: fee = feeRate.muln(feeSize))
+        const feeRate = BigInt(this.transaction._fee.feeRate);
+        const fee = feeRate * BigInt(feeSize);
+        this.transaction._fee.fee = fee.toString();
+        this.transaction._fee.size = feeSize;
+        // Create EVM output using proper FlareJS class with amount minus fee
+        const output = new flarejs_1.evmSerial.Output(new flarejs_1.Address(this.transaction._to[0]), new flarejs_1.BigIntPr(amount - fee), new flarejs_1.Id(new Uint8Array(Buffer.from(this.transaction._assetId, 'hex'))));
+        // Create the import transaction
+        const importTx = new flarejs_1.evmSerial.ImportTx(new flarejs_1.Int(this.transaction._networkID), new flarejs_1.Id(new Uint8Array(Buffer.from(this.transaction._blockchainID, 'hex'))), new flarejs_1.Id(new Uint8Array(this._externalChainId)), inputs, [output]);
+        // Create AddressMaps based on signature slot order (matching credential order), not sorted addresses
+        // This matches the approach used in credentials: addressesIndex determines signature order
+        // AddressMaps should map addresses to signature slots in the same order as credentials
+        // For C-chain imports, we typically have one input, so use the first UTXO
+        // Use centralized method for AddressMap creation
+        const firstUtxo = this.transaction._utxos[0];
+        const addressMap = firstUtxo
+            ? this.createAddressMapForUtxo(firstUtxo, this.transaction._threshold)
+            : new flarejs_1.utils.AddressMap();
+        const addressMaps = new flarejs_1.utils.AddressMaps([addressMap]);
+        const unsignedTx = new flarejs_1.UnsignedTx(importTx, [], // Empty UTXOs array, will be filled during processing
+        addressMaps, credentials);
+        this.transaction.setTransaction(unsignedTx);
+    }
+    /**
+     * Create inputs from UTXOs
+     * @return {
+     *     inputs: TransferableInput[];
+     *     credentials: Credential[];
+     *     amount: bigint;
+     * }
+     */
+    createInputs() {
+        const sender = this.transaction._fromAddresses.slice();
+        if (this.recoverSigner) {
+            // switch first and last signer
+            const tmp = sender.pop();
+            sender.push(sender[0]);
+            if (tmp) {
+                sender[0] = tmp;
+            }
+        }
+        let totalAmount = BigInt(0);
+        const inputs = [];
+        const credentials = [];
+        this.transaction._utxos.forEach((utxo) => {
+            const amount = BigInt(utxo.amount);
+            totalAmount += amount;
+            // Create signature indices for threshold
+            const sigIndices = [];
+            for (let i = 0; i < this.transaction._threshold; i++) {
+                sigIndices.push(i);
+            }
+            // Use fromNative to create TransferableInput (same pattern as ImportInPTxBuilder)
+            // fromNative expects cb58-encoded strings for txId and assetId
+            const txIdCb58 = utxo.txid; // Already cb58 encoded
+            const assetIdCb58 = utils_1.default.cb58Encode(Buffer.from(this.transaction._assetId, 'hex'));
+            const transferableInput = flarejs_1.TransferableInput.fromNative(txIdCb58, Number(utxo.outputidx), assetIdCb58, amount, sigIndices);
+            inputs.push(transferableInput);
+            // Create credential with empty signatures for slot identification
+            // Match avaxp behavior: dynamic ordering based on addressesIndex from UTXO
+            // Use centralized method for credential creation
+            credentials.push(this.createCredentialForUtxo(utxo, this.transaction._threshold));
+        });
+        return {
+            inputs,
+            credentials,
+            amount: totalAmount,
+        };
+    }
+    /**
+     * Calculate the import cost for C-chain import transactions
+     * Matches AVAXP's costImportTx formula:
+     * - Base byte cost: transactionSize * txBytesGas (1 gas per byte)
+     * - Per-input cost: numInputs * costPerSignature (1000 per signature) * threshold
+     * - Fixed fee: 10000
+     *
+     * This returns cost "units" to be multiplied by feeRate, matching AVAXP's approach:
+     * AVAXP: fee = feeRate.muln(costImportTx(tx))
+     * FLRP:  fee = feeRate * calculateImportCost(tx)
+     *
+     * @param tx The ImportTx to calculate the cost for
+     * @returns The total cost units
+     */
+    calculateImportCost(tx) {
+        const codec = flarejs_1.avmSerial.getAVMManager().getDefaultCodec();
+        const txBytes = tx.toBytes(codec);
+        // Base byte cost: 1 gas per byte (matching AVAX txBytesGas)
+        const txBytesGas = 1;
+        let bytesCost = txBytes.length * txBytesGas;
+        // Per-input cost: costPerSignature (1000) per signature
+        const costPerSignature = 1000;
+        const numInputs = tx.importedInputs.length;
+        const numSignatures = this.transaction._threshold; // Each input requires threshold signatures
+        const inputCost = numInputs * costPerSignature * numSignatures;
+        bytesCost += inputCost;
+        // Fixed fee component
+        const fixedFee = 10000;
+        const totalCost = bytesCost + fixedFee;
+        return totalCost;
+    }
+    /**
+     * Calculate the fee size for the transaction (for backwards compatibility)
+     * For C-chain imports, the feeRate is treated as an absolute fee value
+     */
+    calculateFeeSize(tx) {
+        // If tx is provided, calculate based on actual transaction size
+        if (tx) {
+            const codec = flarejs_1.avmSerial.getAVMManager().getDefaultCodec();
+            return tx.toBytes(codec).length;
+        }
+        // For C-chain imports, treat feeRate as the absolute fee (multiplier of 1)
+        return 1;
+    }
+    /**
+     * Recover UTXOs from imported inputs
+     * @param importedInputs Array of transferable inputs
+     * @returns Array of decoded UTXO objects
+     */
+    recoverUtxos(importedInputs) {
+        return importedInputs.map((input) => {
+            const txid = input.utxoID.toString();
+            const outputidx = input.utxoID.outputIdx.toString();
+            return {
+                outputID: iface_1.SECP256K1_Transfer_Output,
+                amount: input.amount().toString(),
+                txid: utils_1.default.cb58Encode(Buffer.from(txid, 'hex')),
+                outputidx: outputidx,
+                threshold: this.transaction._threshold,
+                addresses: this.transaction._fromAddresses.map((addr) => utils_1.default.addressToString(this.transaction._network.hrp, this.transaction._network.alias, Buffer.from(addr))),
+            };
+        });
+    }
+}
+exports.ImportInCTxBuilder = ImportInCTxBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ImportInCTxBuilder.js","sourceRoot":"","sources":["../../../src/lib/ImportInCTxBuilder.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 { AtomicInCTransactionBuilder } from './atomicInCTransactionBuilder';\nimport {\n  evmSerial,\n  UnsignedTx,\n  Credential,\n  BigIntPr,\n  Int,\n  Id,\n  TransferableInput,\n  Address,\n  utils as FlareUtils,\n  avmSerial,\n} from '@flarenetwork/flarejs';\nimport utils from './utils';\nimport { DecodedUtxoObj, FlareTransactionType, SECP256K1_Transfer_Output, Tx } from './iface';\n\nexport class ImportInCTxBuilder extends AtomicInCTransactionBuilder {\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n  }\n\n  /**\n   * C-chain address who is target of the import.\n   * Address format is eth like\n   * @param {string} cAddress\n   */\n  to(cAddress: string): this {\n    this.transaction._to = [utils.parseAddress(cAddress)];\n    return this;\n  }\n\n  protected get transactionType(): TransactionType {\n    return TransactionType.Import;\n  }\n\n  initBuilder(tx: Tx, rawBytes?: Buffer, parsedCredentials?: Credential[]): this {\n    const baseTx = tx as evmSerial.ImportTx;\n    if (!this.verifyTxType(baseTx._type)) {\n      throw new NotSupported('Transaction cannot be parsed or has an unsupported transaction type');\n    }\n\n    // The outputs is a single C-Chain address result.\n    // It's expected to have only one output to the destination C-Chain address.\n    const outputs = baseTx.Outs;\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 Error('AssetID are not equals');\n    }\n    this.transaction._to = [Buffer.from(output.address.toBytes())];\n\n    const inputs = baseTx.importedInputs;\n    this.transaction._utxos = this.recoverUtxos(inputs);\n\n    // Calculate total input and output amounts\n    const totalInputAmount = inputs.reduce((t, i) => t + i.amount(), BigInt(0));\n    const totalOutputAmount = output.amount.value();\n\n    // Calculate fee based on input/output difference\n    const fee = totalInputAmount - totalOutputAmount;\n    const feeSize = this.calculateFeeSize(baseTx);\n    // Use integer division to ensure feeRate can be converted back to BigInt\n    const feeRate = Math.floor(Number(fee) / feeSize);\n\n    this.transaction._fee = {\n      fee: fee.toString(),\n      feeRate: feeRate,\n      size: feeSize,\n    };\n\n    // Use credentials passed from TransactionBuilderFactory (properly extracted using codec)\n    const credentials = parsedCredentials || [];\n    const hasCredentials = credentials.length > 0;\n\n    // If it's a signed transaction, store the original raw bytes to preserve exact format\n    if (hasCredentials && rawBytes) {\n      this.transaction._rawSignedBytes = rawBytes;\n    }\n\n    // Extract threshold from first input's sigIndicies (number of required signatures)\n    const firstInput = inputs[0];\n    const inputThreshold = firstInput.sigIndicies().length || this.transaction._threshold;\n    this.transaction._threshold = inputThreshold;\n\n    // Create AddressMaps based on signature slot order (matching credential order), not sorted addresses\n    // This matches the approach used in credentials: addressesIndex determines signature order\n    // AddressMaps should map addresses to signature slots in the same order as credentials\n    // If _fromAddresses is available, create AddressMap based on UTXO order (matching credential order)\n    // Otherwise, fall back to mapping just the output address\n    const firstUtxo = this.transaction._utxos[0];\n    let addressMap: FlareUtils.AddressMap;\n    if (\n      firstUtxo &&\n      firstUtxo.addresses &&\n      firstUtxo.addresses.length > 0 &&\n      this.transaction._fromAddresses &&\n      this.transaction._fromAddresses.length >= this.transaction._threshold\n    ) {\n      // Use centralized method for AddressMap creation\n      addressMap = this.createAddressMapForUtxo(firstUtxo, this.transaction._threshold);\n    } else {\n      // Fallback: map output address to slot 0 (for C-chain imports, output is the destination)\n      // Or map addresses sequentially if _fromAddresses is available but UTXO addresses are not\n      addressMap = new FlareUtils.AddressMap();\n      if (this.transaction._fromAddresses && this.transaction._fromAddresses.length >= this.transaction._threshold) {\n        this.transaction._fromAddresses.slice(0, this.transaction._threshold).forEach((addr, i) => {\n          addressMap.set(new Address(addr), i);\n        });\n      } else {\n        // Last resort: map output address\n        const toAddress = new Address(output.address.toBytes());\n        addressMap.set(toAddress, 0);\n      }\n    }\n\n    const addressMaps = new FlareUtils.AddressMaps([addressMap]);\n\n    // When credentials were extracted, use them directly to preserve existing signatures\n    // For initBuilder, _fromAddresses may not be set yet, so use all zeros for credential slots\n    let txCredentials: Credential[];\n    if (credentials.length > 0) {\n      txCredentials = credentials;\n    } else {\n      // Create empty credential with threshold number of signature slots (all zeros)\n      const emptySignatures: ReturnType<typeof utils.createNewSig>[] = [];\n      for (let i = 0; i < inputThreshold; i++) {\n        emptySignatures.push(utils.createNewSig(''));\n      }\n      txCredentials = [new Credential(emptySignatures)];\n    }\n\n    const unsignedTx = new UnsignedTx(baseTx, [], addressMaps, txCredentials);\n\n    this.transaction.setTransaction(unsignedTx);\n    return this;\n  }\n\n  static verifyTxType(txnType: string): boolean {\n    return txnType === FlareTransactionType.EvmImportTx;\n  }\n\n  verifyTxType(txnType: string): boolean {\n    return ImportInCTxBuilder.verifyTxType(txnType);\n  }\n\n  /**\n   * Build the import in C-chain transaction\n   * @protected\n   */\n  protected buildFlareTransaction(): void {\n    // if tx has credentials or was already recovered from raw, tx shouldn't change\n    if (this.transaction.hasCredentials) return;\n    if (this.transaction._to.length !== 1) {\n      throw new Error('to is required');\n    }\n    if (!this.transaction._fee.feeRate) {\n      throw new Error('fee rate is required');\n    }\n\n    const { inputs, amount, credentials } = this.createInputs();\n\n    // Calculate import cost units (matching AVAXP's costImportTx approach)\n    // Create a temporary transaction to calculate the actual cost units\n    const tempOutput = new evmSerial.Output(\n      new Address(this.transaction._to[0]),\n      new BigIntPr(amount),\n      new Id(new Uint8Array(Buffer.from(this.transaction._assetId, 'hex')))\n    );\n    const tempImportTx = new evmSerial.ImportTx(\n      new Int(this.transaction._networkID),\n      new Id(new Uint8Array(Buffer.from(this.transaction._blockchainID, 'hex'))),\n      new Id(new Uint8Array(this._externalChainId)),\n      inputs,\n      [tempOutput]\n    );\n\n    // Calculate the import cost units (matches AVAXP's feeSize from costImportTx)\n    const feeSize = this.calculateImportCost(tempImportTx);\n\n    // Multiply feeRate by cost units (matching AVAXP: fee = feeRate.muln(feeSize))\n    const feeRate = BigInt(this.transaction._fee.feeRate);\n    const fee = feeRate * BigInt(feeSize);\n\n    this.transaction._fee.fee = fee.toString();\n    this.transaction._fee.size = feeSize;\n\n    // Create EVM output using proper FlareJS class with amount minus fee\n    const output = new evmSerial.Output(\n      new Address(this.transaction._to[0]),\n      new BigIntPr(amount - fee),\n      new Id(new Uint8Array(Buffer.from(this.transaction._assetId, 'hex')))\n    );\n\n    // Create the import transaction\n    const importTx = new evmSerial.ImportTx(\n      new Int(this.transaction._networkID),\n      new Id(new Uint8Array(Buffer.from(this.transaction._blockchainID, 'hex'))),\n      new Id(new Uint8Array(this._externalChainId)),\n      inputs,\n      [output]\n    );\n\n    // Create AddressMaps based on signature slot order (matching credential order), not sorted addresses\n    // This matches the approach used in credentials: addressesIndex determines signature order\n    // AddressMaps should map addresses to signature slots in the same order as credentials\n    // For C-chain imports, we typically have one input, so use the first UTXO\n    // Use centralized method for AddressMap creation\n    const firstUtxo = this.transaction._utxos[0];\n    const addressMap = firstUtxo\n      ? this.createAddressMapForUtxo(firstUtxo, this.transaction._threshold)\n      : new FlareUtils.AddressMap();\n    const addressMaps = new FlareUtils.AddressMaps([addressMap]);\n\n    const unsignedTx = new UnsignedTx(\n      importTx,\n      [], // Empty UTXOs array, will be filled during processing\n      addressMaps,\n      credentials\n    );\n\n    this.transaction.setTransaction(unsignedTx);\n  }\n\n  /**\n   * Create inputs from UTXOs\n   * @return {\n   *     inputs: TransferableInput[];\n   *     credentials: Credential[];\n   *     amount: bigint;\n   * }\n   */\n  protected createInputs(): {\n    inputs: TransferableInput[];\n    credentials: Credential[];\n    amount: bigint;\n  } {\n    const sender = this.transaction._fromAddresses.slice();\n    if (this.recoverSigner) {\n      // switch first and last signer\n      const tmp = sender.pop();\n      sender.push(sender[0]);\n      if (tmp) {\n        sender[0] = tmp;\n      }\n    }\n\n    let totalAmount = BigInt(0);\n    const inputs: TransferableInput[] = [];\n    const credentials: Credential[] = [];\n\n    this.transaction._utxos.forEach((utxo) => {\n      const amount = BigInt(utxo.amount);\n      totalAmount += amount;\n\n      // Create signature indices for threshold\n      const sigIndices: number[] = [];\n      for (let i = 0; i < this.transaction._threshold; i++) {\n        sigIndices.push(i);\n      }\n\n      // Use fromNative to create TransferableInput (same pattern as ImportInPTxBuilder)\n      // fromNative expects cb58-encoded strings for txId and assetId\n      const txIdCb58 = utxo.txid; // Already cb58 encoded\n      const assetIdCb58 = utils.cb58Encode(Buffer.from(this.transaction._assetId, 'hex'));\n\n      const transferableInput = TransferableInput.fromNative(\n        txIdCb58,\n        Number(utxo.outputidx),\n        assetIdCb58,\n        amount,\n        sigIndices\n      );\n\n      inputs.push(transferableInput);\n\n      // Create credential with empty signatures for slot identification\n      // Match avaxp behavior: dynamic ordering based on addressesIndex from UTXO\n      // Use centralized method for credential creation\n      credentials.push(this.createCredentialForUtxo(utxo, this.transaction._threshold));\n    });\n\n    return {\n      inputs,\n      credentials,\n      amount: totalAmount,\n    };\n  }\n\n  /**\n   * Calculate the import cost for C-chain import transactions\n   * Matches AVAXP's costImportTx formula:\n   * - Base byte cost: transactionSize * txBytesGas (1 gas per byte)\n   * - Per-input cost: numInputs * costPerSignature (1000 per signature) * threshold\n   * - Fixed fee: 10000\n   *\n   * This returns cost \"units\" to be multiplied by feeRate, matching AVAXP's approach:\n   * AVAXP: fee = feeRate.muln(costImportTx(tx))\n   * FLRP:  fee = feeRate * calculateImportCost(tx)\n   *\n   * @param tx The ImportTx to calculate the cost for\n   * @returns The total cost units\n   */\n  private calculateImportCost(tx: evmSerial.ImportTx): number {\n    const codec = avmSerial.getAVMManager().getDefaultCodec();\n    const txBytes = tx.toBytes(codec);\n\n    // Base byte cost: 1 gas per byte (matching AVAX txBytesGas)\n    const txBytesGas = 1;\n    let bytesCost = txBytes.length * txBytesGas;\n\n    // Per-input cost: costPerSignature (1000) per signature\n    const costPerSignature = 1000;\n    const numInputs = tx.importedInputs.length;\n    const numSignatures = this.transaction._threshold; // Each input requires threshold signatures\n    const inputCost = numInputs * costPerSignature * numSignatures;\n    bytesCost += inputCost;\n\n    // Fixed fee component\n    const fixedFee = 10000;\n    const totalCost = bytesCost + fixedFee;\n\n    return totalCost;\n  }\n\n  /**\n   * Calculate the fee size for the transaction (for backwards compatibility)\n   * For C-chain imports, the feeRate is treated as an absolute fee value\n   */\n  private calculateFeeSize(tx?: evmSerial.ImportTx): number {\n    // If tx is provided, calculate based on actual transaction size\n    if (tx) {\n      const codec = avmSerial.getAVMManager().getDefaultCodec();\n      return tx.toBytes(codec).length;\n    }\n\n    // For C-chain imports, treat feeRate as the absolute fee (multiplier of 1)\n    return 1;\n  }\n\n  /**\n   * Recover UTXOs from imported inputs\n   * @param importedInputs Array of transferable inputs\n   * @returns Array of decoded UTXO objects\n   */\n  private recoverUtxos(importedInputs: TransferableInput[]): DecodedUtxoObj[] {\n    return importedInputs.map((input) => {\n      const txid = input.utxoID.toString();\n      const outputidx = input.utxoID.outputIdx.toString();\n\n      return {\n        outputID: SECP256K1_Transfer_Output,\n        amount: input.amount().toString(),\n        txid: utils.cb58Encode(Buffer.from(txid, 'hex')),\n        outputidx: outputidx,\n        threshold: this.transaction._threshold,\n        addresses: this.transaction._fromAddresses.map((addr) =>\n          utils.addressToString(this.transaction._network.hrp, this.transaction._network.alias, Buffer.from(addr))\n        ),\n      };\n    });\n  }\n}\n"]}

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

@@ -0,0 +1,33 @@
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { TransactionType } from '@bitgo-beta/sdk-core';
+import { AtomicTransactionBuilder } from './atomicTransactionBuilder';
+import { TransferableInput, Credential } from '@flarenetwork/flarejs';
+import { Tx } from './iface';
+export declare class ImportInPTxBuilder 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 import transaction for P-chain
+     * @protected
+     */
+    protected buildFlareTransaction(): void;
+    /**
+     * Create inputs from UTXOs for P-chain import
+     * @returns inputs, credentials, and total amount
+     */
+    protected createImportInputs(): {
+        inputs: TransferableInput[];
+        credentials: Credential[];
+        totalAmount: bigint;
+    };
+    /**
+     * Recover UTXOs from imported inputs
+     * @param importedInputs Array of transferable inputs
+     * @returns Array of decoded UTXO objects
+     */
+    private recoverUtxos;
+}
+//# sourceMappingURL=ImportInPTxBuilder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ImportInPTxBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/ImportInPTxBuilder.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,EAML,iBAAiB,EAQjB,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;IA0E9E,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAI7C,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAItC;;;OAGG;IACH,SAAS,CAAC,qBAAqB,IAAI,IAAI;IAkEvC;;;OAGG;IACH,SAAS,CAAC,kBAAkB,IAAI;QAC9B,MAAM,EAAE,iBAAiB,EAAE,CAAC;QAC5B,WAAW,EAAE,UAAU,EAAE,CAAC;QAC1B,WAAW,EAAE,MAAM,CAAC;KACrB;IAqDD;;;;OAIG;IACH,OAAO,CAAC,YAAY;CAiBrB"}