@btc-vision/wallet-sdk 1.0.0

package/lib/test/tx-helpers/utils.d.ts

@@ -0,0 +1,217 @@
+import { AddressType, UnspentOutput } from '../../src/types';
+import { LocalWallet } from '../../src/wallet';
+/**
+ * generate dummy utxos
+ */
+export declare function genDummyUtxos(wallet: LocalWallet, satoshisArray: number[], assetsArray?: {
+    inscriptions?: {
+        inscriptionId: string;
+        offset: number;
+    }[];
+    atomicals?: {
+        atomicalId: string;
+        atomicalNumber: number;
+        type: 'NFT' | 'FT';
+        ticker?: string;
+        atomicalValue: number;
+    }[];
+}[]): UnspentOutput[];
+/**
+ * generate a dummy utxo
+ */
+export declare function genDummyUtxo(wallet: LocalWallet, satoshis: number, assets?: {
+    inscriptions?: {
+        inscriptionId: string;
+        offset: number;
+    }[];
+    atomicals?: {
+        atomicalId: string;
+        atomicalNumber: number;
+        type: 'NFT' | 'FT';
+        ticker?: string;
+        atomicalValue?: number;
+    }[];
+    runes?: {
+        runeid: string;
+        amount: string;
+    }[];
+}, txid?: string, vout?: number): UnspentOutput;
+/**
+ * generate a dummy atomical ft
+ */
+export declare function genDummyAtomicalsFT(ticker: string, atomicalValue: number): {
+    atomicalId: string;
+    atomicalNumber: number;
+    type: 'NFT' | 'FT';
+    ticker: string;
+    atomicalValue: number;
+};
+/**
+ * generate a dummy atomical nft
+ */
+export declare function genDummyAtomicalsNFT(): {
+    atomicalId: string;
+    atomicalNumber: number;
+    type: 'NFT' | 'FT';
+};
+/**
+ * For P2PKH, the signature length is not fixed, so we need to handle it specially
+ */
+export declare function expectFeeRate(addressType: AddressType, feeRateA: number, feeRateB: number): void;
+/**
+ * create a dummy send btc psbt for test
+ */
+export declare function dummySendBTC({ wallet, btcUtxos, tos, feeRate, dump, enableRBF, memo, memos }: {
+    wallet: LocalWallet;
+    btcUtxos: UnspentOutput[];
+    tos: {
+        address: string;
+        satoshis: number;
+    }[];
+    feeRate: number;
+    dump?: boolean;
+    enableRBF?: boolean;
+    memo?: string;
+    memos?: string[];
+}): Promise<{
+    psbt: import("bitcoinjs-lib").Psbt;
+    txid: string;
+    inputCount: number;
+    outputCount: number;
+    feeRate: number;
+}>;
+/**
+ * create a dummy send all btc psbt for test
+ */
+export declare function dummySendAllBTC({ wallet, btcUtxos, toAddress, feeRate, dump, enableRBF }: {
+    wallet: LocalWallet;
+    btcUtxos: UnspentOutput[];
+    toAddress: string;
+    feeRate: number;
+    dump?: boolean;
+    enableRBF?: boolean;
+}): Promise<{
+    psbt: import("bitcoinjs-lib").Psbt;
+    txid: string;
+    inputCount: number;
+    outputCount: number;
+    feeRate: number;
+}>;
+/**
+ * create a dummy send inscription psbt for test
+ */
+export declare function dummySendInscription({ assetWallet, assetUtxo, btcWallet, btcUtxos, feeRate, toAddress, outputValue, dump, enableRBF, enableMixed }: {
+    assetWallet: LocalWallet;
+    assetUtxo: UnspentOutput;
+    btcWallet: LocalWallet;
+    btcUtxos: UnspentOutput[];
+    outputValue: number;
+    feeRate: number;
+    toAddress: string;
+    dump?: boolean;
+    enableRBF?: boolean;
+    enableMixed?: boolean;
+}): Promise<{
+    psbt: import("bitcoinjs-lib").Psbt;
+    txid: string;
+    inputCount: number;
+    outputCount: number;
+    feeRate: number;
+}>;
+/**
+ * create a dummy send inscriptions psbt for test
+ */
+export declare function dummySendInscriptions({ assetWallet, assetUtxos, btcWallet, btcUtxos, feeRate, toAddress, dump, enableRBF }: {
+    assetWallet: LocalWallet;
+    assetUtxos: UnspentOutput[];
+    btcWallet: LocalWallet;
+    btcUtxos: UnspentOutput[];
+    feeRate: number;
+    toAddress: string;
+    dump?: boolean;
+    enableRBF?: boolean;
+}): Promise<{
+    psbt: import("bitcoinjs-lib").Psbt;
+    txid: string;
+    inputCount: number;
+    outputCount: number;
+    feeRate: number;
+}>;
+/**
+ * create a dummy split inscription psbt for test
+ */
+export declare function dummySplitOrdUtxo({ assetWallet, assetUtxo, btcWallet, btcUtxos, feeRate, outputValue, dump, enableRBF }: {
+    assetWallet: LocalWallet;
+    assetUtxo: UnspentOutput;
+    btcWallet: LocalWallet;
+    btcUtxos: UnspentOutput[];
+    outputValue?: number;
+    feeRate: number;
+    dump?: boolean;
+    enableRBF?: boolean;
+}): Promise<{
+    psbt: import("bitcoinjs-lib").Psbt;
+    txid: string;
+    inputCount: number;
+    outputCount: number;
+    feeRate: number;
+    splitedCount: number;
+}>;
+/**
+ * create a dummy send atomical ft psbt for test
+ */
+export declare function dummySendAtomicalsFT({ assetWallet, assetUtxo, btcWallet, btcUtxos, feeRate, toAddress, dump, enableRBF, sendAmount }: {
+    assetWallet: LocalWallet;
+    assetUtxo: UnspentOutput;
+    btcWallet: LocalWallet;
+    btcUtxos: UnspentOutput[];
+    feeRate: number;
+    toAddress: string;
+    dump?: boolean;
+    enableRBF?: boolean;
+    sendAmount: number;
+}): Promise<{
+    psbt: import("bitcoinjs-lib").Psbt;
+    txid: string;
+    inputCount: number;
+    outputCount: number;
+    feeRate: number;
+}>;
+/**
+ * create a dummy send atomical nft psbt for test
+ */
+export declare function dummySendAtomical({ assetWallet, assetUtxo, btcWallet, btcUtxos, feeRate, toAddress, dump, enableRBF }: {
+    assetWallet: LocalWallet;
+    assetUtxo: UnspentOutput;
+    btcWallet: LocalWallet;
+    btcUtxos: UnspentOutput[];
+    feeRate: number;
+    toAddress: string;
+    dump?: boolean;
+    enableRBF?: boolean;
+}): Promise<{
+    psbt: import("bitcoinjs-lib").Psbt;
+    txid: string;
+    inputCount: number;
+    outputCount: number;
+    feeRate: number;
+}>;
+export declare function dummySendRunes({ assetWallet, assetUtxo, btcWallet, btcUtxos, feeRate, toAddress, dump, enableRBF, runeid, runeAmount, outputValue }: {
+    assetWallet: LocalWallet;
+    assetUtxo: UnspentOutput;
+    btcWallet: LocalWallet;
+    btcUtxos: UnspentOutput[];
+    feeRate: number;
+    toAddress: string;
+    dump?: boolean;
+    enableRBF?: boolean;
+    runeid: string;
+    runeAmount: string;
+    outputValue: number;
+}): Promise<{
+    psbt: import("bitcoinjs-lib").Psbt;
+    txid: string;
+    inputCount: number;
+    outputCount: number;
+    feeRate: number;
+}>;

