@btc-vision/wallet-sdk 1.0.0

package/lib/tx-helpers/send-btc.d.ts

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

package/lib/tx-helpers/send-btc.js

@@ -0,0 +1,78 @@
+"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.sendAllBTC = exports.sendBTC = void 0;
+const constants_1 = require("../constants");
+const error_1 = require("../error");
+const transaction_1 = require("../transaction");
+function sendBTC(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { btcUtxos, tos, networkType, changeAddress, feeRate, enableRBF = true, memo, memos } = params;
+        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);
+        tos.forEach((v) => {
+            tx.addOutput(v.address, v.satoshis);
+        });
+        if (memo) {
+            if (Buffer.from(memo, 'hex').toString('hex') === memo) {
+                tx.addOpreturn([Buffer.from(memo, 'hex')]);
+            }
+            else {
+                tx.addOpreturn([Buffer.from(memo)]);
+            }
+        }
+        else if (memos) {
+            if (Buffer.from(memos[0], 'hex').toString('hex') === memos[0]) {
+                tx.addOpreturn(memos.map((memo) => Buffer.from(memo, 'hex')));
+            }
+            else {
+                tx.addOpreturn(memos.map((memo) => Buffer.from(memo)));
+            }
+        }
+        const toSignInputs = yield tx.addSufficientUtxosForFee(btcUtxos);
+        const psbt = tx.toPsbt();
+        return { psbt, toSignInputs };
+    });
+}
+exports.sendBTC = sendBTC;
+function sendAllBTC(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { btcUtxos, toAddress, networkType, feeRate, enableRBF = true } = params;
+        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.addOutput(toAddress, constants_1.UTXO_DUST);
+        const toSignInputs = [];
+        btcUtxos.forEach((v, index) => {
+            tx.addInput(v);
+            toSignInputs.push({ index, publicKey: v.pubkey });
+        });
+        const fee = yield tx.calNetworkFee();
+        const unspent = tx.getTotalInput() - fee;
+        if (unspent < constants_1.UTXO_DUST) {
+            throw new error_1.WalletUtilsError(error_1.ErrorCodes.INSUFFICIENT_BTC_UTXO);
+        }
+        tx.outputs[0].value = unspent;
+        const psbt = tx.toPsbt();
+        return { psbt, toSignInputs };
+    });
+}
+exports.sendAllBTC = sendAllBTC;

package/lib/tx-helpers/send-inscription.d.ts

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

package/lib/tx-helpers/send-inscription.js

@@ -0,0 +1,49 @@
+"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.sendInscription = void 0;
+const error_1 = require("../error");
+const transaction_1 = require("../transaction/transaction");
+const utxo_1 = require("../transaction/utxo");
+function sendInscription({ assetUtxo, btcUtxos, toAddress, networkType, changeAddress, feeRate, outputValue, enableRBF = true, enableMixed = false }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (utxo_1.utxoHelper.hasAnyAssets(btcUtxos)) {
+            throw new error_1.WalletUtilsError(error_1.ErrorCodes.NOT_SAFE_UTXOS);
+        }
+        if (utxo_1.utxoHelper.hasAtomicals([assetUtxo])) {
+            throw new error_1.WalletUtilsError(error_1.ErrorCodes.NOT_SAFE_UTXOS);
+        }
+        if (!enableMixed && assetUtxo.inscriptions.length !== 1) {
+            throw new error_1.WalletUtilsError(error_1.ErrorCodes.NOT_SAFE_UTXOS);
+        }
+        const maxOffset = assetUtxo.inscriptions.reduce((pre, cur) => {
+            return Math.max(pre, cur.offset);
+        }, 0);
+        if (outputValue - 1 < maxOffset) {
+            throw new error_1.WalletUtilsError(error_1.ErrorCodes.ASSET_MAYBE_LOST);
+        }
+        const tx = new transaction_1.Transaction();
+        tx.setNetworkType(networkType);
+        tx.setFeeRate(feeRate);
+        tx.setEnableRBF(enableRBF);
+        tx.setChangeAddress(changeAddress);
+        tx.addInput(assetUtxo);
+        tx.addOutput(toAddress, outputValue);
+        const toSignInputs = yield tx.addSufficientUtxosForFee(btcUtxos);
+        toSignInputs.push({
+            index: 0,
+            publicKey: assetUtxo.pubkey
+        });
+        const psbt = tx.toPsbt();
+        return { psbt, toSignInputs };
+    });
+}
+exports.sendInscription = sendInscription;

