@btc-vision/wallet-sdk 1.0.0

package/lib/transaction/transaction.js

@@ -0,0 +1,358 @@
+"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");
+/**
+ * Convert UnspentOutput to PSBT TxInput
+ */
+function utxoToInput(utxo, estimate) {
+    if (utxo.addressType === types_1.AddressType.P2TR || utxo.addressType === types_1.AddressType.M44_P2TR) {
+        const data = {
+            hash: utxo.txid,
+            index: utxo.vout,
+            witnessUtxo: {
+                value: utxo.satoshis,
+                script: Buffer.from(utxo.scriptPk, 'hex')
+            },
+            tapInternalKey: (0, utils_1.toXOnly)(Buffer.from(utxo.pubkey, 'hex'))
+        };
+        return {
+            data,
+            utxo
+        };
+    }
+    else if (utxo.addressType === types_1.AddressType.P2WPKH || utxo.addressType === types_1.AddressType.M44_P2WPKH) {
+        const data = {
+            hash: utxo.txid,
+            index: utxo.vout,
+            witnessUtxo: {
+                value: utxo.satoshis,
+                script: Buffer.from(utxo.scriptPk, 'hex')
+            }
+        };
+        return {
+            data,
+            utxo
+        };
+    }
+    else if (utxo.addressType === types_1.AddressType.P2PKH) {
+        if (!utxo.rawtx || estimate) {
+            const data = {
+                hash: utxo.txid,
+                index: utxo.vout,
+                witnessUtxo: {
+                    value: utxo.satoshis,
+                    script: Buffer.from(utxo.scriptPk, 'hex')
+                }
+            };
+            return {
+                data,
+                utxo
+            };
+        }
+        else {
+            const data = {
+                hash: utxo.txid,
+                index: utxo.vout,
+                nonWitnessUtxo: Buffer.from(utxo.rawtx, 'hex')
+            };
+            return {
+                data,
+                utxo
+            };
+        }
+    }
+    else if (utxo.addressType === types_1.AddressType.P2SH_P2WPKH) {
+        const redeemData = bitcoin_core_1.bitcoin.payments.p2wpkh({
+            pubkey: Buffer.from(utxo.pubkey, 'hex')
+        });
+        const data = {
+            hash: utxo.txid,
+            index: utxo.vout,
+            witnessUtxo: {
+                value: utxo.satoshis,
+                script: Buffer.from(utxo.scriptPk, 'hex')
+            },
+            redeemScript: redeemData.output
+        };
+        return {
+            data,
+            utxo
+        };
+    }
+}
+/**
+ * Transaction
+ */
+class Transaction {
+    constructor() {
+        this.utxos = [];
+        this.inputs = [];
+        this.outputs = [];
+        this.changeOutputIndex = -1;
+        this.enableRBF = true;
+        this._cacheNetworkFee = 0;
+        this._cacheBtcUtxos = [];
+        this._cacheToSignInputs = [];
+    }
+    setNetworkType(network) {
+        this.networkType = network;
+    }
+    setEnableRBF(enable) {
+        this.enableRBF = enable;
+    }
+    setFeeRate(feeRate) {
+        this.feeRate = feeRate;
+    }
+    setChangeAddress(address) {
+        this.changedAddress = address;
+    }
+    addInput(utxo) {
+        this.utxos.push(utxo);
+        this.inputs.push(utxoToInput(utxo));
+    }
+    removeLastInput() {
+        this.utxos = this.utxos.slice(0, -1);
+        this.inputs = this.inputs.slice(0, -1);
+    }
+    getTotalInput() {
+        return this.inputs.reduce((pre, cur) => pre + cur.utxo.satoshis, 0);
+    }
+    getTotalOutput() {
+        return this.outputs.reduce((pre, cur) => pre + cur.value, 0);
+    }
+    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;
+        });
+    }
+    addOutput(address, value) {
+        this.outputs.push({
+            address,
+            value
+        });
+    }
+    addOpreturn(data) {
+        const embed = bitcoin_core_1.bitcoin.payments.embed({ data });
+        this.outputs.push({
+            script: embed.output,
+            value: 0
+        });
+    }
+    addScriptOutput(script, value) {
+        this.outputs.push({
+            script,
+            value
+        });
+    }
+    getOutput(index) {
+        return this.outputs[index];
+    }
+    addChangeOutput(value) {
+        this.outputs.push({
+            address: this.changedAddress,
+            value
+        });
+        this.changeOutputIndex = this.outputs.length - 1;
+    }
+    getChangeOutput() {
+        return this.outputs[this.changeOutputIndex];
+    }
+    getChangeAmount() {
+        const output = this.getChangeOutput();
+        return output ? output.value : 0;
+    }
+    removeChangeOutput() {
+        this.outputs.splice(this.changeOutputIndex, 1);
+        this.changeOutputIndex = -1;
+    }
+    removeRecentOutputs(count) {
+        this.outputs.splice(-count);
+    }
+    toPsbt() {
+        const network = (0, network_1.toPsbtNetwork)(this.networkType);
+        const psbt = new bitcoin_core_1.bitcoin.Psbt({ network });
+        this.inputs.forEach((v, index) => {
+            if (v.utxo.addressType === types_1.AddressType.P2PKH) {
+                if (v.data.witnessUtxo) {
+                    //@ts-ignore
+                    psbt.__CACHE.__UNSAFE_SIGN_NONSEGWIT = true;
+                }
+            }
+            psbt.data.addInput(v.data);
+            if (this.enableRBF) {
+                psbt.setInputSequence(index, 0xfffffffd);
+            }
+        });
+        this.outputs.forEach((v) => {
+            if (v.address) {
+                psbt.addOutput({
+                    address: v.address,
+                    value: v.value
+                });
+            }
+            else if (v.script) {
+                psbt.addOutput({
+                    script: v.script,
+                    value: v.value
+                });
+            }
+        });
+        return psbt;
+    }
+    clone() {
+        const tx = new Transaction();
+        tx.setNetworkType(this.networkType);
+        tx.setFeeRate(this.feeRate);
+        tx.setEnableRBF(this.enableRBF);
+        tx.setChangeAddress(this.changedAddress);
+        tx.utxos = this.utxos.map((v) => Object.assign({}, v));
+        tx.inputs = this.inputs.map((v) => v);
+        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;
+        });
+    }
+    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);
+            if (selectedUtxos.length == 0) {
+                throw new error_1.WalletUtilsError(error_1.ErrorCodes.INSUFFICIENT_BTC_UTXO);
+            }
+            selectedUtxos.forEach((v) => {
+                this.addInput(v);
+                this._cacheToSignInputs.push({
+                    index: this.inputs.length - 1,
+                    publicKey: v.pubkey
+                });
+                this._cacheNetworkFee += utxo_1.utxoHelper.getAddedVirtualSize(v.addressType) * this.feeRate;
+            });
+            this._cacheBtcUtxos = remainingUtxos;
+            this.selectBtcUtxos();
+        }
+    }
+    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);
+            }
+            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
+${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}]
+`;
+                return str;
+            })
+                .join('')}
+total: ${this.getTotalInput()} Sats
+----------------------------------------------------------------------------------------------
+Outputs
+${this.outputs
+                .map((output, index) => {
+                const str = `
+=>${index} ${output.address} ${output.value} Sats`;
+                return str;
+            })
+                .join('')}
+
+total: ${this.getTotalOutput()} Sats
+=============================================================================================
+    `);
+        });
+    }
+}
+exports.Transaction = Transaction;