package/lib/test/utils.d.ts

@@ -0,0 +1,4 @@
+export declare function expectThrowError(func: any, errorMsg: any): Promise<void>;
+import { bitcoin } from '../src/bitcoin-core';
+export declare function printTx(rawtx: string): void;
+export declare function printPsbt(psbtData: string | bitcoin.Psbt): void;

package/lib/test/wallet/local-wallet.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/transaction/index.d.ts

@@ -0,0 +1,3 @@
+export * from './inscription-utxo';
+export * from './transaction';
+export * from './utxo';

package/lib/transaction/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./inscription-utxo"), exports);
+__exportStar(require("./transaction"), exports);
+__exportStar(require("./utxo"), exports);

package/lib/transaction/inscription-utxo.d.ts

@@ -0,0 +1,33 @@
+import { UnspentOutput } from '../types';
+export declare class InscriptionUnit {
+    satoshis: number;
+    inscriptions: {
+        id: string;
+        outputOffset: number;
+        unitOffset: number;
+    }[];
+    constructor(satoshis: number, inscriptions: {
+        id: string;
+        outputOffset: number;
+        unitOffset: number;
+    }[]);
+    hasInscriptions(): boolean;
+}
+export declare class InscriptionUnspendOutput {
+    inscriptionUnits: InscriptionUnit[];
+    utxo: UnspentOutput;
+    constructor(utxo: UnspentOutput, outputValue?: number);
+    private split;
+    /**
+     * Get non-Ord satoshis for spending
+     */
+    getNonInscriptionSatoshis(): number;
+    /**
+     * Get last non-ord satoshis for spending.
+     * Only the last one is available
+     * @returns
+     */
+    getLastUnitSatoshis(): number;
+    hasInscriptions(): boolean;
+    dump(): void;
+}

