@btc-vision/wallet-sdk 1.0.5 → 1.0.7

package/lib/address/index.d.ts

@@ -0,0 +1,36 @@
+import * as bitcoin from '@btc-vision/bitcoin';
+import { NetworkType } from '../network';
+import { AddressType } from '../types';
+/**
+ * Convert public key to bitcoin payment object.
+ */
+export declare function publicKeyToPayment(publicKey: string, type: AddressType, networkType: NetworkType): bitcoin.P2PKHPayment | bitcoin.P2WPKHPayment | bitcoin.P2TRPayment | bitcoin.P2SHPayment | null | undefined;
+/**
+ * Convert public key to bitcoin address.
+ */
+export declare function publicKeyToAddress(publicKey: string, type: AddressType, networkType: NetworkType): string;
+/**
+ * Convert public key to bitcoin scriptPk.
+ */
+export declare function publicKeyToScriptPk(publicKey: string, type: AddressType, networkType: NetworkType): string | undefined;
+/**
+ * Convert bitcoin address to scriptPk.
+ */
+export declare function addressToScriptPk(address: string, networkType: NetworkType): Buffer<ArrayBufferLike>;
+/**
+ * Check if the address is valid.
+ */
+export declare function isValidAddress(address: string, networkType?: NetworkType): boolean;
+export declare function decodeAddress(address: string): {
+    networkType: NetworkType;
+    addressType: AddressType;
+    dust: number;
+};
+/**
+ * Get address type.
+ */
+export declare function getAddressType(address: string, networkType?: NetworkType): AddressType;
+/**
+ * Convert scriptPk to address.
+ */
+export declare function scriptPkToAddress(scriptPk: string | Buffer, networkType?: NetworkType): string;

package/lib/bitcoin-core.d.ts

@@ -0,0 +1,5 @@
+import * as ecc from '@bitcoinerlab/secp256k1';
+import * as bitcoin from '@btc-vision/bitcoin';
+export declare const ECPair: import("ecpair").ECPairAPI;
+export { ECPairInterface } from 'ecpair';
+export { ecc, bitcoin };

package/lib/constants.d.ts

@@ -0,0 +1 @@
+export declare const UTXO_DUST = 546;

package/lib/error.d.ts

@@ -0,0 +1,20 @@
+export declare enum ErrorCodes {
+    UNKNOWN = -1,
+    INSUFFICIENT_BTC_UTXO = -2,
+    INSUFFICIENT_ASSET_UTXO = -3,
+    NOT_SAFE_UTXOS = -4,
+    ASSET_MAYBE_LOST = -5,
+    ONLY_ONE_ARC20_CAN_BE_SENT = -6
+}
+export declare const ErrorMessages: {
+    [-1]: string;
+    [-2]: string;
+    [-3]: string;
+    [-4]: string;
+    [-5]: string;
+    [-6]: string;
+};
+export declare class WalletUtilsError extends Error {
+    code: ErrorCodes;
+    constructor(code: ErrorCodes, message?: string);
+}

package/lib/index.d.ts

@@ -0,0 +1,14 @@
+export * as address from './address';
+export * as core from './bitcoin-core';
+export * from './constants';
+export * as keyring from './keyring';
+export * as message from './message';
+export * as transaction from './transaction';
+export * as txHelpers from './tx-helpers';
+export * from './types';
+export * as utils from './utils';
+export * as wallet from './wallet';
+export * from './keyring/interfaces/SimpleKeyringOptions';
+export * from './keyring/hd-keyring';
+export * from './keyring/keystone-keyring';
+export * from './keyring/simple-keyring';

package/lib/keyring/hd-keyring.d.ts

