@gitmyabi/chnstaking 1.0.0

package/contracts/CHNStaking_json.d.ts

@@ -0,0 +1,1275 @@
+import type { Address, PublicClient, WalletClient } from 'viem';
+/**
+ * CHNStaking_json ABI
+ *
+ * This ABI is typed using viem's type system for full type safety.
+ */
+export declare const CHNStaking_jsonAbi: readonly [{
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "stakToken";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "uint256";
+        readonly name: "allocPoint";
+        readonly type: "uint256";
+    }];
+    readonly name: "Add";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "userAddress";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "uint256";
+        readonly name: "pid";
+        readonly type: "uint256";
+    }];
+    readonly name: "ClaimRewardFromVault";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "delegate";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "previousBalance";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "newBalance";
+        readonly type: "uint256";
+    }];
+    readonly name: "DelegateVotesChanged";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "user";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "uint256";
+        readonly name: "pid";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly name: "EmergencyWithdraw";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "previousOwner";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "newOwner";
+        readonly type: "address";
+    }];
+    readonly name: "OwnershipTransferred";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "uint256";
+        readonly name: "pid";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "uint256";
+        readonly name: "allocPoint";
+        readonly type: "uint256";
+    }];
+    readonly name: "Set";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "user";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "uint256";
+        readonly name: "pid";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly name: "Stake";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "user";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "uint256";
+        readonly name: "pid";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "amount";
+        readonly type: "uint256";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "reward";
+        readonly type: "uint256";
+    }];
+    readonly name: "Withdraw";
+    readonly type: "event";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "BONUS_MULTIPLIER";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "_allocPoint";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "contract IERC20";
+        readonly name: "_stakeToken";
+        readonly type: "address";
+    }];
+    readonly name: "add";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "bonusEndBlock";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint32";
+        readonly name: "";
+        readonly type: "uint32";
+    }];
+    readonly name: "checkpoints";
+    readonly outputs: readonly [{
+        readonly internalType: "uint32";
+        readonly name: "fromBlock";
+        readonly type: "uint32";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "votes";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "userAddress";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "pid";
+        readonly type: "uint256";
+    }];
+    readonly name: "claimRewardFromVault";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "_pid";
+        readonly type: "uint256";
+    }];
+    readonly name: "emergencyWithdraw";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "_from";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_to";
+        readonly type: "uint256";
+    }];
+    readonly name: "getMultiplier";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "_pid";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "address";
+        readonly name: "account";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "blockNumber";
+        readonly type: "uint256";
+    }];
+    readonly name: "getPriorVotes";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "pid";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "address";
+        readonly name: "user";
+        readonly type: "address";
+    }];
+    readonly name: "getStakingAmount";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "contract IERC20";
+        readonly name: "_rewardToken";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_rewardPerBlock";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_startBlock";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_bonusEndBlock";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_multiplier";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "address";
+        readonly name: "_rewardVault";
+        readonly type: "address";
+    }];
+    readonly name: "initialize";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "massUpdatePools";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly name: "numCheckpoints";
+    readonly outputs: readonly [{
+        readonly internalType: "uint32";
+        readonly name: "";
+        readonly type: "uint32";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "owner";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "_pid";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "address";
+        readonly name: "_user";
+        readonly type: "address";
+    }];
+    readonly name: "pendingReward";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly name: "poolInfo";
+    readonly outputs: readonly [{
+        readonly internalType: "contract IERC20";
+        readonly name: "stakeToken";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "allocPoint";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "lastRewardBlock";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "accCHNPerShare";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "totalAmountStake";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "poolLength";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly name: "poolTokens";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "renounceOwnership";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "rewardPerBlock";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "rewardToken";
+    readonly outputs: readonly [{
+        readonly internalType: "contract IERC20";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "rewardVault";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "_pid";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_allocPoint";
+        readonly type: "uint256";
+    }];
+    readonly name: "set";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "speed";
+        readonly type: "uint256";
+    }];
+    readonly name: "setRewardPerblock";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "_pid";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_amount";
+        readonly type: "uint256";
+    }];
+    readonly name: "stake";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "startBlock";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "totalAllocPoint";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "newOwner";
+        readonly type: "address";
+    }];
+    readonly name: "transferOwnership";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "_pid";
+        readonly type: "uint256";
+    }];
+    readonly name: "updatePool";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly name: "userInfo";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "amount";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "rewardDebt";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "pendingTokenReward";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "_pid";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_amount";
+        readonly type: "uint256";
+    }];
+    readonly name: "withdraw";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}];
+/**
+ * Type-safe ABI for CHNStaking_json
+ */
+export type CHNStaking_jsonAbi = typeof CHNStaking_jsonAbi;
+/**
+ * Contract instance type for CHNStaking_json
+ */
+export type CHNStaking_jsonContract = any;
+/**
+ * CHNStaking_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 { CHNStaking_json } from 'CHNStaking_json';
+ *
+ * const publicClient = createPublicClient({ chain: mainnet, transport: http() });
+ * const walletClient = createWalletClient({ chain: mainnet, transport: http() });
+ *
+ * const contract = new CHNStaking_json('0x...', { publicClient, walletClient });
+ *
+ * // Read functions
+ * const result = await contract.balanceOf('0x...');
+ *
+ * // Write functions
+ * const hash = await contract.transfer('0x...', 1000n);
+ *
+ * // Simulate transactions (dry-run)
+ * const simulation = await contract.simulate.transfer('0x...', 1000n);
+ * console.log('Gas estimate:', simulation.request.gas);
+ *
+ * // Watch events
+ * const unwatch = contract.watch.Transfer((event) => {
+ *   console.log('Transfer event:', event);
+ * });
+ * ```
+ */
+export declare class CHNStaking_json {
+    private contract;
+    private contractAddress;
+    private publicClient;
+    constructor(address: Address, clients: {
+        publicClient: PublicClient;
+        walletClient?: WalletClient;
+    });
+    /**
+     * Get the contract address
+     */
+    get address(): Address;
+    /**
+     * Get the underlying viem contract instance
+     */
+    getContract(): CHNStaking_jsonContract;
+    /**
+     * BONUS_MULTIPLIER
+     * view
+     */
+    BONUS_MULTIPLIER(): Promise<bigint>;
+    /**
+     * bonusEndBlock
+     * view
+     */
+    bonusEndBlock(): Promise<bigint>;
+    /**
+     * checkpoints
+     * view
+     */
+    checkpoints(arg0: bigint, arg1: `0x${string}`, arg2: bigint): Promise<[bigint, bigint]>;
+    /**
+     * getMultiplier
+     * view
+     */
+    getMultiplier(_from: bigint, _to: bigint): Promise<bigint>;
+    /**
+     * getPriorVotes
+     * view
+     */
+    getPriorVotes(_pid: bigint, account: `0x${string}`, blockNumber: bigint): Promise<bigint>;
+    /**
+     * getStakingAmount
+     * view
+     */
+    getStakingAmount(pid: bigint, user: `0x${string}`): Promise<bigint>;
+    /**
+     * numCheckpoints
+     * view
+     */
+    numCheckpoints(arg0: bigint, arg1: `0x${string}`): Promise<bigint>;
+    /**
+     * owner
+     * view
+     */
+    owner(): Promise<`0x${string}`>;
+    /**
+     * pendingReward
+     * view
+     */
+    pendingReward(_pid: bigint, _user: `0x${string}`): Promise<bigint>;
+    /**
+     * poolInfo
+     * view
+     */
+    poolInfo(arg0: bigint): Promise<[`0x${string}`, bigint, bigint, bigint, bigint]>;
+    /**
+     * poolLength
+     * view
+     */
+    poolLength(): Promise<bigint>;
+    /**
+     * poolTokens
+     * view
+     */
+    poolTokens(arg0: `0x${string}`): Promise<boolean>;
+    /**
+     * rewardPerBlock
+     * view
+     */
+    rewardPerBlock(): Promise<bigint>;
+    /**
+     * rewardToken
+     * view
+     */
+    rewardToken(): Promise<`0x${string}`>;
+    /**
+     * rewardVault
+     * view
+     */
+    rewardVault(): Promise<`0x${string}`>;
+    /**
+     * startBlock
+     * view
+     */
+    startBlock(): Promise<bigint>;
+    /**
+     * totalAllocPoint
+     * view
+     */
+    totalAllocPoint(): Promise<bigint>;
+    /**
+     * userInfo
+     * view
+     */
+    userInfo(arg0: bigint, arg1: `0x${string}`): Promise<[bigint, bigint, bigint]>;
+    /**
+     * add
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    add(_allocPoint: bigint, _stakeToken: `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}`>;
+    /**
+     * claimRewardFromVault
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    claimRewardFromVault(userAddress: `0x${string}`, pid: 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}`>;
+    /**
+     * emergencyWithdraw
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    emergencyWithdraw(_pid: 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}`>;
+    /**
+     * initialize
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    initialize(_rewardToken: `0x${string}`, _rewardPerBlock: bigint, _startBlock: bigint, _bonusEndBlock: bigint, _multiplier: bigint, _rewardVault: `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}`>;
+    /**
+     * massUpdatePools
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    massUpdatePools(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}`>;
+    /**
+     * renounceOwnership
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    renounceOwnership(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}`>;
+    /**
+     * set
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    set(_pid: bigint, _allocPoint: 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}`>;
+    /**
+     * setRewardPerblock
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    setRewardPerblock(speed: 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}`>;
+    /**
+     * stake
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    stake(_pid: bigint, _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}`>;
+    /**
+     * transferOwnership
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    transferOwnership(newOwner: `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}`>;
+    /**
+     * updatePool
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    updatePool(_pid: 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}`>;
+    /**
+     * withdraw
+     * nonpayable
+     * @param options Optional transaction parameters (value, gas, nonce, etc.)
+     */
+    withdraw(_pid: bigint, _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}`>;
+    /**
+     * 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 add
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        add(_allocPoint: bigint, _stakeToken: `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 claimRewardFromVault
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        claimRewardFromVault(userAddress: `0x${string}`, pid: bigint, options?: {
+            accessList?: import("viem").AccessList;
+            authorizationList?: import("viem").AuthorizationList;
+            chain?: import("viem").Chain | null;
+            dataSuffix?: `0x${string}`;
+            gas?: bigint;
+            gasPrice?: bigint;
+            maxFeePerGas?: bigint;
+            maxPriorityFeePerGas?: bigint;
+            nonce?: number;
+            value?: bigint;
+        }): Promise<bigint>;
+        /**
+         * Simulate emergencyWithdraw
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        emergencyWithdraw(_pid: 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 initialize
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        initialize(_rewardToken: `0x${string}`, _rewardPerBlock: bigint, _startBlock: bigint, _bonusEndBlock: bigint, _multiplier: bigint, _rewardVault: `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 massUpdatePools
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        massUpdatePools(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 renounceOwnership
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        renounceOwnership(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 set
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        set(_pid: bigint, _allocPoint: 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 setRewardPerblock
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        setRewardPerblock(speed: 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 stake
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        stake(_pid: bigint, _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 transferOwnership
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        transferOwnership(newOwner: `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 updatePool
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        updatePool(_pid: 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 withdraw
+         * Returns gas estimate and result without sending transaction
+         * @param options Optional transaction parameters (value, gas, nonce, etc.)
+         */
+        withdraw(_pid: bigint, _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>;
+    };
+    /**
+     * Watch contract events
+     *
+     * @example
+     * // Watch all Transfer events
+     * const unwatch = contract.watch.Transfer((event) => {
+     *   console.log('Transfer:', event);
+     * });
+     *
+     * // Stop watching
+     * unwatch();
+     */
+    get watch(): {
+        /**
+         * Watch Add events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        Add: (callback: (event: {
+            stakToken: `0x${string}`;
+            allocPoint: bigint;
+        }) => void, filter?: {
+            stakToken: `0x${string}`;
+            allocPoint: bigint;
+        }) => () => void;
+        /**
+         * Watch ClaimRewardFromVault events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        ClaimRewardFromVault: (callback: (event: {
+            userAddress: `0x${string}`;
+            pid: bigint;
+        }) => void, filter?: {
+            userAddress: `0x${string}`;
+            pid: bigint;
+        }) => () => void;
+        /**
+         * Watch DelegateVotesChanged events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        DelegateVotesChanged: (callback: (event: {
+            delegate: `0x${string}`;
+            previousBalance: bigint;
+            newBalance: bigint;
+        }) => void, filter?: {
+            delegate: `0x${string}`;
+        }) => () => void;
+        /**
+         * Watch EmergencyWithdraw events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        EmergencyWithdraw: (callback: (event: {
+            user: `0x${string}`;
+            pid: bigint;
+            amount: bigint;
+        }) => void, filter?: {
+            user: `0x${string}`;
+            pid: bigint;
+        }) => () => void;
+        /**
+         * Watch OwnershipTransferred events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        OwnershipTransferred: (callback: (event: {
+            previousOwner: `0x${string}`;
+            newOwner: `0x${string}`;
+        }) => void, filter?: {
+            previousOwner: `0x${string}`;
+            newOwner: `0x${string}`;
+        }) => () => void;
+        /**
+         * Watch Set events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        Set: (callback: (event: {
+            pid: bigint;
+            allocPoint: bigint;
+        }) => void, filter?: {
+            pid: bigint;
+            allocPoint: bigint;
+        }) => () => void;
+        /**
+         * Watch Stake events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        Stake: (callback: (event: {
+            user: `0x${string}`;
+            pid: bigint;
+            amount: bigint;
+        }) => void, filter?: {
+            user: `0x${string}`;
+            pid: bigint;
+        }) => () => void;
+        /**
+         * Watch Withdraw events
+         * @param callback Function to call when event is emitted
+         * @param filter Optional filter for indexed parameters
+         * @returns Unwatch function to stop listening
+         */
+        Withdraw: (callback: (event: {
+            user: `0x${string}`;
+            pid: bigint;
+            amount: bigint;
+            reward: bigint;
+        }) => void, filter?: {
+            user: `0x${string}`;
+            pid: bigint;
+        }) => () => void;
+    };
+}