@bitgo/sdk-coin-flrp 1.9.1 → 1.10.0

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

@@ -2,7 +2,7 @@ import { TypeSymbols, Credential } from '@flarenetwork/flarejs';
 import { TransactionType } from '@bitgo/sdk-core';
 import { BaseCoin as CoinConfig } from '@bitgo/statics';
 import { Transaction } from './transaction';
-import { TransactionBuilder } from './transactionBuilder';
+import { AtomicTransactionBuilder } from './atomicTransactionBuilder';
 import { FlrpFeeState } from '@bitgo/public-types';
 import { Tx } from './iface';
 /**
@@ -13,8 +13,11 @@ import { Tx } from './iface';
  * - No BLS keys required
  * - Delegates to an existing validator's nodeID
  * - Rewards go to corresponding C-chain address
+ *
+ * Extends AtomicTransactionBuilder to inherit address sorting and credential management
+ * logic needed for proper multisig UTXO handling.
  */
-export declare class PermissionlessDelegatorTxBuilder extends TransactionBuilder {
+export declare class PermissionlessDelegatorTxBuilder extends AtomicTransactionBuilder {
     protected _nodeID: string;
     protected _startTime: bigint;
     protected _endTime: bigint;
@@ -73,14 +76,28 @@ export declare class PermissionlessDelegatorTxBuilder extends TransactionBuilder
      * @param type TypeSymbol from parsed transaction
      */
     verifyTxType(type: TypeSymbols): boolean;
+    /**
+     * Recover UTXOs from transaction inputs.
+     * Uses fromAddresses as proxy for UTXO addresses since we're reconstructing from a parsed transaction.
+     *
+     * @param inputs Array of TransferableInput from baseTx
+     * @param fromAddresses Wallet addresses to use as proxy for UTXO addresses
+     * @returns Array of decoded UTXO objects
+     * @private
+     */
+    private recoverUtxosFromInputs;
     protected buildImplementation(): Promise<Transaction>;
     /**
-     * Get the user's address (index 0) for delegation.
+     * Get the user's address (index 0) for default reward address.
+     *
+     * BitGo Convention for fromAddresses:
+     * - Index 0: User key (signer in normal mode)
+     * - Index 1: BitGo key (always a signer)
+     * - Index 2: Backup key (signer in recovery mode)
      *
-     * For delegation transactions, we use only the user key because:
-     * 1. On-chain rewards go to the C-chain address derived from the delegator's public key
-     * 2. Using the user key ensures rewards go to the user's corresponding C-chain address
-     * 3. The user key is at index 0 in the fromAddresses array (BitGo convention: [user, bitgo, backup])
+     * For delegation transactions, the user's address at index 0 is used as the default
+     * reward address parameter (though the parameter has no on-chain effect - rewards
+     * go to C-chain addresses derived from the P-chain addresses in stake outputs).
      *
      * @returns Buffer containing the user's address
      * @protected
@@ -91,11 +108,26 @@ export declare class PermissionlessDelegatorTxBuilder extends TransactionBuilder
      * Uses pvm.e.newAddPermissionlessDelegatorTx (post-Etna API).
      *
      * Note: The rewardAddresses parameter is accepted by the API but does NOT affect
-     * where rewards are sent on-chain - rewards always go to the C-chain address
-     * derived from the delegator's public key (user key at index 0).
+     * where rewards are sent on-chain. Rewards accrue to C-chain addresses derived
+     * from the P-chain addresses in the stake outputs. The stake outputs contain the
+     * addresses from fromAddressesBytes (sorted to match UTXO owner order).
      * @protected
      */
     protected buildFlareTransaction(): void;
+    /**
+     * Create a corrected AddPermissionlessDelegatorTx with the given change outputs.
+     * This is necessary because FlareJS's newAddPermissionlessDelegatorTx doesn't support setting
+     * the threshold and locktime for change outputs - it defaults to threshold=1.
+     *
+     * FlareJS declares baseTx.outputs as readonly, so we use Object.defineProperty
+     * to override the property with the corrected outputs. This is a workaround until
+     * FlareJS adds proper support for change output thresholds.
+     *
+     * @param originalTx - The original AddPermissionlessDelegatorTx
+     * @param correctedOutputs - The corrected change outputs with proper threshold
+     * @returns A new AddPermissionlessDelegatorTx with the corrected change outputs
+     */
+    private createCorrectedDelegatorTx;
     /**
      * Verify if the transaction type matches AddPermissionlessDelegatorTx
      * @param type TypeSymbol from parsed transaction

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

@@ -1 +1 @@
-{"version":3,"file":"permissionlessDelegatorTxBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/permissionlessDelegatorTxBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,WAAW,EAKX,UAAU,EAEX,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAuC,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACvF,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE1D,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAE7B;;;;;;;;GAQG;AACH,qBAAa,gCAAiC,SAAQ,kBAAkB;IACtE,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC;IAC1B,SAAS,CAAC,UAAU,EAAE,MAAM,CAAC;IAC7B,SAAS,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC3B,SAAS,CAAC,YAAY,EAAE,MAAM,CAAC;IAC/B,SAAS,CAAC,SAAS,EAAE,YAAY,GAAG,SAAS,CAAC;gBAElC,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC;IAK5C,SAAS,KAAK,eAAe,IAAI,eAAe,CAE/C;IAGD,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAYpC,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI;IAM/D,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAYzC;;;;;;;;OAQG;IACH,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAKpC;;;OAGG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAM5B;;;OAGG;IACH,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAKvC;;;OAGG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAKrC;;;OAGG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAOzC;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,YAAY,GAAG,IAAI;IAMtC;;;;;;;OAOG;IACH,WAAW,CAAC,EAAE,EAAE,EAAE,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,iBAAiB,CAAC,EAAE,UAAU,EAAE,GAAG,IAAI;IAgD9E;;;OAGG;IACH,YAAY,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO;cAIxB,mBAAmB,IAAI,OAAO,CAAC,WAAW,CAAC;IAW3D;;;;;;;;;;OAUG;IACH,SAAS,CAAC,cAAc,IAAI,MAAM;IAYlC;;;;;;;;OAQG;IACH,SAAS,CAAC,qBAAqB,IAAI,IAAI;IA4DvC;;;OAGG;IACH,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO;IAI/C,kBAAkB;IAClB,SAAS,KAAK,WAAW,IAAI,WAAW,CAEvC;IAED,SAAS,KAAK,WAAW,CAAC,WAAW,EAAE,WAAW,EAEjD;CACF"}
+{"version":3,"file":"permissionlessDelegatorTxBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/permissionlessDelegatorTxBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,WAAW,EAKX,UAAU,EAKX,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAuC,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACvF,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AAEtE,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,EAAE,EAAkB,MAAM,SAAS,CAAC;AAE7C;;;;;;;;;;;GAWG;AACH,qBAAa,gCAAiC,SAAQ,wBAAwB;IAC5E,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC;IAC1B,SAAS,CAAC,UAAU,EAAE,MAAM,CAAC;IAC7B,SAAS,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC3B,SAAS,CAAC,YAAY,EAAE,MAAM,CAAC;IAC/B,SAAS,CAAC,SAAS,EAAE,YAAY,GAAG,SAAS,CAAC;gBAElC,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC;IAK5C,SAAS,KAAK,eAAe,IAAI,eAAe,CAE/C;IAGD,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAYpC,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI;IAQ/D,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAYzC;;;;;;;;OAQG;IACH,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAKpC;;;OAGG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAM5B;;;OAGG;IACH,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAKvC;;;OAGG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAKrC;;;OAGG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAOzC;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,YAAY,GAAG,IAAI;IAMtC;;;;;;;OAOG;IACH,WAAW,CAAC,EAAE,EAAE,EAAE,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,iBAAiB,CAAC,EAAE,UAAU,EAAE,GAAG,IAAI;IAkF9E;;;OAGG;IACH,YAAY,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO;IAIxC;;;;;;;;OAQG;IACH,OAAO,CAAC,sBAAsB;cAuBd,mBAAmB,IAAI,OAAO,CAAC,WAAW,CAAC;IAW3D;;;;;;;;;;;;;;OAcG;IACH,SAAS,CAAC,cAAc,IAAI,MAAM;IAYlC;;;;;;;;;OASG;IACH,SAAS,CAAC,qBAAqB,IAAI,IAAI;IA0IvC;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,0BAA0B;IAiBlC;;;OAGG;IACH,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO;IAI/C,kBAAkB;IAClB,SAAS,KAAK,WAAW,IAAI,WAAW,CAEvC;IAED,SAAS,KAAK,WAAW,CAAC,WAAW,EAAE,WAAW,EAEjD;CAIF"}

package/dist/src/lib/permissionlessDelegatorTxBuilder.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PermissionlessDelegatorTxBuilder = void 0;
 const flarejs_1 = require("@flarenetwork/flarejs");
 const sdk_core_1 = require("@bitgo/sdk-core");
-const transactionBuilder_1 = require("./transactionBuilder");
+const atomicTransactionBuilder_1 = require("./atomicTransactionBuilder");
 const utils_1 = __importDefault(require("./utils"));
 /**
  * Builder for AddPermissionlessDelegator transactions on Flare P-Chain.
@@ -16,8 +16,11 @@ const utils_1 = __importDefault(require("./utils"));
  * - No BLS keys required
  * - Delegates to an existing validator's nodeID
  * - Rewards go to corresponding C-chain address
+ *
+ * Extends AtomicTransactionBuilder to inherit address sorting and credential management
+ * logic needed for proper multisig UTXO handling.
  */
-class PermissionlessDelegatorTxBuilder extends transactionBuilder_1.TransactionBuilder {
+class PermissionlessDelegatorTxBuilder extends atomicTransactionBuilder_1.AtomicTransactionBuilder {
     constructor(coinConfig) {
         super(coinConfig);
         this.transaction._fee.fee = this.transaction._network.txFee;
@@ -41,6 +44,8 @@ class PermissionlessDelegatorTxBuilder extends transactionBuilder_1.TransactionB
         if (endTime < startTime) {
             throw new sdk_core_1.BuildTransactionError('End date cannot be less than start date');
         }
+        // Note: Minimum duration validation is handled by the network.
+        // Flare P-chain requires minimum 14 days for delegation.
     }
     validateStakeAmount(amount) {
         const minDelegationStake = BigInt(this.transaction._network.minDelegationStake || this.transaction._network.minStake);
@@ -142,13 +147,39 @@ class PermissionlessDelegatorTxBuilder extends transactionBuilder_1.TransactionB
         if (rewardsOwner && rewardsOwner.addrs && rewardsOwner.addrs.length > 0) {
             this.transaction._rewardAddresses = rewardsOwner.addrs.map((addr) => Buffer.from(addr.toBytes()));
         }
+        // Recover UTXOs from baseTx inputs using stake output addresses as proxy
+        this.transaction._utxos = this.recoverUtxosFromInputs([...delegatorTx.baseTx.inputs], this.transaction._fromAddresses);
         const credentials = parsedCredentials || [];
         if (rawBytes && credentials.length > 0) {
             this.transaction._rawSignedBytes = rawBytes;
         }
-        // Create the UnsignedTx with parsed credentials
-        // AddressMaps will be empty as they're computed during signing
-        const unsignedTx = new flarejs_1.UnsignedTx(delegatorTx, [], new flarejs_1.utils.AddressMaps([]), credentials);
+        // Compute addressesIndex to map wallet positions to sorted UTXO positions
+        // Force recompute to ensure fresh mapping from parsed transaction
+        this.computeAddressesIndex(true);
+        // Use parsed credentials if available, otherwise create new ones based on sigIndices
+        // The sigIndices from the parsed transaction (stored in addressesIndex) determine
+        // the correct credential ordering for on-chain verification
+        const txCredentials = credentials.length > 0
+            ? credentials
+            : this.transaction._utxos.map((utxo) => {
+                const utxoThreshold = utxo.threshold || this.transaction._threshold;
+                const sigIndices = utxo.addressesIndex ?? [];
+                // Use sigIndices-based method if we have valid sigIndices from parsed transaction
+                if (sigIndices.length >= utxoThreshold && sigIndices.every((idx) => idx >= 0)) {
+                    return this.createCredentialForUtxo(utxo, utxoThreshold, sigIndices);
+                }
+                return this.createCredentialForUtxo(utxo, utxoThreshold);
+            });
+        // Create addressMaps using sigIndices from parsed transaction for consistency
+        const addressMaps = this.transaction._utxos.map((utxo) => {
+            const utxoThreshold = utxo.threshold || this.transaction._threshold;
+            const sigIndices = utxo.addressesIndex ?? [];
+            if (sigIndices.length >= utxoThreshold && sigIndices.every((idx) => idx >= 0)) {
+                return this.createAddressMapForUtxo(utxo, utxoThreshold, sigIndices);
+            }
+            return this.createAddressMapForUtxo(utxo, utxoThreshold);
+        });
+        const unsignedTx = new flarejs_1.UnsignedTx(delegatorTx, [], new flarejs_1.utils.AddressMaps(addressMaps), txCredentials);
         this.transaction.setTransaction(unsignedTx);
         return this;
     }
@@ -159,6 +190,33 @@ class PermissionlessDelegatorTxBuilder extends transactionBuilder_1.TransactionB
     verifyTxType(type) {
         return PermissionlessDelegatorTxBuilder.verifyTxType(type);
     }
+    /**
+     * Recover UTXOs from transaction inputs.
+     * Uses fromAddresses as proxy for UTXO addresses since we're reconstructing from a parsed transaction.
+     *
+     * @param inputs Array of TransferableInput from baseTx
+     * @param fromAddresses Wallet addresses to use as proxy for UTXO addresses
+     * @returns Array of decoded UTXO objects
+     * @private
+     */
+    recoverUtxosFromInputs(inputs, fromAddresses) {
+        const proxyAddresses = fromAddresses.map((addr) => utils_1.default.addressToString(this.transaction._network.hrp, this.transaction._network.alias, Buffer.from(addr)));
+        return inputs.map((input) => {
+            const utxoId = input.utxoID;
+            const transferInput = input.input;
+            const sigIndicies = transferInput.sigIndicies();
+            const utxo = {
+                outputID: 7, // SECP256K1 Transfer Output type
+                amount: input.amount().toString(),
+                txid: utils_1.default.cb58Encode(Buffer.from(utxoId.txID.toBytes())),
+                outputidx: utxoId.outputIdx.value().toString(),
+                threshold: sigIndicies.length || this.transaction._threshold,
+                addresses: proxyAddresses,
+                addressesIndex: sigIndicies,
+            };
+            return utxo;
+        });
+    }
     async buildImplementation() {
         this.buildFlareTransaction();
         this.transaction.setTransactionType(this.transactionType);
@@ -170,18 +228,22 @@ class PermissionlessDelegatorTxBuilder extends transactionBuilder_1.TransactionB
         return this.transaction;
     }
     /**
-     * Get the user's address (index 0) for delegation.
+     * Get the user's address (index 0) for default reward address.
+     *
+     * BitGo Convention for fromAddresses:
+     * - Index 0: User key (signer in normal mode)
+     * - Index 1: BitGo key (always a signer)
+     * - Index 2: Backup key (signer in recovery mode)
      *
-     * For delegation transactions, we use only the user key because:
-     * 1. On-chain rewards go to the C-chain address derived from the delegator's public key
-     * 2. Using the user key ensures rewards go to the user's corresponding C-chain address
-     * 3. The user key is at index 0 in the fromAddresses array (BitGo convention: [user, bitgo, backup])
+     * For delegation transactions, the user's address at index 0 is used as the default
+     * reward address parameter (though the parameter has no on-chain effect - rewards
+     * go to C-chain addresses derived from the P-chain addresses in stake outputs).
      *
      * @returns Buffer containing the user's address
      * @protected
      */
     getUserAddress() {
-        const userIndex = 0;
+        const userIndex = 0; // BitGo convention: user is always at index 0
         if (!this.transaction._fromAddresses || this.transaction._fromAddresses.length <= userIndex) {
             throw new sdk_core_1.BuildTransactionError('User address (index 0) is required for delegation');
         }
@@ -196,8 +258,9 @@ class PermissionlessDelegatorTxBuilder extends transactionBuilder_1.TransactionB
      * Uses pvm.e.newAddPermissionlessDelegatorTx (post-Etna API).
      *
      * Note: The rewardAddresses parameter is accepted by the API but does NOT affect
-     * where rewards are sent on-chain - rewards always go to the C-chain address
-     * derived from the delegator's public key (user key at index 0).
+     * where rewards are sent on-chain. Rewards accrue to C-chain addresses derived
+     * from the P-chain addresses in the stake outputs. The stake outputs contain the
+     * addresses from fromAddressesBytes (sorted to match UTXO owner order).
      * @protected
      */
     buildFlareTransaction() {
@@ -226,20 +289,26 @@ class PermissionlessDelegatorTxBuilder extends transactionBuilder_1.TransactionB
             throw new sdk_core_1.BuildTransactionError('Fee state is required for delegation');
         }
         this.validateStakeDuration(this._startTime, this._endTime);
+        // Compute addressesIndex to map wallet key indices to sorted UTXO address positions
+        this.computeAddressesIndex();
         // Convert decoded UTXOs to FlareJS Utxo objects
         if (!this.transaction._utxos || this.transaction._utxos.length === 0) {
             throw new sdk_core_1.BuildTransactionError('UTXOs are required for delegation');
         }
         const utxos = utils_1.default.decodedToUtxos(this.transaction._utxos, this.transaction._network.assetId);
-        // Use only the user key (index 0) for fromAddressesBytes
-        // This ensures the C-chain reward address is derived from the user's public key
+        // Get user address for default reward address derivation
         const userAddress = this.getUserAddress();
         const rewardAddresses = this.transaction._rewardAddresses.length > 0 ? this.transaction._rewardAddresses : [userAddress];
         // Use Etna (post-fork) API - pvm.e.newAddPermissionlessDelegatorTx
+        // IMPORTANT: Use getSigningAddresses() to get the correct 2 signing keys
+        // This ensures proper key selection for both normal and recovery modes:
+        // - Normal mode: user (index 0) + bitgo (index 1)
+        // - Recovery mode: backup (index 2) + bitgo (index 1)
+        const signingAddresses = this.getSigningAddresses();
         const delegatorTx = flarejs_1.pvm.e.newAddPermissionlessDelegatorTx({
             end: this._endTime,
             feeState: this._feeState,
-            fromAddressesBytes: [userAddress],
+            fromAddressesBytes: signingAddresses,
             nodeId: this._nodeID,
             rewardAddresses: rewardAddresses,
             start: this._startTime,
@@ -247,7 +316,72 @@ class PermissionlessDelegatorTxBuilder extends transactionBuilder_1.TransactionB
             utxos,
             weight: this._stakeAmount,
         }, this.transaction._context);
-        this.transaction.setTransaction(delegatorTx);
+        // Fix change output threshold bug (same as ExportInPTxBuilder)
+        const flareUnsignedTx = delegatorTx;
+        const innerTx = flareUnsignedTx.getTx();
+        const changeOutputs = innerTx.baseTx.outputs;
+        let correctedDelegatorTx = innerTx;
+        if (changeOutputs.length > 0 && this.transaction._threshold > 1) {
+            // Only apply fix for multisig wallets (threshold > 1)
+            const allWalletAddresses = this.transaction._fromAddresses.map((addr) => Buffer.from(addr));
+            const correctedChangeOutputs = changeOutputs.map((output) => {
+                const transferOut = output.output;
+                const assetIdStr = utils_1.default.flareIdString(Buffer.from(output.assetId.toBytes()).toString('hex')).toString();
+                return flarejs_1.TransferableOutput.fromNative(assetIdStr, transferOut.amount(), allWalletAddresses, this.transaction._locktime, this.transaction._threshold // Fix: use wallet's threshold instead of FlareJS's default (1)
+                );
+            });
+            correctedDelegatorTx = this.createCorrectedDelegatorTx(innerTx, correctedChangeOutputs);
+        }
+        // Recreate credentials and addressMaps from corrected transaction inputs
+        // This follows the same pattern as ExportInPTxBuilder to ensure proper signing
+        const utxosWithIndex = correctedDelegatorTx.baseTx.inputs.map((input) => {
+            const inputTxid = utils_1.default.cb58Encode(Buffer.from(input.utxoID.txID.toBytes()));
+            const inputOutputIdx = input.utxoID.outputIdx.value().toString();
+            const originalUtxo = this.transaction._utxos.find((utxo) => utxo.txid === inputTxid && utxo.outputidx === inputOutputIdx);
+            if (!originalUtxo) {
+                throw new sdk_core_1.BuildTransactionError(`Could not find matching UTXO for input ${inputTxid}:${inputOutputIdx}`);
+            }
+            const transferInput = input.input;
+            const actualSigIndices = transferInput.sigIndicies();
+            return {
+                ...originalUtxo,
+                addressesIndex: originalUtxo.addressesIndex,
+                addresses: originalUtxo.addresses,
+                threshold: originalUtxo.threshold || this.transaction._threshold,
+                actualSigIndices,
+            };
+        });
+        this.transaction._utxos = utxosWithIndex;
+        const txCredentials = utxosWithIndex.map((utxo) => this.createCredentialForUtxo(utxo, utxo.threshold, utxo.actualSigIndices));
+        const addressMaps = utxosWithIndex.map((utxo) => this.createAddressMapForUtxo(utxo, utxo.threshold, utxo.actualSigIndices));
+        // Create new UnsignedTx with corrected change outputs and proper credentials
+        const fixedUnsignedTx = new flarejs_1.UnsignedTx(correctedDelegatorTx, [], new flarejs_1.utils.AddressMaps(addressMaps), txCredentials);
+        this.transaction.setTransaction(fixedUnsignedTx);
+    }
+    /**
+     * Create a corrected AddPermissionlessDelegatorTx with the given change outputs.
+     * This is necessary because FlareJS's newAddPermissionlessDelegatorTx doesn't support setting
+     * the threshold and locktime for change outputs - it defaults to threshold=1.
+     *
+     * FlareJS declares baseTx.outputs as readonly, so we use Object.defineProperty
+     * to override the property with the corrected outputs. This is a workaround until
+     * FlareJS adds proper support for change output thresholds.
+     *
+     * @param originalTx - The original AddPermissionlessDelegatorTx
+     * @param correctedOutputs - The corrected change outputs with proper threshold
+     * @returns A new AddPermissionlessDelegatorTx with the corrected change outputs
+     */
+    createCorrectedDelegatorTx(originalTx, correctedOutputs) {
+        // FlareJS declares baseTx.outputs as `public readonly outputs: readonly TransferableOutput[]`
+        // We use Object.defineProperty to override the readonly property with our corrected outputs.
+        // This is necessary because FlareJS's newAddPermissionlessDelegatorTx doesn't support change output threshold/locktime.
+        Object.defineProperty(originalTx.baseTx, 'outputs', {
+            value: correctedOutputs,
+            writable: false,
+            enumerable: true,
+            configurable: true,
+        });
+        return originalTx;
     }
     /**
      * Verify if the transaction type matches AddPermissionlessDelegatorTx
@@ -265,4 +399,4 @@ class PermissionlessDelegatorTxBuilder extends transactionBuilder_1.TransactionB
     }
 }
 exports.PermissionlessDelegatorTxBuilder = PermissionlessDelegatorTxBuilder;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"permissionlessDelegatorTxBuilder.js","sourceRoot":"","sources":["../../../src/lib/permissionlessDelegatorTxBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  utils as FlareUtils,\n  TypeSymbols,\n  pvm,\n  networkIDs,\n  UnsignedTx,\n  pvmSerial,\n  Credential,\n  TransferOutput,\n} from '@flarenetwork/flarejs';\nimport { BuildTransactionError, NotSupported, TransactionType } from '@bitgo/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo/statics';\nimport { Transaction } from './transaction';\nimport { TransactionBuilder } from './transactionBuilder';\nimport utils from './utils';\nimport { FlrpFeeState } from '@bitgo/public-types';\nimport { Tx } from './iface';\n\n/**\n * Builder for AddPermissionlessDelegator transactions on Flare P-Chain.\n *\n * This builder creates delegation transactions where a user delegates stake\n * to an existing validator. Unlike AddPermissionlessValidator:\n * - No BLS keys required\n * - Delegates to an existing validator's nodeID\n * - Rewards go to corresponding C-chain address\n */\nexport class PermissionlessDelegatorTxBuilder extends TransactionBuilder {\n  protected _nodeID: string;\n  protected _startTime: bigint;\n  protected _endTime: bigint;\n  protected _stakeAmount: bigint;\n  protected _feeState: FlrpFeeState | undefined;\n\n  constructor(coinConfig: Readonly<CoinConfig>) {\n    super(coinConfig);\n    this.transaction._fee.fee = this.transaction._network.txFee;\n  }\n\n  protected get transactionType(): TransactionType {\n    return TransactionType.AddPermissionlessDelegator;\n  }\n\n  // Validation methods\n  validateNodeID(nodeID: string): void {\n    if (!nodeID) {\n      throw new BuildTransactionError('Invalid transaction: missing nodeID');\n    }\n    if (!nodeID.startsWith('NodeID-')) {\n      throw new BuildTransactionError('Invalid transaction: invalid NodeID tag');\n    }\n    if (!utils.isValidNodeID(nodeID)) {\n      throw new BuildTransactionError('Invalid transaction: NodeID is not in cb58 format');\n    }\n  }\n\n  validateStakeDuration(startTime: bigint, endTime: bigint): void {\n    if (endTime < startTime) {\n      throw new BuildTransactionError('End date cannot be less than start date');\n    }\n  }\n\n  validateStakeAmount(amount: bigint): void {\n    const minDelegationStake = BigInt(\n      this.transaction._network.minDelegationStake || this.transaction._network.minStake\n    );\n    if (amount < minDelegationStake) {\n      throw new BuildTransactionError(\n        'Minimum delegation amount is ' + Number(minDelegationStake) / 1000000000 + ' FLR.'\n      );\n    }\n  }\n\n  // Builder methods\n  /**\n   *\n   * NOTE: On Flare, staking rewards are distributed on C-chain (not P-chain).\n   * Rewards go to the C-chain address derived from the same public key as\n   * the P-chain staking address. This parameter is passed to the FlareJS API\n   * but has NO on-chain effect on reward distribution.\n   *\n   * @param address P-chain address in Bech32 format (e.g., \"P-flare1...\" or \"P-costwo1...\")\n   */\n  rewardAddress(address: string): this {\n    this.transaction._rewardAddresses = [utils.parseAddress(address)];\n    return this;\n  }\n\n  /**\n   * Set the validator node ID to delegate to\n   * @param nodeID Validator node ID in format \"NodeID-...\"\n   */\n  nodeID(nodeID: string): this {\n    this.validateNodeID(nodeID);\n    this._nodeID = nodeID;\n    return this;\n  }\n\n  /**\n   * Set the start time for the delegation period\n   * @param value Unix timestamp in seconds\n   */\n  startTime(value: string | number): this {\n    this._startTime = BigInt(value);\n    return this;\n  }\n\n  /**\n   * Set the end time for the delegation period\n   * @param value Unix timestamp in seconds\n   */\n  endTime(value: string | number): this {\n    this._endTime = BigInt(value);\n    return this;\n  }\n\n  /**\n   * Set the amount to stake/delegate\n   * @param value Amount in nanoFLR (wei)\n   */\n  stakeAmount(value: bigint | string): this {\n    const valueBigInt = typeof value === 'bigint' ? value : BigInt(value);\n    this.validateStakeAmount(valueBigInt);\n    this._stakeAmount = valueBigInt;\n    return this;\n  }\n\n  /**\n   * @param feeState Fee state from P-chain\n   */\n  feeState(feeState: FlrpFeeState): this {\n    this._feeState = feeState;\n    this.transaction._feeState = feeState;\n    return this;\n  }\n\n  /**\n   * Initialize builder from a parsed AddPermissionlessDelegatorTx.\n   * Used to reconstruct the builder state from a raw transaction for signing.\n   *\n   * @param tx The parsed transaction\n   * @param rawBytes Optional raw transaction bytes\n   * @param parsedCredentials Optional credentials from the parsed transaction\n   */\n  initBuilder(tx: Tx, rawBytes?: Buffer, parsedCredentials?: Credential[]): this {\n    const delegatorTx = tx as pvmSerial.AddPermissionlessDelegatorTx;\n\n    if (!this.verifyTxType(delegatorTx._type)) {\n      throw new NotSupported('Transaction cannot be parsed or has an unsupported transaction type');\n    }\n\n    // Extract validator info (nodeID, startTime, endTime, weight/stakeAmount)\n    const validator = delegatorTx.subnetValidator.validator;\n    this._nodeID = validator.nodeId.toString();\n    this._startTime = validator.startTime.value();\n    this._endTime = validator.endTime.value();\n    this._stakeAmount = validator.weight.value();\n\n    // Extract from addresses from stake outputs\n    // In delegation transactions, stake outputs contain the owner addresses\n    const stakeOutputs = delegatorTx.stake;\n    if (stakeOutputs.length > 0) {\n      const firstStakeOutput = stakeOutputs[0];\n      // Stake outputs use TransferOutput type with outputOwners property\n      const transferOutput = firstStakeOutput.output as TransferOutput;\n      const outputOwners = transferOutput.outputOwners;\n      if (outputOwners) {\n        this.transaction._threshold = outputOwners.threshold.value();\n        this.transaction._fromAddresses = outputOwners.addrs.map((addr) => Buffer.from(addr.toBytes()));\n      }\n    }\n\n    // Extract reward addresses from delegatorRewardsOwner\n    const rewardsOwner = delegatorTx.getDelegatorRewardsOwner();\n    if (rewardsOwner && rewardsOwner.addrs && rewardsOwner.addrs.length > 0) {\n      this.transaction._rewardAddresses = rewardsOwner.addrs.map((addr) => Buffer.from(addr.toBytes()));\n    }\n\n    const credentials = parsedCredentials || [];\n\n    if (rawBytes && credentials.length > 0) {\n      this.transaction._rawSignedBytes = rawBytes;\n    }\n\n    // Create the UnsignedTx with parsed credentials\n    // AddressMaps will be empty as they're computed during signing\n    const unsignedTx = new UnsignedTx(delegatorTx, [], new FlareUtils.AddressMaps([]), credentials);\n\n    this.transaction.setTransaction(unsignedTx);\n    return this;\n  }\n\n  /**\n   * Instance method to verify transaction type\n   * @param type TypeSymbol from parsed transaction\n   */\n  verifyTxType(type: TypeSymbols): boolean {\n    return PermissionlessDelegatorTxBuilder.verifyTxType(type);\n  }\n\n  protected async buildImplementation(): Promise<Transaction> {\n    this.buildFlareTransaction();\n    this.transaction.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   * Get the user's address (index 0) for delegation.\n   *\n   * For delegation transactions, we use only the user key because:\n   * 1. On-chain rewards go to the C-chain address derived from the delegator's public key\n   * 2. Using the user key ensures rewards go to the user's corresponding C-chain address\n   * 3. The user key is at index 0 in the fromAddresses array (BitGo convention: [user, bitgo, backup])\n   *\n   * @returns Buffer containing the user's address\n   * @protected\n   */\n  protected getUserAddress(): Buffer {\n    const userIndex = 0;\n    if (!this.transaction._fromAddresses || this.transaction._fromAddresses.length <= userIndex) {\n      throw new BuildTransactionError('User address (index 0) is required for delegation');\n    }\n    const userAddress = Buffer.from(this.transaction._fromAddresses[userIndex]);\n    if (userAddress.length !== 20) {\n      throw new BuildTransactionError(`Invalid user address length: expected 20 bytes, got ${userAddress.length}`);\n    }\n    return userAddress;\n  }\n\n  /**\n   * Build the permissionless delegator transaction using FlareJS.\n   * Uses pvm.e.newAddPermissionlessDelegatorTx (post-Etna API).\n   *\n   * Note: The rewardAddresses parameter is accepted by the API but does NOT affect\n   * where rewards are sent on-chain - rewards always go to the C-chain address\n   * derived from the delegator's public key (user key at index 0).\n   * @protected\n   */\n  protected buildFlareTransaction(): void {\n    if (this.transaction.hasCredentials) return;\n\n    // Validate required fields\n    if (!this._nodeID) {\n      throw new BuildTransactionError('NodeID is required for delegation');\n    }\n    if (!this._startTime) {\n      throw new BuildTransactionError('Start time is required for delegation');\n    }\n    if (!this._endTime) {\n      throw new BuildTransactionError('End time is required for delegation');\n    }\n    if (!this._stakeAmount) {\n      throw new BuildTransactionError('Stake amount is required for delegation');\n    }\n    if (!this.transaction._context) {\n      throw new BuildTransactionError('Context is required for delegation');\n    }\n    if (!this.transaction._fromAddresses || this.transaction._fromAddresses.length === 0) {\n      throw new BuildTransactionError('From addresses are required for delegation');\n    }\n    if (!this._feeState) {\n      throw new BuildTransactionError('Fee state is required for delegation');\n    }\n\n    this.validateStakeDuration(this._startTime, this._endTime);\n\n    // Convert decoded UTXOs to FlareJS Utxo objects\n    if (!this.transaction._utxos || this.transaction._utxos.length === 0) {\n      throw new BuildTransactionError('UTXOs are required for delegation');\n    }\n    const utxos = utils.decodedToUtxos(this.transaction._utxos, this.transaction._network.assetId);\n\n    // Use only the user key (index 0) for fromAddressesBytes\n    // This ensures the C-chain reward address is derived from the user's public key\n    const userAddress = this.getUserAddress();\n\n    const rewardAddresses =\n      this.transaction._rewardAddresses.length > 0 ? this.transaction._rewardAddresses : [userAddress];\n\n    // Use Etna (post-fork) API - pvm.e.newAddPermissionlessDelegatorTx\n    const delegatorTx = pvm.e.newAddPermissionlessDelegatorTx(\n      {\n        end: this._endTime,\n        feeState: this._feeState,\n        fromAddressesBytes: [userAddress],\n        nodeId: this._nodeID,\n        rewardAddresses: rewardAddresses,\n        start: this._startTime,\n        subnetId: networkIDs.PrimaryNetworkID.toString(),\n        utxos,\n        weight: this._stakeAmount,\n      },\n      this.transaction._context\n    );\n\n    this.transaction.setTransaction(delegatorTx as UnsignedTx);\n  }\n\n  /**\n   * Verify if the transaction type matches AddPermissionlessDelegatorTx\n   * @param type TypeSymbol from parsed transaction\n   */\n  static verifyTxType(type: TypeSymbols): boolean {\n    return type === TypeSymbols.AddPermissionlessDelegatorTx;\n  }\n\n  /** @inheritdoc */\n  protected get transaction(): Transaction {\n    return this._transaction;\n  }\n\n  protected set transaction(transaction: Transaction) {\n    this._transaction = transaction;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"permissionlessDelegatorTxBuilder.js","sourceRoot":"","sources":["../../../src/lib/permissionlessDelegatorTxBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  utils as FlareUtils,\n  TypeSymbols,\n  pvm,\n  networkIDs,\n  UnsignedTx,\n  pvmSerial,\n  Credential,\n  TransferOutput,\n  TransferableOutput,\n  TransferInput,\n  TransferableInput,\n} from '@flarenetwork/flarejs';\nimport { BuildTransactionError, NotSupported, TransactionType } from '@bitgo/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo/statics';\nimport { Transaction } from './transaction';\nimport { AtomicTransactionBuilder } from './atomicTransactionBuilder';\nimport utils from './utils';\nimport { FlrpFeeState } from '@bitgo/public-types';\nimport { Tx, DecodedUtxoObj } from './iface';\n\n/**\n * Builder for AddPermissionlessDelegator transactions on Flare P-Chain.\n *\n * This builder creates delegation transactions where a user delegates stake\n * to an existing validator. Unlike AddPermissionlessValidator:\n * - No BLS keys required\n * - Delegates to an existing validator's nodeID\n * - Rewards go to corresponding C-chain address\n *\n * Extends AtomicTransactionBuilder to inherit address sorting and credential management\n * logic needed for proper multisig UTXO handling.\n */\nexport class PermissionlessDelegatorTxBuilder extends AtomicTransactionBuilder {\n  protected _nodeID: string;\n  protected _startTime: bigint;\n  protected _endTime: bigint;\n  protected _stakeAmount: bigint;\n  protected _feeState: FlrpFeeState | undefined;\n\n  constructor(coinConfig: Readonly<CoinConfig>) {\n    super(coinConfig);\n    this.transaction._fee.fee = this.transaction._network.txFee;\n  }\n\n  protected get transactionType(): TransactionType {\n    return TransactionType.AddPermissionlessDelegator;\n  }\n\n  // Validation methods\n  validateNodeID(nodeID: string): void {\n    if (!nodeID) {\n      throw new BuildTransactionError('Invalid transaction: missing nodeID');\n    }\n    if (!nodeID.startsWith('NodeID-')) {\n      throw new BuildTransactionError('Invalid transaction: invalid NodeID tag');\n    }\n    if (!utils.isValidNodeID(nodeID)) {\n      throw new BuildTransactionError('Invalid transaction: NodeID is not in cb58 format');\n    }\n  }\n\n  validateStakeDuration(startTime: bigint, endTime: bigint): void {\n    if (endTime < startTime) {\n      throw new BuildTransactionError('End date cannot be less than start date');\n    }\n    // Note: Minimum duration validation is handled by the network.\n    // Flare P-chain requires minimum 14 days for delegation.\n  }\n\n  validateStakeAmount(amount: bigint): void {\n    const minDelegationStake = BigInt(\n      this.transaction._network.minDelegationStake || this.transaction._network.minStake\n    );\n    if (amount < minDelegationStake) {\n      throw new BuildTransactionError(\n        'Minimum delegation amount is ' + Number(minDelegationStake) / 1000000000 + ' FLR.'\n      );\n    }\n  }\n\n  // Builder methods\n  /**\n   *\n   * NOTE: On Flare, staking rewards are distributed on C-chain (not P-chain).\n   * Rewards go to the C-chain address derived from the same public key as\n   * the P-chain staking address. This parameter is passed to the FlareJS API\n   * but has NO on-chain effect on reward distribution.\n   *\n   * @param address P-chain address in Bech32 format (e.g., \"P-flare1...\" or \"P-costwo1...\")\n   */\n  rewardAddress(address: string): this {\n    this.transaction._rewardAddresses = [utils.parseAddress(address)];\n    return this;\n  }\n\n  /**\n   * Set the validator node ID to delegate to\n   * @param nodeID Validator node ID in format \"NodeID-...\"\n   */\n  nodeID(nodeID: string): this {\n    this.validateNodeID(nodeID);\n    this._nodeID = nodeID;\n    return this;\n  }\n\n  /**\n   * Set the start time for the delegation period\n   * @param value Unix timestamp in seconds\n   */\n  startTime(value: string | number): this {\n    this._startTime = BigInt(value);\n    return this;\n  }\n\n  /**\n   * Set the end time for the delegation period\n   * @param value Unix timestamp in seconds\n   */\n  endTime(value: string | number): this {\n    this._endTime = BigInt(value);\n    return this;\n  }\n\n  /**\n   * Set the amount to stake/delegate\n   * @param value Amount in nanoFLR (wei)\n   */\n  stakeAmount(value: bigint | string): this {\n    const valueBigInt = typeof value === 'bigint' ? value : BigInt(value);\n    this.validateStakeAmount(valueBigInt);\n    this._stakeAmount = valueBigInt;\n    return this;\n  }\n\n  /**\n   * @param feeState Fee state from P-chain\n   */\n  feeState(feeState: FlrpFeeState): this {\n    this._feeState = feeState;\n    this.transaction._feeState = feeState;\n    return this;\n  }\n\n  /**\n   * Initialize builder from a parsed AddPermissionlessDelegatorTx.\n   * Used to reconstruct the builder state from a raw transaction for signing.\n   *\n   * @param tx The parsed transaction\n   * @param rawBytes Optional raw transaction bytes\n   * @param parsedCredentials Optional credentials from the parsed transaction\n   */\n  initBuilder(tx: Tx, rawBytes?: Buffer, parsedCredentials?: Credential[]): this {\n    const delegatorTx = tx as pvmSerial.AddPermissionlessDelegatorTx;\n\n    if (!this.verifyTxType(delegatorTx._type)) {\n      throw new NotSupported('Transaction cannot be parsed or has an unsupported transaction type');\n    }\n\n    // Extract validator info (nodeID, startTime, endTime, weight/stakeAmount)\n    const validator = delegatorTx.subnetValidator.validator;\n    this._nodeID = validator.nodeId.toString();\n    this._startTime = validator.startTime.value();\n    this._endTime = validator.endTime.value();\n    this._stakeAmount = validator.weight.value();\n\n    // Extract from addresses from stake outputs\n    // In delegation transactions, stake outputs contain the owner addresses\n    const stakeOutputs = delegatorTx.stake;\n    if (stakeOutputs.length > 0) {\n      const firstStakeOutput = stakeOutputs[0];\n      // Stake outputs use TransferOutput type with outputOwners property\n      const transferOutput = firstStakeOutput.output as TransferOutput;\n      const outputOwners = transferOutput.outputOwners;\n      if (outputOwners) {\n        this.transaction._threshold = outputOwners.threshold.value();\n        this.transaction._fromAddresses = outputOwners.addrs.map((addr) => Buffer.from(addr.toBytes()));\n      }\n    }\n\n    // Extract reward addresses from delegatorRewardsOwner\n    const rewardsOwner = delegatorTx.getDelegatorRewardsOwner();\n    if (rewardsOwner && rewardsOwner.addrs && rewardsOwner.addrs.length > 0) {\n      this.transaction._rewardAddresses = rewardsOwner.addrs.map((addr) => Buffer.from(addr.toBytes()));\n    }\n\n    // Recover UTXOs from baseTx inputs using stake output addresses as proxy\n    this.transaction._utxos = this.recoverUtxosFromInputs(\n      [...delegatorTx.baseTx.inputs],\n      this.transaction._fromAddresses\n    );\n\n    const credentials = parsedCredentials || [];\n\n    if (rawBytes && credentials.length > 0) {\n      this.transaction._rawSignedBytes = rawBytes;\n    }\n\n    // Compute addressesIndex to map wallet positions to sorted UTXO positions\n    // Force recompute to ensure fresh mapping from parsed transaction\n    this.computeAddressesIndex(true);\n\n    // Use parsed credentials if available, otherwise create new ones based on sigIndices\n    // The sigIndices from the parsed transaction (stored in addressesIndex) determine\n    // the correct credential ordering for on-chain verification\n    const txCredentials =\n      credentials.length > 0\n        ? credentials\n        : this.transaction._utxos.map((utxo) => {\n            const utxoThreshold = utxo.threshold || this.transaction._threshold;\n            const sigIndices = utxo.addressesIndex ?? [];\n            // Use sigIndices-based method if we have valid sigIndices from parsed transaction\n            if (sigIndices.length >= utxoThreshold && sigIndices.every((idx) => idx >= 0)) {\n              return this.createCredentialForUtxo(utxo, utxoThreshold, sigIndices);\n            }\n            return this.createCredentialForUtxo(utxo, utxoThreshold);\n          });\n\n    // Create addressMaps using sigIndices from parsed transaction for consistency\n    const addressMaps = this.transaction._utxos.map((utxo) => {\n      const utxoThreshold = utxo.threshold || this.transaction._threshold;\n      const sigIndices = utxo.addressesIndex ?? [];\n      if (sigIndices.length >= utxoThreshold && sigIndices.every((idx) => idx >= 0)) {\n        return this.createAddressMapForUtxo(utxo, utxoThreshold, sigIndices);\n      }\n      return this.createAddressMapForUtxo(utxo, utxoThreshold);\n    });\n\n    const unsignedTx = new UnsignedTx(delegatorTx, [], new FlareUtils.AddressMaps(addressMaps), txCredentials);\n\n    this.transaction.setTransaction(unsignedTx);\n    return this;\n  }\n\n  /**\n   * Instance method to verify transaction type\n   * @param type TypeSymbol from parsed transaction\n   */\n  verifyTxType(type: TypeSymbols): boolean {\n    return PermissionlessDelegatorTxBuilder.verifyTxType(type);\n  }\n\n  /**\n   * Recover UTXOs from transaction inputs.\n   * Uses fromAddresses as proxy for UTXO addresses since we're reconstructing from a parsed transaction.\n   *\n   * @param inputs Array of TransferableInput from baseTx\n   * @param fromAddresses Wallet addresses to use as proxy for UTXO addresses\n   * @returns Array of decoded UTXO objects\n   * @private\n   */\n  private recoverUtxosFromInputs(inputs: TransferableInput[], fromAddresses: Uint8Array[]): DecodedUtxoObj[] {\n    const proxyAddresses = fromAddresses.map((addr) =>\n      utils.addressToString(this.transaction._network.hrp, this.transaction._network.alias, Buffer.from(addr))\n    );\n\n    return inputs.map((input) => {\n      const utxoId = input.utxoID;\n      const transferInput = input.input as TransferInput;\n      const sigIndicies = transferInput.sigIndicies();\n\n      const utxo: DecodedUtxoObj = {\n        outputID: 7, // SECP256K1 Transfer Output type\n        amount: input.amount().toString(),\n        txid: utils.cb58Encode(Buffer.from(utxoId.txID.toBytes())),\n        outputidx: utxoId.outputIdx.value().toString(),\n        threshold: sigIndicies.length || this.transaction._threshold,\n        addresses: proxyAddresses,\n        addressesIndex: sigIndicies,\n      };\n      return utxo;\n    });\n  }\n\n  protected async buildImplementation(): Promise<Transaction> {\n    this.buildFlareTransaction();\n    this.transaction.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   * Get the user's address (index 0) for default reward address.\n   *\n   * BitGo Convention for fromAddresses:\n   * - Index 0: User key (signer in normal mode)\n   * - Index 1: BitGo key (always a signer)\n   * - Index 2: Backup key (signer in recovery mode)\n   *\n   * For delegation transactions, the user's address at index 0 is used as the default\n   * reward address parameter (though the parameter has no on-chain effect - rewards\n   * go to C-chain addresses derived from the P-chain addresses in stake outputs).\n   *\n   * @returns Buffer containing the user's address\n   * @protected\n   */\n  protected getUserAddress(): Buffer {\n    const userIndex = 0; // BitGo convention: user is always at index 0\n    if (!this.transaction._fromAddresses || this.transaction._fromAddresses.length <= userIndex) {\n      throw new BuildTransactionError('User address (index 0) is required for delegation');\n    }\n    const userAddress = Buffer.from(this.transaction._fromAddresses[userIndex]);\n    if (userAddress.length !== 20) {\n      throw new BuildTransactionError(`Invalid user address length: expected 20 bytes, got ${userAddress.length}`);\n    }\n    return userAddress;\n  }\n\n  /**\n   * Build the permissionless delegator transaction using FlareJS.\n   * Uses pvm.e.newAddPermissionlessDelegatorTx (post-Etna API).\n   *\n   * Note: The rewardAddresses parameter is accepted by the API but does NOT affect\n   * where rewards are sent on-chain. Rewards accrue to C-chain addresses derived\n   * from the P-chain addresses in the stake outputs. The stake outputs contain the\n   * addresses from fromAddressesBytes (sorted to match UTXO owner order).\n   * @protected\n   */\n  protected buildFlareTransaction(): void {\n    if (this.transaction.hasCredentials) return;\n\n    // Validate required fields\n    if (!this._nodeID) {\n      throw new BuildTransactionError('NodeID is required for delegation');\n    }\n    if (!this._startTime) {\n      throw new BuildTransactionError('Start time is required for delegation');\n    }\n    if (!this._endTime) {\n      throw new BuildTransactionError('End time is required for delegation');\n    }\n    if (!this._stakeAmount) {\n      throw new BuildTransactionError('Stake amount is required for delegation');\n    }\n    if (!this.transaction._context) {\n      throw new BuildTransactionError('Context is required for delegation');\n    }\n    if (!this.transaction._fromAddresses || this.transaction._fromAddresses.length === 0) {\n      throw new BuildTransactionError('From addresses are required for delegation');\n    }\n    if (!this._feeState) {\n      throw new BuildTransactionError('Fee state is required for delegation');\n    }\n\n    this.validateStakeDuration(this._startTime, this._endTime);\n\n    // Compute addressesIndex to map wallet key indices to sorted UTXO address positions\n    this.computeAddressesIndex();\n\n    // Convert decoded UTXOs to FlareJS Utxo objects\n    if (!this.transaction._utxos || this.transaction._utxos.length === 0) {\n      throw new BuildTransactionError('UTXOs are required for delegation');\n    }\n    const utxos = utils.decodedToUtxos(this.transaction._utxos, this.transaction._network.assetId);\n\n    // Get user address for default reward address derivation\n    const userAddress = this.getUserAddress();\n\n    const rewardAddresses =\n      this.transaction._rewardAddresses.length > 0 ? this.transaction._rewardAddresses : [userAddress];\n\n    // Use Etna (post-fork) API - pvm.e.newAddPermissionlessDelegatorTx\n    // IMPORTANT: Use getSigningAddresses() to get the correct 2 signing keys\n    // This ensures proper key selection for both normal and recovery modes:\n    // - Normal mode: user (index 0) + bitgo (index 1)\n    // - Recovery mode: backup (index 2) + bitgo (index 1)\n    const signingAddresses = this.getSigningAddresses();\n\n    const delegatorTx = pvm.e.newAddPermissionlessDelegatorTx(\n      {\n        end: this._endTime,\n        feeState: this._feeState,\n        fromAddressesBytes: signingAddresses,\n        nodeId: this._nodeID,\n        rewardAddresses: rewardAddresses,\n        start: this._startTime,\n        subnetId: networkIDs.PrimaryNetworkID.toString(),\n        utxos,\n        weight: this._stakeAmount,\n      },\n      this.transaction._context\n    );\n\n    // Fix change output threshold bug (same as ExportInPTxBuilder)\n    const flareUnsignedTx = delegatorTx as UnsignedTx;\n    const innerTx = flareUnsignedTx.getTx() as pvmSerial.AddPermissionlessDelegatorTx;\n    const changeOutputs = innerTx.baseTx.outputs;\n    let correctedDelegatorTx: pvmSerial.AddPermissionlessDelegatorTx = innerTx;\n\n    if (changeOutputs.length > 0 && this.transaction._threshold > 1) {\n      // Only apply fix for multisig wallets (threshold > 1)\n      const allWalletAddresses = this.transaction._fromAddresses.map((addr) => Buffer.from(addr));\n\n      const correctedChangeOutputs = changeOutputs.map((output) => {\n        const transferOut = output.output as TransferOutput;\n\n        const assetIdStr = utils.flareIdString(Buffer.from(output.assetId.toBytes()).toString('hex')).toString();\n        return TransferableOutput.fromNative(\n          assetIdStr,\n          transferOut.amount(),\n          allWalletAddresses,\n          this.transaction._locktime,\n          this.transaction._threshold // Fix: use wallet's threshold instead of FlareJS's default (1)\n        );\n      });\n\n      correctedDelegatorTx = this.createCorrectedDelegatorTx(innerTx, correctedChangeOutputs);\n    }\n\n    // Recreate credentials and addressMaps from corrected transaction inputs\n    // This follows the same pattern as ExportInPTxBuilder to ensure proper signing\n    const utxosWithIndex = correctedDelegatorTx.baseTx.inputs.map((input) => {\n      const inputTxid = utils.cb58Encode(Buffer.from(input.utxoID.txID.toBytes()));\n      const inputOutputIdx = input.utxoID.outputIdx.value().toString();\n\n      const originalUtxo = this.transaction._utxos.find(\n        (utxo) => utxo.txid === inputTxid && utxo.outputidx === inputOutputIdx\n      );\n\n      if (!originalUtxo) {\n        throw new BuildTransactionError(`Could not find matching UTXO for input ${inputTxid}:${inputOutputIdx}`);\n      }\n\n      const transferInput = input.input as TransferInput;\n      const actualSigIndices = transferInput.sigIndicies();\n\n      return {\n        ...originalUtxo,\n        addressesIndex: originalUtxo.addressesIndex,\n        addresses: originalUtxo.addresses,\n        threshold: originalUtxo.threshold || this.transaction._threshold,\n        actualSigIndices,\n      };\n    });\n\n    this.transaction._utxos = utxosWithIndex;\n\n    const txCredentials = utxosWithIndex.map((utxo) =>\n      this.createCredentialForUtxo(utxo, utxo.threshold, utxo.actualSigIndices)\n    );\n\n    const addressMaps = utxosWithIndex.map((utxo) =>\n      this.createAddressMapForUtxo(utxo, utxo.threshold, utxo.actualSigIndices)\n    );\n\n    // Create new UnsignedTx with corrected change outputs and proper credentials\n    const fixedUnsignedTx = new UnsignedTx(\n      correctedDelegatorTx,\n      [],\n      new FlareUtils.AddressMaps(addressMaps),\n      txCredentials\n    );\n\n    this.transaction.setTransaction(fixedUnsignedTx);\n  }\n\n  /**\n   * Create a corrected AddPermissionlessDelegatorTx with the given change outputs.\n   * This is necessary because FlareJS's newAddPermissionlessDelegatorTx doesn't support setting\n   * the threshold and locktime for change outputs - it defaults to threshold=1.\n   *\n   * FlareJS declares baseTx.outputs as readonly, so we use Object.defineProperty\n   * to override the property with the corrected outputs. This is a workaround until\n   * FlareJS adds proper support for change output thresholds.\n   *\n   * @param originalTx - The original AddPermissionlessDelegatorTx\n   * @param correctedOutputs - The corrected change outputs with proper threshold\n   * @returns A new AddPermissionlessDelegatorTx with the corrected change outputs\n   */\n  private createCorrectedDelegatorTx(\n    originalTx: pvmSerial.AddPermissionlessDelegatorTx,\n    correctedOutputs: TransferableOutput[]\n  ): pvmSerial.AddPermissionlessDelegatorTx {\n    // FlareJS declares baseTx.outputs as `public readonly outputs: readonly TransferableOutput[]`\n    // We use Object.defineProperty to override the readonly property with our corrected outputs.\n    // This is necessary because FlareJS's newAddPermissionlessDelegatorTx doesn't support change output threshold/locktime.\n    Object.defineProperty(originalTx.baseTx, 'outputs', {\n      value: correctedOutputs,\n      writable: false,\n      enumerable: true,\n      configurable: true,\n    });\n\n    return originalTx;\n  }\n\n  /**\n   * Verify if the transaction type matches AddPermissionlessDelegatorTx\n   * @param type TypeSymbol from parsed transaction\n   */\n  static verifyTxType(type: TypeSymbols): boolean {\n    return type === TypeSymbols.AddPermissionlessDelegatorTx;\n  }\n\n  /** @inheritdoc */\n  protected get transaction(): Transaction {\n    return this._transaction;\n  }\n\n  protected set transaction(transaction: Transaction) {\n    this._transaction = transaction;\n  }\n\n  // Note: createCredentialForUtxo and createAddressMapForUtxo methods are inherited\n  // from AtomicTransactionBuilder and support both normal and recovery signing modes\n}\n"]}

package/dist/test/resources/transactionData/multisigDelegationTx.d.ts

@@ -0,0 +1,79 @@
+/**
+ *
+ * This demonstrates the half-signing workflow for 2-of-3 multisig delegation transactions
+ */
+/**
+ * Test accounts for half-signing workflow
+ * These are the actual keys used to create and sign the on-chain transaction
+ */
+export declare const HALF_SIGN_TEST_ACCOUNTS: {
+    user: {
+        privateKey: string;
+        publicKey: string;
+        pChainAddress: string;
+    };
+    bitgo: {
+        privateKey: string;
+        publicKey: string;
+        pChainAddress: string;
+    };
+    backup: {
+        privateKey: string;
+        publicKey: string;
+        pChainAddress: string;
+    };
+};
+/**
+ * Transaction parameters for the multisig delegation
+ */
+export declare const MULTISIG_DELEGATION_PARAMS: {
+    nodeID: string;
+    stakeAmount: string;
+    duration: number;
+    startTime: number;
+    endTime: number;
+    rewardAddress: string;
+    multisigAddresses: string[];
+    threshold: number;
+};
+/**
+ * Unsigned transaction hex (before any signatures)
+ * Built with sorted fromAddresses to match UTXO owner order
+ */
+export declare const MULTISIG_DELEGATION_UNSIGNED_TX_HEX = "00000000001a0000007200000000000000000000000000000000000000000000000000000000000000000000000158734f94af871c3d131b56131b6fb7a0291eacadd261e69dfb42a9cdf6f7fddd000000070000000253e89cc00000000000000000000000010000000340c982503bb38f42bd88b8ba953281bca72fd0f16b50b020ff8556fc7f9f88efc17dad2c4fae01c7766cdb20a5bcd2dc7ff069d714911efd25c4aef700000001707288abed3b4da8d181ee2922ac55e1f269845583cf9adff0caee5fd47ddc3c0000000158734f94af871c3d131b56131b6fb7a0291eacadd261e69dfb42a9cdf6f7fddd0000000500002d7bdc49040000000002000000000000000100000000664b4924a25af8be5f07052b2c2e582f7c10a65400000000699c4cf00000000069aec1f000002d79883d200000000000000000000000000000000000000000000000000000000000000000000000000158734f94af871c3d131b56131b6fb7a0291eacadd261e69dfb42a9cdf6f7fddd0000000700002d79883d20000000000000000000000000010000000340c982503bb38f42bd88b8ba953281bca72fd0f16b50b020ff8556fc7f9f88efc17dad2c4fae01c7766cdb20a5bcd2dc7ff069d714911efd25c4aef70000000b0000000000000000000000010000000140c982503bb38f42bd88b8ba953281bca72fd0f1";
+/**
+ * Half-signed transaction hex (signed by user key only)
+ * First signature slot filled, second slot empty
+ */
+export declare const MULTISIG_DELEGATION_HALF_SIGNED_TX_HEX = "00000000001a0000007200000000000000000000000000000000000000000000000000000000000000000000000158734f94af871c3d131b56131b6fb7a0291eacadd261e69dfb42a9cdf6f7fddd000000070000000253e89cc00000000000000000000000010000000340c982503bb38f42bd88b8ba953281bca72fd0f16b50b020ff8556fc7f9f88efc17dad2c4fae01c7766cdb20a5bcd2dc7ff069d714911efd25c4aef700000001707288abed3b4da8d181ee2922ac55e1f269845583cf9adff0caee5fd47ddc3c0000000158734f94af871c3d131b56131b6fb7a0291eacadd261e69dfb42a9cdf6f7fddd0000000500002d7bdc49040000000002000000000000000100000000664b4924a25af8be5f07052b2c2e582f7c10a65400000000699c4cf00000000069aec1f000002d79883d200000000000000000000000000000000000000000000000000000000000000000000000000158734f94af871c3d131b56131b6fb7a0291eacadd261e69dfb42a9cdf6f7fddd0000000700002d79883d20000000000000000000000000010000000340c982503bb38f42bd88b8ba953281bca72fd0f16b50b020ff8556fc7f9f88efc17dad2c4fae01c7766cdb20a5bcd2dc7ff069d714911efd25c4aef70000000b0000000000000000000000010000000140c982503bb38f42bd88b8ba953281bca72fd0f1000000010000000900000002d488c1469bf92cfdeb2c164e1608f9c1bef4aec0b39fe33088a97b74268a908a579f079d56728dcfbda297b6f5c7792e26f109914b65ed974dcd1ad155cb61d3010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000";
+/**
+ * Fully signed transaction hex (signed by both user and bitgo keys)
+ * This transaction was successfully broadcast to Coston2 testnet
+ */
+export declare const MULTISIG_DELEGATION_FULLY_SIGNED_TX_HEX = "00000000001a0000007200000000000000000000000000000000000000000000000000000000000000000000000158734f94af871c3d131b56131b6fb7a0291eacadd261e69dfb42a9cdf6f7fddd000000070000000253e89cc00000000000000000000000010000000340c982503bb38f42bd88b8ba953281bca72fd0f16b50b020ff8556fc7f9f88efc17dad2c4fae01c7766cdb20a5bcd2dc7ff069d714911efd25c4aef700000001707288abed3b4da8d181ee2922ac55e1f269845583cf9adff0caee5fd47ddc3c0000000158734f94af871c3d131b56131b6fb7a0291eacadd261e69dfb42a9cdf6f7fddd0000000500002d7bdc49040000000002000000000000000100000000664b4924a25af8be5f07052b2c2e582f7c10a65400000000699c4cf00000000069aec1f000002d79883d200000000000000000000000000000000000000000000000000000000000000000000000000158734f94af871c3d131b56131b6fb7a0291eacadd261e69dfb42a9cdf6f7fddd0000000700002d79883d20000000000000000000000000010000000340c982503bb38f42bd88b8ba953281bca72fd0f16b50b020ff8556fc7f9f88efc17dad2c4fae01c7766cdb20a5bcd2dc7ff069d714911efd25c4aef70000000b0000000000000000000000010000000140c982503bb38f42bd88b8ba953281bca72fd0f1000000010000000900000002d488c1469bf92cfdeb2c164e1608f9c1bef4aec0b39fe33088a97b74268a908a579f079d56728dcfbda297b6f5c7792e26f109914b65ed974dcd1ad155cb61d30139507d355619359a57ce9f85b42c1d5daca3808db218513b45417f5c6bc1bc531bfefef6ae78309486fe114c6d64626b0ba619f453946a385dc8ff4a31b333b701";
+/**
+ * On-chain transaction ID after broadcast
+ */
+export declare const MULTISIG_DELEGATION_TX_ID = "2hGeGfU7vAi7aMWAGSc5RHfRBpum2LWhxqypv2uxQvZXVrnEA5";
+/**
+ * Address sorting information for the 2-of-3 multisig wallet
+ * After lexicographic sorting by hex value, the addresses remain in the same order:
+ * 1. user (P-costwo1grycy5pmkw8590vghzaf2v5phjnjl583cmc3f5) - sorted index 0
+ * 2. bitgo (P-costwo1ddgtqg8ls4t0clul3rhuzldd9386uqw85nr98f) - sorted index 1
+ * 3. backup (P-costwo1wekdkg99hnfdcllsd8t3fyg7l5jufthhfysjgp) - sorted index 2
+ *
+ * Keys needed for signing (first 2 in sorted order for threshold=2):
+ * - user (original index 0, sorted index 0)
+ * - bitgo (original index 1, sorted index 1)
+ */
+export declare const MULTISIG_ADDRESS_SORTING: {
+    original: string[];
+    sorted: string[];
+    addressesIndex: number[];
+    signingKeys: {
+        role: string;
+        originalIndex: number;
+        sortedIndex: number;
+    }[];
+};
+//# sourceMappingURL=multisigDelegationTx.d.ts.map

package/dist/test/resources/transactionData/multisigDelegationTx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multisigDelegationTx.d.ts","sourceRoot":"","sources":["../../../../test/resources/transactionData/multisigDelegationTx.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;GAGG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;CAgBnC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;CAatC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,mCAAmC,y/BACw8B,CAAC;AAEz/B;;;GAGG;AACH,eAAO,MAAM,sCAAsC,qxCACiuC,CAAC;AAErxC;;;GAGG;AACH,eAAO,MAAM,uCAAuC,qxCACguC,CAAC;AAErxC;;GAEG;AACH,eAAO,MAAM,yBAAyB,uDAAuD,CAAC;AAE9F;;;;;;;;;;GAUG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;CAiBpC,CAAC"}