@atomiqlabs/chain-starknet 1.0.0-beta.0

package/dist/starknet/btcrelay/BtcRelayAbi.js

@@ -0,0 +1,341 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BtcRelayAbi = void 0;
+exports.BtcRelayAbi = [
+    {
+        "type": "impl",
+        "name": "BtcRelayImpl",
+        "interface_name": "btc_relay::IBtcRelay"
+    },
+    {
+        "type": "struct",
+        "name": "btc_relay::structs::blockheader::BlockHeader",
+        "members": [
+            {
+                "name": "reversed_version",
+                "type": "core::integer::u32"
+            },
+            {
+                "name": "previous_blockhash",
+                "type": "[core::integer::u32; 8]"
+            },
+            {
+                "name": "merkle_root",
+                "type": "[core::integer::u32; 8]"
+            },
+            {
+                "name": "reversed_timestamp",
+                "type": "core::integer::u32"
+            },
+            {
+                "name": "nbits",
+                "type": "core::integer::u32"
+            },
+            {
+                "name": "nonce",
+                "type": "core::integer::u32"
+            }
+        ]
+    },
+    {
+        "type": "struct",
+        "name": "core::array::Span::<btc_relay::structs::blockheader::BlockHeader>",
+        "members": [
+            {
+                "name": "snapshot",
+                "type": "@core::array::Array::<btc_relay::structs::blockheader::BlockHeader>"
+            }
+        ]
+    },
+    {
+        "type": "struct",
+        "name": "core::integer::u256",
+        "members": [
+            {
+                "name": "low",
+                "type": "core::integer::u128"
+            },
+            {
+                "name": "high",
+                "type": "core::integer::u128"
+            }
+        ]
+    },
+    {
+        "type": "struct",
+        "name": "btc_relay::structs::stored_blockheader::StoredBlockHeader",
+        "members": [
+            {
+                "name": "blockheader",
+                "type": "btc_relay::structs::blockheader::BlockHeader"
+            },
+            {
+                "name": "block_hash",
+                "type": "[core::integer::u32; 8]"
+            },
+            {
+                "name": "chain_work",
+                "type": "core::integer::u256"
+            },
+            {
+                "name": "block_height",
+                "type": "core::integer::u32"
+            },
+            {
+                "name": "last_diff_adjustment",
+                "type": "core::integer::u32"
+            },
+            {
+                "name": "prev_block_timestamps",
+                "type": "[core::integer::u32; 10]"
+            }
+        ]
+    },
+    {
+        "type": "interface",
+        "name": "btc_relay::IBtcRelay",
+        "items": [
+            {
+                "type": "function",
+                "name": "submit_main_blockheaders",
+                "inputs": [
+                    {
+                        "name": "block_headers",
+                        "type": "core::array::Span::<btc_relay::structs::blockheader::BlockHeader>"
+                    },
+                    {
+                        "name": "stored_header",
+                        "type": "btc_relay::structs::stored_blockheader::StoredBlockHeader"
+                    }
+                ],
+                "outputs": [],
+                "state_mutability": "external"
+            },
+            {
+                "type": "function",
+                "name": "submit_short_fork_blockheaders",
+                "inputs": [
+                    {
+                        "name": "block_headers",
+                        "type": "core::array::Span::<btc_relay::structs::blockheader::BlockHeader>"
+                    },
+                    {
+                        "name": "stored_header",
+                        "type": "btc_relay::structs::stored_blockheader::StoredBlockHeader"
+                    }
+                ],
+                "outputs": [],
+                "state_mutability": "external"
+            },
+            {
+                "type": "function",
+                "name": "submit_fork_blockheaders",
+                "inputs": [
+                    {
+                        "name": "fork_id",
+                        "type": "core::felt252"
+                    },
+                    {
+                        "name": "block_headers",
+                        "type": "core::array::Span::<btc_relay::structs::blockheader::BlockHeader>"
+                    },
+                    {
+                        "name": "stored_header",
+                        "type": "btc_relay::structs::stored_blockheader::StoredBlockHeader"
+                    }
+                ],
+                "outputs": [],
+                "state_mutability": "external"
+            }
+        ]
+    },
+    {
+        "type": "impl",
+        "name": "BtcRelayReadOnlyImpl",
+        "interface_name": "btc_relay::IBtcRelayReadOnly"
+    },
+    {
+        "type": "interface",
+        "name": "btc_relay::IBtcRelayReadOnly",
+        "items": [
+            {
+                "type": "function",
+                "name": "get_chainwork",
+                "inputs": [],
+                "outputs": [
+                    {
+                        "type": "core::integer::u256"
+                    }
+                ],
+                "state_mutability": "view"
+            },
+            {
+                "type": "function",
+                "name": "get_blockheight",
+                "inputs": [],
+                "outputs": [
+                    {
+                        "type": "core::integer::u32"
+                    }
+                ],
+                "state_mutability": "view"
+            },
+            {
+                "type": "function",
+                "name": "verify_blockheader",
+                "inputs": [
+                    {
+                        "name": "stored_header",
+                        "type": "btc_relay::structs::stored_blockheader::StoredBlockHeader"
+                    }
+                ],
+                "outputs": [
+                    {
+                        "type": "core::integer::u32"
+                    }
+                ],
+                "state_mutability": "view"
+            },
+            {
+                "type": "function",
+                "name": "get_commit_hash",
+                "inputs": [
+                    {
+                        "name": "height",
+                        "type": "core::integer::u32"
+                    }
+                ],
+                "outputs": [
+                    {
+                        "type": "core::felt252"
+                    }
+                ],
+                "state_mutability": "view"
+            },
+            {
+                "type": "function",
+                "name": "get_tip_commit_hash",
+                "inputs": [],
+                "outputs": [
+                    {
+                        "type": "core::felt252"
+                    }
+                ],
+                "state_mutability": "view"
+            }
+        ]
+    },
+    {
+        "type": "constructor",
+        "name": "constructor",
+        "inputs": [
+            {
+                "name": "stored_header",
+                "type": "btc_relay::structs::stored_blockheader::StoredBlockHeader"
+            }
+        ]
+    },
+    {
+        "type": "event",
+        "name": "btc_relay::events::StoreHeader",
+        "kind": "struct",
+        "members": [
+            {
+                "name": "commit_hash",
+                "type": "core::felt252",
+                "kind": "key"
+            },
+            {
+                "name": "block_hash_poseidon",
+                "type": "core::felt252",
+                "kind": "key"
+            },
+            {
+                "name": "header",
+                "type": "btc_relay::structs::stored_blockheader::StoredBlockHeader",
+                "kind": "data"
+            }
+        ]
+    },
+    {
+        "type": "event",
+        "name": "btc_relay::events::StoreForkHeader",
+        "kind": "struct",
+        "members": [
+            {
+                "name": "commit_hash",
+                "type": "core::felt252",
+                "kind": "key"
+            },
+            {
+                "name": "block_hash_poseidon",
+                "type": "core::felt252",
+                "kind": "key"
+            },
+            {
+                "name": "fork_id",
+                "type": "core::felt252",
+                "kind": "key"
+            },
+            {
+                "name": "header",
+                "type": "btc_relay::structs::stored_blockheader::StoredBlockHeader",
+                "kind": "data"
+            }
+        ]
+    },
+    {
+        "type": "event",
+        "name": "btc_relay::events::ChainReorg",
+        "kind": "struct",
+        "members": [
+            {
+                "name": "fork_submitter",
+                "type": "core::starknet::contract_address::ContractAddress",
+                "kind": "key"
+            },
+            {
+                "name": "fork_id",
+                "type": "core::felt252",
+                "kind": "key"
+            },
+            {
+                "name": "tip_block_hash_poseidon",
+                "type": "core::felt252",
+                "kind": "key"
+            },
+            {
+                "name": "tip_commit_hash",
+                "type": "core::felt252",
+                "kind": "key"
+            },
+            {
+                "name": "start_height",
+                "type": "core::felt252",
+                "kind": "data"
+            }
+        ]
+    },
+    {
+        "type": "event",
+        "name": "btc_relay::BtcRelay::Event",
+        "kind": "enum",
+        "variants": [
+            {
+                "name": "StoreHeader",
+                "type": "btc_relay::events::StoreHeader",
+                "kind": "nested"
+            },
+            {
+                "name": "StoreForkHeader",
+                "type": "btc_relay::events::StoreForkHeader",
+                "kind": "nested"
+            },
+            {
+                "name": "ChainReorg",
+                "type": "btc_relay::events::ChainReorg",
+                "kind": "nested"
+            }
+        ]
+    }
+];

