@teleportdao/bitcoin 1.0.0

package/dist/bitcoin-base.d.ts

@@ -0,0 +1,56 @@
+export = BitcoinBase;
+declare class BitcoinBase {
+    static checkBalanceIsSufficient({ targets, extendedUtxo, changeAddress, feeRate, fullAmount, }: {
+        targets: any;
+        extendedUtxo: any;
+        changeAddress: any;
+        feeRate: any;
+        fullAmount?: boolean | undefined;
+    }): boolean;
+    constructor(networkName: any, connectionInfo?: {
+        api: {
+            enabled: boolean;
+            provider: string;
+        };
+    });
+    network: any;
+    hdWalletPath: any;
+    transactionBuilder: TransactionBuilder;
+    btcInterface: import("./bitcoin-interface");
+    signer: BitcoinSign;
+    currentAccount: string | null | undefined;
+    currentAccountType: string | null;
+    privateKey: Buffer | null;
+    publicKey: Buffer | null;
+    publicKeys: any[];
+    setMultiSigAccount(accountType?: string): void;
+    setAccountPrivateKey(privateKeyHex: any): void;
+    setAccountPublicKey(publicKeyHex: any): void;
+    setAccountPrivateKeyByMnemonic({ mnemonic, mnemonicPassword, index, walletNumber, addressType, }: {
+        mnemonic: any;
+        mnemonicPassword?: string | undefined;
+        index?: number | undefined;
+        walletNumber?: number | undefined;
+        addressType?: string | undefined;
+    }): void;
+    setAccount(accountType?: string): string | undefined;
+    addressObj: import("bitcoinjs-lib").Payment | undefined;
+    getExtendedUtxo({ address, addressType, publicKey, derivationPath }: {
+        address: string;
+        addressType: string;
+        publicKey: string | null;
+        derivationPath: string | null;
+        privateKeyId: string | null;
+    }): Promise<any>;
+    send({ receiverAddress, amount, fullAmount, speed }: {
+        receiverAddress: any;
+        amount: any;
+        fullAmount?: boolean | undefined;
+        speed?: string | undefined;
+    }): Promise<any>;
+    sendSignedPsbt(signedPsbt: any): Promise<any>;
+    sendMultiSignedPsbt(signedPsbts?: any[]): Promise<any>;
+}
+import TransactionBuilder = require("./transaction-builder/bitcoin-transaction-builder");
+import BitcoinSign = require("./sign/sign-transaction");
+//# sourceMappingURL=bitcoin-base.d.ts.map

package/dist/bitcoin-base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bitcoin-base.d.ts","sourceRoot":"","sources":["../src/bitcoin-base.js"],"names":[],"mappings":";AASA;IAyGE;;;;;;gBAmBC;IA3HD;;;;;OAwBC;IAfC,aAAoC;IACpC,kBAA6E;IAE7E,uCAA2F;IAC3F,4CAAwD;IAExD,oBAA2C;IAE3C,0CAA0B;IAC1B,kCAA8B;IAE9B,0BAAsB;IACtB,yBAAqB;IAErB,kBAAoB;IAGtB,+CAiBC;IAED,+CAEC;IAED,6CAEC;IAED;;;;;;aAkBC;IAED,qDASC;IAFC,wDAA4B;IAe9B;QAR8B,OAAO;QACP,WAAW;QACV,SAAS;QAET,cAAc;QACd,YAAY;qBAU1C;IAuBD;;;;;qBAuBC;IAED,8CAIC;IAED,uDAIC;CACF"}

package/dist/bitcoin-base.js

