@bitgo/sdk-coin-stx 3.5.7 → 3.6.1

package/CHANGELOG.md

@@ -3,6 +3,21 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [3.6.1](https://github.com/BitGo/BitGoJS/compare/@bitgo/sdk-coin-stx@3.6.0...@bitgo/sdk-coin-stx@3.6.1) (2025-05-20)
+
+**Note:** Version bump only for package @bitgo/sdk-coin-stx
+
+# [3.6.0](https://github.com/BitGo/BitGoJS/compare/@bitgo/sdk-coin-stx@3.5.7...@bitgo/sdk-coin-stx@3.6.0) (2025-05-07)
+
+### Bug Fixes
+
+- **sdk-coin-stx:** bug fix in recoverable amount calculation for sip10 ([8b72846](https://github.com/BitGo/BitGoJS/commit/8b72846d84f46ce4306dbb47cc87f2c6bd6fa371))
+- **sdk-coin-stx:** return required fields for unsigned sweep ([8a50ff8](https://github.com/BitGo/BitGoJS/commit/8a50ff884931a806357e29b3e1b2053048781398))
+
+### Features
+
+- **sdk-coin-stx:** added recover method for wrw to support stx & sip10 token ([1ff6572](https://github.com/BitGo/BitGoJS/commit/1ff6572f8aa93b6c487efe17018fc730aaffef44))
+
 ## [3.5.7](https://github.com/BitGo/BitGoJS/compare/@bitgo/sdk-coin-stx@3.5.6...@bitgo/sdk-coin-stx@3.5.7) (2025-04-29)
 
 **Note:** Version bump only for package @bitgo/sdk-coin-stx

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

@@ -1,4 +1,5 @@
 import { ClarityValue, PayloadType } from '@stacks/transactions';
+import { TransactionExplanation as BaseTransactionExplanation } from '@bitgo/sdk-core';
 export interface TxData {
     id: string;
     from: string;
@@ -51,4 +52,53 @@ export interface TokenTransferParams {
     amount: string;
     memo?: string;
 }
+export interface TokenBalanceData {
+    balance: string;
+    total_sent: string;
+    total_received: string;
+}
+export interface NativeStxBalance {
+    balance: string;
+    total_miner_rewards_received: string;
+    lock_tx_id: string;
+    locked: string;
+    lock_height: number;
+    burnchain_lock_height: number;
+    burnchain_unlock_height: number;
+}
+export interface SingleFungibleTokenBalance {
+    balance: string;
+}
+export interface StxNonceResponse {
+    last_mempool_tx_nonce?: number;
+    last_executed_tx_nonce?: number;
+    possible_next_nonce: number;
+    detected_missing_nonces?: number[];
+    detected_mempool_nonces?: number[];
+}
+export interface StxTxnFeeEstimationResponse {
+    estimations: {
+        feeRate: number;
+        fee: number;
+    }[];
+}
+export interface RecoveryOptions {
+    backupKey: string;
+    userKey: string;
+    rootAddress: string;
+    recoveryDestination: string;
+    bitgoKey?: string;
+    walletPassphrase?: string;
+    contractId?: string;
+}
+export interface RecoveryInfo extends BaseTransactionExplanation {
+    txHex: string;
+    feeInfo?: {
+        fee: string;
+    };
+    coin?: string;
+}
+export interface RecoveryTransaction {
+    txHex: string;
+}
 //# sourceMappingURL=iface.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"iface.d.ts","sourceRoot":"","sources":["../../../src/lib/iface.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAEjE,MAAM,WAAW,MAAM;IACrB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,wBAAwB,GAAG,qBAAqB,CAAC;CAC3D;AACD,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC,aAAa,CAAC;IAChD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC,YAAY,CAAC;IAC/C,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,YAAY,EAAE,CAAC;CAC9B;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,GAAG,GAAG,SAAS,EAAE,GAAG,gBAAgB,CAAC;CAC5C;AAED,MAAM,WAAW,SAAU,SAAQ,gBAAgB;IACjD,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;CACf"}
+{"version":3,"file":"iface.d.ts","sourceRoot":"","sources":["../../../src/lib/iface.ts"],"names":[],"mappings":"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"}

package/dist/src/lib/iface.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaWZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL2lmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKiBlc2xpbnQtZGlzYWJsZSBAdHlwZXNjcmlwdC1lc2xpbnQvbm8tZXhwbGljaXQtYW55ICovXG5pbXBvcnQgeyBDbGFyaXR5VmFsdWUsIFBheWxvYWRUeXBlIH0gZnJvbSAnQHN0YWNrcy90cmFuc2FjdGlvbnMnO1xuXG5leHBvcnQgaW50ZXJmYWNlIFR4RGF0YSB7XG4gIGlkOiBzdHJpbmc7XG4gIGZyb206IHN0cmluZztcbiAgZmVlOiBzdHJpbmc7XG4gIG5vbmNlOiBudW1iZXI7XG4gIHBheWxvYWQ6IFN0YWNrc1RyYW5zYWN0aW9uUGF5bG9hZCB8IFN0YWNrc0NvbnRyYWN0UGF5bG9hZDtcbn1cbmV4cG9ydCBpbnRlcmZhY2UgU2lnbmF0dXJlRGF0YSB7XG4gIHR5cGU6IG51bWJlcjtcbiAgZGF0YTogc3RyaW5nO1xuICBpbmRleDogbnVtYmVyO1xuICBzaWdIYXNoOiBzdHJpbmc7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgU3RhY2tzVHJhbnNhY3Rpb25QYXlsb2FkIHtcbiAgcmVhZG9ubHkgcGF5bG9hZFR5cGU6IFBheWxvYWRUeXBlLlRva2VuVHJhbnNmZXI7XG4gIG1lbW8/OiBzdHJpbmc7XG4gIHRvOiBzdHJpbmc7XG4gIGFtb3VudDogc3RyaW5nO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFN0YWNrc0NvbnRyYWN0UGF5bG9hZCB7XG4gIHJlYWRvbmx5IHBheWxvYWRUeXBlOiBQYXlsb2FkVHlwZS5Db250cmFjdENhbGw7XG4gIGNvbnRyYWN0QWRkcmVzczogc3RyaW5nO1xuICBjb250cmFjdE5hbWU6IHN0cmluZztcbiAgZnVuY3Rpb25OYW1lOiBzdHJpbmc7XG4gIGZ1bmN0aW9uQXJnczogQ2xhcml0eVZhbHVlW107XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgQ2xhcml0eVZhbHVlSnNvbiB7XG4gIHR5cGU6IHN0cmluZztcbiAgdmFsPzogYW55IHwgVHVwbGVEYXRhW10gfCBDbGFyaXR5VmFsdWVKc29uO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFR1cGxlRGF0YSBleHRlbmRzIENsYXJpdHlWYWx1ZUpzb24ge1xuICBrZXk6IHN0cmluZztcbn1cblxuZXhwb3J0IGludGVyZmFjZSBTaWduUmVzcG9uc2Uge1xuICBzaWduYXR1cmU6IHN0cmluZztcbiAgcmVjaWQ6IG51bWJlcjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBBZGRyZXNzRGV0YWlscyB7XG4gIGFkZHJlc3M6IHN0cmluZztcbiAgbWVtb0lkPzogc3RyaW5nO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFNlbmRQYXJhbXMge1xuICBhZGRyZXNzOiBzdHJpbmc7XG4gIGFtb3VudDogc3RyaW5nO1xuICBtZW1vPzogc3RyaW5nO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFRva2VuVHJhbnNmZXJQYXJhbXMge1xuICBzZW5kZXI6IHN0cmluZztcbiAgcmVjaXBpZW50OiBzdHJpbmc7XG4gIGFtb3VudDogc3RyaW5nO1xuICBtZW1vPzogc3RyaW5nO1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/stx.d.ts

@@ -1,7 +1,10 @@
-import { BaseCoin, BitGoBase, KeyPair, MultisigType, SignedTransaction, VerifyAddressOptions, VerifyTransactionOptions } from '@bitgo/sdk-core';
+import { BaseCoin, BaseTransaction, BitGoBase, KeyPair, MultisigType, SignedTransaction, VerifyAddressOptions, VerifyTransactionOptions } from '@bitgo/sdk-core';
 import { BaseCoin as StaticsBaseCoin, CoinFamily } from '@bitgo/statics';
 import { ExplainTransactionOptions, StxSignTransactionOptions, StxTransactionExplanation } from './types';
 import { TransactionBuilder } from './lib/transactionBuilder';
+import { AddressDetails, NativeStxBalance, RecoveryInfo, RecoveryOptions, RecoveryTransaction, SingleFungibleTokenBalance, StxNonceResponse } from './lib/iface';
+import { TransferBuilder } from './lib/transferBuilder';
+import { FungibleTokenTransferBuilder } from './lib/fungibleTokenTransferBuilder';
 export declare class Stx extends BaseCoin {
     protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;
     constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>);
@@ -11,8 +14,6 @@ export declare class Stx extends BaseCoin {
     getFullName(): string;
     getBaseFactor(): string | number;
     getTransaction(coinConfig: Readonly<StaticsBaseCoin>): TransactionBuilder;
-    /** {@inheritDoc } **/
-    supportsMultisig(): boolean;
     /** inherited doc */
     getDefaultMultisigType(): MultisigType;
     verifyTransaction(params: VerifyTransactionOptions): Promise<boolean>;
@@ -57,5 +58,141 @@ export declare class Stx extends BaseCoin {
      * @param params
      */
     explainTransaction(params: ExplainTransactionOptions): Promise<StxTransactionExplanation | undefined>;
+    /**
+     * Get URLs of some active public nodes
+     * @returns {String} node url
+     */
+    getPublicNodeUrl(): string;
+    /**
+     * Get native stacks balance for an account
+     * @param {String} address - stacks address
+     * @returns {Promise<NativeStxBalance>}
+     */
+    protected getNativeStxBalanceFromNode({ address }: {
+        address: string;
+    }): Promise<NativeStxBalance>;
+    /**
+     * Get single fungible token balance for an account
+     * @param {String} address - stacks address
+     * @param {String} assetId - fungible token asset id
+     * @returns {Promise<SingleFungibleTokenBalance>}
+     */
+    protected getSingleFungibleTokenBalanceFromNode({ address, assetId, }: {
+        address: string;
+        assetId: string;
+    }): Promise<SingleFungibleTokenBalance>;
+    /**
+     * Get nonce data specific to an account from a public node
+     * @param {String} address - stacks address
+     * @returns {Promise<StxNonceResponse>}
+     */
+    protected getAccountNonceFromNode({ address }: {
+        address: string;
+    }): Promise<StxNonceResponse>;
+    /**
+     * Get stacks transaction estimated fee
+     * @param {String} txHex - hex of stacks transaction payload
+     * @param {Number} txHexLength - length of built serialized transaction
+     * @returns {Promise<Number>} - fee estimate (taking the lowest)
+     */
+    protected getTransactionFeeEstimation({ txHex, txHexLength, }: {
+        txHex: string;
+        txHexLength: number;
+    }): Promise<number>;
+    /**
+     * Format for offline vault signing
+     * @param {BaseTransaction} tx - base transaction
+     * @returns {Promise<RecoveryInfo>}
+     */
+    protected formatForOfflineVault(tx: BaseTransaction): Promise<RecoveryInfo>;
+    /**
+     * Get the recoverable amount & fee after subtracting the txn fee
+     * @param {String} serializedHex - serialized txn hex
+     * @param {Number} txHexLength - deserialized txn length
+     * @param {String} balance - total account balance
+     * @param {String} tokenBalance - total token balance
+     * @returns {Promise<Record<string, string>>}
+     */
+    protected getRecoverableAmountAndFee(serializedHex: string, txHexLength: number, balance: string, tokenBalance?: string): Promise<Record<string, string>>;
+    /**
+     * Method to find the right builder for token or native coin transfer
+     * @param {String} contractAddress - token contract address
+     * @param {String} contractName - token contract name
+     * @returns {TransferBuilder|FungibleTokenTransferBuilder}
+     */
+    protected getTokenOrNativeTransferBuilder(contractAddress?: string, contractName?: string): TransferBuilder | FungibleTokenTransferBuilder;
+    /**
+     * Method to build fungible token transfer transaction
+     * @param {FungibleTokenTransferBuilder} builder - fungible token transfer builder
+     * @param {String} contractAddress - token contract address
+     * @param {String} contractName - token contract name
+     * @param {String[]} pubs - account public keys
+     * @param {Number} nonce - account nonce
+     * @param {AddressDetails} rootAddressDetails - root address details
+     * @param {AddressDetails} destinationAddressDetails - receive address details
+     * @param {String} stxBalance - native stx balance
+     * @returns {Promise<BaseTransaction>} - built transaction
+     */
+    protected buildTokenTransferTransaction({ builder, contractAddress, contractName, pubs, nonce, rootAddressDetails, destinationAddressDetails, stxBalance, }: {
+        builder: FungibleTokenTransferBuilder;
+        contractAddress: string;
+        contractName: string;
+        pubs: string[];
+        nonce: number;
+        rootAddressDetails: AddressDetails;
+        destinationAddressDetails: AddressDetails;
+        stxBalance: string;
+    }): Promise<BaseTransaction>;
+    /**
+     * Method to build native transfer transaction
+     * @param {TransferBuilder} builder - transfer builder
+     * @param {String[]} pubs - account public keys
+     * @param {Number} nonce - account nonce
+     * @param {AddressDetails} destinationAddressDetails - receive address details
+     * @param {String} stxBalance - native stx balance
+     * @returns {Promise<BaseTransaction>} - built transaction
+     */
+    protected buildNativeTransferTransaction({ builder, pubs, nonce, destinationAddressDetails, stxBalance, }: {
+        builder: TransferBuilder;
+        pubs: string[];
+        nonce: number;
+        destinationAddressDetails: AddressDetails;
+        stxBalance: string;
+    }): Promise<BaseTransaction>;
+    /**
+     * Method that uses appropriate builder and builds transaction depending on token or native coin
+     * @param {String[]} pubs - public keys
+     * @param {AddressDetails} rootAddressDetails - sender address detail
+     * @param {AddressDetails} destinationAddressDetails - receiver address detail
+     * @param {Number} nonce - wallet nonce
+     * @param {String} balance - wallet balance
+     * @param {String | undefined} contractAddress - token contract address
+     * @param {String | undefined} contractName - token contract name
+     * @returns {Promise<BaseTransaction>} built transaction
+     */
+    protected getNativeOrTokenTransaction({ pubs, rootAddressDetails, destinationAddressDetails, nonce, stxBalance, contractAddressInput, contractName, }: {
+        pubs: string[];
+        rootAddressDetails: AddressDetails;
+        destinationAddressDetails: AddressDetails;
+        nonce: number;
+        stxBalance: string;
+        contractAddressInput?: string;
+        contractName?: string;
+    }): Promise<{
+        tx: BaseTransaction;
+        builder: TransferBuilder | FungibleTokenTransferBuilder;
+    }>;
+    /**
+     * Method to recover native stx or sip10 tokens from bitgo hot & cold wallets
+     * @param {String} params.backupKey - encrypted wallet backup key (public or private)
+     * @param {String} params.userKey - encrypted wallet user key (public or private)
+     * @param {String} params.rootAddress - wallet root address
+     * @param {String} params.recoveryDestination - receive address
+     * @param {String} params.bitgoKey - encrypted bitgo public key
+     * @param {String} params.walletPassphrase - wallet password
+     * @param {String} params.contractId - contract id of the token (mandatory for token recovery)
+     * @returns {Promise<RecoveryInfo|RecoveryTransaction>} RecoveryTransaction.txHex - hex of serialized transaction (signed or unsigned)
+     */
+    recover(params: RecoveryOptions): Promise<RecoveryInfo | RecoveryTransaction>;
 }
 //# sourceMappingURL=stx.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"stx.d.ts","sourceRoot":"","sources":["../../src/stx.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,SAAS,EACT,OAAO,EACP,YAAY,EAEZ,iBAAiB,EAGjB,oBAAoB,EACpB,wBAAwB,EACzB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,QAAQ,IAAI,eAAe,EAAE,UAAU,EAAS,MAAM,gBAAgB,CAAC;AAGhF,OAAO,EAAE,yBAAyB,EAAE,yBAAyB,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAC;AAG1G,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAG9D,qBAAa,GAAI,SAAQ,QAAQ;IAC/B,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;IAIlB,SAAS,IAAI,UAAU;IAIvB,WAAW,IAAI,MAAM;IAIrB,aAAa,IAAI,MAAM,GAAG,MAAM;IAIhC,cAAc,CAAC,UAAU,EAAE,QAAQ,CAAC,eAAe,CAAC,GAAG,kBAAkB;IAIzE,sBAAsB;IACtB,gBAAgB,IAAI,OAAO;IAI3B,oBAAoB;IACpB,sBAAsB,IAAI,YAAY;IAIhC,iBAAiB,CAAC,MAAM,EAAE,wBAAwB,GAAG,OAAO,CAAC,OAAO,CAAC;IAU3E;;;;;;OAMG;IACG,eAAe,CAAC,MAAM,EAAE,oBAAoB,GAAG,OAAO,CAAC,OAAO,CAAC;IAWrE;;;;;OAKG;IACH,eAAe,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO;IAcvC;;;;;OAKG;IACH,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAQhC;;;;;OAKG;IACH,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAQhC,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAQxC;;;OAGG;IACG,eAAe,CAAC,MAAM,EAAE,yBAAyB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAoB9E,gBAAgB,CAAC,MAAM,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC;IAIjD;;;OAGG;IACG,kBAAkB,CAAC,MAAM,EAAE,yBAAyB,GAAG,OAAO,CAAC,yBAAyB,GAAG,SAAS,CAAC;CA0F5G"}
+{"version":3,"file":"stx.d.ts","sourceRoot":"","sources":["../../src/stx.ts"],"names":[],"mappings":"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"}

package/dist/src/stx.js

@@ -1,9 +1,14 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Stx = void 0;
 const sdk_core_1 = require("@bitgo/sdk-core");
 const statics_1 = require("@bitgo/statics");
 const transactions_1 = require("@stacks/transactions");
+const payload_1 = require("@stacks/transactions/dist/payload");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
 const _1 = require(".");
 const lib_1 = require("./lib");
 const utils_1 = require("./lib/utils");
@@ -33,10 +38,6 @@ class Stx extends sdk_core_1.BaseCoin {
     getTransaction(coinConfig) {
         return new lib_1.TransactionBuilderFactory(coinConfig).getTransferBuilder();
     }
-    /** {@inheritDoc } **/
-    supportsMultisig() {
-        return true;
-    }
     /** inherited doc */
     getDefaultMultisigType() {
         return sdk_core_1.multisigTypes.onchain;
@@ -229,6 +230,372 @@ class Stx extends sdk_core_1.BaseCoin {
             };
         }
     }
+    /**
+     * Get URLs of some active public nodes
+     * @returns {String} node url
+     */
+    getPublicNodeUrl() {
+        return sdk_core_1.Environments[this.bitgo.getEnv()].stxNodeUrl;
+    }
+    /**
+     * Get native stacks balance for an account
+     * @param {String} address - stacks address
+     * @returns {Promise<NativeStxBalance>}
+     */
+    async getNativeStxBalanceFromNode({ address }) {
+        const endpoint = `${this.getPublicNodeUrl()}/extended/v2/addresses/${address}/balances/stx`;
+        try {
+            const response = await this.bitgo.get(endpoint);
+            if (response.statusCode !== 200) {
+                throw new Error(`request failed with status ${response.statusCode}`);
+            }
+            const body = response.body;
+            return body;
+        }
+        catch (e) {
+            throw new Error(`unable to get native stx balance from node: ${e.message}`);
+        }
+    }
+    /**
+     * Get single fungible token balance for an account
+     * @param {String} address - stacks address
+     * @param {String} assetId - fungible token asset id
+     * @returns {Promise<SingleFungibleTokenBalance>}
+     */
+    async getSingleFungibleTokenBalanceFromNode({ address, assetId, }) {
+        const endpoint = `${this.getPublicNodeUrl()}/extended/v2/addresses/${address}/balances/ft/${assetId}`;
+        try {
+            const response = await this.bitgo.get(endpoint);
+            if (response.statusCode !== 200) {
+                throw new Error(`request failed with status ${response.statusCode}`);
+            }
+            const body = response.body;
+            return body;
+        }
+        catch (e) {
+            throw new Error(`unable to get native stx balance from node: ${e.message}`);
+        }
+    }
+    /**
+     * Get nonce data specific to an account from a public node
+     * @param {String} address - stacks address
+     * @returns {Promise<StxNonceResponse>}
+     */
+    async getAccountNonceFromNode({ address }) {
+        const endpoint = `${this.getPublicNodeUrl()}/extended/v1/address/${address}/nonces`;
+        try {
+            const response = await this.bitgo.get(endpoint);
+            if (response.statusCode !== 200) {
+                throw new Error(`request failed with status ${response.statusCode}`);
+            }
+            const body = response.body;
+            return body;
+        }
+        catch (e) {
+            throw new Error(`unable to get account nonce from node: ${e.message}`);
+        }
+    }
+    /**
+     * Get stacks transaction estimated fee
+     * @param {String} txHex - hex of stacks transaction payload
+     * @param {Number} txHexLength - length of built serialized transaction
+     * @returns {Promise<Number>} - fee estimate (taking the lowest)
+     */
+    async getTransactionFeeEstimation({ txHex, txHexLength, }) {
+        const endpoint = `${this.getPublicNodeUrl()}/v2/fees/transaction`;
+        const requestBody = {
+            transaction_payload: txHex,
+            estimated_len: txHexLength,
+        };
+        try {
+            const response = await this.bitgo.post(endpoint).send(requestBody);
+            if (response.statusCode !== 200) {
+                throw new Error(`request failed with status ${response.statusCode}`);
+            }
+            const body = response.body;
+            if (body.estimations.length !== 3) {
+                throw new Error('Invalid response estimation length');
+            }
+            return body.estimations[0].fee;
+        }
+        catch (e) {
+            throw new Error(`unable to get transaction fee estimation: ${e.message}`);
+        }
+    }
+    /**
+     * Format for offline vault signing
+     * @param {BaseTransaction} tx - base transaction
+     * @returns {Promise<RecoveryInfo>}
+     */
+    async formatForOfflineVault(tx) {
+        const txJson = tx.toJson();
+        const transactionExplanation = (await this.explainTransaction({
+            txHex: tx.toBroadcastFormat(),
+            feeInfo: { fee: txJson.fee },
+        }));
+        transactionExplanation.coin = this.getChain();
+        transactionExplanation.feeInfo = { fee: txJson.fee };
+        transactionExplanation.txHex = tx.toBroadcastFormat();
+        return transactionExplanation;
+    }
+    /**
+     * Get the recoverable amount & fee after subtracting the txn fee
+     * @param {String} serializedHex - serialized txn hex
+     * @param {Number} txHexLength - deserialized txn length
+     * @param {String} balance - total account balance
+     * @param {String} tokenBalance - total token balance
+     * @returns {Promise<Record<string, string>>}
+     */
+    async getRecoverableAmountAndFee(serializedHex, txHexLength, balance, tokenBalance) {
+        const estimatedFee = await this.getTransactionFeeEstimation({
+            txHex: serializedHex,
+            txHexLength: txHexLength,
+        });
+        const balanceBN = new bignumber_js_1.default(balance);
+        const feeBN = new bignumber_js_1.default(estimatedFee);
+        if (balanceBN.isLessThan(feeBN)) {
+            throw new Error('insufficient balance to build the transaction');
+        }
+        return {
+            recoverableAmount: tokenBalance ?? balanceBN.minus(feeBN).toString(),
+            fee: feeBN.toString(),
+        };
+    }
+    /**
+     * Method to find the right builder for token or native coin transfer
+     * @param {String} contractAddress - token contract address
+     * @param {String} contractName - token contract name
+     * @returns {TransferBuilder|FungibleTokenTransferBuilder}
+     */
+    getTokenOrNativeTransferBuilder(contractAddress, contractName) {
+        const isToken = !!contractAddress && !!contractName;
+        let factory;
+        if (isToken) {
+            const tokenName = (0, utils_1.findTokenNameByContract)(contractAddress, contractName);
+            if (!tokenName) {
+                throw new Error('invalid contract address or contract name, not supported');
+            }
+            factory = new lib_1.TransactionBuilderFactory(statics_1.coins.get(tokenName));
+        }
+        else {
+            factory = new lib_1.TransactionBuilderFactory(statics_1.coins.get(this.getChain()));
+        }
+        let builder;
+        if (isToken) {
+            builder = factory.getFungibleTokenTransferBuilder();
+        }
+        else {
+            builder = factory.getTransferBuilder();
+        }
+        return builder;
+    }
+    /**
+     * Method to build fungible token transfer transaction
+     * @param {FungibleTokenTransferBuilder} builder - fungible token transfer builder
+     * @param {String} contractAddress - token contract address
+     * @param {String} contractName - token contract name
+     * @param {String[]} pubs - account public keys
+     * @param {Number} nonce - account nonce
+     * @param {AddressDetails} rootAddressDetails - root address details
+     * @param {AddressDetails} destinationAddressDetails - receive address details
+     * @param {String} stxBalance - native stx balance
+     * @returns {Promise<BaseTransaction>} - built transaction
+     */
+    async buildTokenTransferTransaction({ builder, contractAddress, contractName, pubs, nonce, rootAddressDetails, destinationAddressDetails, stxBalance, }) {
+        const txBuilder = builder;
+        const contractTokenName = (0, utils_1.findContractTokenNameUsingContract)(contractAddress, contractName);
+        if (!contractTokenName) {
+            throw new Error('invalid contract address or contract name, not supported');
+        }
+        const assetId = `${contractAddress}.${contractName}::${contractTokenName}`;
+        // fetch the token balance
+        const tokenBalanceData = await this.getSingleFungibleTokenBalanceFromNode({
+            address: rootAddressDetails.address,
+            assetId,
+        });
+        const tokenBalance = tokenBalanceData?.balance;
+        if (!Number(tokenBalance) || isNaN(Number(tokenBalance))) {
+            throw new Error(`no token balance found to recover for address: ${rootAddressDetails.address}, token: ${assetId}`);
+        }
+        txBuilder.fee({ fee: '200' });
+        txBuilder.numberSignatures(2);
+        txBuilder.fromPubKey(pubs);
+        txBuilder.nonce(nonce);
+        txBuilder.contractAddress(contractAddress);
+        txBuilder.contractName(contractName);
+        if (contractTokenName) {
+            txBuilder.tokenName(contractTokenName);
+        }
+        txBuilder.functionName('transfer');
+        const functionArgs = [
+            (0, transactions_1.uintCV)(tokenBalance),
+            (0, transactions_1.standardPrincipalCV)(rootAddressDetails.address),
+            (0, transactions_1.standardPrincipalCV)(destinationAddressDetails.address),
+        ];
+        if (destinationAddressDetails.memoId) {
+            functionArgs.push((0, transactions_1.someCV)((0, transactions_1.bufferCVFromString)(destinationAddressDetails.memoId)));
+        }
+        else {
+            functionArgs.push((0, transactions_1.noneCV)());
+        }
+        txBuilder.functionArgs(functionArgs);
+        const baseTxn = await txBuilder.build();
+        const txBroadcastFormat = baseTxn.toBroadcastFormat();
+        const txDeserialized = (0, transactions_1.deserializeTransaction)(txBroadcastFormat);
+        const serializedHex = (0, payload_1.serializePayload)(txDeserialized.payload).toString('hex');
+        const { recoverableAmount, fee } = await this.getRecoverableAmountAndFee(serializedHex, txBroadcastFormat.length, stxBalance, tokenBalance);
+        functionArgs[0] = (0, transactions_1.uintCV)(recoverableAmount);
+        txBuilder.functionArgs(functionArgs);
+        txBuilder.fee({ fee: fee });
+        return await txBuilder.build();
+    }
+    /**
+     * Method to build native transfer transaction
+     * @param {TransferBuilder} builder - transfer builder
+     * @param {String[]} pubs - account public keys
+     * @param {Number} nonce - account nonce
+     * @param {AddressDetails} destinationAddressDetails - receive address details
+     * @param {String} stxBalance - native stx balance
+     * @returns {Promise<BaseTransaction>} - built transaction
+     */
+    async buildNativeTransferTransaction({ builder, pubs, nonce, destinationAddressDetails, stxBalance, }) {
+        const txBuilder = builder;
+        txBuilder.fee({ fee: '200' });
+        txBuilder.numberSignatures(2);
+        txBuilder.fromPubKey(pubs);
+        txBuilder.nonce(nonce);
+        txBuilder.to(destinationAddressDetails.address);
+        txBuilder.amount(stxBalance);
+        if (destinationAddressDetails.memoId) {
+            txBuilder.memo(destinationAddressDetails.memoId);
+        }
+        const baseTxn = await txBuilder.build();
+        const txBroadcastFormat = baseTxn.toBroadcastFormat();
+        const txDeserialized = (0, transactions_1.deserializeTransaction)(txBroadcastFormat);
+        const serializedHex = (0, payload_1.serializePayload)(txDeserialized.payload).toString('hex');
+        const { recoverableAmount, fee } = await this.getRecoverableAmountAndFee(serializedHex, txBroadcastFormat.length, stxBalance);
+        txBuilder.amount(recoverableAmount);
+        txBuilder.fee({ fee: fee });
+        return await txBuilder.build();
+    }
+    /**
+     * Method that uses appropriate builder and builds transaction depending on token or native coin
+     * @param {String[]} pubs - public keys
+     * @param {AddressDetails} rootAddressDetails - sender address detail
+     * @param {AddressDetails} destinationAddressDetails - receiver address detail
+     * @param {Number} nonce - wallet nonce
+     * @param {String} balance - wallet balance
+     * @param {String | undefined} contractAddress - token contract address
+     * @param {String | undefined} contractName - token contract name
+     * @returns {Promise<BaseTransaction>} built transaction
+     */
+    async getNativeOrTokenTransaction({ pubs, rootAddressDetails, destinationAddressDetails, nonce, stxBalance, contractAddressInput, contractName, }) {
+        const builder = this.getTokenOrNativeTransferBuilder(contractAddressInput, contractName);
+        const contractAddress = contractAddressInput?.toUpperCase();
+        const isToken = !!contractAddress && !!contractName;
+        let finalTx;
+        if (isToken) {
+            finalTx = await this.buildTokenTransferTransaction({
+                builder: builder,
+                contractAddress,
+                contractName,
+                pubs,
+                nonce,
+                rootAddressDetails,
+                destinationAddressDetails,
+                stxBalance,
+            });
+        }
+        else {
+            finalTx = await this.buildNativeTransferTransaction({
+                builder: builder,
+                pubs,
+                nonce,
+                destinationAddressDetails,
+                stxBalance,
+            });
+        }
+        return {
+            tx: finalTx,
+            builder: builder,
+        };
+    }
+    /**
+     * Method to recover native stx or sip10 tokens from bitgo hot & cold wallets
+     * @param {String} params.backupKey - encrypted wallet backup key (public or private)
+     * @param {String} params.userKey - encrypted wallet user key (public or private)
+     * @param {String} params.rootAddress - wallet root address
+     * @param {String} params.recoveryDestination - receive address
+     * @param {String} params.bitgoKey - encrypted bitgo public key
+     * @param {String} params.walletPassphrase - wallet password
+     * @param {String} params.contractId - contract id of the token (mandatory for token recovery)
+     * @returns {Promise<RecoveryInfo|RecoveryTransaction>} RecoveryTransaction.txHex - hex of serialized transaction (signed or unsigned)
+     */
+    async recover(params) {
+        if (!this.isValidAddress(params.rootAddress)) {
+            throw new Error('invalid root address!');
+        }
+        if (!this.isValidAddress(params.recoveryDestination)) {
+            throw new Error('invalid destination address!');
+        }
+        let contractAddress;
+        let contractName;
+        if (params.contractId) {
+            [contractAddress, contractName] = params.contractId.split('.');
+            if ((contractAddress && !contractName) || (contractName && !contractAddress)) {
+                throw new Error('invalid contract id, please provide it in the form (contractAddress.contractName)');
+            }
+        }
+        const isUnsignedSweep = (0, sdk_core_1.getIsUnsignedSweep)(params);
+        const keys = (0, sdk_core_1.getBip32Keys)(this.bitgo, params, { requireBitGoXpub: true });
+        const rootAddressDetails = (0, utils_1.getAddressDetails)(params.rootAddress);
+        const [accountBalanceData, accountNonceData] = await Promise.all([
+            this.getNativeStxBalanceFromNode({ address: rootAddressDetails.address }),
+            this.getAccountNonceFromNode({ address: rootAddressDetails.address }),
+        ]);
+        const balance = Number(accountBalanceData.balance);
+        if (!balance || isNaN(balance)) {
+            throw new Error('could not find any balance to recover for ' + params.rootAddress);
+        }
+        const userPub = (0, transactions_1.publicKeyFromBuffer)(keys[0].publicKey);
+        const backupPub = (0, transactions_1.publicKeyFromBuffer)(keys[1].publicKey);
+        const bitgoPubKey = (0, transactions_1.publicKeyFromBuffer)(keys[2].publicKey);
+        const pubs = [(0, transactions_1.publicKeyToString)(userPub), (0, transactions_1.publicKeyToString)(backupPub), (0, transactions_1.publicKeyToString)(bitgoPubKey)];
+        const destinationAddressDetails = (0, utils_1.getAddressDetails)(params.recoveryDestination);
+        const nonce = typeof accountNonceData?.last_executed_tx_nonce === 'number' ? accountNonceData.last_executed_tx_nonce + 1 : 0;
+        const { tx, builder } = await this.getNativeOrTokenTransaction({
+            pubs,
+            rootAddressDetails,
+            destinationAddressDetails,
+            nonce,
+            stxBalance: accountBalanceData.balance,
+            contractAddressInput: contractAddress,
+            contractName: contractName,
+        });
+        if (isUnsignedSweep) {
+            return await this.formatForOfflineVault(tx);
+        }
+        // check the private key & sign
+        if (!keys[0].privateKey) {
+            throw new Error(`userKey is not a private key`);
+        }
+        const userKey = (0, transactions_1.createStacksPrivateKey)(keys[0].privateKey);
+        builder.sign({ key: (0, transactions_1.privateKeyToString)(userKey) });
+        const halfSignedTx = await builder.build();
+        const txHexHalfSigned = halfSignedTx.toBroadcastFormat();
+        const builder2 = this.getTokenOrNativeTransferBuilder(contractAddress, contractName);
+        builder2.from(txHexHalfSigned);
+        if (!keys[1].privateKey) {
+            throw new Error(`backupKey is not a private key`);
+        }
+        const backupKey = (0, transactions_1.createStacksPrivateKey)(keys[1].privateKey);
+        builder2.sign({ key: (0, transactions_1.privateKeyToString)(backupKey) });
+        const fullySignedTx = await builder2.build();
+        const fullySignedTxHex = fullySignedTx.toBroadcastFormat();
+        return {
+            txHex: fullySignedTxHex,
+        };
+    }
 }
 exports.Stx = Stx;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stx.js","sourceRoot":"","sources":["../../src/stx.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  BaseCoin,\n  BitGoBase,\n  KeyPair,\n  MultisigType,\n  multisigTypes,\n  SignedTransaction,\n  TransactionRecipient,\n  TransactionType,\n  VerifyAddressOptions,\n  VerifyTransactionOptions,\n} from '@bitgo/sdk-core';\nimport { BaseCoin as StaticsBaseCoin, CoinFamily, coins } from '@bitgo/statics';\nimport { ClarityType, cvToString, cvToValue } from '@stacks/transactions';\n\nimport { ExplainTransactionOptions, StxSignTransactionOptions, StxTransactionExplanation } from './types';\nimport { StxLib } from '.';\nimport { TransactionBuilderFactory } from './lib';\nimport { TransactionBuilder } from './lib/transactionBuilder';\nimport { findTokenNameByContract } from './lib/utils';\n\nexport class Stx 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 Stx(bitgo, staticsCoin);\n  }\n\n  getChain(): string {\n    return this._staticsCoin.name;\n  }\n\n  getFamily(): CoinFamily {\n    return this._staticsCoin.family;\n  }\n\n  getFullName(): string {\n    return this._staticsCoin.fullName;\n  }\n\n  getBaseFactor(): string | number {\n    return Math.pow(10, this._staticsCoin.decimalPlaces);\n  }\n\n  getTransaction(coinConfig: Readonly<StaticsBaseCoin>): TransactionBuilder {\n    return new TransactionBuilderFactory(coinConfig).getTransferBuilder();\n  }\n\n  /** {@inheritDoc } **/\n  supportsMultisig(): boolean {\n    return true;\n  }\n\n  /** inherited doc */\n  getDefaultMultisigType(): MultisigType {\n    return multisigTypes.onchain;\n  }\n\n  async verifyTransaction(params: VerifyTransactionOptions): Promise<boolean> {\n    const { txParams } = params;\n    if (Array.isArray(txParams.recipients) && txParams.recipients.length > 1) {\n      throw new Error(\n        `${this.getChain()} doesn't support sending to more than 1 destination address within a single transaction. Try again, using only a single recipient.`\n      );\n    }\n    return true;\n  }\n\n  /**\n   * Check if address is valid, then make sure it matches the base address.\n   *\n   * @param {VerifyAddressOptions} params\n   * @param {String} params.address - the address to verify\n   * @param {String} params.baseAddress - the base address from the wallet\n   */\n  async isWalletAddress(params: VerifyAddressOptions): Promise<boolean> {\n    const { address, keychains } = params;\n    if (!keychains || keychains.length !== 3) {\n      throw new Error('Invalid keychains');\n    }\n    const pubs = keychains.map((keychain) => StxLib.Utils.xpubToSTXPubkey(keychain.pub));\n    const addressVersion = StxLib.Utils.getAddressVersion(address);\n    const baseAddress = StxLib.Utils.getSTXAddressFromPubKeys(pubs, addressVersion).address;\n    return StxLib.Utils.isSameBaseAddress(address, baseAddress);\n  }\n\n  /**\n   * Generate Stacks 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 StxLib.KeyPair({ seed }) : new StxLib.KeyPair();\n    const keys = keyPair.getExtendedKeys();\n\n    if (!keys.xprv) {\n      throw new Error('Missing xprv in key generation.');\n    }\n\n    return {\n      pub: keys.xpub,\n      prv: keys.xprv,\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      return StxLib.Utils.isValidPublicKey(pub);\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      return StxLib.Utils.isValidPrivateKey(prv);\n    } catch (e) {\n      return false;\n    }\n  }\n\n  isValidAddress(address: string): boolean {\n    try {\n      return StxLib.Utils.isValidAddressWithPaymentId(address);\n    } catch (e) {\n      return false;\n    }\n  }\n\n  /**\n   * Signs stacks transaction\n   * @param params\n   */\n  async signTransaction(params: StxSignTransactionOptions): Promise<SignedTransaction> {\n    const factory = new StxLib.TransactionBuilderFactory(coins.get(this.getChain()));\n    const txBuilder = factory.from(params.txPrebuild.txHex);\n    const prvKeys = params.prv instanceof Array ? params.prv : [params.prv];\n    prvKeys.forEach((prv) => txBuilder.sign({ key: prv }));\n    if (params.pubKeys) txBuilder.fromPubKey(params.pubKeys);\n    // if (params.numberSignature) txBuilder.numberSignatures(params.numberSignature);\n    const transaction = await txBuilder.build();\n\n    if (!transaction) {\n      throw new Error('Invalid message passed to signMessage');\n    }\n\n    const txHex = {\n      txHex: transaction.toBroadcastFormat(),\n    };\n\n    return transaction.signature.length >= 2 ? txHex : { halfSigned: txHex };\n  }\n\n  async parseTransaction(params: any): Promise<any> {\n    return {};\n  }\n\n  /**\n   * Explain a Stacks transaction from txHex\n   * @param params\n   */\n  async explainTransaction(params: ExplainTransactionOptions): Promise<StxTransactionExplanation | undefined> {\n    const txHex = params.txHex || (params.halfSigned && params.halfSigned.txHex);\n    if (!txHex || !params.feeInfo) {\n      throw new Error('missing explain tx parameters');\n    }\n\n    const factory = new StxLib.TransactionBuilderFactory(coins.get(this.getChain()));\n    const txBuilder = factory.from(txHex);\n\n    if (params.publicKeys !== undefined) {\n      txBuilder.fromPubKey(params.publicKeys);\n      if (params.publicKeys.length === 1) {\n        // definitely a single sig tx\n        txBuilder.numberSignatures(1);\n      }\n    }\n\n    const tx = await txBuilder.build();\n    const txJson = tx.toJson();\n\n    if (tx.type === TransactionType.Send) {\n      // check if it is a token transaction or native coin transaction\n      let transactionRecipient: TransactionRecipient;\n      let outputAmount: string;\n      let memo: string | undefined;\n      if (txJson.payload.contractAddress && txJson.payload.functionArgs.length >= 3) {\n        outputAmount = cvToValue(txJson.payload.functionArgs[0]).toString();\n        transactionRecipient = {\n          address: cvToString(txJson.payload.functionArgs[2]),\n          amount: outputAmount,\n          tokenName: findTokenNameByContract(txJson.payload.contractAddress, txJson.payload.contractName),\n        };\n        if (\n          txJson.payload.functionArgs.length === 4 &&\n          txJson.payload.functionArgs[3].type === ClarityType.OptionalSome\n        ) {\n          memo = Buffer.from(txJson.payload.functionArgs[3].value.buffer).toString();\n          transactionRecipient['memo'] = memo;\n        }\n      } else {\n        outputAmount = txJson.payload.amount;\n        memo = txJson.payload.memo;\n        transactionRecipient = {\n          address: txJson.payload.to,\n          amount: outputAmount,\n          memo: memo,\n        };\n      }\n      const outputs: TransactionRecipient[] = [transactionRecipient];\n\n      const displayOrder = ['id', 'outputAmount', 'changeAmount', 'outputs', 'changeOutputs', 'fee', 'memo', 'type'];\n      return {\n        displayOrder,\n        id: txJson.id,\n        outputAmount: outputAmount.toString(),\n        changeAmount: '0',\n        outputs,\n        changeOutputs: [],\n        fee: txJson.fee,\n        memo: memo,\n        type: tx.type,\n      };\n    }\n\n    if (tx.type === TransactionType.ContractCall) {\n      const displayOrder = [\n        'id',\n        'fee',\n        'type',\n        'contractAddress',\n        'contractName',\n        'contractFunction',\n        'contractFunctionArgs',\n      ];\n      return {\n        displayOrder,\n        id: txJson.id,\n        changeAmount: '0',\n        outputAmount: '',\n        outputs: [],\n        changeOutputs: [],\n        fee: txJson.fee,\n        type: tx.type,\n        contractAddress: txJson.payload.contractAddress,\n        contractName: txJson.payload.contractName,\n        contractFunction: txJson.payload.functionName,\n        contractFunctionArgs: txJson.payload.functionArgs,\n      };\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stx.js","sourceRoot":"","sources":["../../src/stx.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  BaseCoin,\n  BaseTransaction,\n  BitGoBase,\n  Environments,\n  getBip32Keys,\n  getIsUnsignedSweep,\n  KeyPair,\n  MultisigType,\n  multisigTypes,\n  SignedTransaction,\n  TransactionRecipient,\n  TransactionType,\n  VerifyAddressOptions,\n  VerifyTransactionOptions,\n} from '@bitgo/sdk-core';\nimport { BaseCoin as StaticsBaseCoin, CoinFamily, coins } from '@bitgo/statics';\nimport {\n  bufferCVFromString,\n  ClarityType,\n  ClarityValue,\n  createStacksPrivateKey,\n  cvToString,\n  cvToValue,\n  deserializeTransaction,\n  noneCV,\n  privateKeyToString,\n  publicKeyFromBuffer,\n  publicKeyToString,\n  someCV,\n  standardPrincipalCV,\n  uintCV,\n} from '@stacks/transactions';\nimport { serializePayload } from '@stacks/transactions/dist/payload';\nimport BigNumber from 'bignumber.js';\n\nimport { ExplainTransactionOptions, StxSignTransactionOptions, StxTransactionExplanation } from './types';\nimport { StxLib } from '.';\nimport { TransactionBuilderFactory } from './lib';\nimport { TransactionBuilder } from './lib/transactionBuilder';\nimport { findContractTokenNameUsingContract, findTokenNameByContract, getAddressDetails } from './lib/utils';\nimport {\n  AddressDetails,\n  NativeStxBalance,\n  RecoveryInfo,\n  RecoveryOptions,\n  RecoveryTransaction,\n  SingleFungibleTokenBalance,\n  StxNonceResponse,\n  StxTxnFeeEstimationResponse,\n  TxData,\n} from './lib/iface';\nimport { TransferBuilder } from './lib/transferBuilder';\nimport { FungibleTokenTransferBuilder } from './lib/fungibleTokenTransferBuilder';\n\nexport class Stx 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 Stx(bitgo, staticsCoin);\n  }\n\n  getChain(): string {\n    return this._staticsCoin.name;\n  }\n\n  getFamily(): CoinFamily {\n    return this._staticsCoin.family;\n  }\n\n  getFullName(): string {\n    return this._staticsCoin.fullName;\n  }\n\n  getBaseFactor(): string | number {\n    return Math.pow(10, this._staticsCoin.decimalPlaces);\n  }\n\n  getTransaction(coinConfig: Readonly<StaticsBaseCoin>): TransactionBuilder {\n    return new TransactionBuilderFactory(coinConfig).getTransferBuilder();\n  }\n\n  /** inherited doc */\n  getDefaultMultisigType(): MultisigType {\n    return multisigTypes.onchain;\n  }\n\n  async verifyTransaction(params: VerifyTransactionOptions): Promise<boolean> {\n    const { txParams } = params;\n    if (Array.isArray(txParams.recipients) && txParams.recipients.length > 1) {\n      throw new Error(\n        `${this.getChain()} doesn't support sending to more than 1 destination address within a single transaction. Try again, using only a single recipient.`\n      );\n    }\n    return true;\n  }\n\n  /**\n   * Check if address is valid, then make sure it matches the base address.\n   *\n   * @param {VerifyAddressOptions} params\n   * @param {String} params.address - the address to verify\n   * @param {String} params.baseAddress - the base address from the wallet\n   */\n  async isWalletAddress(params: VerifyAddressOptions): Promise<boolean> {\n    const { address, keychains } = params;\n    if (!keychains || keychains.length !== 3) {\n      throw new Error('Invalid keychains');\n    }\n    const pubs = keychains.map((keychain) => StxLib.Utils.xpubToSTXPubkey(keychain.pub));\n    const addressVersion = StxLib.Utils.getAddressVersion(address);\n    const baseAddress = StxLib.Utils.getSTXAddressFromPubKeys(pubs, addressVersion).address;\n    return StxLib.Utils.isSameBaseAddress(address, baseAddress);\n  }\n\n  /**\n   * Generate Stacks 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 StxLib.KeyPair({ seed }) : new StxLib.KeyPair();\n    const keys = keyPair.getExtendedKeys();\n\n    if (!keys.xprv) {\n      throw new Error('Missing xprv in key generation.');\n    }\n\n    return {\n      pub: keys.xpub,\n      prv: keys.xprv,\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      return StxLib.Utils.isValidPublicKey(pub);\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      return StxLib.Utils.isValidPrivateKey(prv);\n    } catch (e) {\n      return false;\n    }\n  }\n\n  isValidAddress(address: string): boolean {\n    try {\n      return StxLib.Utils.isValidAddressWithPaymentId(address);\n    } catch (e) {\n      return false;\n    }\n  }\n\n  /**\n   * Signs stacks transaction\n   * @param params\n   */\n  async signTransaction(params: StxSignTransactionOptions): Promise<SignedTransaction> {\n    const factory = new StxLib.TransactionBuilderFactory(coins.get(this.getChain()));\n    const txBuilder = factory.from(params.txPrebuild.txHex);\n    const prvKeys = params.prv instanceof Array ? params.prv : [params.prv];\n    prvKeys.forEach((prv) => txBuilder.sign({ key: prv }));\n    if (params.pubKeys) txBuilder.fromPubKey(params.pubKeys);\n    // if (params.numberSignature) txBuilder.numberSignatures(params.numberSignature);\n    const transaction = await txBuilder.build();\n\n    if (!transaction) {\n      throw new Error('Invalid message passed to signMessage');\n    }\n\n    const txHex = {\n      txHex: transaction.toBroadcastFormat(),\n    };\n\n    return transaction.signature.length >= 2 ? txHex : { halfSigned: txHex };\n  }\n\n  async parseTransaction(params: any): Promise<any> {\n    return {};\n  }\n\n  /**\n   * Explain a Stacks transaction from txHex\n   * @param params\n   */\n  async explainTransaction(params: ExplainTransactionOptions): Promise<StxTransactionExplanation | undefined> {\n    const txHex = params.txHex || (params.halfSigned && params.halfSigned.txHex);\n    if (!txHex || !params.feeInfo) {\n      throw new Error('missing explain tx parameters');\n    }\n\n    const factory = new StxLib.TransactionBuilderFactory(coins.get(this.getChain()));\n    const txBuilder = factory.from(txHex);\n\n    if (params.publicKeys !== undefined) {\n      txBuilder.fromPubKey(params.publicKeys);\n      if (params.publicKeys.length === 1) {\n        // definitely a single sig tx\n        txBuilder.numberSignatures(1);\n      }\n    }\n\n    const tx = await txBuilder.build();\n    const txJson = tx.toJson();\n\n    if (tx.type === TransactionType.Send) {\n      // check if it is a token transaction or native coin transaction\n      let transactionRecipient: TransactionRecipient;\n      let outputAmount: string;\n      let memo: string | undefined;\n      if (txJson.payload.contractAddress && txJson.payload.functionArgs.length >= 3) {\n        outputAmount = cvToValue(txJson.payload.functionArgs[0]).toString();\n        transactionRecipient = {\n          address: cvToString(txJson.payload.functionArgs[2]),\n          amount: outputAmount,\n          tokenName: findTokenNameByContract(txJson.payload.contractAddress, txJson.payload.contractName),\n        };\n        if (\n          txJson.payload.functionArgs.length === 4 &&\n          txJson.payload.functionArgs[3].type === ClarityType.OptionalSome\n        ) {\n          memo = Buffer.from(txJson.payload.functionArgs[3].value.buffer).toString();\n          transactionRecipient['memo'] = memo;\n        }\n      } else {\n        outputAmount = txJson.payload.amount;\n        memo = txJson.payload.memo;\n        transactionRecipient = {\n          address: txJson.payload.to,\n          amount: outputAmount,\n          memo: memo,\n        };\n      }\n      const outputs: TransactionRecipient[] = [transactionRecipient];\n\n      const displayOrder = ['id', 'outputAmount', 'changeAmount', 'outputs', 'changeOutputs', 'fee', 'memo', 'type'];\n      return {\n        displayOrder,\n        id: txJson.id,\n        outputAmount: outputAmount.toString(),\n        changeAmount: '0',\n        outputs,\n        changeOutputs: [],\n        fee: txJson.fee,\n        memo: memo,\n        type: tx.type,\n      };\n    }\n\n    if (tx.type === TransactionType.ContractCall) {\n      const displayOrder = [\n        'id',\n        'fee',\n        'type',\n        'contractAddress',\n        'contractName',\n        'contractFunction',\n        'contractFunctionArgs',\n      ];\n      return {\n        displayOrder,\n        id: txJson.id,\n        changeAmount: '0',\n        outputAmount: '',\n        outputs: [],\n        changeOutputs: [],\n        fee: txJson.fee,\n        type: tx.type,\n        contractAddress: txJson.payload.contractAddress,\n        contractName: txJson.payload.contractName,\n        contractFunction: txJson.payload.functionName,\n        contractFunctionArgs: txJson.payload.functionArgs,\n      };\n    }\n  }\n\n  /**\n   * Get URLs of some active public nodes\n   * @returns {String} node url\n   */\n  getPublicNodeUrl(): string {\n    return Environments[this.bitgo.getEnv()].stxNodeUrl;\n  }\n\n  /**\n   * Get native stacks balance for an account\n   * @param {String} address - stacks address\n   * @returns {Promise<NativeStxBalance>}\n   */\n  protected async getNativeStxBalanceFromNode({ address }: { address: string }): Promise<NativeStxBalance> {\n    const endpoint = `${this.getPublicNodeUrl()}/extended/v2/addresses/${address}/balances/stx`;\n    try {\n      const response = await this.bitgo.get(endpoint);\n      if (response.statusCode !== 200) {\n        throw new Error(`request failed with status ${response.statusCode}`);\n      }\n      const body: NativeStxBalance = response.body;\n      return body;\n    } catch (e) {\n      throw new Error(`unable to get native stx balance from node: ${e.message}`);\n    }\n  }\n\n  /**\n   * Get single fungible token balance for an account\n   * @param {String} address - stacks address\n   * @param {String} assetId - fungible token asset id\n   * @returns {Promise<SingleFungibleTokenBalance>}\n   */\n  protected async getSingleFungibleTokenBalanceFromNode({\n    address,\n    assetId,\n  }: {\n    address: string;\n    assetId: string;\n  }): Promise<SingleFungibleTokenBalance> {\n    const endpoint = `${this.getPublicNodeUrl()}/extended/v2/addresses/${address}/balances/ft/${assetId}`;\n    try {\n      const response = await this.bitgo.get(endpoint);\n      if (response.statusCode !== 200) {\n        throw new Error(`request failed with status ${response.statusCode}`);\n      }\n      const body: SingleFungibleTokenBalance = response.body;\n      return body;\n    } catch (e) {\n      throw new Error(`unable to get native stx balance from node: ${e.message}`);\n    }\n  }\n\n  /**\n   * Get nonce data specific to an account from a public node\n   * @param {String} address - stacks address\n   * @returns {Promise<StxNonceResponse>}\n   */\n  protected async getAccountNonceFromNode({ address }: { address: string }): Promise<StxNonceResponse> {\n    const endpoint = `${this.getPublicNodeUrl()}/extended/v1/address/${address}/nonces`;\n    try {\n      const response = await this.bitgo.get(endpoint);\n      if (response.statusCode !== 200) {\n        throw new Error(`request failed with status ${response.statusCode}`);\n      }\n      const body: StxNonceResponse = response.body;\n      return body;\n    } catch (e) {\n      throw new Error(`unable to get account nonce from node: ${e.message}`);\n    }\n  }\n\n  /**\n   * Get stacks transaction estimated fee\n   * @param {String} txHex - hex of stacks transaction payload\n   * @param {Number} txHexLength - length of built serialized transaction\n   * @returns {Promise<Number>} - fee estimate (taking the lowest)\n   */\n  protected async getTransactionFeeEstimation({\n    txHex,\n    txHexLength,\n  }: {\n    txHex: string;\n    txHexLength: number;\n  }): Promise<number> {\n    const endpoint = `${this.getPublicNodeUrl()}/v2/fees/transaction`;\n    const requestBody = {\n      transaction_payload: txHex,\n      estimated_len: txHexLength,\n    };\n    try {\n      const response = await this.bitgo.post(endpoint).send(requestBody);\n      if (response.statusCode !== 200) {\n        throw new Error(`request failed with status ${response.statusCode}`);\n      }\n      const body: StxTxnFeeEstimationResponse = response.body;\n      if (body.estimations.length !== 3) {\n        throw new Error('Invalid response estimation length');\n      }\n      return body.estimations[0].fee;\n    } catch (e) {\n      throw new Error(`unable to get transaction fee estimation: ${e.message}`);\n    }\n  }\n\n  /**\n   * Format for offline vault signing\n   * @param {BaseTransaction} tx - base transaction\n   * @returns {Promise<RecoveryInfo>}\n   */\n  protected async formatForOfflineVault(tx: BaseTransaction): Promise<RecoveryInfo> {\n    const txJson: TxData = tx.toJson();\n    const transactionExplanation: RecoveryInfo = (await this.explainTransaction({\n      txHex: tx.toBroadcastFormat(),\n      feeInfo: { fee: txJson.fee },\n    })) as RecoveryInfo;\n    transactionExplanation.coin = this.getChain();\n    transactionExplanation.feeInfo = { fee: txJson.fee };\n    transactionExplanation.txHex = tx.toBroadcastFormat();\n    return transactionExplanation;\n  }\n\n  /**\n   * Get the recoverable amount & fee after subtracting the txn fee\n   * @param {String} serializedHex - serialized txn hex\n   * @param {Number} txHexLength - deserialized txn length\n   * @param {String} balance - total account balance\n   * @param {String} tokenBalance - total token balance\n   * @returns {Promise<Record<string, string>>}\n   */\n  protected async getRecoverableAmountAndFee(\n    serializedHex: string,\n    txHexLength: number,\n    balance: string,\n    tokenBalance?: string\n  ): Promise<Record<string, string>> {\n    const estimatedFee = await this.getTransactionFeeEstimation({\n      txHex: serializedHex,\n      txHexLength: txHexLength,\n    });\n    const balanceBN = new BigNumber(balance);\n    const feeBN = new BigNumber(estimatedFee);\n    if (balanceBN.isLessThan(feeBN)) {\n      throw new Error('insufficient balance to build the transaction');\n    }\n    return {\n      recoverableAmount: tokenBalance ?? balanceBN.minus(feeBN).toString(),\n      fee: feeBN.toString(),\n    };\n  }\n\n  /**\n   * Method to find the right builder for token or native coin transfer\n   * @param {String} contractAddress - token contract address\n   * @param {String} contractName - token contract name\n   * @returns {TransferBuilder|FungibleTokenTransferBuilder}\n   */\n  protected getTokenOrNativeTransferBuilder(\n    contractAddress?: string,\n    contractName?: string\n  ): TransferBuilder | FungibleTokenTransferBuilder {\n    const isToken = !!contractAddress && !!contractName;\n    let factory: TransactionBuilderFactory;\n    if (isToken) {\n      const tokenName = findTokenNameByContract(contractAddress, contractName);\n      if (!tokenName) {\n        throw new Error('invalid contract address or contract name, not supported');\n      }\n      factory = new TransactionBuilderFactory(coins.get(tokenName));\n    } else {\n      factory = new TransactionBuilderFactory(coins.get(this.getChain()));\n    }\n    let builder: TransferBuilder | FungibleTokenTransferBuilder;\n    if (isToken) {\n      builder = factory.getFungibleTokenTransferBuilder();\n    } else {\n      builder = factory.getTransferBuilder();\n    }\n    return builder;\n  }\n\n  /**\n   * Method to build fungible token transfer transaction\n   * @param {FungibleTokenTransferBuilder} builder - fungible token transfer builder\n   * @param {String} contractAddress - token contract address\n   * @param {String} contractName - token contract name\n   * @param {String[]} pubs - account public keys\n   * @param {Number} nonce - account nonce\n   * @param {AddressDetails} rootAddressDetails - root address details\n   * @param {AddressDetails} destinationAddressDetails - receive address details\n   * @param {String} stxBalance - native stx balance\n   * @returns {Promise<BaseTransaction>} - built transaction\n   */\n  protected async buildTokenTransferTransaction({\n    builder,\n    contractAddress,\n    contractName,\n    pubs,\n    nonce,\n    rootAddressDetails,\n    destinationAddressDetails,\n    stxBalance,\n  }: {\n    builder: FungibleTokenTransferBuilder;\n    contractAddress: string;\n    contractName: string;\n    pubs: string[];\n    nonce: number;\n    rootAddressDetails: AddressDetails;\n    destinationAddressDetails: AddressDetails;\n    stxBalance: string;\n  }): Promise<BaseTransaction> {\n    const txBuilder = builder as FungibleTokenTransferBuilder;\n    const contractTokenName = findContractTokenNameUsingContract(contractAddress, contractName);\n    if (!contractTokenName) {\n      throw new Error('invalid contract address or contract name, not supported');\n    }\n    const assetId = `${contractAddress}.${contractName}::${contractTokenName}`;\n    // fetch the token balance\n    const tokenBalanceData = await this.getSingleFungibleTokenBalanceFromNode({\n      address: rootAddressDetails.address,\n      assetId,\n    });\n    const tokenBalance = tokenBalanceData?.balance;\n    if (!Number(tokenBalance) || isNaN(Number(tokenBalance))) {\n      throw new Error(\n        `no token balance found to recover for address: ${rootAddressDetails.address}, token: ${assetId}`\n      );\n    }\n    txBuilder.fee({ fee: '200' });\n    txBuilder.numberSignatures(2);\n    txBuilder.fromPubKey(pubs);\n    txBuilder.nonce(nonce);\n    txBuilder.contractAddress(contractAddress);\n    txBuilder.contractName(contractName);\n    if (contractTokenName) {\n      txBuilder.tokenName(contractTokenName);\n    }\n    txBuilder.functionName('transfer');\n    const functionArgs: ClarityValue[] = [\n      uintCV(tokenBalance),\n      standardPrincipalCV(rootAddressDetails.address),\n      standardPrincipalCV(destinationAddressDetails.address),\n    ];\n    if (destinationAddressDetails.memoId) {\n      functionArgs.push(someCV(bufferCVFromString(destinationAddressDetails.memoId)));\n    } else {\n      functionArgs.push(noneCV());\n    }\n    txBuilder.functionArgs(functionArgs);\n    const baseTxn = await txBuilder.build();\n    const txBroadcastFormat = baseTxn.toBroadcastFormat();\n    const txDeserialized = deserializeTransaction(txBroadcastFormat);\n    const serializedHex = serializePayload(txDeserialized.payload).toString('hex');\n    const { recoverableAmount, fee } = await this.getRecoverableAmountAndFee(\n      serializedHex,\n      txBroadcastFormat.length,\n      stxBalance,\n      tokenBalance\n    );\n    functionArgs[0] = uintCV(recoverableAmount);\n    txBuilder.functionArgs(functionArgs);\n    txBuilder.fee({ fee: fee });\n    return await txBuilder.build();\n  }\n\n  /**\n   * Method to build native transfer transaction\n   * @param {TransferBuilder} builder - transfer builder\n   * @param {String[]} pubs - account public keys\n   * @param {Number} nonce - account nonce\n   * @param {AddressDetails} destinationAddressDetails - receive address details\n   * @param {String} stxBalance - native stx balance\n   * @returns {Promise<BaseTransaction>} - built transaction\n   */\n  protected async buildNativeTransferTransaction({\n    builder,\n    pubs,\n    nonce,\n    destinationAddressDetails,\n    stxBalance,\n  }: {\n    builder: TransferBuilder;\n    pubs: string[];\n    nonce: number;\n    destinationAddressDetails: AddressDetails;\n    stxBalance: string;\n  }): Promise<BaseTransaction> {\n    const txBuilder = builder as TransferBuilder;\n    txBuilder.fee({ fee: '200' });\n    txBuilder.numberSignatures(2);\n    txBuilder.fromPubKey(pubs);\n    txBuilder.nonce(nonce);\n    txBuilder.to(destinationAddressDetails.address);\n    txBuilder.amount(stxBalance);\n    if (destinationAddressDetails.memoId) {\n      txBuilder.memo(destinationAddressDetails.memoId);\n    }\n    const baseTxn = await txBuilder.build();\n    const txBroadcastFormat = baseTxn.toBroadcastFormat();\n    const txDeserialized = deserializeTransaction(txBroadcastFormat);\n    const serializedHex = serializePayload(txDeserialized.payload).toString('hex');\n    const { recoverableAmount, fee } = await this.getRecoverableAmountAndFee(\n      serializedHex,\n      txBroadcastFormat.length,\n      stxBalance\n    );\n    txBuilder.amount(recoverableAmount);\n    txBuilder.fee({ fee: fee });\n    return await txBuilder.build();\n  }\n\n  /**\n   * Method that uses appropriate builder and builds transaction depending on token or native coin\n   * @param {String[]} pubs - public keys\n   * @param {AddressDetails} rootAddressDetails - sender address detail\n   * @param {AddressDetails} destinationAddressDetails - receiver address detail\n   * @param {Number} nonce - wallet nonce\n   * @param {String} balance - wallet balance\n   * @param {String | undefined} contractAddress - token contract address\n   * @param {String | undefined} contractName - token contract name\n   * @returns {Promise<BaseTransaction>} built transaction\n   */\n  protected async getNativeOrTokenTransaction({\n    pubs,\n    rootAddressDetails,\n    destinationAddressDetails,\n    nonce,\n    stxBalance,\n    contractAddressInput,\n    contractName,\n  }: {\n    pubs: string[];\n    rootAddressDetails: AddressDetails;\n    destinationAddressDetails: AddressDetails;\n    nonce: number;\n    stxBalance: string;\n    contractAddressInput?: string;\n    contractName?: string;\n  }): Promise<{ tx: BaseTransaction; builder: TransferBuilder | FungibleTokenTransferBuilder }> {\n    const builder = this.getTokenOrNativeTransferBuilder(contractAddressInput, contractName);\n    const contractAddress = contractAddressInput?.toUpperCase();\n    const isToken = !!contractAddress && !!contractName;\n    let finalTx: BaseTransaction;\n    if (isToken) {\n      finalTx = await this.buildTokenTransferTransaction({\n        builder: builder as FungibleTokenTransferBuilder,\n        contractAddress,\n        contractName,\n        pubs,\n        nonce,\n        rootAddressDetails,\n        destinationAddressDetails,\n        stxBalance,\n      });\n    } else {\n      finalTx = await this.buildNativeTransferTransaction({\n        builder: builder as TransferBuilder,\n        pubs,\n        nonce,\n        destinationAddressDetails,\n        stxBalance,\n      });\n    }\n    return {\n      tx: finalTx,\n      builder: builder,\n    };\n  }\n\n  /**\n   * Method to recover native stx or sip10 tokens from bitgo hot & cold wallets\n   * @param {String} params.backupKey - encrypted wallet backup key (public or private)\n   * @param {String} params.userKey - encrypted wallet user key (public or private)\n   * @param {String} params.rootAddress - wallet root address\n   * @param {String} params.recoveryDestination - receive address\n   * @param {String} params.bitgoKey - encrypted bitgo public key\n   * @param {String} params.walletPassphrase - wallet password\n   * @param {String} params.contractId - contract id of the token (mandatory for token recovery)\n   * @returns {Promise<RecoveryInfo|RecoveryTransaction>} RecoveryTransaction.txHex - hex of serialized transaction (signed or unsigned)\n   */\n  async recover(params: RecoveryOptions): Promise<RecoveryInfo | RecoveryTransaction> {\n    if (!this.isValidAddress(params.rootAddress)) {\n      throw new Error('invalid root address!');\n    }\n    if (!this.isValidAddress(params.recoveryDestination)) {\n      throw new Error('invalid destination address!');\n    }\n    let contractAddress: string | undefined;\n    let contractName: string | undefined;\n    if (params.contractId) {\n      [contractAddress, contractName] = params.contractId.split('.');\n      if ((contractAddress && !contractName) || (contractName && !contractAddress)) {\n        throw new Error('invalid contract id, please provide it in the form (contractAddress.contractName)');\n      }\n    }\n    const isUnsignedSweep = getIsUnsignedSweep(params);\n    const keys = getBip32Keys(this.bitgo, params, { requireBitGoXpub: true });\n    const rootAddressDetails = getAddressDetails(params.rootAddress);\n    const [accountBalanceData, accountNonceData] = await Promise.all([\n      this.getNativeStxBalanceFromNode({ address: rootAddressDetails.address }),\n      this.getAccountNonceFromNode({ address: rootAddressDetails.address }),\n    ]);\n    const balance = Number(accountBalanceData.balance);\n    if (!balance || isNaN(balance)) {\n      throw new Error('could not find any balance to recover for ' + params.rootAddress);\n    }\n    const userPub = publicKeyFromBuffer(keys[0].publicKey);\n    const backupPub = publicKeyFromBuffer(keys[1].publicKey);\n    const bitgoPubKey = publicKeyFromBuffer(keys[2].publicKey);\n    const pubs = [publicKeyToString(userPub), publicKeyToString(backupPub), publicKeyToString(bitgoPubKey)];\n\n    const destinationAddressDetails = getAddressDetails(params.recoveryDestination);\n    const nonce =\n      typeof accountNonceData?.last_executed_tx_nonce === 'number' ? accountNonceData.last_executed_tx_nonce + 1 : 0;\n\n    const { tx, builder } = await this.getNativeOrTokenTransaction({\n      pubs,\n      rootAddressDetails,\n      destinationAddressDetails,\n      nonce,\n      stxBalance: accountBalanceData.balance,\n      contractAddressInput: contractAddress,\n      contractName: contractName,\n    });\n\n    if (isUnsignedSweep) {\n      return await this.formatForOfflineVault(tx);\n    }\n    // check the private key & sign\n    if (!keys[0].privateKey) {\n      throw new Error(`userKey is not a private key`);\n    }\n    const userKey = createStacksPrivateKey(keys[0].privateKey);\n    builder.sign({ key: privateKeyToString(userKey) });\n\n    const halfSignedTx = await builder.build();\n    const txHexHalfSigned = halfSignedTx.toBroadcastFormat();\n    const builder2 = this.getTokenOrNativeTransferBuilder(contractAddress, contractName);\n    builder2.from(txHexHalfSigned);\n\n    if (!keys[1].privateKey) {\n      throw new Error(`backupKey is not a private key`);\n    }\n    const backupKey = createStacksPrivateKey(keys[1].privateKey);\n    builder2.sign({ key: privateKeyToString(backupKey) });\n\n    const fullySignedTx = await builder2.build();\n    const fullySignedTxHex = fullySignedTx.toBroadcastFormat();\n\n    return {\n      txHex: fullySignedTxHex,\n    };\n  }\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bitgo/sdk-coin-stx",
-  "version": "3.5.7",
+  "version": "3.6.1",
   "description": "BitGo SDK coin library for Stacks",
   "main": "./dist/src/index.js",
   "types": "./dist/src/index.d.ts",
@@ -40,9 +40,9 @@
     ]
   },
   "dependencies": {
-    "@bitgo/sdk-core": "^33.1.0",
+    "@bitgo/sdk-core": "^34.0.0",
     "@bitgo/secp256k1": "^1.3.3",
-    "@bitgo/statics": "^52.1.0",
+    "@bitgo/statics": "^53.0.0",
     "@noble/curves": "1.8.1",
     "@stacks/network": "^4.3.0",
     "@stacks/transactions": "2.0.1",
@@ -52,8 +52,8 @@
     "lodash": "^4.17.15"
   },
   "devDependencies": {
-    "@bitgo/sdk-api": "^1.62.2",
-    "@bitgo/sdk-test": "^8.0.83"
+    "@bitgo/sdk-api": "^1.63.0",
+    "@bitgo/sdk-test": "^8.0.85"
   },
-  "gitHead": "30541f6f2de3e670e990b924ed501cc75b3e7e0a"
+  "gitHead": "f53286120d0683a7ced2399a48c032e5f810bbb5"
 }