@bitgo-beta/sdk-coin-flrp 1.0.1-beta.4 → 1.0.1-beta.400

package/dist/src/lib/atomicInCTransactionBuilder.js

@@ -5,60 +5,49 @@ 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();
-    }
-    /**
-     * Set base fee (already scaled to Flare C-chain native decimals). Accept bigint | number | string.
-     */
-    feeRate(baseFee) {
-        const n = typeof baseFee === 'bigint' ? baseFee : BigInt(baseFee);
-        this.validateFee(n);
-        this.setFeeRate(n);
-        return this;
+        this._externalChainId = utils_1.default.cb58Decode(this.transaction._network.blockchainID);
+        this.transaction._blockchainID = Buffer.from(utils_1.default.cb58Decode(this.transaction._network.cChainBlockchainID)).toString('hex');
     }
-    /**
-     * 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,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,44 +1,121 @@
 import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
 import { TransactionType } from '@bitgo-beta/sdk-core';
-/**
- * Minimal placeholder for Flare P-chain atomic transaction building.
- * This will be expanded with proper Flare P-chain logic (inputs/outputs/credentials, UTXO handling, fees, etc.).
- */
-export declare abstract class AtomicTransactionBuilder {
-    protected readonly _coinConfig: Readonly<CoinConfig>;
-    protected _externalChainId: Buffer | undefined;
-    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>);
+import { TransactionBuilder } from './transactionBuilder';
+import { Transaction } from './transaction';
+import { Credential, utils as FlareUtils } from '@flarenetwork/flarejs';
+import { DecodedUtxoObj } from './iface';
+import { FlrpFeeState } from '@bitgo/public-types';
+export declare abstract class AtomicTransactionBuilder extends TransactionBuilder {
+    protected _externalChainId: Buffer;
+    protected recoverSigner: boolean;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    /** @inheritdoc */
+    protected buildImplementation(): Promise<Transaction>;
+    /**
+     * Builds the Flare transaction. Transaction field is changed.
+     */
+    protected abstract buildFlareTransaction(): void | Promise<void>;
     protected abstract get transactionType(): TransactionType;
-    validateAmount(amount: bigint): void;
     /**
-     * Placeholder that should assemble inputs/outputs and credentials once UTXO + key logic is implemented.
+     * Fee is fix for AVM atomic tx.
+     *
+     * @returns network.txFee
+     * @protected
+     */
+    protected get fixedFee(): string;
+    /**
+     * Set the transaction type
+     *
+     * @param {TransactionType} transactionType The transaction type to be set
+     */
+    setTransactionType(transactionType: TransactionType): void;
+    /**
+     * 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
+     */
+    externalChainId(chainId: string | Buffer): this;
+    /**
+     * Set the transaction fee
+     *
+     * @param {string | bigint} feeValue - the fee value
+     */
+    fee(feeValue: string | bigint): this;
+    /**
+     * Set the fee state for dynamic fee calculation (P-chain transactions)
+     *
+     * @param {FlrpFeeState} state - the fee state from the network
+     */
+    feeState(state: FlrpFeeState): this;
+    /**
+     * Set the amount for the transaction
+     *
+     * @param {bigint | string} value - the amount to transfer
+     */
+    amount(value: bigint | string): this;
+    /**
+     * Compute addressesIndex for UTXOs following AVAX P approach.
+     * addressesIndex[senderIdx] = position of sender[senderIdx] in UTXO's address list
+     *
+     * IMPORTANT: UTXO addresses are sorted lexicographically by byte value to match
+     * on-chain storage order. The API may return addresses in arbitrary order, but
+     * on-chain UTXOs always store addresses in sorted order.
+     *
+     * Example:
+     *   A = user key, B = hsm key, C = backup key
+     *   sender (bitgoAddresses) = [ A, B, C ]
+     *   utxo.addresses (from API) = [ B, C, A ]
+     *   sorted utxo.addresses = [ A, B, C ] (sorted by hex value)
+     *   addressesIndex = [ 0, 1, 2 ]
+     *   (sender[0]=A is at position 0 in sorted UTXO, sender[1]=B is at position 1, etc.)
+     *
+     * @protected
+     */
+    protected computeAddressesIndex(): void;
+    /**
+     * Compute addressesIndex from parsed transaction data.
+     * Similar to computeAddressesIndex() but used when parsing existing transactions
+     * via initBuilder().
+     *
+     * IMPORTANT: UTXO addresses are sorted lexicographically by byte value to match
+     * on-chain storage order, ensuring consistency with fresh builds.
+     *
+     * @protected
+     */
+    protected computeAddressesIndexFromParsed(): void;
+    /**
+     * Validate UTXOs have consistent addresses.
+     * Note: UTXO threshold can differ from transaction threshold - each UTXO has its own
+     * signature requirement based on how it was created (e.g., change outputs may have threshold=1).
+     * @protected
+     */
+    protected validateUtxoAddresses(): void;
+    /**
+     * Create credential with dynamic ordering based on addressesIndex from UTXO.
+     * Matches AVAX P behavior: signature order depends on UTXO address positions.
+     *
+     * addressesIndex[senderIdx] = utxoPosition tells us where each sender is in the UTXO.
+     * We create signature slots ordered by utxoPosition (smaller position = earlier slot).
+     *
+     * @param utxo - The UTXO to create credential for
+     * @param threshold - Number of signatures required for this specific UTXO
+     * @returns Credential with empty signatures ordered based on UTXO positions
+     * @protected
      */
-    protected createInputOutput(_total: bigint): {
-        inputs: unknown[];
-        outputs: unknown[];
-        credentials: unknown[];
-    };
+    protected createCredentialForUtxo(utxo: DecodedUtxoObj, threshold: number): Credential;
     /**
-     * Base initBuilder used by concrete builders. For now just returns this so fluent API works.
+     * Create AddressMap based on addressesIndex following AVAX P approach.
+     * Maps each sender address to its signature slot based on UTXO position ordering.
+     *
+     * addressesIndex[senderIdx] = utxoPosition
+     * Signature slots are ordered by utxoPosition (smaller = earlier slot).
+     *
+     * @param utxo - The UTXO to create AddressMap for
+     * @param threshold - Number of signatures required for this specific UTXO
+     * @returns AddressMap that maps addresses to signature slots based on UTXO order
+     * @protected
      */
-    initBuilder(_tx: unknown): this;
+    protected createAddressMapForUtxo(utxo: DecodedUtxoObj, threshold: number): FlareUtils.AddressMap;
 }
 //# sourceMappingURL=atomicTransactionBuilder.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"atomicTransactionBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/atomicTransactionBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAyB,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAE9E;;;GAGG;AACH,8BAAsB,wBAAwB;IAC5C,SAAS,CAAC,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC,CAAC;IAErD,SAAS,CAAC,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAC;IAI/C,SAAS,CAAC,WAAW,EAAE;QACrB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAClC,UAAU,EAAE,MAAM,CAAC;QACnB,aAAa,EAAE,MAAM,CAAC;QACtB,QAAQ,EAAE,MAAM,CAAC;QACjB,cAAc,EAAE,MAAM,EAAE,CAAC;QACzB,GAAG,EAAE,MAAM,EAAE,CAAC;QACd,SAAS,EAAE,MAAM,CAAC;QAClB,UAAU,EAAE,MAAM,CAAC;QACnB,IAAI,EAAE;YAAE,GAAG,EAAE,MAAM,CAAC;YAAC,OAAO,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC;QACvD,cAAc,EAAE,OAAO,CAAC;QACxB,GAAG,CAAC,EAAE,OAAO,CAAC;QACd,cAAc,EAAE,CAAC,EAAE,EAAE,OAAO,KAAK,IAAI,CAAC;KACvC,CAcC;gBAEU,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI5C,SAAS,CAAC,QAAQ,KAAK,eAAe,IAAI,eAAe,CAAC;IAE1D,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAMpC;;OAEG;IACH,SAAS,CAAC,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG;QAAE,MAAM,EAAE,OAAO,EAAE,CAAC;QAAC,OAAO,EAAE,OAAO,EAAE,CAAC;QAAC,WAAW,EAAE,OAAO,EAAE,CAAA;KAAE;IAI9G;;OAEG;IACH,WAAW,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI;CAGhC"}
