@gitmyabi/yspendle-lpt 1.0.0

package/contracts/PendleLPCompounder_json.ts

@@ -0,0 +1,2181 @@
+import type { Abi, Address, PublicClient, WalletClient, GetContractReturnType } from 'viem';
+import { getContract } from 'viem';
+
+/**
+ * PendleLPCompounder_json ABI
+ * 
+ * This ABI is typed using viem's type system for full type safety.
+ */
+export const PendleLPCompounder_jsonAbi = [
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "_asset",
+        "type": "address"
+      },
+      {
+        "internalType": "address",
+        "name": "_pendleStaking",
+        "type": "address"
+      },
+      {
+        "internalType": "address",
+        "name": "_PENDLE",
+        "type": "address"
+      },
+      {
+        "internalType": "uint24",
+        "name": "_feePENDLEtoBase",
+        "type": "uint24"
+      },
+      {
+        "internalType": "address",
+        "name": "_base",
+        "type": "address"
+      },
+      {
+        "internalType": "uint24",
+        "name": "_feeBaseToTargetToken",
+        "type": "uint24"
+      },
+      {
+        "internalType": "address",
+        "name": "_targetToken",
+        "type": "address"
+      },
+      {
+        "internalType": "address",
+        "name": "_GOV",
+        "type": "address"
+      },
+      {
+        "internalType": "string",
+        "name": "_name",
+        "type": "string"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "constructor"
+  },
+  {
+    "stateMutability": "nonpayable",
+    "type": "fallback"
+  },
+  {
+    "inputs": [],
+    "name": "GOV",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "_rewardToken",
+        "type": "address"
+      },
+      {
+        "internalType": "uint24",
+        "name": "_feeRewardTokenToBase",
+        "type": "uint24"
+      }
+    ],
+    "name": "addReward",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "auction",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "auctionFactory",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "_token",
+        "type": "address"
+      }
+    ],
+    "name": "auctionKicked",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "autocompound",
+    "outputs": [
+      {
+        "internalType": "bool",
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "name": "availableDepositLimit",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "name": "availableWithdrawLimit",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "balanceAsset",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "balanceStaked",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "base",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "claimRewards",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "_amount",
+        "type": "uint256"
+      }
+    ],
+    "name": "deployFunds",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "doHealthCheck",
+    "outputs": [
+      {
+        "internalType": "bool",
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "_amount",
+        "type": "uint256"
+      }
+    ],
+    "name": "freeFunds",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "harvestAndReport",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "_totalAssets",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "isExpired",
+    "outputs": [
+      {
+        "internalType": "bool",
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "_token",
+        "type": "address"
+      }
+    ],
+    "name": "kickable",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "lossLimitRatio",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "minAmountToSell",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "name": "minAmountToSellMapping",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "_token",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "_amountTaken",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "_amountPayed",
+        "type": "uint256"
+      }
+    ],
+    "name": "postTake",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "_token",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "_amountToTake",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "_amountToPay",
+        "type": "uint256"
+      }
+    ],
+    "name": "preTake",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "profitLimitRatio",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "_rewardToken",
+        "type": "address"
+      }
+    ],
+    "name": "removeReward",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "removeTradeFactory",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "rewardTokens",
+    "outputs": [
+      {
+        "internalType": "address[]",
+        "name": "",
+        "type": "address[]"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "router",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "routerParams",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "guessMin",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "guessMax",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "guessOffchain",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "maxIteration",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "eps",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "_auction",
+        "type": "address"
+      }
+    ],
+    "name": "setAuction",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "bool",
+        "name": "_autocompound",
+        "type": "bool"
+      }
+    ],
+    "name": "setAutocompound",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "bool",
+        "name": "_doHealthCheck",
+        "type": "bool"
+      }
+    ],
+    "name": "setDoHealthCheck",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "_newLossLimitRatio",
+        "type": "uint256"
+      }
+    ],
+    "name": "setLossLimitRatio",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "_token",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "_amount",
+        "type": "uint256"
+      }
+    ],
+    "name": "setMinAmountToSellMapping",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "_newProfitLimitRatio",
+        "type": "uint256"
+      }
+    ],
+    "name": "setProfitLimitRatio",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "_guessMin",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "_guessMax",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "_maxIteration",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "_eps",
+        "type": "uint256"
+      }
+    ],
+    "name": "setRouterParams",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "_tradeFactory",
+        "type": "address"
+      },
+      {
+        "internalType": "bool",
+        "name": "_useTradeFactory",
+        "type": "bool"
+      }
+    ],
+    "name": "setTradeFactory",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "_token0",
+        "type": "address"
+      },
+      {
+        "internalType": "address",
+        "name": "_token1",
+        "type": "address"
+      },
+      {
+        "internalType": "uint24",
+        "name": "_fee",
+        "type": "uint24"
+      }
+    ],
+    "name": "setUniFees",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "bool",
+        "name": "_useAuction",
+        "type": "bool"
+      }
+    ],
+    "name": "setUseAuction",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "bool",
+        "name": "_useTradeFactory",
+        "type": "bool"
+      }
+    ],
+    "name": "setUseTradeFactory",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "_amount",
+        "type": "uint256"
+      }
+    ],
+    "name": "shutdownWithdraw",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "_token",
+        "type": "address"
+      }
+    ],
+    "name": "sweep",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "targetToken",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "_totalIdle",
+        "type": "uint256"
+      }
+    ],
+    "name": "tendThis",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "tendTrigger",
+    "outputs": [
+      {
+        "internalType": "bool",
+        "name": "",
+        "type": "bool"
+      },
+      {
+        "internalType": "bytes",
+        "name": "",
+        "type": "bytes"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "tokenizedStrategyAddress",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "tradeFactory",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      },
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "name": "uniFees",
+    "outputs": [
+      {
+        "internalType": "uint24",
+        "name": "",
+        "type": "uint24"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "unwrapTargetTokenToSY",
+    "outputs": [
+      {
+        "internalType": "bool",
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "useAuction",
+    "outputs": [
+      {
+        "internalType": "bool",
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "useTradeFactory",
+    "outputs": [
+      {
+        "internalType": "bool",
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "stateMutability": "payable",
+    "type": "receive"
+  }
+] as const satisfies Abi;
+
+/**
+ * Type-safe ABI for PendleLPCompounder_json
+ */
+export type PendleLPCompounder_jsonAbi = typeof PendleLPCompounder_jsonAbi;
+
+/**
+ * Contract instance type for PendleLPCompounder_json
+ */
+// Use any for contract type to avoid complex viem type issues
+// The runtime behavior is type-safe through viem's ABI typing
+export type PendleLPCompounder_jsonContract = any;
+
+/**
+ * PendleLPCompounder_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 { PendleLPCompounder_json } from 'PendleLPCompounder_json';
+ * 
+ * const publicClient = createPublicClient({ chain: mainnet, transport: http() });
+ * const walletClient = createWalletClient({ chain: mainnet, transport: http() });
+ * 
+ * const contract = new PendleLPCompounder_json('0x...', { publicClient, walletClient });
+ * 
+ * // Read functions
+ * const result = await contract.balanceOf('0x...');
+ * 
+ * // Write functions
+ * const hash = await contract.transfer('0x...', 1000n);
+ * 
+ * // Simulate transactions (dry-run)
+ * const simulation = await contract.simulate.transfer('0x...', 1000n);
+ * console.log('Gas estimate:', simulation.request.gas);
+ * 
+ * // Watch events
+ * const unwatch = contract.watch.Transfer((event) => {
+ *   console.log('Transfer event:', event);
+ * });
+ * ```
+ */
+export class PendleLPCompounder_json {
+  private contract: PendleLPCompounder_jsonContract;
+  private contractAddress: Address;
+  private publicClient: PublicClient;
+
+  constructor(
+    address: Address,
+    clients: {
+      publicClient: PublicClient;
+      walletClient?: WalletClient;
+    }
+  ) {
+    this.contractAddress = address;
+    this.publicClient = clients.publicClient;
+    this.contract = getContract({
+      address,
+      abi: PendleLPCompounder_jsonAbi,
+      client: {
+        public: clients.publicClient,
+        wallet: clients.walletClient,
+      },
+    });
+  }
+
+  /**
+   * Get the contract address
+   */
+  get address(): Address {
+    return this.contractAddress;
+  }
+
+  /**
+   * Get the underlying viem contract instance
+   */
+  getContract(): PendleLPCompounder_jsonContract {
+    return this.contract;
+  }
+
+  /**
+   * GOV
+   * view
+   */
+  async GOV(): Promise<`0x${string}`> {
+    return this.contract.read.GOV() as Promise<`0x${string}`>;
+  }
+
+  /**
+   * auction
+   * view
+   */
+  async auction(): Promise<`0x${string}`> {
+    return this.contract.read.auction() as Promise<`0x${string}`>;
+  }
+
+  /**
+   * auctionFactory
+   * view
+   */
+  async auctionFactory(): Promise<`0x${string}`> {
+    return this.contract.read.auctionFactory() as Promise<`0x${string}`>;
+  }
+
+  /**
+   * autocompound
+   * view
+   */
+  async autocompound(): Promise<boolean> {
+    return this.contract.read.autocompound() as Promise<boolean>;
+  }
+
+  /**
+   * availableDepositLimit
+   * view
+   */
+  async availableDepositLimit(arg0: `0x${string}`): Promise<bigint> {
+    return this.contract.read.availableDepositLimit([arg0] as const) as Promise<bigint>;
+  }
+
+  /**
+   * availableWithdrawLimit
+   * view
+   */
+  async availableWithdrawLimit(arg0: `0x${string}`): Promise<bigint> {
+    return this.contract.read.availableWithdrawLimit([arg0] as const) as Promise<bigint>;
+  }
+
+  /**
+   * balanceAsset
+   * view
+   */
+  async balanceAsset(): Promise<bigint> {
+    return this.contract.read.balanceAsset() as Promise<bigint>;
+  }
+
+  /**
+   * balanceStaked
+   * view
+   */
+  async balanceStaked(): Promise<bigint> {
+    return this.contract.read.balanceStaked() as Promise<bigint>;
+  }
+
+  /**
+   * base
+   * view
+   */
+  async base(): Promise<`0x${string}`> {
+    return this.contract.read.base() as Promise<`0x${string}`>;
+  }
+
+  /**
+   * doHealthCheck
+   * view
+   */
+  async doHealthCheck(): Promise<boolean> {
+    return this.contract.read.doHealthCheck() as Promise<boolean>;
+  }
+
+  /**
+   * isExpired
+   * view
+   */
+  async isExpired(): Promise<boolean> {
+    return this.contract.read.isExpired() as Promise<boolean>;
+  }
+
+  /**
+   * kickable
+   * view
+   */
+  async kickable(_token: `0x${string}`): Promise<bigint> {
+    return this.contract.read.kickable([_token] as const) as Promise<bigint>;
+  }
+
+  /**
+   * lossLimitRatio
+   * view
+   */
+  async lossLimitRatio(): Promise<bigint> {
+    return this.contract.read.lossLimitRatio() as Promise<bigint>;
+  }
+
+  /**
+   * minAmountToSell
+   * view
+   */
+  async minAmountToSell(): Promise<bigint> {
+    return this.contract.read.minAmountToSell() as Promise<bigint>;
+  }
+
+  /**
+   * minAmountToSellMapping
+   * view
+   */
+  async minAmountToSellMapping(arg0: `0x${string}`): Promise<bigint> {
+    return this.contract.read.minAmountToSellMapping([arg0] as const) as Promise<bigint>;
+  }
+
+  /**
+   * profitLimitRatio
+   * view
+   */
+  async profitLimitRatio(): Promise<bigint> {
+    return this.contract.read.profitLimitRatio() as Promise<bigint>;
+  }
+
+  /**
+   * rewardTokens
+   * view
+   */
+  async rewardTokens(): Promise<`0x${string}`[]> {
+    return this.contract.read.rewardTokens() as Promise<`0x${string}`[]>;
+  }
+
+  /**
+   * router
+   * view
+   */
+  async router(): Promise<`0x${string}`> {
+    return this.contract.read.router() as Promise<`0x${string}`>;
+  }
+
+  /**
+   * routerParams
+   * view
+   */
+  async routerParams(): Promise<[bigint, bigint, bigint, bigint, bigint]> {
+    return this.contract.read.routerParams() as Promise<[bigint, bigint, bigint, bigint, bigint]>;
+  }
+
+  /**
+   * targetToken
+   * view
+   */
+  async targetToken(): Promise<`0x${string}`> {
+    return this.contract.read.targetToken() as Promise<`0x${string}`>;
+  }
+
+  /**
+   * tendTrigger
+   * view
+   */
+  async tendTrigger(): Promise<[boolean, `0x${string}`]> {
+    return this.contract.read.tendTrigger() as Promise<[boolean, `0x${string}`]>;
+  }
+
+  /**
+   * tokenizedStrategyAddress
+   * view
+   */
+  async tokenizedStrategyAddress(): Promise<`0x${string}`> {
+    return this.contract.read.tokenizedStrategyAddress() as Promise<`0x${string}`>;
+  }
+
+  /**
+   * tradeFactory
+   * view
+   */
+  async tradeFactory(): Promise<`0x${string}`> {
+    return this.contract.read.tradeFactory() as Promise<`0x${string}`>;
+  }
+
+  /**
+   * uniFees
+   * view
+   */
+  async uniFees(arg0: `0x${string}`, arg1: `0x${string}`): Promise<bigint> {
+    return this.contract.read.uniFees([arg0, arg1] as const) as Promise<bigint>;
+  }
+
+  /**
+   * unwrapTargetTokenToSY
+   * view
+   */
+  async unwrapTargetTokenToSY(): Promise<boolean> {
+    return this.contract.read.unwrapTargetTokenToSY() as Promise<boolean>;
+  }
+
+  /**
+   * useAuction
+   * view
+   */
+  async useAuction(): Promise<boolean> {
+    return this.contract.read.useAuction() as Promise<boolean>;
+  }
+
+  /**
+   * useTradeFactory
+   * view
+   */
+  async useTradeFactory(): Promise<boolean> {
+    return this.contract.read.useTradeFactory() as Promise<boolean>;
+  }
+
+  /**
+   * addReward
+   * nonpayable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   */
+  async addReward(_rewardToken: `0x${string}`, _feeRewardTokenToBase: bigint, options?: {
+    accessList?: import('viem').AccessList;
+    authorizationList?: import('viem').AuthorizationList;
+    chain?: import('viem').Chain | null;
+    dataSuffix?: `0x${string}`;
+    gas?: bigint;
+    gasPrice?: bigint;
+    maxFeePerGas?: bigint;
+    maxPriorityFeePerGas?: bigint;
+    nonce?: number;
+    value?: bigint;
+  }): Promise<`0x${string}`> {
+    if (!this.contract.write) {
+      throw new Error('Wallet client is required for write operations');
+    }
+    return this.contract.write.addReward([_rewardToken, _feeRewardTokenToBase] as const, options) as Promise<`0x${string}`>;
+  }
+
+  /**
+   * auctionKicked
+   * nonpayable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   */
+  async auctionKicked(_token: `0x${string}`, options?: {
+    accessList?: import('viem').AccessList;
+    authorizationList?: import('viem').AuthorizationList;
+    chain?: import('viem').Chain | null;
+    dataSuffix?: `0x${string}`;
+    gas?: bigint;
+    gasPrice?: bigint;
+    maxFeePerGas?: bigint;
+    maxPriorityFeePerGas?: bigint;
+    nonce?: number;
+    value?: bigint;
+  }): Promise<`0x${string}`> {
+    if (!this.contract.write) {
+      throw new Error('Wallet client is required for write operations');
+    }
+    return this.contract.write.auctionKicked([_token] as const, options) as Promise<`0x${string}`>;
+  }
+
+  /**
+   * claimRewards
+   * nonpayable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   */
+  async claimRewards(options?: {
+    accessList?: import('viem').AccessList;
+    authorizationList?: import('viem').AuthorizationList;
+    chain?: import('viem').Chain | null;
+    dataSuffix?: `0x${string}`;
+    gas?: bigint;
+    gasPrice?: bigint;
+    maxFeePerGas?: bigint;
+    maxPriorityFeePerGas?: bigint;
+    nonce?: number;
+    value?: bigint;
+  }): Promise<`0x${string}`> {
+    if (!this.contract.write) {
+      throw new Error('Wallet client is required for write operations');
+    }
+    return this.contract.write.claimRewards(options) as Promise<`0x${string}`>;
+  }
+
+  /**
+   * deployFunds
+   * nonpayable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   */
+  async deployFunds(_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}`> {
+    if (!this.contract.write) {
+      throw new Error('Wallet client is required for write operations');
+    }
+    return this.contract.write.deployFunds([_amount] as const, options) as Promise<`0x${string}`>;
+  }
+
+  /**
+   * freeFunds
+   * nonpayable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   */
+  async freeFunds(_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}`> {
+    if (!this.contract.write) {
+      throw new Error('Wallet client is required for write operations');
+    }
+    return this.contract.write.freeFunds([_amount] as const, options) as Promise<`0x${string}`>;
+  }
+
+  /**
+   * harvestAndReport
+   * nonpayable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   */
+  async harvestAndReport(options?: {
+    accessList?: import('viem').AccessList;
+    authorizationList?: import('viem').AuthorizationList;
+    chain?: import('viem').Chain | null;
+    dataSuffix?: `0x${string}`;
+    gas?: bigint;
+    gasPrice?: bigint;
+    maxFeePerGas?: bigint;
+    maxPriorityFeePerGas?: bigint;
+    nonce?: number;
+    value?: bigint;
+  }): Promise<`0x${string}`> {
+    if (!this.contract.write) {
+      throw new Error('Wallet client is required for write operations');
+    }
+    return this.contract.write.harvestAndReport(options) as Promise<`0x${string}`>;
+  }
+
+  /**
+   * postTake
+   * nonpayable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   */
+  async postTake(_token: `0x${string}`, _amountTaken: bigint, _amountPayed: bigint, options?: {
+    accessList?: import('viem').AccessList;
+    authorizationList?: import('viem').AuthorizationList;
+    chain?: import('viem').Chain | null;
+    dataSuffix?: `0x${string}`;
+    gas?: bigint;
+    gasPrice?: bigint;
+    maxFeePerGas?: bigint;
+    maxPriorityFeePerGas?: bigint;
+    nonce?: number;
+    value?: bigint;
+  }): Promise<`0x${string}`> {
+    if (!this.contract.write) {
+      throw new Error('Wallet client is required for write operations');
+    }
+    return this.contract.write.postTake([_token, _amountTaken, _amountPayed] as const, options) as Promise<`0x${string}`>;
+  }
+
+  /**
+   * preTake
+   * nonpayable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   */
+  async preTake(_token: `0x${string}`, _amountToTake: bigint, _amountToPay: bigint, options?: {
+    accessList?: import('viem').AccessList;
+    authorizationList?: import('viem').AuthorizationList;
+    chain?: import('viem').Chain | null;
+    dataSuffix?: `0x${string}`;
+    gas?: bigint;
+    gasPrice?: bigint;
+    maxFeePerGas?: bigint;
+    maxPriorityFeePerGas?: bigint;
+    nonce?: number;
+    value?: bigint;
+  }): Promise<`0x${string}`> {
+    if (!this.contract.write) {
+      throw new Error('Wallet client is required for write operations');
+    }
+    return this.contract.write.preTake([_token, _amountToTake, _amountToPay] as const, options) as Promise<`0x${string}`>;
+  }
+
+  /**
+   * removeReward
+   * nonpayable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   */
+  async removeReward(_rewardToken: `0x${string}`, options?: {
+    accessList?: import('viem').AccessList;
+    authorizationList?: import('viem').AuthorizationList;
+    chain?: import('viem').Chain | null;
+    dataSuffix?: `0x${string}`;
+    gas?: bigint;
+    gasPrice?: bigint;
+    maxFeePerGas?: bigint;
+    maxPriorityFeePerGas?: bigint;
+    nonce?: number;
+    value?: bigint;
+  }): Promise<`0x${string}`> {
+    if (!this.contract.write) {
+      throw new Error('Wallet client is required for write operations');
+    }
+    return this.contract.write.removeReward([_rewardToken] as const, options) as Promise<`0x${string}`>;
+  }
+
+  /**
+   * removeTradeFactory
+   * nonpayable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   */
+  async removeTradeFactory(options?: {
+    accessList?: import('viem').AccessList;
+    authorizationList?: import('viem').AuthorizationList;
+    chain?: import('viem').Chain | null;
+    dataSuffix?: `0x${string}`;
+    gas?: bigint;
+    gasPrice?: bigint;
+    maxFeePerGas?: bigint;
+    maxPriorityFeePerGas?: bigint;
+    nonce?: number;
+    value?: bigint;
+  }): Promise<`0x${string}`> {
+    if (!this.contract.write) {
+      throw new Error('Wallet client is required for write operations');
+    }
+    return this.contract.write.removeTradeFactory(options) as Promise<`0x${string}`>;
+  }
+
+  /**
+   * setAuction
+   * nonpayable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   */
+  async setAuction(_auction: `0x${string}`, options?: {
+    accessList?: import('viem').AccessList;
+    authorizationList?: import('viem').AuthorizationList;
+    chain?: import('viem').Chain | null;
+    dataSuffix?: `0x${string}`;
+    gas?: bigint;
+    gasPrice?: bigint;
+    maxFeePerGas?: bigint;
+    maxPriorityFeePerGas?: bigint;
+    nonce?: number;
+    value?: bigint;
+  }): Promise<`0x${string}`> {
+    if (!this.contract.write) {
+      throw new Error('Wallet client is required for write operations');
+    }
+    return this.contract.write.setAuction([_auction] as const, options) as Promise<`0x${string}`>;
+  }
+
+  /**
+   * setAutocompound
+   * nonpayable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   */
+  async setAutocompound(_autocompound: boolean, options?: {
+    accessList?: import('viem').AccessList;
+    authorizationList?: import('viem').AuthorizationList;
+    chain?: import('viem').Chain | null;
+    dataSuffix?: `0x${string}`;
+    gas?: bigint;
+    gasPrice?: bigint;
+    maxFeePerGas?: bigint;
+    maxPriorityFeePerGas?: bigint;
+    nonce?: number;
+    value?: bigint;
+  }): Promise<`0x${string}`> {
+    if (!this.contract.write) {
+      throw new Error('Wallet client is required for write operations');
+    }
+    return this.contract.write.setAutocompound([_autocompound] as const, options) as Promise<`0x${string}`>;
+  }
+
+  /**
+   * setDoHealthCheck
+   * nonpayable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   */
+  async setDoHealthCheck(_doHealthCheck: boolean, options?: {
+    accessList?: import('viem').AccessList;
+    authorizationList?: import('viem').AuthorizationList;
+    chain?: import('viem').Chain | null;
+    dataSuffix?: `0x${string}`;
+    gas?: bigint;
+    gasPrice?: bigint;
+    maxFeePerGas?: bigint;
+    maxPriorityFeePerGas?: bigint;
+    nonce?: number;
+    value?: bigint;
+  }): Promise<`0x${string}`> {
+    if (!this.contract.write) {
+      throw new Error('Wallet client is required for write operations');
+    }
+    return this.contract.write.setDoHealthCheck([_doHealthCheck] as const, options) as Promise<`0x${string}`>;
+  }
+
+  /**
+   * setLossLimitRatio
+   * nonpayable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   */
+  async setLossLimitRatio(_newLossLimitRatio: bigint, options?: {
+    accessList?: import('viem').AccessList;
+    authorizationList?: import('viem').AuthorizationList;
+    chain?: import('viem').Chain | null;
+    dataSuffix?: `0x${string}`;
+    gas?: bigint;
+    gasPrice?: bigint;
+    maxFeePerGas?: bigint;
+    maxPriorityFeePerGas?: bigint;
+    nonce?: number;
+    value?: bigint;
+  }): Promise<`0x${string}`> {
+    if (!this.contract.write) {
+      throw new Error('Wallet client is required for write operations');
+    }
+    return this.contract.write.setLossLimitRatio([_newLossLimitRatio] as const, options) as Promise<`0x${string}`>;
+  }
+
+  /**
+   * setMinAmountToSellMapping
+   * nonpayable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   */
+  async setMinAmountToSellMapping(_token: `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}`> {
+    if (!this.contract.write) {
+      throw new Error('Wallet client is required for write operations');
+    }
+    return this.contract.write.setMinAmountToSellMapping([_token, _amount] as const, options) as Promise<`0x${string}`>;
+  }
+
+  /**
+   * setProfitLimitRatio
+   * nonpayable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   */
+  async setProfitLimitRatio(_newProfitLimitRatio: bigint, options?: {
+    accessList?: import('viem').AccessList;
+    authorizationList?: import('viem').AuthorizationList;
+    chain?: import('viem').Chain | null;
+    dataSuffix?: `0x${string}`;
+    gas?: bigint;
+    gasPrice?: bigint;
+    maxFeePerGas?: bigint;
+    maxPriorityFeePerGas?: bigint;
+    nonce?: number;
+    value?: bigint;
+  }): Promise<`0x${string}`> {
+    if (!this.contract.write) {
+      throw new Error('Wallet client is required for write operations');
+    }
+    return this.contract.write.setProfitLimitRatio([_newProfitLimitRatio] as const, options) as Promise<`0x${string}`>;
+  }
+
+  /**
+   * setRouterParams
+   * nonpayable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   */
+  async setRouterParams(_guessMin: bigint, _guessMax: bigint, _maxIteration: bigint, _eps: bigint, options?: {
+    accessList?: import('viem').AccessList;
+    authorizationList?: import('viem').AuthorizationList;
+    chain?: import('viem').Chain | null;
+    dataSuffix?: `0x${string}`;
+    gas?: bigint;
+    gasPrice?: bigint;
+    maxFeePerGas?: bigint;
+    maxPriorityFeePerGas?: bigint;
+    nonce?: number;
+    value?: bigint;
+  }): Promise<`0x${string}`> {
+    if (!this.contract.write) {
+      throw new Error('Wallet client is required for write operations');
+    }
+    return this.contract.write.setRouterParams([_guessMin, _guessMax, _maxIteration, _eps] as const, options) as Promise<`0x${string}`>;
+  }
+
+  /**
+   * setTradeFactory
+   * nonpayable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   */
+  async setTradeFactory(_tradeFactory: `0x${string}`, _useTradeFactory: boolean, options?: {
+    accessList?: import('viem').AccessList;
+    authorizationList?: import('viem').AuthorizationList;
+    chain?: import('viem').Chain | null;
+    dataSuffix?: `0x${string}`;
+    gas?: bigint;
+    gasPrice?: bigint;
+    maxFeePerGas?: bigint;
+    maxPriorityFeePerGas?: bigint;
+    nonce?: number;
+    value?: bigint;
+  }): Promise<`0x${string}`> {
+    if (!this.contract.write) {
+      throw new Error('Wallet client is required for write operations');
+    }
+    return this.contract.write.setTradeFactory([_tradeFactory, _useTradeFactory] as const, options) as Promise<`0x${string}`>;
+  }
+
+  /**
+   * setUniFees
+   * nonpayable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   */
+  async setUniFees(_token0: `0x${string}`, _token1: `0x${string}`, _fee: bigint, options?: {
+    accessList?: import('viem').AccessList;
+    authorizationList?: import('viem').AuthorizationList;
+    chain?: import('viem').Chain | null;
+    dataSuffix?: `0x${string}`;
+    gas?: bigint;
+    gasPrice?: bigint;
+    maxFeePerGas?: bigint;
+    maxPriorityFeePerGas?: bigint;
+    nonce?: number;
+    value?: bigint;
+  }): Promise<`0x${string}`> {
+    if (!this.contract.write) {
+      throw new Error('Wallet client is required for write operations');
+    }
+    return this.contract.write.setUniFees([_token0, _token1, _fee] as const, options) as Promise<`0x${string}`>;
+  }
+
+  /**
+   * setUseAuction
+   * nonpayable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   */
+  async setUseAuction(_useAuction: boolean, options?: {
+    accessList?: import('viem').AccessList;
+    authorizationList?: import('viem').AuthorizationList;
+    chain?: import('viem').Chain | null;
+    dataSuffix?: `0x${string}`;
+    gas?: bigint;
+    gasPrice?: bigint;
+    maxFeePerGas?: bigint;
+    maxPriorityFeePerGas?: bigint;
+    nonce?: number;
+    value?: bigint;
+  }): Promise<`0x${string}`> {
+    if (!this.contract.write) {
+      throw new Error('Wallet client is required for write operations');
+    }
+    return this.contract.write.setUseAuction([_useAuction] as const, options) as Promise<`0x${string}`>;
+  }
+
+  /**
+   * setUseTradeFactory
+   * nonpayable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   */
+  async setUseTradeFactory(_useTradeFactory: boolean, options?: {
+    accessList?: import('viem').AccessList;
+    authorizationList?: import('viem').AuthorizationList;
+    chain?: import('viem').Chain | null;
+    dataSuffix?: `0x${string}`;
+    gas?: bigint;
+    gasPrice?: bigint;
+    maxFeePerGas?: bigint;
+    maxPriorityFeePerGas?: bigint;
+    nonce?: number;
+    value?: bigint;
+  }): Promise<`0x${string}`> {
+    if (!this.contract.write) {
+      throw new Error('Wallet client is required for write operations');
+    }
+    return this.contract.write.setUseTradeFactory([_useTradeFactory] as const, options) as Promise<`0x${string}`>;
+  }
+
+  /**
+   * shutdownWithdraw
+   * nonpayable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   */
+  async shutdownWithdraw(_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}`> {
+    if (!this.contract.write) {
+      throw new Error('Wallet client is required for write operations');
+    }
+    return this.contract.write.shutdownWithdraw([_amount] as const, options) as Promise<`0x${string}`>;
+  }
+
+  /**
+   * sweep
+   * nonpayable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   */
+  async sweep(_token: `0x${string}`, options?: {
+    accessList?: import('viem').AccessList;
+    authorizationList?: import('viem').AuthorizationList;
+    chain?: import('viem').Chain | null;
+    dataSuffix?: `0x${string}`;
+    gas?: bigint;
+    gasPrice?: bigint;
+    maxFeePerGas?: bigint;
+    maxPriorityFeePerGas?: bigint;
+    nonce?: number;
+    value?: bigint;
+  }): Promise<`0x${string}`> {
+    if (!this.contract.write) {
+      throw new Error('Wallet client is required for write operations');
+    }
+    return this.contract.write.sweep([_token] as const, options) as Promise<`0x${string}`>;
+  }
+
+  /**
+   * tendThis
+   * nonpayable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   */
+  async tendThis(_totalIdle: bigint, options?: {
+    accessList?: import('viem').AccessList;
+    authorizationList?: import('viem').AuthorizationList;
+    chain?: import('viem').Chain | null;
+    dataSuffix?: `0x${string}`;
+    gas?: bigint;
+    gasPrice?: bigint;
+    maxFeePerGas?: bigint;
+    maxPriorityFeePerGas?: bigint;
+    nonce?: number;
+    value?: bigint;
+  }): Promise<`0x${string}`> {
+    if (!this.contract.write) {
+      throw new Error('Wallet client is required for write operations');
+    }
+    return this.contract.write.tendThis([_totalIdle] as const, options) as Promise<`0x${string}`>;
+  }
+
+
+
+  /**
+   * Simulate contract write operations (dry-run without sending transaction)
+   * 
+   * @example
+   * const result = await contract.simulate.transfer('0x...', 1000n);
+   * console.log('Gas estimate:', result.request.gas);
+   * console.log('Would succeed:', result.result);
+   */
+  get simulate() {
+    const contract = this.contract;
+    if (!contract.simulate) {
+      throw new Error('Public client is required for simulation');
+    }
+    return {
+      /**
+       * Simulate addReward
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async addReward(_rewardToken: `0x${string}`, _feeRewardTokenToBase: bigint, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+      }): Promise<void> {
+        return contract.simulate.addReward([_rewardToken, _feeRewardTokenToBase] as const, options) as Promise<void>;
+      },
+      /**
+       * Simulate auctionKicked
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async auctionKicked(_token: `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> {
+        return contract.simulate.auctionKicked([_token] as const, options) as Promise<bigint>;
+      },
+      /**
+       * Simulate claimRewards
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async claimRewards(options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+      }): Promise<void> {
+        return contract.simulate.claimRewards(options) as Promise<void>;
+      },
+      /**
+       * Simulate deployFunds
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async deployFunds(_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> {
+        return contract.simulate.deployFunds([_amount] as const, options) as Promise<void>;
+      },
+      /**
+       * Simulate freeFunds
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async freeFunds(_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> {
+        return contract.simulate.freeFunds([_amount] as const, options) as Promise<void>;
+      },
+      /**
+       * Simulate harvestAndReport
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async harvestAndReport(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> {
+        return contract.simulate.harvestAndReport(options) as Promise<bigint>;
+      },
+      /**
+       * Simulate postTake
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async postTake(_token: `0x${string}`, _amountTaken: bigint, _amountPayed: bigint, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+      }): Promise<void> {
+        return contract.simulate.postTake([_token, _amountTaken, _amountPayed] as const, options) as Promise<void>;
+      },
+      /**
+       * Simulate preTake
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async preTake(_token: `0x${string}`, _amountToTake: bigint, _amountToPay: bigint, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+      }): Promise<void> {
+        return contract.simulate.preTake([_token, _amountToTake, _amountToPay] as const, options) as Promise<void>;
+      },
+      /**
+       * Simulate removeReward
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async removeReward(_rewardToken: `0x${string}`, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+      }): Promise<void> {
+        return contract.simulate.removeReward([_rewardToken] as const, options) as Promise<void>;
+      },
+      /**
+       * Simulate removeTradeFactory
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async removeTradeFactory(options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+      }): Promise<void> {
+        return contract.simulate.removeTradeFactory(options) as Promise<void>;
+      },
+      /**
+       * Simulate setAuction
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async setAuction(_auction: `0x${string}`, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+      }): Promise<void> {
+        return contract.simulate.setAuction([_auction] as const, options) as Promise<void>;
+      },
+      /**
+       * Simulate setAutocompound
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async setAutocompound(_autocompound: boolean, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+      }): Promise<void> {
+        return contract.simulate.setAutocompound([_autocompound] as const, options) as Promise<void>;
+      },
+      /**
+       * Simulate setDoHealthCheck
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async setDoHealthCheck(_doHealthCheck: boolean, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+      }): Promise<void> {
+        return contract.simulate.setDoHealthCheck([_doHealthCheck] as const, options) as Promise<void>;
+      },
+      /**
+       * Simulate setLossLimitRatio
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async setLossLimitRatio(_newLossLimitRatio: bigint, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+      }): Promise<void> {
+        return contract.simulate.setLossLimitRatio([_newLossLimitRatio] as const, options) as Promise<void>;
+      },
+      /**
+       * Simulate setMinAmountToSellMapping
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async setMinAmountToSellMapping(_token: `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> {
+        return contract.simulate.setMinAmountToSellMapping([_token, _amount] as const, options) as Promise<void>;
+      },
+      /**
+       * Simulate setProfitLimitRatio
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async setProfitLimitRatio(_newProfitLimitRatio: bigint, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+      }): Promise<void> {
+        return contract.simulate.setProfitLimitRatio([_newProfitLimitRatio] as const, options) as Promise<void>;
+      },
+      /**
+       * Simulate setRouterParams
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async setRouterParams(_guessMin: bigint, _guessMax: bigint, _maxIteration: bigint, _eps: bigint, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+      }): Promise<void> {
+        return contract.simulate.setRouterParams([_guessMin, _guessMax, _maxIteration, _eps] as const, options) as Promise<void>;
+      },
+      /**
+       * Simulate setTradeFactory
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async setTradeFactory(_tradeFactory: `0x${string}`, _useTradeFactory: boolean, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+      }): Promise<void> {
+        return contract.simulate.setTradeFactory([_tradeFactory, _useTradeFactory] as const, options) as Promise<void>;
+      },
+      /**
+       * Simulate setUniFees
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async setUniFees(_token0: `0x${string}`, _token1: `0x${string}`, _fee: bigint, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+      }): Promise<void> {
+        return contract.simulate.setUniFees([_token0, _token1, _fee] as const, options) as Promise<void>;
+      },
+      /**
+       * Simulate setUseAuction
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async setUseAuction(_useAuction: boolean, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+      }): Promise<void> {
+        return contract.simulate.setUseAuction([_useAuction] as const, options) as Promise<void>;
+      },
+      /**
+       * Simulate setUseTradeFactory
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async setUseTradeFactory(_useTradeFactory: boolean, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+      }): Promise<void> {
+        return contract.simulate.setUseTradeFactory([_useTradeFactory] as const, options) as Promise<void>;
+      },
+      /**
+       * Simulate shutdownWithdraw
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async shutdownWithdraw(_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> {
+        return contract.simulate.shutdownWithdraw([_amount] as const, options) as Promise<void>;
+      },
+      /**
+       * Simulate sweep
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async sweep(_token: `0x${string}`, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+      }): Promise<void> {
+        return contract.simulate.sweep([_token] as const, options) as Promise<void>;
+      },
+      /**
+       * Simulate tendThis
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async tendThis(_totalIdle: bigint, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+      }): Promise<void> {
+        return contract.simulate.tendThis([_totalIdle] as const, options) as Promise<void>;
+      }
+    };
+  }
+
+  /**
+   * Watch contract events
+   * 
+   * Note: This contract has no events, so watch returns an empty object.
+   */
+  get watch() {
+    return {};
+  }
+}