@atomiqlabs/chain-evm 1.0.0-dev.22

package/dist/evm/btcrelay/BtcRelayAbi.js

@@ -0,0 +1,261 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BtcRelayAbi = void 0;
+exports.BtcRelayAbi = [
+    {
+        "inputs": [
+            {
+                "components": [
+                    {
+                        "internalType": "bytes32[5]",
+                        "name": "data",
+                        "type": "bytes32[5]"
+                    }
+                ],
+                "internalType": "struct StoredBlockHeader",
+                "name": "storedHeader",
+                "type": "tuple"
+            },
+            {
+                "internalType": "bool",
+                "name": "clampBlockTarget",
+                "type": "bool"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "constructor"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "bytes32",
+                "name": "commitHash",
+                "type": "bytes32"
+            },
+            {
+                "indexed": true,
+                "internalType": "bytes32",
+                "name": "blockHash",
+                "type": "bytes32"
+            },
+            {
+                "indexed": true,
+                "internalType": "uint256",
+                "name": "forkId",
+                "type": "uint256"
+            },
+            {
+                "indexed": false,
+                "internalType": "address",
+                "name": "submitter",
+                "type": "address"
+            },
+            {
+                "indexed": false,
+                "internalType": "uint256",
+                "name": "startHeight",
+                "type": "uint256"
+            }
+        ],
+        "name": "ChainReorg",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "bytes32",
+                "name": "commitHash",
+                "type": "bytes32"
+            },
+            {
+                "indexed": true,
+                "internalType": "bytes32",
+                "name": "blockHash",
+                "type": "bytes32"
+            },
+            {
+                "indexed": true,
+                "internalType": "uint256",
+                "name": "forkId",
+                "type": "uint256"
+            }
+        ],
+        "name": "StoreForkHeader",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "bytes32",
+                "name": "commitHash",
+                "type": "bytes32"
+            },
+            {
+                "indexed": true,
+                "internalType": "bytes32",
+                "name": "blockHash",
+                "type": "bytes32"
+            }
+        ],
+        "name": "StoreHeader",
+        "type": "event"
+    },
+    {
+        "inputs": [],
+        "name": "getBlockheight",
+        "outputs": [
+            {
+                "internalType": "uint32",
+                "name": "blockheight",
+                "type": "uint32"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "getChainwork",
+        "outputs": [
+            {
+                "internalType": "uint224",
+                "name": "chainWork",
+                "type": "uint224"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint256",
+                "name": "height",
+                "type": "uint256"
+            }
+        ],
+        "name": "getCommitHash",
+        "outputs": [
+            {
+                "internalType": "bytes32",
+                "name": "",
+                "type": "bytes32"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "getTipCommitHash",
+        "outputs": [
+            {
+                "internalType": "bytes32",
+                "name": "",
+                "type": "bytes32"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint256",
+                "name": "forkId",
+                "type": "uint256"
+            },
+            {
+                "internalType": "bytes",
+                "name": "data",
+                "type": "bytes"
+            }
+        ],
+        "name": "submitForkBlockheaders",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "bytes",
+                "name": "data",
+                "type": "bytes"
+            }
+        ],
+        "name": "submitMainBlockheaders",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "bytes",
+                "name": "data",
+                "type": "bytes"
+            }
+        ],
+        "name": "submitShortForkBlockheaders",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "components": [
+                    {
+                        "internalType": "bytes32[5]",
+                        "name": "data",
+                        "type": "bytes32[5]"
+                    }
+                ],
+                "internalType": "struct StoredBlockHeader",
+                "name": "storedHeader",
+                "type": "tuple"
+            }
+        ],
+        "name": "verifyBlockheader",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "confirmations",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint256",
+                "name": "height",
+                "type": "uint256"
+            },
+            {
+                "internalType": "bytes32",
+                "name": "commitmentHash",
+                "type": "bytes32"
+            }
+        ],
+        "name": "verifyBlockheaderHash",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "confirmations",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    }
+];

package/dist/evm/btcrelay/BtcRelayTypechain.d.ts

