@gitmyabi/optimismportal 1.0.0

package/contracts/OptimismPortal2_json.d.ts

@@ -0,0 +1,1189 @@
+import type { Address, PublicClient, WalletClient } from 'viem';
+/**
+ * Types.WithdrawalTransaction struct type
+ */
+export type Types_WithdrawalTransaction = {
+    nonce: bigint;
+    sender: `0x${string}`;
+    target: `0x${string}`;
+    value: bigint;
+    gasLimit: bigint;
+    data: `0x${string}`;
+};
+/**
+ * Types.OutputRootProof struct type
+ */
+export type Types_OutputRootProof = {
+    version: `0x${string}`;
+    stateRoot: `0x${string}`;
+    messagePasserStorageRoot: `0x${string}`;
+    latestBlockhash: `0x${string}`;
+};
+/**
+ * OptimismPortal2_json ABI
+ *
+ * This ABI is typed using viem's type system for full type safety.
+ */
+export declare const OptimismPortal2_jsonAbi: readonly [{
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "_proofMaturityDelaySeconds";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "constructor";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "ContentLengthMismatch";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "EmptyItem";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "InvalidDataRemainder";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "InvalidHeader";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "OptimismPortal_AlreadyFinalized";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "OptimismPortal_BadTarget";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "OptimismPortal_CallPaused";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "OptimismPortal_CalldataTooLarge";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "OptimismPortal_GasEstimation";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "OptimismPortal_GasLimitTooLow";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "OptimismPortal_ImproperDisputeGame";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "OptimismPortal_InvalidDisputeGame";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "OptimismPortal_InvalidLockboxState";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "OptimismPortal_InvalidMerkleProof";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "OptimismPortal_InvalidOutputRootProof";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "OptimismPortal_InvalidProofTimestamp";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "OptimismPortal_InvalidRootClaim";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "OptimismPortal_NoReentrancy";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "OptimismPortal_NotAllowedOnCGTMode";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "OptimismPortal_ProofNotOldEnough";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "OptimismPortal_Unproven";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "OutOfGas";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "ProxyAdminOwnedBase_NotProxyAdmin";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "ProxyAdminOwnedBase_NotProxyAdminOrProxyAdminOwner";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "ProxyAdminOwnedBase_NotProxyAdminOwner";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "ProxyAdminOwnedBase_NotResolvedDelegateProxy";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "ProxyAdminOwnedBase_NotSharedProxyAdminOwner";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "ProxyAdminOwnedBase_ProxyAdminNotFound";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "ReinitializableBase_ZeroInitVersion";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "UnexpectedList";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "UnexpectedString";
+    readonly type: "error";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: false;
+        readonly internalType: "uint8";
+        readonly name: "version";
+        readonly type: "uint8";
+    }];
+    readonly name: "Initialized";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "from";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "uint256";
+        readonly name: "version";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "bytes";
+        readonly name: "opaqueData";
+        readonly type: "bytes";
+    }];
+    readonly name: "TransactionDeposited";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "bytes32";
+        readonly name: "withdrawalHash";
+        readonly type: "bytes32";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "bool";
+        readonly name: "success";
+        readonly type: "bool";
+    }];
+    readonly name: "WithdrawalFinalized";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "bytes32";
+        readonly name: "withdrawalHash";
+        readonly type: "bytes32";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "from";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "to";
+        readonly type: "address";
+    }];
+    readonly name: "WithdrawalProven";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "bytes32";
+        readonly name: "withdrawalHash";
+        readonly type: "bytes32";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "proofSubmitter";
+        readonly type: "address";
+    }];
+    readonly name: "WithdrawalProvenExtension1";
+    readonly type: "event";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "anchorStateRegistry";
+    readonly outputs: readonly [{
+        readonly internalType: "contract IAnchorStateRegistry";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "_withdrawalHash";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "address";
+        readonly name: "_proofSubmitter";
+        readonly type: "address";
+    }];
+    readonly name: "checkWithdrawal";
+    readonly outputs: readonly [];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "_to";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_value";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint64";
+        readonly name: "_gasLimit";
+        readonly type: "uint64";
+    }, {
+        readonly internalType: "bool";
+        readonly name: "_isCreation";
+        readonly type: "bool";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "_data";
+        readonly type: "bytes";
+    }];
+    readonly name: "depositTransaction";
+    readonly outputs: readonly [];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "contract IDisputeGame";
+        readonly name: "_disputeGame";
+        readonly type: "address";
+    }];
+    readonly name: "disputeGameBlacklist";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "disputeGameFactory";
+    readonly outputs: readonly [{
+        readonly internalType: "contract IDisputeGameFactory";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "disputeGameFinalityDelaySeconds";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "donateETH";
+    readonly outputs: readonly [];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "ethLockbox";
+    readonly outputs: readonly [{
+        readonly internalType: "contract IETHLockbox";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly components: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "nonce";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "address";
+            readonly name: "sender";
+            readonly type: "address";
+        }, {
+            readonly internalType: "address";
+            readonly name: "target";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "value";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "gasLimit";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "data";
+            readonly type: "bytes";
+        }];
+        readonly internalType: "struct Types.WithdrawalTransaction";
+        readonly name: "_tx";
+        readonly type: "tuple";
+    }];
+    readonly name: "finalizeWithdrawalTransaction";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly components: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "nonce";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "address";
+            readonly name: "sender";
+            readonly type: "address";
+        }, {
+            readonly internalType: "address";
+            readonly name: "target";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "value";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "gasLimit";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "data";
+            readonly type: "bytes";
+        }];
+        readonly internalType: "struct Types.WithdrawalTransaction";
+        readonly name: "_tx";
+        readonly type: "tuple";
+    }, {
+        readonly internalType: "address";
+        readonly name: "_proofSubmitter";
+        readonly type: "address";
+    }];
+    readonly name: "finalizeWithdrawalTransactionExternalProof";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "";
+        readonly type: "bytes32";
+    }];
+    readonly name: "finalizedWithdrawals";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "guardian";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "initVersion";
+    readonly outputs: readonly [{
+        readonly internalType: "uint8";
+        readonly name: "";
+        readonly type: "uint8";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "contract ISystemConfig";
+        readonly name: "_systemConfig";
+        readonly type: "address";
+    }, {
+        readonly internalType: "contract IAnchorStateRegistry";
+        readonly name: "_anchorStateRegistry";
+        readonly type: "address";
+    }];
+    readonly name: "initialize";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "l2Sender";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint64";
+        readonly name: "_byteCount";
+        readonly type: "uint64";
+    }];
+    readonly name: "minimumGasLimit";
+    readonly outputs: readonly [{
+        readonly internalType: "uint64";
+        readonly name: "";
+        readonly type: "uint64";
+    }];
+    readonly stateMutability: "pure";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "_withdrawalHash";
+        readonly type: "bytes32";
+    }];
+    readonly name: "numProofSubmitters";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "params";
+    readonly outputs: readonly [{
+        readonly internalType: "uint128";
+        readonly name: "prevBaseFee";
+        readonly type: "uint128";
+    }, {
+        readonly internalType: "uint64";
+        readonly name: "prevBoughtGas";
+        readonly type: "uint64";
+    }, {
+        readonly internalType: "uint64";
+        readonly name: "prevBlockNum";
+        readonly type: "uint64";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "paused";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "proofMaturityDelaySeconds";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly name: "proofSubmitters";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly components: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "nonce";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "address";
+            readonly name: "sender";
+            readonly type: "address";
+        }, {
+            readonly internalType: "address";
+            readonly name: "target";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "value";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "gasLimit";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "data";
+            readonly type: "bytes";
+        }];
+        readonly internalType: "struct Types.WithdrawalTransaction";
+        readonly name: "_tx";
+        readonly type: "tuple";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_disputeGameIndex";
+        readonly type: "uint256";
+    }, {
+        readonly components: readonly [{
+            readonly internalType: "bytes32";
+            readonly name: "version";
+            readonly type: "bytes32";
+        }, {
+            readonly internalType: "bytes32";
+            readonly name: "stateRoot";
+            readonly type: "bytes32";
+        }, {
+            readonly internalType: "bytes32";
+            readonly name: "messagePasserStorageRoot";
+            readonly type: "bytes32";
+        }, {
+            readonly internalType: "bytes32";
+            readonly name: "latestBlockhash";
+            readonly type: "bytes32";
+        }];
+        readonly internalType: "struct Types.OutputRootProof";
+        readonly name: "_outputRootProof";
+        readonly type: "tuple";
+    }, {
+        readonly internalType: "bytes[]";
+        readonly name: "_withdrawalProof";
+        readonly type: "bytes[]";
+    }];
+    readonly name: "proveWithdrawalTransaction";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly name: "provenWithdrawals";
+    readonly outputs: readonly [{
+        readonly internalType: "contract IDisputeGame";
+        readonly name: "disputeGameProxy";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint64";
+        readonly name: "timestamp";
+        readonly type: "uint64";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "proxyAdmin";
+    readonly outputs: readonly [{
+        readonly internalType: "contract IProxyAdmin";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "proxyAdminOwner";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "respectedGameType";
+    readonly outputs: readonly [{
+        readonly internalType: "GameType";
+        readonly name: "";
+        readonly type: "uint32";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "respectedGameTypeUpdatedAt";
+    readonly outputs: readonly [{
+        readonly internalType: "uint64";
+        readonly name: "";
+        readonly type: "uint64";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "superchainConfig";
+    readonly outputs: readonly [{
+        readonly internalType: "contract ISuperchainConfig";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "systemConfig";
+    readonly outputs: readonly [{
+        readonly internalType: "contract ISystemConfig";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "version";
+    readonly outputs: readonly [{
+        readonly internalType: "string";
+        readonly name: "";
+        readonly type: "string";
+    }];
+    readonly stateMutability: "pure";
+    readonly type: "function";
+}, {
+    readonly stateMutability: "payable";
+    readonly type: "receive";
+}];
+/**
+ * Type-safe ABI for OptimismPortal2_json
+ */
+export type OptimismPortal2_jsonAbi = typeof OptimismPortal2_jsonAbi;
+/**
+ * Contract instance type for OptimismPortal2_json
+ */
+export type OptimismPortal2_jsonContract = any;
+/**
+ * OptimismPortal2_json Contract Class
+ *
+ * Provides a class-based API similar to TypeChain for interacting with the contract.
+ *
+ * @example
+ * ```typescript
+ * import { createPublicClient, createWalletClient, http } from 'viem';
+ * import { mainnet } from 'viem/chains';
+ * import { OptimismPortal2_json } from 'OptimismPortal2_json';
+ *
+ * const publicClient = createPublicClient({ chain: mainnet, transport: http() });
+ * const walletClient = createWalletClient({ chain: mainnet, transport: http() });
+ *
+ * const contract = new OptimismPortal2_json('0x...', { publicClient, walletClient });
+ *
+ * // Read functions
+ * const result = await contract.balanceOf('0x...');
+ *
+ * // Write functions
+ * const hash = await contract.transfer('0x...', 1000n);
+ *
+ * // Simulate transactions (dry-run)
+ * const simulation = await contract.simulate.transfer('0x...', 1000n);
+ * console.log('Gas estimate:', simulation.request.gas);
+ *
+ * // Watch events
+ * const unwatch = contract.watch.Transfer((event) => {
+ *   console.log('Transfer event:', event);
+ * });
+ * ```
+ */
+export declare class OptimismPortal2_json {
+    private contract;
+    private contractAddress;
+    private publicClient;
+    constructor(address: Address, clients: {
+        publicClient: PublicClient;
+        walletClient?: WalletClient;
+    });
+    /**
+     * Get the contract address
+     */
+    get address(): Address;
+    /**
+     * Get the underlying viem contract instance
+     */
+    getContract(): OptimismPortal2_jsonContract;
+    /**
+     * anchorStateRegistry
+     * view
+     */
+    anchorStateRegistry(): Promise<`0x${string}`>;
+    /**
+     * checkWithdrawal
+     * view
+     */
+    checkWithdrawal(_withdrawalHash: `0x${string}`, _proofSubmitter: `0x${string}`): Promise<void>;
+    /**
+     * disputeGameBlacklist
+     * view
+     */
+    disputeGameBlacklist(_disputeGame: `0x${string}`): Promise<boolean>;
+    /**
+     * disputeGameFactory
+     * view
+     */
+    disputeGameFactory(): Promise<`0x${string}`>;
+    /**
+     * disputeGameFinalityDelaySeconds
+     * view
+     */
+    disputeGameFinalityDelaySeconds(): Promise<bigint>;
+    /**
+     * ethLockbox
+     * view
+     */
+    ethLockbox(): Promise<`0x${string}`>;
+    /**
+     * finalizedWithdrawals
+     * view
+     */
+    finalizedWithdrawals(arg0: `0x${string}`): Promise<boolean>;
+    /**
+     * guardian
+     * view
+     */
+    guardian(): Promise<`0x${string}`>;
+    /**
+     * initVersion
+     * view
+     */
+    initVersion(): Promise<bigint>;
+    /**
+     * l2Sender
+     * view
+     */
+    l2Sender(): Promise<`0x${string}`>;
+    /**
+     * minimumGasLimit
+     * pure
+     */
+    minimumGasLimit(_byteCount: bigint): Promise<bigint>;
+    /**
+     * numProofSubmitters
+     * view
+     */
+    numProofSubmitters(_withdrawalHash: `0x${string}`): Promise<bigint>;
+    /**
+     * params
+     * view
+     */
+    params(): Promise<[bigint, bigint, bigint]>;
+    /**
+     * paused
+     * view
+     */
+    paused(): Promise<boolean>;
+    /**
+     * proofMaturityDelaySeconds
+     * view
+     */
+    proofMaturityDelaySeconds(): Promise<bigint>;
+    /**
+     * proofSubmitters
+     * view
+     */
+    proofSubmitters(arg0: `0x${string}`, arg1: bigint): Promise<`0x${string}`>;
+    /**
+     * provenWithdrawals
+     * view
+     */
+    provenWithdrawals(arg0: `0x${string}`, arg1: `0x${string}`): Promise<[`0x${string}`, bigint]>;
+    /**
+     * proxyAdmin
+     * view
+     */
+    proxyAdmin(): Promise<`0x${string}`>;
+    /**
+     * proxyAdminOwner
+     * view
+     */
+    proxyAdminOwner(): Promise<`0x${string}`>;
+    /**
+     * respectedGameType
+     * view
+     */
+    respectedGameType(): Promise<bigint>;
+    /**
+     * respectedGameTypeUpdatedAt
+     * view
+     */
+    respectedGameTypeUpdatedAt(): Promise<bigint>;
+    /**
+     * superchainConfig
+     * view
+     */
+    superchainConfig(): Promise<`0x${string}`>;
+    /**
+     * systemConfig
+     * view
+     */
+    systemConfig(): Promise<`0x${string}`>;
+    /**
+     * version
+     * pure
+     */
+    version(): Promise<string>;
+    /**
+     * depositTransaction
+     * payable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    depositTransaction(_to: `0x${string}`, _value: bigint, _gasLimit: bigint, _isCreation: boolean, _data: `0x${string}`, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+    }): Promise<`0x${string}`>;
+    /**
+     * donateETH
+     * payable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    donateETH(options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+    }): Promise<`0x${string}`>;
+    /**
+     * finalizeWithdrawalTransaction
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    finalizeWithdrawalTransaction(_tx: Types_WithdrawalTransaction, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+    }): Promise<`0x${string}`>;
+    /**
+     * finalizeWithdrawalTransactionExternalProof
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    finalizeWithdrawalTransactionExternalProof(_tx: Types_WithdrawalTransaction, _proofSubmitter: `0x${string}`, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+    }): Promise<`0x${string}`>;
+    /**
+     * initialize
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    initialize(_systemConfig: `0x${string}`, _anchorStateRegistry: `0x${string}`, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+    }): Promise<`0x${string}`>;
+    /**
+     * proveWithdrawalTransaction
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    proveWithdrawalTransaction(_tx: Types_WithdrawalTransaction, _disputeGameIndex: bigint, _outputRootProof: Types_OutputRootProof, _withdrawalProof: `0x${string}`[], options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+    }): Promise<`0x${string}`>;
+    /**
+     * Simulate contract write operations (dry-run without sending transaction)
+     *
+     * @example
+     * const result = await contract.simulate.transfer('0x...', 1000n);
+     * console.log('Gas estimate:', result.request.gas);
+     * console.log('Would succeed:', result.result);
+     */
+    get simulate(): {
+        /**
+         * Simulate depositTransaction
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        depositTransaction(_to: `0x${string}`, _value: bigint, _gasLimit: bigint, _isCreation: boolean, _data: `0x${string}`, options?: {
+            accessList?: import("viem").AccessList;
+            authorizationList?: import("viem").AuthorizationList;
+            chain?: import("viem").Chain | null;
+            dataSuffix?: `0x${string}`;
+            gas?: bigint;
+            gasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+            nonce?: number;
+            value?: bigint;
+        }): Promise<void>;
+        /**
+         * Simulate donateETH
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        donateETH(options?: {
+            accessList?: import("viem").AccessList;
+            authorizationList?: import("viem").AuthorizationList;
+            chain?: import("viem").Chain | null;
+            dataSuffix?: `0x${string}`;
+            gas?: bigint;
+            gasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+            nonce?: number;
+            value?: bigint;
+        }): Promise<void>;
+        /**
+         * Simulate finalizeWithdrawalTransaction
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        finalizeWithdrawalTransaction(_tx: Types_WithdrawalTransaction, options?: {
+            accessList?: import("viem").AccessList;
+            authorizationList?: import("viem").AuthorizationList;
+            chain?: import("viem").Chain | null;
+            dataSuffix?: `0x${string}`;
+            gas?: bigint;
+            gasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+            nonce?: number;
+            value?: bigint;
+        }): Promise<void>;
+        /**
+         * Simulate finalizeWithdrawalTransactionExternalProof
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        finalizeWithdrawalTransactionExternalProof(_tx: Types_WithdrawalTransaction, _proofSubmitter: `0x${string}`, options?: {
+            accessList?: import("viem").AccessList;
+            authorizationList?: import("viem").AuthorizationList;
+            chain?: import("viem").Chain | null;
+            dataSuffix?: `0x${string}`;
+            gas?: bigint;
+            gasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+            nonce?: number;
+            value?: bigint;
+        }): Promise<void>;
+        /**
+         * Simulate initialize
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        initialize(_systemConfig: `0x${string}`, _anchorStateRegistry: `0x${string}`, options?: {
+            accessList?: import("viem").AccessList;
+            authorizationList?: import("viem").AuthorizationList;
+            chain?: import("viem").Chain | null;
+            dataSuffix?: `0x${string}`;
+            gas?: bigint;
+            gasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+            nonce?: number;
+            value?: bigint;
+        }): Promise<void>;
+        /**
+         * Simulate proveWithdrawalTransaction
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        proveWithdrawalTransaction(_tx: Types_WithdrawalTransaction, _disputeGameIndex: bigint, _outputRootProof: Types_OutputRootProof, _withdrawalProof: `0x${string}`[], options?: {
+            accessList?: import("viem").AccessList;
+            authorizationList?: import("viem").AuthorizationList;
+            chain?: import("viem").Chain | null;
+            dataSuffix?: `0x${string}`;
+            gas?: bigint;
+            gasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+            nonce?: number;
+            value?: bigint;
+        }): Promise<void>;
+    };
+    /**
+     * Watch contract events
+     *
+     * @example
+     * // Watch all Transfer events
+     * const unwatch = contract.watch.Transfer((event) => {
+     *   console.log('Transfer:', event);
+     * });
+     *
+     * // Stop watching
+     * unwatch();
+     */
+    get watch(): {
+        /**
+         * Watch Initialized events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        Initialized: (callback: (event: {
+            version: bigint;
+        }) => void) => () => void;
+        /**
+         * Watch TransactionDeposited events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        TransactionDeposited: (callback: (event: {
+            from: `0x${string}`;
+            to: `0x${string}`;
+            version: bigint;
+            opaqueData: `0x${string}`;
+        }) => void, filter?: {
+            from: `0x${string}`;
+            to: `0x${string}`;
+            version: bigint;
+        }) => () => void;
+        /**
+         * Watch WithdrawalFinalized events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        WithdrawalFinalized: (callback: (event: {
+            withdrawalHash: `0x${string}`;
+            success: boolean;
+        }) => void, filter?: {
+            withdrawalHash: `0x${string}`;
+        }) => () => void;
+        /**
+         * Watch WithdrawalProven events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        WithdrawalProven: (callback: (event: {
+            withdrawalHash: `0x${string}`;
+            from: `0x${string}`;
+            to: `0x${string}`;
+        }) => void, filter?: {
+            withdrawalHash: `0x${string}`;
+            from: `0x${string}`;
+            to: `0x${string}`;
+        }) => () => void;
+        /**
+         * Watch WithdrawalProvenExtension1 events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        WithdrawalProvenExtension1: (callback: (event: {
+            withdrawalHash: `0x${string}`;
+            proofSubmitter: `0x${string}`;
+        }) => void, filter?: {
+            withdrawalHash: `0x${string}`;
+            proofSubmitter: `0x${string}`;
+        }) => () => void;
+    };
+}