package/dist/starknet/btcrelay/StarknetBtcRelay.d.ts

@@ -0,0 +1,166 @@
+/// <reference types="node" />
+import { Buffer } from "buffer";
+import { StarknetBtcHeader } from "./headers/StarknetBtcHeader";
+import { BitcoinRpc, BtcBlock, BtcRelay } from "@atomiqlabs/base";
+import { StarknetContractBase } from "../contract/StarknetContractBase";
+import { StarknetBtcStoredHeader } from "./headers/StarknetBtcStoredHeader";
+import { StarknetTx } from "../base/modules/StarknetTransactions";
+import { StarknetSigner } from "../wallet/StarknetSigner";
+import { BtcRelayAbi } from "./BtcRelayAbi";
+import { constants, Provider } from "starknet";
+import { StarknetFees } from "../base/modules/StarknetFees";
+import { StarknetRetryPolicy } from "../base/StarknetBase";
+import { StarknetAction } from "../base/StarknetAction";
+export declare class StarknetBtcRelay<B extends BtcBlock> extends StarknetContractBase<typeof BtcRelayAbi> implements BtcRelay<StarknetBtcStoredHeader, StarknetTx, B, StarknetSigner> {
+    SaveMainHeaders(signer: string, mainHeaders: StarknetBtcHeader[], storedHeader: StarknetBtcStoredHeader): StarknetAction;
+    SaveShortForkHeaders(signer: string, forkHeaders: StarknetBtcHeader[], storedHeader: StarknetBtcStoredHeader): StarknetAction;
+    SaveLongForkHeaders(signer: string, forkId: number, forkHeaders: StarknetBtcHeader[], storedHeader: StarknetBtcStoredHeader, totalForkHeaders?: number): StarknetAction;
+    bitcoinRpc: BitcoinRpc<B>;
+    readonly maxHeadersPerTx: number;
+    readonly maxForkHeadersPerTx: number;
+    readonly maxShortForkHeadersPerTx: number;
+    constructor(chainId: constants.StarknetChainId, provider: Provider, bitcoinRpc: BitcoinRpc<B>, contractAddress?: string, retryPolicy?: StarknetRetryPolicy, solanaFeeEstimator?: StarknetFees);
+    /**
+     * 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
+     * @private
+     */
+    private _saveHeaders;
+    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: StarknetBtcStoredHeader;
+        height: number;
+    } | null>;
+    /**
+     * Retrieves blockheader data by blockheader's commit hash,
+     *
+     * @param commitmentHashStr
+     * @param blockData
+     */
+    retrieveLogByCommitHash(commitmentHashStr: string, blockData: {
+        blockhash: string;
+    }): Promise<StarknetBtcStoredHeader>;
+    /**
+     * Retrieves latest known stored blockheader & blockheader from bitcoin RPC that is in the main chain
+     */
+    retrieveLatestKnownBlockLog(): Promise<{
+        resultStoredHeader: StarknetBtcStoredHeader;
+        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: StarknetBtcStoredHeader, feeRate?: string): Promise<{
+        forkId: number;
+        lastStoredHeader: StarknetBtcStoredHeader;
+        tx: StarknetTx;
+        computedCommitedHeaders: StarknetBtcStoredHeader[];
+    }>;
+    /**
+     * 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: StarknetBtcStoredHeader, tipWork: Buffer, feeRate?: string): Promise<{
+        forkId: number;
+        lastStoredHeader: StarknetBtcStoredHeader;
+        tx: StarknetTx;
+        computedCommitedHeaders: StarknetBtcStoredHeader[];
+    }>;
+    /**
+     * 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: StarknetBtcStoredHeader, forkId: number, tipWork: Buffer, feeRate?: string): Promise<{
+        forkId: number;
+        lastStoredHeader: StarknetBtcStoredHeader;
+        tx: StarknetTx;
+        computedCommitedHeaders: StarknetBtcStoredHeader[];
+    }>;
+    /**
+     * Submits short fork with given blockheaders
+     *
+     * @param signer
+     * @param forkHeaders
+     * @param storedHeader
+     * @param tipWork
+     * @param feeRate
+     */
+    saveShortForkHeaders(signer: string, forkHeaders: BtcBlock[], storedHeader: StarknetBtcStoredHeader, tipWork: Buffer, feeRate?: string): Promise<{
+        forkId: number;
+        lastStoredHeader: StarknetBtcStoredHeader;
+        tx: StarknetTx;
+        computedCommitedHeaders: StarknetBtcStoredHeader[];
+    }>;
+    /**
+     * 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<StarknetTx>;
+}