+{"version":3,"file":"atomicTransactionBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/atomicTransactionBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAyB,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC9E,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,UAAU,EAAW,KAAK,IAAI,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACjF,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAGnD,8BAAsB,wBAAyB,SAAQ,kBAAkB;IACvE,SAAS,CAAC,gBAAgB,EAAE,MAAM,CAAC;IACnC,SAAS,CAAC,aAAa,UAAS;gBAEpB,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAM7C,kBAAkB;cACF,mBAAmB,IAAI,OAAO,CAAC,WAAW,CAAC;IAW3D;;OAEG;IACH,SAAS,CAAC,QAAQ,CAAC,qBAAqB,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAEhE,SAAS,CAAC,QAAQ,KAAK,eAAe,IAAI,eAAe,CAAC;IAE1D;;;;;OAKG;IACH,SAAS,KAAK,QAAQ,IAAI,MAAM,CAE/B;IAED;;;;OAIG;IACH,kBAAkB,CAAC,eAAe,EAAE,eAAe,GAAG,IAAI;IAI1D;;;;;OAKG;IACH,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAO/C;;;;OAIG;IACH,GAAG,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAMpC;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAKnC;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAOpC;;;;;;;;;;;;;;;;;OAiBG;IACH,SAAS,CAAC,qBAAqB,IAAI,IAAI;IAoBvC;;;;;;;;;OASG;IACH,SAAS,CAAC,+BAA+B,IAAI,IAAI;IAiBjD;;;;;OAKG;IACH,SAAS,CAAC,qBAAqB,IAAI,IAAI;IAcvC;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,uBAAuB,CAAC,IAAI,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,GAAG,UAAU;IA0CtF;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,uBAAuB,CAAC,IAAI,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,GAAG,UAAU,CAAC,UAAU;CAoClG"}

