@gitmyabi/eigenpod 1.0.0

package/contracts/EigenPod_json.ts

@@ -0,0 +1,2148 @@
+import type { Abi, Address, PublicClient, WalletClient, GetContractReturnType } from 'viem';
+import { getContract } from 'viem';
+
+
+/**
+ * IEigenPodTypes.Checkpoint struct type
+ */
+export type IEigenPodTypes_Checkpoint = {
+  beaconBlockRoot: `0x${string}`;
+  proofsRemaining: bigint;
+  podBalanceGwei: bigint;
+  balanceDeltasGwei: bigint;
+  prevBeaconBalanceGwei: bigint;
+};
+
+/**
+ * IEigenPodTypes.ConsolidationRequest struct type
+ */
+export type IEigenPodTypes_ConsolidationRequest = {
+  srcPubkey: `0x${string}`;
+  targetPubkey: `0x${string}`;
+};
+
+/**
+ * IEigenPodTypes.WithdrawalRequest struct type
+ */
+export type IEigenPodTypes_WithdrawalRequest = {
+  pubkey: `0x${string}`;
+  amountGwei: bigint;
+};
+
+/**
+ * IEigenPodTypes.ValidatorInfo struct type
+ */
+export type IEigenPodTypes_ValidatorInfo = {
+  validatorIndex: bigint;
+  restakedBalanceGwei: bigint;
+  lastCheckpointedAt: bigint;
+  status: bigint;
+};
+
+/**
+ * BeaconChainProofs.BalanceContainerProof struct type
+ */
+export type BeaconChainProofs_BalanceContainerProof = {
+  balanceContainerRoot: `0x${string}`;
+  proof: `0x${string}`;
+};
+
+/**
+ * BeaconChainProofs.BalanceProof struct type
+ */
+export type BeaconChainProofs_BalanceProof = {
+  pubkeyHash: `0x${string}`;
+  balanceRoot: `0x${string}`;
+  proof: `0x${string}`;
+};
+
+/**
+ * BeaconChainProofs.StateRootProof struct type
+ */
+export type BeaconChainProofs_StateRootProof = {
+  beaconStateRoot: `0x${string}`;
+  proof: `0x${string}`;
+};
+
+/**
+ * BeaconChainProofs.ValidatorProof struct type
+ */
+export type BeaconChainProofs_ValidatorProof = {
+  validatorFields: `0x${string}`[];
+  proof: `0x${string}`;
+};
+/**
+ * EigenPod_json ABI
+ * 
+ * This ABI is typed using viem's type system for full type safety.
+ */
+export const EigenPod_jsonAbi = [
+  {
+    "inputs": [
+      {
+        "internalType": "contract IETHPOSDeposit",
+        "name": "_ethPOS",
+        "type": "address"
+      },
+      {
+        "internalType": "contract IEigenPodManager",
+        "name": "_eigenPodManager",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "constructor"
+  },
+  {
+    "inputs": [],
+    "name": "BeaconTimestampBeforeLatestCheckpoint",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "BeaconTimestampTooFarInPast",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "CannotCheckpointTwiceInSingleBlock",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "CheckpointAlreadyActive",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "CredentialsAlreadyVerified",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "CurrentlyPaused",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "EmptyRoot",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "FeeQueryFailed",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "ForkTimestampZero",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "InputAddressZero",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "InputArrayLengthMismatch",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "InsufficientFunds",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "InsufficientWithdrawableBalance",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "InvalidEIP4788Response",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "InvalidIndex",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "InvalidProof",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "InvalidProofLength",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "InvalidProofLength",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "InvalidPubKeyLength",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "InvalidValidatorFieldsLength",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "LeavesNotPowerOfTwo",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "MsgValueNot32ETH",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "NoActiveCheckpoint",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "NoBalanceToCheckpoint",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "NotEnoughLeaves",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "OnlyEigenPodManager",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "OnlyEigenPodOwner",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "OnlyEigenPodOwnerOrProofSubmitter",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "PredeployFailed",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "TimestampOutOfRange",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "ValidatorInactiveOnBeaconChain",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "ValidatorIsExitingBeaconChain",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "ValidatorNotActiveInPod",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "ValidatorNotSlashedOnBeaconChain",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "WithdrawalCredentialsNotForEigenPod",
+    "type": "error"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "uint64",
+        "name": "checkpointTimestamp",
+        "type": "uint64"
+      },
+      {
+        "indexed": true,
+        "internalType": "bytes32",
+        "name": "beaconBlockRoot",
+        "type": "bytes32"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "validatorCount",
+        "type": "uint256"
+      }
+    ],
+    "name": "CheckpointCreated",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "uint64",
+        "name": "checkpointTimestamp",
+        "type": "uint64"
+      },
+      {
+        "indexed": false,
+        "internalType": "int256",
+        "name": "totalShareDeltaWei",
+        "type": "int256"
+      }
+    ],
+    "name": "CheckpointFinalized",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "bytes32",
+        "name": "sourcePubkeyHash",
+        "type": "bytes32"
+      },
+      {
+        "indexed": true,
+        "internalType": "bytes32",
+        "name": "targetPubkeyHash",
+        "type": "bytes32"
+      }
+    ],
+    "name": "ConsolidationRequested",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": false,
+        "internalType": "bytes32",
+        "name": "pubkeyHash",
+        "type": "bytes32"
+      }
+    ],
+    "name": "EigenPodStaked",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "bytes32",
+        "name": "validatorPubkeyHash",
+        "type": "bytes32"
+      }
+    ],
+    "name": "ExitRequested",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": false,
+        "internalType": "uint8",
+        "name": "version",
+        "type": "uint8"
+      }
+    ],
+    "name": "Initialized",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "amountReceived",
+        "type": "uint256"
+      }
+    ],
+    "name": "NonBeaconChainETHReceived",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": false,
+        "internalType": "address",
+        "name": "prevProofSubmitter",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "internalType": "address",
+        "name": "newProofSubmitter",
+        "type": "address"
+      }
+    ],
+    "name": "ProofSubmitterUpdated",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "recipient",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "amount",
+        "type": "uint256"
+      }
+    ],
+    "name": "RestakedBeaconChainETHWithdrawn",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "bytes32",
+        "name": "validatorPubkeyHash",
+        "type": "bytes32"
+      }
+    ],
+    "name": "SwitchToCompoundingRequested",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": false,
+        "internalType": "bytes32",
+        "name": "pubkeyHash",
+        "type": "bytes32"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint64",
+        "name": "balanceTimestamp",
+        "type": "uint64"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint64",
+        "name": "newValidatorBalanceGwei",
+        "type": "uint64"
+      }
+    ],
+    "name": "ValidatorBalanceUpdated",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "uint64",
+        "name": "checkpointTimestamp",
+        "type": "uint64"
+      },
+      {
+        "indexed": true,
+        "internalType": "bytes32",
+        "name": "pubkeyHash",
+        "type": "bytes32"
+      }
+    ],
+    "name": "ValidatorCheckpointed",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": false,
+        "internalType": "bytes32",
+        "name": "pubkeyHash",
+        "type": "bytes32"
+      }
+    ],
+    "name": "ValidatorRestaked",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "uint64",
+        "name": "checkpointTimestamp",
+        "type": "uint64"
+      },
+      {
+        "indexed": true,
+        "internalType": "bytes32",
+        "name": "pubkeyHash",
+        "type": "bytes32"
+      }
+    ],
+    "name": "ValidatorWithdrawn",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "bytes32",
+        "name": "validatorPubkeyHash",
+        "type": "bytes32"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint64",
+        "name": "withdrawalAmountGwei",
+        "type": "uint64"
+      }
+    ],
+    "name": "WithdrawalRequested",
+    "type": "event"
+  },
+  {
+    "inputs": [],
+    "name": "activeValidatorCount",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint64",
+        "name": "",
+        "type": "uint64"
+      }
+    ],
+    "name": "checkpointBalanceExitedGwei",
+    "outputs": [
+      {
+        "internalType": "uint64",
+        "name": "",
+        "type": "uint64"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "currentCheckpoint",
+    "outputs": [
+      {
+        "components": [
+          {
+            "internalType": "bytes32",
+            "name": "beaconBlockRoot",
+            "type": "bytes32"
+          },
+          {
+            "internalType": "uint24",
+            "name": "proofsRemaining",
+            "type": "uint24"
+          },
+          {
+            "internalType": "uint64",
+            "name": "podBalanceGwei",
+            "type": "uint64"
+          },
+          {
+            "internalType": "int64",
+            "name": "balanceDeltasGwei",
+            "type": "int64"
+          },
+          {
+            "internalType": "uint64",
+            "name": "prevBeaconBalanceGwei",
+            "type": "uint64"
+          }
+        ],
+        "internalType": "struct IEigenPodTypes.Checkpoint",
+        "name": "",
+        "type": "tuple"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "currentCheckpointTimestamp",
+    "outputs": [
+      {
+        "internalType": "uint64",
+        "name": "",
+        "type": "uint64"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "eigenPodManager",
+    "outputs": [
+      {
+        "internalType": "contract IEigenPodManager",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "ethPOS",
+    "outputs": [
+      {
+        "internalType": "contract IETHPOSDeposit",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "getConsolidationRequestFee",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint64",
+        "name": "timestamp",
+        "type": "uint64"
+      }
+    ],
+    "name": "getParentBlockRoot",
+    "outputs": [
+      {
+        "internalType": "bytes32",
+        "name": "",
+        "type": "bytes32"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "getWithdrawalRequestFee",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "_podOwner",
+        "type": "address"
+      }
+    ],
+    "name": "initialize",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "lastCheckpointTimestamp",
+    "outputs": [
+      {
+        "internalType": "uint64",
+        "name": "",
+        "type": "uint64"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "podOwner",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "proofSubmitter",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "contract IERC20[]",
+        "name": "tokenList",
+        "type": "address[]"
+      },
+      {
+        "internalType": "uint256[]",
+        "name": "amountsToWithdraw",
+        "type": "uint256[]"
+      },
+      {
+        "internalType": "address",
+        "name": "recipient",
+        "type": "address"
+      }
+    ],
+    "name": "recoverTokens",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "components": [
+          {
+            "internalType": "bytes",
+            "name": "srcPubkey",
+            "type": "bytes"
+          },
+          {
+            "internalType": "bytes",
+            "name": "targetPubkey",
+            "type": "bytes"
+          }
+        ],
+        "internalType": "struct IEigenPodTypes.ConsolidationRequest[]",
+        "name": "requests",
+        "type": "tuple[]"
+      }
+    ],
+    "name": "requestConsolidation",
+    "outputs": [],
+    "stateMutability": "payable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "components": [
+          {
+            "internalType": "bytes",
+            "name": "pubkey",
+            "type": "bytes"
+          },
+          {
+            "internalType": "uint64",
+            "name": "amountGwei",
+            "type": "uint64"
+          }
+        ],
+        "internalType": "struct IEigenPodTypes.WithdrawalRequest[]",
+        "name": "requests",
+        "type": "tuple[]"
+      }
+    ],
+    "name": "requestWithdrawal",
+    "outputs": [],
+    "stateMutability": "payable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "newProofSubmitter",
+        "type": "address"
+      }
+    ],
+    "name": "setProofSubmitter",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "bytes",
+        "name": "pubkey",
+        "type": "bytes"
+      },
+      {
+        "internalType": "bytes",
+        "name": "signature",
+        "type": "bytes"
+      },
+      {
+        "internalType": "bytes32",
+        "name": "depositDataRoot",
+        "type": "bytes32"
+      }
+    ],
+    "name": "stake",
+    "outputs": [],
+    "stateMutability": "payable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "bool",
+        "name": "revertIfNoBalance",
+        "type": "bool"
+      }
+    ],
+    "name": "startCheckpoint",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "bytes32",
+        "name": "validatorPubkeyHash",
+        "type": "bytes32"
+      }
+    ],
+    "name": "validatorPubkeyHashToInfo",
+    "outputs": [
+      {
+        "components": [
+          {
+            "internalType": "uint64",
+            "name": "validatorIndex",
+            "type": "uint64"
+          },
+          {
+            "internalType": "uint64",
+            "name": "restakedBalanceGwei",
+            "type": "uint64"
+          },
+          {
+            "internalType": "uint64",
+            "name": "lastCheckpointedAt",
+            "type": "uint64"
+          },
+          {
+            "internalType": "enum IEigenPodTypes.VALIDATOR_STATUS",
+            "name": "status",
+            "type": "uint8"
+          }
+        ],
+        "internalType": "struct IEigenPodTypes.ValidatorInfo",
+        "name": "",
+        "type": "tuple"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "bytes",
+        "name": "validatorPubkey",
+        "type": "bytes"
+      }
+    ],
+    "name": "validatorPubkeyToInfo",
+    "outputs": [
+      {
+        "components": [
+          {
+            "internalType": "uint64",
+            "name": "validatorIndex",
+            "type": "uint64"
+          },
+          {
+            "internalType": "uint64",
+            "name": "restakedBalanceGwei",
+            "type": "uint64"
+          },
+          {
+            "internalType": "uint64",
+            "name": "lastCheckpointedAt",
+            "type": "uint64"
+          },
+          {
+            "internalType": "enum IEigenPodTypes.VALIDATOR_STATUS",
+            "name": "status",
+            "type": "uint8"
+          }
+        ],
+        "internalType": "struct IEigenPodTypes.ValidatorInfo",
+        "name": "",
+        "type": "tuple"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "bytes",
+        "name": "validatorPubkey",
+        "type": "bytes"
+      }
+    ],
+    "name": "validatorStatus",
+    "outputs": [
+      {
+        "internalType": "enum IEigenPodTypes.VALIDATOR_STATUS",
+        "name": "",
+        "type": "uint8"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "bytes32",
+        "name": "pubkeyHash",
+        "type": "bytes32"
+      }
+    ],
+    "name": "validatorStatus",
+    "outputs": [
+      {
+        "internalType": "enum IEigenPodTypes.VALIDATOR_STATUS",
+        "name": "",
+        "type": "uint8"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "components": [
+          {
+            "internalType": "bytes32",
+            "name": "balanceContainerRoot",
+            "type": "bytes32"
+          },
+          {
+            "internalType": "bytes",
+            "name": "proof",
+            "type": "bytes"
+          }
+        ],
+        "internalType": "struct BeaconChainProofs.BalanceContainerProof",
+        "name": "balanceContainerProof",
+        "type": "tuple"
+      },
+      {
+        "components": [
+          {
+            "internalType": "bytes32",
+            "name": "pubkeyHash",
+            "type": "bytes32"
+          },
+          {
+            "internalType": "bytes32",
+            "name": "balanceRoot",
+            "type": "bytes32"
+          },
+          {
+            "internalType": "bytes",
+            "name": "proof",
+            "type": "bytes"
+          }
+        ],
+        "internalType": "struct BeaconChainProofs.BalanceProof[]",
+        "name": "proofs",
+        "type": "tuple[]"
+      }
+    ],
+    "name": "verifyCheckpointProofs",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint64",
+        "name": "beaconTimestamp",
+        "type": "uint64"
+      },
+      {
+        "components": [
+          {
+            "internalType": "bytes32",
+            "name": "beaconStateRoot",
+            "type": "bytes32"
+          },
+          {
+            "internalType": "bytes",
+            "name": "proof",
+            "type": "bytes"
+          }
+        ],
+        "internalType": "struct BeaconChainProofs.StateRootProof",
+        "name": "stateRootProof",
+        "type": "tuple"
+      },
+      {
+        "components": [
+          {
+            "internalType": "bytes32[]",
+            "name": "validatorFields",
+            "type": "bytes32[]"
+          },
+          {
+            "internalType": "bytes",
+            "name": "proof",
+            "type": "bytes"
+          }
+        ],
+        "internalType": "struct BeaconChainProofs.ValidatorProof",
+        "name": "proof",
+        "type": "tuple"
+      }
+    ],
+    "name": "verifyStaleBalance",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint64",
+        "name": "beaconTimestamp",
+        "type": "uint64"
+      },
+      {
+        "components": [
+          {
+            "internalType": "bytes32",
+            "name": "beaconStateRoot",
+            "type": "bytes32"
+          },
+          {
+            "internalType": "bytes",
+            "name": "proof",
+            "type": "bytes"
+          }
+        ],
+        "internalType": "struct BeaconChainProofs.StateRootProof",
+        "name": "stateRootProof",
+        "type": "tuple"
+      },
+      {
+        "internalType": "uint40[]",
+        "name": "validatorIndices",
+        "type": "uint40[]"
+      },
+      {
+        "internalType": "bytes[]",
+        "name": "validatorFieldsProofs",
+        "type": "bytes[]"
+      },
+      {
+        "internalType": "bytes32[][]",
+        "name": "validatorFields",
+        "type": "bytes32[][]"
+      }
+    ],
+    "name": "verifyWithdrawalCredentials",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "recipient",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amountWei",
+        "type": "uint256"
+      }
+    ],
+    "name": "withdrawRestakedBeaconChainETH",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "withdrawableRestakedExecutionLayerGwei",
+    "outputs": [
+      {
+        "internalType": "uint64",
+        "name": "",
+        "type": "uint64"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "stateMutability": "payable",
+    "type": "receive"
+  }
+] as const satisfies Abi;
+
+/**
+ * Type-safe ABI for EigenPod_json
+ */
+export type EigenPod_jsonAbi = typeof EigenPod_jsonAbi;
+
+/**
+ * Contract instance type for EigenPod_json
+ */
+// Use any for contract type to avoid complex viem type issues
+// The runtime behavior is type-safe through viem's ABI typing
+export type EigenPod_jsonContract = any;
+
+/**
+ * EigenPod_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 { EigenPod_json } from 'EigenPod_json';
+ * 
+ * const publicClient = createPublicClient({ chain: mainnet, transport: http() });
+ * const walletClient = createWalletClient({ chain: mainnet, transport: http() });
+ * 
+ * const contract = new EigenPod_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 class EigenPod_json {
+  private contract: EigenPod_jsonContract;
+  private contractAddress: Address;
+  private publicClient: PublicClient;
+
+  constructor(
+    address: Address,
+    clients: {
+      publicClient: PublicClient;
+      walletClient?: WalletClient;
+    }
+  ) {
+    this.contractAddress = address;
+    this.publicClient = clients.publicClient;
+    this.contract = getContract({
+      address,
+      abi: EigenPod_jsonAbi,
+      client: {
+        public: clients.publicClient,
+        wallet: clients.walletClient,
+      },
+    });
+  }
+
+  /**
+   * Get the contract address
+   */
+  get address(): Address {
+    return this.contractAddress;
+  }
+
+  /**
+   * Get the underlying viem contract instance
+   */
+  getContract(): EigenPod_jsonContract {
+    return this.contract;
+  }
+
+  /**
+   * activeValidatorCount
+   * view
+   */
+  async activeValidatorCount(): Promise<bigint> {
+    return this.contract.read.activeValidatorCount() as Promise<bigint>;
+  }
+
+  /**
+   * checkpointBalanceExitedGwei
+   * view
+   */
+  async checkpointBalanceExitedGwei(arg0: bigint): Promise<bigint> {
+    return this.contract.read.checkpointBalanceExitedGwei([arg0] as const) as Promise<bigint>;
+  }
+
+  /**
+   * currentCheckpoint
+   * view
+   */
+  async currentCheckpoint(): Promise<IEigenPodTypes_Checkpoint> {
+    return this.contract.read.currentCheckpoint() as Promise<IEigenPodTypes_Checkpoint>;
+  }
+
+  /**
+   * currentCheckpointTimestamp
+   * view
+   */
+  async currentCheckpointTimestamp(): Promise<bigint> {
+    return this.contract.read.currentCheckpointTimestamp() as Promise<bigint>;
+  }
+
+  /**
+   * eigenPodManager
+   * view
+   */
+  async eigenPodManager(): Promise<`0x${string}`> {
+    return this.contract.read.eigenPodManager() as Promise<`0x${string}`>;
+  }
+
+  /**
+   * ethPOS
+   * view
+   */
+  async ethPOS(): Promise<`0x${string}`> {
+    return this.contract.read.ethPOS() as Promise<`0x${string}`>;
+  }
+
+  /**
+   * getConsolidationRequestFee
+   * view
+   */
+  async getConsolidationRequestFee(): Promise<bigint> {
+    return this.contract.read.getConsolidationRequestFee() as Promise<bigint>;
+  }
+
+  /**
+   * getParentBlockRoot
+   * view
+   */
+  async getParentBlockRoot(timestamp: bigint): Promise<`0x${string}`> {
+    return this.contract.read.getParentBlockRoot([timestamp] as const) as Promise<`0x${string}`>;
+  }
+
+  /**
+   * getWithdrawalRequestFee
+   * view
+   */
+  async getWithdrawalRequestFee(): Promise<bigint> {
+    return this.contract.read.getWithdrawalRequestFee() as Promise<bigint>;
+  }
+
+  /**
+   * lastCheckpointTimestamp
+   * view
+   */
+  async lastCheckpointTimestamp(): Promise<bigint> {
+    return this.contract.read.lastCheckpointTimestamp() as Promise<bigint>;
+  }
+
+  /**
+   * podOwner
+   * view
+   */
+  async podOwner(): Promise<`0x${string}`> {
+    return this.contract.read.podOwner() as Promise<`0x${string}`>;
+  }
+
+  /**
+   * proofSubmitter
+   * view
+   */
+  async proofSubmitter(): Promise<`0x${string}`> {
+    return this.contract.read.proofSubmitter() as Promise<`0x${string}`>;
+  }
+
+  /**
+   * validatorPubkeyHashToInfo
+   * view
+   */
+  async validatorPubkeyHashToInfo(validatorPubkeyHash: `0x${string}`): Promise<IEigenPodTypes_ValidatorInfo> {
+    return this.contract.read.validatorPubkeyHashToInfo([validatorPubkeyHash] as const) as Promise<IEigenPodTypes_ValidatorInfo>;
+  }
+
+  /**
+   * validatorPubkeyToInfo
+   * view
+   */
+  async validatorPubkeyToInfo(validatorPubkey: `0x${string}`): Promise<IEigenPodTypes_ValidatorInfo> {
+    return this.contract.read.validatorPubkeyToInfo([validatorPubkey] as const) as Promise<IEigenPodTypes_ValidatorInfo>;
+  }
+
+  async validatorStatus(validatorPubkey: `0x${string}`): Promise<bigint>;
+  async validatorStatus(pubkeyHash: `0x${string}`): Promise<bigint>;
+  async validatorStatus(...args: any[]): Promise<any> {
+    return this.contract.read.validatorStatus(args as any) as Promise<any>;
+  }
+
+  /**
+   * withdrawableRestakedExecutionLayerGwei
+   * view
+   */
+  async withdrawableRestakedExecutionLayerGwei(): Promise<bigint> {
+    return this.contract.read.withdrawableRestakedExecutionLayerGwei() as Promise<bigint>;
+  }
+
+  /**
+   * initialize
+   * nonpayable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   */
+  async initialize(_podOwner: `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}`> {
+    if (!this.contract.write) {
+      throw new Error('Wallet client is required for write operations');
+    }
+    return this.contract.write.initialize([_podOwner] as const, options) as Promise<`0x${string}`>;
+  }
+
+  /**
+   * recoverTokens
+   * nonpayable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   */
+  async recoverTokens(tokenList: `0x${string}`[], amountsToWithdraw: bigint[], recipient: `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}`> {
+    if (!this.contract.write) {
+      throw new Error('Wallet client is required for write operations');
+    }
+    return this.contract.write.recoverTokens([tokenList, amountsToWithdraw, recipient] as const, options) as Promise<`0x${string}`>;
+  }
+
+  /**
+   * requestConsolidation
+   * payable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   */
+  async requestConsolidation(requests: IEigenPodTypes_ConsolidationRequest[], 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}`> {
+    if (!this.contract.write) {
+      throw new Error('Wallet client is required for write operations');
+    }
+    return this.contract.write.requestConsolidation([requests] as const, options) as Promise<`0x${string}`>;
+  }
+
+  /**
+   * requestWithdrawal
+   * payable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   */
+  async requestWithdrawal(requests: IEigenPodTypes_WithdrawalRequest[], 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}`> {
+    if (!this.contract.write) {
+      throw new Error('Wallet client is required for write operations');
+    }
+    return this.contract.write.requestWithdrawal([requests] as const, options) as Promise<`0x${string}`>;
+  }
+
+  /**
+   * setProofSubmitter
+   * nonpayable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   */
+  async setProofSubmitter(newProofSubmitter: `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}`> {
+    if (!this.contract.write) {
+      throw new Error('Wallet client is required for write operations');
+    }
+    return this.contract.write.setProofSubmitter([newProofSubmitter] as const, options) as Promise<`0x${string}`>;
+  }
+
+  /**
+   * stake
+   * payable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   */
+  async stake(pubkey: `0x${string}`, signature: `0x${string}`, depositDataRoot: `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}`> {
+    if (!this.contract.write) {
+      throw new Error('Wallet client is required for write operations');
+    }
+    return this.contract.write.stake([pubkey, signature, depositDataRoot] as const, options) as Promise<`0x${string}`>;
+  }
+
+  /**
+   * startCheckpoint
+   * nonpayable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   */
+  async startCheckpoint(revertIfNoBalance: boolean, 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}`> {
+    if (!this.contract.write) {
+      throw new Error('Wallet client is required for write operations');
+    }
+    return this.contract.write.startCheckpoint([revertIfNoBalance] as const, options) as Promise<`0x${string}`>;
+  }
+
+  /**
+   * verifyCheckpointProofs
+   * nonpayable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   */
+  async verifyCheckpointProofs(balanceContainerProof: BeaconChainProofs_BalanceContainerProof, proofs: BeaconChainProofs_BalanceProof[], 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}`> {
+    if (!this.contract.write) {
+      throw new Error('Wallet client is required for write operations');
+    }
+    return this.contract.write.verifyCheckpointProofs([balanceContainerProof, proofs] as const, options) as Promise<`0x${string}`>;
+  }
+
+  /**
+   * verifyStaleBalance
+   * nonpayable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   */
+  async verifyStaleBalance(beaconTimestamp: bigint, stateRootProof: BeaconChainProofs_StateRootProof, proof: BeaconChainProofs_ValidatorProof, 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}`> {
+    if (!this.contract.write) {
+      throw new Error('Wallet client is required for write operations');
+    }
+    return this.contract.write.verifyStaleBalance([beaconTimestamp, stateRootProof, proof] as const, options) as Promise<`0x${string}`>;
+  }
+
+  /**
+   * verifyWithdrawalCredentials
+   * nonpayable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   */
+  async verifyWithdrawalCredentials(beaconTimestamp: bigint, stateRootProof: BeaconChainProofs_StateRootProof, validatorIndices: bigint[], validatorFieldsProofs: `0x${string}`[], validatorFields: `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}`> {
+    if (!this.contract.write) {
+      throw new Error('Wallet client is required for write operations');
+    }
+    return this.contract.write.verifyWithdrawalCredentials([beaconTimestamp, stateRootProof, validatorIndices, validatorFieldsProofs, validatorFields] as const, options) as Promise<`0x${string}`>;
+  }
+
+  /**
+   * withdrawRestakedBeaconChainETH
+   * nonpayable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   */
+  async withdrawRestakedBeaconChainETH(recipient: `0x${string}`, amountWei: bigint, 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}`> {
+    if (!this.contract.write) {
+      throw new Error('Wallet client is required for write operations');
+    }
+    return this.contract.write.withdrawRestakedBeaconChainETH([recipient, amountWei] as const, options) as 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() {
+    const contract = this.contract;
+    if (!contract.simulate) {
+      throw new Error('Public client is required for simulation');
+    }
+    return {
+      /**
+       * Simulate initialize
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async initialize(_podOwner: `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> {
+        return contract.simulate.initialize([_podOwner] as const, options) as Promise<void>;
+      },
+      /**
+       * Simulate recoverTokens
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async recoverTokens(tokenList: `0x${string}`[], amountsToWithdraw: bigint[], recipient: `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> {
+        return contract.simulate.recoverTokens([tokenList, amountsToWithdraw, recipient] as const, options) as Promise<void>;
+      },
+      /**
+       * Simulate requestConsolidation
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async requestConsolidation(requests: IEigenPodTypes_ConsolidationRequest[], 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> {
+        return contract.simulate.requestConsolidation([requests] as const, options) as Promise<void>;
+      },
+      /**
+       * Simulate requestWithdrawal
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async requestWithdrawal(requests: IEigenPodTypes_WithdrawalRequest[], 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> {
+        return contract.simulate.requestWithdrawal([requests] as const, options) as Promise<void>;
+      },
+      /**
+       * Simulate setProofSubmitter
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async setProofSubmitter(newProofSubmitter: `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> {
+        return contract.simulate.setProofSubmitter([newProofSubmitter] as const, options) as Promise<void>;
+      },
+      /**
+       * Simulate stake
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async stake(pubkey: `0x${string}`, signature: `0x${string}`, depositDataRoot: `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> {
+        return contract.simulate.stake([pubkey, signature, depositDataRoot] as const, options) as Promise<void>;
+      },
+      /**
+       * Simulate startCheckpoint
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async startCheckpoint(revertIfNoBalance: boolean, 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> {
+        return contract.simulate.startCheckpoint([revertIfNoBalance] as const, options) as Promise<void>;
+      },
+      /**
+       * Simulate verifyCheckpointProofs
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async verifyCheckpointProofs(balanceContainerProof: BeaconChainProofs_BalanceContainerProof, proofs: BeaconChainProofs_BalanceProof[], 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> {
+        return contract.simulate.verifyCheckpointProofs([balanceContainerProof, proofs] as const, options) as Promise<void>;
+      },
+      /**
+       * Simulate verifyStaleBalance
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async verifyStaleBalance(beaconTimestamp: bigint, stateRootProof: BeaconChainProofs_StateRootProof, proof: BeaconChainProofs_ValidatorProof, 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> {
+        return contract.simulate.verifyStaleBalance([beaconTimestamp, stateRootProof, proof] as const, options) as Promise<void>;
+      },
+      /**
+       * Simulate verifyWithdrawalCredentials
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async verifyWithdrawalCredentials(beaconTimestamp: bigint, stateRootProof: BeaconChainProofs_StateRootProof, validatorIndices: bigint[], validatorFieldsProofs: `0x${string}`[], validatorFields: `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> {
+        return contract.simulate.verifyWithdrawalCredentials([beaconTimestamp, stateRootProof, validatorIndices, validatorFieldsProofs, validatorFields] as const, options) as Promise<void>;
+      },
+      /**
+       * Simulate withdrawRestakedBeaconChainETH
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async withdrawRestakedBeaconChainETH(recipient: `0x${string}`, amountWei: bigint, 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> {
+        return contract.simulate.withdrawRestakedBeaconChainETH([recipient, amountWei] as const, options) as 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() {
+    return {
+      /**
+       * Watch CheckpointCreated events
+       * @param callback Function to call when event is emitted
+       * @param filter Optional filter for indexed parameters
+       * @returns Unwatch function to stop listening
+       */
+      CheckpointCreated: (callback: (event: { checkpointTimestamp: bigint; beaconBlockRoot: `0x${string}`; validatorCount: bigint }) => void, filter?: { checkpointTimestamp: bigint; beaconBlockRoot: `0x${string}` }) => {
+        return this.publicClient.watchContractEvent({
+          address: this.contractAddress,
+          abi: EigenPod_jsonAbi,
+          eventName: 'CheckpointCreated',
+          args: filter,
+          onLogs: (logs: any[]) => {
+            logs.forEach((log: any) => {
+              callback(log.args as any);
+            });
+          },
+        }) as () => void;
+      },
+      /**
+       * Watch CheckpointFinalized events
+       * @param callback Function to call when event is emitted
+       * @param filter Optional filter for indexed parameters
+       * @returns Unwatch function to stop listening
+       */
+      CheckpointFinalized: (callback: (event: { checkpointTimestamp: bigint; totalShareDeltaWei: bigint }) => void, filter?: { checkpointTimestamp: bigint }) => {
+        return this.publicClient.watchContractEvent({
+          address: this.contractAddress,
+          abi: EigenPod_jsonAbi,
+          eventName: 'CheckpointFinalized',
+          args: filter,
+          onLogs: (logs: any[]) => {
+            logs.forEach((log: any) => {
+              callback(log.args as any);
+            });
+          },
+        }) as () => void;
+      },
+      /**
+       * Watch ConsolidationRequested events
+       * @param callback Function to call when event is emitted
+       * @param filter Optional filter for indexed parameters
+       * @returns Unwatch function to stop listening
+       */
+      ConsolidationRequested: (callback: (event: { sourcePubkeyHash: `0x${string}`; targetPubkeyHash: `0x${string}` }) => void, filter?: { sourcePubkeyHash: `0x${string}`; targetPubkeyHash: `0x${string}` }) => {
+        return this.publicClient.watchContractEvent({
+          address: this.contractAddress,
+          abi: EigenPod_jsonAbi,
+          eventName: 'ConsolidationRequested',
+          args: filter,
+          onLogs: (logs: any[]) => {
+            logs.forEach((log: any) => {
+              callback(log.args as any);
+            });
+          },
+        }) as () => void;
+      },
+      /**
+       * Watch EigenPodStaked events
+       * @param callback Function to call when event is emitted
+       * @param filter Optional filter for indexed parameters
+       * @returns Unwatch function to stop listening
+       */
+      EigenPodStaked: (callback: (event: { pubkeyHash: `0x${string}` }) => void) => {
+        return this.publicClient.watchContractEvent({
+          address: this.contractAddress,
+          abi: EigenPod_jsonAbi,
+          eventName: 'EigenPodStaked',
+          
+          onLogs: (logs: any[]) => {
+            logs.forEach((log: any) => {
+              callback(log.args as any);
+            });
+          },
+        }) as () => void;
+      },
+      /**
+       * Watch ExitRequested events
+       * @param callback Function to call when event is emitted
+       * @param filter Optional filter for indexed parameters
+       * @returns Unwatch function to stop listening
+       */
+      ExitRequested: (callback: (event: { validatorPubkeyHash: `0x${string}` }) => void, filter?: { validatorPubkeyHash: `0x${string}` }) => {
+        return this.publicClient.watchContractEvent({
+          address: this.contractAddress,
+          abi: EigenPod_jsonAbi,
+          eventName: 'ExitRequested',
+          args: filter,
+          onLogs: (logs: any[]) => {
+            logs.forEach((log: any) => {
+              callback(log.args as any);
+            });
+          },
+        }) as () => void;
+      },
+      /**
+       * 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) => {
+        return this.publicClient.watchContractEvent({
+          address: this.contractAddress,
+          abi: EigenPod_jsonAbi,
+          eventName: 'Initialized',
+          
+          onLogs: (logs: any[]) => {
+            logs.forEach((log: any) => {
+              callback(log.args as any);
+            });
+          },
+        }) as () => void;
+      },
+      /**
+       * Watch NonBeaconChainETHReceived events
+       * @param callback Function to call when event is emitted
+       * @param filter Optional filter for indexed parameters
+       * @returns Unwatch function to stop listening
+       */
+      NonBeaconChainETHReceived: (callback: (event: { amountReceived: bigint }) => void) => {
+        return this.publicClient.watchContractEvent({
+          address: this.contractAddress,
+          abi: EigenPod_jsonAbi,
+          eventName: 'NonBeaconChainETHReceived',
+          
+          onLogs: (logs: any[]) => {
+            logs.forEach((log: any) => {
+              callback(log.args as any);
+            });
+          },
+        }) as () => void;
+      },
+      /**
+       * Watch ProofSubmitterUpdated events
+       * @param callback Function to call when event is emitted
+       * @param filter Optional filter for indexed parameters
+       * @returns Unwatch function to stop listening
+       */
+      ProofSubmitterUpdated: (callback: (event: { prevProofSubmitter: `0x${string}`; newProofSubmitter: `0x${string}` }) => void) => {
+        return this.publicClient.watchContractEvent({
+          address: this.contractAddress,
+          abi: EigenPod_jsonAbi,
+          eventName: 'ProofSubmitterUpdated',
+          
+          onLogs: (logs: any[]) => {
+            logs.forEach((log: any) => {
+              callback(log.args as any);
+            });
+          },
+        }) as () => void;
+      },
+      /**
+       * Watch RestakedBeaconChainETHWithdrawn events
+       * @param callback Function to call when event is emitted
+       * @param filter Optional filter for indexed parameters
+       * @returns Unwatch function to stop listening
+       */
+      RestakedBeaconChainETHWithdrawn: (callback: (event: { recipient: `0x${string}`; amount: bigint }) => void, filter?: { recipient: `0x${string}` }) => {
+        return this.publicClient.watchContractEvent({
+          address: this.contractAddress,
+          abi: EigenPod_jsonAbi,
+          eventName: 'RestakedBeaconChainETHWithdrawn',
+          args: filter,
+          onLogs: (logs: any[]) => {
+            logs.forEach((log: any) => {
+              callback(log.args as any);
+            });
+          },
+        }) as () => void;
+      },
+      /**
+       * Watch SwitchToCompoundingRequested events
+       * @param callback Function to call when event is emitted
+       * @param filter Optional filter for indexed parameters
+       * @returns Unwatch function to stop listening
+       */
+      SwitchToCompoundingRequested: (callback: (event: { validatorPubkeyHash: `0x${string}` }) => void, filter?: { validatorPubkeyHash: `0x${string}` }) => {
+        return this.publicClient.watchContractEvent({
+          address: this.contractAddress,
+          abi: EigenPod_jsonAbi,
+          eventName: 'SwitchToCompoundingRequested',
+          args: filter,
+          onLogs: (logs: any[]) => {
+            logs.forEach((log: any) => {
+              callback(log.args as any);
+            });
+          },
+        }) as () => void;
+      },
+      /**
+       * Watch ValidatorBalanceUpdated events
+       * @param callback Function to call when event is emitted
+       * @param filter Optional filter for indexed parameters
+       * @returns Unwatch function to stop listening
+       */
+      ValidatorBalanceUpdated: (callback: (event: { pubkeyHash: `0x${string}`; balanceTimestamp: bigint; newValidatorBalanceGwei: bigint }) => void) => {
+        return this.publicClient.watchContractEvent({
+          address: this.contractAddress,
+          abi: EigenPod_jsonAbi,
+          eventName: 'ValidatorBalanceUpdated',
+          
+          onLogs: (logs: any[]) => {
+            logs.forEach((log: any) => {
+              callback(log.args as any);
+            });
+          },
+        }) as () => void;
+      },
+      /**
+       * Watch ValidatorCheckpointed events
+       * @param callback Function to call when event is emitted
+       * @param filter Optional filter for indexed parameters
+       * @returns Unwatch function to stop listening
+       */
+      ValidatorCheckpointed: (callback: (event: { checkpointTimestamp: bigint; pubkeyHash: `0x${string}` }) => void, filter?: { checkpointTimestamp: bigint; pubkeyHash: `0x${string}` }) => {
+        return this.publicClient.watchContractEvent({
+          address: this.contractAddress,
+          abi: EigenPod_jsonAbi,
+          eventName: 'ValidatorCheckpointed',
+          args: filter,
+          onLogs: (logs: any[]) => {
+            logs.forEach((log: any) => {
+              callback(log.args as any);
+            });
+          },
+        }) as () => void;
+      },
+      /**
+       * Watch ValidatorRestaked events
+       * @param callback Function to call when event is emitted
+       * @param filter Optional filter for indexed parameters
+       * @returns Unwatch function to stop listening
+       */
+      ValidatorRestaked: (callback: (event: { pubkeyHash: `0x${string}` }) => void) => {
+        return this.publicClient.watchContractEvent({
+          address: this.contractAddress,
+          abi: EigenPod_jsonAbi,
+          eventName: 'ValidatorRestaked',
+          
+          onLogs: (logs: any[]) => {
+            logs.forEach((log: any) => {
+              callback(log.args as any);
+            });
+          },
+        }) as () => void;
+      },
+      /**
+       * Watch ValidatorWithdrawn events
+       * @param callback Function to call when event is emitted
+       * @param filter Optional filter for indexed parameters
+       * @returns Unwatch function to stop listening
+       */
+      ValidatorWithdrawn: (callback: (event: { checkpointTimestamp: bigint; pubkeyHash: `0x${string}` }) => void, filter?: { checkpointTimestamp: bigint; pubkeyHash: `0x${string}` }) => {
+        return this.publicClient.watchContractEvent({
+          address: this.contractAddress,
+          abi: EigenPod_jsonAbi,
+          eventName: 'ValidatorWithdrawn',
+          args: filter,
+          onLogs: (logs: any[]) => {
+            logs.forEach((log: any) => {
+              callback(log.args as any);
+            });
+          },
+        }) as () => void;
+      },
+      /**
+       * Watch WithdrawalRequested events
+       * @param callback Function to call when event is emitted
+       * @param filter Optional filter for indexed parameters
+       * @returns Unwatch function to stop listening
+       */
+      WithdrawalRequested: (callback: (event: { validatorPubkeyHash: `0x${string}`; withdrawalAmountGwei: bigint }) => void, filter?: { validatorPubkeyHash: `0x${string}` }) => {
+        return this.publicClient.watchContractEvent({
+          address: this.contractAddress,
+          abi: EigenPod_jsonAbi,
+          eventName: 'WithdrawalRequested',
+          args: filter,
+          onLogs: (logs: any[]) => {
+            logs.forEach((log: any) => {
+              callback(log.args as any);
+            });
+          },
+        }) as () => void;
+      }
+    };
+  }
+}