@btc-vision/wallet-sdk 1.0.0

package/lib/keyring/hd-keyring.js

@@ -0,0 +1,238 @@
+"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 __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.HdKeyring = void 0;
+const bip39 = __importStar(require("bip39"));
+const hdkey_1 = __importDefault(require("hdkey"));
+const bitcoin_core_1 = require("../bitcoin-core");
+const SimpleKeyringOptions_1 = require("./interfaces/SimpleKeyringOptions");
+const bitcoinjs_lib_1 = require("bitcoinjs-lib");
+const hdPathString = "m/44'/0'/0'/0";
+const type = 'HD Key Tree';
+class HdKeyring extends SimpleKeyringOptions_1.IKeyringBase {
+    /* PUBLIC METHODS */
+    constructor(opts) {
+        super((opts === null || opts === void 0 ? void 0 : opts.network) || bitcoinjs_lib_1.networks.bitcoin);
+        this.type = type;
+        this.mnemonic = null;
+        this.xpriv = null;
+        this.hdPath = hdPathString;
+        this.root = null;
+        this.wallets = [];
+        this.activeIndexes = [];
+        this.page = 0;
+        this.perPage = 5;
+        this._index2wallet = {};
+        if (opts) {
+            this.deserialize(opts);
+        }
+    }
+    serialize() {
+        return {
+            mnemonic: this.mnemonic,
+            xpriv: this.xpriv,
+            activeIndexes: this.activeIndexes,
+            hdPath: this.hdPath,
+            passphrase: this.passphrase
+        };
+    }
+    deserialize(_opts = {}) {
+        if (this.root) {
+            throw new Error('Btc-Hd-Keyring: Secret recovery phrase already provided');
+        }
+        let opts = _opts;
+        this.wallets = [];
+        this.mnemonic = null;
+        this.xpriv = null;
+        this.root = null;
+        this.hdPath = opts.hdPath || hdPathString;
+        if (opts.passphrase) {
+            this.passphrase = opts.passphrase;
+        }
+        if (opts.mnemonic) {
+            this.initFromMnemonic(opts.mnemonic);
+        }
+        else if (opts.xpriv) {
+            this.initFromXpriv(opts.xpriv);
+        }
+        if (opts.activeIndexes) {
+            this.activeAccounts(opts.activeIndexes);
+        }
+    }
+    initFromXpriv(xpriv) {
+        if (this.root) {
+            throw new Error('Btc-Hd-Keyring: Secret recovery phrase already provided');
+        }
+        this.xpriv = xpriv;
+        this._index2wallet = {};
+        // @ts-ignore
+        this.hdWallet = hdkey_1.default.fromJSON({ xpriv });
+        this.root = this.hdWallet;
+    }
+    initFromMnemonic(mnemonic) {
+        if (this.root) {
+            throw new Error('Btc-Hd-Keyring: Secret recovery phrase already provided');
+        }
+        this.mnemonic = mnemonic;
+        this._index2wallet = {};
+        const seed = bip39.mnemonicToSeedSync(mnemonic, this.passphrase);
+        this.hdWallet = hdkey_1.default.fromMasterSeed(seed);
+        this.root = this.hdWallet.derive(this.hdPath);
+    }
+    changeHdPath(hdPath) {
+        if (!this.mnemonic) {
+            throw new Error('Btc-Hd-Keyring: Not support');
+        }
+        this.hdPath = hdPath;
+        this.root = this.hdWallet.derive(this.hdPath);
+        const indexes = this.activeIndexes;
+        this._index2wallet = {};
+        this.activeIndexes = [];
+        this.wallets = [];
+        this.activeAccounts(indexes);
+    }
+    getAccountByHdPath(hdPath, index) {
+        if (!this.mnemonic) {
+            throw new Error('Btc-Hd-Keyring: Not support');
+        }
+        const root = this.hdWallet.derive(hdPath);
+        const child = root.deriveChild(index);
+        const ecpair = bitcoin_core_1.ECPair.fromPrivateKey(child.privateKey, {
+            network: this.network
+        });
+        return ecpair.publicKey.toString('hex');
+    }
+    addAccounts(numberOfAccounts = 1) {
+        let count = numberOfAccounts;
+        let currentIdx = 0;
+        const newWallets = [];
+        while (count) {
+            const [, wallet] = this._addressFromIndex(currentIdx);
+            if (this.wallets.includes(wallet)) {
+                currentIdx++;
+            }
+            else {
+                this.wallets.push(wallet);
+                newWallets.push(wallet);
+                this.activeIndexes.push(currentIdx);
+                count--;
+            }
+        }
+        return newWallets.map((w) => {
+            return w.publicKey.toString('hex');
+        });
+    }
+    activeAccounts(indexes) {
+        const accounts = [];
+        for (const index of indexes) {
+            const [address, wallet] = this._addressFromIndex(index);
+            this.wallets.push(wallet);
+            this.activeIndexes.push(index);
+            accounts.push(address);
+        }
+        return accounts;
+    }
+    getFirstPage() {
+        this.page = 0;
+        return this.__getPage(1);
+    }
+    getNextPage() {
+        return this.__getPage(1);
+    }
+    getPreviousPage() {
+        return this.__getPage(-1);
+    }
+    getAddresses(start, end) {
+        const from = start;
+        const to = end;
+        const accounts = [];
+        for (let i = from; i < to; i++) {
+            const [address] = this._addressFromIndex(i);
+            accounts.push({
+                address,
+                index: i + 1
+            });
+        }
+        return accounts;
+    }
+    __getPage(increment) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.page += increment;
+            if (!this.page || this.page <= 0) {
+                this.page = 1;
+            }
+            const from = (this.page - 1) * this.perPage;
+            const to = from + this.perPage;
+            const accounts = [];
+            for (let i = from; i < to; i++) {
+                const [address] = this._addressFromIndex(i);
+                accounts.push({
+                    address,
+                    index: i + 1
+                });
+            }
+            return accounts;
+        });
+    }
+    getAccounts() {
+        return this.wallets.map((w) => {
+            return w.publicKey.toString('hex');
+        });
+    }
+    getIndexByAddress(address) {
+        for (const key in this._index2wallet) {
+            if (this._index2wallet[key][0] === address) {
+                return Number(key);
+            }
+        }
+        return null;
+    }
+    _addressFromIndex(i) {
+        if (!this._index2wallet[i]) {
+            const child = this.root.deriveChild(i);
+            // @ts-ignore
+            const ecpair = bitcoin_core_1.ECPair.fromPrivateKey(child.privateKey || Buffer.from(child.toString(), 'hex'), {
+                network: this.network
+            });
+            const address = ecpair.publicKey.toString('hex');
+            this._index2wallet[i] = [address, ecpair];
+        }
+        return this._index2wallet[i];
+    }
+}
+exports.HdKeyring = HdKeyring;
+HdKeyring.type = type;

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

