@btc-vision/wallet-sdk 1.0.0

package/es/bundle.js.LICENSE.txt

@@ -0,0 +1,48 @@
+/*!
+   *  decimal.js v10.4.3
+   *  An arbitrary-precision Decimal type for JavaScript.
+   *  https://github.com/MikeMcl/decimal.js
+   *  Copyright (c) 2022 Michael Mclaughlin <M8ch88l@gmail.com>
+   *  MIT Licence
+   */
+
+/*!
+ * The buffer module from node.js, for the browser.
+ *
+ * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
+ * @license  MIT
+ */
+
+/*!
+ * The buffer module from node.js, for the browser.
+ *
+ * @author   Feross Aboukhadijeh <https://feross.org>
+ * @license  MIT
+ */
+
+/*! https://mths.be/punycode v1.4.1 by @mathias */
+
+/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
+
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+
+/*! noble-secp256k1 - MIT License (c) 2019 Paul Miller (paulmillr.com) */
+
+/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
+
+/**
+ * @license
+ * Lodash <https://lodash.com/>
+ * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
+ * Released under MIT license <https://lodash.com/license>
+ * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+ * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ */
+
+//! The internal pubkey (x-only, so no Y coordinate parity).
+
+//! The output pubkey (taken from the scriptPubKey).
+
+//!< Taproot only; implied when sighash byte is missing, and equivalent to SIGHASH_ALL

package/lib/address/index.d.ts

