@bitgo-beta/sdk-coin-flrp 1.0.1-beta.75 → 1.0.1-beta.751

package/dist/src/flrp.d.ts

@@ -1,7 +1,7 @@
 import { BaseCoin as StaticsBaseCoin, CoinFamily } from '@bitgo-beta/statics';
-import { BaseCoin, BitGoBase, KeyPair, VerifyAddressOptions, SignedTransaction, ParseTransactionOptions, ITransactionRecipient, ParsedTransaction, MultisigType, AuditDecryptedKeyParams } from '@bitgo-beta/sdk-core';
+import { AuditDecryptedKeyParams, BaseCoin, BitGoBase, KeyPair, MPCAlgorithm, MultisigType, ParsedTransaction, ParseTransactionOptions, SignedTransaction, VerifyAddressOptions, ITransactionRecipient, SignableTransaction } from '@bitgo-beta/sdk-core';
 import * as FlrpLib from './lib';
-import { FlrpSignTransactionOptions, ExplainTransactionOptions, FlrpVerifyTransactionOptions, FlrpTransactionStakingOptions, FlrpTransactionParams } from './lib/iface';
+import { CreatePairedWalletParams, CreatePairedWalletResponse, FlrpEntry, FlrpExplainTransactionOptions, FlrpSignTransactionOptions, FlrpTransactionParams, FlrpVerifyTransactionOptions } from './lib/iface';
 export declare class Flrp extends BaseCoin {
     protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;
     constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>);
@@ -12,13 +12,11 @@ export declare class Flrp extends BaseCoin {
     getBaseFactor(): string | number;
     /** inherited doc */
     getDefaultMultisigType(): MultisigType;
-    /**
-     * Check if staking txn is valid, based on expected tx params.
-     *
-     * @param {FlrpTransactionStakingOptions} stakingOptions expected staking params to check against
-     * @param {FlrpLib.TransactionExplanation} explainedTx explained staking transaction
-     */
-    validateStakingTx(stakingOptions: FlrpTransactionStakingOptions, explainedTx: FlrpLib.TransactionExplanation): void;
+    /** @inheritdoc */
+    supportsTss(): boolean;
+    /** @inheritdoc */
+    getMPCAlgorithm(): MPCAlgorithm;
+    verifyTransaction(params: FlrpVerifyTransactionOptions): Promise<boolean>;
     /**
      * Check if export txn is valid, based on expected tx params.
      *
@@ -29,11 +27,19 @@ export declare class Flrp extends BaseCoin {
     /**
      * Check if import txn into P is valid, based on expected tx params.
      *
-     * @param {FlrpLib.FlrpEntry[]} explainedTxInputs tx inputs (unspents to be imported)
+     * @param {FlrpEntry[]} explainedTxInputs tx inputs (unspents to be imported)
      * @param {FlrpTransactionParams} txParams expected tx info to check against
      */
-    validateImportTx(explainedTxInputs: FlrpLib.FlrpEntry[], txParams: FlrpTransactionParams): void;
-    verifyTransaction(params: FlrpVerifyTransactionOptions): Promise<boolean>;
+    validateImportTx(explainedTxInputs: FlrpEntry[], txParams: FlrpTransactionParams): void;
+    /**
+     * Validate AddPermissionlessDelegator transaction parameters.
+     * Validates both expected txParams and the parsed explainedTx for consistency.
+     *
+     * @param {FlrpTransactionParams} txParams - Expected transaction parameters
+     * @param {FlrpLib.TransactionExplanation} explainedTx - Parsed transaction explanation
+     */
+    validateDelegationTx(txParams: FlrpTransactionParams, explainedTx: FlrpLib.TransactionExplanation): void;
+    private getBuilder;
     /**
      * Check if address is valid, then make sure it matches the root address.
      *
@@ -72,20 +78,38 @@ export declare class Flrp extends BaseCoin {
     isValidPrv(prv: string): boolean;
     isValidAddress(address: string | string[]): boolean;
     /**
-     * Signs Flrp transaction
+     * Get the raw bytes that need to be signed by the MPC ceremony.
+     * MPC.sign() internally SHA-256 hashes, so return raw unsigned tx bytes.
+     */
+    getSignablePayload(txHex: string): Promise<Buffer>;
+    /**
+     * Inject an MPC-produced signature into an unsigned transaction.
+     * @param txHex - Unsigned transaction hex
+     * @param signature - 65-byte ECDSA signature (r || s || recovery)
+     * @returns Signed transaction hex
+     */
+    addSignatureToTransaction(txHex: string, signature: Buffer): Promise<string>;
+    /**
+     * Signs Avaxp transaction
      */
     signTransaction(params: FlrpSignTransactionOptions): Promise<SignedTransaction>;
     parseTransaction(params: ParseTransactionOptions): Promise<ParsedTransaction>;
     /**
-     * Explain a Flrp transaction from txHex
+     * Explain a Avaxp transaction from txHex
      * @param params
      * @param callback
      */
-    explainTransaction(params: ExplainTransactionOptions): Promise<FlrpLib.TransactionExplanation>;
-    recoverySignature(message: Buffer, signature: Buffer): Buffer;
+    explainTransaction(params: FlrpExplainTransactionOptions): Promise<FlrpLib.TransactionExplanation>;
+    recoverySignature(messageHash: Buffer, signature: Buffer): Buffer;
     signMessage(key: KeyPair, message: string | Buffer): Promise<Buffer>;
-    private getBuilder;
+    /**
+     * Returns true when the signableHex for this transaction is already the
+     * final signing hash (SHA-256 for Avalanche atomic txs), and the MPC
+     * signing flow should use it directly without additional hashing.
+     */
+    isSignablePreHashed(unsignedTx: SignableTransaction): boolean;
     /** @inheritDoc */
     auditDecryptedKey(params: AuditDecryptedKeyParams): void;
+    createPairedWallet(params: CreatePairedWalletParams): Promise<CreatePairedWalletResponse>;
 }
 //# sourceMappingURL=flrp.d.ts.map