package/lib/transaction/utxo.d.ts

@@ -0,0 +1,35 @@
+import { NetworkType } from '../network';
+import { AddressType, UnspentOutput } from '../types';
+declare function hasInscription(utxos: UnspentOutput[]): boolean;
+declare function hasAtomicalsFT(utxos: UnspentOutput[]): boolean;
+declare function hasAtomicalsNFT(utxos: UnspentOutput[]): boolean;
+declare function hasAtomicals(utxos: UnspentOutput[]): boolean;
+declare function hasAnyAssets(utxos: UnspentOutput[]): boolean;
+/**
+ * select utxos so that the total amount of utxos is greater than or equal to targetAmount
+ * return the selected utxos and the unselected utxos
+ * @param utxos
+ * @param targetAmount
+ */
+declare function selectBtcUtxos(utxos: UnspentOutput[], targetAmount: number): {
+    selectedUtxos: UnspentOutput[];
+    remainingUtxos: UnspentOutput[];
+};
+/**
+ * return the added virtual size of the utxo
+ */
+declare function getAddedVirtualSize(addressType: AddressType): number;
+export declare function getUtxoDust(addressType: AddressType): 546 | 294 | 330;
+export declare function getAddressUtxoDust(address: string, networkType?: NetworkType): number;
+export declare const utxoHelper: {
+    hasAtomicalsFT: typeof hasAtomicalsFT;
+    hasAtomicalsNFT: typeof hasAtomicalsNFT;
+    hasAtomicals: typeof hasAtomicals;
+    hasInscription: typeof hasInscription;
+    hasAnyAssets: typeof hasAnyAssets;
+    selectBtcUtxos: typeof selectBtcUtxos;
+    getAddedVirtualSize: typeof getAddedVirtualSize;
+    getUtxoDust: typeof getUtxoDust;
+    getAddressUtxoDust: typeof getAddressUtxoDust;
+};
+export {};