@@ -0,0 +1,37 @@
+/// <reference types="node" />
+import { NetworkType } from '../network';
+import { AddressType } from '../types';
+import * as bitcoin from 'bitcoinjs-lib';
+/**
+ * Convert public key to bitcoin payment object.
+ */
+export declare function publicKeyToPayment(publicKey: string, type: AddressType, networkType: NetworkType): bitcoin.payments.Payment;
+/**
+ * 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;
+/**
+ * Convert bitcoin address to scriptPk.
+ */
+export declare function addressToScriptPk(address: string, networkType: NetworkType): Buffer;
+/**
+ * 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/address/index.js

@@ -0,0 +1,235 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scriptPkToAddress = exports.getAddressType = exports.decodeAddress = exports.isValidAddress = exports.addressToScriptPk = exports.publicKeyToScriptPk = exports.publicKeyToAddress = exports.publicKeyToPayment = void 0;
+const network_1 = require("../network");
+const types_1 = require("../types");
+const bitcoin = __importStar(require("bitcoinjs-lib"));
+const bitcoinjs_lib_1 = require("bitcoinjs-lib");
+/**
+ * Convert public key to bitcoin payment object.
+ */
+function publicKeyToPayment(publicKey, type, networkType) {
+    const network = (0, network_1.toPsbtNetwork)(networkType);
+    if (!publicKey)
+        return null;
+    const pubkey = Buffer.from(publicKey, 'hex');
+    if (type === types_1.AddressType.P2PKH) {
+        return bitcoinjs_lib_1.payments.p2pkh({
+            pubkey,
+            network
+        });
+    }
+    else if (type === types_1.AddressType.P2WPKH || type === types_1.AddressType.M44_P2WPKH) {
+        return bitcoinjs_lib_1.payments.p2wpkh({
+            pubkey,
+            network
+        });
+    }
+    else if (type === types_1.AddressType.P2TR || type === types_1.AddressType.M44_P2TR) {
+        return bitcoinjs_lib_1.payments.p2tr({
+            internalPubkey: pubkey.slice(1, 33),
+            network
+        });
+    }
+    else if (type === types_1.AddressType.P2SH_P2WPKH) {
+        const data = bitcoinjs_lib_1.payments.p2wpkh({
+            pubkey,
+            network
+        });
+        return bitcoinjs_lib_1.payments.p2sh({
+            pubkey,
+            network,
+            redeem: data
+        });
+    }
+}
+exports.publicKeyToPayment = publicKeyToPayment;
+/**
+ * Convert public key to bitcoin address.
+ */
+function publicKeyToAddress(publicKey, type, networkType) {
+    const payment = publicKeyToPayment(publicKey, type, networkType);
+    if (payment && payment.address) {
+        return payment.address;
+    }
+    else {
+        return '';
+    }
+}
+exports.publicKeyToAddress = publicKeyToAddress;
+/**
+ * Convert public key to bitcoin scriptPk.
+ */
+function publicKeyToScriptPk(publicKey, type, networkType) {
+    const payment = publicKeyToPayment(publicKey, type, networkType);
+    return payment.output.toString('hex');
+}
+exports.publicKeyToScriptPk = publicKeyToScriptPk;
+/**
+ * Convert bitcoin address to scriptPk.
+ */
+function addressToScriptPk(address, networkType) {
+    const network = (0, network_1.toPsbtNetwork)(networkType);
+    return bitcoin.address.toOutputScript(address, network);
+}
+exports.addressToScriptPk = addressToScriptPk;
+/**
+ * Check if the address is valid.
+ */
+function isValidAddress(address, networkType = network_1.NetworkType.MAINNET) {
+    let error;
+    try {
+        bitcoin.address.toOutputScript(address, (0, network_1.toPsbtNetwork)(networkType));
+    }
+    catch (e) {
+        error = e;
+    }
+    if (error) {
+        return false;
+    }
+    else {
+        return true;
+    }
+}
+exports.isValidAddress = isValidAddress;
+function decodeAddress(address) {
+    const mainnet = bitcoin.networks.bitcoin;
+    const testnet = bitcoin.networks.testnet;
+    const regtest = bitcoin.networks.regtest;
+    let decodeBase58;
+    let decodeBech32;
+    let networkType;
+    let addressType;
+    if (address.startsWith('bc1') || address.startsWith('tb1') || address.startsWith('bcrt1')) {
+        try {
+            decodeBech32 = bitcoin.address.fromBech32(address);
+            if (decodeBech32.prefix === mainnet.bech32) {
+                networkType = network_1.NetworkType.MAINNET;
+            }
+            else if (decodeBech32.prefix === testnet.bech32) {
+                networkType = network_1.NetworkType.TESTNET;
+            }
+            else if (decodeBech32.prefix === regtest.bech32) {
+                networkType = network_1.NetworkType.REGTEST;
+            }
+            if (decodeBech32.version === 0) {
+                if (decodeBech32.data.length === 20) {
+                    addressType = types_1.AddressType.P2WPKH;
+                }
+                else if (decodeBech32.data.length === 32) {
+                    addressType = types_1.AddressType.P2WSH;
+                }
+            }
+            else if (decodeBech32.version === 1) {
+                if (decodeBech32.data.length === 32) {
+                    addressType = types_1.AddressType.P2TR;
+                }
+            }
+            return {
+                networkType,
+                addressType,
+                dust: getAddressTypeDust(addressType)
+            };
+        }
+        catch (e) { }
+    }
+    else {
+        try {
+            decodeBase58 = bitcoin.address.fromBase58Check(address);
+            if (decodeBase58.version === mainnet.pubKeyHash) {
+                networkType = network_1.NetworkType.MAINNET;
+                addressType = types_1.AddressType.P2PKH;
+            }
+            else if (decodeBase58.version === testnet.pubKeyHash) {
+                networkType = network_1.NetworkType.TESTNET;
+                addressType = types_1.AddressType.P2PKH;
+            }
+            else if (decodeBase58.version === regtest.pubKeyHash) {
+                // do not work
+                networkType = network_1.NetworkType.REGTEST;
+                addressType = types_1.AddressType.P2PKH;
+            }
+            else if (decodeBase58.version === mainnet.scriptHash) {
+                networkType = network_1.NetworkType.MAINNET;
+                addressType = types_1.AddressType.P2SH_P2WPKH;
+            }
+            else if (decodeBase58.version === testnet.scriptHash) {
+                networkType = network_1.NetworkType.TESTNET;
+                addressType = types_1.AddressType.P2SH_P2WPKH;
+            }
+            else if (decodeBase58.version === regtest.scriptHash) {
+                // do not work
+                networkType = network_1.NetworkType.REGTEST;
+                addressType = types_1.AddressType.P2SH_P2WPKH;
+            }
+            return {
+                networkType,
+                addressType,
+                dust: getAddressTypeDust(addressType)
+            };
+        }
+        catch (e) { }
+    }
+    return {
+        networkType: network_1.NetworkType.MAINNET,
+        addressType: types_1.AddressType.UNKNOWN,
+        dust: 546
+    };
+}
+exports.decodeAddress = decodeAddress;
+function getAddressTypeDust(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;
+    }
+}
+/**
+ * Get address type.
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function getAddressType(address, networkType = network_1.NetworkType.MAINNET) {
+    return decodeAddress(address).addressType;
+}
+exports.getAddressType = getAddressType;
+/**
+ * Convert scriptPk to address.
+ */
+function scriptPkToAddress(scriptPk, networkType = network_1.NetworkType.MAINNET) {
+    const network = (0, network_1.toPsbtNetwork)(networkType);
+    try {
+        const address = bitcoin.address.fromOutputScript(typeof scriptPk === 'string' ? Buffer.from(scriptPk, 'hex') : scriptPk, network);
+        return address;
+    }
+    catch (e) {
+        return '';
+    }
+}
+exports.scriptPkToAddress = scriptPkToAddress;