package/dist/src/flrp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"flrp.d.ts","sourceRoot":"","sources":["../../src/flrp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,QAAQ,IAAI,eAAe,EAAE,UAAU,EAAS,MAAM,qBAAqB,CAAC;AACnG,OAAO,EACL,QAAQ,EACR,SAAS,EACT,OAAO,EACP,oBAAoB,EACpB,iBAAiB,EACjB,uBAAuB,EAOvB,qBAAqB,EACrB,iBAAiB,EACjB,YAAY,EAEZ,uBAAuB,EAExB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,OAAO,MAAM,OAAO,CAAC;AACjC,OAAO,EACL,0BAA0B,EAC1B,yBAAyB,EACzB,4BAA4B,EAC5B,6BAA6B,EAC7B,qBAAqB,EACtB,MAAM,aAAa,CAAC;AAIrB,qBAAa,IAAK,SAAQ,QAAQ;IAChC,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,QAAQ,CAAC,eAAe,CAAC,CAAC;gBAE/C,KAAK,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,QAAQ,CAAC,eAAe,CAAC;IAUrE,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,QAAQ,CAAC,eAAe,CAAC,GAAG,QAAQ;IAI1F,QAAQ,IAAI,MAAM;IAGlB,SAAS,IAAI,UAAU;IAGvB,WAAW,IAAI,MAAM;IAGrB,aAAa,IAAI,MAAM,GAAG,MAAM;IAIhC,oBAAoB;IACpB,sBAAsB,IAAI,YAAY;IAItC;;;;;OAKG;IACH,iBAAiB,CAAC,cAAc,EAAE,6BAA6B,EAAE,WAAW,EAAE,OAAO,CAAC,sBAAsB,GAAG,IAAI;IAYnH;;;;;OAKG;IACH,gBAAgB,CAAC,UAAU,EAAE,qBAAqB,EAAE,EAAE,WAAW,EAAE,OAAO,CAAC,sBAAsB,GAAG,IAAI;IAqBxG;;;;;OAKG;IACH,gBAAgB,CAAC,iBAAiB,EAAE,OAAO,CAAC,SAAS,EAAE,EAAE,QAAQ,EAAE,qBAAqB,GAAG,IAAI;IAgBzF,iBAAiB,CAAC,MAAM,EAAE,4BAA4B,GAAG,OAAO,CAAC,OAAO,CAAC;IA4D/E;;;;;OAKG;IACG,eAAe,CAAC,MAAM,EAAE,oBAAoB,GAAG,OAAO,CAAC,OAAO,CAAC;IA6BrE;;;;;;OAMG;IACH,OAAO,CAAC,mBAAmB;IAI3B;;;;;OAKG;IACH,eAAe,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO;IAcvC;;;;;OAKG;IACH,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAShC;;;;;OAKG;IACH,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAShC,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO;IAanD;;OAEG;IACG,eAAe,CAAC,MAAM,EAAE,0BAA0B,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAkB/E,gBAAgB,CAAC,MAAM,EAAE,uBAAuB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAInF;;;;OAIG;IACG,kBAAkB,CAAC,MAAM,EAAE,yBAAyB,GAAG,OAAO,CAAC,OAAO,CAAC,sBAAsB,CAAC;IAcpG,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM;IAIvD,WAAW,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAW1E,OAAO,CAAC,UAAU;IAIlB,kBAAkB;IAClB,iBAAiB,CAAC,MAAM,EAAE,uBAAuB,GAAG,IAAI;CAIzD"}
+{"version":3,"file":"flrp.d.ts","sourceRoot":"","sources":["../../src/flrp.ts"],"names":[],"mappings":"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"}

package/dist/src/flrp.js

