@meshsdk/bitcoin 1.9.0-beta.81 → 1.9.0-beta.83

package/dist/index.cjs

@@ -3700,7 +3700,7 @@ var parseHttpError = function(error) {
             status: error.response.status
         });
     }
-    if (error.request && !_instanceof(error.request, XMLHttpRequest)) {
+    if (error.request) {
         return JSON.stringify(error.request);
     }
     return JSON.stringify({
@@ -4012,6 +4012,57 @@ var BlockstreamProvider = /*#__PURE__*/ function() {
                 }).call(this);
             }
         },
+        {
+            key: "fetchFeeEstimates",
+            value: /**
+   * Get fee estimates for confirmation within a specified number of blocks.
+   * Returns fee rate in sat/vB based on Blockstream's fee estimates API.
+   * @param blocks - Confirmation target in blocks (1-25, 144, 504, 1008)
+   * @returns Fee rate in sat/vB
+   */ function fetchFeeEstimates(blocks) {
+                return _async_to_generator(function() {
+                    var _ref, data, status, feeEstimates, availableTargets, closestTarget, error;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _state.trys.push([
+                                    0,
+                                    2,
+                                    ,
+                                    3
+                                ]);
+                                return [
+                                    4,
+                                    this._axiosInstance.get("/fee-estimates")
+                                ];
+                            case 1:
+                                _ref = _state.sent(), data = _ref.data, status = _ref.status;
+                                if (status === 200) {
+                                    feeEstimates = data;
+                                    availableTargets = Object.keys(feeEstimates).map(Number).sort(function(a, b) {
+                                        return a - b;
+                                    });
+                                    closestTarget = availableTargets.find(function(target) {
+                                        return target >= blocks;
+                                    }) || availableTargets[availableTargets.length - 1];
+                                    return [
+                                        2,
+                                        feeEstimates[closestTarget.toString()] || 10
+                                    ];
+                                }
+                                throw parseHttpError(data);
+                            case 2:
+                                error = _state.sent();
+                                throw parseHttpError(error);
+                            case 3:
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
         {
             key: "submitTx",
             value: /**
@@ -4063,16 +4114,29 @@ var BlockstreamProvider = /*#__PURE__*/ function() {
 }();
 // src/providers/maestro.ts
 var MaestroProvider = /*#__PURE__*/ function() {
-    function MaestroProvider(param) {
-        var network = param.network, apiKey = param.apiKey;
+    function MaestroProvider() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
         _class_call_check(this, MaestroProvider);
-        this._axiosInstance = axios_default.create({
-            baseURL: "https://xbt-".concat(network, ".gomaestro-api.org/v0"),
-            headers: {
-                "api-key": apiKey
-            }
-        });
-        this._network = network;
+        if (typeof args[0] === "string" && (args[0].startsWith("http") || args[0].startsWith("/"))) {
+            this._axiosInstance = axios_default.create({
+                baseURL: args[0],
+                headers: {
+                    "api-key": args[1]
+                }
+            });
+            this._network = args[0].includes("testnet") ? "testnet" : "mainnet";
+        } else {
+            var _args_ = args[0], network = _args_.network, apiKey = _args_.apiKey;
+            this._axiosInstance = axios_default.create({
+                baseURL: "https://xbt-".concat(network, ".gomaestro-api.org/v0"),
+                headers: {
+                    "api-key": apiKey
+                }
+            });
+            this._network = network;
+        }
     }
     _create_class(MaestroProvider, [
         {
@@ -4335,8 +4399,7 @@ var MaestroProvider = /*#__PURE__*/ function() {
         },
         {
             key: "fetchFeeEstimates",
-            value: // Additional Bitcoin-specific methods (beyond IBitcoinProvider)
-            /**
+            value: /**
    * Get fee estimates for Bitcoin transactions.
    * @param blocks - The number of blocks to estimate fees for (default: 6).
    * @returns FeeEstimateResponse containing the estimated fee rate.
@@ -4361,7 +4424,7 @@ var MaestroProvider = /*#__PURE__*/ function() {
                                 _ref = _state.sent(), data = _ref.data, status = _ref.status;
                                 if (status === 200) return [
                                     2,
-                                    data
+                                    data.data.feerate
                                 ];
                                 throw parseHttpError(data);
                             case 2:
@@ -4378,7 +4441,8 @@ var MaestroProvider = /*#__PURE__*/ function() {
         },
         {
             key: "fetchSatoshiActivity",
-            value: /**
+            value: // Additional Bitcoin-specific methods (beyond IBitcoinProvider)
+            /**
    * Fetch satoshi activity for a Bitcoin address (transaction history).
    * @param address - The Bitcoin address.
    * @param options - Optional parameters for filtering and pagination.
@@ -4982,7 +5046,18 @@ var import_bip39 = require("bip39");
 var EmbeddedWallet = /*#__PURE__*/ function() {
     function EmbeddedWallet(options) {
         _class_call_check(this, EmbeddedWallet);
-        this._network = options.testnet ? bitcoin.networks.testnet : bitcoin.networks.bitcoin;
+        switch(options.network){
+            case "Testnet":
+                this._network = bitcoin.networks.testnet;
+                break;
+            case "Regtest":
+                this._network = bitcoin.networks.regtest;
+                break;
+            case "Mainnet":
+            default:
+                this._network = bitcoin.networks.bitcoin;
+                break;
+        }
         if (options.key.type === "mnemonic") {
             var _options_path;
             this._wallet = _derive(options.key.words, (_options_path = options.path) !== null && _options_path !== void 0 ? _options_path : "m/84'/0'/0'/0/0", this._network);
@@ -4995,24 +5070,56 @@ var EmbeddedWallet = /*#__PURE__*/ function() {
     }
     _create_class(EmbeddedWallet, [
         {
-            /**
-   * Returns the wallet's SegWit (P2WPKH) address and associated public key.
+            key: "getAddresses",
+            value: /**
+   * Returns the wallet's Bitcoin addresses following Xverse API format.
    *
-   * @returns {Address} The wallet address object including address, public key, and metadata.
-   * @throws {Error} If internal address or public key is not properly initialized.
-   */ key: "getAddress",
-            value: function getAddress() {
-                if (this._isReadOnly && this._address) {
-                    return {
-                        address: this._address,
-                        purpose: "payment",
-                        addressType: "p2wpkh"
-                    };
-                }
-                if (!this._wallet) {
-                    throw new Error("Wallet not initialized properly.");
-                }
-                return resolveAddress(this._wallet.publicKey, this._network);
+   * @param purposes Array of address purposes to request:
+   *   - `'ordinals'` for managing ordinals (should return P2TR taproot address)
+   *   - `'payment'` for managing bitcoin (returns P2WPKH address)
+   *   TODO: Should follow Xverse docs to return taproot address for ordinals purpose
+   * @param message Optional message to display in request prompt (ignored for embedded wallets)
+   * @returns {Promise<GetAddressResult[]>} Array of address objects with address, publicKey, purpose, addressType, network, and walletType
+   * @throws {Error} If wallet is not properly initialized.
+   */ function getAddresses(purposes, message) {
+                return _async_to_generator(function() {
+                    var addressInfo;
+                    return _ts_generator(this, function(_state) {
+                        if (this._isReadOnly && this._address) {
+                            return [
+                                2,
+                                [
+                                    {
+                                        address: this._address,
+                                        publicKey: "",
+                                        // Not available for read-only wallets
+                                        purpose: "payment",
+                                        addressType: "p2wpkh",
+                                        network: this._getNetworkString(),
+                                        walletType: "software"
+                                    }
+                                ]
+                            ];
+                        }
+                        if (!this._wallet) {
+                            throw new Error("Wallet not initialized properly.");
+                        }
+                        addressInfo = resolveAddress(this._wallet.publicKey, this._network);
+                        return [
+                            2,
+                            [
+                                {
+                                    address: addressInfo.address,
+                                    publicKey: addressInfo.publicKey || this._wallet.publicKey.toString("hex"),
+                                    purpose: "payment",
+                                    addressType: addressInfo.addressType,
+                                    network: this._getNetworkString(),
+                                    walletType: "software"
+                                }
+                            ]
+                        ];
+                    });
+                }).call(this);
             }
         },
         {
@@ -5035,13 +5142,26 @@ var EmbeddedWallet = /*#__PURE__*/ function() {
         {
             /**
    * Returns the network identifier of the wallet.
-   * 0': Indicates the Bitcoin mainnet.
-   * 1': Indicates the Bitcoin testnet.
+   * 0: Indicates the Bitcoin testnet.
+   * 1: Indicates the Bitcoin mainnet.
+   * 2: Indicates the Bitcoin regtest.
    *
-   * @returns {0 | 1} The Bitcoin network ID.
+   * @returns {0 | 1 | 2} The Bitcoin network ID.
    */ key: "getNetworkId",
             value: function getNetworkId() {
-                return this._network === bitcoin.networks.testnet ? 1 : 0;
+                if (this._network === bitcoin.networks.testnet) return 0;
+                if (this._network === bitcoin.networks.regtest) return 2;
+                return 1;
+            }
+        },
+        {
+            /**
+   * Returns the network type as a string for API responses.
+   */ key: "_getNetworkString",
+            value: function _getNetworkString() {
+                if (this._network === bitcoin.networks.testnet) return "testnet";
+                if (this._network === bitcoin.networks.regtest) return "regtest";
+                return "mainnet";
             }
         },
         {
@@ -5055,15 +5175,20 @@ var EmbeddedWallet = /*#__PURE__*/ function() {
                     return _ts_generator(this, function(_state) {
                         switch(_state.label){
                             case 0:
-                                address = this.getAddress();
+                                return [
+                                    4,
+                                    this.getAddresses()
+                                ];
+                            case 1:
+                                address = _state.sent();
                                 if (this._provider === void 0) {
                                     throw new Error("`provider` is not defined. Provide a BitcoinProvider.");
                                 }
                                 return [
                                     4,
-                                    this._provider.fetchAddressUTxOs(address.address)
+                                    this._provider.fetchAddressUTxOs(address[0].address)
                                 ];
-                            case 1:
+                            case 2:
                                 return [
                                     2,
                                     _state.sent()
@@ -5074,17 +5199,21 @@ var EmbeddedWallet = /*#__PURE__*/ function() {
             }
         },
         {
-            key: "signData",
+            key: "signMessage",
             value: /**
-   * Signs a given message using the wallet's private key.
+   * Signs a message following Xverse API format.
    *
-   * @param message - The message to be signed.
-   * @returns The signature of the message as a string.
+   * @param params - Object containing address, message, and optional protocol
+   * @returns Promise resolving to signature result
    * @throws {Error} If the wallet is read-only or private key is not available.
-   */ function signData(message) {
+   */ function signMessage(params) {
                 return _async_to_generator(function() {
-                    var keyPair, messageBuffer, bufferToHash, hash, signature;
+                    var address, message, _params_protocol, protocol, keyPair, messageBuffer, bufferToHash, hash, signature;
                     return _ts_generator(this, function(_state) {
+                        address = params.address, message = params.message, _params_protocol = params.protocol, protocol = _params_protocol === void 0 ? "ECDSA" : _params_protocol;
+                        if (protocol === "BIP322") {
+                            throw new Error("BIP322 protocol is not yet supported. Only ECDSA is currently available.");
+                        }
                         if (this._isReadOnly) {
                             throw new Error("Cannot sign data with a read-only wallet.");
                         }
@@ -5103,52 +5232,233 @@ var EmbeddedWallet = /*#__PURE__*/ function() {
                         signature = keyPair.sign(hash);
                         return [
                             2,
-                            signature.toString("base64")
+                            {
+                                signature: signature.toString("base64"),
+                                messageHash: hash.toString("hex"),
+                                address: address
+                            }
                         ];
                     });
                 }).call(this);
             }
         },
         {
-            key: "signTx",
+            key: "signPsbt",
             value: /**
-   * Sign a transaction payload.
-   * @param payload - The transaction payload to sign.
-   * @returns The signed transaction in hex format.
+   * Sign a PSBT following Xverse API format.
+   * @param params - Object containing PSBT and signing instructions
+   * @returns Promise resolving to signed PSBT result
    * @throws {Error} If the wallet is read-only or private key is not available.
-   */ function signTx(payload) {
+   */ function signPsbt(params) {
                 return _async_to_generator(function() {
-                    var psbt, p2wpkh, ecPair, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, input, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, output, i;
+                    var _this, psbtBase64, signInputs, _params_broadcast, broadcast, psbt, ecPair, allInputIndexes, signedPsbt, txHex, txid;
                     return _ts_generator(this, function(_state) {
-                        if (this._isReadOnly) {
-                            throw new Error("Cannot sign transactions with a read-only wallet.");
+                        switch(_state.label){
+                            case 0:
+                                _this = this;
+                                psbtBase64 = params.psbt, signInputs = params.signInputs, _params_broadcast = params.broadcast, broadcast = _params_broadcast === void 0 ? false : _params_broadcast;
+                                if (this._isReadOnly) {
+                                    throw new Error("Cannot sign transactions with a read-only wallet.");
+                                }
+                                if (!this._wallet || !this._wallet.privateKey) {
+                                    throw new Error("Private key is not available for signing.");
+                                }
+                                psbt = bitcoin.Psbt.fromBase64(psbtBase64, {
+                                    network: this._network
+                                });
+                                ecPair = ECPair.fromPrivateKey(this._wallet.privateKey, {
+                                    network: this._network
+                                });
+                                allInputIndexes = Object.values(signInputs).flat();
+                                allInputIndexes.forEach(function(inputIndex) {
+                                    psbt.signInput(inputIndex, _this._wallet);
+                                    psbt.validateSignaturesOfInput(inputIndex, function(pubkey, hash, signature) {
+                                        return ecPair.publicKey.equals(pubkey) && ecPair.verify(hash, signature);
+                                    });
+                                });
+                                signedPsbt = psbt.toBase64();
+                                if (!broadcast) return [
+                                    3,
+                                    2
+                                ];
+                                if (!this._provider) {
+                                    throw new Error("`provider` is not defined. Provide a BitcoinProvider for broadcasting.");
+                                }
+                                psbt.finalizeAllInputs();
+                                txHex = psbt.extractTransaction().toHex();
+                                return [
+                                    4,
+                                    this._provider.submitTx(txHex)
+                                ];
+                            case 1:
+                                txid = _state.sent();
+                                return [
+                                    2,
+                                    {
+                                        psbt: signedPsbt,
+                                        txid: txid
+                                    }
+                                ];
+                            case 2:
+                                return [
+                                    2,
+                                    {
+                                        psbt: signedPsbt
+                                    }
+                                ];
                         }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "sendTransfer",
+            value: /**
+   * Send Bitcoin to recipients following Xverse API format.
+   * @param params - Object containing recipients array
+   * @returns Promise resolving to transaction result
+   * @throws {Error} If the wallet is read-only or provider is not available.
+   */ function sendTransfer(params) {
+                return _async_to_generator(function() {
+                    var recipients, _ref, addresses, utxos, walletAddress, psbt, inputCount, signInputs, signResult;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                if (this._isReadOnly) {
+                                    throw new Error("Cannot send transactions with a read-only wallet.");
+                                }
+                                if (!this._provider) {
+                                    throw new Error("`provider` is not defined. Provide a BitcoinProvider for sending.");
+                                }
+                                if (!this._wallet) {
+                                    throw new Error("Wallet not initialized properly.");
+                                }
+                                recipients = params.recipients;
+                                return [
+                                    4,
+                                    Promise.all([
+                                        this.getAddresses(),
+                                        this.getUTxOs()
+                                    ])
+                                ];
+                            case 1:
+                                _ref = _sliced_to_array.apply(void 0, [
+                                    _state.sent(),
+                                    2
+                                ]), addresses = _ref[0], utxos = _ref[1];
+                                walletAddress = addresses[0].address;
+                                return [
+                                    4,
+                                    this._buildTransferPsbt(utxos, recipients, walletAddress)
+                                ];
+                            case 2:
+                                psbt = _state.sent();
+                                inputCount = psbt.inputCount;
+                                signInputs = _define_property({}, walletAddress, Array.from({
+                                    length: inputCount
+                                }, function(_, i) {
+                                    return i;
+                                }));
+                                return [
+                                    4,
+                                    this.signPsbt({
+                                        psbt: psbt.toBase64(),
+                                        signInputs: signInputs,
+                                        broadcast: true
+                                    })
+                                ];
+                            case 3:
+                                signResult = _state.sent();
+                                return [
+                                    2,
+                                    {
+                                        txid: signResult.txid
+                                    }
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "getBalance",
+            value: /**
+   * Get wallet balance following Xverse API format.
+   * @returns Promise resolving to balance information
+   * @throws {Error} If provider is not available.
+   */ function getBalance() {
+                return _async_to_generator(function() {
+                    var addresses, address, addressInfo, confirmed, unconfirmed, total;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                if (!this._provider) {
+                                    throw new Error("`provider` is not defined. Provide a BitcoinProvider for balance.");
+                                }
+                                return [
+                                    4,
+                                    this.getAddresses()
+                                ];
+                            case 1:
+                                addresses = _state.sent();
+                                address = addresses[0].address;
+                                return [
+                                    4,
+                                    this._provider.fetchAddress(address)
+                                ];
+                            case 2:
+                                addressInfo = _state.sent();
+                                confirmed = addressInfo.chain_stats.funded_txo_sum - addressInfo.chain_stats.spent_txo_sum;
+                                unconfirmed = addressInfo.mempool_stats.funded_txo_sum - addressInfo.mempool_stats.spent_txo_sum;
+                                total = confirmed + unconfirmed;
+                                return [
+                                    2,
+                                    {
+                                        confirmed: confirmed.toString(),
+                                        unconfirmed: unconfirmed.toString(),
+                                        total: total.toString()
+                                    }
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "signMultipleTransactions",
+            value: /**
+   * Sign multiple transactions (Xverse custom method).
+   * @param params - Object containing network, message, and PSBTs array
+   * @returns Promise resolving to signed PSBTs
+   * @throws {Error} If the wallet is read-only or private key is not available.
+   */ function signMultipleTransactions(params) {
+                return _async_to_generator(function() {
+                    var _this, psbts, results, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _this1, _loop, _iterator, _step;
+                    return _ts_generator(this, function(_state) {
+                        _this = this;
                         if (!this._wallet || !this._wallet.privateKey) {
                             throw new Error("Private key is not available for signing.");
                         }
-                        psbt = new bitcoin.Psbt({
-                            network: this._network
-                        });
-                        p2wpkh = bitcoin.payments.p2wpkh({
-                            pubkey: this._wallet.publicKey,
-                            network: this._network
-                        });
-                        ecPair = ECPair.fromPrivateKey(this._wallet.privateKey, {
-                            network: this._network
-                        });
+                        psbts = params.psbts;
+                        results = [];
                         _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
                         try {
-                            for(_iterator = payload.inputs[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                                input = _step.value;
-                                psbt.addInput({
-                                    hash: input.txid,
-                                    index: input.vout,
-                                    witnessUtxo: {
-                                        script: p2wpkh.output,
-                                        value: input.value
-                                    }
+                            _loop = function() {
+                                var psbtInfo = _step.value;
+                                var psbt = bitcoin.Psbt.fromBase64(psbtInfo.psbtBase64, {
+                                    network: _this1._network
                                 });
-                            }
+                                var inputIndexes = psbtInfo.inputsToSign.flatMap(function(input) {
+                                    return input.signingIndexes;
+                                });
+                                inputIndexes.forEach(function(index) {
+                                    return psbt.signInput(index, _this._wallet);
+                                });
+                                results.push({
+                                    psbt: psbt.toBase64()
+                                });
+                            };
+                            for(_iterator = psbts[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_this1 = this, _loop();
                         } catch (err) {
                             _didIteratorError = true;
                             _iteratorError = err;
@@ -5163,43 +5473,150 @@ var EmbeddedWallet = /*#__PURE__*/ function() {
                                 }
                             }
                         }
-                        _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
-                        try {
-                            for(_iterator1 = payload.outputs[Symbol.iterator](); !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
-                                output = _step1.value;
-                                psbt.addOutput({
-                                    address: output.address,
-                                    value: output.value
-                                });
-                            }
-                        } catch (err) {
-                            _didIteratorError1 = true;
-                            _iteratorError1 = err;
-                        } finally{
-                            try {
-                                if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
-                                    _iterator1.return();
-                                }
-                            } finally{
-                                if (_didIteratorError1) {
-                                    throw _iteratorError1;
-                                }
-                            }
-                        }
-                        for(i = 0; i < payload.inputs.length; i++){
-                            psbt.signInput(i, this._wallet);
-                            psbt.validateSignaturesOfInput(i, function(pubkey, hash, signature) {
-                                return ecPair.publicKey.equals(pubkey) && ecPair.verify(hash, signature);
-                            });
-                        }
-                        psbt.finalizeAllInputs();
                         return [
                             2,
-                            psbt.extractTransaction().toHex()
+                            results
                         ];
                     });
                 }).call(this);
             }
+        },
+        {
+            /**
+   * Simple largest-first coin selection algorithm.
+   * Selects UTXOs in descending order by value until target amount + fees is reached.
+   * 
+   * @param utxos Available UTXOs
+   * @param targetAmount Amount needed in satoshis
+   * @param feeRate Fee rate in sat/vByte
+   * @returns Selected UTXOs and change amount
+   */ key: "_selectUtxosLargestFirst",
+            value: function _selectUtxosLargestFirst(utxos, targetAmount, feeRate) {
+                var sortedUtxos = _to_consumable_array(utxos).sort(function(a, b) {
+                    return b.value - a.value;
+                });
+                var selectedValue = 0;
+                var selectedUtxos = [];
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = sortedUtxos[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var utxo = _step.value;
+                        selectedUtxos.push(utxo);
+                        selectedValue += utxo.value;
+                        var estimatedTxSize = selectedUtxos.length * 150 + 2 * 34 + 10;
+                        var fee = Math.ceil(estimatedTxSize * feeRate);
+                        if (selectedValue >= targetAmount + fee) {
+                            var finalFee = Math.ceil((selectedUtxos.length * 150 + 2 * 34 + 10) * feeRate);
+                            var change = selectedValue - targetAmount - finalFee;
+                            return {
+                                selectedUtxos: selectedUtxos,
+                                change: change
+                            };
+                        }
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+                throw new Error("Insufficient funds for transaction.");
+            }
+        },
+        {
+            key: "_buildTransferPsbt",
+            value: /**
+   * Build PSBT for transfer using optimal coin selection.
+   * @param utxos Available UTXOs
+   * @param recipients Transfer recipients
+   * @param walletAddress Wallet address for change
+   * @returns Built PSBT ready for signing
+   */ function _buildTransferPsbt(utxos, recipients, walletAddress) {
+                return _async_to_generator(function() {
+                    var feeRate, error, targetAmount, _this__selectUtxosLargestFirst, selectedUtxos, change, psbt, p2wpkh;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                feeRate = 10;
+                                if (!this._provider) return [
+                                    3,
+                                    4
+                                ];
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    3,
+                                    ,
+                                    4
+                                ]);
+                                return [
+                                    4,
+                                    this._provider.fetchFeeEstimates(6)
+                                ];
+                            case 2:
+                                feeRate = _state.sent();
+                                return [
+                                    3,
+                                    4
+                                ];
+                            case 3:
+                                error = _state.sent();
+                                console.warn("Fee estimation failed, using default rate:", error);
+                                return [
+                                    3,
+                                    4
+                                ];
+                            case 4:
+                                targetAmount = recipients.reduce(function(sum, r) {
+                                    return sum + r.amount;
+                                }, 0);
+                                _this__selectUtxosLargestFirst = this._selectUtxosLargestFirst(utxos, targetAmount, feeRate), selectedUtxos = _this__selectUtxosLargestFirst.selectedUtxos, change = _this__selectUtxosLargestFirst.change;
+                                psbt = new bitcoin.Psbt({
+                                    network: this._network
+                                });
+                                p2wpkh = bitcoin.payments.p2wpkh({
+                                    pubkey: this._wallet.publicKey,
+                                    network: this._network
+                                });
+                                selectedUtxos.forEach(function(utxo) {
+                                    psbt.addInput({
+                                        hash: utxo.txid,
+                                        index: utxo.vout,
+                                        witnessUtxo: {
+                                            script: p2wpkh.output,
+                                            value: utxo.value
+                                        }
+                                    });
+                                });
+                                recipients.forEach(function(recipient) {
+                                    psbt.addOutput({
+                                        address: recipient.address,
+                                        value: recipient.amount
+                                    });
+                                });
+                                if (change > 0) {
+                                    psbt.addOutput({
+                                        address: walletAddress,
+                                        value: change
+                                    });
+                                }
+                                return [
+                                    2,
+                                    psbt
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
         }
     ], [
         {