@@ -0,0 +1,138 @@
+"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());
+    });
+};
+const bip39 = require("bip39");
+const bip32 = require("bip32");
+const hdWalletNetworksPath = require("@teleportdao/configs").hdWalletPath;
+const networks = require("./utils/networks");
+const TransactionBuilder = require("./transaction-builder/bitcoin-transaction-builder");
+const BitcoinSign = require("./sign/sign-transaction");
+class BitcoinBase {
+    constructor(networkName, connectionInfo = {
+        api: {
+            enabled: true,
+            provider: "BlockStream",
+        },
+    }) {
+        this.network = networks[networkName];
+        this.hdWalletPath = hdWalletNetworksPath[networkName.replace("_testnet", "")];
+        this.transactionBuilder = new TransactionBuilder(connectionInfo, networkName, this.network);
+        this.btcInterface = this.transactionBuilder.btcInterface;
+        this.signer = new BitcoinSign(this.network);
+        this.currentAccount = null;
+        this.currentAccountType = null;
+        this.privateKey = null;
+        this.publicKey = null;
+        this.publicKeys = [];
+    }
+    setMultiSigAccount(accountType = "p2sh") {
+        switch (accountType) {
+            default:
+                throw new Error("accountType is incorrect");
+        }
+        this.currentAccountType = accountType;
+    }
+    setAccountPrivateKey(privateKeyHex) {
+        this.privateKey = Buffer.from(privateKeyHex, "hex");
+    }
+    setAccountPublicKey(publicKeyHex) {
+        this.publicKey = Buffer.from(publicKeyHex, "hex");
+    }
+    setAccountPrivateKeyByMnemonic({ mnemonic, mnemonicPassword = "", index = 0, walletNumber = 0, addressType = "p2sh-p2wpkh", }) {
+        if (!bip39.validateMnemonic(mnemonic))
+            throw new Error("invalid mnemonic");
+        const seed = bip39.mnemonicToSeedSync(mnemonic, mnemonicPassword);
+        const node = bip32.fromSeed(seed);
+        if (!this.hdWalletPath[addressType])
+            throw new Error("incorrect path or addressType");
+        const path = `${this.hdWalletPath[addressType]}/${walletNumber}`;
+        const account = node.derivePath(path);
+        const userKeyPair = account.derive(index);
+        this.setAccountPrivateKey(userKeyPair.privateKey.toString("hex"));
+        this.setAccountPublicKey(userKeyPair.publicKey.toString("hex"));
+    }
+    setAccount(accountType = "p2pkh") {
+        let addressObj = this.transactionBuilder.createAddressObject({
+            addressType: accountType,
+            publicKey: this.publicKey,
+        });
+        this.currentAccount = addressObj.address;
+        this.currentAccountType = accountType;
+        this.addressObj = addressObj;
+        return addressObj.address;
+    }
+    getExtendedUtxo({ address, addressType, publicKey, derivationPath }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.transactionBuilder.getExtendedUtxo({
+                address,
+                addressType,
+                publicKey,
+                derivationPath,
+            });
+        });
+    }
+    static checkBalanceIsSufficient({ targets, extendedUtxo, changeAddress, feeRate, fullAmount = false, }) {
+        try {
+            TransactionBuilder.helperHandleInputsAndOutputs({
+                targets,
+                extendedUtxo,
+                changeAddress,
+                feeRate,
+                fullAmount,
+            });
+            return true;
+        }
+        catch (err) {
+            return false;
+        }
+    }
+    send({ receiverAddress, amount, fullAmount = false, speed = "normal" }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let extendedUtxo = yield this.getExtendedUtxo({
+                address: this.currentAccount,
+                addressType: this.currentAccountType,
+                publicKey: this.publicKey.toString("hex"),
+            });
+            let feeRate = yield this.transactionBuilder._getFeeRate(speed);
+            let unsignedTx = yield this.transactionBuilder.processUnsignedTransaction({
+                extendedUtxo,
+                targets: [
+                    {
+                        address: receiverAddress,
+                        value: amount,
+                    },
+                ],
+                changeAddress: this.currentAccount,
+                feeRate,
+                fullAmount,
+            });
+            let signedPsbt = yield this.signer.signPsbt(unsignedTx, this.privateKey);
+            let signedTx = this.signer.finalizePsbts([signedPsbt]);
+            let txId = yield this.transactionBuilder.sendTx(signedTx);
+            return txId;
+        });
+    }
+    sendSignedPsbt(signedPsbt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let signedTx = this.signer.finalizePsbts([signedPsbt]);
+            let txId = yield this.transactionBuilder.sendTx(signedTx);
+            return txId;
+        });
+    }
+    sendMultiSignedPsbt(signedPsbts = []) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let signedTx = this.signer.finalizePsbts(signedPsbts);
+            let txId = yield this.transactionBuilder.sendTx(signedTx);
+            return txId;
+        });
+    }
+}
+module.exports = BitcoinBase;
+//# sourceMappingURL=bitcoin-base.js.map