package/lib/tx-helpers/send-inscriptions.d.ts

@@ -0,0 +1,14 @@
+import { NetworkType } from '../network';
+import { ToSignInput, UnspentOutput } from '../types';
+export declare function sendInscriptions({ assetUtxos, btcUtxos, toAddress, networkType, changeAddress, feeRate, enableRBF }: {
+    assetUtxos: 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-inscriptions.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.sendInscriptions = void 0;
+const error_1 = require("../error");
+const transaction_1 = require("../transaction/transaction");
+const utxo_1 = require("../transaction/utxo");
+function sendInscriptions({ assetUtxos, btcUtxos, toAddress, networkType, changeAddress, feeRate, enableRBF = true }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (utxo_1.utxoHelper.hasAnyAssets(btcUtxos)) {
+            throw new error_1.WalletUtilsError(error_1.ErrorCodes.NOT_SAFE_UTXOS);
+        }
+        if (utxo_1.utxoHelper.hasAtomicals(assetUtxos)) {
+            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 = [];
+        for (let i = 0; i < assetUtxos.length; i++) {
+            const assetUtxo = assetUtxos[i];
+            if (assetUtxo.inscriptions.length > 1) {
+                throw new Error('Multiple inscriptions in one UTXO! Please split them first.');
+            }
+            tx.addInput(assetUtxo);
+            tx.addOutput(toAddress, assetUtxo.satoshis);
+            toSignInputs.push({ index: i, publicKey: assetUtxo.pubkey });
+        }
+        const _toSignInputs = yield tx.addSufficientUtxosForFee(btcUtxos);
+        toSignInputs.push(..._toSignInputs);
+        const psbt = tx.toPsbt();
+        return { psbt, toSignInputs };
+    });
+}
+exports.sendInscriptions = sendInscriptions;

package/lib/tx-helpers/send-runes.d.ts

@@ -0,0 +1,19 @@
+import { bitcoin } from '../bitcoin-core';
+import { NetworkType } from '../network';
+import { ToSignInput, UnspentOutput } from '../types';
+export declare function sendRunes({ assetUtxos, btcUtxos, assetAddress, btcAddress, toAddress, networkType, runeid, runeAmount, outputValue, feeRate, enableRBF }: {
+    assetUtxos: UnspentOutput[];
+    btcUtxos: UnspentOutput[];
+    assetAddress: string;
+    btcAddress: string;
+    toAddress: string;
+    networkType: NetworkType;
+    runeid: string;
+    runeAmount: string;
+    outputValue: number;
+    feeRate: number;
+    enableRBF?: boolean;
+}): Promise<{
+    psbt: bitcoin.Psbt;
+    toSignInputs: ToSignInput[];
+}>;

package/lib/tx-helpers/send-runes.js

@@ -0,0 +1,101 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendRunes = void 0;
+const big_integer_1 = __importDefault(require("big-integer"));
+const bitcoin_core_1 = require("../bitcoin-core");
+const error_1 = require("../error");
+const runes_1 = require("../runes");
+const rund_id_1 = require("../runes/rund_id");
+const transaction_1 = require("../transaction/transaction");
+const utxo_1 = require("../transaction/utxo");
+// only one arc20 can be send
+function sendRunes({ assetUtxos, btcUtxos, assetAddress, btcAddress, toAddress, networkType, runeid, runeAmount, outputValue, feeRate, enableRBF = true }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // safe check
+        if (utxo_1.utxoHelper.hasAtomicalsNFT(assetUtxos) || utxo_1.utxoHelper.hasInscription(assetUtxos)) {
+            throw new error_1.WalletUtilsError(error_1.ErrorCodes.NOT_SAFE_UTXOS);
+        }
+        if (utxo_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(btcAddress);
+        const toSignInputs = [];
+        // add assets
+        assetUtxos.forEach((v, index) => {
+            tx.addInput(v);
+            toSignInputs.push({ index, publicKey: v.pubkey });
+        });
+        let fromRuneAmount = (0, big_integer_1.default)(0);
+        let hasMultipleRunes = false;
+        let runesMap = {};
+        assetUtxos.forEach((v) => {
+            if (v.runes) {
+                v.runes.forEach((w) => {
+                    runesMap[w.runeid] = true;
+                    if (w.runeid === runeid) {
+                        fromRuneAmount = fromRuneAmount.plus((0, big_integer_1.default)(w.amount));
+                    }
+                });
+            }
+        });
+        if (Object.keys(runesMap).length > 1) {
+            hasMultipleRunes = true;
+        }
+        const changedRuneAmount = fromRuneAmount.minus((0, big_integer_1.default)(runeAmount));
+        if (changedRuneAmount.lt(0)) {
+            throw new error_1.WalletUtilsError(error_1.ErrorCodes.INSUFFICIENT_ASSET_UTXO);
+        }
+        let needChange = false;
+        if (hasMultipleRunes || changedRuneAmount.gt(0)) {
+            needChange = true;
+        }
+        let payload = [];
+        let runeId = rund_id_1.RuneId.fromString(runeid);
+        runes_1.varint.encodeToVec(0, payload);
+        // add send data
+        runes_1.varint.encodeToVec(runeId.block, payload);
+        runes_1.varint.encodeToVec(runeId.tx, payload);
+        runes_1.varint.encodeToVec(runeAmount, payload);
+        if (needChange) {
+            // 1 is to change
+            // 2 is to send
+            runes_1.varint.encodeToVec(2, payload);
+        }
+        else {
+            // 1 is to send
+            runes_1.varint.encodeToVec(1, payload);
+        }
+        // add op_return
+        tx.addScriptOutput(
+        // OUTPUT_0
+        bitcoin_core_1.bitcoin.script.compile([bitcoin_core_1.bitcoin.opcodes.OP_RETURN, bitcoin_core_1.bitcoin.opcodes.OP_13, Buffer.from(new Uint8Array(payload))]), 0);
+        if (needChange) {
+            // OUTPUT_1
+            // add change
+            tx.addOutput(assetAddress, outputValue);
+        }
+        tx.addOutput(toAddress, outputValue);
+        // add btc
+        const _toSignInputs = yield tx.addSufficientUtxosForFee(btcUtxos, true);
+        toSignInputs.push(..._toSignInputs);
+        const psbt = tx.toPsbt();
+        return { psbt, toSignInputs };
+    });
+}
+exports.sendRunes = sendRunes;