package/dist/src/lib/atomicTransactionBuilder.js

@@ -1,49 +1,259 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AtomicTransactionBuilder = void 0;
 const sdk_core_1 = require("@bitgo-beta/sdk-core");
-/**
- * Minimal placeholder for Flare P-chain atomic transaction building.
- * This will be expanded with proper Flare P-chain logic (inputs/outputs/credentials, UTXO handling, fees, etc.).
- */
-class AtomicTransactionBuilder {
-    constructor(coinConfig) {
-        // Simplified internal transaction state (mirrors shape expected by existing builders)
-        // Simplified internal transaction state
-        this.transaction = {
-            _network: {},
-            _networkID: 0,
-            _blockchainID: Buffer.alloc(0),
-            _assetId: Buffer.alloc(0),
-            _fromAddresses: [],
-            _to: [],
-            _locktime: 0n,
-            _threshold: 1,
-            _fee: { fee: '0' },
-            hasCredentials: false,
-            setTransaction: function (_tx) {
-                this._tx = _tx;
-            },
-        };
-        this._coinConfig = coinConfig;
-    }
-    validateAmount(amount) {
-        if (amount <= 0n) {
-            throw new sdk_core_1.BuildTransactionError('Amount must be positive');
+const transactionBuilder_1 = require("./transactionBuilder");
+const transaction_1 = require("./transaction");
+const flarejs_1 = require("@flarenetwork/flarejs");
+const utils_1 = __importDefault(require("./utils"));
+class AtomicTransactionBuilder extends transactionBuilder_1.TransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this.recoverSigner = false;
+        this.transaction = new transaction_1.Transaction(_coinConfig);
+        this.transaction._fee.fee = this.fixedFee;
+    }
+    /** @inheritdoc */
+    async buildImplementation() {
+        await this.buildFlareTransaction();
+        this.setTransactionType(this.transactionType);
+        if (this.hasSigner()) {
+            for (const keyPair of this._signer) {
+                await this.transaction.sign(keyPair);
+            }
         }
+        return this.transaction;
+    }
+    /**
+     * Fee is fix for AVM atomic tx.
+     *
+     * @returns network.txFee
+     * @protected
+     */
+    get fixedFee() {
+        return this.transaction._network.txFee;
+    }
+    /**
+     * Set the transaction type
+     *
+     * @param {TransactionType} transactionType The transaction type to be set
+     */
+    setTransactionType(transactionType) {
+        this.transaction._type = transactionType;
     }
     /**
-     * Placeholder that should assemble inputs/outputs and credentials once UTXO + key logic is implemented.
+     * 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
      */
-    createInputOutput(_total) {
-        return { inputs: [], outputs: [], credentials: [] };
+    externalChainId(chainId) {
+        const newTargetChainId = typeof chainId === 'string' ? utils_1.default.cb58Decode(chainId) : Buffer.from(chainId);
+        this.validateChainId(newTargetChainId);
+        this._externalChainId = newTargetChainId;
+        return this;
     }
     /**
-     * Base initBuilder used by concrete builders. For now just returns this so fluent API works.
+     * Set the transaction fee
+     *
+     * @param {string | bigint} feeValue - the fee value
      */
-    initBuilder(_tx) {
+    fee(feeValue) {
+        const fee = typeof feeValue === 'string' ? feeValue : feeValue.toString();
+        this.transaction._fee.fee = fee;
         return this;
     }
+    /**
+     * Set the fee state for dynamic fee calculation (P-chain transactions)
+     *
+     * @param {FlrpFeeState} state - the fee state from the network
+     */
+    feeState(state) {
+        this.transaction._feeState = state;
+        return this;
+    }
+    /**
+     * Set the amount for the transaction
+     *
+     * @param {bigint | string} value - the amount to transfer
+     */
+    amount(value) {
+        const valueBigInt = typeof value === 'string' ? BigInt(value) : value;
+        this.validateAmount(valueBigInt);
+        this.transaction._amount = valueBigInt;
+        return this;
+    }
+    /**
+     * Compute addressesIndex for UTXOs following AVAX P approach.
+     * addressesIndex[senderIdx] = position of sender[senderIdx] in UTXO's address list
+     *
+     * IMPORTANT: UTXO addresses are sorted lexicographically by byte value to match
+     * on-chain storage order. The API may return addresses in arbitrary order, but
+     * on-chain UTXOs always store addresses in sorted order.
+     *
+     * Example:
+     *   A = user key, B = hsm key, C = backup key
+     *   sender (bitgoAddresses) = [ A, B, C ]
+     *   utxo.addresses (from API) = [ B, C, A ]
+     *   sorted utxo.addresses = [ A, B, C ] (sorted by hex value)
+     *   addressesIndex = [ 0, 1, 2 ]
+     *   (sender[0]=A is at position 0 in sorted UTXO, sender[1]=B is at position 1, etc.)
+     *
+     * @protected
+     */
+    computeAddressesIndex() {
+        const sender = this.transaction._fromAddresses;
+        this.transaction._utxos.forEach((utxo) => {
+            if (utxo.addressesIndex && utxo.addressesIndex.length > 0) {
+                return;
+            }
+            if (utxo.addresses && utxo.addresses.length > 0) {
+                const sortedAddresses = utils_1.default.sortAddressesByHex(utxo.addresses);
+                utxo.addresses = sortedAddresses;
+                const utxoAddresses = sortedAddresses.map((a) => utils_1.default.parseAddress(a));
+                utxo.addressesIndex = sender.map((a) => utxoAddresses.findIndex((u) => Buffer.compare(Buffer.from(u), Buffer.from(a)) === 0));
+            }
+        });
+    }
+    /**
+     * Compute addressesIndex from parsed transaction data.
+     * Similar to computeAddressesIndex() but used when parsing existing transactions
+     * via initBuilder().
+     *
+     * IMPORTANT: UTXO addresses are sorted lexicographically by byte value to match
+     * on-chain storage order, ensuring consistency with fresh builds.
+     *
+     * @protected
+     */
+    computeAddressesIndexFromParsed() {
+        const sender = this.transaction._fromAddresses;
+        if (!sender || sender.length === 0)
+            return;
+        this.transaction._utxos.forEach((utxo) => {
+            if (utxo.addresses && utxo.addresses.length > 0) {
+                const sortedAddresses = utils_1.default.sortAddressesByHex(utxo.addresses);
+                utxo.addresses = sortedAddresses;
+                const utxoAddresses = sortedAddresses.map((a) => utils_1.default.parseAddress(a));
+                utxo.addressesIndex = sender.map((senderAddr) => utxoAddresses.findIndex((utxoAddr) => Buffer.compare(Buffer.from(utxoAddr), Buffer.from(senderAddr)) === 0));
+            }
+        });
+    }
+    /**
+     * Validate UTXOs have consistent addresses.
+     * Note: UTXO threshold can differ from transaction threshold - each UTXO has its own
+     * signature requirement based on how it was created (e.g., change outputs may have threshold=1).
+     * @protected
+     */
+    validateUtxoAddresses() {
+        this.transaction._utxos.forEach((utxo) => {
+            if (!utxo) {
+                throw new sdk_core_1.BuildTransactionError('Utxo is undefined');
+            }
+            if (utxo.addressesIndex?.includes(-1)) {
+                throw new sdk_core_1.BuildTransactionError('Addresses are inconsistent: ' + utxo.txid);
+            }
+            if (utxo.threshold !== undefined && utxo.threshold <= 0) {
+                throw new sdk_core_1.BuildTransactionError('UTXO threshold must be positive: ' + utxo.txid);
+            }
+        });
+    }
+    /**
+     * Create credential with dynamic ordering based on addressesIndex from UTXO.
+     * Matches AVAX P behavior: signature order depends on UTXO address positions.
+     *
+     * addressesIndex[senderIdx] = utxoPosition tells us where each sender is in the UTXO.
+     * We create signature slots ordered by utxoPosition (smaller position = earlier slot).
+     *
+     * @param utxo - The UTXO to create credential for
+     * @param threshold - Number of signatures required for this specific UTXO
+     * @returns Credential with empty signatures ordered based on UTXO positions
+     * @protected
+     */
+    createCredentialForUtxo(utxo, threshold) {
+        const sender = this.transaction._fromAddresses;
+        const addressesIndex = utxo.addressesIndex ?? [];
+        // either user (0) or recovery (2)
+        const firstIndex = this.recoverSigner ? 2 : 0;
+        const bitgoIndex = 1;
+        if (threshold === 1) {
+            if (sender && sender.length > firstIndex && addressesIndex[firstIndex] !== undefined) {
+                return new flarejs_1.Credential([utils_1.default.createEmptySigWithAddress(Buffer.from(sender[firstIndex]).toString('hex'))]);
+            }
+            return new flarejs_1.Credential([utils_1.default.createNewSig('')]);
+        }
+        // If we have valid addressesIndex, use it to determine signature order
+        // addressesIndex[senderIdx] = position in UTXO
+        // Smaller position = earlier slot in signature array
+        if (addressesIndex.length >= 2 && sender && sender.length >= threshold) {
+            let emptySignatures;
+            if (addressesIndex[bitgoIndex] < addressesIndex[firstIndex]) {
+                emptySignatures = [
+                    utils_1.default.createNewSig(''),
+                    utils_1.default.createEmptySigWithAddress(Buffer.from(sender[firstIndex]).toString('hex')),
+                ];
+            }
+            else {
+                emptySignatures = [
+                    utils_1.default.createEmptySigWithAddress(Buffer.from(sender[firstIndex]).toString('hex')),
+                    utils_1.default.createNewSig(''),
+                ];
+            }
+            return new flarejs_1.Credential(emptySignatures);
+        }
+        const emptySignatures = [];
+        for (let i = 0; i < threshold; i++) {
+            emptySignatures.push(utils_1.default.createNewSig(''));
+        }
+        return new flarejs_1.Credential(emptySignatures);
+    }
+    /**
+     * Create AddressMap based on addressesIndex following AVAX P approach.
+     * Maps each sender address to its signature slot based on UTXO position ordering.
+     *
+     * addressesIndex[senderIdx] = utxoPosition
+     * Signature slots are ordered by utxoPosition (smaller = earlier slot).
+     *
+     * @param utxo - The UTXO to create AddressMap for
+     * @param threshold - Number of signatures required for this specific UTXO
+     * @returns AddressMap that maps addresses to signature slots based on UTXO order
+     * @protected
+     */
+    createAddressMapForUtxo(utxo, threshold) {
+        const addressMap = new flarejs_1.utils.AddressMap();
+        const sender = this.transaction._fromAddresses;
+        const addressesIndex = utxo.addressesIndex ?? [];
+        const firstIndex = this.recoverSigner ? 2 : 0;
+        const bitgoIndex = 1;
+        if (threshold === 1) {
+            if (sender && sender.length > firstIndex) {
+                addressMap.set(new flarejs_1.Address(sender[firstIndex]), 0);
+            }
+            else if (sender && sender.length > 0) {
+                addressMap.set(new flarejs_1.Address(sender[0]), 0);
+            }
+            return addressMap;
+        }
+        if (addressesIndex.length >= 2 && sender && sender.length >= threshold) {
+            if (addressesIndex[bitgoIndex] < addressesIndex[firstIndex]) {
+                addressMap.set(new flarejs_1.Address(sender[bitgoIndex]), 0);
+                addressMap.set(new flarejs_1.Address(sender[firstIndex]), 1);
+            }
+            else {
+                addressMap.set(new flarejs_1.Address(sender[firstIndex]), 0);
+                addressMap.set(new flarejs_1.Address(sender[bitgoIndex]), 1);
+            }
+            return addressMap;
+        }
+        if (sender && sender.length >= threshold) {
+            sender.slice(0, threshold).forEach((addr, i) => {
+                addressMap.set(new flarejs_1.Address(addr), i);
+            });
+        }
+        return addressMap;
+    }
 }
 exports.AtomicTransactionBuilder = AtomicTransactionBuilder;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"atomicTransactionBuilder.js","sourceRoot":"","sources":["../../../src/lib/atomicTransactionBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { BuildTransactionError, TransactionType } from '@bitgo-beta/sdk-core';\nimport { TransactionBuilder } from './transactionBuilder';\nimport { Transaction } from './transaction';\nimport { Credential, Address, utils as FlareUtils } from '@flarenetwork/flarejs';\nimport { DecodedUtxoObj } from './iface';\nimport { FlrpFeeState } from '@bitgo/public-types';\nimport utils from './utils';\n\nexport abstract class AtomicTransactionBuilder extends TransactionBuilder {\n  protected _externalChainId: Buffer;\n  protected recoverSigner = false;\n\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n    this.transaction = new Transaction(_coinConfig);\n    this.transaction._fee.fee = this.fixedFee;\n  }\n\n  /** @inheritdoc */\n  protected async buildImplementation(): Promise<Transaction> {\n    await this.buildFlareTransaction();\n    this.setTransactionType(this.transactionType);\n    if (this.hasSigner()) {\n      for (const keyPair of this._signer) {\n        await this.transaction.sign(keyPair);\n      }\n    }\n    return this.transaction;\n  }\n\n  /**\n   * Builds the Flare transaction. Transaction field is changed.\n   */\n  protected abstract buildFlareTransaction(): void | Promise<void>;\n\n  protected abstract get transactionType(): TransactionType;\n\n  /**\n   * Fee is fix for AVM atomic tx.\n   *\n   * @returns network.txFee\n   * @protected\n   */\n  protected get fixedFee(): string {\n    return this.transaction._network.txFee;\n  }\n\n  /**\n   * Set the transaction type\n   *\n   * @param {TransactionType} transactionType The transaction type to be set\n   */\n  setTransactionType(transactionType: TransactionType): void {\n    this.transaction._type = transactionType;\n  }\n\n  /**\n   * The internal chain is the one set for the coin in coinConfig.network. The external chain is the other chain involved.\n   * The external chain id is the source on import and the destination on export.\n   *\n   * @param {string} chainId - id of the external chain\n   */\n  externalChainId(chainId: string | Buffer): this {\n    const newTargetChainId = typeof chainId === 'string' ? utils.cb58Decode(chainId) : Buffer.from(chainId);\n    this.validateChainId(newTargetChainId);\n    this._externalChainId = newTargetChainId;\n    return this;\n  }\n\n  /**\n   * Set the transaction fee\n   *\n   * @param {string | bigint} feeValue - the fee value\n   */\n  fee(feeValue: string | bigint): this {\n    const fee = typeof feeValue === 'string' ? feeValue : feeValue.toString();\n    (this.transaction as Transaction)._fee.fee = fee;\n    return this;\n  }\n\n  /**\n   * Set the fee state for dynamic fee calculation (P-chain transactions)\n   *\n   * @param {FlrpFeeState} state - the fee state from the network\n   */\n  feeState(state: FlrpFeeState): this {\n    this.transaction._feeState = state;\n    return this;\n  }\n\n  /**\n   * Set the amount for the transaction\n   *\n   * @param {bigint | string} value - the amount to transfer\n   */\n  amount(value: bigint | string): this {\n    const valueBigInt = typeof value === 'string' ? BigInt(value) : value;\n    this.validateAmount(valueBigInt);\n    this.transaction._amount = valueBigInt;\n    return this;\n  }\n\n  /**\n   * Compute addressesIndex for UTXOs following AVAX P approach.\n   * addressesIndex[senderIdx] = position of sender[senderIdx] in UTXO's address list\n   *\n   * IMPORTANT: UTXO addresses are sorted lexicographically by byte value to match\n   * on-chain storage order. The API may return addresses in arbitrary order, but\n   * on-chain UTXOs always store addresses in sorted order.\n   *\n   * Example:\n   *   A = user key, B = hsm key, C = backup key\n   *   sender (bitgoAddresses) = [ A, B, C ]\n   *   utxo.addresses (from API) = [ B, C, A ]\n   *   sorted utxo.addresses = [ A, B, C ] (sorted by hex value)\n   *   addressesIndex = [ 0, 1, 2 ]\n   *   (sender[0]=A is at position 0 in sorted UTXO, sender[1]=B is at position 1, etc.)\n   *\n   * @protected\n   */\n  protected computeAddressesIndex(): void {\n    const sender = this.transaction._fromAddresses;\n\n    this.transaction._utxos.forEach((utxo) => {\n      if (utxo.addressesIndex && utxo.addressesIndex.length > 0) {\n        return;\n      }\n\n      if (utxo.addresses && utxo.addresses.length > 0) {\n        const sortedAddresses = utils.sortAddressesByHex(utxo.addresses);\n        utxo.addresses = sortedAddresses;\n\n        const utxoAddresses = sortedAddresses.map((a) => utils.parseAddress(a));\n        utxo.addressesIndex = sender.map((a) =>\n          utxoAddresses.findIndex((u) => Buffer.compare(Buffer.from(u), Buffer.from(a)) === 0)\n        );\n      }\n    });\n  }\n\n  /**\n   * Compute addressesIndex from parsed transaction data.\n   * Similar to computeAddressesIndex() but used when parsing existing transactions\n   * via initBuilder().\n   *\n   * IMPORTANT: UTXO addresses are sorted lexicographically by byte value to match\n   * on-chain storage order, ensuring consistency with fresh builds.\n   *\n   * @protected\n   */\n  protected computeAddressesIndexFromParsed(): void {\n    const sender = this.transaction._fromAddresses;\n    if (!sender || sender.length === 0) return;\n\n    this.transaction._utxos.forEach((utxo) => {\n      if (utxo.addresses && utxo.addresses.length > 0) {\n        const sortedAddresses = utils.sortAddressesByHex(utxo.addresses);\n        utxo.addresses = sortedAddresses;\n\n        const utxoAddresses = sortedAddresses.map((a) => utils.parseAddress(a));\n        utxo.addressesIndex = sender.map((senderAddr) =>\n          utxoAddresses.findIndex((utxoAddr) => Buffer.compare(Buffer.from(utxoAddr), Buffer.from(senderAddr)) === 0)\n        );\n      }\n    });\n  }\n\n  /**\n   * Validate UTXOs have consistent addresses.\n   * Note: UTXO threshold can differ from transaction threshold - each UTXO has its own\n   * signature requirement based on how it was created (e.g., change outputs may have threshold=1).\n   * @protected\n   */\n  protected validateUtxoAddresses(): void {\n    this.transaction._utxos.forEach((utxo) => {\n      if (!utxo) {\n        throw new BuildTransactionError('Utxo is undefined');\n      }\n      if (utxo.addressesIndex?.includes(-1)) {\n        throw new BuildTransactionError('Addresses are inconsistent: ' + utxo.txid);\n      }\n      if (utxo.threshold !== undefined && utxo.threshold <= 0) {\n        throw new BuildTransactionError('UTXO threshold must be positive: ' + utxo.txid);\n      }\n    });\n  }\n\n  /**\n   * Create credential with dynamic ordering based on addressesIndex from UTXO.\n   * Matches AVAX P behavior: signature order depends on UTXO address positions.\n   *\n   * addressesIndex[senderIdx] = utxoPosition tells us where each sender is in the UTXO.\n   * We create signature slots ordered by utxoPosition (smaller position = earlier slot).\n   *\n   * @param utxo - The UTXO to create credential for\n   * @param threshold - Number of signatures required for this specific UTXO\n   * @returns Credential with empty signatures ordered based on UTXO positions\n   * @protected\n   */\n  protected createCredentialForUtxo(utxo: DecodedUtxoObj, threshold: number): Credential {\n    const sender = this.transaction._fromAddresses;\n    const addressesIndex = utxo.addressesIndex ?? [];\n\n    // either user (0) or recovery (2)\n    const firstIndex = this.recoverSigner ? 2 : 0;\n    const bitgoIndex = 1;\n\n    if (threshold === 1) {\n      if (sender && sender.length > firstIndex && addressesIndex[firstIndex] !== undefined) {\n        return new Credential([utils.createEmptySigWithAddress(Buffer.from(sender[firstIndex]).toString('hex'))]);\n      }\n      return new Credential([utils.createNewSig('')]);\n    }\n\n    // If we have valid addressesIndex, use it to determine signature order\n    // addressesIndex[senderIdx] = position in UTXO\n    // Smaller position = earlier slot in signature array\n    if (addressesIndex.length >= 2 && sender && sender.length >= threshold) {\n      let emptySignatures: ReturnType<typeof utils.createNewSig>[];\n\n      if (addressesIndex[bitgoIndex] < addressesIndex[firstIndex]) {\n        emptySignatures = [\n          utils.createNewSig(''),\n          utils.createEmptySigWithAddress(Buffer.from(sender[firstIndex]).toString('hex')),\n        ];\n      } else {\n        emptySignatures = [\n          utils.createEmptySigWithAddress(Buffer.from(sender[firstIndex]).toString('hex')),\n          utils.createNewSig(''),\n        ];\n      }\n      return new Credential(emptySignatures);\n    }\n\n    const emptySignatures: ReturnType<typeof utils.createNewSig>[] = [];\n    for (let i = 0; i < threshold; i++) {\n      emptySignatures.push(utils.createNewSig(''));\n    }\n    return new Credential(emptySignatures);\n  }\n\n  /**\n   * Create AddressMap based on addressesIndex following AVAX P approach.\n   * Maps each sender address to its signature slot based on UTXO position ordering.\n   *\n   * addressesIndex[senderIdx] = utxoPosition\n   * Signature slots are ordered by utxoPosition (smaller = earlier slot).\n   *\n   * @param utxo - The UTXO to create AddressMap for\n   * @param threshold - Number of signatures required for this specific UTXO\n   * @returns AddressMap that maps addresses to signature slots based on UTXO order\n   * @protected\n   */\n  protected createAddressMapForUtxo(utxo: DecodedUtxoObj, threshold: number): FlareUtils.AddressMap {\n    const addressMap = new FlareUtils.AddressMap();\n    const sender = this.transaction._fromAddresses;\n    const addressesIndex = utxo.addressesIndex ?? [];\n\n    const firstIndex = this.recoverSigner ? 2 : 0;\n    const bitgoIndex = 1;\n\n    if (threshold === 1) {\n      if (sender && sender.length > firstIndex) {\n        addressMap.set(new Address(sender[firstIndex]), 0);\n      } else if (sender && sender.length > 0) {\n        addressMap.set(new Address(sender[0]), 0);\n      }\n      return addressMap;\n    }\n\n    if (addressesIndex.length >= 2 && sender && sender.length >= threshold) {\n      if (addressesIndex[bitgoIndex] < addressesIndex[firstIndex]) {\n        addressMap.set(new Address(sender[bitgoIndex]), 0);\n        addressMap.set(new Address(sender[firstIndex]), 1);\n      } else {\n        addressMap.set(new Address(sender[firstIndex]), 0);\n        addressMap.set(new Address(sender[bitgoIndex]), 1);\n      }\n      return addressMap;\n    }\n\n    if (sender && sender.length >= threshold) {\n      sender.slice(0, threshold).forEach((addr, i) => {\n        addressMap.set(new Address(addr), i);\n      });\n    }\n\n    return addressMap;\n  }\n}\n"]}