@atomiqlabs/chain-starknet 1.0.0-beta.0

package/dist/starknet/base/modules/StarknetTokens.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetTokens = void 0;
+const StarknetModule_1 = require("../StarknetModule");
+const StarknetAction_1 = require("../StarknetAction");
+const ERC20Abi_1 = require("./ERC20Abi");
+const starknet_1 = require("starknet");
+const Utils_1 = require("../../../utils/Utils");
+class StarknetTokens extends StarknetModule_1.StarknetModule {
+    getContract(address) {
+        return new starknet_1.Contract(ERC20Abi_1.ERC20Abi, address, this.root.provider).typedv2(ERC20Abi_1.ERC20Abi);
+    }
+    /**
+     * Action for transferring the erc20 token
+     *
+     * @param signer
+     * @param recipient
+     * @param token
+     * @param amount
+     * @constructor
+     * @private
+     */
+    Transfer(signer, recipient, token, amount) {
+        const erc20 = this.getContract(token);
+        return new StarknetAction_1.StarknetAction(signer, this.root, erc20.populateTransaction.transfer(recipient, amount), StarknetTokens.GasCosts.TRANSFER);
+    }
+    /**
+     * Approves spend of tokens for a specific spender
+     *
+     * @param signer
+     * @param spender
+     * @param token
+     * @param amount
+     * @constructor
+     * @private
+     */
+    Approve(signer, spender, token, amount) {
+        const erc20 = this.getContract(token);
+        return new StarknetAction_1.StarknetAction(signer, this.root, erc20.populateTransaction.approve(spender, amount), StarknetTokens.GasCosts.APPROVE);
+    }
+    ///////////////////
+    //// Tokens
+    /**
+     * Checks if the provided string is a valid starknet token
+     *
+     * @param token
+     */
+    isValidToken(token) {
+        return this.root.Addresses.isValidAddress(token);
+    }
+    /**
+     * Returns the token balance of the address
+     *
+     * @param address
+     * @param token
+     */
+    async getTokenBalance(address, token) {
+        const erc20 = this.getContract(token);
+        const balance = await erc20.balance_of(address);
+        const balanceBN = (0, Utils_1.toBigInt)(balance);
+        this.logger.debug("getTokenBalance(): token balance fetched, token: " + token +
+            " address: " + address + " amount: " + balanceBN.toString());
+        return balanceBN;
+    }
+    /**
+     * Returns the native currency address, return the default used by the fee module
+     */
+    getNativeCurrencyAddress() {
+        return this.root.Fees.getDefaultGasToken();
+    }
+    ///////////////////
+    //// Transfers
+    /**
+     * Creates transactions for sending the over the tokens
+     *
+     * @param signer
+     * @param token token to send
+     * @param amount amount of the token to send
+     * @param recipient recipient's address
+     * @param feeRate fee rate to use for the transactions
+     * @private
+     */
+    async txsTransfer(signer, token, amount, recipient, feeRate) {
+        const action = this.Transfer(signer, recipient, token, amount);
+        feeRate = feeRate ?? await this.root.Fees.getFeeRate();
+        this.logger.debug("txsTransfer(): transfer TX created, recipient: " + recipient.toString() +
+            " token: " + token.toString() + " amount: " + amount.toString(10));
+        return [await action.tx(feeRate)];
+    }
+}
+exports.StarknetTokens = StarknetTokens;
+StarknetTokens.ERC20_ETH = "0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7";
+StarknetTokens.ERC20_STRK = "0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d";
+StarknetTokens.GasCosts = {
+    TRANSFER: { l1: 400, l2: 0 },
+    APPROVE: { l1: 400, l2: 0 }
+};

package/dist/starknet/base/modules/StarknetTransactions.d.ts