package/lib/transaction/utxo.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.utxoHelper = exports.getAddressUtxoDust = exports.getUtxoDust = void 0;
+const address_1 = require("../address");
+const network_1 = require("../network");
+const types_1 = require("../types");
+function hasInscription(utxos) {
+    if (utxos.find((v) => v.inscriptions.length > 0)) {
+        return true;
+    }
+    return false;
+}
+function hasAtomicalsFT(utxos) {
+    if (utxos.find((v) => v.atomicals.find((w) => w.type === 'FT'))) {
+        return true;
+    }
+    return false;
+}
+function hasAtomicalsNFT(utxos) {
+    if (utxos.find((v) => v.atomicals.find((w) => w.type === 'NFT'))) {
+        return true;
+    }
+    return false;
+}
+function hasAtomicals(utxos) {
+    if (utxos.find((v) => v.atomicals.length > 0)) {
+        return true;
+    }
+    return false;
+}
+function hasAnyAssets(utxos) {
+    if (utxos.find((v) => v.inscriptions.length > 0 || v.atomicals.length > 0)) {
+        return true;
+    }
+    return false;
+}
+/**
+ * select utxos so that the total amount of utxos is greater than or equal to targetAmount
+ * return the selected utxos and the unselected utxos
+ * @param utxos
+ * @param targetAmount
+ */
+function selectBtcUtxos(utxos, targetAmount) {
+    let selectedUtxos = [];
+    let remainingUtxos = [];
+    let totalAmount = 0;
+    for (const utxo of utxos) {
+        if (totalAmount < targetAmount) {
+            totalAmount += utxo.satoshis;
+            selectedUtxos.push(utxo);
+        }
+        else {
+            remainingUtxos.push(utxo);
+        }
+    }
+    return {
+        selectedUtxos,
+        remainingUtxos
+    };
+}
+/**
+ * return the added virtual size of the utxo
+ */
+function getAddedVirtualSize(addressType) {
+    if (addressType === types_1.AddressType.P2WPKH || addressType === types_1.AddressType.M44_P2WPKH) {
+        return 41 + (1 + 1 + 72 + 1 + 33) / 4;
+    }
+    else if (addressType === types_1.AddressType.P2TR || addressType === types_1.AddressType.M44_P2TR) {
+        return 41 + (1 + 1 + 64) / 4;
+    }
+    else if (addressType === types_1.AddressType.P2PKH) {
+        return 41 + 1 + 1 + 72 + 1 + 33;
+    }
+    else if (addressType === types_1.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) {
+        return 294;
+    }
+    else if (addressType === types_1.AddressType.P2TR || addressType === types_1.AddressType.M44_P2TR) {
+        return 330;
+    }
+    else {
+        return 546;
+    }
+}
+exports.getUtxoDust = getUtxoDust;
+// 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;
+}
+exports.getAddressUtxoDust = getAddressUtxoDust;
+exports.utxoHelper = {
+    hasAtomicalsFT,
+    hasAtomicalsNFT,
+    hasAtomicals,
+    hasInscription,
+    hasAnyAssets,
+    selectBtcUtxos,
+    getAddedVirtualSize,
+    getUtxoDust,
+    getAddressUtxoDust
+};

