@atomicfinance/bitcoin-node-wallet-provider 3.5.0 → 3.5.2

package/lib/BitcoinNodeWalletProvider.js

@@ -0,0 +1,173 @@
+"use strict";
+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 crypto_1 = require("@atomicfinance/crypto");
+const jsonrpc_provider_1 = require("@atomicfinance/jsonrpc-provider");
+const provider_1 = __importDefault(require("@atomicfinance/provider"));
+const types_1 = require("@atomicfinance/types");
+const bitcoin_networks_1 = require("bitcoin-networks");
+const bitcoinjs_lib_1 = require("bitcoinjs-lib");
+const lodash_1 = require("lodash");
+const BIP70_CHAIN_TO_NETWORK = {
+    main: bitcoin_networks_1.BitcoinNetworks.bitcoin,
+    test: bitcoin_networks_1.BitcoinNetworks.bitcoin_testnet,
+    regtest: bitcoin_networks_1.BitcoinNetworks.bitcoin_regtest,
+};
+class BitcoinNodeWalletProvider extends provider_1.default {
+    constructor(opts) {
+        super();
+        const { uri, username, password, network, addressType = types_1.bitcoin.AddressType.BECH32, } = opts;
+        const addressTypes = Object.values(types_1.bitcoin.AddressType);
+        if (!addressTypes.includes(addressType)) {
+            throw new Error(`addressType must be one of ${addressTypes.join(',')}`);
+        }
+        this._addressType = addressType;
+        this._network = network;
+        this._rpc = new jsonrpc_provider_1.JsonRpcProvider(uri, username, password);
+        this._addressInfoCache = {};
+    }
+    async signMessage(message, from) {
+        return this._rpc
+            .jsonrpc('signmessage', from, message)
+            .then((result) => Buffer.from(result, 'base64').toString('hex'));
+    }
+    async withTxFee(func, feePerByte) {
+        const feePerKB = new types_1.BigNumber(feePerByte).div(1e8).times(1000).toNumber();
+        const originalTxFee = (await this._rpc.jsonrpc('getwalletinfo'))
+            .paytxfee;
+        await this._rpc.jsonrpc('settxfee', feePerKB);
+        const result = await func();
+        await this._rpc.jsonrpc('settxfee', originalTxFee);
+        return result;
+    }
+    async _sendTransaction(options) {
+        const value = new types_1.BigNumber(options.value).dividedBy(1e8).toNumber();
+        const hash = await this._rpc.jsonrpc('sendtoaddress', options.to, value, '', '', false, true);
+        const transaction = await this._rpc.jsonrpc('gettransaction', hash, true);
+        const fee = new types_1.BigNumber(transaction.fee).abs().times(1e8).toNumber();
+        return (0, bitcoin_utils_1.normalizeTransactionObject)((0, bitcoin_utils_1.decodeRawTransaction)(transaction.hex, this._network), fee);
+    }
+    async sendTransaction(options) {
+        return options.fee
+            ? this.withTxFee(async () => this._sendTransaction(options), options.fee)
+            : this._sendTransaction(options);
+    }
+    async updateTransactionFee(tx, newFeePerByte) {
+        const txHash = (0, lodash_1.isString)(tx) ? tx : tx.hash;
+        return this.withTxFee(async () => {
+            const result = await this._rpc.jsonrpc('bumpfee', txHash);
+            const transaction = await this._rpc.jsonrpc('gettransaction', result.txid, true);
+            const fee = new types_1.BigNumber(transaction.fee).abs().times(1e8).toNumber();
+            return (0, bitcoin_utils_1.normalizeTransactionObject)((0, bitcoin_utils_1.decodeRawTransaction)(transaction.hex, this._network), fee);
+        }, newFeePerByte);
+    }
+    async signPSBT(data, inputs) {
+        const psbt = bitcoinjs_lib_1.Psbt.fromBase64(data, { network: this._network });
+        for (const input of inputs) {
+            const usedAddresses = await this.getUsedAddresses();
+            const address = usedAddresses.find((address) => address.derivationPath === input.derivationPath);
+            const wif = await this.dumpPrivKey(address.address);
+            const keyPair = bitcoinjs_lib_1.ECPair.fromWIF(wif, this._network);
+            psbt.signInput(input.index, keyPair);
+        }
+        return psbt.toBase64();
+    }
+    async signBatchP2SHTransaction(inputs, addresses, tx, locktime, segwit = false) {
+        const wallets = [];
+        for (const address of addresses) {
+            const wif = await this.dumpPrivKey(address);
+            const wallet = bitcoinjs_lib_1.ECPair.fromWIF(wif, this._network);
+            wallets.push(wallet);
+        }
+        const sigs = [];
+        for (let i = 0; i < inputs.length; i++) {
+            let sigHash;
+            if (segwit) {
+                sigHash = tx.hashForWitnessV0(inputs[i].index, inputs[i].outputScript, inputs[i].vout.vSat, bitcoinjs_lib_1.Transaction.SIGHASH_ALL); // AMOUNT NEEDS TO BE PREVOUT AMOUNT
+            }
+            else {
+                sigHash = tx.hashForSignature(inputs[i].index, inputs[i].outputScript, bitcoinjs_lib_1.Transaction.SIGHASH_ALL);
+            }
+            const sig = bitcoinjs_lib_1.script.signature.encode(wallets[i].sign(sigHash), bitcoinjs_lib_1.Transaction.SIGHASH_ALL);
+            sigs.push(sig);
+        }
+        return sigs;
+    }
+    async dumpPrivKey(address) {
+        return this._rpc.jsonrpc('dumpprivkey', address);
+    }
+    async getNewAddress(addressType, label = '') {
+        const params = addressType ? [label, addressType] : [label];
+        const newAddress = await this._rpc.jsonrpc('getnewaddress', ...params);
+        if (!newAddress)
+            return null;
+        return this.getAddressInfo(newAddress);
+    }
+    async getAddressInfo(address) {
+        if (address in this._addressInfoCache) {
+            return this._addressInfoCache[address];
+        }
+        const addressInfo = await this._rpc.jsonrpc('getaddressinfo', address);
+        let publicKey, derivationPath;
+        if (!addressInfo.iswatchonly) {
+            publicKey = addressInfo.pubkey;
+            derivationPath = addressInfo.hdkeypath;
+        }
+        const addressObject = new types_1.Address({ address, publicKey, derivationPath });
+        this._addressInfoCache[address] = addressObject;
+        return addressObject;
+    }
+    async getAddresses() {
+        return this.getUsedAddresses();
+    }
+    async getUnusedAddress() {
+        return this.getNewAddress(this._addressType);
+    }
+    async getUsedAddresses() {
+        const usedAddresses = await this._rpc.jsonrpc('listaddressgroupings');
+        const emptyAddresses = await this._rpc.jsonrpc('listreceivedbyaddress', 0, true, false);
+        const addrs = (0, lodash_1.uniq)([
+            ...(0, lodash_1.flatten)(usedAddresses).map((addr) => addr[0]),
+            ...emptyAddresses.map((a) => a.address),
+        ]);
+        const addressObjects = await Promise.all(addrs.map((address) => this.getAddressInfo(address)));
+        return addressObjects;
+    }
+    async getWalletAddress(address) {
+        return this.getAddressInfo(address);
+    }
+    async isWalletAvailable() {
+        try {
+            await this._rpc.jsonrpc('getwalletinfo');
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    async getConnectedNetwork() {
+        const blockchainInfo = await this._rpc.jsonrpc('getblockchaininfo');
+        const chain = blockchainInfo.chain;
+        return BIP70_CHAIN_TO_NETWORK[chain];
+    }
+    async generateSecret(message) {
+        const secretAddressLabel = 'secretAddress';
+        let address;
+        try {
+            const labelAddresses = await this._rpc.jsonrpc('getaddressesbylabel', secretAddressLabel);
+            address = Object.keys(labelAddresses)[0];
+        }
+        catch (e) {
+            // Label does not exist
+            address = (await this.getNewAddress(types_1.bitcoin.AddressType.LEGACY, secretAddressLabel)).address; // Signing only possible with legacy addresses
+        }
+        const signedMessage = await this.signMessage(message, address);
+        const secret = (0, crypto_1.sha256)(signedMessage);
+        return secret;
+    }
+}
+exports.default = BitcoinNodeWalletProvider;
+//# sourceMappingURL=BitcoinNodeWalletProvider.js.map

package/lib/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomicfinance/bitcoin-node-wallet-provider",
-  "version": "3.5.0",
+  "version": "3.5.2",
   "description": "",
   "module": "dist/index.js",
   "main": "dist/index.js",
@@ -25,11 +25,11 @@
     "node": ">=14"
   },
   "dependencies": {
-    "@atomicfinance/bitcoin-utils": "^3.5.0",
-    "@atomicfinance/crypto": "^3.5.0",
-    "@atomicfinance/jsonrpc-provider": "^3.5.0",
-    "@atomicfinance/types": "^3.5.0",
-    "@atomicfinance/utils": "^3.5.0",
+    "@atomicfinance/bitcoin-utils": "^3.5.2",
+    "@atomicfinance/crypto": "^3.5.2",
+    "@atomicfinance/jsonrpc-provider": "^3.5.2",
+    "@atomicfinance/types": "^3.5.2",
+    "@atomicfinance/utils": "^3.5.2",
     "@babel/runtime": "^7.12.1",
     "bignumber.js": "^9.0.0",
     "bitcoin-networks": "^1.0.0",