package/dist/bitcoin-base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bitcoin-base.js","sourceRoot":"","sources":["../src/bitcoin-base.js"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,18 @@
+export = BitcoinInterfaceUtils;
+declare class BitcoinInterfaceUtils {
+    constructor(networkName: any);
+    testnet: any;
+    network: any;
+    convertHashToAddress(hashHex: any, addressType: any): string | undefined;
+    convertAddressToScript(address: any): {
+        script: Buffer | undefined;
+        hash: Buffer | undefined;
+        addressType: "p2wpkh" | "p2sh" | "p2pkh";
+    };
+    convertAddressToObject(address: any): {
+        addressObject: import("bitcoinjs-lib").Payment;
+        addressType: "p2wpkh" | "p2sh" | "p2pkh";
+    };
+    createAddressObjectByPublicKey(address: any, addressType: any): import("bitcoinjs-lib").Payment;
+}
+//# sourceMappingURL=bitcoin-interface-utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bitcoin-interface-utils.d.ts","sourceRoot":"","sources":["../src/bitcoin-interface-utils.js"],"names":[],"mappings":";AAOA;IACE,8BAGC;IAFC,aAA+C;IAC/C,aAAoC;IAGtC,yEAMC;IAED;;;;MAOC;IAED;;;MAGC;IAED,gGAGC;CACF"}

package/dist/bitcoin-interface-utils.js

@@ -0,0 +1,31 @@
+"use strict";
+const networks = require("./utils/networks");
+const { createAddressObjectByHash, createAddressObjectByAddress, createAddressObjectByPublicKey, } = require("./bitcoin-utils");
+class BitcoinInterfaceUtils {
+    constructor(networkName) {
+        this.testnet = networkName.includes("_testnet");
+        this.network = networks[networkName];
+    }
+    convertHashToAddress(hashHex, addressType) {
+        let addressObj = createAddressObjectByHash({ addressType, hash: Buffer.from(hashHex, "hex") }, this.network);
+        return addressObj.address;
+    }
+    convertAddressToScript(address) {
+        let { addressObject, addressType } = createAddressObjectByAddress(address, this.network);
+        return {
+            script: addressObject.output,
+            hash: addressObject.hash,
+            addressType,
+        };
+    }
+    convertAddressToObject(address) {
+        let addObj = createAddressObjectByAddress(address, this.network);
+        return addObj;
+    }
+    createAddressObjectByPublicKey(address, addressType) {
+        let addObj = createAddressObjectByPublicKey({ address, addressType }, this.network);
+        return addObj;
+    }
+}
+module.exports = BitcoinInterfaceUtils;
+//# sourceMappingURL=bitcoin-interface-utils.js.map

