@teleportdao/bitcoin 2.0.4 → 2.0.7

package/dist/bitcoin-interface.js

@@ -1,120 +1,120 @@
-"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());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BitcoinInterface = void 0;
-const providers_1 = require("@teleportdao/providers");
-const tools_1 = require("./utils/tools");
-const bitcoin_utils_1 = require("./bitcoin-utils");
-const bitcoin_interface_wallet_1 = __importDefault(require("./bitcoin-interface-wallet"));
-class BitcoinInterface extends bitcoin_interface_wallet_1.default {
-    constructor(networkName, connectionInfo) {
-        super(networkName, connectionInfo);
-        if (connectionInfo === null || connectionInfo === void 0 ? void 0 : connectionInfo.rpc) {
-            this.rpcProvider = providers_1.bitcoin.getRpcProvider(connectionInfo.rpc);
-        }
-    }
-    getLatestBlockNumber() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let latestHeight = yield (this.rpcProvider || this.apiProvider).getLatestBlockNumber();
-            return latestHeight;
-        });
-    }
-    getBlockHash(blockNumber) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let headerHash = yield (0, tools_1.runWithRetries)(() => (this.rpcProvider || this.apiProvider).getBlockHash(blockNumber));
-            return headerHash;
-        });
-    }
-    getBlockHeaderHex(blockNumber) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let headerHex = yield (0, tools_1.runWithRetries)(() => (this.rpcProvider || this.apiProvider).getBlockHeaderHex(blockNumber));
-            return headerHex;
-        });
-    }
-    getTransaction(txId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (this.rpcProvider || this.apiProvider).getTransaction(txId);
-        });
-    }
-    getRawTransaction(txId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (this.rpcProvider || this.apiProvider).getRawTransaction(txId);
-        });
-    }
-    sendRawTransaction(txId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (this.rpcProvider || this.apiProvider).sendRawTransaction(txId);
-        });
-    }
-    getMerkleProof(txId, blockHash) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.rpcProvider) {
-                return this.apiProvider.getMerkleProof(txId);
-            }
-            let txIds = yield (0, tools_1.runWithRetries)(() => this.rpcProvider.getBlockTransactionIds(blockHash), {
-                maxTries: 10,
-                retrySleep: 2000,
-            });
-            let proof = (0, bitcoin_utils_1.calculateMerkleProof)(txIds, txId);
-            return proof;
-        });
-    }
-    getRequestProof(transaction) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let transactionHex = transaction.hex || (yield this.getRawTransaction(transaction.txId));
-            let blockHash = transaction.blockHash;
-            let blockNumber = transaction.blockNumber;
-            if (!(transaction.blockHash && transaction.blockNumber)) {
-                let txInfo = yield this.getTransaction(transaction.txId);
-                blockHash = txInfo.blockHash;
-                blockNumber = txInfo.blockNumber;
-            }
-            let parsedTx = (0, bitcoin_utils_1.parseRawTransaction)(transactionHex);
-            let merkleProof = transaction.merkleProof || (yield this.getMerkleProof(transaction.txId, blockHash));
-            return {
-                parsedTx,
-                merkleProof,
-                blockNumber: blockNumber,
-                blockHash: blockHash,
-            };
-        });
-    }
-    getBlockTransactions(addresses, blockNumber, inputTxIds = []) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.rpcProvider) {
-                throw new Error("RPC provider not set");
-            }
-            let rawBlockHex = yield (0, tools_1.runWithRetries)(() => this.rpcProvider.getBlockByBlockNumber(blockNumber, 0), {
-                maxTries: 10,
-                retrySleep: 2000,
-            });
-            return (0, bitcoin_utils_1.extractTransactionsAndBlockInfoFromRawBlock)(rawBlockHex, blockNumber, addresses, inputTxIds, this.network);
-        });
-    }
-    getMultipleBlocksTransactions(addresses, startBlockNumber, endBlockNumber, inputTxIds = []) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let blockTxs = [];
-            for (let blockNumber = +startBlockNumber + 1; blockNumber <= endBlockNumber; blockNumber += 1) {
-                console.log(blockNumber);
-                const response = yield this.getBlockTransactions(addresses, blockNumber, inputTxIds);
-                blockTxs.push(response.withdrawTxs, response.depositTxs);
-            }
-            blockTxs = yield Promise.all(blockTxs);
-            return blockTxs.flat(1);
-        });
-    }
-}
-exports.BitcoinInterface = BitcoinInterface;
-exports.default = BitcoinInterface;
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitcoinInterface = void 0;
+const providers_1 = require("@teleportdao/providers");
+const tools_1 = require("./utils/tools");
+const bitcoin_utils_1 = require("./bitcoin-utils");
+const bitcoin_interface_wallet_1 = __importDefault(require("./bitcoin-interface-wallet"));
+class BitcoinInterface extends bitcoin_interface_wallet_1.default {
+    constructor(networkName, connectionInfo) {
+        super(networkName, connectionInfo);
+        if (connectionInfo === null || connectionInfo === void 0 ? void 0 : connectionInfo.rpc) {
+            this.rpcProvider = providers_1.bitcoin.getRpcProvider(connectionInfo.rpc);
+        }
+    }
+    getLatestBlockNumber() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let latestHeight = yield (this.rpcProvider || this.apiProvider).getLatestBlockNumber();
+            return latestHeight;
+        });
+    }
+    getBlockHash(blockNumber) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let headerHash = yield (0, tools_1.runWithRetries)(() => (this.rpcProvider || this.apiProvider).getBlockHash(blockNumber));
+            return headerHash;
+        });
+    }
+    getBlockHeaderHex(blockNumber) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let headerHex = yield (0, tools_1.runWithRetries)(() => (this.rpcProvider || this.apiProvider).getBlockHeaderHex(blockNumber));
+            return headerHex;
+        });
+    }
+    getTransaction(txId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (this.rpcProvider || this.apiProvider).getTransaction(txId);
+        });
+    }
+    getRawTransaction(txId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (this.rpcProvider || this.apiProvider).getRawTransaction(txId);
+        });
+    }
+    sendRawTransaction(txId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (this.rpcProvider || this.apiProvider).sendRawTransaction(txId);
+        });
+    }
+    getMerkleProof(txId, blockHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.rpcProvider) {
+                return this.apiProvider.getMerkleProof(txId);
+            }
+            let txIds = yield (0, tools_1.runWithRetries)(() => this.rpcProvider.getBlockTransactionIds(blockHash), {
+                maxTries: 10,
+                retrySleep: 2000,
+            });
+            let proof = (0, bitcoin_utils_1.calculateMerkleProof)(txIds, txId);
+            return proof;
+        });
+    }
+    getRequestProof(transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let transactionHex = transaction.hex || (yield this.getRawTransaction(transaction.txId));
+            let blockHash = transaction.blockHash;
+            let blockNumber = transaction.blockNumber;
+            if (!(transaction.blockHash && transaction.blockNumber)) {
+                let txInfo = yield this.getTransaction(transaction.txId);
+                blockHash = txInfo.blockHash;
+                blockNumber = txInfo.blockNumber;
+            }
+            let parsedTx = (0, bitcoin_utils_1.parseRawTransaction)(transactionHex);
+            let merkleProof = transaction.merkleProof || (yield this.getMerkleProof(transaction.txId, blockHash));
+            return {
+                parsedTx,
+                merkleProof,
+                blockNumber: blockNumber,
+                blockHash: blockHash,
+            };
+        });
+    }
+    getBlockTransactions(addresses, blockNumber, inputTxIds = []) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.rpcProvider) {
+                throw new Error("RPC provider not set");
+            }
+            let rawBlockHex = yield (0, tools_1.runWithRetries)(() => this.rpcProvider.getBlockByBlockNumber(blockNumber, 0), {
+                maxTries: 10,
+                retrySleep: 2000,
+            });
+            return (0, bitcoin_utils_1.extractTransactionsAndBlockInfoFromRawBlock)(rawBlockHex, blockNumber, addresses, inputTxIds, this.network);
+        });
+    }
+    getMultipleBlocksTransactions(addresses, startBlockNumber, endBlockNumber, inputTxIds = []) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let blockTxs = [];
+            for (let blockNumber = +startBlockNumber + 1; blockNumber <= endBlockNumber; blockNumber += 1) {
+                console.log(blockNumber);
+                const response = yield this.getBlockTransactions(addresses, blockNumber, inputTxIds);
+                blockTxs.push(response.withdrawTxs, response.depositTxs);
+            }
+            blockTxs = yield Promise.all(blockTxs);
+            return blockTxs.flat(1);
+        });
+    }
+}
+exports.BitcoinInterface = BitcoinInterface;
+exports.default = BitcoinInterface;
 //# sourceMappingURL=bitcoin-interface.js.map