@@ -42,6 +42,7 @@ const sdk_core_1 = require("@bitgo-beta/sdk-core");
 const FlrpLib = __importStar(require("./lib"));
 const utils_1 = __importDefault(require("./lib/utils"));
 const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const ethereumjs_util_1 = require("ethereumjs-util");
 class Flrp extends sdk_core_1.BaseCoin {
     constructor(bitgo, staticsCoin) {
         super(bitgo);
@@ -67,62 +68,15 @@ class Flrp extends sdk_core_1.BaseCoin {
     }
     /** inherited doc */
     getDefaultMultisigType() {
-        return sdk_core_1.multisigTypes.onchain;
+        return sdk_core_1.multisigTypes.tss;
     }
-    /**
-     * Check if staking txn is valid, based on expected tx params.
-     *
-     * @param {FlrpTransactionStakingOptions} stakingOptions expected staking params to check against
-     * @param {FlrpLib.TransactionExplanation} explainedTx explained staking transaction
-     */
-    validateStakingTx(stakingOptions, explainedTx) {
-        const filteredRecipients = [{ address: stakingOptions.nodeID, amount: stakingOptions.amount }];
-        const filteredOutputs = explainedTx.outputs.map((output) => utils_1.default.pick(output, ['address', 'amount']));
-        if (!utils_1.default.isEqual(filteredOutputs, filteredRecipients)) {
-            throw new Error('Tx outputs does not match with expected txParams');
-        }
-        if (stakingOptions?.amount !== explainedTx.outputAmount) {
-            throw new Error('Tx total amount does not match with expected total amount field');
-        }
-    }
-    /**
-     * Check if export txn is valid, based on expected tx params.
-     *
-     * @param {ITransactionRecipient[]} recipients expected recipients and info
-     * @param {FlrpLib.TransactionExplanation} explainedTx explained export transaction
-     */
-    validateExportTx(recipients, explainedTx) {
-        if (recipients.length !== 1 || explainedTx.outputs.length !== 1) {
-            throw new Error('Export Tx requires one recipient');
-        }
-        const maxImportFee = this._staticsCoin.network.maxImportFee || '0';
-        const recipientAmount = new bignumber_js_1.default(recipients[0].amount);
-        if (recipientAmount.isGreaterThan(explainedTx.outputAmount) ||
-            recipientAmount.plus(maxImportFee).isLessThan(explainedTx.outputAmount)) {
-            throw new Error(`Tx total amount ${explainedTx.outputAmount} does not match with expected total amount field ${recipientAmount} and max import fee ${maxImportFee}`);
-        }
-        if (explainedTx.outputs && !utils_1.default.isValidAddress(explainedTx.outputs[0].address)) {
-            throw new Error(`Invalid P-chain address ${explainedTx.outputs[0].address}`);
-        }
+    /** @inheritdoc */
+    supportsTss() {
+        return true;
     }
-    /**
-     * Check if import txn into P is valid, based on expected tx params.
-     *
-     * @param {FlrpLib.FlrpEntry[]} explainedTxInputs tx inputs (unspents to be imported)
-     * @param {FlrpTransactionParams} txParams expected tx info to check against
-     */
-    validateImportTx(explainedTxInputs, txParams) {
-        if (txParams.unspents) {
-            if (explainedTxInputs.length !== txParams.unspents.length) {
-                throw new Error(`Expected ${txParams.unspents.length} UTXOs, transaction had ${explainedTxInputs.length}`);
-            }
-            const unspents = new Set(txParams.unspents);
-            for (const unspent of explainedTxInputs) {
-                if (!unspents.has(unspent.id)) {
-                    throw new Error(`Transaction should not contain the UTXO: ${unspent.id}`);
-                }
-            }
-        }
+    /** @inheritdoc */
+    getMPCAlgorithm() {
+        return 'ecdsa';
     }
     async verifyTransaction(params) {
         const txHex = params.txPrebuild && params.txPrebuild.txHex;
@@ -135,24 +89,26 @@ class Flrp extends sdk_core_1.BaseCoin {
             tx = await txBuilder.build();
         }
         catch (error) {
-            throw new Error('Invalid transaction');
+            throw new Error(`Invalid transaction: ${error.message}`);
         }
         const explainedTx = tx.explainTransaction();
-        const { type, stakingOptions } = params.txParams;
-        // TODO(BG-62112): change ImportToC type to Import
-        if (!type || (type !== 'ImportToC' && explainedTx.type !== sdk_core_1.TransactionType[type])) {
+        const type = params.txParams.type;
+        // WP intentType aliases (lowercase) must map to TransactionType enum keys.
+        const normalizedType = type === 'stake'
+            ? 'AddPermissionlessDelegator'
+            : type === 'import'
+                ? 'Import'
+                : type === 'importtoc'
+                    ? 'ImportToC'
+                    : type;
+        // When type is provided, verify it matches the parsed transaction.
+        // When type is not provided (MPC/TSS intent flow where buildParams are unavailable),
+        // skip the type match check and rely on explainedTx.type from the parsed hex —
+        // the transaction was built by wallet-platform and the hex is the source of truth.
+        if (normalizedType && normalizedType !== 'ImportToC' && explainedTx.type !== sdk_core_1.TransactionType[normalizedType]) {
             throw new Error('Tx type does not match with expected txParams type');
         }
         switch (explainedTx.type) {
-            // @deprecated
-            case sdk_core_1.TransactionType.AddDelegator:
-            case sdk_core_1.TransactionType.AddValidator:
-            case sdk_core_1.TransactionType.AddPermissionlessDelegator:
-            case sdk_core_1.TransactionType.AddPermissionlessValidator:
-                if (stakingOptions) {
-                    this.validateStakingTx(stakingOptions, explainedTx);
-                }
-                break;
             case sdk_core_1.TransactionType.Export:
                 if (!params.txParams.recipients || params.txParams.recipients?.length !== 1) {
                     throw new Error('Export Tx requires a recipient');
@@ -179,11 +135,96 @@ class Flrp extends sdk_core_1.BaseCoin {
                     this.validateImportTx(explainedTx.inputs, params.txParams);
                 }
                 break;
+            case sdk_core_1.TransactionType.AddPermissionlessDelegator:
+                if (params.txParams.stakingOptions) {
+                    this.validateDelegationTx(params.txParams, explainedTx);
+                }
+                break;
             default:
                 throw new Error('Tx type is not supported yet');
         }
         return true;
     }
+    /**
+     * Check if export txn is valid, based on expected tx params.
+     *
+     * @param {ITransactionRecipient[]} recipients expected recipients and info
+     * @param {FlrpLib.TransactionExplanation} explainedTx explained export transaction
+     */
+    validateExportTx(recipients, explainedTx) {
+        if (recipients.length !== 1 || explainedTx.outputs.length !== 1) {
+            throw new Error('Export Tx requires one recipient');
+        }
+        const maxImportFee = this._staticsCoin.network.maxImportFee;
+        const recipientAmount = new bignumber_js_1.default(recipients[0].amount);
+        if (recipientAmount.isGreaterThan(explainedTx.outputAmount) ||
+            recipientAmount.plus(maxImportFee).isLessThan(explainedTx.outputAmount)) {
+            throw new Error(`Tx total amount ${explainedTx.outputAmount} does not match with expected total amount field ${recipientAmount} and max import fee ${maxImportFee}`);
+        }
+        if (explainedTx.outputs && !utils_1.default.isValidAddress(explainedTx.outputs[0].address)) {
+            throw new Error(`Invalid P-chain address ${explainedTx.outputs[0].address}`);
+        }
+    }
+    /**
+     * Check if import txn into P is valid, based on expected tx params.
+     *
+     * @param {FlrpEntry[]} explainedTxInputs tx inputs (unspents to be imported)
+     * @param {FlrpTransactionParams} txParams expected tx info to check against
+     */
+    validateImportTx(explainedTxInputs, txParams) {
+        if (txParams.unspents) {
+            if (explainedTxInputs.length !== txParams.unspents.length) {
+                throw new Error(`Expected ${txParams.unspents.length} UTXOs, transaction had ${explainedTxInputs.length}`);
+            }
+            const unspents = new Set(txParams.unspents);
+            for (const unspent of explainedTxInputs) {
+                if (!unspents.has(unspent.id)) {
+                    throw new Error(`Transaction should not contain the UTXO: ${unspent.id}`);
+                }
+            }
+        }
+    }
+    /**
+     * Validate AddPermissionlessDelegator transaction parameters.
+     * Validates both expected txParams and the parsed explainedTx for consistency.
+     *
+     * @param {FlrpTransactionParams} txParams - Expected transaction parameters
+     * @param {FlrpLib.TransactionExplanation} explainedTx - Parsed transaction explanation
+     */
+    validateDelegationTx(txParams, explainedTx) {
+        if (!txParams.stakingOptions) {
+            throw new Error('Delegation transaction requires stakingOptions');
+        }
+        const { nodeID, amount, durationSeconds, rewardAddress } = txParams.stakingOptions;
+        if (!nodeID) {
+            throw new Error('Delegation transaction requires nodeID');
+        }
+        if (!amount) {
+            throw new Error('Delegation transaction requires amount');
+        }
+        if (!durationSeconds) {
+            throw new Error('Delegation transaction requires durationSeconds');
+        }
+        if (!rewardAddress) {
+            throw new Error('Delegation transaction requires rewardAddress');
+        }
+        // Validate nodeID format using utility method
+        if (!utils_1.default.isValidNodeID(nodeID)) {
+            throw new Error(`Invalid nodeID format: ${nodeID}`);
+        }
+        // Validate that the parsed transaction's output amount matches the expected staking amount
+        // The outputAmount in explainedTx represents the total stake amount in the transaction
+        if (explainedTx.outputAmount) {
+            const expectedAmount = new bignumber_js_1.default(amount);
+            const actualAmount = new bignumber_js_1.default(explainedTx.outputAmount);
+            if (!expectedAmount.isEqualTo(actualAmount)) {
+                throw new Error(`Delegation amount mismatch: expected ${amount}, transaction has ${explainedTx.outputAmount}`);
+            }
+        }
+    }
+    getBuilder() {
+        return new FlrpLib.TransactionBuilderFactory(statics_1.coins.get(this.getChain()));
+    }
     /**
      * Check if address is valid, then make sure it matches the root address.
      *
@@ -195,11 +236,19 @@ class Flrp extends sdk_core_1.BaseCoin {
         if (!this.isValidAddress(address)) {
             throw new sdk_core_1.InvalidAddressError(`invalid address: ${address}`);
         }
+        // multisig addresses are separated by ~
+        const splitAddresses = address.split('~');
+        // MPC/TSS: single address derived from common keychain
+        if (splitAddresses.length === 1 && keychains?.length === 1) {
+            const expectedAddr = new FlrpLib.KeyPair({ pub: keychains[0].pub }).getAddress(this._staticsCoin.network.type);
+            if (expectedAddr !== address) {
+                throw new sdk_core_1.UnexpectedAddressError(`address validation failure: ${address} is not of this wallet`);
+            }
+            return true;
+        }
         if (!keychains || keychains.length !== 3) {
             throw new Error('Invalid keychains');
         }
-        // multisig addresses are separated by ~
-        const splitAddresses = address.split('~');
         // derive addresses from keychain
         const unlockAddresses = keychains.map((keychain) => new FlrpLib.KeyPair({ pub: keychain.pub }).getAddress(this._staticsCoin.network.type));
         if (splitAddresses.length !== unlockAddresses.length) {
@@ -272,13 +321,34 @@ class Flrp extends sdk_core_1.BaseCoin {
             return false;
         }
         // validate eth address for cross-chain txs to c-chain
-        if (typeof address === 'string' && utils_1.default.isValidEthereumAddress(address)) {
+        if (typeof address === 'string' && (0, ethereumjs_util_1.isValidAddress)(address)) {
             return true;
         }
         return FlrpLib.Utils.isValidAddress(address);
     }
     /**
-     * Signs Flrp transaction
+     * Get the raw bytes that need to be signed by the MPC ceremony.
+     * MPC.sign() internally SHA-256 hashes, so return raw unsigned tx bytes.
+     */
+    async getSignablePayload(txHex) {
+        const txBuilder = this.getBuilder().from(txHex);
+        const tx = (await txBuilder.build());
+        return Buffer.from(tx.signablePayload);
+    }
+    /**
+     * Inject an MPC-produced signature into an unsigned transaction.
+     * @param txHex - Unsigned transaction hex
+     * @param signature - 65-byte ECDSA signature (r || s || recovery)
+     * @returns Signed transaction hex
+     */
+    async addSignatureToTransaction(txHex, signature) {
+        const txBuilder = this.getBuilder().from(txHex);
+        const tx = await txBuilder.build();
+        tx.addExternalSignature(new Uint8Array(signature));
+        return tx.toBroadcastFormat();
+    }
+    /**
+     * Signs Avaxp transaction
      */
     async signTransaction(params) {
         // deserialize raw transaction (note: fromAddress has onchain order)
@@ -299,7 +369,7 @@ class Flrp extends sdk_core_1.BaseCoin {
         return {};
     }
     /**
-     * Explain a Flrp transaction from txHex
+     * Explain a Avaxp transaction from txHex
      * @param params
      * @param callback
      */
@@ -310,15 +380,35 @@ class Flrp extends sdk_core_1.BaseCoin {
         }
         try {
             const txBuilder = this.getBuilder().from(txHex);
-            const tx = await txBuilder.build();
-            return tx.explainTransaction();
+            const tx = (await txBuilder.build());
+            const explanation = tx.explainTransaction();
+            // For a C→P export (ExportInC viewed from the FLRP P-chain perspective), the
+            // exportedOutputs contain the P-chain UTXO amount, which is the gross amount
+            // BEFORE the import fee is deducted. The platform uses this explanation to show
+            // the "pending import amount" before the ImportInP is confirmed. To avoid
+            // displaying a higher-than-actual amount, subtract the minimum import-to-P fee
+            // so the displayed amount reflects the expected net P-chain receipt.
+            if (tx.isTransactionForCChain && explanation.type === sdk_core_1.TransactionType.Export) {
+                const minImportToPFee = BigInt(this._staticsCoin.network.minImportToPFee);
+                const adjustedOutputs = explanation.outputs.map((o) => ({
+                    ...o,
+                    amount: (BigInt(o.amount) - minImportToPFee).toString(),
+                }));
+                const adjustedOutputAmount = (BigInt(explanation.outputAmount) - minImportToPFee).toString();
+                return {
+                    ...explanation,
+                    outputs: adjustedOutputs,
+                    outputAmount: adjustedOutputAmount,
+                };
+            }
+            return explanation;
         }
         catch (e) {
             throw new Error(`Invalid transaction: ${e.message}`);
         }
     }
-    recoverySignature(message, signature) {
-        return FlrpLib.Utils.recoverySignature(this._staticsCoin.network, message, signature);
+    recoverySignature(messageHash, signature) {
+        return FlrpLib.Utils.recoverySignature(messageHash, signature);
     }
     async signMessage(key, message) {
         const prv = new FlrpLib.KeyPair(key).getPrivateKey();
@@ -330,14 +420,25 @@ class Flrp extends sdk_core_1.BaseCoin {
         }
         return FlrpLib.Utils.createSignature(this._staticsCoin.network, message, prv);
     }
-    getBuilder() {
-        return new FlrpLib.TransactionBuilderFactory(statics_1.coins.get(this.getChain()));
+    /**
+     * Returns true when the signableHex for this transaction is already the
+     * final signing hash (SHA-256 for Avalanche atomic txs), and the MPC
+     * signing flow should use it directly without additional hashing.
+     */
+    isSignablePreHashed(unsignedTx) {
+        return (0, sdk_core_1.isAvalancheAtomicTx)(unsignedTx);
     }
     /** @inheritDoc */
     auditDecryptedKey(params) {
-        /** https://bitgoinc.atlassian.net/browse/COIN-4213 */
         throw new sdk_core_1.MethodNotImplementedError();
     }
+    async createPairedWallet(params) {
+        const { walletId, label } = params;
+        return this.bitgo
+            .post(this.url(`/wallet/${walletId}/create-paired-wallet`))
+            .send(label ? { label } : {})
+            .result();
+    }
 }
 exports.Flrp = Flrp;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flrp.js","sourceRoot":"","sources":["../../src/flrp.ts"],"names":[],"mappings":"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","sourcesContent":["import { FlareNetwork, BaseCoin as StaticsBaseCoin, CoinFamily, coins } from '@bitgo-beta/statics';\nimport {\n  BaseCoin,\n  BitGoBase,\n  KeyPair,\n  VerifyAddressOptions,\n  SignedTransaction,\n  ParseTransactionOptions,\n  BaseTransaction,\n  InvalidTransactionError,\n  SigningError,\n  TransactionType,\n  InvalidAddressError,\n  UnexpectedAddressError,\n  ITransactionRecipient,\n  ParsedTransaction,\n  MultisigType,\n  multisigTypes,\n  AuditDecryptedKeyParams,\n  MethodNotImplementedError,\n} from '@bitgo-beta/sdk-core';\nimport * as FlrpLib from './lib';\nimport {\n  FlrpSignTransactionOptions,\n  ExplainTransactionOptions,\n  FlrpVerifyTransactionOptions,\n  FlrpTransactionStakingOptions,\n  FlrpTransactionParams,\n} from './lib/iface';\nimport utils from './lib/utils';\nimport BigNumber from 'bignumber.js';\n\nexport class Flrp extends BaseCoin {\n  protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;\n\n  constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>) {\n    super(bitgo);\n\n    if (!staticsCoin) {\n      throw new Error('missing required constructor parameter staticsCoin');\n    }\n\n    this._staticsCoin = staticsCoin;\n  }\n\n  static createInstance(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>): BaseCoin {\n    return new Flrp(bitgo, staticsCoin);\n  }\n\n  getChain(): string {\n    return this._staticsCoin.name;\n  }\n  getFamily(): CoinFamily {\n    return this._staticsCoin.family;\n  }\n  getFullName(): string {\n    return this._staticsCoin.fullName;\n  }\n  getBaseFactor(): string | number {\n    return Math.pow(10, this._staticsCoin.decimalPlaces);\n  }\n\n  /** inherited doc */\n  getDefaultMultisigType(): MultisigType {\n    return multisigTypes.onchain;\n  }\n\n  /**\n   * Check if staking txn is valid, based on expected tx params.\n   *\n   * @param {FlrpTransactionStakingOptions} stakingOptions expected staking params to check against\n   * @param {FlrpLib.TransactionExplanation} explainedTx explained staking transaction\n   */\n  validateStakingTx(stakingOptions: FlrpTransactionStakingOptions, explainedTx: FlrpLib.TransactionExplanation): void {\n    const filteredRecipients = [{ address: stakingOptions.nodeID, amount: stakingOptions.amount }];\n    const filteredOutputs = explainedTx.outputs.map((output) => utils.pick(output, ['address', 'amount']));\n\n    if (!utils.isEqual(filteredOutputs, filteredRecipients)) {\n      throw new Error('Tx outputs does not match with expected txParams');\n    }\n    if (stakingOptions?.amount !== explainedTx.outputAmount) {\n      throw new Error('Tx total amount does not match with expected total amount field');\n    }\n  }\n\n  /**\n   * Check if export txn is valid, based on expected tx params.\n   *\n   * @param {ITransactionRecipient[]} recipients expected recipients and info\n   * @param {FlrpLib.TransactionExplanation} explainedTx explained export transaction\n   */\n  validateExportTx(recipients: ITransactionRecipient[], explainedTx: FlrpLib.TransactionExplanation): void {\n    if (recipients.length !== 1 || explainedTx.outputs.length !== 1) {\n      throw new Error('Export Tx requires one recipient');\n    }\n\n    const maxImportFee = (this._staticsCoin.network as FlareNetwork).maxImportFee || '0';\n    const recipientAmount = new BigNumber(recipients[0].amount);\n    if (\n      recipientAmount.isGreaterThan(explainedTx.outputAmount) ||\n      recipientAmount.plus(maxImportFee).isLessThan(explainedTx.outputAmount)\n    ) {\n      throw new Error(\n        `Tx total amount ${explainedTx.outputAmount} does not match with expected total amount field ${recipientAmount} and max import fee ${maxImportFee}`\n      );\n    }\n\n    if (explainedTx.outputs && !utils.isValidAddress(explainedTx.outputs[0].address)) {\n      throw new Error(`Invalid P-chain address ${explainedTx.outputs[0].address}`);\n    }\n  }\n\n  /**\n   * Check if import txn into P is valid, based on expected tx params.\n   *\n   * @param {FlrpLib.FlrpEntry[]} explainedTxInputs tx inputs (unspents to be imported)\n   * @param {FlrpTransactionParams} txParams expected tx info to check against\n   */\n  validateImportTx(explainedTxInputs: FlrpLib.FlrpEntry[], txParams: FlrpTransactionParams): void {\n    if (txParams.unspents) {\n      if (explainedTxInputs.length !== txParams.unspents.length) {\n        throw new Error(`Expected ${txParams.unspents.length} UTXOs, transaction had ${explainedTxInputs.length}`);\n      }\n\n      const unspents = new Set(txParams.unspents);\n\n      for (const unspent of explainedTxInputs) {\n        if (!unspents.has(unspent.id)) {\n          throw new Error(`Transaction should not contain the UTXO: ${unspent.id}`);\n        }\n      }\n    }\n  }\n\n  async verifyTransaction(params: FlrpVerifyTransactionOptions): Promise<boolean> {\n    const txHex = params.txPrebuild && params.txPrebuild.txHex;\n    if (!txHex) {\n      throw new Error('missing required tx prebuild property txHex');\n    }\n    let tx;\n    try {\n      const txBuilder = this.getBuilder().from(txHex);\n      tx = await txBuilder.build();\n    } catch (error) {\n      throw new Error('Invalid transaction');\n    }\n    const explainedTx = tx.explainTransaction();\n\n    const { type, stakingOptions } = params.txParams;\n    // TODO(BG-62112): change ImportToC type to Import\n    if (!type || (type !== 'ImportToC' && explainedTx.type !== TransactionType[type])) {\n      throw new Error('Tx type does not match with expected txParams type');\n    }\n\n    switch (explainedTx.type) {\n      // @deprecated\n      case TransactionType.AddDelegator:\n      case TransactionType.AddValidator:\n      case TransactionType.AddPermissionlessDelegator:\n      case TransactionType.AddPermissionlessValidator:\n        if (stakingOptions) {\n          this.validateStakingTx(stakingOptions, explainedTx);\n        }\n        break;\n      case TransactionType.Export:\n        if (!params.txParams.recipients || params.txParams.recipients?.length !== 1) {\n          throw new Error('Export Tx requires a recipient');\n        } else {\n          this.validateExportTx(params.txParams.recipients, explainedTx);\n        }\n        break;\n      case TransactionType.Import:\n        if (tx.isTransactionForCChain) {\n          // Import to C-chain\n          if (explainedTx.outputs.length !== 1) {\n            throw new Error('Expected 1 output in import transaction');\n          }\n          if (!params.txParams.recipients || params.txParams.recipients.length !== 1) {\n            throw new Error('Expected 1 recipient in import transaction');\n          }\n        } else {\n          // Import to P-chain\n          if (explainedTx.outputs.length !== 1) {\n            throw new Error('Expected 1 output in import transaction');\n          }\n          this.validateImportTx(explainedTx.inputs, params.txParams);\n        }\n        break;\n      default:\n        throw new Error('Tx type is not supported yet');\n    }\n    return true;\n  }\n\n  /**\n   * Check if address is valid, then make sure it matches the root address.\n   *\n   * @param params.address address to validate\n   * @param params.keychains public keys to generate the wallet\n   */\n  async isWalletAddress(params: VerifyAddressOptions): Promise<boolean> {\n    const { address, keychains } = params;\n\n    if (!this.isValidAddress(address)) {\n      throw new InvalidAddressError(`invalid address: ${address}`);\n    }\n    if (!keychains || keychains.length !== 3) {\n      throw new Error('Invalid keychains');\n    }\n\n    // multisig addresses are separated by ~\n    const splitAddresses = address.split('~');\n\n    // derive addresses from keychain\n    const unlockAddresses = keychains.map((keychain) =>\n      new FlrpLib.KeyPair({ pub: keychain.pub }).getAddress(this._staticsCoin.network.type)\n    );\n\n    if (splitAddresses.length !== unlockAddresses.length) {\n      throw new UnexpectedAddressError(`address validation failure: multisig address length does not match`);\n    }\n\n    if (!this.adressesArraysMatch(splitAddresses, unlockAddresses)) {\n      throw new UnexpectedAddressError(`address validation failure: ${address} is not of this wallet`);\n    }\n\n    return true;\n  }\n\n  /**\n   * Validate that two multisig address arrays have the same elements, order doesnt matter\n   * @param addressArray1\n   * @param addressArray2\n   * @returns true if address arrays have the same addresses\n   * @private\n   */\n  private adressesArraysMatch(addressArray1: string[], addressArray2: string[]) {\n    return JSON.stringify(addressArray1.sort()) === JSON.stringify(addressArray2.sort());\n  }\n\n  /**\n   * Generate Flrp key pair\n   *\n   * @param {Buffer} seed - Seed from which the new keypair should be generated, otherwise a random seed is used\n   * @returns {Object} object with generated pub and prv\n   */\n  generateKeyPair(seed?: Buffer): KeyPair {\n    const keyPair = seed ? new FlrpLib.KeyPair({ seed }) : new FlrpLib.KeyPair();\n    const keys = keyPair.getKeys();\n\n    if (!keys.prv) {\n      throw new Error('Missing prv in key generation.');\n    }\n\n    return {\n      pub: keys.pub,\n      prv: keys.prv,\n    };\n  }\n\n  /**\n   * Return boolean indicating whether input is valid public key for the coin\n   *\n   * @param {string} pub the prv to be checked\n   * @returns is it valid?\n   */\n  isValidPub(pub: string): boolean {\n    try {\n      new FlrpLib.KeyPair({ pub });\n      return true;\n    } catch (e) {\n      return false;\n    }\n  }\n\n  /**\n   * Return boolean indicating whether input is valid private key for the coin\n   *\n   * @param {string} prv the prv to be checked\n   * @returns is it valid?\n   */\n  isValidPrv(prv: string): boolean {\n    try {\n      new FlrpLib.KeyPair({ prv });\n      return true;\n    } catch (e) {\n      return false;\n    }\n  }\n\n  isValidAddress(address: string | string[]): boolean {\n    if (address === undefined) {\n      return false;\n    }\n\n    // validate eth address for cross-chain txs to c-chain\n    if (typeof address === 'string' && utils.isValidEthereumAddress(address)) {\n      return true;\n    }\n\n    return FlrpLib.Utils.isValidAddress(address);\n  }\n\n  /**\n   * Signs Flrp transaction\n   */\n  async signTransaction(params: FlrpSignTransactionOptions): Promise<SignedTransaction> {\n    // deserialize raw transaction (note: fromAddress has onchain order)\n    const txBuilder = this.getBuilder().from(params.txPrebuild.txHex);\n    const key = params.prv;\n\n    // push the keypair to signer array\n    txBuilder.sign({ key });\n\n    // build the transaction\n    const transaction: BaseTransaction = await txBuilder.build();\n    if (!transaction) {\n      throw new InvalidTransactionError('Error while trying to build transaction');\n    }\n    return transaction.signature.length >= 2\n      ? { txHex: transaction.toBroadcastFormat() }\n      : { halfSigned: { txHex: transaction.toBroadcastFormat() } };\n  }\n\n  async parseTransaction(params: ParseTransactionOptions): Promise<ParsedTransaction> {\n    return {};\n  }\n\n  /**\n   * Explain a Flrp transaction from txHex\n   * @param params\n   * @param callback\n   */\n  async explainTransaction(params: ExplainTransactionOptions): Promise<FlrpLib.TransactionExplanation> {\n    const txHex = params.txHex ?? params?.halfSigned?.txHex;\n    if (!txHex) {\n      throw new Error('missing transaction hex');\n    }\n    try {\n      const txBuilder = this.getBuilder().from(txHex);\n      const tx = await txBuilder.build();\n      return tx.explainTransaction();\n    } catch (e) {\n      throw new Error(`Invalid transaction: ${e.message}`);\n    }\n  }\n\n  recoverySignature(message: Buffer, signature: Buffer): Buffer {\n    return FlrpLib.Utils.recoverySignature(this._staticsCoin.network as FlareNetwork, message, signature);\n  }\n\n  async signMessage(key: KeyPair, message: string | Buffer): Promise<Buffer> {\n    const prv = new FlrpLib.KeyPair(key).getPrivateKey();\n    if (!prv) {\n      throw new SigningError('Invalid key pair options');\n    }\n    if (typeof message === 'string') {\n      message = Buffer.from(message, 'hex');\n    }\n    return FlrpLib.Utils.createSignature(this._staticsCoin.network as FlareNetwork, message, prv);\n  }\n\n  private getBuilder(): FlrpLib.TransactionBuilderFactory {\n    return new FlrpLib.TransactionBuilderFactory(coins.get(this.getChain()));\n  }\n\n  /** @inheritDoc */\n  auditDecryptedKey(params: AuditDecryptedKeyParams): void {\n    /** https://bitgoinc.atlassian.net/browse/COIN-4213 */\n    throw new MethodNotImplementedError();\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flrp.js","sourceRoot":"","sources":["../../src/flrp.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseCoin as StaticsBaseCoin, CoinFamily, coins, FlareNetwork } from '@bitgo-beta/statics';\nimport {\n  AuditDecryptedKeyParams,\n  BaseCoin,\n  BitGoBase,\n  KeyPair,\n  MPCAlgorithm,\n  MultisigType,\n  multisigTypes,\n  ParsedTransaction,\n  ParseTransactionOptions,\n  SignedTransaction,\n  VerifyAddressOptions,\n  TransactionType,\n  ITransactionRecipient,\n  InvalidAddressError,\n  UnexpectedAddressError,\n  InvalidTransactionError,\n  BaseTransaction,\n  SigningError,\n  MethodNotImplementedError,\n  SignableTransaction,\n  isAvalancheAtomicTx,\n} from '@bitgo-beta/sdk-core';\nimport * as FlrpLib from './lib';\nimport {\n  CreatePairedWalletParams,\n  CreatePairedWalletResponse,\n  FlrpEntry,\n  FlrpExplainTransactionOptions,\n  FlrpSignTransactionOptions,\n  FlrpTransactionParams,\n  FlrpVerifyTransactionOptions,\n} from './lib/iface';\nimport utils from './lib/utils';\nimport BigNumber from 'bignumber.js';\nimport { isValidAddress as isValidEthAddress } from 'ethereumjs-util';\n\nexport class Flrp extends BaseCoin {\n  protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;\n\n  constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>) {\n    super(bitgo);\n\n    if (!staticsCoin) {\n      throw new Error('missing required constructor parameter staticsCoin');\n    }\n\n    this._staticsCoin = staticsCoin;\n  }\n\n  static createInstance(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>): BaseCoin {\n    return new Flrp(bitgo, staticsCoin);\n  }\n\n  getChain(): string {\n    return this._staticsCoin.name;\n  }\n  getFamily(): CoinFamily {\n    return this._staticsCoin.family;\n  }\n  getFullName(): string {\n    return this._staticsCoin.fullName;\n  }\n  getBaseFactor(): string | number {\n    return Math.pow(10, this._staticsCoin.decimalPlaces);\n  }\n\n  /** inherited doc */\n  getDefaultMultisigType(): MultisigType {\n    return multisigTypes.tss;\n  }\n\n  /** @inheritdoc */\n  supportsTss(): boolean {\n    return true;\n  }\n\n  /** @inheritdoc */\n  getMPCAlgorithm(): MPCAlgorithm {\n    return 'ecdsa';\n  }\n\n  async verifyTransaction(params: FlrpVerifyTransactionOptions): Promise<boolean> {\n    const txHex = params.txPrebuild && params.txPrebuild.txHex;\n    if (!txHex) {\n      throw new Error('missing required tx prebuild property txHex');\n    }\n    let tx;\n    try {\n      const txBuilder = this.getBuilder().from(txHex);\n      tx = await txBuilder.build();\n    } catch (error) {\n      throw new Error(`Invalid transaction: ${error.message}`);\n    }\n    const explainedTx = tx.explainTransaction();\n\n    const type = params.txParams.type;\n    // WP intentType aliases (lowercase) must map to TransactionType enum keys.\n    const normalizedType =\n      type === 'stake'\n        ? 'AddPermissionlessDelegator'\n        : type === 'import'\n        ? 'Import'\n        : type === 'importtoc'\n        ? 'ImportToC'\n        : type;\n\n    // When type is provided, verify it matches the parsed transaction.\n    // When type is not provided (MPC/TSS intent flow where buildParams are unavailable),\n    // skip the type match check and rely on explainedTx.type from the parsed hex —\n    // the transaction was built by wallet-platform and the hex is the source of truth.\n    if (normalizedType && normalizedType !== 'ImportToC' && explainedTx.type !== TransactionType[normalizedType]) {\n      throw new Error('Tx type does not match with expected txParams type');\n    }\n\n    switch (explainedTx.type) {\n      case TransactionType.Export:\n        if (!params.txParams.recipients || params.txParams.recipients?.length !== 1) {\n          throw new Error('Export Tx requires a recipient');\n        } else {\n          this.validateExportTx(params.txParams.recipients, explainedTx);\n        }\n        break;\n      case TransactionType.Import:\n        if (tx.isTransactionForCChain) {\n          // Import to C-chain\n          if (explainedTx.outputs.length !== 1) {\n            throw new Error('Expected 1 output in import transaction');\n          }\n          if (!params.txParams.recipients || params.txParams.recipients.length !== 1) {\n            throw new Error('Expected 1 recipient in import transaction');\n          }\n        } else {\n          // Import to P-chain\n          if (explainedTx.outputs.length !== 1) {\n            throw new Error('Expected 1 output in import transaction');\n          }\n          this.validateImportTx(explainedTx.inputs, params.txParams);\n        }\n        break;\n      case TransactionType.AddPermissionlessDelegator:\n        if (params.txParams.stakingOptions) {\n          this.validateDelegationTx(params.txParams, explainedTx);\n        }\n        break;\n      default:\n        throw new Error('Tx type is not supported yet');\n    }\n    return true;\n  }\n\n  /**\n   * Check if export txn is valid, based on expected tx params.\n   *\n   * @param {ITransactionRecipient[]} recipients expected recipients and info\n   * @param {FlrpLib.TransactionExplanation} explainedTx explained export transaction\n   */\n  validateExportTx(recipients: ITransactionRecipient[], explainedTx: FlrpLib.TransactionExplanation): void {\n    if (recipients.length !== 1 || explainedTx.outputs.length !== 1) {\n      throw new Error('Export Tx requires one recipient');\n    }\n\n    const maxImportFee = (this._staticsCoin.network as FlareNetwork).maxImportFee;\n    const recipientAmount = new BigNumber(recipients[0].amount);\n    if (\n      recipientAmount.isGreaterThan(explainedTx.outputAmount) ||\n      recipientAmount.plus(maxImportFee).isLessThan(explainedTx.outputAmount)\n    ) {\n      throw new Error(\n        `Tx total amount ${explainedTx.outputAmount} does not match with expected total amount field ${recipientAmount} and max import fee ${maxImportFee}`\n      );\n    }\n\n    if (explainedTx.outputs && !utils.isValidAddress(explainedTx.outputs[0].address)) {\n      throw new Error(`Invalid P-chain address ${explainedTx.outputs[0].address}`);\n    }\n  }\n\n  /**\n   * Check if import txn into P is valid, based on expected tx params.\n   *\n   * @param {FlrpEntry[]} explainedTxInputs tx inputs (unspents to be imported)\n   * @param {FlrpTransactionParams} txParams expected tx info to check against\n   */\n  validateImportTx(explainedTxInputs: FlrpEntry[], txParams: FlrpTransactionParams): void {\n    if (txParams.unspents) {\n      if (explainedTxInputs.length !== txParams.unspents.length) {\n        throw new Error(`Expected ${txParams.unspents.length} UTXOs, transaction had ${explainedTxInputs.length}`);\n      }\n\n      const unspents = new Set(txParams.unspents);\n\n      for (const unspent of explainedTxInputs) {\n        if (!unspents.has(unspent.id)) {\n          throw new Error(`Transaction should not contain the UTXO: ${unspent.id}`);\n        }\n      }\n    }\n  }\n\n  /**\n   * Validate AddPermissionlessDelegator transaction parameters.\n   * Validates both expected txParams and the parsed explainedTx for consistency.\n   *\n   * @param {FlrpTransactionParams} txParams - Expected transaction parameters\n   * @param {FlrpLib.TransactionExplanation} explainedTx - Parsed transaction explanation\n   */\n  validateDelegationTx(txParams: FlrpTransactionParams, explainedTx: FlrpLib.TransactionExplanation): void {\n    if (!txParams.stakingOptions) {\n      throw new Error('Delegation transaction requires stakingOptions');\n    }\n\n    const { nodeID, amount, durationSeconds, rewardAddress } = txParams.stakingOptions;\n\n    if (!nodeID) {\n      throw new Error('Delegation transaction requires nodeID');\n    }\n\n    if (!amount) {\n      throw new Error('Delegation transaction requires amount');\n    }\n\n    if (!durationSeconds) {\n      throw new Error('Delegation transaction requires durationSeconds');\n    }\n\n    if (!rewardAddress) {\n      throw new Error('Delegation transaction requires rewardAddress');\n    }\n\n    // Validate nodeID format using utility method\n    if (!utils.isValidNodeID(nodeID)) {\n      throw new Error(`Invalid nodeID format: ${nodeID}`);\n    }\n\n    // Validate that the parsed transaction's output amount matches the expected staking amount\n    // The outputAmount in explainedTx represents the total stake amount in the transaction\n    if (explainedTx.outputAmount) {\n      const expectedAmount = new BigNumber(amount);\n      const actualAmount = new BigNumber(explainedTx.outputAmount);\n      if (!expectedAmount.isEqualTo(actualAmount)) {\n        throw new Error(`Delegation amount mismatch: expected ${amount}, transaction has ${explainedTx.outputAmount}`);\n      }\n    }\n  }\n\n  private getBuilder(): FlrpLib.TransactionBuilderFactory {\n    return new FlrpLib.TransactionBuilderFactory(coins.get(this.getChain()));\n  }\n\n  /**\n   * Check if address is valid, then make sure it matches the root address.\n   *\n   * @param params.address address to validate\n   * @param params.keychains public keys to generate the wallet\n   */\n  async isWalletAddress(params: VerifyAddressOptions): Promise<boolean> {\n    const { address, keychains } = params;\n\n    if (!this.isValidAddress(address)) {\n      throw new InvalidAddressError(`invalid address: ${address}`);\n    }\n\n    // multisig addresses are separated by ~\n    const splitAddresses = address.split('~');\n\n    // MPC/TSS: single address derived from common keychain\n    if (splitAddresses.length === 1 && keychains?.length === 1) {\n      const expectedAddr = new FlrpLib.KeyPair({ pub: keychains[0].pub }).getAddress(this._staticsCoin.network.type);\n      if (expectedAddr !== address) {\n        throw new UnexpectedAddressError(`address validation failure: ${address} is not of this wallet`);\n      }\n      return true;\n    }\n\n    if (!keychains || keychains.length !== 3) {\n      throw new Error('Invalid keychains');\n    }\n\n    // derive addresses from keychain\n    const unlockAddresses = keychains.map((keychain) =>\n      new FlrpLib.KeyPair({ pub: keychain.pub }).getAddress(this._staticsCoin.network.type)\n    );\n\n    if (splitAddresses.length !== unlockAddresses.length) {\n      throw new UnexpectedAddressError(`address validation failure: multisig address length does not match`);\n    }\n\n    if (!this.adressesArraysMatch(splitAddresses, unlockAddresses)) {\n      throw new UnexpectedAddressError(`address validation failure: ${address} is not of this wallet`);\n    }\n\n    return true;\n  }\n\n  /**\n   * Validate that two multisig address arrays have the same elements, order doesnt matter\n   * @param addressArray1\n   * @param addressArray2\n   * @returns true if address arrays have the same addresses\n   * @private\n   */\n  private adressesArraysMatch(addressArray1: string[], addressArray2: string[]) {\n    return JSON.stringify(addressArray1.sort()) === JSON.stringify(addressArray2.sort());\n  }\n\n  /**\n   * Generate Flrp key pair\n   *\n   * @param {Buffer} seed - Seed from which the new keypair should be generated, otherwise a random seed is used\n   * @returns {Object} object with generated pub and prv\n   */\n  generateKeyPair(seed?: Buffer): KeyPair {\n    const keyPair = seed ? new FlrpLib.KeyPair({ seed }) : new FlrpLib.KeyPair();\n    const keys = keyPair.getKeys();\n\n    if (!keys.prv) {\n      throw new Error('Missing prv in key generation.');\n    }\n\n    return {\n      pub: keys.pub,\n      prv: keys.prv,\n    };\n  }\n\n  /**\n   * Return boolean indicating whether input is valid public key for the coin\n   *\n   * @param {string} pub the prv to be checked\n   * @returns is it valid?\n   */\n  isValidPub(pub: string): boolean {\n    try {\n      new FlrpLib.KeyPair({ pub });\n      return true;\n    } catch (e) {\n      return false;\n    }\n  }\n\n  /**\n   * Return boolean indicating whether input is valid private key for the coin\n   *\n   * @param {string} prv the prv to be checked\n   * @returns is it valid?\n   */\n  isValidPrv(prv: string): boolean {\n    try {\n      new FlrpLib.KeyPair({ prv });\n      return true;\n    } catch (e) {\n      return false;\n    }\n  }\n\n  isValidAddress(address: string | string[]): boolean {\n    if (address === undefined) {\n      return false;\n    }\n\n    // validate eth address for cross-chain txs to c-chain\n    if (typeof address === 'string' && isValidEthAddress(address)) {\n      return true;\n    }\n\n    return FlrpLib.Utils.isValidAddress(address);\n  }\n\n  /**\n   * Get the raw bytes that need to be signed by the MPC ceremony.\n   * MPC.sign() internally SHA-256 hashes, so return raw unsigned tx bytes.\n   */\n  async getSignablePayload(txHex: string): Promise<Buffer> {\n    const txBuilder = this.getBuilder().from(txHex);\n    const tx = (await txBuilder.build()) as FlrpLib.Transaction;\n    return Buffer.from(tx.signablePayload);\n  }\n\n  /**\n   * Inject an MPC-produced signature into an unsigned transaction.\n   * @param txHex - Unsigned transaction hex\n   * @param signature - 65-byte ECDSA signature (r || s || recovery)\n   * @returns Signed transaction hex\n   */\n  async addSignatureToTransaction(txHex: string, signature: Buffer): Promise<string> {\n    const txBuilder = this.getBuilder().from(txHex);\n    const tx = await txBuilder.build();\n    (tx as FlrpLib.Transaction).addExternalSignature(new Uint8Array(signature));\n    return tx.toBroadcastFormat();\n  }\n\n  /**\n   * Signs Avaxp transaction\n   */\n  async signTransaction(params: FlrpSignTransactionOptions): Promise<SignedTransaction> {\n    // deserialize raw transaction (note: fromAddress has onchain order)\n    const txBuilder = this.getBuilder().from(params.txPrebuild.txHex);\n    const key = params.prv;\n\n    // push the keypair to signer array\n    txBuilder.sign({ key });\n\n    // build the transaction\n    const transaction: BaseTransaction = await txBuilder.build();\n    if (!transaction) {\n      throw new InvalidTransactionError('Error while trying to build transaction');\n    }\n    return transaction.signature.length >= 2\n      ? { txHex: transaction.toBroadcastFormat() }\n      : { halfSigned: { txHex: transaction.toBroadcastFormat() } };\n  }\n\n  async parseTransaction(params: ParseTransactionOptions): Promise<ParsedTransaction> {\n    return {};\n  }\n\n  /**\n   * Explain a Avaxp transaction from txHex\n   * @param params\n   * @param callback\n   */\n  async explainTransaction(params: FlrpExplainTransactionOptions): Promise<FlrpLib.TransactionExplanation> {\n    const txHex = params.txHex ?? params?.halfSigned?.txHex;\n    if (!txHex) {\n      throw new Error('missing transaction hex');\n    }\n    try {\n      const txBuilder = this.getBuilder().from(txHex);\n      const tx = (await txBuilder.build()) as FlrpLib.Transaction;\n      const explanation = tx.explainTransaction();\n\n      // For a C→P export (ExportInC viewed from the FLRP P-chain perspective), the\n      // exportedOutputs contain the P-chain UTXO amount, which is the gross amount\n      // BEFORE the import fee is deducted. The platform uses this explanation to show\n      // the \"pending import amount\" before the ImportInP is confirmed. To avoid\n      // displaying a higher-than-actual amount, subtract the minimum import-to-P fee\n      // so the displayed amount reflects the expected net P-chain receipt.\n      if (tx.isTransactionForCChain && explanation.type === TransactionType.Export) {\n        const minImportToPFee = BigInt((this._staticsCoin.network as FlareNetwork).minImportToPFee);\n        const adjustedOutputs = explanation.outputs.map((o) => ({\n          ...o,\n          amount: (BigInt(o.amount) - minImportToPFee).toString(),\n        }));\n        const adjustedOutputAmount = (BigInt(explanation.outputAmount) - minImportToPFee).toString();\n        return {\n          ...explanation,\n          outputs: adjustedOutputs,\n          outputAmount: adjustedOutputAmount,\n        };\n      }\n\n      return explanation;\n    } catch (e) {\n      throw new Error(`Invalid transaction: ${e.message}`);\n    }\n  }\n\n  recoverySignature(messageHash: Buffer, signature: Buffer): Buffer {\n    return FlrpLib.Utils.recoverySignature(messageHash, signature);\n  }\n\n  async signMessage(key: KeyPair, message: string | Buffer): Promise<Buffer> {\n    const prv = new FlrpLib.KeyPair(key).getPrivateKey();\n    if (!prv) {\n      throw new SigningError('Invalid key pair options');\n    }\n    if (typeof message === 'string') {\n      message = Buffer.from(message, 'hex');\n    }\n    return FlrpLib.Utils.createSignature(this._staticsCoin.network as FlareNetwork, message, prv);\n  }\n\n  /**\n   * Returns true when the signableHex for this transaction is already the\n   * final signing hash (SHA-256 for Avalanche atomic txs), and the MPC\n   * signing flow should use it directly without additional hashing.\n   */\n  isSignablePreHashed(unsignedTx: SignableTransaction): boolean {\n    return isAvalancheAtomicTx(unsignedTx);\n  }\n\n  /** @inheritDoc */\n  auditDecryptedKey(params: AuditDecryptedKeyParams): void {\n    throw new MethodNotImplementedError();\n  }\n\n  async createPairedWallet(params: CreatePairedWalletParams): Promise<CreatePairedWalletResponse> {\n    const { walletId, label } = params;\n    return this.bitgo\n      .post(this.url(`/wallet/${walletId}/create-paired-wallet`))\n      .send(label ? { label } : {})\n      .result();\n  }\n}\n"]}

package/dist/src/index.d.ts

@@ -1,6 +1,5 @@
 export * from './flrp';
 export * from './tflrp';
 export * as FlrPLib from './lib';
-export * from './iface';
 export * from './register';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC;AACxB,OAAO,KAAK,OAAO,MAAM,OAAO,CAAC;AACjC,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC;AACxB,OAAO,KAAK,OAAO,MAAM,OAAO,CAAC;AACjC,cAAc,YAAY,CAAC"}

package/dist/src/index.js

@@ -40,6 +40,5 @@ exports.FlrPLib = void 0;
 __exportStar(require("./flrp"), exports);
 __exportStar(require("./tflrp"), exports);
 exports.FlrPLib = __importStar(require("./lib"));
-__exportStar(require("./iface"), exports);
 __exportStar(require("./register"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUEseUNBQXVCO0FBQ3ZCLDBDQUF3QjtBQUN4QixpREFBaUM7QUFDakMsMENBQXdCO0FBQ3hCLDZDQUEyQiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZmxycCc7XG5leHBvcnQgKiBmcm9tICcuL3RmbHJwJztcbmV4cG9ydCAqIGFzIEZsclBMaWIgZnJvbSAnLi9saWInO1xuZXhwb3J0ICogZnJvbSAnLi9pZmFjZSc7XG5leHBvcnQgKiBmcm9tICcuL3JlZ2lzdGVyJztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUEseUNBQXVCO0FBQ3ZCLDBDQUF3QjtBQUN4QixpREFBaUM7QUFDakMsNkNBQTJCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9mbHJwJztcbmV4cG9ydCAqIGZyb20gJy4vdGZscnAnO1xuZXhwb3J0ICogYXMgRmxyUExpYiBmcm9tICcuL2xpYic7XG5leHBvcnQgKiBmcm9tICcuL3JlZ2lzdGVyJztcbiJdfQ==