package/dist/bitcoin-interface-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bitcoin-interface-utils.js","sourceRoot":"","sources":["../src/bitcoin-interface-utils.js"],"names":[],"mappings":";AAAA,MAAM,QAAQ,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAA;AAC5C,MAAM,EACJ,yBAAyB,EACzB,4BAA4B,EAC5B,8BAA8B,GAC/B,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAA;AAE9B,MAAM,qBAAqB;IACzB,YAAY,WAAW;QACrB,IAAI,CAAC,OAAO,GAAG,WAAW,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAA;QAC/C,IAAI,CAAC,OAAO,GAAG,QAAQ,CAAC,WAAW,CAAC,CAAA;IACtC,CAAC;IAED,oBAAoB,CAAC,OAAO,EAAE,WAAW;QACvC,IAAI,UAAU,GAAG,yBAAyB,CACxC,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,EAAE,EAClD,IAAI,CAAC,OAAO,CACb,CAAA;QACD,OAAO,UAAU,CAAC,OAAO,CAAA;IAC3B,CAAC;IAED,sBAAsB,CAAC,OAAO;QAC5B,IAAI,EAAE,aAAa,EAAE,WAAW,EAAE,GAAG,4BAA4B,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,CAAA;QACxF,OAAO;YACL,MAAM,EAAE,aAAa,CAAC,MAAM;YAC5B,IAAI,EAAE,aAAa,CAAC,IAAI;YACxB,WAAW;SACZ,CAAA;IACH,CAAC;IAED,sBAAsB,CAAC,OAAO;QAC5B,IAAI,MAAM,GAAG,4BAA4B,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,CAAA;QAChE,OAAO,MAAM,CAAA;IACf,CAAC;IAED,8BAA8B,CAAC,OAAO,EAAE,WAAW;QACjD,IAAI,MAAM,GAAG,8BAA8B,CAAC,EAAE,OAAO,EAAE,WAAW,EAAE,EAAE,IAAI,CAAC,OAAO,CAAC,CAAA;QACnF,OAAO,MAAM,CAAA;IACf,CAAC;CACF;AAED,MAAM,CAAC,OAAO,GAAG,qBAAqB,CAAA"}

package/dist/bitcoin-interface.d.ts