@@ -0,0 +1,20 @@
+"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("./hd-keyring"), exports);
+__exportStar(require("./keystone-keyring"), exports);
+__exportStar(require("./simple-keyring"), exports);
+__exportStar(require("./interfaces/SimpleKeyringOptions"), exports);

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

@@ -0,0 +1,53 @@
+/// <reference types="node" />
+import { Network, Psbt } from 'bitcoinjs-lib';
+import { EventEmitter } from 'events';
+import { ECPairInterface } from 'ecpair';
+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;
+    readonly xpriv?: string;
+    readonly passphrase?: string;
+}
+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, text: string): string;
+    exportAccount(publicKey: string): string;
+    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

@@ -0,0 +1,85 @@
+"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.IKeyringBase = void 0;
+const bitcoinjs_lib_1 = require("bitcoinjs-lib");
+const events_1 = require("events");
+const bip371_1 = require("bitcoinjs-lib/src/psbt/bip371");
+const utils_1 = require("../../utils");
+const message_1 = require("../../message");
+class IKeyringBase extends events_1.EventEmitter {
+    constructor(network = bitcoinjs_lib_1.networks.bitcoin) {
+        super();
+        this.network = network;
+        this.type = '';
+        this.wallets = [];
+    }
+    removeAccount(publicKey) {
+        if (!this.wallets.map((wallet) => wallet.publicKey.toString('hex')).includes(publicKey)) {
+            throw new Error(`PublicKey ${publicKey} not found in this keyring`);
+        }
+        this.wallets = this.wallets.filter((wallet) => wallet.publicKey.toString('hex') !== publicKey);
+    }
+    verifyMessage(publicKey, text, sig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, message_1.verifyMessageOfECDSA)(publicKey, text, sig);
+        });
+    }
+    // Sign any content, but note that the content signed by this method is unreadable, so use it with caution.
+    signData(publicKey, data, type = 'ecdsa') {
+        const keyPair = this._getPrivateKeyFor(publicKey);
+        if (type === 'ecdsa') {
+            return keyPair.sign(Buffer.from(data, 'hex')).toString('hex');
+        }
+        else if (type === 'schnorr') {
+            return keyPair.signSchnorr(Buffer.from(data, 'hex')).toString('hex');
+        }
+        else {
+            throw new Error('Not support type');
+        }
+    }
+    signMessage(publicKey, text) {
+        const keyPair = this._getPrivateKeyFor(publicKey);
+        return (0, message_1.signMessageOfDeterministicECDSA)(keyPair, text);
+    }
+    exportAccount(publicKey) {
+        const wallet = this._getWalletForAccount(publicKey);
+        return wallet.privateKey.toString('hex');
+    }
+    signTransaction(psbt, inputs, opts) {
+        inputs.forEach((input) => {
+            const keyPair = this._getPrivateKeyFor(input.publicKey);
+            if ((0, bip371_1.isTaprootInput)(psbt.data.inputs[input.index]) && !input.disableTweakSigner) {
+                const signer = (0, utils_1.tweakSigner)(keyPair, opts);
+                psbt.signInput(input.index, signer, input.sighashTypes);
+            }
+            else {
+                psbt.signInput(input.index, keyPair, input.sighashTypes);
+            }
+        });
+        return psbt;
+    }
+    _getWalletForAccount(publicKey) {
+        let wallet = this.wallets.find((wallet) => wallet.publicKey.toString('hex') == publicKey);
+        if (!wallet) {
+            throw new Error('Simple Keyring - Unable to find matching publicKey.');
+        }
+        return wallet;
+    }
+    _getPrivateKeyFor(publicKey) {
+        if (!publicKey) {
+            throw new Error('Must specify publicKey.');
+        }
+        return this._getWalletForAccount(publicKey);
+    }
+}
+exports.IKeyringBase = IKeyringBase;
+IKeyringBase.type = '';

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;
+    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<any[]>;
+    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): any[];
+    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, text: string): string;
+    verifyMessage(publicKey: string, text: string, sig: string): Promise<boolean>;
+}
+export {};