@gitmyabi/stakingmanager 1.0.4 → 1.0.6

package/contracts/TransparentUpgradeableProxy_json.ts

@@ -77,6 +77,76 @@ export const TransparentUpgradeableProxy_jsonAbi = [
     "stateMutability": "payable",
     "type": "fallback"
   },
+  {
+    "inputs": [],
+    "name": "admin",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "admin_",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "newAdmin",
+        "type": "address"
+      }
+    ],
+    "name": "changeAdmin",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "implementation",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "implementation_",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "newImplementation",
+        "type": "address"
+      }
+    ],
+    "name": "upgradeTo",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "newImplementation",
+        "type": "address"
+      },
+      {
+        "internalType": "bytes",
+        "name": "data",
+        "type": "bytes"
+      }
+    ],
+    "name": "upgradeToAndCall",
+    "outputs": [],
+    "stateMutability": "payable",
+    "type": "function"
+  },
   {
     "stateMutability": "payable",
     "type": "receive"
@@ -167,17 +237,233 @@ export class TransparentUpgradeableProxy_json {
 
   // No read functions
 
-  // No write functions
+  /**
+   * admin
+   * nonpayable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   */
+  async admin(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.admin(options) as Promise<`0x${string}`>;
+  }
+
+  /**
+   * changeAdmin
+   * nonpayable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   */
+  async changeAdmin(newAdmin: `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.changeAdmin([newAdmin] as const, options) as Promise<`0x${string}`>;
+  }
+
+  /**
+   * implementation
+   * nonpayable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   */
+  async implementation(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.implementation(options) as Promise<`0x${string}`>;
+  }
+
+  /**
+   * upgradeTo
+   * nonpayable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   */
+  async upgradeTo(newImplementation: `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.upgradeTo([newImplementation] as const, options) as Promise<`0x${string}`>;
+  }
+
+  /**
+   * upgradeToAndCall
+   * payable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
+   */
+  async upgradeToAndCall(newImplementation: `0x${string}`, data: `0x${string}`, options?: {
+    accessList?: import('viem').AccessList;
+    authorizationList?: import('viem').AuthorizationList;
+    chain?: import('viem').Chain | null;
+    dataSuffix?: `0x${string}`;
+    gas?: bigint;
+    gasPrice?: bigint;
+    maxFeePerGas?: bigint;
+    maxPriorityFeePerGas?: bigint;
+    nonce?: number;
+    value?: bigint;
+  }): Promise<`0x${string}`> {
+    if (!this.contract.write) {
+      throw new Error('Wallet client is required for write operations');
+    }
+    return this.contract.write.upgradeToAndCall([newImplementation, data] as const, options) as Promise<`0x${string}`>;
+  }
 
 
 
   /**
    * Simulate contract write operations (dry-run without sending transaction)
    * 
-   * Note: This contract has no write functions, so simulate returns an empty object.
+   * @example
+   * const result = await contract.simulate.transfer('0x...', 1000n);
+   * console.log('Gas estimate:', result.request.gas);
+   * console.log('Would succeed:', result.result);
    */
   get simulate() {
-    return {};
+    const contract = this.contract;
+    if (!contract.simulate) {
+      throw new Error('Public client is required for simulation');
+    }
+    return {
+      /**
+       * Simulate admin
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async admin(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}`> {
+        return contract.simulate.admin(options) as Promise<`0x${string}`>;
+      },
+      /**
+       * Simulate changeAdmin
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async changeAdmin(newAdmin: `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.changeAdmin([newAdmin] as const, options) as Promise<void>;
+      },
+      /**
+       * Simulate implementation
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async implementation(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}`> {
+        return contract.simulate.implementation(options) as Promise<`0x${string}`>;
+      },
+      /**
+       * Simulate upgradeTo
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async upgradeTo(newImplementation: `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.upgradeTo([newImplementation] as const, options) as Promise<void>;
+      },
+      /**
+       * Simulate upgradeToAndCall
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async upgradeToAndCall(newImplementation: `0x${string}`, data: `0x${string}`, options?: {
+        accessList?: import('viem').AccessList;
+        authorizationList?: import('viem').AuthorizationList;
+        chain?: import('viem').Chain | null;
+        dataSuffix?: `0x${string}`;
+        gas?: bigint;
+        gasPrice?: bigint;
+        maxFeePerGas?: bigint;
+        maxPriorityFeePerGas?: bigint;
+        nonce?: number;
+        value?: bigint;
+      }): Promise<void> {
+        return contract.simulate.upgradeToAndCall([newImplementation, data] as const, options) as Promise<void>;
+      }
+    };
   }
 
   /**

package/contracts/index.d.ts

@@ -1,4 +1,4 @@
 export { TransparentUpgradeableProxy_jsonAbi, TransparentUpgradeableProxy_json } from './TransparentUpgradeableProxy_json';
 export type { TransparentUpgradeableProxy_jsonAbi as TransparentUpgradeableProxy_jsonAbiType, TransparentUpgradeableProxy_jsonContract } from './TransparentUpgradeableProxy_json';
-export { stakingManagerV2_jsonAbi, stakingManagerV2_json } from './stakingManagerV2_json';
-export type { stakingManagerV2_jsonAbi as stakingManagerV2_jsonAbiType, stakingManagerV2_jsonContract } from './stakingManagerV2_json';
+export { stakingManager_jsonAbi, stakingManager_json } from './stakingManager_json';
+export type { stakingManager_jsonAbi as stakingManager_jsonAbiType, stakingManager_jsonContract } from './stakingManager_json';

package/contracts/index.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.stakingManagerV2_json = exports.stakingManagerV2_jsonAbi = exports.TransparentUpgradeableProxy_json = exports.TransparentUpgradeableProxy_jsonAbi = void 0;
+exports.stakingManager_json = exports.stakingManager_jsonAbi = exports.TransparentUpgradeableProxy_json = exports.TransparentUpgradeableProxy_jsonAbi = void 0;
 // Auto-generated exports for all contracts
 var TransparentUpgradeableProxy_json_1 = require("./TransparentUpgradeableProxy_json");
 Object.defineProperty(exports, "TransparentUpgradeableProxy_jsonAbi", { enumerable: true, get: function () { return TransparentUpgradeableProxy_json_1.TransparentUpgradeableProxy_jsonAbi; } });
 Object.defineProperty(exports, "TransparentUpgradeableProxy_json", { enumerable: true, get: function () { return TransparentUpgradeableProxy_json_1.TransparentUpgradeableProxy_json; } });
-var stakingManagerV2_json_1 = require("./stakingManagerV2_json");
-Object.defineProperty(exports, "stakingManagerV2_jsonAbi", { enumerable: true, get: function () { return stakingManagerV2_json_1.stakingManagerV2_jsonAbi; } });
-Object.defineProperty(exports, "stakingManagerV2_json", { enumerable: true, get: function () { return stakingManagerV2_json_1.stakingManagerV2_json; } });
+var stakingManager_json_1 = require("./stakingManager_json");
+Object.defineProperty(exports, "stakingManager_jsonAbi", { enumerable: true, get: function () { return stakingManager_json_1.stakingManager_jsonAbi; } });
+Object.defineProperty(exports, "stakingManager_json", { enumerable: true, get: function () { return stakingManager_json_1.stakingManager_json; } });

package/contracts/index.ts

@@ -1,5 +1,5 @@
 // Auto-generated exports for all contracts
 export { TransparentUpgradeableProxy_jsonAbi, TransparentUpgradeableProxy_json } from './TransparentUpgradeableProxy_json';
 export type { TransparentUpgradeableProxy_jsonAbi as TransparentUpgradeableProxy_jsonAbiType, TransparentUpgradeableProxy_jsonContract } from './TransparentUpgradeableProxy_json';
-export { stakingManagerV2_jsonAbi, stakingManagerV2_json } from './stakingManagerV2_json';
-export type { stakingManagerV2_jsonAbi as stakingManagerV2_jsonAbiType, stakingManagerV2_jsonContract } from './stakingManagerV2_json';
+export { stakingManager_jsonAbi, stakingManager_json } from './stakingManager_json';
+export type { stakingManager_jsonAbi as stakingManager_jsonAbiType, stakingManager_jsonContract } from './stakingManager_json';

package/contracts/{stakingManagerV2_json.d.ts → stakingManager_json.d.ts}

@@ -1,10 +1,10 @@
 import type { Address, PublicClient, WalletClient } from 'viem';
 /**
- * stakingManagerV2_json ABI
+ * stakingManager_json ABI
  *
  * This ABI is typed using viem's type system for full type safety.
  */
-export declare const stakingManagerV2_jsonAbi: readonly [{
+export declare const stakingManager_jsonAbi: readonly [{
     readonly inputs: readonly [];
     readonly stateMutability: "nonpayable";
     readonly type: "constructor";
@@ -78,32 +78,6 @@ export declare const stakingManagerV2_jsonAbi: readonly [{
     }];
     readonly name: "Withdraw";
     readonly type: "event";
-}, {
-    readonly inputs: readonly [{
-        readonly internalType: "address";
-        readonly name: "_rewardTokenAddress";
-        readonly type: "address";
-    }, {
-        readonly internalType: "address";
-        readonly name: "_presale";
-        readonly type: "address";
-    }, {
-        readonly internalType: "uint256";
-        readonly name: "_rewardTokensPerBlock";
-        readonly type: "uint256";
-    }, {
-        readonly internalType: "uint256";
-        readonly name: "_lockTime";
-        readonly type: "uint256";
-    }, {
-        readonly internalType: "uint256";
-        readonly name: "_endBlock";
-        readonly type: "uint256";
-    }];
-    readonly name: "__stakingManager_init";
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-    readonly type: "function";
 }, {
     readonly inputs: readonly [{
         readonly internalType: "address[]";
@@ -188,6 +162,32 @@ export declare const stakingManagerV2_jsonAbi: readonly [{
     readonly outputs: readonly [];
     readonly stateMutability: "nonpayable";
     readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "_rewardTokenAddress";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "_presale";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_rewardTokensPerBlock";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_lockTime";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_endBlock";
+        readonly type: "uint256";
+    }];
+    readonly name: "initialize";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
 }, {
     readonly inputs: readonly [{
         readonly internalType: "address";
@@ -358,20 +358,6 @@ export declare const stakingManagerV2_jsonAbi: readonly [{
     }];
     readonly stateMutability: "view";
     readonly type: "function";
-}, {
-    readonly inputs: readonly [{
-        readonly internalType: "address";
-        readonly name: "_token";
-        readonly type: "address";
-    }, {
-        readonly internalType: "uint256";
-        readonly name: "_amount";
-        readonly type: "uint256";
-    }];
-    readonly name: "tokenTransfer";
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-    readonly type: "function";
 }, {
     readonly inputs: readonly [];
     readonly name: "tokensStaked";
@@ -424,15 +410,15 @@ export declare const stakingManagerV2_jsonAbi: readonly [{
     readonly type: "function";
 }];
 /**
- * Type-safe ABI for stakingManagerV2_json
+ * Type-safe ABI for stakingManager_json
  */
-export type stakingManagerV2_jsonAbi = typeof stakingManagerV2_jsonAbi;
+export type stakingManager_jsonAbi = typeof stakingManager_jsonAbi;
 /**
- * Contract instance type for stakingManagerV2_json
+ * Contract instance type for stakingManager_json
  */
-export type stakingManagerV2_jsonContract = any;
+export type stakingManager_jsonContract = any;
 /**
- * stakingManagerV2_json Contract Class
+ * stakingManager_json Contract Class
  *
  * Provides a class-based API similar to TypeChain for interacting with the contract.
  *
@@ -440,12 +426,12 @@ export type stakingManagerV2_jsonContract = any;
  * ```typescript
  * import { createPublicClient, createWalletClient, http } from 'viem';
  * import { mainnet } from 'viem/chains';
- * import { stakingManagerV2_json } from 'stakingManagerV2_json';
+ * import { stakingManager_json } from 'stakingManager_json';
  *
  * const publicClient = createPublicClient({ chain: mainnet, transport: http() });
  * const walletClient = createWalletClient({ chain: mainnet, transport: http() });
  *
- * const contract = new stakingManagerV2_json('0x...', { publicClient, walletClient });
+ * const contract = new stakingManager_json('0x...', { publicClient, walletClient });
  *
  * // Read functions
  * const result = await contract.balanceOf('0x...');
@@ -463,7 +449,7 @@ export type stakingManagerV2_jsonContract = any;
  * });
  * ```
  */
-export declare class stakingManagerV2_json {
+export declare class stakingManager_json {
     private contract;
     private contractAddress;
     private publicClient;
@@ -478,7 +464,7 @@ export declare class stakingManagerV2_json {
     /**
      * Get the underlying viem contract instance
      */
-    getContract(): stakingManagerV2_jsonContract;
+    getContract(): stakingManager_jsonContract;
     /**
      * claimStart
      * view
@@ -550,11 +536,11 @@ export declare class stakingManagerV2_json {
      */
     userLockedRewards(arg0: `0x${string}`): Promise<bigint>;
     /**
-     * __stakingManager_init
+     * blacklistUsers
      * nonpayable
      * @param options Optional transaction parameters (value, gas, nonce, etc.)
      */
-    __stakingManager_init(_rewardTokenAddress: `0x${string}`, _presale: `0x${string}`, _rewardTokensPerBlock: bigint, _lockTime: bigint, _endBlock: bigint, options?: {
+    blacklistUsers(_usersToBlacklist: `0x${string}`[], options?: {
         accessList?: import('viem').AccessList;
         authorizationList?: import('viem').AuthorizationList;
         chain?: import('viem').Chain | null;
@@ -567,11 +553,11 @@ export declare class stakingManagerV2_json {
         value?: bigint;
     }): Promise<`0x${string}`>;
     /**
-     * blacklistUsers
+     * deposit
      * nonpayable
      * @param options Optional transaction parameters (value, gas, nonce, etc.)
      */
-    blacklistUsers(_usersToBlacklist: `0x${string}`[], options?: {
+    deposit(_amount: bigint, options?: {
         accessList?: import('viem').AccessList;
         authorizationList?: import('viem').AuthorizationList;
         chain?: import('viem').Chain | null;
@@ -584,11 +570,11 @@ export declare class stakingManagerV2_json {
         value?: bigint;
     }): Promise<`0x${string}`>;
     /**
-     * deposit
+     * depositByPresale
      * nonpayable
      * @param options Optional transaction parameters (value, gas, nonce, etc.)
      */
-    deposit(_amount: bigint, options?: {
+    depositByPresale(_user: `0x${string}`, _amount: bigint, options?: {
         accessList?: import('viem').AccessList;
         authorizationList?: import('viem').AuthorizationList;
         chain?: import('viem').Chain | null;
@@ -601,11 +587,11 @@ export declare class stakingManagerV2_json {
         value?: bigint;
     }): Promise<`0x${string}`>;
     /**
-     * depositByPresale
+     * harvestRewards
      * nonpayable
      * @param options Optional transaction parameters (value, gas, nonce, etc.)
      */
-    depositByPresale(_user: `0x${string}`, _amount: bigint, options?: {
+    harvestRewards(options?: {
         accessList?: import('viem').AccessList;
         authorizationList?: import('viem').AuthorizationList;
         chain?: import('viem').Chain | null;
@@ -618,11 +604,11 @@ export declare class stakingManagerV2_json {
         value?: bigint;
     }): Promise<`0x${string}`>;
     /**
-     * harvestRewards
+     * initialize
      * nonpayable
      * @param options Optional transaction parameters (value, gas, nonce, etc.)
      */
-    harvestRewards(options?: {
+    initialize(_rewardTokenAddress: `0x${string}`, _presale: `0x${string}`, _rewardTokensPerBlock: bigint, _lockTime: bigint, _endBlock: bigint, options?: {
         accessList?: import('viem').AccessList;
         authorizationList?: import('viem').AuthorizationList;
         chain?: import('viem').Chain | null;
@@ -770,23 +756,6 @@ export declare class stakingManagerV2_json {
         nonce?: number;
         value?: bigint;
     }): Promise<`0x${string}`>;
-    /**
-     * tokenTransfer
-     * nonpayable
-     * @param options Optional transaction parameters (value, gas, nonce, etc.)
-     */
-    tokenTransfer(_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}`>;
     /**
      * transferOwnership
      * nonpayable
@@ -831,11 +800,11 @@ export declare class stakingManagerV2_json {
      */
     get simulate(): {
         /**
-         * Simulate __stakingManager_init
+         * Simulate blacklistUsers
          * Returns gas estimate and result without sending transaction
          * @param options Optional transaction parameters (value, gas, nonce, etc.)
          */
-        __stakingManager_init(_rewardTokenAddress: `0x${string}`, _presale: `0x${string}`, _rewardTokensPerBlock: bigint, _lockTime: bigint, _endBlock: bigint, options?: {
+        blacklistUsers(_usersToBlacklist: `0x${string}`[], options?: {
             accessList?: import("viem").AccessList;
             authorizationList?: import("viem").AuthorizationList;
             chain?: import("viem").Chain | null;
@@ -848,11 +817,11 @@ export declare class stakingManagerV2_json {
             value?: bigint;
         }): Promise<void>;
         /**
-         * Simulate blacklistUsers
+         * Simulate deposit
          * Returns gas estimate and result without sending transaction
          * @param options Optional transaction parameters (value, gas, nonce, etc.)
          */
-        blacklistUsers(_usersToBlacklist: `0x${string}`[], options?: {
+        deposit(_amount: bigint, options?: {
             accessList?: import("viem").AccessList;
             authorizationList?: import("viem").AuthorizationList;
             chain?: import("viem").Chain | null;
@@ -865,11 +834,11 @@ export declare class stakingManagerV2_json {
             value?: bigint;
         }): Promise<void>;
         /**
-         * Simulate deposit
+         * Simulate depositByPresale
          * Returns gas estimate and result without sending transaction
          * @param options Optional transaction parameters (value, gas, nonce, etc.)
          */
-        deposit(_amount: bigint, options?: {
+        depositByPresale(_user: `0x${string}`, _amount: bigint, options?: {
             accessList?: import("viem").AccessList;
             authorizationList?: import("viem").AuthorizationList;
             chain?: import("viem").Chain | null;
@@ -882,11 +851,11 @@ export declare class stakingManagerV2_json {
             value?: bigint;
         }): Promise<void>;
         /**
-         * Simulate depositByPresale
+         * Simulate harvestRewards
          * Returns gas estimate and result without sending transaction
          * @param options Optional transaction parameters (value, gas, nonce, etc.)
          */
-        depositByPresale(_user: `0x${string}`, _amount: bigint, options?: {
+        harvestRewards(options?: {
             accessList?: import("viem").AccessList;
             authorizationList?: import("viem").AuthorizationList;
             chain?: import("viem").Chain | null;
@@ -899,11 +868,11 @@ export declare class stakingManagerV2_json {
             value?: bigint;
         }): Promise<void>;
         /**
-         * Simulate harvestRewards
+         * Simulate initialize
          * Returns gas estimate and result without sending transaction
          * @param options Optional transaction parameters (value, gas, nonce, etc.)
          */
-        harvestRewards(options?: {
+        initialize(_rewardTokenAddress: `0x${string}`, _presale: `0x${string}`, _rewardTokensPerBlock: bigint, _lockTime: bigint, _endBlock: bigint, options?: {
             accessList?: import("viem").AccessList;
             authorizationList?: import("viem").AuthorizationList;
             chain?: import("viem").Chain | null;
@@ -1051,23 +1020,6 @@ export declare class stakingManagerV2_json {
             nonce?: number;
             value?: bigint;
         }): Promise<void>;
-        /**
-         * Simulate tokenTransfer
-         * Returns gas estimate and result without sending transaction
-         * @param options Optional transaction parameters (value, gas, nonce, etc.)
-         */
-        tokenTransfer(_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>;
         /**
          * Simulate transferOwnership
          * Returns gas estimate and result without sending transaction