@@ -0,0 +1,50 @@
+import bitcore from 'bitcore-lib';
+import { ECPairInterface } from '../bitcoin-core';
+import { DeserializeOption, IKeyringBase } from './interfaces/SimpleKeyringOptions';
+export declare class HdKeyring extends IKeyringBase<DeserializeOption> {
+    static type: string;
+    type: string;
+    mnemonic: string | null;
+    xpriv: string | null;
+    passphrase: string | null;
+    hdPath: string;
+    root: bitcore.HDPrivateKey | null;
+    hdWallet?: any;
+    wallets: ECPairInterface[];
+    activeIndexes: number[];
+    page: number;
+    perPage: number;
+    private _index2wallet;
+    constructor(opts?: DeserializeOption);
+    serialize(): DeserializeOption;
+    deserialize(_opts?: DeserializeOption): void;
+    initFromXpriv(xpriv: string): void;
+    initFromMnemonic(mnemonic: string): void;
+    changeHdPath(hdPath: string): void;
+    getAccountByHdPath(hdPath: string, index: number): string;
+    addAccounts(numberOfAccounts?: number): string[];
+    activeAccounts(indexes: number[]): string[];
+    getFirstPage(): Promise<{
+        address: string;
+        index: number;
+    }[]>;
+    getNextPage(): Promise<{
+        address: string;
+        index: number;
+    }[]>;
+    getPreviousPage(): Promise<{
+        address: string;
+        index: number;
+    }[]>;
+    getAddresses(start: number, end: number): {
+        address: string;
+        index: number;
+    }[];
+    __getPage(increment: number): Promise<{
+        address: string;
+        index: number;
+    }[]>;
+    getAccounts(): string[];
+    getIndexByAddress(address: string): number | null;
+    private _addressFromIndex;
+}

package/lib/keyring/index.d.ts

@@ -0,0 +1,4 @@
+export * from './hd-keyring';
+export * from './keystone-keyring';
+export * from './simple-keyring';
+export * from './interfaces/SimpleKeyringOptions';

package/lib/keyring/interfaces/SimpleKeyringOptions.d.ts

@@ -0,0 +1,52 @@
+import { Network, Psbt } from '@btc-vision/bitcoin';
+import { ECPairInterface } from 'ecpair';
+import { EventEmitter } from 'events';
+interface BaseKeyringOptions {
+    readonly network?: Network;
+}
+export interface SimpleKeyringOptions extends BaseKeyringOptions {
+    readonly privateKeys?: string[];
+}
+export interface DeserializeOptionBase extends BaseKeyringOptions {
+    readonly hdPath?: string;
+    readonly activeIndexes?: number[];
+}
+export interface DeserializeOption extends DeserializeOptionBase {
+    readonly mnemonic?: string | null;
+    readonly xpriv?: string | null;
+    readonly passphrase?: string | null;
+}
+export interface KeystoneKey {
+    readonly path: string;
+    readonly extendedPublicKey: string;
+}
+export interface DeserializeOptionKeystone extends DeserializeOptionBase {
+    readonly mfp: string;
+    readonly keys: KeystoneKey[];
+}
+export type KeyringOptions = SimpleKeyringOptions | DeserializeOption | DeserializeOptionKeystone;
+export declare abstract class IKeyringBase<T extends BaseKeyringOptions> extends EventEmitter {
+    readonly network: Network;
+    static type: string;
+    type: string;
+    protected wallets: ECPairInterface[];
+    protected constructor(network?: Network);
+    abstract serialize(): T;
+    abstract addAccounts(numberOfAccounts: number): string[];
+    abstract deserialize(opts?: T): unknown;
+    removeAccount(publicKey: string): void;
+    verifyMessage(publicKey: string, text: string, sig: string): Promise<boolean>;
+    signData(publicKey: string, data: string, type?: 'ecdsa' | 'schnorr'): string;
+    abstract getAccounts(): string[];
+    signMessage(publicKey: string, message: string | Buffer): string;
+    exportAccount(publicKey: string): string | undefined;
+    signTransaction(psbt: Psbt, inputs: {
+        index: number;
+        publicKey: string;
+        sighashTypes?: number[];
+        disableTweakSigner?: boolean;
+    }[], opts?: any): Psbt;
+    private _getWalletForAccount;
+    private _getPrivateKeyFor;
+}
+export {};