package/lib/tx-helpers/index.d.ts

@@ -0,0 +1,8 @@
+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/index.js

@@ -0,0 +1,18 @@
+"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; } });

package/lib/tx-helpers/send-atomicals-ft.d.ts

@@ -0,0 +1,16 @@
+import { NetworkType } from '../network';
+import { ToSignInput, UnspentOutput } from '../types';
+export declare function sendAtomicalsFT(params: {
+    assetUtxos: UnspentOutput[];
+    btcUtxos: UnspentOutput[];
+    toAddress: string;
+    networkType: NetworkType;
+    changeAssetAddress: string;
+    sendAmount: number;
+    changeAddress: string;
+    feeRate: number;
+    enableRBF?: boolean;
+}): Promise<{
+    psbt: import("bitcoinjs-lib").Psbt;
+    toSignInputs: ToSignInput[];
+}>;

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

@@ -0,0 +1,66 @@
+"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 = void 0;
+const error_1 = require("../error");
+const transaction_1 = require("../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);
+        }
+        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;
+                }
+                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 });
+        });
+        // 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 };
+    });
+}
+exports.sendAtomicalsFT = sendAtomicalsFT;

package/lib/tx-helpers/send-atomicals-nft.d.ts

@@ -0,0 +1,14 @@
+import { NetworkType } from '../network';
+import { ToSignInput, UnspentOutput } from '../types';
+export declare function sendAtomicalsNFT(params: {
+    assetUtxo: UnspentOutput;
+    btcUtxos: UnspentOutput[];
+    toAddress: string;
+    networkType: NetworkType;
+    changeAddress: string;
+    feeRate: number;
+    enableRBF?: boolean;
+}): Promise<{
+    psbt: import("bitcoinjs-lib").Psbt;
+    toSignInputs: ToSignInput[];
+}>;

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

@@ -0,0 +1,45 @@
+"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.sendAtomicalsNFT = void 0;
+const error_1 = require("../error");
+const transaction_1 = require("../transaction");
+function sendAtomicalsNFT(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { assetUtxo, btcUtxos, toAddress, networkType, changeAddress, feeRate, enableRBF = true } = params;
+        // safe check
+        if (transaction_1.utxoHelper.hasAtomicalsFT([assetUtxo]) || transaction_1.utxoHelper.hasInscription([assetUtxo])) {
+            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);
+        }
+        if (assetUtxo.atomicals.length !== 1) {
+            throw new error_1.WalletUtilsError(error_1.ErrorCodes.NOT_SAFE_UTXOS);
+        }
+        const tx = new transaction_1.Transaction();
+        tx.setNetworkType(networkType);
+        tx.setFeeRate(feeRate);
+        tx.setEnableRBF(enableRBF);
+        tx.setChangeAddress(changeAddress);
+        const toSignInputs = [];
+        // add asset
+        tx.addInput(assetUtxo);
+        toSignInputs.push({ index: 0, publicKey: assetUtxo.pubkey });
+        tx.addOutput(toAddress, assetUtxo.satoshis);
+        // add btc
+        const _toSignInputs = yield tx.addSufficientUtxosForFee(btcUtxos, true);
+        toSignInputs.push(..._toSignInputs);
+        const psbt = tx.toPsbt();
+        return { psbt, toSignInputs };
+    });
+}
+exports.sendAtomicalsNFT = sendAtomicalsNFT;