package/lib/transaction/inscription-utxo.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InscriptionUnspendOutput = exports.InscriptionUnit = void 0;
+const constants_1 = require("../constants");
+class InscriptionUnit {
+    constructor(satoshis, inscriptions) {
+        this.satoshis = satoshis;
+        this.inscriptions = inscriptions;
+    }
+    hasInscriptions() {
+        return this.inscriptions.length > 0;
+    }
+}
+exports.InscriptionUnit = InscriptionUnit;
+class InscriptionUnspendOutput {
+    constructor(utxo, outputValue) {
+        this.utxo = utxo;
+        this.split(utxo.satoshis, utxo.inscriptions, outputValue);
+    }
+    // split the UTXO to units
+    split(satoshis, inscriptions, splitOutputValue = constants_1.UTXO_DUST) {
+        const inscriptionUnits = [];
+        let leftAmount = satoshis;
+        for (let i = 0; i < inscriptions.length; i++) {
+            const id = inscriptions[i].inscriptionId;
+            const offset = inscriptions[i].offset;
+            const usedSatoshis = satoshis - leftAmount;
+            const curOffset = offset - usedSatoshis;
+            if (curOffset < 0 || leftAmount < splitOutputValue) {
+                if (inscriptionUnits.length == 0) {
+                    inscriptionUnits.push(new InscriptionUnit(leftAmount, [
+                        {
+                            id: id,
+                            outputOffset: offset,
+                            unitOffset: curOffset
+                        }
+                    ]));
+                    leftAmount = 0;
+                }
+                else {
+                    // injected to previous
+                    const preUnit = inscriptionUnits[inscriptionUnits.length - 1];
+                    preUnit.inscriptions.push({
+                        id,
+                        outputOffset: offset,
+                        unitOffset: preUnit.satoshis + curOffset
+                    });
+                    continue;
+                }
+            }
+            if (leftAmount >= curOffset) {
+                if (leftAmount > splitOutputValue * 2) {
+                    if (curOffset >= splitOutputValue) {
+                        inscriptionUnits.push(new InscriptionUnit(curOffset, []));
+                        inscriptionUnits.push(new InscriptionUnit(splitOutputValue, [
+                            {
+                                id,
+                                outputOffset: offset,
+                                unitOffset: 0
+                            }
+                        ]));
+                    }
+                    else {
+                        inscriptionUnits.push(new InscriptionUnit(curOffset + splitOutputValue, [
+                            {
+                                id,
+                                outputOffset: offset,
+                                unitOffset: curOffset
+                            }
+                        ]));
+                    }
+                }
+                else {
+                    inscriptionUnits.push(new InscriptionUnit(curOffset + splitOutputValue, [{ id, outputOffset: offset, unitOffset: curOffset }]));
+                }
+            }
+            leftAmount -= curOffset + splitOutputValue;
+        }
+        if (leftAmount > constants_1.UTXO_DUST) {
+            inscriptionUnits.push(new InscriptionUnit(leftAmount, []));
+        }
+        else if (leftAmount > 0) {
+            if (inscriptionUnits.length > 0) {
+                inscriptionUnits[inscriptionUnits.length - 1].satoshis += leftAmount;
+            }
+            else {
+                inscriptionUnits.push(new InscriptionUnit(leftAmount, []));
+            }
+        }
+        this.inscriptionUnits = inscriptionUnits;
+    }
+    /**
+     * Get non-Ord satoshis for spending
+     */
+    getNonInscriptionSatoshis() {
+        return this.inscriptionUnits.filter((v) => v.inscriptions.length == 0).reduce((pre, cur) => pre + cur.satoshis, 0);
+    }
+    /**
+     * Get last non-ord satoshis for spending.
+     * Only the last one is available
+     * @returns
+     */
+    getLastUnitSatoshis() {
+        const last = this.inscriptionUnits[this.inscriptionUnits.length - 1];
+        if (last.inscriptions.length == 0) {
+            return last.satoshis;
+        }
+        return 0;
+    }
+    hasInscriptions() {
+        return this.utxo.inscriptions.length > 0;
+    }
+    // print each units
+    dump() {
+        this.inscriptionUnits.forEach((v) => {
+            console.log('satoshis:', v.satoshis, 'inscriptions:', v.inscriptions);
+        });
+    }
+}
+exports.InscriptionUnspendOutput = InscriptionUnspendOutput;

