@gitmyabi/logic 0.0.0-stage → 1.0.0

package/contracts/Logic.d.ts

@@ -0,0 +1,2256 @@
+import type { Address, PublicClient, WalletClient } from 'viem';
+/**
+ * Logic.V4SwapData struct type
+ */
+export type Logic_V4SwapData = {
+    key: PoolKey;
+    params: SwapParams;
+};
+/**
+ * PoolKey struct type
+ */
+export type PoolKey = {
+    currency0: `0x${string}`;
+    currency1: `0x${string}`;
+    fee: bigint;
+    tickSpacing: bigint;
+    hooks: `0x${string}`;
+};
+/**
+ * SwapParams struct type
+ */
+export type SwapParams = {
+    zeroForOne: boolean;
+    amountSpecified: bigint;
+    sqrtPriceLimitX96: bigint;
+};
+/**
+ * Logic ABI
+ *
+ * This ABI is typed using viem's type system for full type safety.
+ */
+export declare const LogicAbi: readonly [{
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "proxyOwner";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "proxyContract";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "constructor";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "WHITELIST_MANAGER";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "deployer";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address[]";
+        readonly name: "pools";
+        readonly type: "address[]";
+    }];
+    readonly name: "addWhitelistedAlgebraCustomPoolAddressesHum_1T0MDH";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address[]";
+        readonly name: "bots";
+        readonly type: "address[]";
+    }];
+    readonly name: "addWhitelistedBotAddressesHum";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address[]";
+        readonly name: "pairs";
+        readonly type: "address[]";
+    }];
+    readonly name: "addWhitelistedPairAddressesHum";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address[]";
+        readonly name: "accounts";
+        readonly type: "address[]";
+    }];
+    readonly name: "addWhitelistedTokenAddressesHum";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address[]";
+        readonly name: "accounts";
+        readonly type: "address[]";
+    }];
+    readonly name: "addWhitelistedTransferAddressesHum";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address[]";
+        readonly name: "factories";
+        readonly type: "address[]";
+    }];
+    readonly name: "addWhitelistedUniswapV3FactoryHum";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address[]";
+        readonly name: "pools";
+        readonly type: "address[]";
+    }];
+    readonly name: "addWhitelistedUniswapV3PoolAddressesHum";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address[]";
+        readonly name: "accounts";
+        readonly type: "address[]";
+    }];
+    readonly name: "addWhitelistedUniswapV3PositionManagerHum";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address[]";
+        readonly name: "hooks";
+        readonly type: "address[]";
+    }];
+    readonly name: "addWhitelistedUniswapV4HooksHum";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "poolManager";
+        readonly type: "address";
+    }, {
+        readonly internalType: "bytes[]";
+        readonly name: "keys";
+        readonly type: "bytes[]";
+    }];
+    readonly name: "addWhitelistedUniswapV4PoolsHum";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "int256";
+        readonly name: "amount0Delta";
+        readonly type: "int256";
+    }, {
+        readonly internalType: "int256";
+        readonly name: "amount1Delta";
+        readonly type: "int256";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "data";
+        readonly type: "bytes";
+    }];
+    readonly name: "algebraSwapCallback";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly name: "isWhitelistedBotAddress";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly name: "isWhitelistedPairAddress";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "";
+        readonly type: "bytes32";
+    }];
+    readonly name: "isWhitelistedPoolHash";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly name: "isWhitelistedPoolHook";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly name: "isWhitelistedRouterAddress";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly name: "isWhitelistedSlot11Address_3HRmBk";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly name: "isWhitelistedSlot3Address_7xvhmR";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly name: "isWhitelistedTokenAddress";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly name: "isWhitelistedTransferAddress";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly name: "isWhitelistedUniswapV3FactoryAddress";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly name: "isWhitelistedUniswapV3PoolAddress";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly name: "isWhitelistedUniswapV3PositionManagerAddress";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address[]";
+        readonly name: "tokens";
+        readonly type: "address[]";
+    }, {
+        readonly internalType: "address";
+        readonly name: "newProxy";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "newProxyOwner";
+        readonly type: "address";
+    }];
+    readonly name: "migrateTokensProxyOwnerHum";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "int256";
+        readonly name: "amount0Delta";
+        readonly type: "int256";
+    }, {
+        readonly internalType: "int256";
+        readonly name: "amount1Delta";
+        readonly type: "int256";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "data";
+        readonly type: "bytes";
+    }];
+    readonly name: "pancakeV3SwapCallback";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "int256";
+        readonly name: "amount0Delta";
+        readonly type: "int256";
+    }, {
+        readonly internalType: "int256";
+        readonly name: "amount1Delta";
+        readonly type: "int256";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "data";
+        readonly type: "bytes";
+    }];
+    readonly name: "ramsesV2SwapCallback";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address[]";
+        readonly name: "bots";
+        readonly type: "address[]";
+    }];
+    readonly name: "removeWhitelistedBotAddressesHum";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address[]";
+        readonly name: "pairs";
+        readonly type: "address[]";
+    }];
+    readonly name: "removeWhitelistedPairAddressesHum";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address[]";
+        readonly name: "accounts";
+        readonly type: "address[]";
+    }];
+    readonly name: "removeWhitelistedTokenAddressesHum";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address[]";
+        readonly name: "accounts";
+        readonly type: "address[]";
+    }];
+    readonly name: "removeWhitelistedTransferAddressesHum";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address[]";
+        readonly name: "factories";
+        readonly type: "address[]";
+    }];
+    readonly name: "removeWhitelistedUniswapV3FactoryHum";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address[]";
+        readonly name: "pools";
+        readonly type: "address[]";
+    }];
+    readonly name: "removeWhitelistedUniswapV3PoolAddressesHum";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address[]";
+        readonly name: "accounts";
+        readonly type: "address[]";
+    }];
+    readonly name: "removeWhitelistedUniswapV3PositionManagerHum";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address[]";
+        readonly name: "hooks";
+        readonly type: "address[]";
+    }];
+    readonly name: "removeWhitelistedUniswapV4HooksHum";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "poolManager";
+        readonly type: "address";
+    }, {
+        readonly internalType: "bytes[]";
+        readonly name: "keys";
+        readonly type: "bytes[]";
+    }];
+    readonly name: "removeWhitelistedUniswapV4PoolsHum";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly name: "slot9ValueOf_A7ULVH";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "int256";
+        readonly name: "amount0Delta";
+        readonly type: "int256";
+    }, {
+        readonly internalType: "int256";
+        readonly name: "amount1Delta";
+        readonly type: "int256";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "data";
+        readonly type: "bytes";
+    }];
+    readonly name: "squadV3SwapCallback";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "amountIn";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "address";
+        readonly name: "tokenIn";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "amountOutMin";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "bool";
+        readonly name: "zeroForOne";
+        readonly type: "bool";
+    }, {
+        readonly internalType: "address";
+        readonly name: "pool";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "deadline";
+        readonly type: "uint256";
+    }];
+    readonly name: "swapExactTokensForTokensUniswapV3Hum";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly components: readonly [{
+            readonly components: readonly [{
+                readonly internalType: "address";
+                readonly name: "currency0";
+                readonly type: "address";
+            }, {
+                readonly internalType: "address";
+                readonly name: "currency1";
+                readonly type: "address";
+            }, {
+                readonly internalType: "uint24";
+                readonly name: "fee";
+                readonly type: "uint24";
+            }, {
+                readonly internalType: "int24";
+                readonly name: "tickSpacing";
+                readonly type: "int24";
+            }, {
+                readonly internalType: "address";
+                readonly name: "hooks";
+                readonly type: "address";
+            }];
+            readonly internalType: "struct PoolKey";
+            readonly name: "key";
+            readonly type: "tuple";
+        }, {
+            readonly components: readonly [{
+                readonly internalType: "bool";
+                readonly name: "zeroForOne";
+                readonly type: "bool";
+            }, {
+                readonly internalType: "int256";
+                readonly name: "amountSpecified";
+                readonly type: "int256";
+            }, {
+                readonly internalType: "uint160";
+                readonly name: "sqrtPriceLimitX96";
+                readonly type: "uint160";
+            }];
+            readonly internalType: "struct SwapParams";
+            readonly name: "params";
+            readonly type: "tuple";
+        }];
+        readonly internalType: "struct Logic.V4SwapData";
+        readonly name: "data";
+        readonly type: "tuple";
+    }, {
+        readonly internalType: "address";
+        readonly name: "poolManager";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "amountOutMin";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "deadline";
+        readonly type: "uint256";
+    }];
+    readonly name: "swapExactTokensForTokensUniswapV4Hum";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint128";
+        readonly name: "amount";
+        readonly type: "uint128";
+    }, {
+        readonly internalType: "int24";
+        readonly name: "boundaryPoint";
+        readonly type: "int24";
+    }, {
+        readonly internalType: "address";
+        readonly name: "tokenIn";
+        readonly type: "address";
+    }, {
+        readonly internalType: "bool";
+        readonly name: "x2y";
+        readonly type: "bool";
+    }, {
+        readonly internalType: "address";
+        readonly name: "pool";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "deadline";
+        readonly type: "uint256";
+    }];
+    readonly name: "swapToBoundaryIziSwapHum_4KPMRG";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "amountIn";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "sqrtPriceLimitX96";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "address";
+        readonly name: "tokenIn";
+        readonly type: "address";
+    }, {
+        readonly internalType: "bool";
+        readonly name: "zeroForOne";
+        readonly type: "bool";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "fee";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "address";
+        readonly name: "pair";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "deadline";
+        readonly type: "uint256";
+    }];
+    readonly name: "swapTokensForTokensLimitOrderUniswapV2Hum";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "amountIn";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "sqrtPriceLimitX96";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "address";
+        readonly name: "tokenIn";
+        readonly type: "address";
+    }, {
+        readonly internalType: "bool";
+        readonly name: "zeroForOne";
+        readonly type: "bool";
+    }, {
+        readonly internalType: "address";
+        readonly name: "pool";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "deadline";
+        readonly type: "uint256";
+    }];
+    readonly name: "swapTokensForTokensLimitOrderUniswapV3Hum";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly components: readonly [{
+            readonly components: readonly [{
+                readonly internalType: "address";
+                readonly name: "currency0";
+                readonly type: "address";
+            }, {
+                readonly internalType: "address";
+                readonly name: "currency1";
+                readonly type: "address";
+            }, {
+                readonly internalType: "uint24";
+                readonly name: "fee";
+                readonly type: "uint24";
+            }, {
+                readonly internalType: "int24";
+                readonly name: "tickSpacing";
+                readonly type: "int24";
+            }, {
+                readonly internalType: "address";
+                readonly name: "hooks";
+                readonly type: "address";
+            }];
+            readonly internalType: "struct PoolKey";
+            readonly name: "key";
+            readonly type: "tuple";
+        }, {
+            readonly components: readonly [{
+                readonly internalType: "bool";
+                readonly name: "zeroForOne";
+                readonly type: "bool";
+            }, {
+                readonly internalType: "int256";
+                readonly name: "amountSpecified";
+                readonly type: "int256";
+            }, {
+                readonly internalType: "uint160";
+                readonly name: "sqrtPriceLimitX96";
+                readonly type: "uint160";
+            }];
+            readonly internalType: "struct SwapParams";
+            readonly name: "params";
+            readonly type: "tuple";
+        }];
+        readonly internalType: "struct Logic.V4SwapData";
+        readonly name: "data";
+        readonly type: "tuple";
+    }, {
+        readonly internalType: "address";
+        readonly name: "poolManager";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "deadline";
+        readonly type: "uint256";
+    }];
+    readonly name: "swapTokensForTokensLimitOrderUniswapV4Hum";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "x";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "y";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "data";
+        readonly type: "bytes";
+    }];
+    readonly name: "swapX2YCallback";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "x";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "y";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "data";
+        readonly type: "bytes";
+    }];
+    readonly name: "swapY2XCallback";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly name: "transferChainCoinProxyOwnerHum";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "token";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly name: "transferTokenProxyOwnerHum";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "int256";
+        readonly name: "amount0Delta";
+        readonly type: "int256";
+    }, {
+        readonly internalType: "int256";
+        readonly name: "amount1Delta";
+        readonly type: "int256";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "data";
+        readonly type: "bytes";
+    }];
+    readonly name: "uniswapV3SwapCallback";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes";
+        readonly name: "data";
+        readonly type: "bytes";
+    }];
+    readonly name: "unlockCallback";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes";
+        readonly name: "";
+        readonly type: "bytes";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "validateProxyHum";
+    readonly outputs: readonly [];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}];
+/**
+ * Type-safe ABI for Logic
+ */
+export type LogicAbi = typeof LogicAbi;
+/**
+ * Contract instance type for Logic
+ */
+export type LogicContract = any;
+/**
+ * Logic 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 { Logic } from 'Logic';
+ *
+ * const publicClient = createPublicClient({ chain: mainnet, transport: http() });
+ * const walletClient = createWalletClient({ chain: mainnet, transport: http() });
+ *
+ * const contract = new Logic('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 Logic {
+    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(): LogicContract;
+    /**
+     * WHITELIST_MANAGER
+     * view
+     */
+    WHITELIST_MANAGER(): Promise<`0x${string}`>;
+    /**
+     * isWhitelistedBotAddress
+     * view
+     */
+    isWhitelistedBotAddress(arg0: `0x${string}`): Promise<boolean>;
+    /**
+     * isWhitelistedPairAddress
+     * view
+     */
+    isWhitelistedPairAddress(arg0: `0x${string}`): Promise<boolean>;
+    /**
+     * isWhitelistedPoolHash
+     * view
+     */
+    isWhitelistedPoolHash(arg0: `0x${string}`): Promise<boolean>;
+    /**
+     * isWhitelistedPoolHook
+     * view
+     */
+    isWhitelistedPoolHook(arg0: `0x${string}`): Promise<boolean>;
+    /**
+     * isWhitelistedRouterAddress
+     * view
+     */
+    isWhitelistedRouterAddress(arg0: `0x${string}`): Promise<boolean>;
+    /**
+     * isWhitelistedSlot11Address_3HRmBk
+     * view
+     */
+    isWhitelistedSlot11Address_3HRmBk(arg0: `0x${string}`): Promise<boolean>;
+    /**
+     * isWhitelistedSlot3Address_7xvhmR
+     * view
+     */
+    isWhitelistedSlot3Address_7xvhmR(arg0: `0x${string}`): Promise<boolean>;
+    /**
+     * isWhitelistedTokenAddress
+     * view
+     */
+    isWhitelistedTokenAddress(arg0: `0x${string}`): Promise<boolean>;
+    /**
+     * isWhitelistedTransferAddress
+     * view
+     */
+    isWhitelistedTransferAddress(arg0: `0x${string}`): Promise<boolean>;
+    /**
+     * isWhitelistedUniswapV3FactoryAddress
+     * view
+     */
+    isWhitelistedUniswapV3FactoryAddress(arg0: `0x${string}`): Promise<boolean>;
+    /**
+     * isWhitelistedUniswapV3PoolAddress
+     * view
+     */
+    isWhitelistedUniswapV3PoolAddress(arg0: `0x${string}`): Promise<boolean>;
+    /**
+     * isWhitelistedUniswapV3PositionManagerAddress
+     * view
+     */
+    isWhitelistedUniswapV3PositionManagerAddress(arg0: `0x${string}`): Promise<boolean>;
+    /**
+     * slot9ValueOf_A7ULVH
+     * view
+     */
+    slot9ValueOf_A7ULVH(arg0: `0x${string}`): Promise<bigint>;
+    /**
+     * validateProxyHum
+     * view
+     */
+    validateProxyHum(): Promise<void>;
+    /**
+     * addWhitelistedAlgebraCustomPoolAddressesHum_1T0MDH
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    addWhitelistedAlgebraCustomPoolAddressesHum_1T0MDH(deployer: `0x${string}`, pools: `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}`>;
+    /**
+     * addWhitelistedBotAddressesHum
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    addWhitelistedBotAddressesHum(bots: `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}`>;
+    /**
+     * addWhitelistedPairAddressesHum
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    addWhitelistedPairAddressesHum(pairs: `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}`>;
+    /**
+     * addWhitelistedTokenAddressesHum
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    addWhitelistedTokenAddressesHum(accounts: `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}`>;
+    /**
+     * addWhitelistedTransferAddressesHum
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    addWhitelistedTransferAddressesHum(accounts: `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}`>;
+    /**
+     * addWhitelistedUniswapV3FactoryHum
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    addWhitelistedUniswapV3FactoryHum(factories: `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}`>;
+    /**
+     * addWhitelistedUniswapV3PoolAddressesHum
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    addWhitelistedUniswapV3PoolAddressesHum(pools: `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}`>;
+    /**
+     * addWhitelistedUniswapV3PositionManagerHum
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    addWhitelistedUniswapV3PositionManagerHum(accounts: `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}`>;
+    /**
+     * addWhitelistedUniswapV4HooksHum
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    addWhitelistedUniswapV4HooksHum(hooks: `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}`>;
+    /**
+     * addWhitelistedUniswapV4PoolsHum
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    addWhitelistedUniswapV4PoolsHum(poolManager: `0x${string}`, keys: `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}`>;
+    /**
+     * algebraSwapCallback
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    algebraSwapCallback(amount0Delta: bigint, amount1Delta: bigint, data: `0x${string}`, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+    }): Promise<`0x${string}`>;
+    /**
+     * migrateTokensProxyOwnerHum
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    migrateTokensProxyOwnerHum(tokens: `0x${string}`[], newProxy: `0x${string}`, newProxyOwner: `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}`>;
+    /**
+     * pancakeV3SwapCallback
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    pancakeV3SwapCallback(amount0Delta: bigint, amount1Delta: bigint, data: `0x${string}`, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+    }): Promise<`0x${string}`>;
+    /**
+     * ramsesV2SwapCallback
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    ramsesV2SwapCallback(amount0Delta: bigint, amount1Delta: bigint, data: `0x${string}`, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+    }): Promise<`0x${string}`>;
+    /**
+     * removeWhitelistedBotAddressesHum
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    removeWhitelistedBotAddressesHum(bots: `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}`>;
+    /**
+     * removeWhitelistedPairAddressesHum
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    removeWhitelistedPairAddressesHum(pairs: `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}`>;
+    /**
+     * removeWhitelistedTokenAddressesHum
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    removeWhitelistedTokenAddressesHum(accounts: `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}`>;
+    /**
+     * removeWhitelistedTransferAddressesHum
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    removeWhitelistedTransferAddressesHum(accounts: `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}`>;
+    /**
+     * removeWhitelistedUniswapV3FactoryHum
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    removeWhitelistedUniswapV3FactoryHum(factories: `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}`>;
+    /**
+     * removeWhitelistedUniswapV3PoolAddressesHum
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    removeWhitelistedUniswapV3PoolAddressesHum(pools: `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}`>;
+    /**
+     * removeWhitelistedUniswapV3PositionManagerHum
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    removeWhitelistedUniswapV3PositionManagerHum(accounts: `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}`>;
+    /**
+     * removeWhitelistedUniswapV4HooksHum
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    removeWhitelistedUniswapV4HooksHum(hooks: `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}`>;
+    /**
+     * removeWhitelistedUniswapV4PoolsHum
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    removeWhitelistedUniswapV4PoolsHum(poolManager: `0x${string}`, keys: `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}`>;
+    /**
+     * squadV3SwapCallback
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    squadV3SwapCallback(amount0Delta: bigint, amount1Delta: bigint, data: `0x${string}`, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+    }): Promise<`0x${string}`>;
+    /**
+     * swapExactTokensForTokensUniswapV3Hum
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    swapExactTokensForTokensUniswapV3Hum(amountIn: bigint, tokenIn: `0x${string}`, amountOutMin: bigint, zeroForOne: boolean, pool: `0x${string}`, deadline: 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}`>;
+    /**
+     * swapExactTokensForTokensUniswapV4Hum
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    swapExactTokensForTokensUniswapV4Hum(data: Logic_V4SwapData, poolManager: `0x${string}`, amountOutMin: bigint, deadline: 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}`>;
+    /**
+     * swapToBoundaryIziSwapHum_4KPMRG
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    swapToBoundaryIziSwapHum_4KPMRG(amount: bigint, boundaryPoint: bigint, tokenIn: `0x${string}`, x2y: boolean, pool: `0x${string}`, deadline: 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}`>;
+    /**
+     * swapTokensForTokensLimitOrderUniswapV2Hum
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    swapTokensForTokensLimitOrderUniswapV2Hum(amountIn: bigint, sqrtPriceLimitX96: bigint, tokenIn: `0x${string}`, zeroForOne: boolean, fee: bigint, pair: `0x${string}`, deadline: 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}`>;
+    /**
+     * swapTokensForTokensLimitOrderUniswapV3Hum
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    swapTokensForTokensLimitOrderUniswapV3Hum(amountIn: bigint, sqrtPriceLimitX96: bigint, tokenIn: `0x${string}`, zeroForOne: boolean, pool: `0x${string}`, deadline: 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}`>;
+    /**
+     * swapTokensForTokensLimitOrderUniswapV4Hum
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    swapTokensForTokensLimitOrderUniswapV4Hum(data: Logic_V4SwapData, poolManager: `0x${string}`, deadline: 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}`>;
+    /**
+     * swapX2YCallback
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    swapX2YCallback(x: bigint, y: bigint, data: `0x${string}`, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+    }): Promise<`0x${string}`>;
+    /**
+     * swapY2XCallback
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    swapY2XCallback(x: bigint, y: bigint, data: `0x${string}`, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+    }): Promise<`0x${string}`>;
+    /**
+     * transferChainCoinProxyOwnerHum
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    transferChainCoinProxyOwnerHum(to: `0x${string}`, amount: 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}`>;
+    /**
+     * transferTokenProxyOwnerHum
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    transferTokenProxyOwnerHum(token: `0x${string}`, to: `0x${string}`, amount: 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}`>;
+    /**
+     * uniswapV3SwapCallback
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    uniswapV3SwapCallback(amount0Delta: bigint, amount1Delta: bigint, data: `0x${string}`, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+    }): Promise<`0x${string}`>;
+    /**
+     * unlockCallback
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    unlockCallback(data: `0x${string}`, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+    }): Promise<`0x${string}`>;
+    /**
+     * 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 addWhitelistedAlgebraCustomPoolAddressesHum_1T0MDH
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        addWhitelistedAlgebraCustomPoolAddressesHum_1T0MDH(deployer: `0x${string}`, pools: `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 addWhitelistedBotAddressesHum
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        addWhitelistedBotAddressesHum(bots: `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 addWhitelistedPairAddressesHum
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        addWhitelistedPairAddressesHum(pairs: `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 addWhitelistedTokenAddressesHum
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        addWhitelistedTokenAddressesHum(accounts: `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 addWhitelistedTransferAddressesHum
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        addWhitelistedTransferAddressesHum(accounts: `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 addWhitelistedUniswapV3FactoryHum
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        addWhitelistedUniswapV3FactoryHum(factories: `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 addWhitelistedUniswapV3PoolAddressesHum
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        addWhitelistedUniswapV3PoolAddressesHum(pools: `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 addWhitelistedUniswapV3PositionManagerHum
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        addWhitelistedUniswapV3PositionManagerHum(accounts: `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 addWhitelistedUniswapV4HooksHum
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        addWhitelistedUniswapV4HooksHum(hooks: `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 addWhitelistedUniswapV4PoolsHum
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        addWhitelistedUniswapV4PoolsHum(poolManager: `0x${string}`, keys: `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 algebraSwapCallback
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        algebraSwapCallback(amount0Delta: bigint, amount1Delta: bigint, data: `0x${string}`, options?: {
+            accessList?: import("viem").AccessList;
+            authorizationList?: import("viem").AuthorizationList;
+            chain?: import("viem").Chain | null;
+            dataSuffix?: `0x${string}`;
+            gas?: bigint;
+            gasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+            nonce?: number;
+            value?: bigint;
+        }): Promise<void>;
+        /**
+         * Simulate migrateTokensProxyOwnerHum
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        migrateTokensProxyOwnerHum(tokens: `0x${string}`[], newProxy: `0x${string}`, newProxyOwner: `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 pancakeV3SwapCallback
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        pancakeV3SwapCallback(amount0Delta: bigint, amount1Delta: bigint, data: `0x${string}`, options?: {
+            accessList?: import("viem").AccessList;
+            authorizationList?: import("viem").AuthorizationList;
+            chain?: import("viem").Chain | null;
+            dataSuffix?: `0x${string}`;
+            gas?: bigint;
+            gasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+            nonce?: number;
+            value?: bigint;
+        }): Promise<void>;
+        /**
+         * Simulate ramsesV2SwapCallback
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        ramsesV2SwapCallback(amount0Delta: bigint, amount1Delta: bigint, data: `0x${string}`, options?: {
+            accessList?: import("viem").AccessList;
+            authorizationList?: import("viem").AuthorizationList;
+            chain?: import("viem").Chain | null;
+            dataSuffix?: `0x${string}`;
+            gas?: bigint;
+            gasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+            nonce?: number;
+            value?: bigint;
+        }): Promise<void>;
+        /**
+         * Simulate removeWhitelistedBotAddressesHum
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        removeWhitelistedBotAddressesHum(bots: `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 removeWhitelistedPairAddressesHum
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        removeWhitelistedPairAddressesHum(pairs: `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 removeWhitelistedTokenAddressesHum
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        removeWhitelistedTokenAddressesHum(accounts: `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 removeWhitelistedTransferAddressesHum
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        removeWhitelistedTransferAddressesHum(accounts: `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 removeWhitelistedUniswapV3FactoryHum
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        removeWhitelistedUniswapV3FactoryHum(factories: `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 removeWhitelistedUniswapV3PoolAddressesHum
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        removeWhitelistedUniswapV3PoolAddressesHum(pools: `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 removeWhitelistedUniswapV3PositionManagerHum
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        removeWhitelistedUniswapV3PositionManagerHum(accounts: `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 removeWhitelistedUniswapV4HooksHum
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        removeWhitelistedUniswapV4HooksHum(hooks: `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 removeWhitelistedUniswapV4PoolsHum
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        removeWhitelistedUniswapV4PoolsHum(poolManager: `0x${string}`, keys: `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 squadV3SwapCallback
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        squadV3SwapCallback(amount0Delta: bigint, amount1Delta: bigint, data: `0x${string}`, options?: {
+            accessList?: import("viem").AccessList;
+            authorizationList?: import("viem").AuthorizationList;
+            chain?: import("viem").Chain | null;
+            dataSuffix?: `0x${string}`;
+            gas?: bigint;
+            gasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+            nonce?: number;
+            value?: bigint;
+        }): Promise<void>;
+        /**
+         * Simulate swapExactTokensForTokensUniswapV3Hum
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        swapExactTokensForTokensUniswapV3Hum(amountIn: bigint, tokenIn: `0x${string}`, amountOutMin: bigint, zeroForOne: boolean, pool: `0x${string}`, deadline: 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 swapExactTokensForTokensUniswapV4Hum
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        swapExactTokensForTokensUniswapV4Hum(data: Logic_V4SwapData, poolManager: `0x${string}`, amountOutMin: bigint, deadline: 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 swapToBoundaryIziSwapHum_4KPMRG
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        swapToBoundaryIziSwapHum_4KPMRG(amount: bigint, boundaryPoint: bigint, tokenIn: `0x${string}`, x2y: boolean, pool: `0x${string}`, deadline: 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 swapTokensForTokensLimitOrderUniswapV2Hum
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        swapTokensForTokensLimitOrderUniswapV2Hum(amountIn: bigint, sqrtPriceLimitX96: bigint, tokenIn: `0x${string}`, zeroForOne: boolean, fee: bigint, pair: `0x${string}`, deadline: 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 swapTokensForTokensLimitOrderUniswapV3Hum
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        swapTokensForTokensLimitOrderUniswapV3Hum(amountIn: bigint, sqrtPriceLimitX96: bigint, tokenIn: `0x${string}`, zeroForOne: boolean, pool: `0x${string}`, deadline: 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 swapTokensForTokensLimitOrderUniswapV4Hum
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        swapTokensForTokensLimitOrderUniswapV4Hum(data: Logic_V4SwapData, poolManager: `0x${string}`, deadline: 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 swapX2YCallback
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        swapX2YCallback(x: bigint, y: bigint, data: `0x${string}`, options?: {
+            accessList?: import("viem").AccessList;
+            authorizationList?: import("viem").AuthorizationList;
+            chain?: import("viem").Chain | null;
+            dataSuffix?: `0x${string}`;
+            gas?: bigint;
+            gasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+            nonce?: number;
+            value?: bigint;
+        }): Promise<void>;
+        /**
+         * Simulate swapY2XCallback
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        swapY2XCallback(x: bigint, y: bigint, data: `0x${string}`, options?: {
+            accessList?: import("viem").AccessList;
+            authorizationList?: import("viem").AuthorizationList;
+            chain?: import("viem").Chain | null;
+            dataSuffix?: `0x${string}`;
+            gas?: bigint;
+            gasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+            nonce?: number;
+            value?: bigint;
+        }): Promise<void>;
+        /**
+         * Simulate transferChainCoinProxyOwnerHum
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        transferChainCoinProxyOwnerHum(to: `0x${string}`, amount: 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 transferTokenProxyOwnerHum
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        transferTokenProxyOwnerHum(token: `0x${string}`, to: `0x${string}`, amount: 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 uniswapV3SwapCallback
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        uniswapV3SwapCallback(amount0Delta: bigint, amount1Delta: bigint, data: `0x${string}`, options?: {
+            accessList?: import("viem").AccessList;
+            authorizationList?: import("viem").AuthorizationList;
+            chain?: import("viem").Chain | null;
+            dataSuffix?: `0x${string}`;
+            gas?: bigint;
+            gasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+            nonce?: number;
+            value?: bigint;
+        }): Promise<void>;
+        /**
+         * Simulate unlockCallback
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        unlockCallback(data: `0x${string}`, options?: {
+            accessList?: import("viem").AccessList;
+            authorizationList?: import("viem").AuthorizationList;
+            chain?: import("viem").Chain | null;
+            dataSuffix?: `0x${string}`;
+            gas?: bigint;
+            gasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+            nonce?: number;
+            value?: bigint;
+        }): Promise<`0x${string}`>;
+    };
+    /**
+     * Watch contract events
+     *
+     * Note: This contract has no events, so watch returns an empty object.
+     */
+    get watch(): {};
+}