@@ -0,0 +1,154 @@
+export = BitcoinInterface;
+declare class BitcoinInterface extends BitcoinInterfaceUtils {
+    constructor(connectionInfo: any, networkName: any, config?: {
+        minTeleporterFeeAmount: number;
+    });
+    rpcProvider: import("@teleportdao/providers/dist/bitcoin/rpc") | undefined;
+    apiProviderName: any;
+    apiProvider: any;
+    minTeleporterFeeAmount: number;
+    provider: any;
+    getLatestBlockNumber(): Promise<any>;
+    getBlockHash(blockNumber: any): Promise<any>;
+    getBlockHeaderHex(blockNumber: any): Promise<any>;
+    getTransaction(txId: any): Promise<any>;
+    getFeeRate(speed?: string): Promise<any>;
+    getHexBlockHeaders(startBlockNumber: any, endBlockNumber: any): Promise<{
+        hexBlockHeaders: string;
+        fromBlockNumber: any;
+        toBlockNumber: any;
+        difficulty: any;
+    }[]>;
+    getRequestProof(transaction: any): Promise<{
+        parsedTx: {
+            version: any;
+            flag: any;
+            vin: string;
+            vout: string;
+            witness: string;
+            locktime: string;
+        };
+        merkleProof: any;
+        blockNumber: any;
+        blockHash: any;
+    }>;
+    getMerkleProof(txId: any, blockHash: any): Promise<{
+        intermediateNodes: any;
+        transactionIndex: any;
+    }>;
+    getAddressesUtxo(addresses: any): Promise<any>;
+    getBalance(address: any): Promise<any>;
+    getBlockTransactions(addresses: any, blockNumber: any): Promise<any[]>;
+    getMultipleBlocksTransactions(addresses: any, startBlockNumber: any, endBlockNumber: any): Promise<any>;
+    getTransactionHistory(addresses: any, startBlockNumber: any, endBlockNumber: any): Promise<any>;
+    getMempoolTransactionHistory(addresses: any): Promise<any>;
+    getTeleporterRequests(addresses: any, startblockNumber: any, endBlockNumber: any, mempool?: boolean): Promise<{
+        requests: {
+            transaction: any;
+            request: {
+                status: boolean;
+                data: {
+                    requestType: string;
+                    chainId: number;
+                    appId: number;
+                    recipientAddress: string;
+                    percentageFee: number;
+                    speed: boolean;
+                    exchangeTokenAddress: string;
+                    outputAmount: number;
+                    deadline: number;
+                    isFixedToken: boolean;
+                };
+                message?: undefined;
+                code?: undefined;
+            } | {
+                status: boolean;
+                message: string;
+                code: string;
+                data?: undefined;
+            } | {
+                status: boolean;
+                data: {
+                    requestType: string;
+                    chainId: number;
+                    appId: number;
+                    recipientAddress: string;
+                    percentageFee: number;
+                    mode: number;
+                    tokenAddress: string;
+                    borrowAmount: number;
+                };
+                message?: undefined;
+                code?: undefined;
+            } | {
+                status: boolean;
+                data: any;
+                value: any;
+                message?: undefined;
+                code?: undefined;
+            };
+            lockerAddress: any;
+            lockerLockingScript: any;
+        }[];
+        invalidRequests: {
+            transaction: any;
+            request: {
+                status: boolean;
+                data: {
+                    requestType: string;
+                    chainId: number;
+                    appId: number;
+                    recipientAddress: string;
+                    percentageFee: number;
+                    speed: boolean;
+                    exchangeTokenAddress: string;
+                    outputAmount: number;
+                    deadline: number;
+                    isFixedToken: boolean;
+                };
+                message?: undefined;
+                code?: undefined;
+            } | {
+                status: boolean;
+                message: string;
+                code: string;
+                data?: undefined;
+            } | {
+                status: boolean;
+                data: {
+                    requestType: string;
+                    chainId: number;
+                    appId: number;
+                    recipientAddress: string;
+                    percentageFee: number;
+                    mode: number;
+                    tokenAddress: string;
+                    borrowAmount: number;
+                };
+                message?: undefined;
+                code?: undefined;
+            } | {
+                status: boolean;
+                data: any;
+                value: any;
+                message?: undefined;
+                code?: undefined;
+            };
+            lockerAddress: any;
+            lockerLockingScript: any;
+        }[];
+    }>;
+    getLockersBurnTransactions(addresses: any, startBlockNumber: any, endBlockNumber: any, mempool?: boolean): Promise<{
+        transaction: any;
+        burnInfo: {
+            receivers: any[];
+            changes: any[];
+            totalInputValue: any;
+            lockerVin: any;
+        };
+        lockerAddress: any;
+        lockerLockingScript: any;
+    }[]>;
+}
+import BitcoinInterfaceUtils = require("./bitcoin-interface-utils");
+//# sourceMappingURL=bitcoin-interface.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bitcoin-interface.d.ts","sourceRoot":"","sources":["../src/bitcoin-interface.js"],"names":[],"mappings":";AAYA;IACE;;OAeC;IAZG,2EAAqD;IAMrD,qBAAkD;IAClD,iBAAkE;IAGpE,+BAA2D;IAC3D,cAAoD;IAMtD,qCAGC;IAED,6CAGC;IAED,kDAGC;IAED,wCAEC;IAGD,yCAMC;IAKD;;;;;SAkCC;IAED;;;;;;;;;;;;OAoBC;IAED;;;OAMC;IAKD,+CAWC;IAED,uCAMC;IAID,uEAYC;IAGD,wGAaC;IAGD,gGAcC;IAGD,2DAMC;IAID;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwBC;IAED;;;;;;;;;;SAuBC;CACF"}

package/dist/bitcoin-interface.js

