@teleportdao/bitcoin 2.0.5 → 2.0.7

package/dist/bitcoin-interface-teleswap.d.ts

@@ -1,102 +1,102 @@
-import { bitcoin } from "@teleportdao/providers";
-import { UnwrapInfo, WrapOpReturnWithType } from "./helper/teleswap-helper";
-import BitcoinInterface from "./bitcoin-interface";
-import { BitcoinNodeConnectionInfo, Transaction } from "./type";
-export type ValidWrapRequest = {
-    transaction: bitcoin.Types.ConfirmedTransaction & {
-        address?: string;
-        addressScript?: string;
-        merkleProof?: Transaction["merkleProof"];
-    };
-    request: {
-        status: boolean;
-        data: WrapOpReturnWithType;
-        value: number;
-        valueOutputIndex: number;
-    };
-    lockerAddress: string;
-    lockerLockingScript: string;
-};
-export type InValidWrapRequest = {
-    transaction: bitcoin.Types.ConfirmedTransaction & {
-        address?: string;
-        addressScript?: string;
-        merkleProof?: Transaction["merkleProof"];
-    };
-    request: {
-        status: boolean;
-        message: string;
-        code: string;
-    };
-    lockerAddress: string;
-    lockerLockingScript: string;
-};
-export type UnwrapRequest = {
-    burnInfo: UnwrapInfo | undefined;
-    lockerAddress: string;
-    lockerLockingScript: string;
-};
-export declare class BitcoinInterfaceTeleswap extends BitcoinInterface {
-    constructor(connectionInfo: BitcoinNodeConnectionInfo, networkName: string);
-    getHexBlockHeaders(startBlockNumber: number, endBlockNumber: number): Promise<{
-        hexBlockHeaders: string;
-        fromBlockNumber: number;
-        toBlockNumber: number;
-        difficulty: string | null;
-    }[]>;
-    getWrapRequests(addresses: string[], startblockNumber: number, endBlockNumber: number): Promise<{
-        requests: ValidWrapRequest[];
-        invalidRequests: InValidWrapRequest[];
-    }>;
-    getWrapRequestByTx(inputTransaction: {
-        txId: string;
-    } | (bitcoin.Types.ConfirmedTransaction & {
-        address?: string;
-        addressScript?: string;
-        merkleProof?: Transaction["merkleProof"];
-    }), lockerAddress: string): Promise<{
-        transaction: bitcoin.Types.ConfirmedTransaction & {
-            address?: string | undefined;
-            addressScript?: string | undefined;
-            merkleProof?: Transaction["merkleProof"];
-        };
-        request: {
-            status: boolean;
-            message: string;
-            code: string;
-            data?: undefined;
-            value?: undefined;
-            valueOutputIndex?: undefined;
-            requestOutputIndex?: undefined;
-        } | {
-            status: true;
-            data: WrapOpReturnWithType;
-            value: number;
-            valueOutputIndex: number;
-            requestOutputIndex: number;
-            message?: undefined;
-            code?: undefined;
-        };
-        lockerAddress: string;
-        lockerLockingScript: string;
-    }>;
-    getLockersUnWrapTransactions(addresses: string[], startBlockNumber: number, endBlockNumber: number): Promise<{
-        transaction: Transaction;
-        burnInfo: UnwrapInfo | undefined;
-        lockerAddress: string;
-        lockerLockingScript: string;
-    }[]>;
-    getLockersUnwrapMEmpoolTransactions(addresses: string[], startBlockNumber: number, endBlockNumber: number): Promise<{
-        transaction: Transaction;
-        burnInfo: UnwrapInfo | undefined;
-        lockerAddress: string;
-        lockerLockingScript: string;
-    }[]>;
-    getTransactionUnwrapInfoByTx(transaction: {
-        txId: any;
-        vout?: any;
-        vin?: any;
-        addressScript?: any;
-    }, lockerAddress: string): Promise<UnwrapRequest | undefined>;
-}
+import { bitcoin } from "@teleportdao/providers";
+import { UnwrapInfo, WrapOpReturnWithType } from "./helper/teleswap-helper";
+import BitcoinInterface from "./bitcoin-interface";
+import { BitcoinNodeConnectionInfo, Transaction } from "./type";
+export type ValidWrapRequest = {
+    transaction: bitcoin.Types.ConfirmedTransaction & {
+        address?: string;
+        addressScript?: string;
+        merkleProof?: Transaction["merkleProof"];
+    };
+    request: {
+        status: boolean;
+        data: WrapOpReturnWithType;
+        value: number;
+        valueOutputIndex: number;
+    };
+    lockerAddress: string;
+    lockerLockingScript: string;
+};
+export type InValidWrapRequest = {
+    transaction: bitcoin.Types.ConfirmedTransaction & {
+        address?: string;
+        addressScript?: string;
+        merkleProof?: Transaction["merkleProof"];
+    };
+    request: {
+        status: boolean;
+        message: string;
+        code: string;
+    };
+    lockerAddress: string;
+    lockerLockingScript: string;
+};
+export type UnwrapRequest = {
+    burnInfo: UnwrapInfo | undefined;
+    lockerAddress: string;
+    lockerLockingScript: string;
+};
+export declare class BitcoinInterfaceTeleswap extends BitcoinInterface {
+    constructor(connectionInfo: BitcoinNodeConnectionInfo, networkName: string);
+    getHexBlockHeaders(startBlockNumber: number, endBlockNumber: number): Promise<{
+        hexBlockHeaders: string;
+        fromBlockNumber: number;
+        toBlockNumber: number;
+        difficulty: string | null;
+    }[]>;
+    getWrapRequests(addresses: string[], startblockNumber: number, endBlockNumber: number): Promise<{
+        requests: ValidWrapRequest[];
+        invalidRequests: InValidWrapRequest[];
+    }>;
+    getWrapRequestByTx(inputTransaction: {
+        txId: string;
+    } | (bitcoin.Types.ConfirmedTransaction & {
+        address?: string;
+        addressScript?: string;
+        merkleProof?: Transaction["merkleProof"];
+    }), lockerAddress: string): Promise<{
+        transaction: bitcoin.Types.ConfirmedTransaction & {
+            address?: string | undefined;
+            addressScript?: string | undefined;
+            merkleProof?: Transaction["merkleProof"];
+        };
+        request: {
+            status: boolean;
+            message: string;
+            code: string;
+            data?: undefined;
+            value?: undefined;
+            valueOutputIndex?: undefined;
+            requestOutputIndex?: undefined;
+        } | {
+            status: true;
+            data: WrapOpReturnWithType;
+            value: number;
+            valueOutputIndex: number;
+            requestOutputIndex: number;
+            message?: undefined;
+            code?: undefined;
+        };
+        lockerAddress: string;
+        lockerLockingScript: string;
+    }>;
+    getLockersUnWrapTransactions(addresses: string[], startBlockNumber: number, endBlockNumber: number): Promise<{
+        transaction: Transaction;
+        burnInfo: UnwrapInfo | undefined;
+        lockerAddress: string;
+        lockerLockingScript: string;
+    }[]>;
+    getLockersUnwrapMEmpoolTransactions(addresses: string[], startBlockNumber: number, endBlockNumber: number): Promise<{
+        transaction: Transaction;
+        burnInfo: UnwrapInfo | undefined;
+        lockerAddress: string;
+        lockerLockingScript: string;
+    }[]>;
+    getTransactionUnwrapInfoByTx(transaction: {
+        txId: any;
+        vout?: any;
+        vin?: any;
+        addressScript?: any;
+    }, lockerAddress: string): Promise<UnwrapRequest | undefined>;
+}
 //# sourceMappingURL=bitcoin-interface-teleswap.d.ts.map

