@btc-vision/wallet-sdk 1.0.0 → 1.0.4

package/lib/keyring/interfaces/SimpleKeyringOptions.js

@@ -1,26 +1,15 @@
-"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) {
+import { isTaprootInput, networks } from '@btc-vision/bitcoin';
+import { EventEmitter } from 'events';
+import { signMessageOfDeterministicECDSA, verifyMessageOfECDSA } from '../../message';
+import { tweakSigner } from '../../utils';
+export class IKeyringBase extends EventEmitter {
+    network;
+    static type = '';
+    type = '';
+    wallets = [];
+    constructor(network = networks.bitcoin) {
         super();
         this.network = network;
-        this.type = '';
-        this.wallets = [];
     }
     removeAccount(publicKey) {
         if (!this.wallets.map((wallet) => wallet.publicKey.toString('hex')).includes(publicKey)) {
@@ -28,10 +17,8 @@ class IKeyringBase extends events_1.EventEmitter {
         }
         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);
-        });
+    async verifyMessage(publicKey, text, sig) {
+        return 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') {
@@ -48,17 +35,17 @@ class IKeyringBase extends events_1.EventEmitter {
     }
     signMessage(publicKey, text) {
         const keyPair = this._getPrivateKeyFor(publicKey);
-        return (0, message_1.signMessageOfDeterministicECDSA)(keyPair, text);
+        return signMessageOfDeterministicECDSA(keyPair, text);
     }
     exportAccount(publicKey) {
         const wallet = this._getWalletForAccount(publicKey);
-        return wallet.privateKey.toString('hex');
+        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);
+            if (isTaprootInput(psbt.data.inputs[input.index]) && !input.disableTweakSigner) {
+                const signer = tweakSigner(keyPair, opts);
                 psbt.signInput(input.index, signer, input.sighashTypes);
             }
             else {
@@ -81,5 +68,3 @@ class IKeyringBase extends events_1.EventEmitter {
         return this._getWalletForAccount(publicKey);
     }
 }
-exports.IKeyringBase = IKeyringBase;
-IKeyringBase.type = '';

package/lib/keyring/keystone-keyring.js

@@ -1,76 +1,40 @@
-"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.KeystoneKeyring = void 0;
-const keystone_sdk_1 = __importStar(require("@keystonehq/keystone-sdk"));
-const utils_1 = require("@keystonehq/keystone-sdk/dist/utils");
-const bitcoinjs_lib_1 = require("bitcoinjs-lib");
-const bitcore_lib_1 = __importDefault(require("bitcore-lib"));
-const message_1 = require("../message");
-const SimpleKeyringOptions_1 = require("./interfaces/SimpleKeyringOptions");
+import { networks, Psbt } from '@btc-vision/bitcoin';
+import KeystoneSDK, { KeystoneBitcoinSDK, UR } from '@keystonehq/keystone-sdk';
+import { uuid } from '@keystonehq/keystone-sdk/dist/utils';
+import bitcore from 'bitcore-lib';
+import { verifyMessageOfECDSA } from '../message';
+import { IKeyringBase } from './interfaces/SimpleKeyringOptions';
 const type = 'Keystone';
-class KeystoneKeyring extends SimpleKeyringOptions_1.IKeyringBase {
+export class KeystoneKeyring extends IKeyringBase {
+    static type = type;
+    type = type;
+    mfp = '';
+    keys = [];
+    hdPath;
+    activeIndexes = [];
+    root = undefined;
+    page = 0;
+    perPage = 5;
+    origin = 'UniSat Wallet';
     constructor(opts) {
-        super((opts === null || opts === void 0 ? void 0 : opts.network) || bitcoinjs_lib_1.networks.bitcoin);
-        this.type = type;
-        this.mfp = '';
-        this.keys = [];
-        this.activeIndexes = [];
-        this.root = null;
-        this.page = 0;
-        this.perPage = 5;
-        this.origin = 'UniSat Wallet';
+        super(opts?.network || networks.bitcoin);
         if (opts) {
             this.deserialize(opts);
         }
     }
-    initFromUR(type, cbor) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const keystoneSDK = new keystone_sdk_1.default({
-                origin: this.origin
-            });
-            const account = keystoneSDK.parseAccount(new keystone_sdk_1.UR(Buffer.from(cbor, 'hex'), type));
-            this.deserialize({
-                mfp: account.masterFingerprint,
-                keys: account.keys.map((k) => ({
-                    path: k.path,
-                    extendedPublicKey: k.extendedPublicKey
-                }))
-            });
+    async initFromUR(type, cbor) {
+        const keystoneSDK = new KeystoneSDK({
+            origin: this.origin
+        });
+        const account = keystoneSDK.parseAccount(new UR(Buffer.from(cbor, 'hex'), type));
+        this.deserialize({
+            mfp: account.masterFingerprint,
+            keys: account.keys
+                .filter((k) => k.extendedPublicKey !== undefined)
+                .map((k) => ({
+                path: k.path,
+                extendedPublicKey: k.extendedPublicKey
+            }))
         });
     }
     getHardenedPath(hdPath) {
@@ -83,27 +47,25 @@ class KeystoneKeyring extends SimpleKeyringOptions_1.IKeyringBase {
         if (!key) {
             throw new Error('Invalid path');
         }
-        return new bitcore_lib_1.default.HDPublicKey(key.extendedPublicKey);
+        return new bitcore.HDPublicKey(key.extendedPublicKey);
     }
     getDefaultHdPath() {
         return "m/44'/0'/0'/0";
     }
     initRoot() {
-        var _a;
-        this.root = this.getHDPublicKey((_a = this.hdPath) !== null && _a !== void 0 ? _a : this.getDefaultHdPath());
+        this.root = this.getHDPublicKey(this.hdPath ?? this.getDefaultHdPath());
     }
     deserialize(opts) {
-        var _a;
         this.mfp = opts.mfp;
         this.keys = opts.keys;
-        this.hdPath = (_a = opts.hdPath) !== null && _a !== void 0 ? _a : this.getDefaultHdPath();
+        this.hdPath = opts.hdPath ?? this.getDefaultHdPath();
         this.activeIndexes = opts.activeIndexes ? [...opts.activeIndexes] : [];
         this.initRoot();
         if (opts.hdPath !== null &&
             opts.hdPath !== undefined &&
             opts.hdPath.length >= 13 &&
             opts.hdPath[opts.hdPath.length - 1] === '1') {
-            this.root = this.root.derive(`m/1`);
+            this.root = this.root?.derive(`m/1`);
         }
     }
     serialize() {
@@ -119,36 +81,34 @@ class KeystoneKeyring extends SimpleKeyringOptions_1.IKeyringBase {
         let i = 0;
         const pubkeys = [];
         while (count) {
-            if (this.activeIndexes.includes(i)) {
+            if (this.activeIndexes?.includes(i)) {
                 i++;
             }
             else {
                 const w = this.getWalletByIndex(i);
                 pubkeys.push(w.publicKey);
-                this.activeIndexes.push(i);
+                this.activeIndexes?.push(i);
                 count--;
             }
         }
         return pubkeys;
     }
-    addChangeAddressAccounts(numberOfAccounts = 1) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let count = numberOfAccounts;
-            let i = 0;
-            const pubkeys = [];
-            while (count) {
-                if (this.activeIndexes.includes(i)) {
-                    i++;
-                }
-                else {
-                    const w = this.getChangeAddressWalletByIndex(i);
-                    pubkeys.push(w.publicKey);
-                    this.activeIndexes.push(i);
-                    count--;
-                }
+    async addChangeAddressAccounts(numberOfAccounts = 1) {
+        let count = numberOfAccounts;
+        let i = 0;
+        const pubkeys = [];
+        while (count) {
+            if (this.activeIndexes?.includes(i)) {
+                i++;
             }
-            return Promise.resolve(pubkeys);
-        });
+            else {
+                const w = this.getChangeAddressWalletByIndex(i);
+                pubkeys.push(w.publicKey);
+                this.activeIndexes?.push(i);
+                count--;
+            }
+        }
+        return Promise.resolve(pubkeys);
     }
     getAccounts() {
         if (this.hdPath !== null &&
@@ -162,27 +122,23 @@ class KeystoneKeyring extends SimpleKeyringOptions_1.IKeyringBase {
         }
         return this.activeIndexes.map((i) => this.getWalletByIndex(i).publicKey);
     }
-    getAccounts2() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.activeIndexes.map((index) => {
-                const child = this.root.derive(`m/${index}`);
-                return {
-                    index,
-                    path: `${this.hdPath}/${index}`,
-                    publicKey: child.publicKey.toString()
-                };
-            });
+    async getAccounts2() {
+        return this.activeIndexes.map((index) => {
+            const child = this.root.derive(`m/${index}`);
+            return {
+                index,
+                path: `${this.hdPath}/${index}`,
+                publicKey: child.publicKey.toString()
+            };
         });
     }
-    getAccountsWithBrand() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.activeIndexes.map((i) => {
-                const w = this.getWalletByIndex(i);
-                return {
-                    address: w.publicKey,
-                    index: i
-                };
-            });
+    async getAccountsWithBrand() {
+        return this.activeIndexes.map((i) => {
+            const w = this.getWalletByIndex(i);
+            return {
+                address: w.publicKey,
+                index: i
+            };
         });
     }
     getWalletByIndex(index) {
@@ -237,24 +193,22 @@ class KeystoneKeyring extends SimpleKeyringOptions_1.IKeyringBase {
         }
         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 w = this.getWalletByIndex(i);
-                accounts.push({
-                    address: w.publicKey,
-                    index: i + 1
-                });
-            }
-            return accounts;
-        });
+    async getPage(increment) {
+        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 w = this.getWalletByIndex(i);
+            accounts.push({
+                address: w.publicKey,
+                index: i + 1
+            });
+        }
+        return accounts;
     }
     activeAccounts(indexes) {
         const accounts = [];
@@ -273,9 +227,8 @@ class KeystoneKeyring extends SimpleKeyringOptions_1.IKeyringBase {
         this.activeAccounts(this.activeIndexes);
     }
     changeChangeAddressHdPath(hdPath) {
-        var _a;
         this.hdPath = hdPath;
-        this.root = this.getHDPublicKey((_a = this.hdPath) !== null && _a !== void 0 ? _a : this.getDefaultHdPath());
+        this.root = this.getHDPublicKey(this.hdPath ?? this.getDefaultHdPath());
         this.root = this.root.derive(`m/1`);
         this.activeIndexes = [];
         return [];
@@ -290,88 +243,76 @@ class KeystoneKeyring extends SimpleKeyringOptions_1.IKeyringBase {
         const child = root.derive(`m/1/${index}`);
         return child.publicKey.toString();
     }
-    genSignPsbtUr(psbtHex) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const psbt = bitcoinjs_lib_1.Psbt.fromHex(psbtHex);
-            const keystoneSDK = new keystone_sdk_1.default({
-                origin: this.origin
-            });
-            const ur = keystoneSDK.btc.generatePSBT(psbt.data.toBuffer());
-            return {
-                type: ur.type,
-                cbor: ur.cbor.toString('hex')
-            };
+    async genSignPsbtUr(psbtHex) {
+        const psbt = Psbt.fromHex(psbtHex);
+        const keystoneSDK = new KeystoneSDK({
+            origin: this.origin
         });
+        const ur = keystoneSDK.btc.generatePSBT(psbt.data.toBuffer());
+        return {
+            type: ur.type,
+            cbor: ur.cbor.toString('hex')
+        };
     }
-    parseSignPsbtUr(type, cbor) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const keystoneSDK = new keystone_sdk_1.default({
-                origin: this.origin
-            });
-            return keystoneSDK.btc.parsePSBT(new keystone_sdk_1.UR(Buffer.from(cbor, 'hex'), type));
+    async parseSignPsbtUr(type, cbor) {
+        const keystoneSDK = new KeystoneSDK({
+            origin: this.origin
         });
+        return keystoneSDK.btc.parsePSBT(new UR(Buffer.from(cbor, 'hex'), type));
     }
-    genSignMsgUr(publicKey, text) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const keystoneSDK = new keystone_sdk_1.default({
-                origin: this.origin
-            });
-            let i = undefined;
-            if (this.hdPath !== null &&
-                this.hdPath !== undefined &&
-                this.hdPath.length >= 13 &&
-                this.hdPath[this.hdPath.length - 1] === '1') {
-                const root = this.getHDPublicKey(this.hdPath);
-                i = this.activeIndexes.find((i) => {
-                    const child = root.derive(`m/1/${i}`);
-                    if (child.publicKey.toString() === publicKey) {
-                        return true;
-                    }
-                });
-            }
-            else {
-                i = this.activeIndexes.find((i) => this.getWalletByIndex(i).publicKey === publicKey);
-            }
-            if (i === undefined) {
-                throw new Error('publicKey not found');
-            }
-            const requestId = utils_1.uuid.v4();
-            const ur = keystoneSDK.btc.generateSignRequest({
-                requestId,
-                signData: Buffer.from(text).toString('hex'),
-                dataType: keystone_sdk_1.KeystoneBitcoinSDK.DataType.message,
-                accounts: [
-                    {
-                        path: `${this.hdPath}/${i}`,
-                        xfp: this.mfp
-                    }
-                ],
-                origin: this.origin
+    async genSignMsgUr(publicKey, text) {
+        const keystoneSDK = new KeystoneSDK({
+            origin: this.origin
+        });
+        let i = undefined;
+        if (this.hdPath !== null &&
+            this.hdPath !== undefined &&
+            this.hdPath.length >= 13 &&
+            this.hdPath[this.hdPath.length - 1] === '1') {
+            const root = this.getHDPublicKey(this.hdPath);
+            i = this.activeIndexes.find((i) => {
+                const child = root.derive(`m/1/${i}`);
+                if (child.publicKey.toString() === publicKey) {
+                    return true;
+                }
             });
-            return {
-                requestId,
-                type: ur.type,
-                cbor: ur.cbor.toString('hex')
-            };
+        }
+        else {
+            i = this.activeIndexes.find((i) => this.getWalletByIndex(i).publicKey === publicKey);
+        }
+        if (i === undefined) {
+            throw new Error('publicKey not found');
+        }
+        const requestId = uuid.v4();
+        const ur = keystoneSDK.btc.generateSignRequest({
+            requestId,
+            signData: Buffer.from(text).toString('hex'),
+            dataType: KeystoneBitcoinSDK.DataType.message,
+            accounts: [
+                {
+                    path: `${this.hdPath}/${i}`,
+                    xfp: this.mfp
+                }
+            ],
+            origin: this.origin
         });
+        return {
+            requestId,
+            type: ur.type,
+            cbor: ur.cbor.toString('hex')
+        };
     }
-    parseSignMsgUr(type, cbor) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const keystoneSDK = new keystone_sdk_1.default({
-                origin: this.origin
-            });
-            return keystoneSDK.btc.parseSignature(new keystone_sdk_1.UR(Buffer.from(cbor, 'hex'), type));
+    async parseSignMsgUr(type, cbor) {
+        const keystoneSDK = new KeystoneSDK({
+            origin: this.origin
         });
+        return keystoneSDK.btc.parseSignature(new UR(Buffer.from(cbor, 'hex'), type));
     }
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     signMessage(publicKey, text) {
         return 'Signing Message with Keystone should use genSignMsgUr and parseSignMsgUr';
     }
-    verifyMessage(publicKey, text, sig) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (0, message_1.verifyMessageOfECDSA)(publicKey, text, sig);
-        });
+    async verifyMessage(publicKey, text, sig) {
+        return verifyMessageOfECDSA(publicKey, text, sig);
     }
 }
-exports.KeystoneKeyring = KeystoneKeyring;
-KeystoneKeyring.type = type;

package/lib/keyring/simple-keyring.js

@@ -1,15 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.verifySignData = exports.SimpleKeyring = void 0;
-const bs58check_1 = require("bs58check");
-const bitcoin_core_1 = require("../bitcoin-core");
-const SimpleKeyringOptions_1 = require("./interfaces/SimpleKeyringOptions");
-const bitcoinjs_lib_1 = require("bitcoinjs-lib");
+import { networks } from '@btc-vision/bitcoin';
+import * as bs58check from 'bs58check';
+import { ECPair } from '../bitcoin-core';
+import { IKeyringBase } from './interfaces/SimpleKeyringOptions';
 const type = 'Simple Key Pair';
-class SimpleKeyring extends SimpleKeyringOptions_1.IKeyringBase {
+export class SimpleKeyring extends IKeyringBase {
+    static type = type;
+    type = type;
     constructor(opts) {
-        super((opts === null || opts === void 0 ? void 0 : opts.network) || bitcoinjs_lib_1.networks.bitcoin);
-        this.type = type;
+        super(opts?.network || networks.bitcoin);
         if (opts && opts.privateKeys) {
             this.deserialize(opts);
         }
@@ -32,15 +30,15 @@ class SimpleKeyring extends SimpleKeyringOptions_1.IKeyringBase {
             }
             else {
                 // base58
-                buf = Buffer.from((0, bs58check_1.decode)(key).slice(1, 33));
+                buf = Buffer.from(bs58check.default.decode(key).slice(1, 33));
             }
-            return bitcoin_core_1.ECPair.fromPrivateKey(buf);
+            return ECPair.fromPrivateKey(buf);
         });
     }
     addAccounts(n = 1) {
         const newWallets = [];
         for (let i = 0; i < n; i++) {
-            newWallets.push(bitcoin_core_1.ECPair.makeRandom());
+            newWallets.push(ECPair.makeRandom());
         }
         this.wallets = this.wallets.concat(newWallets);
         return newWallets.map(({ publicKey }) => publicKey.toString('hex'));
@@ -49,10 +47,8 @@ class SimpleKeyring extends SimpleKeyringOptions_1.IKeyringBase {
         return this.wallets.map(({ publicKey }) => publicKey.toString('hex'));
     }
 }
-exports.SimpleKeyring = SimpleKeyring;
-SimpleKeyring.type = type;
-function verifySignData(publicKey, hash, type, signature) {
-    const keyPair = bitcoin_core_1.ECPair.fromPublicKey(Buffer.from(publicKey, 'hex'));
+export function verifySignData(publicKey, hash, type, signature) {
+    const keyPair = ECPair.fromPublicKey(Buffer.from(publicKey, 'hex'));
     if (type === 'ecdsa') {
         return keyPair.verify(Buffer.from(hash, 'hex'), Buffer.from(signature, 'hex'));
     }
@@ -63,4 +59,3 @@ function verifySignData(publicKey, hash, type, signature) {
         throw new Error('Not support type');
     }
 }
-exports.verifySignData = verifySignData;