@@ -0,0 +1,248 @@
+"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());
+    });
+};
+const { getRpcProvider, getApiProvider } = require("@teleportdao/providers").bitcoin;
+const { runWithRetries, sleep } = require("./utils/tools");
+const { parseRawTransaction, calculateMerkleProof, parseBlockHeader, extractTransactionsAndBlockInfoFromRawBlock, } = require("./bitcoin-utils");
+const { checkAndParseProtocolRequest } = require("./helper/teleport-request-helper");
+const { getBurnTransactionInfo } = require("./helper/burn-request-helper");
+const BitcoinInterfaceUtils = require("./bitcoin-interface-utils");
+class BitcoinInterface extends BitcoinInterfaceUtils {
+    constructor(connectionInfo, networkName, config = { minTeleporterFeeAmount: 0 }) {
+        var _a;
+        super(networkName);
+        if ((_a = connectionInfo.rpc) === null || _a === void 0 ? void 0 : _a.enabled) {
+            this.rpcProvider = getRpcProvider(connectionInfo.rpc);
+        }
+        else if (connectionInfo.api.provider !== "BlockStream") {
+            throw new Error("if rpc is disabled, we just support BlockStream as api provider");
+        }
+        if (connectionInfo.api.enabled) {
+            this.apiProviderName = connectionInfo.api.provider;
+            this.apiProvider = getApiProvider(connectionInfo.api, networkName);
+        }
+        this.minTeleporterFeeAmount = config.minTeleporterFeeAmount;
+        this.provider = this.rpcProvider || this.apiProvider;
+    }
+    getLatestBlockNumber() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let latestHeight = yield this.provider.getLatestBlockNumber();
+            return latestHeight;
+        });
+    }
+    getBlockHash(blockNumber) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let headerHash = yield runWithRetries(() => this.provider.getBlockHash(blockNumber));
+            return headerHash;
+        });
+    }
+    getBlockHeaderHex(blockNumber) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let headerHex = yield runWithRetries(() => this.provider.getBlockHeaderHex(blockNumber));
+            return headerHex;
+        });
+    }
+    getTransaction(txId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.provider.getTransaction(txId);
+        });
+    }
+    getFeeRate(speed = "normal") {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(speed === "normal" || speed === "slow" || speed === "fast")) {
+                throw new Error("incorrect speed");
+            }
+            let fee = yield this.provider.getFeeRate(speed);
+            return fee;
+        });
+    }
+    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 = 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;
+        });
+    }
+    getRequestProof(transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let transactionHex = transaction.hex || (yield this.provider.getRawTransaction(transaction.txId));
+            let txInfo;
+            if (!(transaction.blockHash && transaction.blockNumber)) {
+                txInfo = yield this.provider.getTransaction(transaction.txId);
+            }
+            let blockHash = transaction.blockHash || txInfo.blockHash;
+            let blockNumber = transaction.blockNumber || txInfo.blockNumber;
+            let parsedTx = parseRawTransaction(transactionHex);
+            let merkleProof = transaction.merkleProof || (yield this.getMerkleProof(transaction.txId, blockHash));
+            return {
+                parsedTx,
+                merkleProof,
+                blockNumber,
+                blockHash,
+            };
+        });
+    }
+    getMerkleProof(txId, blockHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let txIds = yield this.provider.getBlockTransactionIds(blockHash);
+            let proof = calculateMerkleProof(txIds, txId);
+            return proof;
+        });
+    }
+    getAddressesUtxo(addresses) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.apiProvider) {
+                throw new Error("this function need an api provider");
+            }
+            const allPromises = [];
+            for (let address of addresses) {
+                let promise = yield this.apiProvider.getUtxos(address);
+                allPromises.push(promise);
+            }
+            let result = yield Promise.all(allPromises);
+            return result.flat(1);
+        });
+    }
+    getBalance(address) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.apiProvider) {
+                throw new Error("this function need an api provider");
+            }
+            let utxos = (_a = (yield this.apiProvider.getUtxos(address))) !== null && _a !== void 0 ? _a : [];
+            return utxos.reduce((a, tx) => a + Number(tx.value), 0);
+        });
+    }
+    getBlockTransactions(addresses, blockNumber) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let utxos = yield this.getAddressesUtxo(addresses);
+            let rawBlockHex = yield this.rpcProvider.getBlockByBlockNumber(blockNumber, 0);
+            let { withdrawTxs, depositTxs } = extractTransactionsAndBlockInfoFromRawBlock(rawBlockHex, blockNumber, addresses, utxos, this.network);
+            return depositTxs.concat(withdrawTxs);
+        });
+    }
+    getMultipleBlocksTransactions(addresses, startBlockNumber, endBlockNumber) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (endBlockNumber - startBlockNumber > 20) {
+                throw new Error("cant get more than 20 block per function call");
+            }
+            let blockTxs = [];
+            for (let blockNumber = +startBlockNumber + 1; blockNumber <= endBlockNumber; blockNumber += 1) {
+                console.log("get block transactions. blockNumber: ", blockNumber);
+                const response = this.getBlockTransactions(addresses, blockNumber);
+                blockTxs.push(response);
+                yield sleep(200);
+            }
+            blockTxs = yield Promise.all(blockTxs);
+            return blockTxs.flat(1);
+        });
+    }
+    getTransactionHistory(addresses, startBlockNumber, endBlockNumber) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.rpcProvider) {
+                let endBlock = endBlockNumber || (yield this.getLatestBlockNumber());
+                let startBlock = Math.max(+startBlockNumber, +endBlock - 20);
+                return this.getMultipleBlocksTransactions(addresses, startBlock, endBlock);
+            }
+            if (this.apiProviderName !== "BlockStream") {
+                throw new Error("just support BlockStream as api provider for this function");
+            }
+            let txs = yield this.apiProvider.getTransactionHistoryForMultipleAddresses(addresses, startBlockNumber);
+            return txs.flat(1);
+        });
+    }
+    getMempoolTransactionHistory(addresses) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.apiProviderName !== "BlockStream") {
+                throw new Error("teleporter just support BlockStream as api provider");
+            }
+            let txs = yield this.apiProvider.getMempoolTransactionHistoryForMultipleAddresses(addresses);
+            return txs.flat(1);
+        });
+    }
+    getTeleporterRequests(addresses, startblockNumber, endBlockNumber, mempool = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let transactions = mempool
+                ? yield this.getMempoolTransactionHistory(addresses)
+                : yield this.getTransactionHistory(addresses, startblockNumber, endBlockNumber);
+            let requests = [];
+            let invalidRequests = [];
+            for (let transaction of transactions) {
+                console.log(`received tx to check for teleport: ${transaction.txId}`);
+                let address = transaction.address;
+                let request = checkAndParseProtocolRequest(transaction.vout, address, {
+                    minTeleporterFeeAmount: this.minTeleporterFeeAmount,
+                });
+                let lockerLockingScript = transaction.addressScript || this.convertAddressToScript(address).script.toString("hex");
+                if (request.status) {
+                    requests.push({ transaction, request, lockerAddress: address, lockerLockingScript });
+                }
+                else if (request.code !== "NO_OP_RETURN") {
+                    invalidRequests.push({ transaction, request, lockerAddress: address, lockerLockingScript });
+                }
+            }
+            return { requests, invalidRequests };
+        });
+    }
+    getLockersBurnTransactions(addresses, startBlockNumber, endBlockNumber, mempool = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let transactions = mempool
+                ? yield this.getMempoolTransactionHistory(addresses)
+                : yield this.getTransactionHistory(addresses, startBlockNumber, endBlockNumber);
+            let validTxs = [];
+            for (let transaction of transactions) {
+                let address = transaction.address;
+                console.log(`received tx to check burn: ${transaction.txId}`);
+                let burnInfo = getBurnTransactionInfo(address, transaction.vin, transaction.vout);
+                if (burnInfo) {
+                    validTxs.push({
+                        transaction,
+                        burnInfo,
+                        lockerAddress: address,
+                        lockerLockingScript: transaction.addressScript ||
+                            this.convertAddressToScript(address).script.toString("hex"),
+                    });
+                }
+            }
+            return validTxs;
+        });
+    }
+}
+module.exports = BitcoinInterface;
+//# sourceMappingURL=bitcoin-interface.js.map