package/dist/bitcoin-interface-teleswap.js

@@ -1,177 +1,177 @@
-"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.BitcoinInterfaceTeleswap = void 0;
-const configs_1 = require("@teleportdao/configs");
-const bitcoin_utils_1 = require("./bitcoin-utils");
-const teleswap_helper_1 = require("./helper/teleswap-helper");
-const bitcoin_interface_1 = __importDefault(require("./bitcoin-interface"));
-class BitcoinInterfaceTeleswap extends bitcoin_interface_1.default {
-    constructor(connectionInfo, networkName) {
-        if (!connectionInfo.rpc) {
-            throw new Error("rpc provider is required");
-        }
-        super(networkName, connectionInfo);
-    }
-    getHexBlockHeaders(startBlockNumber, endBlockNumber) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const blockHeaders = [];
-            let difficulty = null;
-            let hexBlockHeaders = "";
-            let fromBlockNumber = startBlockNumber;
-            for (let blockNumber = startBlockNumber; blockNumber <= endBlockNumber; blockNumber += 1) {
-                let blockHeader = yield this.getBlockHeaderHex(blockNumber);
-                console.log("block", blockNumber);
-                let parsedBlockHeader = (0, bitcoin_utils_1.parseBlockHeader)(blockHeader);
-                if (difficulty && parsedBlockHeader.difficulty !== difficulty) {
-                    blockHeaders.push({
-                        hexBlockHeaders,
-                        fromBlockNumber,
-                        toBlockNumber: blockNumber - 1,
-                        difficulty,
-                    });
-                    hexBlockHeaders = blockHeader;
-                    fromBlockNumber = blockNumber;
-                }
-                else {
-                    hexBlockHeaders += blockHeader;
-                }
-                difficulty = parsedBlockHeader.difficulty;
-            }
-            if (hexBlockHeaders) {
-                blockHeaders.push({
-                    hexBlockHeaders,
-                    fromBlockNumber,
-                    toBlockNumber: endBlockNumber,
-                    difficulty,
-                });
-            }
-            return blockHeaders;
-        });
-    }
-    getWrapRequests(addresses, startblockNumber, endBlockNumber) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let transactions = yield this.getMultipleBlocksTransactions(addresses, startblockNumber, endBlockNumber);
-            let requests = [];
-            let invalidRequests = [];
-            for (let inputTx of transactions) {
-                let { transaction, request, lockerAddress, lockerLockingScript } = yield this.getWrapRequestByTx(inputTx, inputTx.address);
-                if (request.status && "data" in request && request.data) {
-                    if (!configs_1.teleswap.requestAppId[request.data.requestType].appIds.includes(request.data.appId)) {
-                        invalidRequests.push({
-                            transaction,
-                            request: Object.assign(Object.assign({}, request), { message: "invalid app id", code: "INVALID_APP_ID" }),
-                            lockerAddress,
-                            lockerLockingScript,
-                        });
-                    }
-                    else {
-                        requests.push({
-                            transaction,
-                            request,
-                            lockerAddress,
-                            lockerLockingScript,
-                        });
-                    }
-                }
-                else if (request.code !== "NO_OP_RETURN") {
-                    invalidRequests.push({ transaction, request, lockerAddress, lockerLockingScript });
-                }
-            }
-            return { requests, invalidRequests };
-        });
-    }
-    getWrapRequestByTx(inputTransaction, lockerAddress) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let transaction;
-            if ("vout" in inputTransaction && "blockNumber" in inputTransaction) {
-                transaction = inputTransaction;
-            }
-            else {
-                if (!inputTransaction.txId)
-                    throw new Error("txId not exist");
-                transaction = yield this.getTransaction(inputTransaction.txId);
-            }
-            let vout = transaction.vout;
-            let request = (0, teleswap_helper_1.checkAndParseWrapRequest)(vout, lockerAddress);
-            let lockerLockingScript = transaction.addressScript ||
-                this.convertAddressToScript(lockerAddress).script.toString("hex");
-            return {
-                transaction,
-                request,
-                lockerAddress,
-                lockerLockingScript,
-            };
-        });
-    }
-    getLockersUnWrapTransactions(addresses, startBlockNumber, endBlockNumber) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let transactions = yield this.getMultipleBlocksTransactions(addresses, startBlockNumber, endBlockNumber);
-            let validTxs = [];
-            for (let transaction of transactions) {
-                let address = transaction.address;
-                let txBurnInfo = yield this.getTransactionUnwrapInfoByTx(transaction, address);
-                if (txBurnInfo) {
-                    const { burnInfo, lockerAddress, lockerLockingScript } = txBurnInfo;
-                    validTxs.push({
-                        transaction,
-                        burnInfo,
-                        lockerAddress,
-                        lockerLockingScript,
-                    });
-                }
-            }
-            return validTxs;
-        });
-    }
-    getLockersUnwrapMEmpoolTransactions(addresses, startBlockNumber, endBlockNumber) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let transactions = yield this.getMultipleBlocksTransactions(addresses, startBlockNumber, endBlockNumber);
-            let validTxs = [];
-            for (let transaction of transactions) {
-                let address = transaction.address;
-                let txBurnInfo = yield this.getTransactionUnwrapInfoByTx(transaction, address);
-                if (txBurnInfo) {
-                    const { burnInfo, lockerAddress, lockerLockingScript } = txBurnInfo;
-                    validTxs.push({
-                        transaction,
-                        burnInfo,
-                        lockerAddress,
-                        lockerLockingScript,
-                    });
-                }
-            }
-            return validTxs;
-        });
-    }
-    getTransactionUnwrapInfoByTx(transaction, lockerAddress) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!transaction.txId)
-                throw new Error("txId not exist");
-            let vin = transaction.vin || (yield this.getTransaction(transaction.txId)).vin;
-            let burnInfo = (0, teleswap_helper_1.getBurnTransactionInfo)(lockerAddress, vin, transaction.vout);
-            if (!burnInfo)
-                return;
-            let lockerLockingScript = transaction.addressScript ||
-                this.convertAddressToScript(lockerAddress).script.toString("hex");
-            return {
-                burnInfo,
-                lockerAddress,
-                lockerLockingScript,
-            };
-        });
-    }
-}
-exports.BitcoinInterfaceTeleswap = BitcoinInterfaceTeleswap;
+"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.BitcoinInterfaceTeleswap = void 0;
+const configs_1 = require("@teleportdao/configs");
+const bitcoin_utils_1 = require("./bitcoin-utils");
+const teleswap_helper_1 = require("./helper/teleswap-helper");
+const bitcoin_interface_1 = __importDefault(require("./bitcoin-interface"));
+class BitcoinInterfaceTeleswap extends bitcoin_interface_1.default {
+    constructor(connectionInfo, networkName) {
+        if (!connectionInfo.rpc) {
+            throw new Error("rpc provider is required");
+        }
+        super(networkName, connectionInfo);
+    }
+    getHexBlockHeaders(startBlockNumber, endBlockNumber) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const blockHeaders = [];
+            let difficulty = null;
+            let hexBlockHeaders = "";
+            let fromBlockNumber = startBlockNumber;
+            for (let blockNumber = startBlockNumber; blockNumber <= endBlockNumber; blockNumber += 1) {
+                let blockHeader = yield this.getBlockHeaderHex(blockNumber);
+                console.log("block", blockNumber);
+                let parsedBlockHeader = (0, bitcoin_utils_1.parseBlockHeader)(blockHeader);
+                if (difficulty && parsedBlockHeader.difficulty !== difficulty) {
+                    blockHeaders.push({
+                        hexBlockHeaders,
+                        fromBlockNumber,
+                        toBlockNumber: blockNumber - 1,
+                        difficulty,
+                    });
+                    hexBlockHeaders = blockHeader;
+                    fromBlockNumber = blockNumber;
+                }
+                else {
+                    hexBlockHeaders += blockHeader;
+                }
+                difficulty = parsedBlockHeader.difficulty;
+            }
+            if (hexBlockHeaders) {
+                blockHeaders.push({
+                    hexBlockHeaders,
+                    fromBlockNumber,
+                    toBlockNumber: endBlockNumber,
+                    difficulty,
+                });
+            }
+            return blockHeaders;
+        });
+    }
+    getWrapRequests(addresses, startblockNumber, endBlockNumber) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let transactions = yield this.getMultipleBlocksTransactions(addresses, startblockNumber, endBlockNumber);
+            let requests = [];
+            let invalidRequests = [];
+            for (let inputTx of transactions) {
+                let { transaction, request, lockerAddress, lockerLockingScript } = yield this.getWrapRequestByTx(inputTx, inputTx.address);
+                if (request.status && "data" in request && request.data) {
+                    if (!configs_1.teleswap.requestAppId[request.data.requestType].appIds.includes(request.data.appId)) {
+                        invalidRequests.push({
+                            transaction,
+                            request: Object.assign(Object.assign({}, request), { message: "invalid app id", code: "INVALID_APP_ID" }),
+                            lockerAddress,
+                            lockerLockingScript,
+                        });
+                    }
+                    else {
+                        requests.push({
+                            transaction,
+                            request,
+                            lockerAddress,
+                            lockerLockingScript,
+                        });
+                    }
+                }
+                else if (request.code !== "NO_OP_RETURN") {
+                    invalidRequests.push({ transaction, request, lockerAddress, lockerLockingScript });
+                }
+            }
+            return { requests, invalidRequests };
+        });
+    }
+    getWrapRequestByTx(inputTransaction, lockerAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let transaction;
+            if ("vout" in inputTransaction && "blockNumber" in inputTransaction) {
+                transaction = inputTransaction;
+            }
+            else {
+                if (!inputTransaction.txId)
+                    throw new Error("txId not exist");
+                transaction = yield this.getTransaction(inputTransaction.txId);
+            }
+            let vout = transaction.vout;
+            let request = (0, teleswap_helper_1.checkAndParseWrapRequest)(vout, lockerAddress);
+            let lockerLockingScript = transaction.addressScript ||
+                this.convertAddressToScript(lockerAddress).script.toString("hex");
+            return {
+                transaction,
+                request,
+                lockerAddress,
+                lockerLockingScript,
+            };
+        });
+    }
+    getLockersUnWrapTransactions(addresses, startBlockNumber, endBlockNumber) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let transactions = yield this.getMultipleBlocksTransactions(addresses, startBlockNumber, endBlockNumber);
+            let validTxs = [];
+            for (let transaction of transactions) {
+                let address = transaction.address;
+                let txBurnInfo = yield this.getTransactionUnwrapInfoByTx(transaction, address);
+                if (txBurnInfo) {
+                    const { burnInfo, lockerAddress, lockerLockingScript } = txBurnInfo;
+                    validTxs.push({
+                        transaction,
+                        burnInfo,
+                        lockerAddress,
+                        lockerLockingScript,
+                    });
+                }
+            }
+            return validTxs;
+        });
+    }
+    getLockersUnwrapMEmpoolTransactions(addresses, startBlockNumber, endBlockNumber) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let transactions = yield this.getMultipleBlocksTransactions(addresses, startBlockNumber, endBlockNumber);
+            let validTxs = [];
+            for (let transaction of transactions) {
+                let address = transaction.address;
+                let txBurnInfo = yield this.getTransactionUnwrapInfoByTx(transaction, address);
+                if (txBurnInfo) {
+                    const { burnInfo, lockerAddress, lockerLockingScript } = txBurnInfo;
+                    validTxs.push({
+                        transaction,
+                        burnInfo,
+                        lockerAddress,
+                        lockerLockingScript,
+                    });
+                }
+            }
+            return validTxs;
+        });
+    }
+    getTransactionUnwrapInfoByTx(transaction, lockerAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!transaction.txId)
+                throw new Error("txId not exist");
+            let vin = transaction.vin || (yield this.getTransaction(transaction.txId)).vin;
+            let burnInfo = (0, teleswap_helper_1.getBurnTransactionInfo)(lockerAddress, vin, transaction.vout);
+            if (!burnInfo)
+                return;
+            let lockerLockingScript = transaction.addressScript ||
+                this.convertAddressToScript(lockerAddress).script.toString("hex");
+            return {
+                burnInfo,
+                lockerAddress,
+                lockerLockingScript,
+            };
+        });
+    }
+}
+exports.BitcoinInterfaceTeleswap = BitcoinInterfaceTeleswap;
 //# sourceMappingURL=bitcoin-interface-teleswap.js.map