package/lib/tx-helpers/split-inscription-utxo.d.ts

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

package/lib/tx-helpers/split-inscription-utxo.js

@@ -0,0 +1,58 @@
+"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.splitInscriptionUtxo = void 0;
+const constants_1 = require("../constants");
+const error_1 = require("../error");
+const transaction_1 = require("../transaction");
+function splitInscriptionUtxo({ btcUtxos, assetUtxo, networkType, changeAddress, feeRate, enableRBF = true, outputValue = 546 }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (transaction_1.utxoHelper.hasAnyAssets(btcUtxos)) {
+            throw new error_1.WalletUtilsError(error_1.ErrorCodes.NOT_SAFE_UTXOS);
+        }
+        if (transaction_1.utxoHelper.hasAtomicals([assetUtxo])) {
+            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 lastUnit = null;
+        let splitedCount = 0;
+        const ordUtxo = new transaction_1.InscriptionUnspendOutput(assetUtxo, outputValue);
+        tx.addInput(ordUtxo.utxo);
+        toSignInputs.push({ index: 0, publicKey: ordUtxo.utxo.pubkey });
+        for (let j = 0; j < ordUtxo.inscriptionUnits.length; j++) {
+            const unit = ordUtxo.inscriptionUnits[j];
+            if (unit.hasInscriptions()) {
+                tx.addChangeOutput(unit.satoshis);
+                lastUnit = unit;
+                splitedCount++;
+                continue;
+            }
+            tx.addChangeOutput(unit.satoshis);
+            lastUnit = unit;
+        }
+        if (!lastUnit.hasInscriptions()) {
+            tx.removeChangeOutput();
+        }
+        if (lastUnit.satoshis < constants_1.UTXO_DUST) {
+            lastUnit.satoshis = constants_1.UTXO_DUST;
+        }
+        const _toSignInputs = yield tx.addSufficientUtxosForFee(btcUtxos);
+        toSignInputs.push(..._toSignInputs);
+        const psbt = tx.toPsbt();
+        return { psbt, toSignInputs, splitedCount };
+    });
+}
+exports.splitInscriptionUtxo = splitInscriptionUtxo;