@@ -0,0 +1,172 @@
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../typechain/common";
+export type StoredBlockHeaderStruct = {
+    data: [BytesLike, BytesLike, BytesLike, BytesLike, BytesLike];
+};
+export type StoredBlockHeaderStructOutput = [
+    data: [string, string, string, string, string]
+] & {
+    data: [string, string, string, string, string];
+};
+export interface BtcRelayInterface extends Interface {
+    getFunction(nameOrSignature: "getBlockheight" | "getChainwork" | "getCommitHash" | "getTipCommitHash" | "submitForkBlockheaders" | "submitMainBlockheaders" | "submitShortForkBlockheaders" | "verifyBlockheader" | "verifyBlockheaderHash"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "ChainReorg" | "StoreForkHeader" | "StoreHeader"): EventFragment;
+    encodeFunctionData(functionFragment: "getBlockheight", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getChainwork", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getCommitHash", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "getTipCommitHash", values?: undefined): string;
+    encodeFunctionData(functionFragment: "submitForkBlockheaders", values: [BigNumberish, BytesLike]): string;
+    encodeFunctionData(functionFragment: "submitMainBlockheaders", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "submitShortForkBlockheaders", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "verifyBlockheader", values: [StoredBlockHeaderStruct]): string;
+    encodeFunctionData(functionFragment: "verifyBlockheaderHash", values: [BigNumberish, BytesLike]): string;
+    decodeFunctionResult(functionFragment: "getBlockheight", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getChainwork", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getCommitHash", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getTipCommitHash", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "submitForkBlockheaders", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "submitMainBlockheaders", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "submitShortForkBlockheaders", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "verifyBlockheader", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "verifyBlockheaderHash", data: BytesLike): Result;
+}
+export declare namespace ChainReorgEvent {
+    type InputTuple = [
+        commitHash: BytesLike,
+        blockHash: BytesLike,
+        forkId: BigNumberish,
+        submitter: AddressLike,
+        startHeight: BigNumberish
+    ];
+    type OutputTuple = [
+        commitHash: string,
+        blockHash: string,
+        forkId: bigint,
+        submitter: string,
+        startHeight: bigint
+    ];
+    interface OutputObject {
+        commitHash: string;
+        blockHash: string;
+        forkId: bigint;
+        submitter: string;
+        startHeight: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace StoreForkHeaderEvent {
+    type InputTuple = [
+        commitHash: BytesLike,
+        blockHash: BytesLike,
+        forkId: BigNumberish
+    ];
+    type OutputTuple = [
+        commitHash: string,
+        blockHash: string,
+        forkId: bigint
+    ];
+    interface OutputObject {
+        commitHash: string;
+        blockHash: string;
+        forkId: bigint;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace StoreHeaderEvent {
+    type InputTuple = [commitHash: BytesLike, blockHash: BytesLike];
+    type OutputTuple = [commitHash: string, blockHash: string];
+    interface OutputObject {
+        commitHash: string;
+        blockHash: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface BtcRelay extends BaseContract {
+    connect(runner?: ContractRunner | null): BtcRelay;
+    waitForDeployment(): Promise<this>;
+    interface: BtcRelayInterface;
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    getBlockheight: TypedContractMethod<[], [bigint], "view">;
+    getChainwork: TypedContractMethod<[], [bigint], "view">;
+    getCommitHash: TypedContractMethod<[height: BigNumberish], [string], "view">;
+    getTipCommitHash: TypedContractMethod<[], [string], "view">;
+    submitForkBlockheaders: TypedContractMethod<[
+        forkId: BigNumberish,
+        data: BytesLike
+    ], [
+        void
+    ], "nonpayable">;
+    submitMainBlockheaders: TypedContractMethod<[
+        data: BytesLike
+    ], [
+        void
+    ], "nonpayable">;
+    submitShortForkBlockheaders: TypedContractMethod<[
+        data: BytesLike
+    ], [
+        void
+    ], "nonpayable">;
+    verifyBlockheader: TypedContractMethod<[
+        storedHeader: StoredBlockHeaderStruct
+    ], [
+        bigint
+    ], "view">;
+    verifyBlockheaderHash: TypedContractMethod<[
+        height: BigNumberish,
+        commitmentHash: BytesLike
+    ], [
+        bigint
+    ], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "getBlockheight"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "getChainwork"): TypedContractMethod<[], [bigint], "view">;
+    getFunction(nameOrSignature: "getCommitHash"): TypedContractMethod<[height: BigNumberish], [string], "view">;
+    getFunction(nameOrSignature: "getTipCommitHash"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "submitForkBlockheaders"): TypedContractMethod<[
+        forkId: BigNumberish,
+        data: BytesLike
+    ], [
+        void
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "submitMainBlockheaders"): TypedContractMethod<[data: BytesLike], [void], "nonpayable">;
+    getFunction(nameOrSignature: "submitShortForkBlockheaders"): TypedContractMethod<[data: BytesLike], [void], "nonpayable">;
+    getFunction(nameOrSignature: "verifyBlockheader"): TypedContractMethod<[
+        storedHeader: StoredBlockHeaderStruct
+    ], [
+        bigint
+    ], "view">;
+    getFunction(nameOrSignature: "verifyBlockheaderHash"): TypedContractMethod<[
+        height: BigNumberish,
+        commitmentHash: BytesLike
+    ], [
+        bigint
+    ], "view">;
+    getEvent(key: "ChainReorg"): TypedContractEvent<ChainReorgEvent.InputTuple, ChainReorgEvent.OutputTuple, ChainReorgEvent.OutputObject>;
+    getEvent(key: "StoreForkHeader"): TypedContractEvent<StoreForkHeaderEvent.InputTuple, StoreForkHeaderEvent.OutputTuple, StoreForkHeaderEvent.OutputObject>;
+    getEvent(key: "StoreHeader"): TypedContractEvent<StoreHeaderEvent.InputTuple, StoreHeaderEvent.OutputTuple, StoreHeaderEvent.OutputObject>;
+    filters: {
+        "ChainReorg(bytes32,bytes32,uint256,address,uint256)": TypedContractEvent<ChainReorgEvent.InputTuple, ChainReorgEvent.OutputTuple, ChainReorgEvent.OutputObject>;
+        ChainReorg: TypedContractEvent<ChainReorgEvent.InputTuple, ChainReorgEvent.OutputTuple, ChainReorgEvent.OutputObject>;
+        "StoreForkHeader(bytes32,bytes32,uint256)": TypedContractEvent<StoreForkHeaderEvent.InputTuple, StoreForkHeaderEvent.OutputTuple, StoreForkHeaderEvent.OutputObject>;
+        StoreForkHeader: TypedContractEvent<StoreForkHeaderEvent.InputTuple, StoreForkHeaderEvent.OutputTuple, StoreForkHeaderEvent.OutputObject>;
+        "StoreHeader(bytes32,bytes32)": TypedContractEvent<StoreHeaderEvent.InputTuple, StoreHeaderEvent.OutputTuple, StoreHeaderEvent.OutputObject>;
+        StoreHeader: TypedContractEvent<StoreHeaderEvent.InputTuple, StoreHeaderEvent.OutputTuple, StoreHeaderEvent.OutputObject>;
+    };
+}

package/dist/evm/btcrelay/BtcRelayTypechain.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/evm/btcrelay/EVMBtcRelay.d.ts

@@ -0,0 +1,188 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { BitcoinNetwork, BitcoinRpc, BtcBlock, BtcRelay, RelaySynchronizer } from "@atomiqlabs/base";
+import { EVMBtcHeader } from "./headers/EVMBtcHeader";
+import { EVMContractBase } from "../contract/EVMContractBase";
+import { BtcRelay as BtcRelayTypechain } from "./BtcRelayTypechain";
+import { EVMBtcStoredHeader } from "./headers/EVMBtcStoredHeader";
+import { EVMSigner } from "../wallet/EVMSigner";
+import { EVMTx } from "../chain/modules/EVMTransactions";
+import { EVMChainInterface } from "../chain/EVMChainInterface";
+export declare class EVMBtcRelay<B extends BtcBlock> extends EVMContractBase<BtcRelayTypechain> implements BtcRelay<EVMBtcStoredHeader, EVMTx, B, EVMSigner> {
+    SaveMainHeaders(signer: string, mainHeaders: EVMBtcHeader[], storedHeader: EVMBtcStoredHeader, feeRate: string): Promise<EVMTx>;
+    SaveShortForkHeaders(signer: string, forkHeaders: EVMBtcHeader[], storedHeader: EVMBtcStoredHeader, feeRate: string): Promise<EVMTx>;
+    SaveLongForkHeaders(signer: string, forkId: number, forkHeaders: EVMBtcHeader[], storedHeader: EVMBtcStoredHeader, feeRate: string, totalForkHeaders?: number): Promise<EVMTx>;
+    bitcoinRpc: BitcoinRpc<B>;
+    readonly maxHeadersPerTx: number;
+    readonly maxForkHeadersPerTx: number;
+    readonly maxShortForkHeadersPerTx: number;
+    constructor(chainInterface: EVMChainInterface<any>, bitcoinRpc: BitcoinRpc<B>, bitcoinNetwork: BitcoinNetwork, contractAddress: string, contractDeploymentHeight?: number);
+    /**
+     * Computes subsequent commited headers as they will appear on the blockchain when transactions
+     *  are submitted & confirmed
+     *
+     * @param initialStoredHeader
+     * @param syncedHeaders
+     * @private
+     */
+    private computeCommitedHeaders;
+    /**
+     * A common logic for submitting blockheaders in a transaction
+     *
+     * @param signer
+     * @param headers headers to sync to the btc relay
+     * @param storedHeader current latest stored block header for a given fork
+     * @param tipWork work of the current tip in a given fork
+     * @param forkId forkId to submit to, forkId=0 means main chain, forkId=-1 means short fork
+     * @param feeRate feeRate for the transaction
+     * @param totalForkHeaders Total number of headers in a fork
+     * @private
+     */
+    private _saveHeaders;
+    private findStoredBlockheaderInTraces;
+    private getBlock;
+    private getBlockHeight;
+    /**
+     * Returns data about current main chain tip stored in the btc relay
+     */
+    getTipData(): Promise<{
+        commitHash: string;
+        blockhash: string;
+        chainWork: Buffer;
+        blockheight: number;
+    }>;
+    /**
+     * Retrieves blockheader with a specific blockhash, returns null if requiredBlockheight is provided and
+     *  btc relay contract is not synced up to the desired blockheight
+     *
+     * @param blockData
+     * @param requiredBlockheight
+     */
+    retrieveLogAndBlockheight(blockData: {
+        blockhash: string;
+    }, requiredBlockheight?: number): Promise<{
+        header: EVMBtcStoredHeader;
+        height: number;
+    } | null>;
+    /**
+     * Retrieves blockheader data by blockheader's commit hash,
+     *
+     * @param commitmentHashStr
+     * @param blockData
+     */
+    retrieveLogByCommitHash(commitmentHashStr: string, blockData: {
+        blockhash: string;
+    }): Promise<EVMBtcStoredHeader>;
+    /**
+     * Retrieves latest known stored blockheader & blockheader from bitcoin RPC that is in the main chain
+     */
+    retrieveLatestKnownBlockLog(): Promise<{
+        resultStoredHeader: EVMBtcStoredHeader;
+        resultBitcoinHeader: B;
+    }>;
+    /**
+     * Saves blockheaders as a bitcoin main chain to the btc relay
+     *
+     * @param signer
+     * @param mainHeaders
+     * @param storedHeader
+     * @param feeRate
+     */
+    saveMainHeaders(signer: string, mainHeaders: BtcBlock[], storedHeader: EVMBtcStoredHeader, feeRate?: string): Promise<{
+        forkId: number;
+        lastStoredHeader: EVMBtcStoredHeader;
+        tx: import("ethers").TransactionRequest;
+        computedCommitedHeaders: EVMBtcStoredHeader[];
+    }>;
+    /**
+     * Creates a new long fork and submits the headers to it
+     *
+     * @param signer
+     * @param forkHeaders
+     * @param storedHeader
+     * @param tipWork
+     * @param feeRate
+     */
+    saveNewForkHeaders(signer: string, forkHeaders: BtcBlock[], storedHeader: EVMBtcStoredHeader, tipWork: Buffer, feeRate?: string): Promise<{
+        forkId: number;
+        lastStoredHeader: EVMBtcStoredHeader;
+        tx: import("ethers").TransactionRequest;
+        computedCommitedHeaders: EVMBtcStoredHeader[];
+    }>;
+    /**
+     * Continues submitting blockheaders to a given fork
+     *
+     * @param signer
+     * @param forkHeaders
+     * @param storedHeader
+     * @param forkId
+     * @param tipWork
+     * @param feeRate
+     */
+    saveForkHeaders(signer: string, forkHeaders: BtcBlock[], storedHeader: EVMBtcStoredHeader, forkId: number, tipWork: Buffer, feeRate?: string): Promise<{
+        forkId: number;
+        lastStoredHeader: EVMBtcStoredHeader;
+        tx: import("ethers").TransactionRequest;
+        computedCommitedHeaders: EVMBtcStoredHeader[];
+    }>;
+    /**
+     * Submits short fork with given blockheaders
+     *
+     * @param signer
+     * @param forkHeaders
+     * @param storedHeader
+     * @param tipWork
+     * @param feeRate
+     */
+    saveShortForkHeaders(signer: string, forkHeaders: BtcBlock[], storedHeader: EVMBtcStoredHeader, tipWork: Buffer, feeRate?: string): Promise<{
+        forkId: number;
+        lastStoredHeader: EVMBtcStoredHeader;
+        tx: import("ethers").TransactionRequest;
+        computedCommitedHeaders: EVMBtcStoredHeader[];
+    }>;
+    /**
+     * Estimate required synchronization fee (worst case) to synchronize btc relay to the required blockheight
+     *
+     * @param requiredBlockheight
+     * @param feeRate
+     */
+    estimateSynchronizeFee(requiredBlockheight: number, feeRate?: string): Promise<bigint>;
+    /**
+     * Returns fee required (in SOL) to synchronize a single block to btc relay
+     *
+     * @param feeRate
+     */
+    getFeePerBlock(feeRate?: string): Promise<bigint>;
+    /**
+     * Gets fee rate required for submitting blockheaders to the main chain
+     */
+    getMainFeeRate(signer: string | null): Promise<string>;
+    /**
+     * Gets fee rate required for submitting blockheaders to the specific fork
+     */
+    getForkFeeRate(signer: string, forkId: number): Promise<string>;
+    saveInitialHeader(signer: string, header: B, epochStart: number, pastBlocksTimestamps: number[], feeRate?: string): Promise<EVMTx>;
+    /**
+     * Gets committed header, identified by blockhash & blockheight, determines required BTC relay blockheight based on
+     *  requiredConfirmations
+     * If synchronizer is passed & blockhash is not found, it produces transactions to sync up the btc relay to the
+     *  current chain tip & adds them to the txs array
+     *
+     * @param signer
+     * @param btcRelay
+     * @param btcTxs
+     * @param txs solana transaction array, in case we need to synchronize the btc relay ourselves the synchronization
+     *  txns are added here
+     * @param synchronizer optional synchronizer to use to synchronize the btc relay in case it is not yet synchronized
+     *  to the required blockheight
+     * @param feeRate Fee rate to use for synchronization transactions
+     * @private
+     */
+    static getCommitedHeadersAndSynchronize(signer: string, btcRelay: EVMBtcRelay<any>, btcTxs: {
+        blockheight: number;
+        requiredConfirmations: number;
+        blockhash: string;
+    }[], txs: EVMTx[], synchronizer?: RelaySynchronizer<EVMBtcStoredHeader, EVMTx, any>, feeRate?: string): Promise<{
+        [blockhash: string]: EVMBtcStoredHeader;
+    }>;
+}