package/dist/bitcoin-interface-utils.d.ts

@@ -1,21 +1,21 @@
-/// <reference types="node" />
-import type { Network } from "bitcoinjs-lib";
-export declare class BitcoinInterfaceUtils {
-    testnet: boolean;
-    network: Network;
-    constructor(networkName: string);
-    convertHashToAddress(hashHex: string, addressType: string): string;
-    convertScriptToAddress(scriptHex: string, addressType: string): string;
-    convertAddressToScript(address: string): {
-        script: Buffer | undefined;
-        hash: Buffer | undefined;
-        addressType: "p2tr" | "p2wpkh" | "p2sh" | "p2pkh";
-    };
-    convertAddressToObject(address: string): {
-        addressObject: import("bitcoinjs-lib").Payment;
-        addressType: "p2tr" | "p2wpkh" | "p2sh" | "p2pkh";
-    };
-    createAddressObjectByPublicKey(publicKey: string, addressType: string): import("bitcoinjs-lib").Payment;
-}
-export default BitcoinInterfaceUtils;
+/// <reference types="node" />
+import type { Network } from "bitcoinjs-lib";
+export declare class BitcoinInterfaceUtils {
+    testnet: boolean;
+    network: Network;
+    constructor(networkName: string);
+    convertHashToAddress(hashHex: string, addressType: string): string;
+    convertScriptToAddress(scriptHex: string, addressType: string): string;
+    convertAddressToScript(address: string): {
+        script: Buffer | undefined;
+        hash: Buffer | undefined;
+        addressType: "p2tr" | "p2wpkh" | "p2sh" | "p2pkh";
+    };
+    convertAddressToObject(address: string): {
+        addressObject: import("bitcoinjs-lib").Payment;
+        addressType: "p2tr" | "p2wpkh" | "p2sh" | "p2pkh";
+    };
+    createAddressObjectByPublicKey(publicKey: string, addressType: string): import("bitcoinjs-lib").Payment;
+}
+export default BitcoinInterfaceUtils;
 //# sourceMappingURL=bitcoin-interface-utils.d.ts.map