@gitmyabi/curvegauge 1.0.0

package/contracts/CurveGauge_json.d.ts

@@ -0,0 +1,1590 @@
+import type { Address, PublicClient, WalletClient } from 'viem';
+/**
+ * CurveGauge_json ABI
+ *
+ * This ABI is typed using viem's type system for full type safety.
+ */
+export declare const CurveGauge_jsonAbi: readonly [{
+    readonly inputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "constructor";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "stateId";
+        readonly type: "bytes32";
+    }];
+    readonly name: "AlreadyInState";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "ArrayLengthMismatch";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "toStateId";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "bytes32";
+        readonly name: "currentStateId";
+        readonly type: "bytes32";
+    }];
+    readonly name: "CannotEnterStateWithLowerHeight";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "CannotExitFromNoAllocationState";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "toStateId";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "bytes32";
+        readonly name: "currentStateId";
+        readonly type: "bytes32";
+    }];
+    readonly name: "CannotExitToStateWithHigherHeight";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "EmergencyExitUnavailable";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "EmergencyModeActivated";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "EnterUnavailable";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "InconsistentState";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "IncorrectAmount";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "navDelta";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "maxSlippageCached";
+        readonly type: "uint256";
+    }];
+    readonly name: "IncorrectSlippage";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "stateId";
+        readonly type: "bytes32";
+    }];
+    readonly name: "IncorrectStateId";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "InvalidInitialization";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "NavResolutionModeActivated";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "NavResolutionModeNotActivated";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "currentStateId";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "currentStateBitmask";
+        readonly type: "uint256";
+    }];
+    readonly name: "NotInTargetState";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "NotInitializing";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "token";
+        readonly type: "address";
+    }];
+    readonly name: "NotWhitelistedToken";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "ReentrancyGuardReentrantCall";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "ReshufflingModeDisabled";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "token";
+        readonly type: "address";
+    }];
+    readonly name: "SafeERC20FailedOperation";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "navBefore";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "navAfter";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "minNavDelta";
+        readonly type: "uint256";
+    }];
+    readonly name: "SlippageCheckFailed";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "stateId";
+        readonly type: "bytes32";
+    }];
+    readonly name: "StateAlreadyExists";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "stateId";
+        readonly type: "bytes32";
+    }];
+    readonly name: "StateHasZeroBitmask";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "stateId";
+        readonly type: "bytes32";
+    }];
+    readonly name: "StateNotFound";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "TargetStateAlreadySet";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "value";
+        readonly type: "address";
+    }];
+    readonly name: "TokenAlreadySet";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "token";
+        readonly type: "address";
+    }];
+    readonly name: "TokenNotFound";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "TreasuryNotSet";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "Unauthorized";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "ZeroAddress";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "ZeroArrayLength";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "ZeroState";
+    readonly type: "error";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: false;
+        readonly internalType: "bytes32";
+        readonly name: "toStateId";
+        readonly type: "bytes32";
+    }];
+    readonly name: "EmergencyExitFailed";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "oldEmergencyExitMaxSlippage";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "newEmergencyExitMaxSlippage";
+        readonly type: "uint256";
+    }];
+    readonly name: "EmergencyExitMaxSlippageUpdated";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: false;
+        readonly internalType: "bytes32";
+        readonly name: "toStateId";
+        readonly type: "bytes32";
+    }];
+    readonly name: "EmergencyExitSucceeded";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: false;
+        readonly internalType: "bytes32";
+        readonly name: "toStateId";
+        readonly type: "bytes32";
+    }];
+    readonly name: "EmergencyExited";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: false;
+        readonly internalType: "bool";
+        readonly name: "isEmergencyMode";
+        readonly type: "bool";
+    }];
+    readonly name: "EmergencyModeUpdated";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "oldEnterMaxSlippage";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "newEnterMaxSlippage";
+        readonly type: "uint256";
+    }];
+    readonly name: "EnterMaxSlippageUpdated";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "navBefore";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "navAfter";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "bool";
+        readonly name: "hasRemainder";
+        readonly type: "bool";
+    }];
+    readonly name: "Entered";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "oldExitMaxSlippage";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "newExitMaxSlippage";
+        readonly type: "uint256";
+    }];
+    readonly name: "ExitMaxSlippageUpdated";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "navBefore";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "navAfter";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "bytes32";
+        readonly name: "stateId";
+        readonly type: "bytes32";
+    }];
+    readonly name: "Exited";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: false;
+        readonly internalType: "bytes32";
+        readonly name: "stateId";
+        readonly type: "bytes32";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "navAfter";
+        readonly type: "uint256";
+    }];
+    readonly name: "Harvested";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: false;
+        readonly internalType: "uint64";
+        readonly name: "version";
+        readonly type: "uint64";
+    }];
+    readonly name: "Initialized";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: false;
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly name: "InputTokenSet";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: false;
+        readonly internalType: "bool";
+        readonly name: "isNavResolutionMode";
+        readonly type: "bool";
+    }];
+    readonly name: "NavResolutionModeUpdated";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: false;
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly name: "OutputTokenSet";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: false;
+        readonly internalType: "bytes32";
+        readonly name: "stateId";
+        readonly type: "bytes32";
+    }];
+    readonly name: "ReenteredToState";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: false;
+        readonly internalType: "bytes32";
+        readonly name: "oldStateId";
+        readonly type: "bytes32";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "bytes32";
+        readonly name: "newStateId";
+        readonly type: "bytes32";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "newStateBitmask";
+        readonly type: "uint256";
+    }];
+    readonly name: "StateUpdated";
+    readonly type: "event";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "acceptedStateId";
+        readonly type: "bytes32";
+    }];
+    readonly name: "acceptNav";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "currentStateId";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "";
+        readonly type: "bytes32";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "currentStateNav";
+    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: "toStateId";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "share";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "minNavDelta";
+        readonly type: "uint256";
+    }];
+    readonly name: "emergencyExit";
+    readonly outputs: readonly [];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "emergencyExitMaxSlippage";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256[]";
+        readonly name: "amounts";
+        readonly type: "uint256[]";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "minNavDelta";
+        readonly type: "uint256";
+    }];
+    readonly name: "enter";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }, {
+        readonly internalType: "uint256[]";
+        readonly name: "";
+        readonly type: "uint256[]";
+    }];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "enterMaxSlippage";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "share";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "maxNavDelta";
+        readonly type: "uint256";
+    }];
+    readonly name: "exit";
+    readonly outputs: readonly [{
+        readonly internalType: "address[]";
+        readonly name: "";
+        readonly type: "address[]";
+    }, {
+        readonly internalType: "uint256[]";
+        readonly name: "";
+        readonly type: "uint256[]";
+    }];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "exitMaxSlippage";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "gauge";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "getInputTokens";
+    readonly outputs: readonly [{
+        readonly internalType: "address[]";
+        readonly name: "";
+        readonly type: "address[]";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "getOutputTokens";
+    readonly outputs: readonly [{
+        readonly internalType: "address[]";
+        readonly name: "";
+        readonly type: "address[]";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "getStateIds";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes32[]";
+        readonly name: "";
+        readonly type: "bytes32[]";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "token";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly name: "getTokenAmountInNotion";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "harvest";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "strategyContainer";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "_gauge";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_enterMaxSlippage";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_exitMaxSlippage";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_emergencyExitMaxSlippage";
+        readonly type: "uint256";
+    }];
+    readonly name: "initialize";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "isNavResolutionMode";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "lastStoredGaugeBalance";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "lastStoredVirtualPrice";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "lpToken";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "stateId";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "minNavDelta";
+        readonly type: "uint256";
+    }];
+    readonly name: "reenterToState";
+    readonly outputs: readonly [];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "_emergencyExitMaxSlippage";
+        readonly type: "uint256";
+    }];
+    readonly name: "setEmergencyExitMaxSlippage";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "_enterMaxSlippage";
+        readonly type: "uint256";
+    }];
+    readonly name: "setEnterMaxSlippage";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "_exitMaxSlippage";
+        readonly type: "uint256";
+    }];
+    readonly name: "setExitMaxSlippage";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address[]";
+        readonly name: "inputTokens";
+        readonly type: "address[]";
+    }];
+    readonly name: "setInputTokens";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address[]";
+        readonly name: "outputTokens";
+        readonly type: "address[]";
+    }];
+    readonly name: "setOutputTokens";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "stateId";
+        readonly type: "bytes32";
+    }];
+    readonly name: "stateBitmask";
+    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: "stateId";
+        readonly type: "bytes32";
+    }];
+    readonly name: "stateNav";
+    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: "toStateId";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "share";
+        readonly type: "uint256";
+    }];
+    readonly name: "tryEmergencyExit";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "underlyingAsset0";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "underlyingAsset1";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}];
+/**
+ * Type-safe ABI for CurveGauge_json
+ */
+export type CurveGauge_jsonAbi = typeof CurveGauge_jsonAbi;
+/**
+ * Contract instance type for CurveGauge_json
+ */
+export type CurveGauge_jsonContract = any;
+/**
+ * CurveGauge_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 { CurveGauge_json } from 'CurveGauge_json';
+ *
+ * const publicClient = createPublicClient({ chain: mainnet, transport: http() });
+ * const walletClient = createWalletClient({ chain: mainnet, transport: http() });
+ *
+ * const contract = new CurveGauge_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 CurveGauge_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(): CurveGauge_jsonContract;
+    /**
+     * currentStateId
+     * view
+     */
+    currentStateId(): Promise<`0x${string}`>;
+    /**
+     * currentStateNav
+     * view
+     */
+    currentStateNav(): Promise<bigint>;
+    /**
+     * emergencyExitMaxSlippage
+     * view
+     */
+    emergencyExitMaxSlippage(): Promise<bigint>;
+    /**
+     * enterMaxSlippage
+     * view
+     */
+    enterMaxSlippage(): Promise<bigint>;
+    /**
+     * exitMaxSlippage
+     * view
+     */
+    exitMaxSlippage(): Promise<bigint>;
+    /**
+     * gauge
+     * view
+     */
+    gauge(): Promise<`0x${string}`>;
+    /**
+     * getInputTokens
+     * view
+     */
+    getInputTokens(): Promise<`0x${string}`[]>;
+    /**
+     * getOutputTokens
+     * view
+     */
+    getOutputTokens(): Promise<`0x${string}`[]>;
+    /**
+     * getStateIds
+     * view
+     */
+    getStateIds(): Promise<`0x${string}`[]>;
+    /**
+     * getTokenAmountInNotion
+     * view
+     */
+    getTokenAmountInNotion(token: `0x${string}`, amount: bigint): Promise<bigint>;
+    /**
+     * isNavResolutionMode
+     * view
+     */
+    isNavResolutionMode(): Promise<boolean>;
+    /**
+     * lastStoredGaugeBalance
+     * view
+     */
+    lastStoredGaugeBalance(): Promise<bigint>;
+    /**
+     * lastStoredVirtualPrice
+     * view
+     */
+    lastStoredVirtualPrice(): Promise<bigint>;
+    /**
+     * lpToken
+     * view
+     */
+    lpToken(): Promise<`0x${string}`>;
+    /**
+     * stateBitmask
+     * view
+     */
+    stateBitmask(stateId: `0x${string}`): Promise<bigint>;
+    /**
+     * stateNav
+     * view
+     */
+    stateNav(stateId: `0x${string}`): Promise<bigint>;
+    /**
+     * underlyingAsset0
+     * view
+     */
+    underlyingAsset0(): Promise<`0x${string}`>;
+    /**
+     * underlyingAsset1
+     * view
+     */
+    underlyingAsset1(): Promise<`0x${string}`>;
+    /**
+     * acceptNav
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    acceptNav(acceptedStateId: `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}`>;
+    /**
+     * emergencyExit
+     * payable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    emergencyExit(toStateId: `0x${string}`, share: bigint, minNavDelta: 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}`>;
+    /**
+     * enter
+     * payable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    enter(amounts: bigint[], minNavDelta: 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}`>;
+    /**
+     * exit
+     * payable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    exit(share: bigint, maxNavDelta: 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}`>;
+    /**
+     * harvest
+     * payable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    harvest(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(strategyContainer: `0x${string}`, _gauge: `0x${string}`, _enterMaxSlippage: bigint, _exitMaxSlippage: bigint, _emergencyExitMaxSlippage: 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}`>;
+    /**
+     * reenterToState
+     * payable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    reenterToState(stateId: `0x${string}`, minNavDelta: 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}`>;
+    /**
+     * setEmergencyExitMaxSlippage
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    setEmergencyExitMaxSlippage(_emergencyExitMaxSlippage: 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}`>;
+    /**
+     * setEnterMaxSlippage
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    setEnterMaxSlippage(_enterMaxSlippage: 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}`>;
+    /**
+     * setExitMaxSlippage
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    setExitMaxSlippage(_exitMaxSlippage: 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}`>;
+    /**
+     * setInputTokens
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    setInputTokens(inputTokens: `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}`>;
+    /**
+     * setOutputTokens
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    setOutputTokens(outputTokens: `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}`>;
+    /**
+     * tryEmergencyExit
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    tryEmergencyExit(toStateId: `0x${string}`, share: 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}`>;
+    /**
+     * 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 acceptNav
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        acceptNav(acceptedStateId: `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<bigint>;
+        /**
+         * Simulate emergencyExit
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        emergencyExit(toStateId: `0x${string}`, share: bigint, minNavDelta: 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>;
+        /**
+         * Simulate enter
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        enter(amounts: bigint[], minNavDelta: 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<[bigint, boolean, bigint[]]>;
+        /**
+         * Simulate exit
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        exit(share: bigint, maxNavDelta: 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}`[], bigint[]]>;
+        /**
+         * Simulate harvest
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        harvest(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<bigint>;
+        /**
+         * Simulate initialize
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        initialize(strategyContainer: `0x${string}`, _gauge: `0x${string}`, _enterMaxSlippage: bigint, _exitMaxSlippage: bigint, _emergencyExitMaxSlippage: 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>;
+        /**
+         * Simulate reenterToState
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        reenterToState(stateId: `0x${string}`, minNavDelta: 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>;
+        /**
+         * Simulate setEmergencyExitMaxSlippage
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        setEmergencyExitMaxSlippage(_emergencyExitMaxSlippage: 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>;
+        /**
+         * Simulate setEnterMaxSlippage
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        setEnterMaxSlippage(_enterMaxSlippage: 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>;
+        /**
+         * Simulate setExitMaxSlippage
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        setExitMaxSlippage(_exitMaxSlippage: 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>;
+        /**
+         * Simulate setInputTokens
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        setInputTokens(inputTokens: `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 setOutputTokens
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        setOutputTokens(outputTokens: `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 tryEmergencyExit
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        tryEmergencyExit(toStateId: `0x${string}`, share: 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>;
+    };
+    /**
+     * Watch contract events
+     *
+     * @example
+     * // Watch all Transfer events
+     * const unwatch = contract.watch.Transfer((event) => {
+     *   console.log('Transfer:', event);
+     * });
+     *
+     * // Stop watching
+     * unwatch();
+     */
+    get watch(): {
+        /**
+         * Watch EmergencyExitFailed events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        EmergencyExitFailed: (callback: (event: {
+            toStateId: `0x${string}`;
+        }) => void) => () => void;
+        /**
+         * Watch EmergencyExitMaxSlippageUpdated events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        EmergencyExitMaxSlippageUpdated: (callback: (event: {
+            oldEmergencyExitMaxSlippage: bigint;
+            newEmergencyExitMaxSlippage: bigint;
+        }) => void) => () => void;
+        /**
+         * Watch EmergencyExitSucceeded events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        EmergencyExitSucceeded: (callback: (event: {
+            toStateId: `0x${string}`;
+        }) => void) => () => void;
+        /**
+         * Watch EmergencyExited events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        EmergencyExited: (callback: (event: {
+            toStateId: `0x${string}`;
+        }) => void) => () => void;
+        /**
+         * Watch EmergencyModeUpdated events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        EmergencyModeUpdated: (callback: (event: {
+            isEmergencyMode: boolean;
+        }) => void) => () => void;
+        /**
+         * Watch EnterMaxSlippageUpdated events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        EnterMaxSlippageUpdated: (callback: (event: {
+            oldEnterMaxSlippage: bigint;
+            newEnterMaxSlippage: bigint;
+        }) => void) => () => void;
+        /**
+         * Watch Entered events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        Entered: (callback: (event: {
+            navBefore: bigint;
+            navAfter: bigint;
+            hasRemainder: boolean;
+        }) => void) => () => void;
+        /**
+         * Watch ExitMaxSlippageUpdated events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        ExitMaxSlippageUpdated: (callback: (event: {
+            oldExitMaxSlippage: bigint;
+            newExitMaxSlippage: bigint;
+        }) => void) => () => void;
+        /**
+         * Watch Exited events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        Exited: (callback: (event: {
+            navBefore: bigint;
+            navAfter: bigint;
+            stateId: `0x${string}`;
+        }) => void) => () => void;
+        /**
+         * Watch Harvested events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        Harvested: (callback: (event: {
+            stateId: `0x${string}`;
+            navAfter: bigint;
+        }) => void) => () => 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) => () => void;
+        /**
+         * Watch InputTokenSet events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        InputTokenSet: (callback: (event: {
+            arg0: `0x${string}`;
+        }) => void) => () => void;
+        /**
+         * Watch NavResolutionModeUpdated events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        NavResolutionModeUpdated: (callback: (event: {
+            isNavResolutionMode: boolean;
+        }) => void) => () => void;
+        /**
+         * Watch OutputTokenSet events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        OutputTokenSet: (callback: (event: {
+            arg0: `0x${string}`;
+        }) => void) => () => void;
+        /**
+         * Watch ReenteredToState events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        ReenteredToState: (callback: (event: {
+            stateId: `0x${string}`;
+        }) => void) => () => void;
+        /**
+         * Watch StateUpdated events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        StateUpdated: (callback: (event: {
+            oldStateId: `0x${string}`;
+            newStateId: `0x${string}`;
+            newStateBitmask: bigint;
+        }) => void) => () => void;
+    };
+}