@btc-vision/wallet-sdk 1.0.0 → 1.0.4

package/lib/utils.js

@@ -1,20 +1,13 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.shortAddress = exports.amountToSaothis = exports.satoshisToAmount = exports.schnorrValidator = exports.validator = exports.tweakSigner = exports.toXOnly = void 0;
-const bignumber_js_1 = __importDefault(require("bignumber.js"));
-const bitcoin_core_1 = require("./bitcoin-core");
-const toXOnly = (pubKey) => (pubKey.length === 32 ? pubKey : pubKey.slice(1, 33));
-exports.toXOnly = toXOnly;
+import BigNumber from 'bignumber.js';
+import { bitcoin, ecc, ECPair } from './bitcoin-core';
+export const toXOnly = (pubKey) => (pubKey.length === 32 ? pubKey : pubKey.slice(1, 33));
 function tapTweakHash(pubKey, h) {
-    return bitcoin_core_1.bitcoin.crypto.taggedHash('TapTweak', Buffer.concat(h ? [pubKey, h] : [pubKey]));
+    return bitcoin.crypto.taggedHash('TapTweak', Buffer.concat(h ? [pubKey, h] : [pubKey]));
 }
 /**
  * Transform raw private key to taproot address private key
  */
-function tweakSigner(signer, opts = {}) {
+export function tweakSigner(signer, opts = {}) {
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-ignore
     let privateKey = signer.privateKey;
@@ -22,50 +15,44 @@ function tweakSigner(signer, opts = {}) {
         throw new Error('Private key is required for tweaking signer!');
     }
     if (signer.publicKey[0] === 3) {
-        privateKey = bitcoin_core_1.ecc.privateNegate(privateKey);
+        privateKey = ecc.privateNegate(privateKey);
     }
-    const tweakedPrivateKey = bitcoin_core_1.ecc.privateAdd(privateKey, tapTweakHash((0, exports.toXOnly)(signer.publicKey), opts.tweakHash));
+    const tweakedPrivateKey = ecc.privateAdd(privateKey, tapTweakHash(toXOnly(signer.publicKey), opts.tweakHash));
     if (!tweakedPrivateKey) {
         throw new Error('Invalid tweaked private key!');
     }
-    return bitcoin_core_1.ECPair.fromPrivateKey(Buffer.from(tweakedPrivateKey), {
+    return ECPair.fromPrivateKey(Buffer.from(tweakedPrivateKey), {
         network: opts.network
     });
 }
-exports.tweakSigner = tweakSigner;
 /**
  * ECDSA signature validator
  */
-const validator = (pubkey, msghash, signature) => bitcoin_core_1.ECPair.fromPublicKey(pubkey).verify(msghash, signature);
-exports.validator = validator;
+export const validator = (pubkey, msghash, signature) => ECPair.fromPublicKey(pubkey).verify(msghash, signature);
 /**
  * Schnorr signature validator
  */
-const schnorrValidator = (pubkey, msghash, signature) => {
-    return bitcoin_core_1.ECPair.fromPublicKey(pubkey).verifySchnorr(msghash, signature);
+export const schnorrValidator = (pubkey, msghash, signature) => {
+    return ECPair.fromPublicKey(pubkey).verifySchnorr(msghash, signature);
 };
-exports.schnorrValidator = schnorrValidator;
 /**
  * Transform satoshis to btc format
  */
-function satoshisToAmount(val) {
-    const num = new bignumber_js_1.default(val);
+export function satoshisToAmount(val) {
+    const num = new BigNumber(val);
     return num.dividedBy(100000000).toFixed(8);
 }
-exports.satoshisToAmount = satoshisToAmount;
 /**
  * Transform btc format to satoshis
  */
-function amountToSaothis(val) {
-    const num = new bignumber_js_1.default(val);
+export function amountToSaothis(val) {
+    const num = new BigNumber(val);
     return num.multipliedBy(100000000).toNumber();
 }
-exports.amountToSaothis = amountToSaothis;
-function shortAddress(address, len = 5) {
+export function shortAddress(address, len = 5) {
     if (!address)
         return '';
     if (address.length <= len * 2)
         return address;
     return address.slice(0, len) + '...' + address.slice(address.length - len);
 }
-exports.shortAddress = shortAddress;

package/lib/wallet/abstract-wallet.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/lib/wallet/estimate-wallet.js

@@ -1,174 +1,157 @@
-"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.EstimateWallet = void 0;
-const address_1 = require("../address");
-const bitcoin_core_1 = require("../bitcoin-core");
-const keyring_1 = require("../keyring");
-const message_1 = require("../message");
-const network_1 = require("../network");
-const types_1 = require("../types");
-const utils_1 = require("../utils");
+import { publicKeyToAddress, scriptPkToAddress } from '../address';
+import { bitcoin, ECPair } from '../bitcoin-core';
+import { SimpleKeyring } from '../keyring';
+import { signMessageOfBIP322Simple } from '../message';
+import { NetworkType, toPsbtNetwork } from '../network';
+import { AddressType } from '../types';
+import { toXOnly } from '../utils';
 /**
  * EstimateWallet is a wallet that can be used to estimate the size of a transaction.
  */
-class EstimateWallet {
-    constructor(wif, networkType = network_1.NetworkType.MAINNET, addressType = types_1.AddressType.P2WPKH) {
-        const network = (0, network_1.toPsbtNetwork)(networkType);
-        const keyPair = bitcoin_core_1.ECPair.fromWIF(wif, network);
-        this.keyring = new keyring_1.SimpleKeyring({
+export class EstimateWallet {
+    keyring;
+    address;
+    pubkey;
+    network;
+    networkType;
+    addressType;
+    constructor(wif, networkType = NetworkType.MAINNET, addressType = AddressType.P2WPKH) {
+        const network = toPsbtNetwork(networkType);
+        const keyPair = ECPair.fromWIF(wif, network);
+        this.keyring = new SimpleKeyring({
             privateKeys: [keyPair.privateKey.toString('hex')],
             network: network
         });
         this.keyring.addAccounts(1);
         this.pubkey = keyPair.publicKey.toString('hex');
-        this.address = (0, address_1.publicKeyToAddress)(this.pubkey, addressType, networkType);
+        this.address = publicKeyToAddress(this.pubkey, addressType, networkType);
         this.network = network;
         this.networkType = networkType;
         this.addressType = addressType;
     }
-    static fromRandom(addressType = types_1.AddressType.P2WPKH, networkType = network_1.NetworkType.MAINNET) {
-        const network = (0, network_1.toPsbtNetwork)(networkType);
-        const ecpair = bitcoin_core_1.ECPair.makeRandom({ network });
+    static fromRandom(addressType = AddressType.P2WPKH, networkType = NetworkType.MAINNET) {
+        const network = toPsbtNetwork(networkType);
+        const ecpair = ECPair.makeRandom({ network });
         const wallet = new EstimateWallet(ecpair.toWIF(), networkType, addressType);
         return wallet;
     }
     getNetworkType() {
         return this.networkType;
     }
-    signPsbt(psbt, opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const _opts = opts || {
-                autoFinalized: true,
-                toSignInputs: []
-            };
-            let _inputs = yield this.formatOptionsToSignInputs(psbt, opts);
-            if (_inputs.length == 0) {
-                throw new Error('no input to sign');
-            }
-            psbt.data.inputs.forEach((v) => {
-                var _a;
-                const isNotSigned = !(v.finalScriptSig || v.finalScriptWitness);
-                const isP2TR = this.addressType === types_1.AddressType.P2TR || this.addressType === types_1.AddressType.M44_P2TR;
-                const lostInternalPubkey = !v.tapInternalKey;
-                // Special measures taken for compatibility with certain applications.
-                if (isNotSigned && isP2TR && lostInternalPubkey) {
-                    const tapInternalKey = (0, utils_1.toXOnly)(Buffer.from(this.pubkey, 'hex'));
-                    const { output } = bitcoin_core_1.bitcoin.payments.p2tr({
-                        internalPubkey: tapInternalKey,
-                        network: (0, network_1.toPsbtNetwork)(this.networkType)
-                    });
-                    if (((_a = v.witnessUtxo) === null || _a === void 0 ? void 0 : _a.script.toString('hex')) == (output === null || output === void 0 ? void 0 : output.toString('hex'))) {
-                        v.tapInternalKey = tapInternalKey;
-                    }
-                }
-            });
-            psbt = yield this.keyring.signTransaction(psbt, _inputs);
-            if (_opts.autoFinalized) {
-                _inputs.forEach((v) => {
-                    // psbt.validateSignaturesOfInput(v.index, validator);
-                    psbt.finalizeInput(v.index);
+    async signPsbt(psbt, opts) {
+        const _opts = opts || {
+            autoFinalized: true,
+            toSignInputs: []
+        };
+        let _inputs = await this.formatOptionsToSignInputs(psbt, opts);
+        if (_inputs.length == 0) {
+            throw new Error('no input to sign');
+        }
+        psbt.data.inputs.forEach((v) => {
+            const isNotSigned = !(v.finalScriptSig || v.finalScriptWitness);
+            const isP2TR = this.addressType === AddressType.P2TR || this.addressType === AddressType.M44_P2TR;
+            const lostInternalPubkey = !v.tapInternalKey;
+            // Special measures taken for compatibility with certain applications.
+            if (isNotSigned && isP2TR && lostInternalPubkey) {
+                const tapInternalKey = toXOnly(Buffer.from(this.pubkey, 'hex'));
+                const { output } = bitcoin.payments.p2tr({
+                    internalPubkey: tapInternalKey,
+                    network: toPsbtNetwork(this.networkType)
                 });
+                if (v.witnessUtxo?.script.toString('hex') == output?.toString('hex')) {
+                    v.tapInternalKey = tapInternalKey;
+                }
             }
-            return psbt;
         });
+        psbt = await this.keyring.signTransaction(psbt, _inputs);
+        if (_opts.autoFinalized) {
+            _inputs.forEach((v) => {
+                // psbt.validateSignaturesOfInput(v.index, validator);
+                psbt.finalizeInput(v.index);
+            });
+        }
+        return psbt;
     }
-    getPublicKey() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const pubkeys = yield this.keyring.getAccounts();
-            return pubkeys[0];
-        });
+    async getPublicKey() {
+        const pubkeys = await this.keyring.getAccounts();
+        return pubkeys[0];
     }
-    signMessage(text, type) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (type === 'bip322-simple') {
-                return yield (0, message_1.signMessageOfBIP322Simple)({
-                    message: text,
-                    address: this.address,
-                    networkType: this.networkType,
-                    wallet: this
-                });
-            }
-            else {
-                const pubkey = yield this.getPublicKey();
-                return yield this.keyring.signMessage(pubkey, text);
-            }
-        });
+    async signMessage(text, type) {
+        if (type === 'bip322-simple') {
+            return await signMessageOfBIP322Simple({
+                message: text,
+                address: this.address,
+                networkType: this.networkType,
+                wallet: this
+            });
+        }
+        else {
+            const pubkey = await this.getPublicKey();
+            return await this.keyring.signMessage(pubkey, text);
+        }
     }
-    formatOptionsToSignInputs(_psbt, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const accountAddress = this.address;
-            const accountPubkey = yield this.getPublicKey();
-            let toSignInputs = [];
-            if (options && options.toSignInputs) {
-                // We expect userToSignInputs objects to be similar to ToSignInput interface,
-                // but we allow address to be specified in addition to publicKey for convenience.
-                toSignInputs = options.toSignInputs.map((input) => {
-                    var _a;
-                    const index = Number(input.index);
-                    if (isNaN(index))
-                        throw new Error('invalid index in toSignInput');
-                    if (!input.address && !input.publicKey) {
-                        throw new Error('no address or public key in toSignInput');
-                    }
-                    if (input.address &&
-                        input.address != accountAddress) {
-                        throw new Error('invalid address in toSignInput');
-                    }
-                    if (input.publicKey &&
-                        input.publicKey != accountPubkey) {
-                        throw new Error('invalid public key in toSignInput');
-                    }
-                    const sighashTypes = (_a = input.sighashTypes) === null || _a === void 0 ? void 0 : _a.map(Number);
-                    if (sighashTypes === null || sighashTypes === void 0 ? void 0 : sighashTypes.some(isNaN))
-                        throw new Error('invalid sighash type in toSignInput');
-                    return {
-                        index,
-                        publicKey: accountPubkey,
-                        sighashTypes,
-                        disableTweakSigner: input.disableTweakSigner
-                    };
-                });
-            }
-            else {
-                const networkType = this.getNetworkType();
-                const psbtNetwork = (0, network_1.toPsbtNetwork)(networkType);
-                const psbt = typeof _psbt === 'string'
-                    ? bitcoin_core_1.bitcoin.Psbt.fromHex(_psbt, { network: psbtNetwork })
-                    : _psbt;
-                psbt.data.inputs.forEach((v, index) => {
-                    let script = null;
-                    if (v.witnessUtxo) {
-                        script = v.witnessUtxo.script;
-                    }
-                    else if (v.nonWitnessUtxo) {
-                        const tx = bitcoin_core_1.bitcoin.Transaction.fromBuffer(v.nonWitnessUtxo);
-                        const output = tx.outs[psbt.txInputs[index].index];
-                        script = output.script;
-                    }
-                    const isSigned = v.finalScriptSig || v.finalScriptWitness;
-                    if (script && !isSigned) {
-                        const address = (0, address_1.scriptPkToAddress)(script, this.networkType);
-                        if (accountAddress === address) {
-                            toSignInputs.push({
-                                index,
-                                publicKey: accountPubkey,
-                                sighashTypes: v.sighashType ? [v.sighashType] : undefined
-                            });
-                        }
+    async formatOptionsToSignInputs(_psbt, options) {
+        const accountAddress = this.address;
+        const accountPubkey = await this.getPublicKey();
+        let toSignInputs = [];
+        if (options && options.toSignInputs) {
+            // We expect userToSignInputs objects to be similar to ToSignInput interface,
+            // but we allow address to be specified in addition to publicKey for convenience.
+            toSignInputs = options.toSignInputs.map((input) => {
+                const index = Number(input.index);
+                if (isNaN(index))
+                    throw new Error('invalid index in toSignInput');
+                if (!input.address && !input.publicKey) {
+                    throw new Error('no address or public key in toSignInput');
+                }
+                if (input.address &&
+                    input.address != accountAddress) {
+                    throw new Error('invalid address in toSignInput');
+                }
+                if (input.publicKey &&
+                    input.publicKey != accountPubkey) {
+                    throw new Error('invalid public key in toSignInput');
+                }
+                const sighashTypes = input.sighashTypes?.map(Number);
+                if (sighashTypes?.some(isNaN))
+                    throw new Error('invalid sighash type in toSignInput');
+                return {
+                    index,
+                    publicKey: accountPubkey,
+                    sighashTypes,
+                    disableTweakSigner: input.disableTweakSigner
+                };
+            });
+        }
+        else {
+            const networkType = this.getNetworkType();
+            const psbtNetwork = toPsbtNetwork(networkType);
+            const psbt = typeof _psbt === 'string'
+                ? bitcoin.Psbt.fromHex(_psbt, { network: psbtNetwork })
+                : _psbt;
+            psbt.data.inputs.forEach((v, index) => {
+                let script = null;
+                if (v.witnessUtxo) {
+                    script = v.witnessUtxo.script;
+                }
+                else if (v.nonWitnessUtxo) {
+                    const tx = bitcoin.Transaction.fromBuffer(v.nonWitnessUtxo);
+                    const output = tx.outs[psbt.txInputs[index].index];
+                    script = output.script;
+                }
+                const isSigned = v.finalScriptSig || v.finalScriptWitness;
+                if (script && !isSigned) {
+                    const address = scriptPkToAddress(script, this.networkType);
+                    if (accountAddress === address) {
+                        toSignInputs.push({
+                            index,
+                            publicKey: accountPubkey,
+                            sighashTypes: v.sighashType ? [v.sighashType] : undefined
+                        });
                     }
-                });
-            }
-            return toSignInputs;
-        });
+                }
+            });
+        }
+        return toSignInputs;
     }
 }
-exports.EstimateWallet = EstimateWallet;

package/lib/wallet/index.js

@@ -1,19 +1,3 @@
-"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("./abstract-wallet"), exports);
-__exportStar(require("./estimate-wallet"), exports);
-__exportStar(require("./local-wallet"), exports);
+export * from './abstract-wallet';
+export * from './estimate-wallet';
+export * from './local-wallet';