@bitgo-beta/sdk-coin-flrp 1.0.0-alpha.5 → 1.0.0-alpha.50

package/dist/src/lib/ImportInPTxBuilder.js

@@ -0,0 +1,245 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportInPTxBuilder = 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 ImportInPTxBuilder extends atomicTransactionBuilder_1.AtomicTransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        // For Import INTO P-chain:
+        // - external chain (source) is C-chain
+        // - blockchain ID (destination) is P-chain
+        this._externalChainId = utils_1.default.cb58Decode(this.transaction._network.cChainBlockchainID);
+        // P-chain blockchain ID (from network config - typically all zeros for primary network)
+        this.transaction._blockchainID = Buffer.from(utils_1.default.cb58Decode(this.transaction._network.blockchainID)).toString('hex');
+    }
+    get transactionType() {
+        return sdk_core_1.TransactionType.Import;
+    }
+    initBuilder(tx, rawBytes, parsedCredentials) {
+        const importTx = tx;
+        if (!this.verifyTxType(importTx._type)) {
+            throw new sdk_core_1.NotSupported('Transaction cannot be parsed or has an unsupported transaction type');
+        }
+        // The regular change output is the tx output in Import tx.
+        // It's expected to have only one output with the addresses of the sender.
+        const outputs = importTx.baseTx.outputs;
+        if (outputs.length !== 1) {
+            throw new sdk_core_1.BuildTransactionError('Transaction can have one external output');
+        }
+        const output = outputs[0];
+        const assetId = output.assetId.toBytes();
+        if (Buffer.compare(assetId, Buffer.from(this.transaction._assetId, 'hex')) !== 0) {
+            throw new Error('The Asset ID of the output does not match the transaction');
+        }
+        const transferOutput = output.output;
+        const outputOwners = transferOutput.outputOwners;
+        // Set locktime from output
+        this.transaction._locktime = outputOwners.locktime.value();
+        // Set threshold from output
+        this.transaction._threshold = outputOwners.threshold.value();
+        // Convert output addresses to buffers and set as fromAddresses
+        this.transaction._fromAddresses = outputOwners.addrs.map((addr) => Buffer.from(addr.toBytes()));
+        // Set external chain ID from the source chain
+        this._externalChainId = Buffer.from(importTx.sourceChain.toBytes());
+        // Recover UTXOs from imported inputs
+        this.transaction._utxos = this.recoverUtxos(importTx.ins);
+        // Calculate and set fee from input/output difference
+        const totalInputAmount = importTx.ins.reduce((sum, input) => sum + input.amount(), BigInt(0));
+        const outputAmount = transferOutput.amount();
+        const fee = totalInputAmount - outputAmount;
+        this.transaction._fee.fee = fee.toString();
+        // Use credentials passed from TransactionBuilderFactory (properly extracted using codec)
+        const credentials = parsedCredentials || [];
+        const hasCredentials = credentials.length > 0;
+        // If there are credentials, store the original bytes to preserve exact format
+        if (rawBytes && hasCredentials) {
+            this.transaction._rawSignedBytes = rawBytes;
+        }
+        // Create proper UnsignedTx wrapper with credentials
+        const sortedAddresses = [...this.transaction._fromAddresses].sort((a, b) => Buffer.compare(a, b));
+        const addressMaps = sortedAddresses.map((a, i) => new flarejs_1.utils.AddressMap([[new flarejs_1.Address(a), i]]));
+        // When credentials were extracted, use them directly to preserve existing signatures
+        // Match avaxp behavior: dynamic ordering based on addressesIndex from UTXO
+        const txCredentials = credentials.length > 0
+            ? credentials
+            : this.transaction._utxos.map((utxo) => {
+                // either user (0) or recovery (2)
+                const firstIndex = this.recoverSigner ? 2 : 0;
+                const bitgoIndex = 1;
+                // If UTXO has addresses, compute dynamic ordering
+                if (utxo && utxo.addresses && utxo.addresses.length > 0) {
+                    const utxoAddresses = utxo.addresses.map((a) => utils_1.default.parseAddress(a));
+                    const addressesIndex = this.transaction._fromAddresses.map((a) => utxoAddresses.findIndex((u) => Buffer.compare(Buffer.from(u), Buffer.from(a)) === 0));
+                    // Dynamic ordering based on addressesIndex
+                    let sigSlots;
+                    if (addressesIndex[bitgoIndex] < addressesIndex[firstIndex]) {
+                        // Bitgo comes first: [zeros, userAddress]
+                        sigSlots = [
+                            utils_1.default.createNewSig(''),
+                            utils_1.default.createEmptySigWithAddress(Buffer.from(this.transaction._fromAddresses[firstIndex]).toString('hex')),
+                        ];
+                    }
+                    else {
+                        // User comes first: [userAddress, zeros]
+                        sigSlots = [
+                            utils_1.default.createEmptySigWithAddress(Buffer.from(this.transaction._fromAddresses[firstIndex]).toString('hex')),
+                            utils_1.default.createNewSig(''),
+                        ];
+                    }
+                    return new flarejs_1.Credential(sigSlots);
+                }
+                else {
+                    // Fallback: use all zeros if no UTXO addresses available
+                    const sigSlots = [];
+                    for (let i = 0; i < this.transaction._threshold; i++) {
+                        sigSlots.push(utils_1.default.createNewSig(''));
+                    }
+                    return new flarejs_1.Credential(sigSlots);
+                }
+            });
+        const unsignedTx = new flarejs_1.UnsignedTx(importTx, [], new flarejs_1.utils.AddressMaps(addressMaps), txCredentials);
+        this.transaction.setTransaction(unsignedTx);
+        return this;
+    }
+    static verifyTxType(txnType) {
+        return txnType === iface_1.FlareTransactionType.PvmImportTx;
+    }
+    verifyTxType(txnType) {
+        return ImportInPTxBuilder.verifyTxType(txnType);
+    }
+    /**
+     * Build the import transaction for P-chain
+     * @protected
+     */
+    buildFlareTransaction() {
+        // if tx has credentials, tx shouldn't change
+        if (this.transaction.hasCredentials)
+            return;
+        const { inputs, credentials, totalAmount } = this.createImportInputs();
+        // Calculate fee from transaction fee settings
+        const fee = BigInt(this.transaction.fee.fee);
+        const outputAmount = totalAmount - fee;
+        // Create the output for P-chain (TransferableOutput with TransferOutput)
+        const assetIdBytes = new Uint8Array(Buffer.from(this.transaction._assetId, 'hex'));
+        // Create OutputOwners with the P-chain addresses (sorted by byte value as per AVAX protocol)
+        const sortedAddresses = [...this.transaction._fromAddresses].sort((a, b) => Buffer.compare(a, b));
+        const outputOwners = new flarejs_1.OutputOwners(new flarejs_1.BigIntPr(this.transaction._locktime), new flarejs_1.Int(this.transaction._threshold), sortedAddresses.map((addr) => new flarejs_1.Address(addr)));
+        const transferOutput = new flarejs_1.TransferOutput(new flarejs_1.BigIntPr(outputAmount), outputOwners);
+        const output = new flarejs_1.TransferableOutput(new flarejs_1.Id(assetIdBytes), transferOutput);
+        // Create the BaseTx for the P-chain import transaction
+        const baseTx = new flarejs_1.avaxSerial.BaseTx(new flarejs_1.Int(this.transaction._networkID), new flarejs_1.Id(Buffer.from(this.transaction._blockchainID, 'hex')), [output], // outputs
+        [], // inputs (empty for import - inputs come from importedInputs)
+        new flarejs_1.Bytes(new Uint8Array(0)) // empty memo
+        );
+        // Create the P-chain import transaction using pvmSerial.ImportTx
+        const importTx = new flarejs_1.pvmSerial.ImportTx(baseTx, new flarejs_1.Id(this._externalChainId), // sourceChain (C-chain)
+        inputs // importedInputs (ins)
+        );
+        // Create address maps for signing
+        const addressMaps = this.transaction._fromAddresses.map((a, i) => new flarejs_1.utils.AddressMap([[new flarejs_1.Address(a), i]]));
+        // Create unsigned transaction
+        const unsignedTx = new flarejs_1.UnsignedTx(importTx, [], // Empty UTXOs array
+        new flarejs_1.utils.AddressMaps(addressMaps), credentials);
+        this.transaction.setTransaction(unsignedTx);
+    }
+    /**
+     * Create inputs from UTXOs for P-chain import
+     * @returns inputs, credentials, and total amount
+     */
+    createImportInputs() {
+        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
+            // 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
+            const hasAddresses = this.transaction._fromAddresses && this.transaction._fromAddresses.length >= this.transaction._threshold;
+            if (!hasAddresses) {
+                // If addresses not available, use all zeros
+                const emptySignatures = sigIndices.map(() => utils_1.default.createNewSig(''));
+                credentials.push(new flarejs_1.Credential(emptySignatures));
+            }
+            else {
+                // Compute addressesIndex: position of each _fromAddresses in UTXO's address list
+                const utxoAddresses = utxo.addresses.map((a) => utils_1.default.parseAddress(a));
+                const addressesIndex = this.transaction._fromAddresses.map((a) => utxoAddresses.findIndex((u) => Buffer.compare(Buffer.from(u), Buffer.from(a)) === 0));
+                // either user (0) or recovery (2)
+                const firstIndex = this.recoverSigner ? 2 : 0;
+                const bitgoIndex = 1;
+                // Dynamic ordering based on addressesIndex
+                let emptySignatures;
+                if (addressesIndex[bitgoIndex] < addressesIndex[firstIndex]) {
+                    // Bitgo comes first in signature order: [zeros, userAddress]
+                    emptySignatures = [
+                        utils_1.default.createNewSig(''),
+                        utils_1.default.createEmptySigWithAddress(Buffer.from(this.transaction._fromAddresses[firstIndex]).toString('hex')),
+                    ];
+                }
+                else {
+                    // User comes first in signature order: [userAddress, zeros]
+                    emptySignatures = [
+                        utils_1.default.createEmptySigWithAddress(Buffer.from(this.transaction._fromAddresses[firstIndex]).toString('hex')),
+                        utils_1.default.createNewSig(''),
+                    ];
+                }
+                credentials.push(new flarejs_1.Credential(emptySignatures));
+            }
+        });
+        return {
+            inputs,
+            credentials,
+            totalAmount,
+        };
+    }
+    /**
+     * Recover UTXOs from imported inputs
+     * @param importedInputs Array of transferable inputs
+     * @returns Array of decoded UTXO objects
+     */
+    recoverUtxos(importedInputs) {
+        return importedInputs.map((input) => {
+            const utxoId = input.utxoID;
+            const transferInput = input.input;
+            const utxo = {
+                outputID: iface_1.SECP256K1_Transfer_Output,
+                amount: transferInput.amount().toString(),
+                txid: utils_1.default.cb58Encode(Buffer.from(utxoId.txID.toBytes())),
+                outputidx: utxoId.outputIdx.value().toString(),
+                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))),
+            };
+            return utxo;
+        });
+    }
+}
+exports.ImportInPTxBuilder = ImportInPTxBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ImportInPTxBuilder.js","sourceRoot":"","sources":["../../../src/lib/ImportInPTxBuilder.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  avaxSerial,\n  UnsignedTx,\n  Int,\n  Id,\n  TransferableInput,\n  TransferableOutput,\n  TransferOutput,\n  TransferInput,\n  OutputOwners,\n  utils as FlareUtils,\n  Address,\n  BigIntPr,\n  Credential,\n  Bytes,\n} from '@flarenetwork/flarejs';\nimport utils from './utils';\nimport { DecodedUtxoObj, FlareTransactionType, SECP256K1_Transfer_Output, Tx } from './iface';\n\nexport class ImportInPTxBuilder extends AtomicTransactionBuilder {\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n    // For Import INTO P-chain:\n    // - external chain (source) is C-chain\n    // - blockchain ID (destination) is P-chain\n    this._externalChainId = utils.cb58Decode(this.transaction._network.cChainBlockchainID);\n    // P-chain blockchain ID (from network config - typically all zeros for primary network)\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.Import;\n  }\n\n  initBuilder(tx: Tx, rawBytes?: Buffer, parsedCredentials?: Credential[]): this {\n    const importTx = tx as pvmSerial.ImportTx;\n\n    if (!this.verifyTxType(importTx._type)) {\n      throw new NotSupported('Transaction cannot be parsed or has an unsupported transaction type');\n    }\n\n    // The regular change output is the tx output in Import tx.\n    // It's expected to have only one output with the addresses of the sender.\n    const outputs = importTx.baseTx.outputs;\n    if (outputs.length !== 1) {\n      throw new BuildTransactionError('Transaction can have one external output');\n    }\n\n    const output = outputs[0];\n    const assetId = output.assetId.toBytes();\n    if (Buffer.compare(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 transferOutput = output.output as TransferOutput;\n    const outputOwners = transferOutput.outputOwners;\n\n    // Set locktime from output\n    this.transaction._locktime = outputOwners.locktime.value();\n\n    // Set threshold from output\n    this.transaction._threshold = outputOwners.threshold.value();\n\n    // Convert output addresses to buffers and set as fromAddresses\n    this.transaction._fromAddresses = outputOwners.addrs.map((addr) => Buffer.from(addr.toBytes()));\n\n    // Set external chain ID from the source chain\n    this._externalChainId = Buffer.from(importTx.sourceChain.toBytes());\n\n    // Recover UTXOs from imported inputs\n    this.transaction._utxos = this.recoverUtxos(importTx.ins);\n\n    // Calculate and set fee from input/output difference\n    const totalInputAmount = importTx.ins.reduce((sum, input) => sum + input.amount(), BigInt(0));\n    const outputAmount = transferOutput.amount();\n    const fee = totalInputAmount - outputAmount;\n    this.transaction._fee.fee = fee.toString();\n\n    // Use credentials passed from TransactionBuilderFactory (properly extracted using codec)\n    const credentials = parsedCredentials || [];\n    const hasCredentials = credentials.length > 0;\n\n    // If there are credentials, store the original bytes to preserve exact format\n    if (rawBytes && hasCredentials) {\n      this.transaction._rawSignedBytes = rawBytes;\n    }\n\n    // Create proper UnsignedTx wrapper with credentials\n    const sortedAddresses = [...this.transaction._fromAddresses].sort((a, b) => Buffer.compare(a, b));\n    const addressMaps = sortedAddresses.map((a, i) => new FlareUtils.AddressMap([[new Address(a), i]]));\n\n    // When credentials were extracted, use them directly to preserve existing signatures\n    // Match avaxp behavior: dynamic ordering based on addressesIndex from UTXO\n    const txCredentials =\n      credentials.length > 0\n        ? credentials\n        : this.transaction._utxos.map((utxo) => {\n            // either user (0) or recovery (2)\n            const firstIndex = this.recoverSigner ? 2 : 0;\n            const bitgoIndex = 1;\n\n            // If UTXO has addresses, compute dynamic ordering\n            if (utxo && utxo.addresses && utxo.addresses.length > 0) {\n              const utxoAddresses = utxo.addresses.map((a) => utils.parseAddress(a));\n              const addressesIndex = this.transaction._fromAddresses.map((a) =>\n                utxoAddresses.findIndex((u) => Buffer.compare(Buffer.from(u), Buffer.from(a)) === 0)\n              );\n\n              // Dynamic ordering based on addressesIndex\n              let sigSlots: ReturnType<typeof utils.createNewSig>[];\n              if (addressesIndex[bitgoIndex] < addressesIndex[firstIndex]) {\n                // Bitgo comes first: [zeros, userAddress]\n                sigSlots = [\n                  utils.createNewSig(''),\n                  utils.createEmptySigWithAddress(\n                    Buffer.from(this.transaction._fromAddresses[firstIndex]).toString('hex')\n                  ),\n                ];\n              } else {\n                // User comes first: [userAddress, zeros]\n                sigSlots = [\n                  utils.createEmptySigWithAddress(\n                    Buffer.from(this.transaction._fromAddresses[firstIndex]).toString('hex')\n                  ),\n                  utils.createNewSig(''),\n                ];\n              }\n              return new Credential(sigSlots);\n            } else {\n              // Fallback: use all zeros if no UTXO addresses available\n              const sigSlots: ReturnType<typeof utils.createNewSig>[] = [];\n              for (let i = 0; i < this.transaction._threshold; i++) {\n                sigSlots.push(utils.createNewSig(''));\n              }\n              return new Credential(sigSlots);\n            }\n          });\n\n    const unsignedTx = new UnsignedTx(importTx, [], new FlareUtils.AddressMaps(addressMaps), txCredentials);\n\n    this.transaction.setTransaction(unsignedTx);\n    return this;\n  }\n\n  static verifyTxType(txnType: string): boolean {\n    return txnType === FlareTransactionType.PvmImportTx;\n  }\n\n  verifyTxType(txnType: string): boolean {\n    return ImportInPTxBuilder.verifyTxType(txnType);\n  }\n\n  /**\n   * Build the import transaction for P-chain\n   * @protected\n   */\n  protected buildFlareTransaction(): void {\n    // if tx has credentials, tx shouldn't change\n    if (this.transaction.hasCredentials) return;\n\n    const { inputs, credentials, totalAmount } = this.createImportInputs();\n\n    // Calculate fee from transaction fee settings\n    const fee = BigInt(this.transaction.fee.fee);\n    const outputAmount = totalAmount - fee;\n\n    // Create the output for P-chain (TransferableOutput with TransferOutput)\n    const assetIdBytes = new Uint8Array(Buffer.from(this.transaction._assetId, 'hex'));\n\n    // Create OutputOwners with the P-chain addresses (sorted by byte value as per AVAX protocol)\n    const sortedAddresses = [...this.transaction._fromAddresses].sort((a, b) => Buffer.compare(a, b));\n    const outputOwners = new OutputOwners(\n      new BigIntPr(this.transaction._locktime),\n      new Int(this.transaction._threshold),\n      sortedAddresses.map((addr) => new Address(addr))\n    );\n\n    const transferOutput = new TransferOutput(new BigIntPr(outputAmount), outputOwners);\n    const output = new TransferableOutput(new Id(assetIdBytes), transferOutput);\n\n    // Create the BaseTx for the P-chain import transaction\n    const baseTx = new avaxSerial.BaseTx(\n      new Int(this.transaction._networkID),\n      new Id(Buffer.from(this.transaction._blockchainID, 'hex')),\n      [output], // outputs\n      [], // inputs (empty for import - inputs come from importedInputs)\n      new Bytes(new Uint8Array(0)) // empty memo\n    );\n\n    // Create the P-chain import transaction using pvmSerial.ImportTx\n    const importTx = new pvmSerial.ImportTx(\n      baseTx,\n      new Id(this._externalChainId), // sourceChain (C-chain)\n      inputs // importedInputs (ins)\n    );\n\n    // Create address maps for signing\n    const addressMaps = this.transaction._fromAddresses.map((a, i) => new FlareUtils.AddressMap([[new Address(a), i]]));\n\n    // Create unsigned transaction\n    const unsignedTx = new UnsignedTx(\n      importTx,\n      [], // Empty UTXOs array\n      new FlareUtils.AddressMaps(addressMaps),\n      credentials\n    );\n\n    this.transaction.setTransaction(unsignedTx);\n  }\n\n  /**\n   * Create inputs from UTXOs for P-chain import\n   * @returns inputs, credentials, and total amount\n   */\n  protected createImportInputs(): {\n    inputs: TransferableInput[];\n    credentials: Credential[];\n    totalAmount: 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: DecodedUtxoObj) => {\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\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      const hasAddresses =\n        this.transaction._fromAddresses && this.transaction._fromAddresses.length >= this.transaction._threshold;\n\n      if (!hasAddresses) {\n        // If addresses not available, use all zeros\n        const emptySignatures = sigIndices.map(() => utils.createNewSig(''));\n        credentials.push(new Credential(emptySignatures));\n      } else {\n        // Compute addressesIndex: position of each _fromAddresses in UTXO's address list\n        const utxoAddresses = utxo.addresses.map((a) => utils.parseAddress(a));\n        const addressesIndex = this.transaction._fromAddresses.map((a) =>\n          utxoAddresses.findIndex((u) => Buffer.compare(Buffer.from(u), Buffer.from(a)) === 0)\n        );\n\n        // either user (0) or recovery (2)\n        const firstIndex = this.recoverSigner ? 2 : 0;\n        const bitgoIndex = 1;\n\n        // Dynamic ordering based on addressesIndex\n        let emptySignatures: ReturnType<typeof utils.createNewSig>[];\n        if (addressesIndex[bitgoIndex] < addressesIndex[firstIndex]) {\n          // Bitgo comes first in signature order: [zeros, userAddress]\n          emptySignatures = [\n            utils.createNewSig(''),\n            utils.createEmptySigWithAddress(Buffer.from(this.transaction._fromAddresses[firstIndex]).toString('hex')),\n          ];\n        } else {\n          // User comes first in signature order: [userAddress, zeros]\n          emptySignatures = [\n            utils.createEmptySigWithAddress(Buffer.from(this.transaction._fromAddresses[firstIndex]).toString('hex')),\n            utils.createNewSig(''),\n          ];\n        }\n        credentials.push(new Credential(emptySignatures));\n      }\n    });\n\n    return {\n      inputs,\n      credentials,\n      totalAmount,\n    };\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 utxoId = input.utxoID;\n      const transferInput = input.input as TransferInput;\n      const utxo: DecodedUtxoObj = {\n        outputID: SECP256K1_Transfer_Output,\n        amount: transferInput.amount().toString(),\n        txid: utils.cb58Encode(Buffer.from(utxoId.txID.toBytes())),\n        outputidx: utxoId.outputIdx.value().toString(),\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      return utxo;\n    });\n  }\n}\n"]}

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

@@ -1,26 +1,28 @@
 import { AtomicTransactionBuilder } from './atomicTransactionBuilder';
 import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
-/**
- * Flare P->C atomic import/export style builder (C-chain context). This adapts the AVAXP logic
- * removing direct Avalanche SDK dependencies. Network / chain ids are expected to be provided
- * in the transaction._network object by a higher-level factory once Flare network constants
- * are finalized. For now we CB58-decode placeholders if present and default to zero buffers.
- */
+import { UnsignedTx } from '@flarenetwork/flarejs';
+import { Transaction } from './transaction';
 export declare abstract class AtomicInCTransactionBuilder extends AtomicTransactionBuilder {
-    protected fixedFee: bigint;
     constructor(_coinConfig: Readonly<CoinConfig>);
     /**
-     * Set base fee (already scaled to Flare C-chain native decimals). Accept bigint | number | string.
+     * C-Chain base fee with decimal places converted from 18 to 9.
+     *
+     * @param {string | number} baseFee
      */
-    feeRate(baseFee: bigint | number | string): this;
+    feeRate(baseFee: string | number): this;
+    /** @inheritdoc */
+    fromImplementation(rawTransaction: string): Transaction;
     /**
-     * Recreate builder state from raw tx (hex). Flare C-chain support TBD; for now validate & stash.
+     * Check that fee is greater than 0.
+     * @param {bigint} fee
      */
-    protected fromImplementation(rawTransaction: string): {
-        _tx?: unknown;
-    };
-    private validateFee;
-    private initializeChainIds;
-    private setFeeRate;
+    validateFee(fee: bigint): void;
+    /**
+     * Initialize the transaction builder fields using the decoded transaction data
+     *
+     * @param {UnsignedTx} tx the transaction data
+     * @returns itself
+     */
+    initBuilder(tx: UnsignedTx): this;
 }
 //# sourceMappingURL=atomicInCTransactionBuilder.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"atomicInCTransactionBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/atomicInCTransactionBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AACtE,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAe7D;;;;;GAKG;AACH,8BAAsB,2BAA4B,SAAQ,wBAAwB;IAEhF,SAAS,CAAC,QAAQ,SAAM;gBACZ,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAK7C;;OAEG;IACH,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI;IAOhD;;OAEG;IACH,SAAS,CAAC,kBAAkB,CAAC,cAAc,EAAE,MAAM,GAAG;QAAE,GAAG,CAAC,EAAE,OAAO,CAAA;KAAE;IASvE,OAAO,CAAC,WAAW;IAMnB,OAAO,CAAC,kBAAkB;IAU1B,OAAO,CAAC,UAAU;CAKnB"}
+{"version":3,"file":"atomicInCTransactionBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/atomicInCTransactionBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AACtE,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAE7D,OAAO,EAAa,UAAU,EAA2C,MAAM,uBAAuB,CAAC;AAEvG,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,8BAAsB,2BAA4B,SAAQ,wBAAwB;gBACpE,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAU7C;;;;OAIG;IACH,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAOvC,kBAAkB;IAClB,kBAAkB,CAAC,cAAc,EAAE,MAAM,GAAG,WAAW;IAYvD;;;OAGG;IACH,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAM9B;;;;;OAKG;IACH,WAAW,CAAC,EAAE,EAAE,UAAU,GAAG,IAAI;CASlC"}

package/dist/src/lib/atomicInCTransactionBuilder.js

@@ -5,60 +5,62 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AtomicInCTransactionBuilder = void 0;
 const atomicTransactionBuilder_1 = require("./atomicTransactionBuilder");
-const utils_1 = __importDefault(require("./utils"));
 const sdk_core_1 = require("@bitgo-beta/sdk-core");
-/**
- * Flare P->C atomic import/export style builder (C-chain context). This adapts the AVAXP logic
- * removing direct Avalanche SDK dependencies. Network / chain ids are expected to be provided
- * in the transaction._network object by a higher-level factory once Flare network constants
- * are finalized. For now we CB58-decode placeholders if present and default to zero buffers.
- */
+const flarejs_1 = require("@flarenetwork/flarejs");
+const utils_1 = __importDefault(require("./utils"));
 class AtomicInCTransactionBuilder extends atomicTransactionBuilder_1.AtomicTransactionBuilder {
     constructor(_coinConfig) {
         super(_coinConfig);
-        // Placeholder fixed fee (can be overridden by subclasses or network config)
-        this.fixedFee = 0n;
-        this.initializeChainIds();
+        // external chain id is P
+        this._externalChainId = utils_1.default.cb58Decode(this.transaction._network.blockchainID);
+        // chain id is C
+        this.transaction._blockchainID = Buffer.from(utils_1.default.cb58Decode(this.transaction._network.cChainBlockchainID)).toString('hex');
     }
     /**
-     * Set base fee (already scaled to Flare C-chain native decimals). Accept bigint | number | string.
+     * C-Chain base fee with decimal places converted from 18 to 9.
+     *
+     * @param {string | number} baseFee
      */
     feeRate(baseFee) {
-        const n = typeof baseFee === 'bigint' ? baseFee : BigInt(baseFee);
-        this.validateFee(n);
-        this.setFeeRate(n);
+        const fee = BigInt(baseFee);
+        this.validateFee(fee);
+        this.transaction._fee.feeRate = Number(fee);
         return this;
     }
-    /**
-     * Recreate builder state from raw tx (hex). Flare C-chain support TBD; for now validate & stash.
-     */
+    /** @inheritdoc */
     fromImplementation(rawTransaction) {
-        // If utils has validateRawTransaction use it; otherwise basic check
-        if (utils_1.default.validateRawTransaction) {
-            utils_1.default.validateRawTransaction(rawTransaction);
-        }
-        this.transaction.setTransaction(rawTransaction);
+        const txBytes = new Uint8Array(Buffer.from(rawTransaction, 'hex'));
+        const codec = flarejs_1.avmSerial.getAVMManager().getDefaultCodec();
+        const [tx] = flarejs_1.evmSerial.ImportTx.fromBytes(txBytes, codec);
+        const addressMaps = this.transaction._fromAddresses.map((a) => new flarejs_1.utils.AddressMap([[new flarejs_1.Address(a), 0]]));
+        const unsignedTx = new flarejs_1.UnsignedTx(tx, [], new flarejs_1.utils.AddressMaps(addressMaps), []);
+        this.initBuilder(unsignedTx);
         return this.transaction;
     }
+    /**
+     * Check that fee is greater than 0.
+     * @param {bigint} fee
+     */
     validateFee(fee) {
-        if (fee <= 0n) {
+        if (fee <= BigInt(0)) {
             throw new sdk_core_1.BuildTransactionError('Fee must be greater than 0');
         }
     }
-    initializeChainIds() {
-        const meta = this.transaction._network;
-        if (meta?.blockchainID) {
-            this._externalChainId = utils_1.default.cb58Decode(meta.blockchainID);
-        }
-        if (meta?.cChainBlockchainID) {
-            this.transaction._blockchainID = utils_1.default.cb58Decode(meta.cChainBlockchainID);
+    /**
+     * Initialize the transaction builder fields using the decoded transaction data
+     *
+     * @param {UnsignedTx} tx the transaction data
+     * @returns itself
+     */
+    initBuilder(tx) {
+        // Validate network and blockchain IDs
+        const baseTx = tx.getTx();
+        if (baseTx.getBlockchainId() !== this.transaction._blockchainID) {
+            throw new Error('blockchain ID mismatch');
         }
-    }
-    setFeeRate(n) {
-        const currentContainer = this.transaction;
-        const current = currentContainer._fee || { fee: '0' };
-        currentContainer._fee = { ...current, feeRate: n.toString() };
+        this.transaction.setTransaction(tx);
+        return this;
     }
 }
 exports.AtomicInCTransactionBuilder = AtomicInCTransactionBuilder;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXRvbWljSW5DVHJhbnNhY3Rpb25CdWlsZGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2xpYi9hdG9taWNJbkNUcmFuc2FjdGlvbkJ1aWxkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBQUEseUVBQXNFO0FBRXRFLG9EQUE0QjtBQUM1QixtREFBNkQ7QUFhN0Q7Ozs7O0dBS0c7QUFDSCxNQUFzQiwyQkFBNEIsU0FBUSxtREFBd0I7SUFHaEYsWUFBWSxXQUFpQztRQUMzQyxLQUFLLENBQUMsV0FBVyxDQUFDLENBQUM7UUFIckIsNEVBQTRFO1FBQ2xFLGFBQVEsR0FBRyxFQUFFLENBQUM7UUFHdEIsSUFBSSxDQUFDLGtCQUFrQixFQUFFLENBQUM7SUFDNUIsQ0FBQztJQUVEOztPQUVHO0lBQ0gsT0FBTyxDQUFDLE9BQWlDO1FBQ3ZDLE1BQU0sQ0FBQyxHQUFHLE9BQU8sT0FBTyxLQUFLLFFBQVEsQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDbEUsSUFBSSxDQUFDLFdBQVcsQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUNwQixJQUFJLENBQUMsVUFBVSxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBQ25CLE9BQU8sSUFBSSxDQUFDO0lBQ2QsQ0FBQztJQUVEOztPQUVHO0lBQ08sa0JBQWtCLENBQUMsY0FBc0I7UUFDakQsb0VBQW9FO1FBQ3BFLElBQUssZUFBcUUsQ0FBQyxzQkFBc0IsRUFBRSxDQUFDO1lBQ2pHLGVBQW9FLENBQUMsc0JBQXNCLENBQUMsY0FBYyxDQUFDLENBQUM7UUFDL0csQ0FBQztRQUNELElBQUksQ0FBQyxXQUFXLENBQUMsY0FBYyxDQUFDLGNBQWMsQ0FBQyxDQUFDO1FBQ2hELE9BQU8sSUFBSSxDQUFDLFdBQVcsQ0FBQztJQUMxQixDQUFDO0lBRU8sV0FBVyxDQUFDLEdBQVc7UUFDN0IsSUFBSSxHQUFHLElBQUksRUFBRSxFQUFFLENBQUM7WUFDZCxNQUFNLElBQUksZ0NBQXFCLENBQUMsNEJBQTRCLENBQUMsQ0FBQztRQUNoRSxDQUFDO0lBQ0gsQ0FBQztJQUVPLGtCQUFrQjtRQUN4QixNQUFNLElBQUksR0FBRyxJQUFJLENBQUMsV0FBVyxDQUFDLFFBQWlDLENBQUM7UUFDaEUsSUFBSSxJQUFJLEVBQUUsWUFBWSxFQUFFLENBQUM7WUFDdkIsSUFBSSxDQUFDLGdCQUFnQixHQUFHLGVBQUssQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFDLFlBQVksQ0FBQyxDQUFDO1FBQzlELENBQUM7UUFDRCxJQUFJLElBQUksRUFBRSxrQkFBa0IsRUFBRSxDQUFDO1lBQzdCLElBQUksQ0FBQyxXQUFXLENBQUMsYUFBYSxHQUFHLGVBQUssQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFDLGtCQUFrQixDQUFDLENBQUM7UUFDN0UsQ0FBQztJQUNILENBQUM7SUFFTyxVQUFVLENBQUMsQ0FBUztRQUMxQixNQUFNLGdCQUFnQixHQUFHLElBQUksQ0FBQyxXQUE0QyxDQUFDO1FBQzNFLE1BQU0sT0FBTyxHQUFHLGdCQUFnQixDQUFDLElBQUksSUFBSSxFQUFFLEdBQUcsRUFBRSxHQUFHLEVBQUUsQ0FBQztRQUN0RCxnQkFBZ0IsQ0FBQyxJQUFJLEdBQUcsRUFBRSxHQUFHLE9BQU8sRUFBRSxPQUFPLEVBQUUsQ0FBQyxDQUFDLFFBQVEsRUFBRSxFQUFFLENBQUM7SUFDaEUsQ0FBQztDQUNGO0FBbkRELGtFQW1EQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEF0b21pY1RyYW5zYWN0aW9uQnVpbGRlciB9IGZyb20gJy4vYXRvbWljVHJhbnNhY3Rpb25CdWlsZGVyJztcbmltcG9ydCB7IEJhc2VDb2luIGFzIENvaW5Db25maWcgfSBmcm9tICdAYml0Z28tYmV0YS9zdGF0aWNzJztcbmltcG9ydCB1dGlscyBmcm9tICcuL3V0aWxzJztcbmltcG9ydCB7IEJ1aWxkVHJhbnNhY3Rpb25FcnJvciB9IGZyb20gJ0BiaXRnby1iZXRhL3Nkay1jb3JlJztcblxuaW50ZXJmYWNlIEZsYXJlQ2hhaW5OZXR3b3JrTWV0YSB7XG4gIGJsb2NrY2hhaW5JRD86IHN0cmluZzsgLy8gUC1jaGFpbiBpZCAoZXh0ZXJuYWwpXG4gIGNDaGFpbkJsb2NrY2hhaW5JRD86IHN0cmluZzsgLy8gQy1jaGFpbiBpZCAobG9jYWwpXG4gIFtrOiBzdHJpbmddOiB1bmtub3duO1xufVxuXG5pbnRlcmZhY2UgRmVlU2hhcGUge1xuICBmZWU/OiBzdHJpbmc7IC8vIGxlZ2FjeVxuICBmZWVSYXRlPzogc3RyaW5nOyAvLyBwZXIgdW5pdCByYXRlXG59XG5cbi8qKlxuICogRmxhcmUgUC0+QyBhdG9taWMgaW1wb3J0L2V4cG9ydCBzdHlsZSBidWlsZGVyIChDLWNoYWluIGNvbnRleHQpLiBUaGlzIGFkYXB0cyB0aGUgQVZBWFAgbG9naWNcbiAqIHJlbW92aW5nIGRpcmVjdCBBdmFsYW5jaGUgU0RLIGRlcGVuZGVuY2llcy4gTmV0d29yayAvIGNoYWluIGlkcyBhcmUgZXhwZWN0ZWQgdG8gYmUgcHJvdmlkZWRcbiAqIGluIHRoZSB0cmFuc2FjdGlvbi5fbmV0d29yayBvYmplY3QgYnkgYSBoaWdoZXItbGV2ZWwgZmFjdG9yeSBvbmNlIEZsYXJlIG5ldHdvcmsgY29uc3RhbnRzXG4gKiBhcmUgZmluYWxpemVkLiBGb3Igbm93IHdlIENCNTgtZGVjb2RlIHBsYWNlaG9sZGVycyBpZiBwcmVzZW50IGFuZCBkZWZhdWx0IHRvIHplcm8gYnVmZmVycy5cbiAqL1xuZXhwb3J0IGFic3RyYWN0IGNsYXNzIEF0b21pY0luQ1RyYW5zYWN0aW9uQnVpbGRlciBleHRlbmRzIEF0b21pY1RyYW5zYWN0aW9uQnVpbGRlciB7XG4gIC8vIFBsYWNlaG9sZGVyIGZpeGVkIGZlZSAoY2FuIGJlIG92ZXJyaWRkZW4gYnkgc3ViY2xhc3NlcyBvciBuZXR3b3JrIGNvbmZpZylcbiAgcHJvdGVjdGVkIGZpeGVkRmVlID0gMG47XG4gIGNvbnN0cnVjdG9yKF9jb2luQ29uZmlnOiBSZWFkb25seTxDb2luQ29uZmlnPikge1xuICAgIHN1cGVyKF9jb2luQ29uZmlnKTtcbiAgICB0aGlzLmluaXRpYWxpemVDaGFpbklkcygpO1xuICB9XG5cbiAgLyoqXG4gICAqIFNldCBiYXNlIGZlZSAoYWxyZWFkeSBzY2FsZWQgdG8gRmxhcmUgQy1jaGFpbiBuYXRpdmUgZGVjaW1hbHMpLiBBY2NlcHQgYmlnaW50IHwgbnVtYmVyIHwgc3RyaW5nLlxuICAgKi9cbiAgZmVlUmF0ZShiYXNlRmVlOiBiaWdpbnQgfCBudW1iZXIgfCBzdHJpbmcpOiB0aGlzIHtcbiAgICBjb25zdCBuID0gdHlwZW9mIGJhc2VGZWUgPT09ICdiaWdpbnQnID8gYmFzZUZlZSA6IEJpZ0ludChiYXNlRmVlKTtcbiAgICB0aGlzLnZhbGlkYXRlRmVlKG4pO1xuICAgIHRoaXMuc2V0RmVlUmF0ZShuKTtcbiAgICByZXR1cm4gdGhpcztcbiAgfVxuXG4gIC8qKlxuICAgKiBSZWNyZWF0ZSBidWlsZGVyIHN0YXRlIGZyb20gcmF3IHR4IChoZXgpLiBGbGFyZSBDLWNoYWluIHN1cHBvcnQgVEJEOyBmb3Igbm93IHZhbGlkYXRlICYgc3Rhc2guXG4gICAqL1xuICBwcm90ZWN0ZWQgZnJvbUltcGxlbWVudGF0aW9uKHJhd1RyYW5zYWN0aW9uOiBzdHJpbmcpOiB7IF90eD86IHVua25vd24gfSB7XG4gICAgLy8gSWYgdXRpbHMgaGFzIHZhbGlkYXRlUmF3VHJhbnNhY3Rpb24gdXNlIGl0OyBvdGhlcndpc2UgYmFzaWMgY2hlY2tcbiAgICBpZiAoKHV0aWxzIGFzIHVua25vd24gYXMgeyB2YWxpZGF0ZVJhd1RyYW5zYWN0aW9uPzogKHI6IHN0cmluZykgPT4gdm9pZCB9KS52YWxpZGF0ZVJhd1RyYW5zYWN0aW9uKSB7XG4gICAgICAodXRpbHMgYXMgdW5rbm93biBhcyB7IHZhbGlkYXRlUmF3VHJhbnNhY3Rpb246IChyOiBzdHJpbmcpID0+IHZvaWQgfSkudmFsaWRhdGVSYXdUcmFuc2FjdGlvbihyYXdUcmFuc2FjdGlvbik7XG4gICAgfVxuICAgIHRoaXMudHJhbnNhY3Rpb24uc2V0VHJhbnNhY3Rpb24ocmF3VHJhbnNhY3Rpb24pO1xuICAgIHJldHVybiB0aGlzLnRyYW5zYWN0aW9uO1xuICB9XG5cbiAgcHJpdmF0ZSB2YWxpZGF0ZUZlZShmZWU6IGJpZ2ludCk6IHZvaWQge1xuICAgIGlmIChmZWUgPD0gMG4pIHtcbiAgICAgIHRocm93IG5ldyBCdWlsZFRyYW5zYWN0aW9uRXJyb3IoJ0ZlZSBtdXN0IGJlIGdyZWF0ZXIgdGhhbiAwJyk7XG4gICAgfVxuICB9XG5cbiAgcHJpdmF0ZSBpbml0aWFsaXplQ2hhaW5JZHMoKTogdm9pZCB7XG4gICAgY29uc3QgbWV0YSA9IHRoaXMudHJhbnNhY3Rpb24uX25ldHdvcmsgYXMgRmxhcmVDaGFpbk5ldHdvcmtNZXRhO1xuICAgIGlmIChtZXRhPy5ibG9ja2NoYWluSUQpIHtcbiAgICAgIHRoaXMuX2V4dGVybmFsQ2hhaW5JZCA9IHV0aWxzLmNiNThEZWNvZGUobWV0YS5ibG9ja2NoYWluSUQpO1xuICAgIH1cbiAgICBpZiAobWV0YT8uY0NoYWluQmxvY2tjaGFpbklEKSB7XG4gICAgICB0aGlzLnRyYW5zYWN0aW9uLl9ibG9ja2NoYWluSUQgPSB1dGlscy5jYjU4RGVjb2RlKG1ldGEuY0NoYWluQmxvY2tjaGFpbklEKTtcbiAgICB9XG4gIH1cblxuICBwcml2YXRlIHNldEZlZVJhdGUobjogYmlnaW50KTogdm9pZCB7XG4gICAgY29uc3QgY3VycmVudENvbnRhaW5lciA9IHRoaXMudHJhbnNhY3Rpb24gYXMgdW5rbm93biBhcyB7IF9mZWU6IEZlZVNoYXBlIH07XG4gICAgY29uc3QgY3VycmVudCA9IGN1cnJlbnRDb250YWluZXIuX2ZlZSB8fCB7IGZlZTogJzAnIH07XG4gICAgY3VycmVudENvbnRhaW5lci5fZmVlID0geyAuLi5jdXJyZW50LCBmZWVSYXRlOiBuLnRvU3RyaW5nKCkgfTtcbiAgfVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,93 +1,59 @@
 import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
-import { TransactionType, BaseTransaction } from '@bitgo-beta/sdk-core';
-import { Credential, TransferableInput, TransferableOutput } from '@flarenetwork/flarejs';
-import { TransactionExplanation, DecodedUtxoObj } from './iface';
-/**
- * Flare P-chain atomic transaction builder with FlareJS credential support.
- * This provides the foundation for building Flare P-chain transactions with proper
- * credential handling using FlareJS Credential and Signature classes.
- */
-export declare abstract class AtomicTransactionBuilder {
-    protected readonly _coinConfig: Readonly<CoinConfig>;
-    protected _externalChainId: Buffer | undefined;
-    protected _utxos: DecodedUtxoObj[];
-    protected transaction: {
-        _network: Record<string, unknown>;
-        _networkID: number;
-        _blockchainID: Buffer;
-        _assetId: Buffer;
-        _fromAddresses: string[];
-        _to: string[];
-        _locktime: bigint;
-        _threshold: number;
-        _fee: {
-            fee: string;
-            feeRate?: string;
-            size?: number;
-        };
-        hasCredentials: boolean;
-        _tx?: unknown;
-        setTransaction: (tx: unknown) => void;
-    };
-    constructor(coinConfig: Readonly<CoinConfig>);
-    protected abstract get transactionType(): TransactionType;
-    validateAmount(amount: bigint): void;
-    /**
-     * Validates that credentials array is properly formed
-     * @param credentials - Array of credentials to validate
-     */
-    protected validateCredentials(credentials: Credential[]): void;
-    /**
-     * Creates inputs, outputs, and credentials for Flare P-chain atomic transactions.
-     * Based on AVAX P-chain implementation adapted for FlareJS.
-     *
-     * Note: This is a simplified implementation that creates the core structure.
-     * The FlareJS type system integration will be refined in future iterations.
-     *
-     * @param total - Total amount needed including fees
-     * @returns Object containing TransferableInput[], TransferableOutput[], and Credential[]
-     */
-    protected createInputOutput(total: bigint): {
+import { TransactionType } from '@bitgo-beta/sdk-core';
+import { TransactionBuilder } from './transactionBuilder';
+import { Transaction } from './transaction';
+import { TransferableInput, Credential } from '@flarenetwork/flarejs';
+export declare abstract class AtomicTransactionBuilder extends TransactionBuilder {
+    protected _externalChainId: Buffer;
+    protected recoverSigner: boolean;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    /**
+     * Create inputs and outputs from UTXOs
+     * @param {bigint} amount Amount to transfer
+     * @return {
+     *     inputs: TransferableInput[];
+     *     outputs: TransferableInput[];
+     *     credentials: Credential[];
+     * }
+     * @protected
+     */
+    protected createInputOutput(amount: bigint): {
         inputs: TransferableInput[];
-        outputs: TransferableOutput[];
+        outputs: TransferableInput[];
         credentials: Credential[];
     };
+    /** @inheritdoc */
+    protected buildImplementation(): Promise<Transaction>;
     /**
-     * Set UTXOs for the transaction. This is required for creating inputs and outputs.
-     *
-     * @param utxos - Array of decoded UTXO objects
-     * @returns this builder instance for chaining
+     * Builds the Flare transaction. Transaction field is changed.
      */
-    utxos(utxos: DecodedUtxoObj[]): this;
+    protected abstract buildFlareTransaction(): void;
+    protected abstract get transactionType(): TransactionType;
     /**
-     * Flare equivalent of Avalanche's SelectCredentialClass
-     * Creates a credential with the provided signatures
+     * Fee is fix for AVM atomic tx.
      *
-     * @param credentialId - The credential ID (not used in FlareJS but kept for compatibility)
-     * @param signatures - Array of signature hex strings or empty strings for placeholders
-     * @returns Credential instance
-     */
-    protected createFlareCredential(_credentialId: number, signatures: string[]): Credential;
-    /**
-     * Base initBuilder used by concrete builders. For now just returns this so fluent API works.
+     * @returns network.txFee
+     * @protected
      */
-    initBuilder(_tx: unknown): this;
+    protected get fixedFee(): string;
     /**
-     * Sign transaction with private key (placeholder implementation)
-     * TODO: Implement proper FlareJS signing
+     * Set the transaction type
+     *
+     * @param {TransactionType} transactionType The transaction type to be set
      */
-    sign(_params: {
-        key: string;
-    }): this;
+    setTransactionType(transactionType: TransactionType): void;
     /**
-     * Build the transaction (placeholder implementation)
-     * TODO: Implement proper FlareJS transaction building
+     * The internal chain is the one set for the coin in coinConfig.network. The external chain is the other chain involved.
+     * The external chain id is the source on import and the destination on export.
+     *
+     * @param {string} chainId - id of the external chain
      */
-    build(): Promise<BaseTransaction>;
+    externalChainId(chainId: string | Buffer): this;
     /**
-     * Parse and explain a transaction from hex (placeholder implementation)
-     * TODO: Implement proper FlareJS transaction parsing
+     * Set the transaction fee
+     *
+     * @param {string | bigint} feeValue - the fee value
      */
-    explainTransaction(): TransactionExplanation;
+    fee(feeValue: string | bigint): this;
 }
 //# sourceMappingURL=atomicTransactionBuilder.d.ts.map