package/lib/types.d.ts

@@ -0,0 +1,59 @@
+interface BaseUserToSignInput {
+    index: number;
+    sighashTypes?: number[] | undefined;
+    disableTweakSigner?: boolean;
+}
+export interface AddressUserToSignInput extends BaseUserToSignInput {
+    address: string;
+}
+export interface PublicKeyUserToSignInput extends BaseUserToSignInput {
+    publicKey: string;
+}
+export type UserToSignInput = AddressUserToSignInput | PublicKeyUserToSignInput;
+export interface SignPsbtOptions {
+    autoFinalized?: boolean;
+    toSignInputs?: UserToSignInput[];
+}
+export interface ToSignInput {
+    index: number;
+    publicKey: string;
+    sighashTypes?: number[];
+    disableTweakSigner?: boolean;
+}
+export interface UnspentOutput {
+    txid: string;
+    vout: number;
+    satoshis: number;
+    scriptPk: string;
+    pubkey: string;
+    addressType: AddressType;
+    inscriptions: {
+        inscriptionId: string;
+        inscriptionNumber?: number;
+        offset: number;
+    }[];
+    atomicals: {
+        atomicalId: string;
+        atomicalNumber: number;
+        type: 'FT' | 'NFT';
+        ticker?: string;
+        atomicalValue?: number;
+    }[];
+    runes?: {
+        runeid: string;
+        amount: string;
+    }[];
+    rawtx?: string;
+}
+export declare enum AddressType {
+    P2PKH = 0,
+    P2WPKH = 1,
+    P2TR = 2,
+    P2SH_P2WPKH = 3,
+    M44_P2WPKH = 4,
+    M44_P2TR = 5,
+    P2WSH = 6,
+    P2SH = 7,
+    UNKNOWN = 8
+}
+export {};

package/lib/types.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddressType = void 0;
+var AddressType;
+(function (AddressType) {
+    AddressType[AddressType["P2PKH"] = 0] = "P2PKH";
+    AddressType[AddressType["P2WPKH"] = 1] = "P2WPKH";
+    AddressType[AddressType["P2TR"] = 2] = "P2TR";
+    AddressType[AddressType["P2SH_P2WPKH"] = 3] = "P2SH_P2WPKH";
+    AddressType[AddressType["M44_P2WPKH"] = 4] = "M44_P2WPKH";
+    AddressType[AddressType["M44_P2TR"] = 5] = "M44_P2TR";
+    AddressType[AddressType["P2WSH"] = 6] = "P2WSH";
+    AddressType[AddressType["P2SH"] = 7] = "P2SH";
+    AddressType[AddressType["UNKNOWN"] = 8] = "UNKNOWN";
+})(AddressType = exports.AddressType || (exports.AddressType = {}));

package/lib/utils.d.ts

@@ -0,0 +1,23 @@
+import { bitcoin } from './bitcoin-core';
+export declare const toXOnly: (pubKey: Buffer) => Buffer;
+/**
+ * Transform raw private key to taproot address private key
+ */
+export declare function tweakSigner(signer: bitcoin.Signer, opts?: any): bitcoin.Signer;
+/**
+ * ECDSA signature validator
+ */
+export declare const validator: (pubkey: Buffer, msghash: Buffer, signature: Buffer) => boolean;
+/**
+ * Schnorr signature validator
+ */
+export declare const schnorrValidator: (pubkey: Buffer, msghash: Buffer, signature: Buffer) => boolean;
+/**
+ * Transform satoshis to btc format
+ */
+export declare function satoshisToAmount(val: number): string;
+/**
+ * Transform btc format to satoshis
+ */
+export declare function amountToSaothis(val: any): number;
+export declare function shortAddress(address?: string, len?: number): string;