@@ -0,0 +1,87 @@
+import { StarknetModule } from "../StarknetModule";
+import { Call, DeployAccountContractPayload, DeployAccountContractTransaction, Invocation, InvocationsSignerDetails, BigNumberish } from "starknet";
+import { StarknetSigner } from "../../wallet/StarknetSigner";
+export type StarknetTx = ({
+    type: "DEPLOY_ACCOUNT";
+    tx: DeployAccountContractPayload;
+    signed?: DeployAccountContractTransaction;
+} | {
+    type: "INVOKE";
+    tx: Array<Call>;
+    signed?: Invocation;
+}) & {
+    details: InvocationsSignerDetails & {
+        maxFee?: BigNumberish;
+    };
+    txId?: string;
+};
+export declare class StarknetTransactions extends StarknetModule {
+    private cbkBeforeTxSigned;
+    /**
+     * Waits for transaction confirmation using WS subscription and occasional HTTP polling, also re-sends
+     *  the transaction at regular interval
+     *
+     * @param tx starknet transaction to wait for confirmation for & keep re-sending until it confirms
+     * @param abortSignal signal to abort waiting for tx confirmation
+     * @private
+     */
+    private confirmTransaction;
+    /**
+     * Prepares starknet transactions, checks if the account is deployed, assigns nonces if needed & calls beforeTxSigned callback
+     *
+     * @param signer
+     * @param txs
+     * @private
+     */
+    private prepareTransactions;
+    /**
+     * Sends out a signed transaction to the RPC
+     *
+     * @param tx Starknet tx to send
+     * @param onBeforePublish a callback called before every transaction is published
+     * @param signer
+     * @param retryOnSubmissionFailure
+     * @private
+     */
+    private sendSignedTransaction;
+    /**
+     * Prepares, signs , sends (in parallel or sequentially) & optionally waits for confirmation
+     *  of a batch of starknet transactions
+     *
+     * @param signer
+     * @param txs transactions to send
+     * @param waitForConfirmation whether to wait for transaction confirmations (this also makes sure the transactions
+     *  are re-sent at regular intervals)
+     * @param abortSignal abort signal to abort waiting for transaction confirmations
+     * @param parallel whether the send all the transaction at once in parallel or sequentially (such that transactions
+     *  are executed in order)
+     * @param onBeforePublish a callback called before every transaction is published
+     */
+    sendAndConfirm(signer: StarknetSigner, txs: StarknetTx[], waitForConfirmation?: boolean, abortSignal?: AbortSignal, parallel?: boolean, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<string[]>;
+    /**
+     * Serializes the solana transaction, saves the transaction, signers & last valid blockheight
+     *
+     * @param tx
+     */
+    serializeTx(tx: StarknetTx): Promise<string>;
+    /**
+     * Deserializes saved solana transaction, extracting the transaction, signers & last valid blockheight
+     *
+     * @param txData
+     */
+    deserializeTx(txData: string): Promise<StarknetTx>;
+    /**
+     * Gets the status of the raw starknet transaction
+     *
+     * @param tx
+     */
+    getTxStatus(tx: string): Promise<"pending" | "success" | "not_found" | "reverted">;
+    /**
+     * Gets the status of the starknet transaction with a specific txId
+     *
+     * @param txId
+     */
+    getTxIdStatus(txId: string): Promise<"pending" | "success" | "not_found" | "reverted">;
+    onBeforeTxSigned(callback: (tx: StarknetTx) => Promise<void>): void;
+    offBeforeTxSigned(callback: (tx: StarknetTx) => Promise<void>): boolean;
+}

package/dist/starknet/base/modules/StarknetTransactions.js

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetTransactions = void 0;
+const StarknetModule_1 = require("../StarknetModule");
+const Utils_1 = require("../../../utils/Utils");
+class StarknetTransactions extends StarknetModule_1.StarknetModule {
+    /**
+     * Waits for transaction confirmation using WS subscription and occasional HTTP polling, also re-sends
+     *  the transaction at regular interval
+     *
+     * @param tx starknet transaction to wait for confirmation for & keep re-sending until it confirms
+     * @param abortSignal signal to abort waiting for tx confirmation
+     * @private
+     */
+    async confirmTransaction(tx, abortSignal) {
+        let state = "pending";
+        while (state === "pending" || state === "not_found") {
+            await (0, Utils_1.timeoutPromise)(3, abortSignal);
+            state = await this.getTxIdStatus(tx.txId);
+            if (state === "not_found" && tx.signed != null)
+                await this.sendSignedTransaction(tx, undefined, undefined, false).catch(e => {
+                    if (e.message != null && e.message.includes("59: A transaction with the same hash already exists in the mempool"))
+                        return;
+                    console.error("Error on transaction re-send: ", e);
+                });
+        }
+        if (state === "reverted")
+            throw new Error("Transaction reverted!");
+    }
+    /**
+     * Prepares starknet transactions, checks if the account is deployed, assigns nonces if needed & calls beforeTxSigned callback
+     *
+     * @param signer
+     * @param txs
+     * @private
+     */
+    async prepareTransactions(signer, txs) {
+        let nonce = await signer.getNonce();
+        if (nonce === BigInt(0) && signer.isWalletAccount()) {
+            //Just increment the nonce by one and hope the wallet is smart enough to deploy account first
+            nonce = BigInt(1);
+        }
+        const deployPayload = await signer.checkAndGetDeployPayload(nonce);
+        if (deployPayload != null) {
+            txs.unshift(await this.root.Accounts.getAccountDeployTransaction(deployPayload));
+        }
+        for (let i = 0; i < txs.length; i++) {
+            const tx = txs[i];
+            if (tx.details.nonce != null)
+                nonce = BigInt(tx.details.nonce); //Take the nonce from last tx
+            if (nonce == null)
+                nonce = BigInt(await this.root.provider.getNonceForAddress(signer.getAddress())); //Fetch the nonce
+            if (tx.details.nonce == null)
+                tx.details.nonce = nonce;
+            this.logger.debug("sendAndConfirm(): transaction prepared (" + (i + 1) + "/" + txs.length + "), nonce: " + tx.details.nonce);
+            nonce += BigInt(1);
+            if (this.cbkBeforeTxSigned != null)
+                await this.cbkBeforeTxSigned(tx);
+        }
+    }
+    /**
+     * Sends out a signed transaction to the RPC
+     *
+     * @param tx Starknet tx to send
+     * @param onBeforePublish a callback called before every transaction is published
+     * @param signer
+     * @param retryOnSubmissionFailure
+     * @private
+     */
+    async sendSignedTransaction(tx, onBeforePublish, signer, retryOnSubmissionFailure = true) {
+        if (onBeforePublish != null)
+            await onBeforePublish(tx.txId, await this.serializeTx(tx));
+        this.logger.debug("sendSignedTransaction(): sending transaction: ", tx);
+        if (tx.signed == null) {
+            let txHash;
+            switch (tx.type) {
+                case "INVOKE":
+                    txHash = (await signer.account.execute(tx.tx, tx.details)).transaction_hash;
+                    break;
+                case "DEPLOY_ACCOUNT":
+                    txHash = (await signer.account.deployAccount(tx.tx, tx.details)).transaction_hash;
+                    break;
+                default:
+                    throw new Error("Unsupported tx type!");
+            }
+            tx.txId = txHash;
+            return txHash;
+        }
+        const txResult = await (0, Utils_1.tryWithRetries)(() => {
+            switch (tx.type) {
+                case "INVOKE":
+                    return this.provider.channel.invoke(tx.signed, tx.details).then(res => res.transaction_hash);
+                case "DEPLOY_ACCOUNT":
+                    return this.provider.channel.deployAccount(tx.signed, tx.details).then((res) => res.transaction_hash);
+                default:
+                    throw new Error("Unsupported tx type!");
+            }
+        }, retryOnSubmissionFailure ? this.retryPolicy : { maxRetries: 1 });
+        if (tx.txId !== txResult)
+            this.logger.warn("sendSignedTransaction(): sent tx hash not matching the precomputed hash!");
+        this.logger.info("sendSignedTransaction(): tx sent, expected txHash: " + tx.txId + ", txHash: " + txResult);
+        return txResult;
+    }
+    /**
+     * Prepares, signs , sends (in parallel or sequentially) & optionally waits for confirmation
+     *  of a batch of starknet transactions
+     *
+     * @param signer
+     * @param txs transactions to send
+     * @param waitForConfirmation whether to wait for transaction confirmations (this also makes sure the transactions
+     *  are re-sent at regular intervals)
+     * @param abortSignal abort signal to abort waiting for transaction confirmations
+     * @param parallel whether the send all the transaction at once in parallel or sequentially (such that transactions
+     *  are executed in order)
+     * @param onBeforePublish a callback called before every transaction is published
+     */
+    async sendAndConfirm(signer, txs, waitForConfirmation, abortSignal, parallel, onBeforePublish) {
+        await this.prepareTransactions(signer, txs);
+        if (!signer.isWalletAccount()) {
+            for (let i = 0; i < txs.length; i++) {
+                const tx = txs[i];
+                switch (tx.type) {
+                    case "INVOKE":
+                        tx.signed = await signer.account.buildInvocation(tx.tx, tx.details);
+                        (0, Utils_1.calculateHash)(tx);
+                        break;
+                    case "DEPLOY_ACCOUNT":
+                        tx.signed = await signer.account.buildAccountDeployPayload(tx.tx, tx.details);
+                        (0, Utils_1.calculateHash)(tx);
+                        break;
+                    default:
+                        throw new Error("Unsupported tx type!");
+                }
+                this.logger.debug("sendAndConfirm(): transaction signed (" + (i + 1) + "/" + txs.length + "): " + tx.txId);
+            }
+        }
+        this.logger.debug("sendAndConfirm(): sending transactions, count: " + txs.length +
+            " waitForConfirmation: " + waitForConfirmation + " parallel: " + parallel);
+        const txIds = [];
+        if (parallel) {
+            const promises = [];
+            for (let i = 0; i < txs.length; i++) {
+                const signedTx = txs[i];
+                const txId = await this.sendSignedTransaction(signedTx, onBeforePublish, signer);
+                if (waitForConfirmation)
+                    promises.push(this.confirmTransaction(signedTx, abortSignal));
+                txIds.push(txId);
+                this.logger.debug("sendAndConfirm(): transaction sent (" + (i + 1) + "/" + txs.length + "): " + signedTx.txId);
+            }
+            if (promises.length > 0)
+                await Promise.all(promises);
+        }
+        else {
+            for (let i = 0; i < txs.length; i++) {
+                const signedTx = txs[i];
+                const txId = await this.sendSignedTransaction(signedTx, onBeforePublish, signer);
+                const confirmPromise = this.confirmTransaction(signedTx, abortSignal);
+                this.logger.debug("sendAndConfirm(): transaction sent (" + (i + 1) + "/" + txs.length + "): " + signedTx.txId);
+                //Don't await the last promise when !waitForConfirmation
+                if (i < txs.length - 1 || waitForConfirmation)
+                    await confirmPromise;
+                txIds.push(txId);
+            }
+        }
+        this.logger.info("sendAndConfirm(): sent transactions, count: " + txs.length +
+            " waitForConfirmation: " + waitForConfirmation + " parallel: " + parallel);
+        return txIds;
+    }
+    /**
+     * Serializes the solana transaction, saves the transaction, signers & last valid blockheight
+     *
+     * @param tx
+     */
+    serializeTx(tx) {
+        return Promise.resolve(JSON.stringify(tx, (key, value) => {
+            if (typeof (value) === "bigint")
+                return (0, Utils_1.toHex)(value);
+            return value;
+        }));
+    }
+    /**
+     * Deserializes saved solana transaction, extracting the transaction, signers & last valid blockheight
+     *
+     * @param txData
+     */
+    deserializeTx(txData) {
+        return Promise.resolve(JSON.parse(txData));
+    }
+    /**
+     * Gets the status of the raw starknet transaction
+     *
+     * @param tx
+     */
+    async getTxStatus(tx) {
+        const parsedTx = await this.deserializeTx(tx);
+        return await this.getTxIdStatus(parsedTx.txId);
+    }
+    /**
+     * Gets the status of the starknet transaction with a specific txId
+     *
+     * @param txId
+     */
+    async getTxIdStatus(txId) {
+        const status = await this.provider.getTransactionStatus(txId).catch(e => {
+            if (e.message != null && e.message.includes("29: Transaction hash not found"))
+                return null;
+            throw e;
+        });
+        if (status == null)
+            return "not_found";
+        if (status.finality_status === "RECEIVED")
+            return "pending";
+        if (status.finality_status !== "REJECTED" && status.execution_status === "SUCCEEDED") {
+            return "success";
+        }
+        return "reverted";
+    }
+    onBeforeTxSigned(callback) {
+        this.cbkBeforeTxSigned = callback;
+    }
+    offBeforeTxSigned(callback) {
+        this.cbkBeforeTxSigned = null;
+        return true;
+    }
+}
+exports.StarknetTransactions = StarknetTransactions;

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

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