@atomicfinance/bitcoin-js-wallet-provider 3.5.2 → 3.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomicfinance/bitcoin-js-wallet-provider",
-  "version": "3.5.2",
+  "version": "3.6.0",
   "description": "",
   "module": "dist/index.js",
   "main": "dist/index.js",
@@ -24,12 +24,12 @@
     "node": ">=14"
   },
   "dependencies": {
-    "@atomicfinance/bitcoin-utils": "^3.5.2",
-    "@atomicfinance/bitcoin-wallet-provider": "^3.5.2",
-    "@atomicfinance/types": "^3.5.2",
-    "@atomicfinance/utils": "^3.5.2",
+    "@atomicfinance/bitcoin-utils": "^3.6.0",
+    "@atomicfinance/bitcoin-wallet-provider": "^3.6.0",
+    "@atomicfinance/types": "^3.6.0",
+    "@atomicfinance/utils": "^3.6.0",
     "@babel/runtime": "^7.12.1",
-    "@node-dlc/core": "0.23.6",
+    "@node-dlc/core": "0.24.0",
     "bip32": "^2.0.6",
     "bip39": "^3.0.2",
     "bitcoin-networks": "^1.0.0",

package/lib/BitcoinJsWalletProvider.js

@@ -1,424 +0,0 @@
-"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 });
-const bitcoin_utils_1 = require("@atomicfinance/bitcoin-utils");
-const bitcoin_wallet_provider_1 = __importDefault(require("@atomicfinance/bitcoin-wallet-provider"));
-const provider_1 = __importDefault(require("@atomicfinance/provider"));
-const types_1 = require("@atomicfinance/types");
-const assert_1 = __importDefault(require("assert"));
-const bip32_1 = require("bip32");
-const bip39_1 = require("bip39");
-const bitcoin = __importStar(require("bitcoinjs-lib"));
-const bitcoinjs_lib_1 = require("bitcoinjs-lib");
-const bitcoinjs_message_1 = require("bitcoinjs-message");
-const secp256k1_1 = __importDefault(require("secp256k1"));
-const FEE_PER_BYTE_FALLBACK = 5;
-class BitcoinJsWalletProvider extends (0, bitcoin_wallet_provider_1.default)(provider_1.default) {
-    constructor(options) {
-        const { network, mnemonic, baseDerivationPath, addressType = types_1.bitcoin.AddressType.BECH32, addressIndex = 0, changeAddressIndex = 0, } = options;
-        super({
-            network,
-            baseDerivationPath,
-            addressType,
-            addressIndex,
-            changeAddressIndex,
-        });
-        if (!mnemonic)
-            throw new Error('Mnemonic should not be empty');
-        this._mnemonic = mnemonic;
-    }
-    async seedNode() {
-        if (this._seedNode)
-            return this._seedNode;
-        const seed = await (0, bip39_1.mnemonicToSeed)(this._mnemonic);
-        this._seedNode = (0, bip32_1.fromSeed)(seed, this._network);
-        return this._seedNode;
-    }
-    async baseDerivationNode() {
-        if (this._baseDerivationNode)
-            return this._baseDerivationNode;
-        const baseNode = await this.seedNode();
-        this._baseDerivationNode = baseNode.derivePath(this._baseDerivationPath);
-        return this._baseDerivationNode;
-    }
-    async keyPair(derivationPath) {
-        const wif = await this._toWIF(derivationPath);
-        return bitcoinjs_lib_1.ECPair.fromWIF(wif, this._network);
-    }
-    async _toWIF(derivationPath) {
-        const node = await this.seedNode();
-        return node.derivePath(derivationPath).toWIF();
-    }
-    async exportPrivateKey() {
-        return this._toWIF(this._baseDerivationPath);
-    }
-    async signMessage(message, from) {
-        const address = await this.getWalletAddress(from);
-        const keyPair = await this.keyPair(address.derivationPath);
-        const signature = await (0, bitcoinjs_message_1.signAsync)(message, keyPair.privateKey, keyPair.compressed);
-        return signature.toString('hex');
-    }
-    _createMultisigPayment(m, pubkeys) {
-        if (m > pubkeys.length) {
-            throw new Error(`not enough keys supplied (got ${pubkeys.length} keys, but need at least ${m} to redeem)`);
-        }
-        // Create m-of-n multisig
-        const p2ms = bitcoin.payments.p2ms({
-            m: m,
-            pubkeys: pubkeys.map((key) => Buffer.from(key, 'hex')),
-            network: this._network,
-        });
-        // Create p2wsh for multisig
-        const p2wsh = bitcoin.payments.p2wsh({
-            redeem: p2ms,
-            network: this._network,
-        });
-        return p2wsh;
-    }
-    /**
-     * Creates a native-segwit multi-signature address (P2MS in P2WSH) with n signatures of m required keys
-     * https://developer.bitcoin.org/reference/rpc/createmultisig.html
-     * @param m the number of required signatures
-     * @param pubkeys n possible pubkeys in total
-     * @returns a json object containing the `address` and `redeemScript`
-     */
-    createMultisig(m, pubkeys) {
-        const p2wsh = this._createMultisigPayment(m, pubkeys);
-        return {
-            address: p2wsh.address,
-            redeemScript: p2wsh.redeem?.output?.toString('hex'),
-        };
-    }
-    /**
-     * Creates a PSBT of a native-segwit multi-signature address (P2MS in P2WSH) with n signatures of m required keys
-     * https://developer.bitcoin.org/reference/rpc/createmultisig.html
-     * https://developer.bitcoin.org/reference/rpc/createpsbt.html
-     * @param m the number of required signatures
-     * @param pubkeys n possible pubkeys in total
-     * @param inputs the Inputs to the PSBT
-     * @param ouputs the Outputs to the PSBT
-     * @returns a base64 encoded psbt string
-     */
-    buildMultisigPSBT(m, pubkeys, inputs, outputs) {
-        (0, assert_1.default)(inputs.length > 0, 'no inputs found');
-        (0, assert_1.default)(outputs.length > 0, 'no outputs found');
-        const p2wsh = this._createMultisigPayment(m, pubkeys);
-        // Verify pubkeyhash for all inputs matches the p2wsh hash
-        (0, assert_1.default)(inputs.every((input) => p2wsh.output.toString('hex') === input.scriptPubKey), 'address pubkeyhash does not match input scriptPubKey');
-        // creator
-        const psbt = new bitcoin.Psbt({ network: this._network });
-        // updater
-        inputs.forEach((input) => {
-            psbt.addInput({
-                hash: input.txid,
-                index: input.vout,
-                witnessUtxo: { script: p2wsh.output, value: input.value },
-                witnessScript: p2wsh.redeem.output,
-            });
-        });
-        outputs.forEach((output) => {
-            psbt.addOutput({
-                address: output.to,
-                value: output.value,
-            });
-        });
-        return psbt.toBase64();
-    }
-    /**
-     * Update a PSBT with input information from our wallet and then sign inputs that we can sign for
-     * https://developer.bitcoin.org/reference/rpc/walletprocesspsbt.html
-     * @param psbt a base64 encoded psbt string (P2WSH only)
-     * @returns a base64 encoded signed psbt string
-     */
-    async walletProcessPSBT(psbtString) {
-        const psbt = bitcoin.Psbt.fromBase64(psbtString);
-        await Promise.all(psbt.data.inputs.map(async (input, i) => {
-            (0, assert_1.default)(psbt.getInputType(i).slice(0, 5) === 'p2wsh', 'only accepts P2WSH inputs');
-            const scriptStack = bitcoin.script.decompile(input.witnessScript);
-            const pubkeys = scriptStack.filter((data) => Buffer.isBuffer(data) && secp256k1_1.default.publicKeyVerify(data));
-            await Promise.all(pubkeys.map(async (key) => {
-                // create address using pubkey
-                const { address: addressString } = bitcoin.payments.p2wpkh({
-                    pubkey: key,
-                    network: this._network,
-                });
-                // Retrieve address object from wallet using address
-                const address = await this.findAddress([addressString]);
-                // exit if address doesn't exist in wallet
-                if (!address)
-                    return;
-                // derive keypair
-                const keyPair = await this.keyPair(address.derivationPath);
-                // sign PSBT using keypair
-                psbt.signInput(i, keyPair);
-            }));
-        }));
-        psbt.validateSignaturesOfAllInputs(); // ensure all signatures are valid!
-        return psbt.toBase64();
-    }
-    /**
-     * Finalize the inputs of a PSBT. If the transaction is fully signed, it will
-     * produce a network serialized transaction which can be broadcast with sendrawtransaction
-     * https://developer.bitcoin.org/reference/rpc/finalizepsbt.html
-     * @param psbt a base64 encoded psbt string
-     * @returns a json object containing `psbt` in base64, `hex` for transaction and `complete` for if
-     * the transaction has a complete set of signatures
-     */
-    finalizePSBT(psbtString) {
-        const psbt = bitcoin.Psbt.fromBase64(psbtString);
-        try {
-            psbt.validateSignaturesOfAllInputs(); // ensure all signatures are valid!
-            psbt.finalizeAllInputs();
-        }
-        catch (error) {
-            return {
-                psbt: psbt.toBase64(),
-                complete: false,
-            };
-        }
-        return {
-            psbt: psbt.toBase64(),
-            hex: psbt.extractTransaction().toHex(),
-            complete: true,
-        };
-    }
-    async sendSweepTransactionWithSetOutputs(externalChangeAddress, feePerByte, _outputs, fixedInputs) {
-        const { hex, fee } = await this._buildSweepTransactionWithSetOutputs(externalChangeAddress, feePerByte, _outputs, fixedInputs);
-        await this.getMethod('sendRawTransaction')(hex);
-        return (0, bitcoin_utils_1.normalizeTransactionObject)((0, bitcoin_utils_1.decodeRawTransaction)(hex, this._network), fee);
-    }
-    async buildSweepTransactionWithSetOutputs(externalChangeAddress, feePerByte, _outputs, fixedInputs) {
-        return this._buildSweepTransactionWithSetOutputs(externalChangeAddress, feePerByte, _outputs, fixedInputs);
-    }
-    async _buildSweepTransactionWithSetOutputs(externalChangeAddress, feePerByte, _outputs = [], fixedInputs) {
-        const _feePerByte = feePerByte ||
-            (await this.getMethod('getFeePerByte')()) ||
-            FEE_PER_BYTE_FALLBACK;
-        const inputs = [];
-        const outputs = [];
-        try {
-            const inputsForAmount = await this.getInputsForAmount(_outputs, _feePerByte, fixedInputs, 100, true);
-            if (inputsForAmount.change) {
-                throw Error('There should not be any change for sweeping transaction');
-            }
-            inputs.push(...(inputsForAmount.inputs || []));
-            outputs.push(...(inputsForAmount.outputs || []));
-        }
-        catch (e) {
-            if (fixedInputs.length === 0) {
-                throw Error(`Inputs for amount doesn't exist and no fixedInputs provided`);
-            }
-            const inputsForAmount = await this._getInputForAmountWithoutUtxoCheck(_outputs, _feePerByte, fixedInputs);
-            inputs.push(...(inputsForAmount.inputs.map((utxo) => types_1.Input.fromUTXO(utxo)) || []));
-            outputs.push(...(inputsForAmount.outputs || []));
-        }
-        _outputs.forEach((output) => {
-            const spliceIndex = outputs.findIndex((sweepOutput) => output.value === sweepOutput.value);
-            outputs.splice(spliceIndex, 1);
-        });
-        _outputs.push({
-            to: externalChangeAddress,
-            value: outputs[0].value,
-        });
-        return this._buildTransactionWithoutUtxoCheck(_outputs, _feePerByte, inputs);
-    }
-    _getInputForAmountWithoutUtxoCheck(_outputs, _feePerByte, fixedInputs) {
-        const utxoBalance = fixedInputs.reduce((a, b) => a + (b['value'] || 0), 0);
-        const outputBalance = _outputs.reduce((a, b) => a + (b['value'] || 0), 0);
-        const amountToSend = utxoBalance -
-            _feePerByte * ((_outputs.length + 1) * 39 + fixedInputs.length * 153); // todo better calculation
-        const targets = _outputs.map((target, i) => ({
-            id: 'main',
-            value: target.value,
-        }));
-        if (amountToSend - outputBalance > 0) {
-            targets.push({ id: 'main', value: amountToSend - outputBalance });
-        }
-        return (0, bitcoin_utils_1.selectCoins)(fixedInputs, targets, Math.ceil(_feePerByte), fixedInputs);
-    }
-    async _buildTransactionWithoutUtxoCheck(outputs, feePerByte, fixedInputs) {
-        const network = this._network;
-        const { fee } = this._getInputForAmountWithoutUtxoCheck(outputs, feePerByte, fixedInputs);
-        const inputs = fixedInputs;
-        const txb = new bitcoin.TransactionBuilder(network);
-        for (const output of outputs) {
-            const to = output.to; // Allow for OP_RETURN
-            txb.addOutput(to, output.value);
-        }
-        const prevOutScriptType = 'p2wpkh';
-        for (let i = 0; i < inputs.length; i++) {
-            const wallet = await this.getWalletAddress(inputs[i].address);
-            const keyPair = await this.keyPair(wallet.derivationPath);
-            const paymentVariant = this.getPaymentVariantFromPublicKey(keyPair.publicKey);
-            txb.addInput(inputs[i].txid, inputs[i].vout, 0, paymentVariant.output);
-        }
-        for (let i = 0; i < inputs.length; i++) {
-            const wallet = await this.getWalletAddress(inputs[i].address);
-            const keyPair = await this.keyPair(wallet.derivationPath);
-            const paymentVariant = this.getPaymentVariantFromPublicKey(keyPair.publicKey);
-            const needsWitness = true;
-            const signParams = {
-                prevOutScriptType,
-                vin: i,
-                keyPair,
-                witnessValue: 0,
-            };
-            if (needsWitness) {
-                signParams.witnessValue = inputs[i].value;
-            }
-            txb.sign(signParams);
-        }
-        return { hex: txb.build().toHex(), fee };
-    }
-    async _buildTransaction(targets, feePerByte, fixedInputs) {
-        const network = this._network;
-        const unusedAddress = await this.getUnusedAddress(true);
-        const { inputs, change, fee } = await this.getInputsForAmount(targets, feePerByte, fixedInputs);
-        if (change) {
-            targets.push({
-                address: unusedAddress.address,
-                value: change.value,
-            });
-        }
-        const psbt = new bitcoinjs_lib_1.Psbt({ network });
-        const needsWitness = [
-            types_1.bitcoin.AddressType.BECH32,
-            types_1.bitcoin.AddressType.P2SH_SEGWIT,
-        ].includes(this._addressType);
-        for (let i = 0; i < inputs.length; i++) {
-            const wallet = await this.getWalletAddress(inputs[i].address);
-            const keyPair = await this.keyPair(wallet.derivationPath);
-            const paymentVariant = this.getPaymentVariantFromPublicKey(keyPair.publicKey);
-            const psbtInput = {
-                hash: inputs[i].txid,
-                index: inputs[i].vout,
-                sequence: 0,
-            };
-            if (needsWitness) {
-                psbtInput.witnessUtxo = {
-                    script: paymentVariant.output,
-                    value: inputs[i].value,
-                };
-            }
-            else {
-                const inputTxRaw = await this.getMethod('getRawTransactionByHash')(inputs[i].txid);
-                psbtInput.nonWitnessUtxo = Buffer.from(inputTxRaw, 'hex');
-            }
-            if (this._addressType === types_1.bitcoin.AddressType.P2SH_SEGWIT) {
-                psbtInput.redeemScript = paymentVariant.redeem.output;
-            }
-            psbt.addInput(psbtInput);
-        }
-        for (const output of targets) {
-            if (output.script) {
-                psbt.addOutput({
-                    value: output.value,
-                    script: output.script,
-                });
-            }
-            else {
-                psbt.addOutput({
-                    value: output.value,
-                    address: output.address,
-                });
-            }
-        }
-        for (let i = 0; i < inputs.length; i++) {
-            const wallet = await this.getWalletAddress(inputs[i].address);
-            const keyPair = await this.keyPair(wallet.derivationPath);
-            psbt.signInput(i, keyPair);
-            psbt.validateSignaturesOfInput(i);
-        }
-        psbt.finalizeAllInputs();
-        return { hex: psbt.extractTransaction().toHex(), fee };
-    }
-    async _buildSweepTransaction(externalChangeAddress, feePerByte) {
-        let _feePerByte = feePerByte || null;
-        if (!_feePerByte)
-            _feePerByte = await this.getMethod('getFeePerByte')();
-        const { inputs, outputs, change } = await this.getInputsForAmount([], _feePerByte, [], 100, true);
-        if (change) {
-            throw new Error('There should not be any change for sweeping transaction');
-        }
-        const _outputs = [
-            {
-                address: externalChangeAddress,
-                value: outputs[0].value,
-            },
-        ];
-        return this._buildTransaction(_outputs, feePerByte, inputs);
-    }
-    async signPSBT(data, inputs) {
-        const psbt = bitcoinjs_lib_1.Psbt.fromBase64(data, { network: this._network });
-        for (const input of inputs) {
-            const keyPair = await this.keyPair(input.derivationPath);
-            psbt.signInput(input.index, keyPair);
-        }
-        return psbt.toBase64();
-    }
-    async signBatchP2SHTransaction(inputs, addresses, tx, _lockTime, segwit) {
-        const keyPairs = [];
-        for (const address of addresses) {
-            const wallet = await this.getWalletAddress(address);
-            const keyPair = await this.keyPair(wallet.derivationPath);
-            keyPairs.push(keyPair);
-        }
-        const sigs = [];
-        for (let i = 0; i < inputs.length; i++) {
-            const index = inputs[i].txInputIndex
-                ? inputs[i].txInputIndex
-                : inputs[i].index;
-            let sigHash;
-            if (segwit) {
-                sigHash = tx.hashForWitnessV0(index, inputs[i].outputScript, inputs[i].vout.vSat, bitcoinjs_lib_1.Transaction.SIGHASH_ALL);
-            }
-            else {
-                sigHash = tx.hashForSignature(index, inputs[i].outputScript, bitcoinjs_lib_1.Transaction.SIGHASH_ALL);
-            }
-            const sig = bitcoinjs_lib_1.script.signature.encode(keyPairs[i].sign(sigHash), bitcoinjs_lib_1.Transaction.SIGHASH_ALL);
-            sigs.push(sig);
-        }
-        return sigs;
-    }
-    getScriptType() {
-        if (this._addressType === types_1.bitcoin.AddressType.LEGACY)
-            return 'p2pkh';
-        else if (this._addressType === types_1.bitcoin.AddressType.P2SH_SEGWIT)
-            return 'p2sh-p2wpkh';
-        else if (this._addressType === types_1.bitcoin.AddressType.BECH32)
-            return 'p2wpkh';
-    }
-    async getConnectedNetwork() {
-        return this._network;
-    }
-    async isWalletAvailable() {
-        return true;
-    }
-}
-exports.default = BitcoinJsWalletProvider;
-//# sourceMappingURL=BitcoinJsWalletProvider.js.map

package/lib/index.js

@@ -1,9 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BitcoinJsWalletProvider = void 0;
-const BitcoinJsWalletProvider_1 = __importDefault(require("./BitcoinJsWalletProvider"));
-exports.BitcoinJsWalletProvider = BitcoinJsWalletProvider_1.default;
-//# sourceMappingURL=index.js.map