@btc-vision/wallet-sdk 1.0.0

package/lib/wallet/estimate-wallet.js

@@ -0,0 +1,174 @@
+"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");
+/**
+ * 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({
+            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.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 });
+        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);
+                });
+            }
+            return psbt;
+        });
+    }
+    getPublicKey() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pubkeys = yield 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);
+            }
+        });
+    }
+    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
+                            });
+                        }
+                    }
+                });
+            }
+            return toSignInputs;
+        });
+    }
+}
+exports.EstimateWallet = EstimateWallet;

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

@@ -0,0 +1,19 @@
+"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);

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;
+    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(text: string, type: 'bip322-simple' | 'ecdsa'): Promise<string>;
+    signData(data: string, type?: 'ecdsa' | 'schnorr'): Promise<string>;
+    private formatOptionsToSignInputs;
+}

package/lib/wallet/local-wallet.js

@@ -0,0 +1,183 @@
+"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.LocalWallet = 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");
+class LocalWallet {
+    constructor(wif, addressType = types_1.AddressType.P2WPKH, networkType = network_1.NetworkType.MAINNET) {
+        const network = (0, network_1.toPsbtNetwork)(networkType);
+        const keyPair = bitcoin_core_1.ECPair.fromWIF(wif, network);
+        this.keyring = new keyring_1.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.network = network;
+        this.networkType = networkType;
+        this.addressType = addressType;
+        this.scriptPk = (0, address_1.publicKeyToScriptPk)(this.pubkey, addressType, networkType);
+    }
+    static fromMnemonic(addressType, networkType, mnemonic, passPhrase, hdPath) {
+        const keyring = new keyring_1.HdKeyring({
+            mnemonic,
+            hdPath,
+            passphrase: passPhrase,
+            activeIndexes: [0]
+        });
+        const _wallet = keyring.wallets[0];
+        _wallet.network = (0, network_1.toPsbtNetwork)(networkType);
+        return new LocalWallet(keyring.wallets[0].toWIF(), addressType, networkType);
+    }
+    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 });
+        return new LocalWallet(ecpair.toWIF(), addressType, networkType);
+    }
+    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 = this.keyring.signTransaction(psbt, _inputs);
+            if (_opts.autoFinalized) {
+                _inputs.forEach((v) => {
+                    // psbt.validateSignaturesOfInput(v.index, validator);
+                    psbt.finalizeInput(v.index);
+                });
+            }
+            return psbt;
+        });
+    }
+    getPublicKey() {
+        const pubkeys = 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 = this.getPublicKey();
+                return this.keyring.signMessage(pubkey, text);
+            }
+        });
+    }
+    signData(data, type = 'ecdsa') {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pubkey = this.getPublicKey();
+            return this.keyring.signData(pubkey, data, type);
+        });
+    }
+    formatOptionsToSignInputs(_psbt, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const accountAddress = this.address;
+            const accountPubkey = 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
+                            });
+                        }
+                    }
+                });
+            }
+            return toSignInputs;
+        });
+    }
+}
+exports.LocalWallet = LocalWallet;

package/package.json

@@ -0,0 +1,97 @@
+{
+  "name": "@btc-vision/wallet-sdk",
+  "version": "1.0.0",
+  "description": "UniSat Wallet SDK",
+  "keywords": [
+    "bitcoin",
+    "keyring",
+    "unisat"
+  ],
+  "homepage": "https://github.com/btc-vision/wallet-sdk#readme",
+  "bugs": {
+    "url": "https://github.com/btc-vision/wallet-sdk/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/btc-vision/wallet-sdk.git"
+  },
+  "author": "cybersinsloth",
+  "license": "ISC",
+  "main": "lib/index.js",
+  "module": "es/index.js",
+  "types": "lib/index.d.ts",
+  "files": [
+    "/es",
+    "/lib"
+  ],
+  "scripts": {
+    "build": "npm run build:cjs && npm run build:esm",
+    "build:cjs": "rimraf lib && cross-env BABEL_ENV=cjs gulp build",
+    "build:esm": "rimraf es && cross-env BABEL_ENV=esm gulp build",
+    "build:typed": "tsc --declaration --emitDeclarationOnly --noEmit false",
+    "test": "mocha -r ts-node/register test/**/*.ts --timeout 300000",
+    "prepublishOnly": "npm run build",
+    "lint": "eslint ./src ./test"
+  },
+  "dependencies": {
+    "@bitcoinerlab/secp256k1": "^1.1.1",
+    "@keystonehq/keystone-sdk": "^0.3.0",
+    "big-integer": "^1.6.52",
+    "bignumber.js": "^9.1.2",
+    "bip-schnorr": "^0.6.7",
+    "bip39": "^3.1.0",
+    "bitcoinjs-lib": "^6.1.6",
+    "bitcore-lib": "^10.2.1",
+    "ecpair": "^2.1.0",
+    "hdkey": "^2.1.0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.16.7",
+    "@babel/plugin-transform-runtime": "^7.16.5",
+    "@babel/preset-env": "^7.16.5",
+    "@babel/preset-typescript": "^7.16.5",
+    "@types/bitcore-lib": "^0.15.6",
+    "@types/chai": "^4.2.20",
+    "@types/hdkey": "^2.0.3",
+    "@types/mocha": "^8.2.2",
+    "@types/node": "^16.11.10",
+    "@typescript-eslint/eslint-plugin": "^5.59.1",
+    "@typescript-eslint/parser": "^5.59.1",
+    "babel-loader": "^8.2.3",
+    "browserify-zlib": "^0.2.0",
+    "chai": "^4.3.4",
+    "clean-webpack-plugin": "^4.0.0",
+    "cross-env": "^7.0.3",
+    "crypto-browserify": "^3.12.0",
+    "eslint": "8.0.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.1.3",
+    "eslint-webpack-plugin": "^4.1.0",
+    "glob": "^7.1.7",
+    "gulp": "^4.0.2",
+    "gulp-babel": "^8.0.0",
+    "gulp-typescript": "*",
+    "https-browserify": "^1.0.0",
+    "mocha": "10.1.0",
+    "prettier": "^3.2.5",
+    "stream-browserify": "^3.0.0",
+    "stream-http": "^3.2.0",
+    "ts-loader": "^9.5.1",
+    "ts-node": "^10.4.0",
+    "tsconfig-paths-webpack-plugin": "^4.1.0",
+    "typescript": "^4.5.3",
+    "watch": "^1.0.2",
+    "watchify": "^4.0.0",
+    "webpack": "^5.91.0",
+    "webpack-cli": "^4.9.1",
+    "webpack-stream": "^7.0.0",
+    "vm-browserify": "^1.1.2"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}