package/lib/bitcoin-core.d.ts

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

package/lib/bitcoin-core.js

@@ -0,0 +1,37 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bitcoin = exports.ecc = exports.ECPair = void 0;
+const ecpair_1 = __importDefault(require("ecpair"));
+const ecc = __importStar(require("@bitcoinerlab/secp256k1"));
+exports.ecc = ecc;
+const bitcoin = __importStar(require("bitcoinjs-lib"));
+exports.bitcoin = bitcoin;
+const bitcoinjs_lib_1 = require("bitcoinjs-lib");
+(0, bitcoinjs_lib_1.initEccLib)(ecc);
+exports.ECPair = (0, ecpair_1.default)(ecc);

package/lib/constants.d.ts

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

package/lib/constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UTXO_DUST = void 0;
+// Default UTXO_DUST, this is usually sufficient, but for more precise cases, please use the getAddressUtxoDust method to obtain
+exports.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/error.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletUtilsError = exports.ErrorMessages = exports.ErrorCodes = void 0;
+var ErrorCodes;
+(function (ErrorCodes) {
+    ErrorCodes[ErrorCodes["UNKNOWN"] = -1] = "UNKNOWN";
+    ErrorCodes[ErrorCodes["INSUFFICIENT_BTC_UTXO"] = -2] = "INSUFFICIENT_BTC_UTXO";
+    ErrorCodes[ErrorCodes["INSUFFICIENT_ASSET_UTXO"] = -3] = "INSUFFICIENT_ASSET_UTXO";
+    ErrorCodes[ErrorCodes["NOT_SAFE_UTXOS"] = -4] = "NOT_SAFE_UTXOS";
+    ErrorCodes[ErrorCodes["ASSET_MAYBE_LOST"] = -5] = "ASSET_MAYBE_LOST";
+    ErrorCodes[ErrorCodes["ONLY_ONE_ARC20_CAN_BE_SENT"] = -6] = "ONLY_ONE_ARC20_CAN_BE_SENT";
+})(ErrorCodes = exports.ErrorCodes || (exports.ErrorCodes = {}));
+exports.ErrorMessages = {
+    [ErrorCodes.UNKNOWN]: 'Unknown error',
+    [ErrorCodes.INSUFFICIENT_BTC_UTXO]: 'Insufficient btc utxo',
+    [ErrorCodes.INSUFFICIENT_ASSET_UTXO]: 'Insufficient asset utxo',
+    [ErrorCodes.NOT_SAFE_UTXOS]: 'Not safe utxos',
+    [ErrorCodes.ASSET_MAYBE_LOST]: 'Asset maybe lost',
+    [ErrorCodes.ONLY_ONE_ARC20_CAN_BE_SENT]: 'Only one arc20 can be sent'
+};
+class WalletUtilsError extends Error {
+    constructor(code, message = exports.ErrorMessages[code] || 'Unknown error') {
+        super(message);
+        this.code = ErrorCodes.UNKNOWN;
+        this.code = code;
+        Object.setPrototypeOf(this, WalletUtilsError.prototype);
+    }
+}
+exports.WalletUtilsError = WalletUtilsError;

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/index.js

@@ -0,0 +1,50 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 });
+exports.wallet = exports.utils = exports.txHelpers = exports.transaction = exports.message = exports.keyring = exports.core = exports.address = void 0;
+Object.defineProperty(global, '_bitcore', {
+    get() {
+        return undefined;
+    },
+    set() { }
+});
+exports.address = __importStar(require("./address"));
+exports.core = __importStar(require("./bitcoin-core"));
+__exportStar(require("./constants"), exports);
+exports.keyring = __importStar(require("./keyring"));
+exports.message = __importStar(require("./message"));
+exports.transaction = __importStar(require("./transaction"));
+exports.txHelpers = __importStar(require("./tx-helpers"));
+__exportStar(require("./types"), exports);
+exports.utils = __importStar(require("./utils"));
+exports.wallet = __importStar(require("./wallet"));
+// Export with types.
+__exportStar(require("./keyring/interfaces/SimpleKeyringOptions"), exports);
+__exportStar(require("./keyring/hd-keyring"), exports);
+__exportStar(require("./keyring/keystone-keyring"), exports);
+__exportStar(require("./keyring/simple-keyring"), exports);

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;
+    xpriv: string;
+    passphrase: string;
+    hdPath: string;
+    root: bitcore.HDPrivateKey;
+    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;
+    private _addressFromIndex;
+}