package/lib/keyring/interfaces/SimpleKeyringOptions.js

@@ -33,9 +33,9 @@ export class IKeyringBase extends EventEmitter {
             throw new Error('Not support type');
         }
     }
-    signMessage(publicKey, text) {
+    signMessage(publicKey, message) {
         const keyPair = this._getPrivateKeyFor(publicKey);
-        return signMessageOfDeterministicECDSA(keyPair, text);
+        return signMessageOfDeterministicECDSA(keyPair, message);
     }
     exportAccount(publicKey) {
         const wallet = this._getWalletForAccount(publicKey);

package/lib/keyring/keystone-keyring.d.ts

@@ -0,0 +1,82 @@
+import bitcore from 'bitcore-lib';
+import { DeserializeOptionKeystone, IKeyringBase, KeystoneKey } from './interfaces/SimpleKeyringOptions';
+interface Wallet {
+    index: number;
+    publicKey: string;
+    path: string;
+}
+export declare class KeystoneKeyring extends IKeyringBase<DeserializeOptionKeystone> {
+    static type: string;
+    type: string;
+    mfp: string;
+    keys: KeystoneKey[];
+    hdPath?: string;
+    activeIndexes: number[];
+    root: bitcore.HDPublicKey | undefined;
+    page: number;
+    perPage: number;
+    origin: string;
+    constructor(opts?: DeserializeOptionKeystone);
+    initFromUR(type: string, cbor: string): Promise<void>;
+    getHardenedPath(hdPath: string): string;
+    getHDPublicKey(hdPath: string): bitcore.HDPublicKey;
+    getDefaultHdPath(): string;
+    initRoot(): void;
+    deserialize(opts: DeserializeOptionKeystone): void;
+    serialize(): DeserializeOptionKeystone;
+    addAccounts(numberOfAccounts?: number): string[];
+    addChangeAddressAccounts(numberOfAccounts?: number): Promise<string[]>;
+    getAccounts(): string[];
+    getAccounts2(): Promise<{
+        index: number;
+        path: string;
+        publicKey: string;
+    }[]>;
+    getAccountsWithBrand(): Promise<{
+        address: string;
+        index: number;
+    }[]>;
+    getWalletByIndex(index: number): Wallet;
+    getChangeAddressWalletByIndex(index: number): Wallet;
+    removeAccount(publicKey: string): void;
+    exportAccount(_publicKey: string): string;
+    getFirstPage(): Promise<{
+        address: string;
+        index: number;
+    }[]>;
+    getNextPage(): Promise<{
+        address: string;
+        index: number;
+    }[]>;
+    getPreviousPage(): Promise<{
+        address: string;
+        index: number;
+    }[]>;
+    getAddresses(start: number, end: number): {
+        address: string;
+        index: number;
+    }[];
+    getPage(increment: number): Promise<{
+        address: string;
+        index: number;
+    }[]>;
+    activeAccounts(indexes: number[]): string[];
+    changeHdPath(hdPath: string): void;
+    changeChangeAddressHdPath(hdPath: string): never[];
+    getAccountByHdPath(hdPath: string, index: number): string;
+    getChangeAddressAccountByHdPath(hdPath: string, index: number): string;
+    genSignPsbtUr(psbtHex: string): Promise<{
+        type: string;
+        cbor: string;
+    }>;
+    parseSignPsbtUr(type: string, cbor: string): Promise<string>;
+    genSignMsgUr(publicKey: string, text: string): Promise<{
+        requestId: any;
+        type: string;
+        cbor: string;
+    }>;
+    parseSignMsgUr(type: string, cbor: string): Promise<import("@keystonehq/keystone-sdk").BtcSignature>;
+    signMessage(publicKey: string, message: string | Buffer): string;
+    verifyMessage(publicKey: string, text: string, sig: string): Promise<boolean>;
+}
+export {};

package/lib/keyring/keystone-keyring.js

@@ -309,7 +309,7 @@ export class KeystoneKeyring extends IKeyringBase {
         return keystoneSDK.btc.parseSignature(new UR(Buffer.from(cbor, 'hex'), type));
     }
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    signMessage(publicKey, text) {
+    signMessage(publicKey, message) {
         return 'Signing Message with Keystone should use genSignMsgUr and parseSignMsgUr';
     }
     async verifyMessage(publicKey, text, sig) {

package/lib/keyring/simple-keyring.d.ts

@@ -0,0 +1,11 @@
+import { IKeyringBase, SimpleKeyringOptions } from './interfaces/SimpleKeyringOptions';
+export declare class SimpleKeyring extends IKeyringBase<SimpleKeyringOptions> {
+    static type: string;
+    type: string;
+    constructor(opts?: SimpleKeyringOptions);
+    serialize(): SimpleKeyringOptions;
+    deserialize(opts: SimpleKeyringOptions): void;
+    addAccounts(n?: number): string[];
+    getAccounts(): string[];
+}
+export declare function verifySignData(publicKey: string, hash: string, type: 'ecdsa' | 'schnorr', signature: string): boolean;

package/lib/message/bip322-simple.d.ts

@@ -0,0 +1,19 @@
+import * as bitcoin from '@btc-vision/bitcoin';
+import { NetworkType } from '../network';
+import { AbstractWallet } from '../wallet';
+export declare function genPsbtOfBIP322Simple({ message, address, networkType }: {
+    message: string | Buffer;
+    address: string;
+    networkType: NetworkType;
+}): bitcoin.Psbt;
+export declare function getSignatureFromPsbtOfBIP322Simple(psbt: bitcoin.Psbt): string;
+/**
+ * reference: https://github.com/bitcoin/bips/blob/master/bip-0322.mediawiki
+ */
+export declare function signMessageOfBIP322Simple({ message, address, networkType, wallet }: {
+    message: string | Buffer;
+    address: string;
+    networkType: NetworkType;
+    wallet: AbstractWallet;
+}): Promise<string>;
+export declare function verifyMessageOfBIP322Simple(address: string, msg: string, signature: string, networkType?: NetworkType): boolean;

package/lib/message/bip322-simple.js

@@ -8,7 +8,8 @@ function bip0322_hash(message) {
     const { sha256 } = bitcoin.crypto;
     const tag = 'BIP0322-signed-message';
     const tagHash = sha256(Buffer.from(tag));
-    const result = sha256(Buffer.concat([tagHash, tagHash, Buffer.from(message)]));
+    const messageBuffer = typeof message === 'string' ? Buffer.from(message, 'utf8') : message;
+    const result = sha256(Buffer.concat([tagHash, tagHash, messageBuffer]));
     return result.toString('hex');
 }
 export function genPsbtOfBIP322Simple({ message, address, networkType }) {
@@ -43,9 +44,11 @@ export function genPsbtOfBIP322Simple({ message, address, networkType }) {
 export function getSignatureFromPsbtOfBIP322Simple(psbt) {
     const txToSign = psbt.extractTransaction();
     function encodeVarString(b) {
-        return Buffer.concat([encode(b.byteLength), b]);
+        const { buffer: vb } = encode(b.length);
+        return Buffer.concat([Buffer.from(vb), b]);
     }
-    const len = encode(txToSign.ins[0].witness.length).buffer;
+    const { buffer: varintBuf } = encode(txToSign.ins[0].witness.length);
+    const len = Buffer.from(varintBuf);
     const result = Buffer.concat([len, ...txToSign.ins[0].witness.map((w) => encodeVarString(w))]);
     const signature = result.toString('base64');
     return signature;

package/lib/message/deterministic-ecdsa.d.ts

@@ -0,0 +1,2 @@
+import { ECPairInterface } from '../bitcoin-core';
+export declare function signMessageOfDeterministicECDSA(ecpair: ECPairInterface, message: string | Buffer): string;

package/lib/message/deterministic-ecdsa.js

@@ -30,7 +30,7 @@ function varintBufNum(n) {
 }
 function magicHash(message) {
     const prefix1 = varintBufNum(MAGIC_BYTES.length);
-    const messageBuffer = Buffer.from(message);
+    const messageBuffer = typeof message === 'string' ? Buffer.from(message) : message;
     const prefix2 = varintBufNum(messageBuffer.length);
     const buf = Buffer.concat([prefix1, MAGIC_BYTES, prefix2, messageBuffer]);
     return bitcoin.crypto.hash256(buf);

package/lib/message/ecdsa.d.ts

@@ -0,0 +1,3 @@
+import { ECPairInterface } from 'ecpair';
+export declare function signMessageOfECDSA(privateKey: ECPairInterface, text: string): string;
+export declare function verifyMessageOfECDSA(publicKey: string, text: string, sig: string): boolean;

package/lib/message/index.d.ts

@@ -0,0 +1,3 @@
+export * from './bip322-simple';
+export * from './deterministic-ecdsa';
+export * from './ecdsa';

package/lib/network/index.d.ts

@@ -0,0 +1,14 @@
+import { bitcoin } from '../bitcoin-core';
+export declare enum NetworkType {
+    MAINNET = 0,
+    TESTNET = 1,
+    REGTEST = 2
+}
+/**
+ * Convert network type to @btc-vision/bitcoin network.
+ */
+export declare function toPsbtNetwork(networkType: NetworkType): bitcoin.networks.Network;
+/**
+ * Convert @btc-vision/bitcoin network to network type.
+ */
+export declare function toNetworkType(network: bitcoin.Network): NetworkType;

package/lib/runes/index.d.ts

@@ -0,0 +1 @@
+export * from './varint';

package/lib/runes/rund_id.d.ts

@@ -0,0 +1,11 @@
+export declare class RuneId {
+    block: number;
+    tx: number;
+    constructor({ block, tx }: {
+        block: number;
+        tx: number;
+    });
+    static fromBigInt(n: any): RuneId;
+    static fromString(s: string): RuneId;
+    toString(): string;
+}

package/lib/runes/varint.d.ts

@@ -0,0 +1,14 @@
+declare function try_decode(buf: any): (string | number)[];
+declare function encodeToVec(n: any, v: any): void;
+declare function decode(buffer: any): {
+    num: string | number;
+    index: string | number;
+};
+declare function encode(n: any): Buffer<ArrayBuffer>;
+export declare const varint: {
+    encode: typeof encode;
+    decode: typeof decode;
+    try_decode: typeof try_decode;
+    encodeToVec: typeof encodeToVec;
+};
+export {};

package/lib/transaction/index.d.ts

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

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);
+    /**
+     * 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;
+    private split;
+}

package/lib/transaction/transaction.d.ts

@@ -0,0 +1,51 @@
+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 {
+    outputs: TxOutput[];
+    changedAddress: string;
+    private utxos;
+    private inputs;
+    private changeOutputIndex;
+    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>;
+    addSufficientUtxosForFee(btcUtxos: UnspentOutput[], forceAsFee?: boolean): Promise<ToSignInput[]>;
+    dumpTx(psbt: any): Promise<void>;
+    private selectBtcUtxos;
+}
+export {};

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/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/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("@btc-vision/bitcoin").Psbt;
+    toSignInputs: ToSignInput[];
+}>;

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("@btc-vision/bitcoin").Psbt;
+    toSignInputs: ToSignInput[];
+}>;

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("@btc-vision/bitcoin").Psbt;
+    toSignInputs: ToSignInput[];
+}>;
+export declare function sendAllBTC(params: {
+    btcUtxos: UnspentOutput[];
+    toAddress: string;
+    networkType: NetworkType;
+    feeRate: number;
+    enableRBF?: boolean;
+}): Promise<{
+    psbt: import("@btc-vision/bitcoin").Psbt;
+    toSignInputs: ToSignInput[];
+}>;

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("@btc-vision/bitcoin").Psbt;
+    toSignInputs: import("../types").ToSignInput[];
+}>;

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("@btc-vision/bitcoin").Psbt;
+    toSignInputs: ToSignInput[];
+}>;

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/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("@btc-vision/bitcoin").Psbt;
+    toSignInputs: ToSignInput[];
+    splitedCount: number;
+}>;

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,// deprecated
+    M44_P2TR = 5,// deprecated
+    P2WSH = 6,
+    P2SH = 7,
+    UNKNOWN = 8
+}
+export {};

package/lib/utils.d.ts

@@ -0,0 +1,23 @@
+import { bitcoin } from './bitcoin-core';
+export declare const toXOnly: (pubKey: Buffer) => Buffer<ArrayBufferLike>;
+/**
+ * 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/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(message: string | Buffer, type: 'bip322-simple' | 'ecdsa'): Promise<string>;
+}

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(message: string | Buffer, type: 'bip322-simple' | 'ecdsa'): Promise<string>;
+    private formatOptionsToSignInputs;
+}

package/lib/wallet/estimate-wallet.js

@@ -76,10 +76,10 @@ export class EstimateWallet {
         const pubkeys = await this.keyring.getAccounts();
         return pubkeys[0];
     }
-    async signMessage(text, type) {
+    async signMessage(message, type) {
         if (type === 'bip322-simple') {
             return await signMessageOfBIP322Simple({
-                message: text,
+                message,
                 address: this.address,
                 networkType: this.networkType,
                 wallet: this
@@ -87,7 +87,7 @@ export class EstimateWallet {
         }
         else {
             const pubkey = await this.getPublicKey();
-            return await this.keyring.signMessage(pubkey, text);
+            return this.keyring.signMessage(pubkey, message);
         }
     }
     async formatOptionsToSignInputs(_psbt, options) {

package/lib/wallet/index.d.ts

@@ -0,0 +1,3 @@
+export * from './abstract-wallet';
+export * from './estimate-wallet';
+export * from './local-wallet';

package/lib/wallet/local-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';
+export declare class LocalWallet implements AbstractWallet {
+    keyring: SimpleKeyring;
+    address: string;
+    pubkey: string;
+    network: bitcoin.Network;
+    addressType: AddressType;
+    networkType: NetworkType;
+    scriptPk: string | undefined;
+    constructor(wif: string, addressType?: AddressType, networkType?: NetworkType);
+    static fromMnemonic(addressType: AddressType, networkType: NetworkType, mnemonic: string, passPhrase?: string, hdPath?: string): LocalWallet;
+    static fromRandom(addressType?: AddressType, networkType?: NetworkType): LocalWallet;
+    getNetworkType(): NetworkType;
+    signPsbt(psbt: bitcoin.Psbt, opts?: SignPsbtOptions): Promise<bitcoin.Psbt>;
+    getPublicKey(): string;
+    signMessage(message: string | Buffer, type: 'bip322-simple' | 'ecdsa'): Promise<string>;
+    signData(data: string, type?: 'ecdsa' | 'schnorr'): Promise<string>;
+    private formatOptionsToSignInputs;
+}

package/lib/wallet/local-wallet.js

@@ -82,10 +82,10 @@ export class LocalWallet {
         const pubkeys = this.keyring.getAccounts();
         return pubkeys[0];
     }
-    async signMessage(text, type) {
+    async signMessage(message, type) {
         if (type === 'bip322-simple') {
             return await signMessageOfBIP322Simple({
-                message: text,
+                message,
                 address: this.address,
                 networkType: this.networkType,
                 wallet: this
@@ -93,7 +93,7 @@ export class LocalWallet {
         }
         else {
             const pubkey = this.getPublicKey();
-            return this.keyring.signMessage(pubkey, text);
+            return this.keyring.signMessage(pubkey, message);
         }
     }
     async signData(data, type = 'ecdsa') {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@btc-vision/wallet-sdk",
-    "version": "1.0.5",
+    "version": "1.0.7",
     "description": "OP_WALLET SDK",
     "keywords": [
         "bitcoin",