package/dist/bitcoin-utils.d.ts

@@ -1,97 +1,97 @@
-/// <reference types="node" />
-import * as bitcoin from "bitcoinjs-lib";
-import networks from "./utils/networks";
-import { Transaction } from "./type";
-export { networks };
-export declare function generateMnemonic(): string;
-export declare function getPrivateKeyHexFromMnemonic(mnemonic: string, index?: number, isChange?: boolean): Promise<string>;
-export declare function reverseBytes(hexInput: string): string;
-export declare function getPublicKeyHexByXpubAndIndex(xpub: string, index?: number, isChange?: boolean, network?: bitcoin.networks.Network): string;
-export declare function getPubKeyFromPrivateKeyWIF(privateKeyWIF: string, network?: bitcoin.networks.Network): Buffer;
-export declare function getPubKeyFromPrivateKeyHex(privateKeyHex: string, network?: bitcoin.networks.Network): Buffer;
-export declare function getPrivateKeyHexFromWIF(privateKeyWIF: string, network?: bitcoin.networks.Network): string;
-export declare function parseRawTransaction(rawTransaction: string): {
-    version: string;
-    flag: string;
-    vin: string;
-    vout: string;
-    witness: string;
-    locktime: string;
-};
-export declare function calculateMerkleProof(blockTransactions: string[], txId: string, blockMerkleRoot?: string): {
-    intermediateNodes: string;
-    transactionIndex: number;
-};
-export declare function parseBlockHeader(headerHex: string): {
-    version: string;
-    previousBlockHash: string;
-    merkleRoot: string;
-    timestamp: string;
-    difficulty: string;
-    nonce: string;
-};
-export declare function getAddressType(address: string, network?: bitcoin.networks.Network): "p2tr" | "p2wpkh" | "p2sh" | "p2pkh";
-export declare function createAddressObjectByAddress(address: string, network?: bitcoin.networks.Network): {
-    addressObject: bitcoin.payments.Payment;
-    addressType: "p2tr" | "p2wpkh" | "p2sh" | "p2pkh";
-};
-export declare function convertBitcoinScriptToAddress(script: Buffer, network?: bitcoin.networks.Network): string | undefined;
-export declare function parseRawBlock(rawBlockHex: string, blockNumber?: number, network?: bitcoin.networks.Network): {
-    blockNumber: number | undefined;
-    merkleRoot: string;
-    prvBlockHash: string;
-    transactions: {
-        txId: string;
-        version: number;
-        locktime: number;
-        blockNumber: number | undefined;
-        blockHash: string;
-        vout: {
-            address: string | undefined;
-            script: string;
-            value: number;
-            index: number;
-        }[];
-        vin: {
-            txId: string;
-            index: number;
-        }[];
-    }[] | undefined;
-};
-export declare function extractTransactionsAndBlockInfoFromRawBlock(rawBlockHex: string, blockNumber: number, addresses?: string[], inputTxIds?: {
-    txId: string;
-    index: number;
-    address: string;
-    script?: string;
-    value?: number;
-}[], network?: bitcoin.networks.Network): {
-    blockInfo: {
-        blockNumber: number;
-        blockHash: string;
-        merkleRoot: string;
-        prvBlockHash: string;
-    };
-    withdrawTxs: Transaction[];
-    depositTxs: Transaction[];
-};
-export declare function validateAddress(address: string, network?: bitcoin.networks.Network): boolean;
-export declare function createAddressObjectByScript({ addressType, script }: {
-    addressType: string;
-    script: Buffer;
-}, network?: bitcoin.Network): bitcoin.payments.Payment;
-export declare function createAddressObjectByHash({ addressType, hash }: {
-    addressType: string;
-    hash: Buffer;
-}, network?: bitcoin.Network): bitcoin.payments.Payment;
-export declare function createAddressObjectByPublicKey({ addressType, publicKey }: {
-    addressType: string;
-    publicKey: Buffer;
-}, network?: bitcoin.Network): bitcoin.payments.Payment;
-export declare function publicKeyConvertor(publicKeyHex: string, compressed?: boolean): string;
-export declare const addressTypeHelper: {
-    addressTypesNumber: {
-        [key: string]: number;
-    };
-    addressTypes: string[];
-};
+/// <reference types="node" />
+import * as bitcoin from "bitcoinjs-lib";
+import networks from "./utils/networks";
+import { Transaction } from "./type";
+export { networks };
+export declare function generateMnemonic(): string;
+export declare function getPrivateKeyHexFromMnemonic(mnemonic: string, index?: number, isChange?: boolean): Promise<string>;
+export declare function reverseBytes(hexInput: string): string;
+export declare function getPublicKeyHexByXpubAndIndex(xpub: string, index?: number, isChange?: boolean, network?: bitcoin.networks.Network): string;
+export declare function getPubKeyFromPrivateKeyWIF(privateKeyWIF: string, network?: bitcoin.networks.Network): Buffer;
+export declare function getPubKeyFromPrivateKeyHex(privateKeyHex: string, network?: bitcoin.networks.Network): Buffer;
+export declare function getPrivateKeyHexFromWIF(privateKeyWIF: string, network?: bitcoin.networks.Network): string;
+export declare function parseRawTransaction(rawTransaction: string): {
+    version: string;
+    flag: string;
+    vin: string;
+    vout: string;
+    witness: string;
+    locktime: string;
+};
+export declare function calculateMerkleProof(blockTransactions: string[], txId: string, blockMerkleRoot?: string): {
+    intermediateNodes: string;
+    transactionIndex: number;
+};
+export declare function parseBlockHeader(headerHex: string): {
+    version: string;
+    previousBlockHash: string;
+    merkleRoot: string;
+    timestamp: string;
+    difficulty: string;
+    nonce: string;
+};
+export declare function getAddressType(address: string, network?: bitcoin.networks.Network): "p2tr" | "p2wpkh" | "p2sh" | "p2pkh";
+export declare function createAddressObjectByAddress(address: string, network?: bitcoin.networks.Network): {
+    addressObject: bitcoin.payments.Payment;
+    addressType: "p2tr" | "p2wpkh" | "p2sh" | "p2pkh";
+};
+export declare function convertBitcoinScriptToAddress(script: Buffer, network?: bitcoin.networks.Network): string | undefined;
+export declare function parseRawBlock(rawBlockHex: string, blockNumber?: number, network?: bitcoin.networks.Network): {
+    blockNumber: number | undefined;
+    merkleRoot: string;
+    prvBlockHash: string;
+    transactions: {
+        txId: string;
+        version: number;
+        locktime: number;
+        blockNumber: number | undefined;
+        blockHash: string;
+        vout: {
+            address: string | undefined;
+            script: string;
+            value: number;
+            index: number;
+        }[];
+        vin: {
+            txId: string;
+            index: number;
+        }[];
+    }[] | undefined;
+};
+export declare function extractTransactionsAndBlockInfoFromRawBlock(rawBlockHex: string, blockNumber: number, addresses?: string[], inputTxIds?: {
+    txId: string;
+    index: number;
+    address: string;
+    script?: string;
+    value?: number;
+}[], network?: bitcoin.networks.Network): {
+    blockInfo: {
+        blockNumber: number;
+        blockHash: string;
+        merkleRoot: string;
+        prvBlockHash: string;
+    };
+    withdrawTxs: Transaction[];
+    depositTxs: Transaction[];
+};
+export declare function validateAddress(address: string, network?: bitcoin.networks.Network): boolean;
+export declare function createAddressObjectByScript({ addressType, script }: {
+    addressType: string;
+    script: Buffer;
+}, network?: bitcoin.Network): bitcoin.payments.Payment;
+export declare function createAddressObjectByHash({ addressType, hash }: {
+    addressType: string;
+    hash: Buffer;
+}, network?: bitcoin.Network): bitcoin.payments.Payment;
+export declare function createAddressObjectByPublicKey({ addressType, publicKey }: {
+    addressType: string;
+    publicKey: Buffer;
+}, network?: bitcoin.Network): bitcoin.payments.Payment;
+export declare function publicKeyConvertor(publicKeyHex: string, compressed?: boolean): string;
+export declare const addressTypeHelper: {
+    addressTypesNumber: {
+        [key: string]: number;
+    };
+    addressTypes: string[];
+};
 //# sourceMappingURL=bitcoin-utils.d.ts.map