package/lib/utils.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shortAddress = exports.amountToSaothis = exports.satoshisToAmount = exports.schnorrValidator = exports.validator = exports.tweakSigner = exports.toXOnly = void 0;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const bitcoin_core_1 = require("./bitcoin-core");
+const toXOnly = (pubKey) => (pubKey.length === 32 ? pubKey : pubKey.slice(1, 33));
+exports.toXOnly = toXOnly;
+function tapTweakHash(pubKey, h) {
+    return bitcoin_core_1.bitcoin.crypto.taggedHash('TapTweak', Buffer.concat(h ? [pubKey, h] : [pubKey]));
+}
+/**
+ * Transform raw private key to taproot address private key
+ */
+function tweakSigner(signer, opts = {}) {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    let privateKey = signer.privateKey;
+    if (!privateKey) {
+        throw new Error('Private key is required for tweaking signer!');
+    }
+    if (signer.publicKey[0] === 3) {
+        privateKey = bitcoin_core_1.ecc.privateNegate(privateKey);
+    }
+    const tweakedPrivateKey = bitcoin_core_1.ecc.privateAdd(privateKey, tapTweakHash((0, exports.toXOnly)(signer.publicKey), opts.tweakHash));
+    if (!tweakedPrivateKey) {
+        throw new Error('Invalid tweaked private key!');
+    }
+    return bitcoin_core_1.ECPair.fromPrivateKey(Buffer.from(tweakedPrivateKey), {
+        network: opts.network
+    });
+}
+exports.tweakSigner = tweakSigner;
+/**
+ * ECDSA signature validator
+ */
+const validator = (pubkey, msghash, signature) => bitcoin_core_1.ECPair.fromPublicKey(pubkey).verify(msghash, signature);
+exports.validator = validator;
+/**
+ * Schnorr signature validator
+ */
+const schnorrValidator = (pubkey, msghash, signature) => {
+    return bitcoin_core_1.ECPair.fromPublicKey(pubkey).verifySchnorr(msghash, signature);
+};
+exports.schnorrValidator = schnorrValidator;
+/**
+ * Transform satoshis to btc format
+ */
+function satoshisToAmount(val) {
+    const num = new bignumber_js_1.default(val);
+    return num.dividedBy(100000000).toFixed(8);
+}
+exports.satoshisToAmount = satoshisToAmount;
+/**
+ * Transform btc format to satoshis
+ */
+function amountToSaothis(val) {
+    const num = new bignumber_js_1.default(val);
+    return num.multipliedBy(100000000).toNumber();
+}
+exports.amountToSaothis = amountToSaothis;
+function shortAddress(address, len = 5) {
+    if (!address)
+        return '';
+    if (address.length <= len * 2)
+        return address;
+    return address.slice(0, len) + '...' + address.slice(address.length - len);
+}
+exports.shortAddress = shortAddress;

package/lib/wallet/abstract-wallet.d.ts

@@ -0,0 +1,6 @@
+import { bitcoin } from '../bitcoin-core';
+import { SignPsbtOptions } from '../types';
+export interface AbstractWallet {
+    signPsbt(psbt: bitcoin.Psbt, opts?: SignPsbtOptions): Promise<bitcoin.Psbt>;
+    signMessage(text: string, type: 'bip322-simple' | 'ecdsa'): Promise<string>;
+}

package/lib/wallet/abstract-wallet.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/wallet/estimate-wallet.d.ts

@@ -0,0 +1,23 @@
+import { bitcoin } from '../bitcoin-core';
+import { SimpleKeyring } from '../keyring';
+import { NetworkType } from '../network';
+import { AddressType, SignPsbtOptions } from '../types';
+import { AbstractWallet } from './abstract-wallet';
+/**
+ * EstimateWallet is a wallet that can be used to estimate the size of a transaction.
+ */
+export declare class EstimateWallet implements AbstractWallet {
+    keyring: SimpleKeyring;
+    address: string;
+    pubkey: string;
+    network: bitcoin.Network;
+    networkType: NetworkType;
+    addressType: AddressType;
+    constructor(wif: string, networkType?: NetworkType, addressType?: AddressType);
+    static fromRandom(addressType?: AddressType, networkType?: NetworkType): EstimateWallet;
+    getNetworkType(): NetworkType;
+    signPsbt(psbt: bitcoin.Psbt, opts?: SignPsbtOptions): Promise<bitcoin.Psbt>;
+    getPublicKey(): Promise<string>;
+    signMessage(text: string, type: 'bip322-simple' | 'ecdsa'): Promise<string>;
+    private formatOptionsToSignInputs;
+}