@btc-vision/wallet-sdk 1.0.2 → 1.0.5

package/lib/transaction/transaction.js

@@ -1,29 +1,18 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Transaction = void 0;
-const address_1 = require("../address");
-const bitcoin_core_1 = require("../bitcoin-core");
-const constants_1 = require("../constants");
-const error_1 = require("../error");
-const network_1 = require("../network");
-const types_1 = require("../types");
-const utils_1 = require("../utils");
-const wallet_1 = require("../wallet");
-const utxo_1 = require("./utxo");
+import { payments } from 'bitcoinjs-lib';
+import { addressToScriptPk } from '../address';
+import { bitcoin } from '../bitcoin-core';
+import { UTXO_DUST } from '../constants';
+import { ErrorCodes, WalletUtilsError } from '../error';
+import { NetworkType, toPsbtNetwork } from '../network';
+import { AddressType } from '../types';
+import { toXOnly } from '../utils';
+import { EstimateWallet } from '../wallet';
+import { utxoHelper } from './utxo';
 /**
  * Convert UnspentOutput to PSBT TxInput
  */
 function utxoToInput(utxo, estimate) {
-    if (utxo.addressType === types_1.AddressType.P2TR || utxo.addressType === types_1.AddressType.M44_P2TR) {
+    if (utxo.addressType === AddressType.P2TR || utxo.addressType === AddressType.M44_P2TR) {
         const data = {
             hash: utxo.txid,
             index: utxo.vout,
@@ -31,14 +20,14 @@ function utxoToInput(utxo, estimate) {
                 value: utxo.satoshis,
                 script: Buffer.from(utxo.scriptPk, 'hex')
             },
-            tapInternalKey: (0, utils_1.toXOnly)(Buffer.from(utxo.pubkey, 'hex'))
+            tapInternalKey: toXOnly(Buffer.from(utxo.pubkey, 'hex'))
         };
         return {
             data,
             utxo
         };
     }
-    else if (utxo.addressType === types_1.AddressType.P2WPKH || utxo.addressType === types_1.AddressType.M44_P2WPKH) {
+    else if (utxo.addressType === AddressType.P2WPKH || utxo.addressType === AddressType.M44_P2WPKH) {
         const data = {
             hash: utxo.txid,
             index: utxo.vout,
@@ -52,7 +41,7 @@ function utxoToInput(utxo, estimate) {
             utxo
         };
     }
-    else if (utxo.addressType === types_1.AddressType.P2PKH) {
+    else if (utxo.addressType === AddressType.P2PKH) {
         if (!utxo.rawtx || estimate) {
             const data = {
                 hash: utxo.txid,
@@ -79,8 +68,8 @@ function utxoToInput(utxo, estimate) {
             };
         }
     }
-    else if (utxo.addressType === types_1.AddressType.P2SH_P2WPKH) {
-        const redeemData = bitcoin_core_1.bitcoin.payments.p2wpkh({
+    else if (utxo.addressType === AddressType.P2SH_P2WPKH) {
+        const redeemData = bitcoin.payments.p2wpkh({
             pubkey: Buffer.from(utxo.pubkey, 'hex')
         });
         const data = {
@@ -97,21 +86,36 @@ function utxoToInput(utxo, estimate) {
             utxo
         };
     }
+    else {
+        return {
+            data: {
+                hash: utxo.txid,
+                index: utxo.vout,
+                witnessUtxo: {
+                    value: utxo.satoshis,
+                    script: Buffer.from(utxo.scriptPk, 'hex')
+                }
+            },
+            utxo
+        };
+    }
 }
 /**
  * Transaction
  */
-class Transaction {
-    constructor() {
-        this.outputs = [];
-        this.utxos = [];
-        this.inputs = [];
-        this.changeOutputIndex = -1;
-        this.enableRBF = true;
-        this._cacheNetworkFee = 0;
-        this._cacheBtcUtxos = [];
-        this._cacheToSignInputs = [];
-    }
+export class Transaction {
+    outputs = [];
+    changedAddress = '';
+    utxos = [];
+    inputs = [];
+    changeOutputIndex = -1;
+    networkType = NetworkType.MAINNET;
+    feeRate = 1;
+    enableRBF = true;
+    _cacheNetworkFee = 0;
+    _cacheBtcUtxos = [];
+    _cacheToSignInputs = [];
+    constructor() { }
     setNetworkType(network) {
         this.networkType = network;
     }
@@ -141,13 +145,11 @@ class Transaction {
     getUnspent() {
         return this.getTotalInput() - this.getTotalOutput();
     }
-    calNetworkFee() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const psbt = yield this.createEstimatePsbt();
-            const txSize = psbt.extractTransaction(true).virtualSize();
-            const fee = Math.ceil(txSize * this.feeRate);
-            return fee;
-        });
+    async calNetworkFee() {
+        const psbt = await this.createEstimatePsbt();
+        const txSize = psbt.extractTransaction(true).virtualSize();
+        const fee = Math.ceil(txSize * this.feeRate);
+        return fee;
     }
     addOutput(address, value) {
         this.outputs.push({
@@ -156,7 +158,7 @@ class Transaction {
         });
     }
     addOpreturn(data) {
-        const embed = bitcoin_core_1.bitcoin.payments.embed({ data });
+        const embed = payments.embed({ data });
         this.outputs.push({
             script: embed.output,
             value: 0
@@ -193,10 +195,10 @@ class Transaction {
         this.outputs.splice(-count);
     }
     toPsbt() {
-        const network = (0, network_1.toPsbtNetwork)(this.networkType);
-        const psbt = new bitcoin_core_1.bitcoin.Psbt({ network });
+        const network = toPsbtNetwork(this.networkType);
+        const psbt = new bitcoin.Psbt({ network });
         this.inputs.forEach((v, index) => {
-            if (v.utxo.addressType === types_1.AddressType.P2PKH) {
+            if (v.utxo.addressType === AddressType.P2PKH) {
                 if (v.data.witnessUtxo) {
                     //@ts-ignore
                     psbt.__CACHE.__UNSAFE_SIGN_NONSEGWIT = true;
@@ -234,113 +236,107 @@ class Transaction {
         tx.outputs = this.outputs.map((v) => v);
         return tx;
     }
-    createEstimatePsbt() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const estimateWallet = wallet_1.EstimateWallet.fromRandom(this.inputs[0].utxo.addressType, this.networkType);
-            const scriptPk = (0, address_1.addressToScriptPk)(estimateWallet.address, this.networkType).toString('hex');
-            const tx = this.clone();
-            tx.utxos.forEach((v) => {
-                v.pubkey = estimateWallet.pubkey;
-                v.scriptPk = scriptPk;
-            });
-            tx.inputs = [];
-            tx.utxos.forEach((v) => {
-                const input = utxoToInput(v, true);
-                tx.inputs.push(input);
-            });
-            const psbt = tx.toPsbt();
-            const toSignInputs = tx.inputs.map((v, index) => ({
-                index,
-                publicKey: estimateWallet.pubkey
-            }));
-            yield estimateWallet.signPsbt(psbt, {
-                autoFinalized: true,
-                toSignInputs: toSignInputs
-            });
-            return psbt;
+    async createEstimatePsbt() {
+        const estimateWallet = EstimateWallet.fromRandom(this.inputs[0].utxo.addressType, this.networkType);
+        const scriptPk = addressToScriptPk(estimateWallet.address, this.networkType).toString('hex');
+        const tx = this.clone();
+        tx.utxos.forEach((v) => {
+            v.pubkey = estimateWallet.pubkey;
+            v.scriptPk = scriptPk;
         });
+        tx.inputs = [];
+        tx.utxos.forEach((v) => {
+            const input = utxoToInput(v, true);
+            tx.inputs.push(input);
+        });
+        const psbt = tx.toPsbt();
+        const toSignInputs = tx.inputs.map((v, index) => ({
+            index,
+            publicKey: estimateWallet.pubkey
+        }));
+        await estimateWallet.signPsbt(psbt, {
+            autoFinalized: true,
+            toSignInputs: toSignInputs
+        });
+        return psbt;
     }
-    addSufficientUtxosForFee(btcUtxos, forceAsFee) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (btcUtxos.length > 0) {
-                this._cacheBtcUtxos = btcUtxos;
-                const dummyBtcUtxo = Object.assign({}, btcUtxos[0]);
-                dummyBtcUtxo.satoshis = 2100000000000000;
-                this.addInput(dummyBtcUtxo);
-                this.addChangeOutput(0);
-                const networkFee = yield this.calNetworkFee();
-                const dummyBtcUtxoSize = utxo_1.utxoHelper.getAddedVirtualSize(dummyBtcUtxo.addressType);
-                this._cacheNetworkFee = networkFee - dummyBtcUtxoSize * this.feeRate;
-                this.removeLastInput();
-                this.selectBtcUtxos();
-            }
-            else {
-                if (forceAsFee) {
-                    throw new error_1.WalletUtilsError(error_1.ErrorCodes.INSUFFICIENT_BTC_UTXO);
-                }
-                if (this.getTotalInput() < this.getTotalOutput()) {
-                    throw new error_1.WalletUtilsError(error_1.ErrorCodes.INSUFFICIENT_BTC_UTXO);
-                }
-                this._cacheNetworkFee = yield this.calNetworkFee();
-            }
-            const changeAmount = this.getTotalInput() - this.getTotalOutput() - Math.ceil(this._cacheNetworkFee);
-            if (changeAmount > constants_1.UTXO_DUST) {
-                this.removeChangeOutput();
-                this.addChangeOutput(changeAmount);
+    async addSufficientUtxosForFee(btcUtxos, forceAsFee) {
+        if (btcUtxos.length > 0) {
+            this._cacheBtcUtxos = btcUtxos;
+            const dummyBtcUtxo = Object.assign({}, btcUtxos[0]);
+            dummyBtcUtxo.satoshis = 2100000000000000;
+            this.addInput(dummyBtcUtxo);
+            this.addChangeOutput(0);
+            const networkFee = await this.calNetworkFee();
+            const dummyBtcUtxoSize = utxoHelper.getAddedVirtualSize(dummyBtcUtxo.addressType);
+            this._cacheNetworkFee = networkFee - dummyBtcUtxoSize * this.feeRate;
+            this.removeLastInput();
+            this.selectBtcUtxos();
+        }
+        else {
+            if (forceAsFee) {
+                throw new WalletUtilsError(ErrorCodes.INSUFFICIENT_BTC_UTXO);
             }
-            else {
-                this.removeChangeOutput();
+            if (this.getTotalInput() < this.getTotalOutput()) {
+                throw new WalletUtilsError(ErrorCodes.INSUFFICIENT_BTC_UTXO);
             }
-            return this._cacheToSignInputs;
-        });
+            this._cacheNetworkFee = await this.calNetworkFee();
+        }
+        const changeAmount = this.getTotalInput() - this.getTotalOutput() - Math.ceil(this._cacheNetworkFee);
+        if (changeAmount > UTXO_DUST) {
+            this.removeChangeOutput();
+            this.addChangeOutput(changeAmount);
+        }
+        else {
+            this.removeChangeOutput();
+        }
+        return this._cacheToSignInputs;
     }
-    dumpTx(psbt) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const tx = psbt.extractTransaction();
-            const feeRate = psbt.getFeeRate();
-            console.log(`
-=============================================================================================
-Summary
-  txid:     ${tx.getId()}
-  Size:     ${tx.byteLength()}
-  Fee Paid: ${psbt.getFee()}
-  Fee Rate: ${feeRate} sat/vB
-  Detail:   ${psbt.txInputs.length} Inputs, ${psbt.txOutputs.length} Outputs
-----------------------------------------------------------------------------------------------
-Inputs
+    async dumpTx(psbt) {
+        const tx = psbt.extractTransaction();
+        const feeRate = psbt.getFeeRate();
+        console.log(`
+=============================================================================================
+Summary
+  txid:     ${tx.getId()}
+  Size:     ${tx.byteLength()}
+  Fee Paid: ${psbt.getFee()}
+  Fee Rate: ${feeRate} sat/vB
+  Detail:   ${psbt.txInputs.length} Inputs, ${psbt.txOutputs.length} Outputs
+----------------------------------------------------------------------------------------------
+Inputs
 ${this.inputs
-                .map((input, index) => {
-                const str = `
-=>${index} ${input.data.witnessUtxo.value} Sats
-        lock-size: ${input.data.witnessUtxo.script.length}
-        via ${input.data.hash} [${input.data.index}]
+            .map((input, index) => {
+            const str = `
+=>${index} ${input.data.witnessUtxo.value} Sats
+        lock-size: ${input.data.witnessUtxo.script.length}
+        via ${input.data.hash} [${input.data.index}]
 `;
-                return str;
-            })
-                .join('')}
-total: ${this.getTotalInput()} Sats
-----------------------------------------------------------------------------------------------
-Outputs
+            return str;
+        })
+            .join('')}
+total: ${this.getTotalInput()} Sats
+----------------------------------------------------------------------------------------------
+Outputs
 ${this.outputs
-                .map((output, index) => {
-                const str = `
+            .map((output, index) => {
+            const str = `
 =>${index} ${output.address} ${output.value} Sats`;
-                return str;
-            })
-                .join('')}
-
-total: ${this.getTotalOutput()} Sats
-=============================================================================================
+            return str;
+        })
+            .join('')}
+
+total: ${this.getTotalOutput()} Sats
+=============================================================================================
     `);
-        });
     }
     selectBtcUtxos() {
         const totalInput = this.getTotalInput();
         const totalOutput = this.getTotalOutput() + this._cacheNetworkFee;
         if (totalInput < totalOutput) {
-            const { selectedUtxos, remainingUtxos } = utxo_1.utxoHelper.selectBtcUtxos(this._cacheBtcUtxos, totalOutput - totalInput);
+            const { selectedUtxos, remainingUtxos } = utxoHelper.selectBtcUtxos(this._cacheBtcUtxos, totalOutput - totalInput);
             if (selectedUtxos.length == 0) {
-                throw new error_1.WalletUtilsError(error_1.ErrorCodes.INSUFFICIENT_BTC_UTXO);
+                throw new WalletUtilsError(ErrorCodes.INSUFFICIENT_BTC_UTXO);
             }
             selectedUtxos.forEach((v) => {
                 this.addInput(v);
@@ -348,11 +344,10 @@ total: ${this.getTotalOutput()} Sats
                     index: this.inputs.length - 1,
                     publicKey: v.pubkey
                 });
-                this._cacheNetworkFee += utxo_1.utxoHelper.getAddedVirtualSize(v.addressType) * this.feeRate;
+                this._cacheNetworkFee += utxoHelper.getAddedVirtualSize(v.addressType) * this.feeRate;
             });
             this._cacheBtcUtxos = remainingUtxos;
             this.selectBtcUtxos();
         }
     }
 }
-exports.Transaction = Transaction;

package/lib/transaction/utxo.js

@@ -1,11 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.utxoHelper = void 0;
-exports.getUtxoDust = getUtxoDust;
-exports.getAddressUtxoDust = getAddressUtxoDust;
-const address_1 = require("../address");
-const network_1 = require("../network");
-const types_1 = require("../types");
+import { decodeAddress } from '../address';
+import { NetworkType } from '../network';
+import { AddressType } from '../types';
 function hasInscription(utxos) {
     if (utxos.find((v) => v.inscriptions.length > 0)) {
         return true;
@@ -64,25 +59,25 @@ function selectBtcUtxos(utxos, targetAmount) {
  * return the added virtual size of the utxo
  */
 function getAddedVirtualSize(addressType) {
-    if (addressType === types_1.AddressType.P2WPKH || addressType === types_1.AddressType.M44_P2WPKH) {
+    if (addressType === AddressType.P2WPKH || addressType === AddressType.M44_P2WPKH) {
         return 41 + (1 + 1 + 72 + 1 + 33) / 4;
     }
-    else if (addressType === types_1.AddressType.P2TR || addressType === types_1.AddressType.M44_P2TR) {
+    else if (addressType === AddressType.P2TR || addressType === AddressType.M44_P2TR) {
         return 41 + (1 + 1 + 64) / 4;
     }
-    else if (addressType === types_1.AddressType.P2PKH) {
+    else if (addressType === AddressType.P2PKH) {
         return 41 + 1 + 1 + 72 + 1 + 33;
     }
-    else if (addressType === types_1.AddressType.P2SH_P2WPKH) {
+    else if (addressType === AddressType.P2SH_P2WPKH) {
         return 41 + 24 + (1 + 1 + 72 + 1 + 33) / 4;
     }
     throw new Error('unknown address type');
 }
-function getUtxoDust(addressType) {
-    if (addressType === types_1.AddressType.P2WPKH || addressType === types_1.AddressType.M44_P2WPKH) {
+export function getUtxoDust(addressType) {
+    if (addressType === AddressType.P2WPKH || addressType === AddressType.M44_P2WPKH) {
         return 294;
     }
-    else if (addressType === types_1.AddressType.P2TR || addressType === types_1.AddressType.M44_P2TR) {
+    else if (addressType === AddressType.P2TR || addressType === AddressType.M44_P2TR) {
         return 330;
     }
     else {
@@ -91,10 +86,10 @@ function getUtxoDust(addressType) {
 }
 // deprecated
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-function getAddressUtxoDust(address, networkType = network_1.NetworkType.MAINNET) {
-    return (0, address_1.decodeAddress)(address).dust;
+export function getAddressUtxoDust(address, networkType = NetworkType.MAINNET) {
+    return decodeAddress(address).dust;
 }
-exports.utxoHelper = {
+export const utxoHelper = {
     hasAtomicalsFT,
     hasAtomicalsNFT,
     hasAtomicals,

package/lib/tx-helpers/index.js

@@ -1,18 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.splitInscriptionUtxo = exports.sendRunes = exports.sendInscriptions = exports.sendInscription = exports.sendBTC = exports.sendAtomicalsNFT = exports.sendAtomicalsFT = exports.sendAllBTC = void 0;
-const send_atomicals_ft_1 = require("./send-atomicals-ft");
-Object.defineProperty(exports, "sendAtomicalsFT", { enumerable: true, get: function () { return send_atomicals_ft_1.sendAtomicalsFT; } });
-const send_atomicals_nft_1 = require("./send-atomicals-nft");
-Object.defineProperty(exports, "sendAtomicalsNFT", { enumerable: true, get: function () { return send_atomicals_nft_1.sendAtomicalsNFT; } });
-const send_btc_1 = require("./send-btc");
-Object.defineProperty(exports, "sendAllBTC", { enumerable: true, get: function () { return send_btc_1.sendAllBTC; } });
-Object.defineProperty(exports, "sendBTC", { enumerable: true, get: function () { return send_btc_1.sendBTC; } });
-const send_inscription_1 = require("./send-inscription");
-Object.defineProperty(exports, "sendInscription", { enumerable: true, get: function () { return send_inscription_1.sendInscription; } });
-const send_inscriptions_1 = require("./send-inscriptions");
-Object.defineProperty(exports, "sendInscriptions", { enumerable: true, get: function () { return send_inscriptions_1.sendInscriptions; } });
-const send_runes_1 = require("./send-runes");
-Object.defineProperty(exports, "sendRunes", { enumerable: true, get: function () { return send_runes_1.sendRunes; } });
-const split_inscription_utxo_1 = require("./split-inscription-utxo");
-Object.defineProperty(exports, "splitInscriptionUtxo", { enumerable: true, get: function () { return split_inscription_utxo_1.splitInscriptionUtxo; } });
+import { sendAtomicalsFT } from './send-atomicals-ft';
+import { sendAtomicalsNFT } from './send-atomicals-nft';
+import { sendAllBTC, sendBTC } from './send-btc';
+import { sendInscription } from './send-inscription';
+import { sendInscriptions } from './send-inscriptions';
+import { sendRunes } from './send-runes';
+import { splitInscriptionUtxo } from './split-inscription-utxo';
+export { sendAllBTC, sendAtomicalsFT, sendAtomicalsNFT, sendBTC, sendInscription, sendInscriptions, sendRunes, splitInscriptionUtxo };

package/lib/tx-helpers/send-atomicals-ft.js

@@ -1,65 +1,51 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sendAtomicalsFT = sendAtomicalsFT;
-const error_1 = require("../error");
-const transaction_1 = require("../transaction");
+import { ErrorCodes, WalletUtilsError } from '../error';
+import { Transaction, utxoHelper } from '../transaction';
 // only one arc20 can be send
-function sendAtomicalsFT(params) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const { assetUtxos, btcUtxos, toAddress, networkType, changeAssetAddress, sendAmount, changeAddress, feeRate, enableRBF = true } = params;
-        // safe check
-        if (transaction_1.utxoHelper.hasAtomicalsNFT(assetUtxos) || transaction_1.utxoHelper.hasInscription(assetUtxos)) {
-            throw new error_1.WalletUtilsError(error_1.ErrorCodes.NOT_SAFE_UTXOS);
-        }
-        if (transaction_1.utxoHelper.hasAnyAssets(btcUtxos)) {
-            throw new error_1.WalletUtilsError(error_1.ErrorCodes.NOT_SAFE_UTXOS);
+export async function sendAtomicalsFT(params) {
+    const { assetUtxos, btcUtxos, toAddress, networkType, changeAssetAddress, sendAmount, changeAddress, feeRate, enableRBF = true } = params;
+    // safe check
+    if (utxoHelper.hasAtomicalsNFT(assetUtxos) || utxoHelper.hasInscription(assetUtxos)) {
+        throw new WalletUtilsError(ErrorCodes.NOT_SAFE_UTXOS);
+    }
+    if (utxoHelper.hasAnyAssets(btcUtxos)) {
+        throw new WalletUtilsError(ErrorCodes.NOT_SAFE_UTXOS);
+    }
+    const tx = new Transaction();
+    tx.setNetworkType(networkType);
+    tx.setFeeRate(feeRate);
+    tx.setEnableRBF(enableRBF);
+    tx.setChangeAddress(changeAddress);
+    const toSignInputs = [];
+    let totalInputFTAmount = 0;
+    assetUtxos.forEach((v) => {
+        if (v.atomicals.length > 1) {
+            throw new WalletUtilsError(ErrorCodes.ONLY_ONE_ARC20_CAN_BE_SENT);
         }
-        const tx = new transaction_1.Transaction();
-        tx.setNetworkType(networkType);
-        tx.setFeeRate(feeRate);
-        tx.setEnableRBF(enableRBF);
-        tx.setChangeAddress(changeAddress);
-        const toSignInputs = [];
-        let totalInputFTAmount = 0;
-        assetUtxos.forEach((v) => {
-            if (v.atomicals.length > 1) {
-                throw new error_1.WalletUtilsError(error_1.ErrorCodes.ONLY_ONE_ARC20_CAN_BE_SENT);
+        v.atomicals.forEach((w) => {
+            if (!w.atomicalValue) {
+                w.atomicalValue = v.satoshis;
             }
-            v.atomicals.forEach((w) => {
-                if (!w.atomicalValue) {
-                    w.atomicalValue = v.satoshis;
-                }
-                totalInputFTAmount += w.atomicalValue;
-            });
-        });
-        if (sendAmount > totalInputFTAmount) {
-            throw new error_1.WalletUtilsError(error_1.ErrorCodes.INSUFFICIENT_ASSET_UTXO);
-        }
-        // add assets
-        assetUtxos.forEach((v, index) => {
-            tx.addInput(v);
-            toSignInputs.push({ index, publicKey: v.pubkey });
+            totalInputFTAmount += w.atomicalValue;
         });
-        // add receiver
-        tx.addOutput(toAddress, sendAmount);
-        // add change
-        const changeArc20Amount = totalInputFTAmount - sendAmount;
-        if (changeArc20Amount > 0) {
-            tx.addOutput(changeAssetAddress, changeArc20Amount);
-        }
-        // add btc
-        const _toSignInputs = yield tx.addSufficientUtxosForFee(btcUtxos, true);
-        toSignInputs.push(..._toSignInputs);
-        const psbt = tx.toPsbt();
-        return { psbt, toSignInputs };
     });
+    if (sendAmount > totalInputFTAmount) {
+        throw new WalletUtilsError(ErrorCodes.INSUFFICIENT_ASSET_UTXO);
+    }
+    // add assets
+    assetUtxos.forEach((v, index) => {
+        tx.addInput(v);
+        toSignInputs.push({ index, publicKey: v.pubkey });
+    });
+    // add receiver
+    tx.addOutput(toAddress, sendAmount);
+    // add change
+    const changeArc20Amount = totalInputFTAmount - sendAmount;
+    if (changeArc20Amount > 0) {
+        tx.addOutput(changeAssetAddress, changeArc20Amount);
+    }
+    // add btc
+    const _toSignInputs = await tx.addSufficientUtxosForFee(btcUtxos, true);
+    toSignInputs.push(..._toSignInputs);
+    const psbt = tx.toPsbt();
+    return { psbt, toSignInputs };
 }