package/lib/transaction/transaction.d.ts

@@ -0,0 +1,52 @@
+/// <reference types="node" />
+import { bitcoin } from '../bitcoin-core';
+import { NetworkType } from '../network';
+import { ToSignInput, UnspentOutput } from '../types';
+interface TxOutput {
+    address?: string;
+    script?: Buffer;
+    value: number;
+}
+/**
+ * Transaction
+ */
+export declare class Transaction {
+    private utxos;
+    private inputs;
+    outputs: TxOutput[];
+    private changeOutputIndex;
+    changedAddress: string;
+    private networkType;
+    private feeRate;
+    private enableRBF;
+    private _cacheNetworkFee;
+    private _cacheBtcUtxos;
+    private _cacheToSignInputs;
+    constructor();
+    setNetworkType(network: NetworkType): void;
+    setEnableRBF(enable: boolean): void;
+    setFeeRate(feeRate: number): void;
+    setChangeAddress(address: string): void;
+    addInput(utxo: UnspentOutput): void;
+    removeLastInput(): void;
+    getTotalInput(): number;
+    getTotalOutput(): number;
+    getUnspent(): number;
+    calNetworkFee(): Promise<number>;
+    addOutput(address: string, value: number): void;
+    addOpreturn(data: Buffer[]): void;
+    addScriptOutput(script: Buffer, value: number): void;
+    getOutput(index: number): TxOutput;
+    addChangeOutput(value: number): void;
+    getChangeOutput(): TxOutput;
+    getChangeAmount(): number;
+    removeChangeOutput(): void;
+    removeRecentOutputs(count: number): void;
+    toPsbt(): bitcoin.Psbt;
+    clone(): Transaction;
+    createEstimatePsbt(): Promise<bitcoin.Psbt>;
+    private selectBtcUtxos;
+    addSufficientUtxosForFee(btcUtxos: UnspentOutput[], forceAsFee?: boolean): Promise<ToSignInput[]>;
+    dumpTx(psbt: any): Promise<void>;
+}
+export {};