@atomicfinance/bitcoin-rpc-provider 3.5.0 → 3.5.2

package/lib/BitcoinRpcProvider.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const bitcoin_utils_1 = require("@atomicfinance/bitcoin-utils");
+const errors_1 = require("@atomicfinance/errors");
+const jsonrpc_provider_1 = require("@atomicfinance/jsonrpc-provider");
+const types_1 = require("@atomicfinance/types");
+const utils_1 = require("@atomicfinance/utils");
+const lodash_1 = require("lodash");
+class BitcoinRpcProvider extends jsonrpc_provider_1.JsonRpcProvider {
+    constructor(options) {
+        const { uri, username, password, network, feeBlockConfirmations = 1, defaultFeePerByte = 3, } = options;
+        super(uri, username, password);
+        this._network = network;
+        this._feeBlockConfirmations = feeBlockConfirmations;
+        this._defaultFeePerByte = defaultFeePerByte;
+        this._usedAddressCache = {};
+    }
+    async decodeRawTransaction(rawTransaction) {
+        return this.jsonrpc('decoderawtransaction', rawTransaction);
+    }
+    async getFeePerByte(numberOfBlocks = this._feeBlockConfirmations) {
+        try {
+            const { feerate } = await this.jsonrpc('estimatesmartfee', numberOfBlocks);
+            if (feerate && feerate > 0) {
+                return Math.ceil((feerate * 1e8) / 1000);
+            }
+            throw new Error('Invalid estimated fee');
+        }
+        catch (e) {
+            return this._defaultFeePerByte;
+        }
+    }
+    async getMinRelayFee() {
+        const { relayfee } = await this.jsonrpc('getnetworkinfo');
+        return (relayfee * 1e8) / 1000;
+    }
+    async getBalance(_addresses) {
+        const addresses = _addresses.map(utils_1.addressToString);
+        const _utxos = await this.getUnspentTransactions(addresses);
+        const utxos = (0, lodash_1.flatten)(_utxos);
+        return utxos.reduce((acc, utxo) => acc.plus(utxo.value), new types_1.BigNumber(0));
+    }
+    async getUnspentTransactions(_addresses) {
+        const addresses = _addresses.map(utils_1.addressToString);
+        const utxos = await this.jsonrpc('listunspent', 0, 9999999, addresses);
+        return utxos.map((utxo) => ({
+            ...utxo,
+            value: new types_1.BigNumber(utxo.amount).times(1e8).toNumber(),
+        }));
+    }
+    async getAddressTransactionCounts(_addresses) {
+        const addresses = _addresses.map(utils_1.addressToString);
+        const receivedAddresses = await this.jsonrpc('listreceivedbyaddress', 0, false, true);
+        return addresses.reduce((acc, addr) => {
+            const receivedAddress = receivedAddresses.find((receivedAddress) => receivedAddress.address === addr);
+            const transactionCount = receivedAddress
+                ? receivedAddress.txids.length
+                : 0;
+            acc[addr] = transactionCount;
+            return acc;
+        }, {});
+    }
+    async getReceivedByAddress(address) {
+        return this.jsonrpc('getreceivedbyaddress', address);
+    }
+    async importAddresses(addresses) {
+        const request = addresses.map((address) => ({
+            scriptPubKey: { address },
+            timestamp: 0,
+        }));
+        return this.jsonrpc('importmulti', request);
+    }
+    async getTransactionHex(transactionHash) {
+        return this.jsonrpc('getrawtransaction', transactionHash);
+    }
+    async generateBlock(numberOfBlocks) {
+        const miningAddressLabel = 'miningAddress';
+        let address;
+        try {
+            // Avoid creating 100s of addresses for mining
+            const labelAddresses = await this.jsonrpc('getaddressesbylabel', miningAddressLabel);
+            address = Object.keys(labelAddresses)[0];
+        }
+        catch (e) {
+            // Label does not exist
+            address = await this.jsonrpc('getnewaddress', miningAddressLabel);
+        }
+        return this.jsonrpc('generatetoaddress', numberOfBlocks, address);
+    }
+    async getBlockByHash(blockHash, includeTx = false) {
+        let data;
+        try {
+            data = await this.jsonrpc('getblock', blockHash); // TODO: This doesn't fit the interface?: https://chainquery.com/bitcoin-cli/getblock
+        }
+        catch (e) {
+            if (e.name === 'NodeError' && e.message.includes('Block not found')) {
+                const { name, message, ...attrs } = e;
+                throw new errors_1.BlockNotFoundError(`Block not found: ${blockHash}`, attrs);
+            }
+            throw e;
+        }
+        const { hash, height: number, mediantime: timestamp, difficulty, size, previousblockhash: parentHash, nonce, tx: transactionHashes, } = data;
+        let transactions = transactionHashes;
+        // TODO: Why transactions need to be retrieved individually? getblock has verbose 2 https://chainquery.com/bitcoin-cli/getblock
+        if (includeTx) {
+            const txs = transactionHashes.map((hash) => this.getTransactionByHash(hash));
+            transactions = await Promise.all(txs);
+        }
+        return {
+            hash,
+            number,
+            timestamp,
+            difficulty: parseFloat(new types_1.BigNumber(difficulty).toFixed()),
+            size,
+            parentHash,
+            nonce,
+            transactions,
+        };
+    }
+    async getBlockByNumber(blockNumber, includeTx = false) {
+        let blockHash;
+        try {
+            blockHash = await this.jsonrpc('getblockhash', blockNumber);
+        }
+        catch (e) {
+            if (e.name === 'NodeError' &&
+                e.message.includes('Block height out of range')) {
+                const { name, message, ...attrs } = e;
+                throw new errors_1.BlockNotFoundError(`Block not found: ${blockNumber}`, attrs);
+            }
+            throw e;
+        }
+        return this.getBlockByHash(blockHash, includeTx);
+    }
+    async getBlockHeight() {
+        return this.jsonrpc('getblockcount');
+    }
+    async getTransactionByHash(transactionHash) {
+        try {
+            const tx = await this.getParsedTransactionByHash(transactionHash, true);
+            return tx;
+        }
+        catch (e) {
+            if (e.name === 'NodeError' &&
+                e.message.includes('No such mempool transaction')) {
+                const { name, message, ...attrs } = e;
+                throw new errors_1.TxNotFoundError(`Transaction not found: ${transactionHash}`, attrs);
+            }
+            throw e;
+        }
+    }
+    async getTransactionFee(tx) {
+        const isCoinbaseTx = tx.vin.find((vin) => vin.coinbase);
+        if (isCoinbaseTx)
+            return; // Coinbase transactions do not have a fee
+        const inputs = tx.vin.map((vin) => ({ txid: vin.txid, vout: vin.vout }));
+        const inputTransactions = await Promise.all(inputs.map((input) => this.jsonrpc('getrawtransaction', input.txid, 1)));
+        const inputValues = inputTransactions.map((inputTx, index) => {
+            const vout = inputs[index].vout;
+            const output = inputTx.vout[vout];
+            return output.value * 1e8;
+        });
+        const inputValue = inputValues.reduce((a, b) => a.plus(new types_1.BigNumber(b)), new types_1.BigNumber(0));
+        const outputValue = tx.vout.reduce((a, b) => a.plus(new types_1.BigNumber(b.value).times(new types_1.BigNumber(1e8))), new types_1.BigNumber(0));
+        const feeValue = inputValue.minus(outputValue);
+        return feeValue.toNumber();
+    }
+    async getParsedTransactionByHash(transactionHash, addFees = false) {
+        const tx = await this.jsonrpc('getrawtransaction', transactionHash, 1);
+        return (0, bitcoin_utils_1.normalizeTransactionObject)(tx, addFees ? await this.getTransactionFee(tx) : undefined, tx.confirmations > 0
+            ? await this.getBlockByHash(tx.blockhash)
+            : undefined);
+    }
+    async getRawTransactionByHash(transactionHash) {
+        const tx = await this.jsonrpc('getrawtransaction', transactionHash, 0);
+        return tx;
+    }
+    async sendRawTransaction(rawTransaction) {
+        return this.jsonrpc('sendrawtransaction', rawTransaction);
+    }
+    async sendBatchTransaction(transactions) {
+        const outputs = {};
+        for (const tx of transactions) {
+            outputs[(0, utils_1.addressToString)(tx.to)] = new types_1.BigNumber(tx.value)
+                .dividedBy(1e8)
+                .toNumber();
+        }
+        const rawTxOutputs = await this.createRawTransaction([], outputs);
+        const rawTxFunded = await this.fundRawTransaction(rawTxOutputs);
+        const rawTxSigned = await this.signRawTransaction(rawTxFunded.hex);
+        const fee = new types_1.BigNumber(rawTxFunded.fee).times(1e8).toNumber();
+        await this.sendRawTransaction(rawTxSigned.hex);
+        return (0, bitcoin_utils_1.normalizeTransactionObject)((0, bitcoin_utils_1.decodeRawTransaction)(rawTxSigned.hex, this._network), fee);
+    }
+    async signRawTransaction(hexstring) {
+        return this.jsonrpc('signrawtransactionwithwallet', hexstring);
+    }
+    async createRawTransaction(transactions, outputs) {
+        return this.jsonrpc('createrawtransaction', transactions, outputs);
+    }
+    async fundRawTransaction(hexstring) {
+        return this.jsonrpc('fundrawtransaction', hexstring);
+    }
+}
+exports.default = BitcoinRpcProvider;
+//# sourceMappingURL=BitcoinRpcProvider.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.BitcoinRpcProvider = void 0;
+const BitcoinRpcProvider_1 = __importDefault(require("./BitcoinRpcProvider"));
+exports.BitcoinRpcProvider = BitcoinRpcProvider_1.default;
+//# sourceMappingURL=index.js.map

package/package.json

@@ -1,10 +1,9 @@
 {
   "name": "@atomicfinance/bitcoin-rpc-provider",
-  "version": "3.5.0",
+  "version": "3.5.2",
   "description": "",
   "module": "dist/index.js",
   "main": "dist/index.js",
-  "types": "dist/lib/index.d.ts",
   "directories": {
     "dist": "dist",
     "src": "lib"
@@ -25,11 +24,11 @@
     "node": ">=14"
   },
   "dependencies": {
-    "@atomicfinance/bitcoin-utils": "^3.5.0",
-    "@atomicfinance/errors": "^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/errors": "^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",