@gitmyabi/vault 1.0.8 → 1.0.9

package/contracts/Vault_json.ts

@@ -8,121 +8,53 @@ import { getContract } from 'viem';
  */
 export const Vault_jsonAbi = [
   {
-    "inputs": [
-      {
-        "internalType": "contract IERC721",
-        "name": "_nftContract",
-        "type": "address"
-      },
-      {
-        "internalType": "uint256",
-        "name": "_emergencyPenalty",
-        "type": "uint256"
-      },
-      {
-        "internalType": "address",
-        "name": "_emergencyPenaltyReceiver",
-        "type": "address"
-      },
-      {
-        "internalType": "uint256",
-        "name": "_successFee",
-        "type": "uint256"
-      },
-      {
-        "internalType": "address",
-        "name": "_successFeeReceiver",
-        "type": "address"
-      }
-    ],
+    "inputs": [],
     "stateMutability": "nonpayable",
     "type": "constructor"
   },
   {
+    "anonymous": false,
     "inputs": [
       {
+        "indexed": false,
         "internalType": "address",
-        "name": "owner",
+        "name": "previousAdmin",
         "type": "address"
-      }
-    ],
-    "name": "OwnableInvalidOwner",
-    "type": "error"
-  },
-  {
-    "inputs": [
+      },
       {
+        "indexed": false,
         "internalType": "address",
-        "name": "account",
+        "name": "newAdmin",
         "type": "address"
       }
     ],
-    "name": "OwnableUnauthorizedAccount",
-    "type": "error"
-  },
-  {
-    "inputs": [],
-    "name": "ReentrancyGuardReentrantCall",
-    "type": "error"
+    "name": "AdminChanged",
+    "type": "event"
   },
   {
+    "anonymous": false,
     "inputs": [
       {
+        "indexed": true,
         "internalType": "address",
-        "name": "token",
+        "name": "beacon",
         "type": "address"
       }
     ],
-    "name": "SafeERC20FailedOperation",
-    "type": "error"
+    "name": "BeaconUpgraded",
+    "type": "event"
   },
   {
     "anonymous": false,
     "inputs": [
       {
         "indexed": false,
-        "internalType": "uint256",
-        "name": "uid",
-        "type": "uint256"
-      },
-      {
-        "indexed": false,
-        "internalType": "uint256",
-        "name": "startTimestamp",
-        "type": "uint256"
-      },
-      {
-        "indexed": false,
-        "internalType": "uint256",
-        "name": "endTimestamp",
-        "type": "uint256"
-      },
-      {
-        "indexed": false,
-        "internalType": "address[]",
-        "name": "tokens",
-        "type": "address[]"
-      },
-      {
-        "indexed": false,
-        "internalType": "uint256[]",
-        "name": "amounts",
-        "type": "uint256[]"
-      },
-      {
-        "indexed": false,
-        "internalType": "uint256[]",
-        "name": "prices",
-        "type": "uint256[]"
-      },
-      {
-        "indexed": false,
-        "internalType": "address",
-        "name": "receiver",
-        "type": "address"
+        "internalType": "uint8",
+        "name": "version",
+        "type": "uint8"
       }
     ],
-    "name": "NewDeposit",
+    "name": "Initialized",
     "type": "event"
   },
   {
@@ -148,114 +80,75 @@ export const Vault_jsonAbi = [
     "anonymous": false,
     "inputs": [
       {
-        "indexed": false,
-        "internalType": "uint256",
-        "name": "emergencyPenalty",
-        "type": "uint256"
-      }
-    ],
-    "name": "SetEmergencyPenalty",
-    "type": "event"
-  },
-  {
-    "anonymous": false,
-    "inputs": [
-      {
-        "indexed": false,
-        "internalType": "address",
-        "name": "emergencyPenaltyReceiver",
-        "type": "address"
-      }
-    ],
-    "name": "SetEmergencyPenaltyReceiver",
-    "type": "event"
-  },
-  {
-    "anonymous": false,
-    "inputs": [
+        "indexed": true,
+        "internalType": "bytes32",
+        "name": "role",
+        "type": "bytes32"
+      },
       {
-        "indexed": false,
-        "internalType": "uint256",
-        "name": "successFee",
-        "type": "uint256"
-      }
-    ],
-    "name": "SetSuccessFee",
-    "type": "event"
-  },
-  {
-    "anonymous": false,
-    "inputs": [
+        "indexed": true,
+        "internalType": "bytes32",
+        "name": "previousAdminRole",
+        "type": "bytes32"
+      },
       {
-        "indexed": false,
-        "internalType": "address",
-        "name": "successFeeReceiver",
-        "type": "address"
+        "indexed": true,
+        "internalType": "bytes32",
+        "name": "newAdminRole",
+        "type": "bytes32"
       }
     ],
-    "name": "SetSuccessFeeReceiver",
+    "name": "RoleAdminChanged",
     "type": "event"
   },
   {
     "anonymous": false,
     "inputs": [
       {
-        "indexed": false,
-        "internalType": "uint256",
-        "name": "uid",
-        "type": "uint256"
+        "indexed": true,
+        "internalType": "bytes32",
+        "name": "role",
+        "type": "bytes32"
       },
       {
-        "indexed": false,
+        "indexed": true,
         "internalType": "address",
-        "name": "token",
+        "name": "account",
         "type": "address"
       },
       {
-        "indexed": false,
-        "internalType": "uint256",
-        "name": "amount",
-        "type": "uint256"
+        "indexed": true,
+        "internalType": "address",
+        "name": "sender",
+        "type": "address"
       }
     ],
-    "name": "SuccessFeeCharged",
+    "name": "RoleGranted",
     "type": "event"
   },
   {
     "anonymous": false,
     "inputs": [
       {
-        "indexed": false,
-        "internalType": "address",
-        "name": "token",
-        "type": "address"
-      },
-      {
-        "indexed": false,
-        "internalType": "address",
-        "name": "stateView",
-        "type": "address"
-      },
-      {
-        "indexed": false,
+        "indexed": true,
         "internalType": "bytes32",
-        "name": "poolId",
+        "name": "role",
         "type": "bytes32"
       },
       {
-        "indexed": false,
-        "internalType": "bool",
-        "name": "isToken0",
-        "type": "bool"
+        "indexed": true,
+        "internalType": "address",
+        "name": "account",
+        "type": "address"
       },
       {
-        "indexed": false,
-        "internalType": "bool",
-        "name": "status",
-        "type": "bool"
+        "indexed": true,
+        "internalType": "address",
+        "name": "sender",
+        "type": "address"
       }
     ],
-    "name": "TokenUpdated",
+    "name": "RoleRevoked",
     "type": "event"
   },
   {
@@ -264,33 +157,21 @@ export const Vault_jsonAbi = [
       {
         "indexed": true,
         "internalType": "address",
-        "name": "user",
+        "name": "implementation",
         "type": "address"
-      },
-      {
-        "indexed": false,
-        "internalType": "uint256",
-        "name": "uid",
-        "type": "uint256"
-      },
-      {
-        "indexed": false,
-        "internalType": "bool",
-        "name": "isEmergency",
-        "type": "bool"
       }
     ],
-    "name": "Withdraw",
+    "name": "Upgraded",
     "type": "event"
   },
   {
     "inputs": [],
-    "name": "FEES_DECIMALS",
+    "name": "DEFAULT_ADMIN_ROLE",
     "outputs": [
       {
-        "internalType": "uint256",
+        "internalType": "bytes32",
         "name": "",
-        "type": "uint256"
+        "type": "bytes32"
       }
     ],
     "stateMutability": "view",
@@ -298,12 +179,12 @@ export const Vault_jsonAbi = [
   },
   {
     "inputs": [],
-    "name": "MAX_TERM",
+    "name": "PAYEE_ROLE",
     "outputs": [
       {
-        "internalType": "uint256",
+        "internalType": "bytes32",
         "name": "",
-        "type": "uint256"
+        "type": "bytes32"
       }
     ],
     "stateMutability": "view",
@@ -311,12 +192,12 @@ export const Vault_jsonAbi = [
   },
   {
     "inputs": [],
-    "name": "MAX_TOKENS_IN_DEPOSIT",
+    "name": "PAYER_ROLE",
     "outputs": [
       {
-        "internalType": "uint256",
+        "internalType": "bytes32",
         "name": "",
-        "type": "uint256"
+        "type": "bytes32"
       }
     ],
     "stateMutability": "view",
@@ -325,51 +206,45 @@ export const Vault_jsonAbi = [
   {
     "inputs": [
       {
-        "internalType": "address",
-        "name": "",
-        "type": "address"
-      }
-    ],
-    "name": "allowedTokens",
-    "outputs": [
-      {
-        "internalType": "address",
-        "name": "token",
-        "type": "address"
-      },
-      {
-        "internalType": "address",
-        "name": "stateView",
-        "type": "address"
-      },
-      {
-        "internalType": "bytes32",
-        "name": "poolId",
-        "type": "bytes32"
+        "internalType": "contract IERC20Upgradeable[]",
+        "name": "tokens",
+        "type": "address[]"
       },
       {
-        "internalType": "bool",
-        "name": "isToken0",
-        "type": "bool"
+        "internalType": "address[]",
+        "name": "payees",
+        "type": "address[]"
       },
       {
-        "internalType": "bool",
-        "name": "status",
-        "type": "bool"
+        "internalType": "uint256[]",
+        "name": "amounts",
+        "type": "uint256[]"
       }
     ],
-    "stateMutability": "view",
+    "name": "batchTransferErc20",
+    "outputs": [],
+    "stateMutability": "nonpayable",
     "type": "function"
   },
   {
     "inputs": [
       {
-        "internalType": "uint256",
-        "name": "_newEmergencyPenalty",
-        "type": "uint256"
+        "internalType": "contract IERC721Upgradeable[]",
+        "name": "tokens",
+        "type": "address[]"
+      },
+      {
+        "internalType": "address[]",
+        "name": "payees",
+        "type": "address[]"
+      },
+      {
+        "internalType": "uint256[]",
+        "name": "tokenIds",
+        "type": "uint256[]"
       }
     ],
-    "name": "changeEmergencyPenalty",
+    "name": "batchTransferErc721",
     "outputs": [],
     "stateMutability": "nonpayable",
     "type": "function"
@@ -377,12 +252,17 @@ export const Vault_jsonAbi = [
   {
     "inputs": [
       {
-        "internalType": "address",
-        "name": "_newEmergencyPenaltyReveiver",
-        "type": "address"
+        "internalType": "address[]",
+        "name": "payees",
+        "type": "address[]"
+      },
+      {
+        "internalType": "uint256[]",
+        "name": "amounts",
+        "type": "uint256[]"
       }
     ],
-    "name": "changeEmergencyPenaltyReceiver",
+    "name": "batchTransferEther",
     "outputs": [],
     "stateMutability": "nonpayable",
     "type": "function"
@@ -390,156 +270,154 @@ export const Vault_jsonAbi = [
   {
     "inputs": [
       {
-        "internalType": "uint256",
-        "name": "_newSuccessFee",
-        "type": "uint256"
+        "internalType": "bytes32",
+        "name": "role",
+        "type": "bytes32"
       }
     ],
-    "name": "changeSuccessFee",
-    "outputs": [],
-    "stateMutability": "nonpayable",
-    "type": "function"
-  },
-  {
-    "inputs": [
+    "name": "getRoleAdmin",
+    "outputs": [
       {
-        "internalType": "address",
-        "name": "_successFeeReceiver",
-        "type": "address"
+        "internalType": "bytes32",
+        "name": "",
+        "type": "bytes32"
       }
     ],
-    "name": "changeSuccessFeeReceiver",
-    "outputs": [],
-    "stateMutability": "nonpayable",
+    "stateMutability": "view",
     "type": "function"
   },
   {
     "inputs": [
       {
-        "internalType": "address[]",
-        "name": "_tokens",
-        "type": "address[]"
-      },
-      {
-        "internalType": "uint256[]",
-        "name": "_amounts",
-        "type": "uint256[]"
+        "internalType": "bytes32",
+        "name": "role",
+        "type": "bytes32"
       },
       {
         "internalType": "uint256",
-        "name": "_term",
+        "name": "index",
         "type": "uint256"
-      },
-      {
-        "internalType": "address",
-        "name": "receiver",
-        "type": "address"
       }
     ],
-    "name": "createDeposit",
+    "name": "getRoleMember",
     "outputs": [
       {
-        "internalType": "uint256",
+        "internalType": "address",
         "name": "",
-        "type": "uint256"
+        "type": "address"
       }
     ],
-    "stateMutability": "nonpayable",
+    "stateMutability": "view",
     "type": "function"
   },
   {
     "inputs": [
       {
-        "internalType": "uint256",
-        "name": "",
-        "type": "uint256"
+        "internalType": "bytes32",
+        "name": "role",
+        "type": "bytes32"
       }
     ],
-    "name": "deposits",
+    "name": "getRoleMemberCount",
     "outputs": [
       {
         "internalType": "uint256",
-        "name": "startTimestamp",
-        "type": "uint256"
-      },
-      {
-        "internalType": "uint256",
-        "name": "endTimestamp",
+        "name": "",
         "type": "uint256"
-      },
-      {
-        "internalType": "bool",
-        "name": "active",
-        "type": "bool"
       }
     ],
     "stateMutability": "view",
     "type": "function"
   },
   {
-    "inputs": [],
-    "name": "emergencyPenalty",
-    "outputs": [
+    "inputs": [
       {
-        "internalType": "uint256",
-        "name": "",
-        "type": "uint256"
+        "internalType": "bytes32",
+        "name": "role",
+        "type": "bytes32"
+      },
+      {
+        "internalType": "address",
+        "name": "account",
+        "type": "address"
       }
     ],
-    "stateMutability": "view",
+    "name": "grantRole",
+    "outputs": [],
+    "stateMutability": "nonpayable",
     "type": "function"
   },
   {
-    "inputs": [],
-    "name": "emergencyPenaltyReceiver",
-    "outputs": [
+    "inputs": [
+      {
+        "internalType": "bytes32",
+        "name": "role",
+        "type": "bytes32"
+      },
       {
         "internalType": "address",
-        "name": "",
+        "name": "account",
         "type": "address"
       }
     ],
+    "name": "hasRole",
+    "outputs": [
+      {
+        "internalType": "bool",
+        "name": "",
+        "type": "bool"
+      }
+    ],
     "stateMutability": "view",
     "type": "function"
   },
   {
-    "inputs": [
-      {
-        "internalType": "uint256",
-        "name": "_uid",
-        "type": "uint256"
-      }
-    ],
-    "name": "emergencyWithdraw",
+    "inputs": [],
+    "name": "initialize",
     "outputs": [],
     "stateMutability": "nonpayable",
     "type": "function"
   },
   {
     "inputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      },
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      },
       {
         "internalType": "uint256",
-        "name": "_uid",
+        "name": "",
         "type": "uint256"
+      },
+      {
+        "internalType": "bytes",
+        "name": "",
+        "type": "bytes"
       }
     ],
-    "name": "getDepositProfit",
+    "name": "onERC721Received",
     "outputs": [
       {
-        "internalType": "uint256",
+        "internalType": "bytes4",
         "name": "",
-        "type": "uint256"
+        "type": "bytes4"
       }
     ],
-    "stateMutability": "view",
+    "stateMutability": "nonpayable",
     "type": "function"
   },
   {
     "inputs": [],
-    "name": "nftContract",
+    "name": "owner",
     "outputs": [
       {
-        "internalType": "contract IERC721",
+        "internalType": "address",
         "name": "",
         "type": "address"
       }
@@ -549,12 +427,12 @@ export const Vault_jsonAbi = [
   },
   {
     "inputs": [],
-    "name": "owner",
+    "name": "proxiableUUID",
     "outputs": [
       {
-        "internalType": "address",
+        "internalType": "bytes32",
         "name": "",
-        "type": "address"
+        "type": "bytes32"
       }
     ],
     "stateMutability": "view",
@@ -570,144 +448,169 @@ export const Vault_jsonAbi = [
   {
     "inputs": [
       {
-        "internalType": "address",
-        "name": "_token",
-        "type": "address"
+        "internalType": "bytes32",
+        "name": "role",
+        "type": "bytes32"
       },
       {
         "internalType": "address",
-        "name": "_stateView",
+        "name": "account",
         "type": "address"
-      },
+      }
+    ],
+    "name": "renounceRole",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
       {
         "internalType": "bytes32",
-        "name": "_poolId",
+        "name": "role",
         "type": "bytes32"
       },
       {
-        "internalType": "bool",
-        "name": "_isToken0",
-        "type": "bool"
-      },
-      {
-        "internalType": "bool",
-        "name": "_status",
-        "type": "bool"
+        "internalType": "address",
+        "name": "account",
+        "type": "address"
       }
     ],
-    "name": "setAllowedToken",
+    "name": "revokeRole",
     "outputs": [],
     "stateMutability": "nonpayable",
     "type": "function"
   },
   {
-    "inputs": [],
-    "name": "successFee",
+    "inputs": [
+      {
+        "internalType": "bytes4",
+        "name": "interfaceId",
+        "type": "bytes4"
+      }
+    ],
+    "name": "supportsInterface",
     "outputs": [
       {
-        "internalType": "uint256",
+        "internalType": "bool",
         "name": "",
-        "type": "uint256"
+        "type": "bool"
       }
     ],
     "stateMutability": "view",
     "type": "function"
   },
   {
-    "inputs": [],
-    "name": "successFeeReceiver",
-    "outputs": [
+    "inputs": [
+      {
+        "internalType": "contract IERC20Upgradeable",
+        "name": "token",
+        "type": "address"
+      },
       {
         "internalType": "address",
-        "name": "",
+        "name": "payee",
         "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amount",
+        "type": "uint256"
       }
     ],
-    "stateMutability": "view",
+    "name": "transferErc20",
+    "outputs": [],
+    "stateMutability": "nonpayable",
     "type": "function"
   },
   {
     "inputs": [
+      {
+        "internalType": "contract IERC721Upgradeable",
+        "name": "token",
+        "type": "address"
+      },
       {
         "internalType": "address",
-        "name": "newOwner",
+        "name": "payee",
         "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "tokenId",
+        "type": "uint256"
       }
     ],
-    "name": "transferOwnership",
+    "name": "transferErc721",
     "outputs": [],
     "stateMutability": "nonpayable",
     "type": "function"
   },
   {
     "inputs": [
+      {
+        "internalType": "address",
+        "name": "payee",
+        "type": "address"
+      },
       {
         "internalType": "uint256",
-        "name": "_uid",
+        "name": "amount",
         "type": "uint256"
       }
     ],
-    "name": "viewAmountListById",
-    "outputs": [
-      {
-        "internalType": "uint256[]",
-        "name": "",
-        "type": "uint256[]"
-      }
-    ],
-    "stateMutability": "view",
+    "name": "transferEther",
+    "outputs": [],
+    "stateMutability": "nonpayable",
     "type": "function"
   },
   {
     "inputs": [
       {
-        "internalType": "uint256",
-        "name": "_uid",
-        "type": "uint256"
-      }
-    ],
-    "name": "viewStartPriceX96ListById",
-    "outputs": [
-      {
-        "internalType": "uint256[]",
-        "name": "",
-        "type": "uint256[]"
+        "internalType": "address",
+        "name": "newOwner",
+        "type": "address"
       }
     ],
-    "stateMutability": "view",
+    "name": "transferOwnership",
+    "outputs": [],
+    "stateMutability": "nonpayable",
     "type": "function"
   },
   {
     "inputs": [
       {
-        "internalType": "uint256",
-        "name": "_uid",
-        "type": "uint256"
-      }
-    ],
-    "name": "viewTokenListById",
-    "outputs": [
-      {
-        "internalType": "address[]",
-        "name": "",
-        "type": "address[]"
+        "internalType": "address",
+        "name": "newImplementation",
+        "type": "address"
       }
     ],
-    "stateMutability": "view",
+    "name": "upgradeTo",
+    "outputs": [],
+    "stateMutability": "nonpayable",
     "type": "function"
   },
   {
     "inputs": [
       {
-        "internalType": "uint256",
-        "name": "_uid",
-        "type": "uint256"
+        "internalType": "address",
+        "name": "newImplementation",
+        "type": "address"
+      },
+      {
+        "internalType": "bytes",
+        "name": "data",
+        "type": "bytes"
       }
     ],
-    "name": "withdraw",
+    "name": "upgradeToAndCall",
     "outputs": [],
-    "stateMutability": "nonpayable",
+    "stateMutability": "payable",
     "type": "function"
+  },
+  {
+    "stateMutability": "payable",
+    "type": "receive"
   }
 ] as const satisfies Abi;
 
@@ -794,131 +697,183 @@ export class Vault_json {
   }
 
   /**
-   * FEES_DECIMALS
+   * DEFAULT_ADMIN_ROLE
    * view
    */
-  async FEES_DECIMALS(): Promise<bigint> {
-    return this.contract.read.FEES_DECIMALS() as Promise<bigint>;
+  async DEFAULT_ADMIN_ROLE(): Promise<`0x${string}`> {
+    return this.contract.read.DEFAULT_ADMIN_ROLE() as Promise<`0x${string}`>;
   }
 
   /**
-   * MAX_TERM
+   * PAYEE_ROLE
    * view
    */
-  async MAX_TERM(): Promise<bigint> {
-    return this.contract.read.MAX_TERM() as Promise<bigint>;
+  async PAYEE_ROLE(): Promise<`0x${string}`> {
+    return this.contract.read.PAYEE_ROLE() as Promise<`0x${string}`>;
   }
 
   /**
-   * MAX_TOKENS_IN_DEPOSIT
+   * PAYER_ROLE
    * view
    */
-  async MAX_TOKENS_IN_DEPOSIT(): Promise<bigint> {
-    return this.contract.read.MAX_TOKENS_IN_DEPOSIT() as Promise<bigint>;
+  async PAYER_ROLE(): Promise<`0x${string}`> {
+    return this.contract.read.PAYER_ROLE() as Promise<`0x${string}`>;
   }
 
   /**
-   * allowedTokens
+   * getRoleAdmin
    * view
    */
-  async allowedTokens(arg0: `0x${string}`): Promise<[`0x${string}`, `0x${string}`, `0x${string}`, boolean, boolean]> {
-    return this.contract.read.allowedTokens([arg0] as const) as Promise<[`0x${string}`, `0x${string}`, `0x${string}`, boolean, boolean]>;
+  async getRoleAdmin(role: `0x${string}`): Promise<`0x${string}`> {
+    return this.contract.read.getRoleAdmin([role] as const) as Promise<`0x${string}`>;
   }
 
   /**
-   * deposits
+   * getRoleMember
    * view
    */
-  async deposits(arg0: bigint): Promise<[bigint, bigint, boolean]> {
-    return this.contract.read.deposits([arg0] as const) as Promise<[bigint, bigint, boolean]>;
+  async getRoleMember(role: `0x${string}`, index: bigint): Promise<`0x${string}`> {
+    return this.contract.read.getRoleMember([role, index] as const) as Promise<`0x${string}`>;
   }
 
   /**
-   * emergencyPenalty
+   * getRoleMemberCount
    * view
    */
-  async emergencyPenalty(): Promise<bigint> {
-    return this.contract.read.emergencyPenalty() as Promise<bigint>;
+  async getRoleMemberCount(role: `0x${string}`): Promise<bigint> {
+    return this.contract.read.getRoleMemberCount([role] as const) as Promise<bigint>;
   }
 
   /**
-   * emergencyPenaltyReceiver
+   * hasRole
    * view
    */
-  async emergencyPenaltyReceiver(): Promise<`0x${string}`> {
-    return this.contract.read.emergencyPenaltyReceiver() as Promise<`0x${string}`>;
+  async hasRole(role: `0x${string}`, account: `0x${string}`): Promise<boolean> {
+    return this.contract.read.hasRole([role, account] as const) as Promise<boolean>;
   }
 
   /**
-   * getDepositProfit
-   * view
-   */
-  async getDepositProfit(_uid: bigint): Promise<bigint> {
-    return this.contract.read.getDepositProfit([_uid] as const) as Promise<bigint>;
-  }
-
-  /**
-   * nftContract
+   * owner
    * view
    */
-  async nftContract(): Promise<`0x${string}`> {
-    return this.contract.read.nftContract() as Promise<`0x${string}`>;
+  async owner(): Promise<`0x${string}`> {
+    return this.contract.read.owner() as Promise<`0x${string}`>;
   }
 
   /**
-   * owner
+   * proxiableUUID
    * view
    */
-  async owner(): Promise<`0x${string}`> {
-    return this.contract.read.owner() as Promise<`0x${string}`>;
+  async proxiableUUID(): Promise<`0x${string}`> {
+    return this.contract.read.proxiableUUID() as Promise<`0x${string}`>;
   }
 
   /**
-   * successFee
+   * supportsInterface
    * view
    */
-  async successFee(): Promise<bigint> {
-    return this.contract.read.successFee() as Promise<bigint>;
+  async supportsInterface(interfaceId: `0x${string}`): Promise<boolean> {
+    return this.contract.read.supportsInterface([interfaceId] as const) as Promise<boolean>;
   }
 
   /**
-   * successFeeReceiver
-   * view
+   * batchTransferErc20
+   * nonpayable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
    */
-  async successFeeReceiver(): Promise<`0x${string}`> {
-    return this.contract.read.successFeeReceiver() as Promise<`0x${string}`>;
+  async batchTransferErc20(tokens: `0x${string}`[], payees: `0x${string}`[], amounts: 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.batchTransferErc20([tokens, payees, amounts] as const, options) as Promise<`0x${string}`>;
   }
 
   /**
-   * viewAmountListById
-   * view
+   * batchTransferErc721
+   * nonpayable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
    */
-  async viewAmountListById(_uid: bigint): Promise<bigint[]> {
-    return this.contract.read.viewAmountListById([_uid] as const) as Promise<bigint[]>;
+  async batchTransferErc721(tokens: `0x${string}`[], payees: `0x${string}`[], tokenIds: 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.batchTransferErc721([tokens, payees, tokenIds] as const, options) as Promise<`0x${string}`>;
   }
 
   /**
-   * viewStartPriceX96ListById
-   * view
+   * batchTransferEther
+   * nonpayable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
    */
-  async viewStartPriceX96ListById(_uid: bigint): Promise<bigint[]> {
-    return this.contract.read.viewStartPriceX96ListById([_uid] as const) as Promise<bigint[]>;
+  async batchTransferEther(payees: `0x${string}`[], amounts: 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.batchTransferEther([payees, amounts] as const, options) as Promise<`0x${string}`>;
   }
 
   /**
-   * viewTokenListById
-   * view
+   * grantRole
+   * nonpayable
+   * @param options Optional transaction parameters (value, gas, nonce, etc.)
    */
-  async viewTokenListById(_uid: bigint): Promise<`0x${string}`[]> {
-    return this.contract.read.viewTokenListById([_uid] as const) as Promise<`0x${string}`[]>;
+  async grantRole(role: `0x${string}`, account: `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.grantRole([role, account] as const, options) as Promise<`0x${string}`>;
   }
 
   /**
-   * changeEmergencyPenalty
+   * initialize
    * nonpayable
    * @param options Optional transaction parameters (value, gas, nonce, etc.)
    */
-  async changeEmergencyPenalty(_newEmergencyPenalty: bigint, options?: {
+  async initialize(options?: {
     accessList?: import('viem').AccessList;
     authorizationList?: import('viem').AuthorizationList;
     chain?: import('viem').Chain | null;
@@ -933,15 +888,15 @@ export class Vault_json {
     if (!this.contract.write) {
       throw new Error('Wallet client is required for write operations');
     }
-    return this.contract.write.changeEmergencyPenalty([_newEmergencyPenalty] as const, options) as Promise<`0x${string}`>;
+    return this.contract.write.initialize(options) as Promise<`0x${string}`>;
   }
 
   /**
-   * changeEmergencyPenaltyReceiver
+   * onERC721Received
    * nonpayable
    * @param options Optional transaction parameters (value, gas, nonce, etc.)
    */
-  async changeEmergencyPenaltyReceiver(_newEmergencyPenaltyReveiver: `0x${string}`, options?: {
+  async onERC721Received(arg0: `0x${string}`, arg1: `0x${string}`, arg2: bigint, arg3: `0x${string}`, options?: {
     accessList?: import('viem').AccessList;
     authorizationList?: import('viem').AuthorizationList;
     chain?: import('viem').Chain | null;
@@ -956,15 +911,15 @@ export class Vault_json {
     if (!this.contract.write) {
       throw new Error('Wallet client is required for write operations');
     }
-    return this.contract.write.changeEmergencyPenaltyReceiver([_newEmergencyPenaltyReveiver] as const, options) as Promise<`0x${string}`>;
+    return this.contract.write.onERC721Received([arg0, arg1, arg2, arg3] as const, options) as Promise<`0x${string}`>;
   }
 
   /**
-   * changeSuccessFee
+   * renounceOwnership
    * nonpayable
    * @param options Optional transaction parameters (value, gas, nonce, etc.)
    */
-  async changeSuccessFee(_newSuccessFee: bigint, options?: {
+  async renounceOwnership(options?: {
     accessList?: import('viem').AccessList;
     authorizationList?: import('viem').AuthorizationList;
     chain?: import('viem').Chain | null;
@@ -979,15 +934,15 @@ export class Vault_json {
     if (!this.contract.write) {
       throw new Error('Wallet client is required for write operations');
     }
-    return this.contract.write.changeSuccessFee([_newSuccessFee] as const, options) as Promise<`0x${string}`>;
+    return this.contract.write.renounceOwnership(options) as Promise<`0x${string}`>;
   }
 
   /**
-   * changeSuccessFeeReceiver
+   * renounceRole
    * nonpayable
    * @param options Optional transaction parameters (value, gas, nonce, etc.)
    */
-  async changeSuccessFeeReceiver(_successFeeReceiver: `0x${string}`, options?: {
+  async renounceRole(role: `0x${string}`, account: `0x${string}`, options?: {
     accessList?: import('viem').AccessList;
     authorizationList?: import('viem').AuthorizationList;
     chain?: import('viem').Chain | null;
@@ -1002,15 +957,15 @@ export class Vault_json {
     if (!this.contract.write) {
       throw new Error('Wallet client is required for write operations');
     }
-    return this.contract.write.changeSuccessFeeReceiver([_successFeeReceiver] as const, options) as Promise<`0x${string}`>;
+    return this.contract.write.renounceRole([role, account] as const, options) as Promise<`0x${string}`>;
   }
 
   /**
-   * createDeposit
+   * revokeRole
    * nonpayable
    * @param options Optional transaction parameters (value, gas, nonce, etc.)
    */
-  async createDeposit(_tokens: `0x${string}`[], _amounts: bigint[], _term: bigint, receiver: `0x${string}`, options?: {
+  async revokeRole(role: `0x${string}`, account: `0x${string}`, options?: {
     accessList?: import('viem').AccessList;
     authorizationList?: import('viem').AuthorizationList;
     chain?: import('viem').Chain | null;
@@ -1025,15 +980,15 @@ export class Vault_json {
     if (!this.contract.write) {
       throw new Error('Wallet client is required for write operations');
     }
-    return this.contract.write.createDeposit([_tokens, _amounts, _term, receiver] as const, options) as Promise<`0x${string}`>;
+    return this.contract.write.revokeRole([role, account] as const, options) as Promise<`0x${string}`>;
   }
 
   /**
-   * emergencyWithdraw
+   * transferErc20
    * nonpayable
    * @param options Optional transaction parameters (value, gas, nonce, etc.)
    */
-  async emergencyWithdraw(_uid: bigint, options?: {
+  async transferErc20(token: `0x${string}`, payee: `0x${string}`, amount: bigint, options?: {
     accessList?: import('viem').AccessList;
     authorizationList?: import('viem').AuthorizationList;
     chain?: import('viem').Chain | null;
@@ -1048,15 +1003,15 @@ export class Vault_json {
     if (!this.contract.write) {
       throw new Error('Wallet client is required for write operations');
     }
-    return this.contract.write.emergencyWithdraw([_uid] as const, options) as Promise<`0x${string}`>;
+    return this.contract.write.transferErc20([token, payee, amount] as const, options) as Promise<`0x${string}`>;
   }
 
   /**
-   * renounceOwnership
+   * transferErc721
    * nonpayable
    * @param options Optional transaction parameters (value, gas, nonce, etc.)
    */
-  async renounceOwnership(options?: {
+  async transferErc721(token: `0x${string}`, payee: `0x${string}`, tokenId: bigint, options?: {
     accessList?: import('viem').AccessList;
     authorizationList?: import('viem').AuthorizationList;
     chain?: import('viem').Chain | null;
@@ -1071,15 +1026,15 @@ export class Vault_json {
     if (!this.contract.write) {
       throw new Error('Wallet client is required for write operations');
     }
-    return this.contract.write.renounceOwnership(options) as Promise<`0x${string}`>;
+    return this.contract.write.transferErc721([token, payee, tokenId] as const, options) as Promise<`0x${string}`>;
   }
 
   /**
-   * setAllowedToken
+   * transferEther
    * nonpayable
    * @param options Optional transaction parameters (value, gas, nonce, etc.)
    */
-  async setAllowedToken(_token: `0x${string}`, _stateView: `0x${string}`, _poolId: `0x${string}`, _isToken0: boolean, _status: boolean, options?: {
+  async transferEther(payee: `0x${string}`, amount: bigint, options?: {
     accessList?: import('viem').AccessList;
     authorizationList?: import('viem').AuthorizationList;
     chain?: import('viem').Chain | null;
@@ -1094,7 +1049,7 @@ export class Vault_json {
     if (!this.contract.write) {
       throw new Error('Wallet client is required for write operations');
     }
-    return this.contract.write.setAllowedToken([_token, _stateView, _poolId, _isToken0, _status] as const, options) as Promise<`0x${string}`>;
+    return this.contract.write.transferEther([payee, amount] as const, options) as Promise<`0x${string}`>;
   }
 
   /**
@@ -1121,11 +1076,34 @@ export class Vault_json {
   }
 
   /**
-   * withdraw
+   * upgradeTo
    * nonpayable
    * @param options Optional transaction parameters (value, gas, nonce, etc.)
    */
-  async withdraw(_uid: bigint, options?: {
+  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;
@@ -1140,7 +1118,7 @@ export class Vault_json {
     if (!this.contract.write) {
       throw new Error('Wallet client is required for write operations');
     }
-    return this.contract.write.withdraw([_uid] as const, options) as Promise<`0x${string}`>;
+    return this.contract.write.upgradeToAndCall([newImplementation, data] as const, options) as Promise<`0x${string}`>;
   }
 
 
@@ -1160,11 +1138,11 @@ export class Vault_json {
     }
     return {
       /**
-       * Simulate changeEmergencyPenalty
+       * Simulate batchTransferErc20
        * Returns gas estimate and result without sending transaction
        * @param options Optional transaction parameters (value, gas, nonce, etc.)
        */
-      async changeEmergencyPenalty(_newEmergencyPenalty: bigint, options?: {
+      async batchTransferErc20(tokens: `0x${string}`[], payees: `0x${string}`[], amounts: bigint[], options?: {
         accessList?: import('viem').AccessList;
         authorizationList?: import('viem').AuthorizationList;
         chain?: import('viem').Chain | null;
@@ -1176,14 +1154,14 @@ export class Vault_json {
         nonce?: number;
         value?: bigint;
       }): Promise<void> {
-        return contract.simulate.changeEmergencyPenalty([_newEmergencyPenalty] as const, options) as Promise<void>;
+        return contract.simulate.batchTransferErc20([tokens, payees, amounts] as const, options) as Promise<void>;
       },
       /**
-       * Simulate changeEmergencyPenaltyReceiver
+       * Simulate batchTransferErc721
        * Returns gas estimate and result without sending transaction
        * @param options Optional transaction parameters (value, gas, nonce, etc.)
        */
-      async changeEmergencyPenaltyReceiver(_newEmergencyPenaltyReveiver: `0x${string}`, options?: {
+      async batchTransferErc721(tokens: `0x${string}`[], payees: `0x${string}`[], tokenIds: bigint[], options?: {
         accessList?: import('viem').AccessList;
         authorizationList?: import('viem').AuthorizationList;
         chain?: import('viem').Chain | null;
@@ -1195,14 +1173,14 @@ export class Vault_json {
         nonce?: number;
         value?: bigint;
       }): Promise<void> {
-        return contract.simulate.changeEmergencyPenaltyReceiver([_newEmergencyPenaltyReveiver] as const, options) as Promise<void>;
+        return contract.simulate.batchTransferErc721([tokens, payees, tokenIds] as const, options) as Promise<void>;
       },
       /**
-       * Simulate changeSuccessFee
+       * Simulate batchTransferEther
        * Returns gas estimate and result without sending transaction
        * @param options Optional transaction parameters (value, gas, nonce, etc.)
        */
-      async changeSuccessFee(_newSuccessFee: bigint, options?: {
+      async batchTransferEther(payees: `0x${string}`[], amounts: bigint[], options?: {
         accessList?: import('viem').AccessList;
         authorizationList?: import('viem').AuthorizationList;
         chain?: import('viem').Chain | null;
@@ -1214,14 +1192,14 @@ export class Vault_json {
         nonce?: number;
         value?: bigint;
       }): Promise<void> {
-        return contract.simulate.changeSuccessFee([_newSuccessFee] as const, options) as Promise<void>;
+        return contract.simulate.batchTransferEther([payees, amounts] as const, options) as Promise<void>;
       },
       /**
-       * Simulate changeSuccessFeeReceiver
+       * Simulate grantRole
        * Returns gas estimate and result without sending transaction
        * @param options Optional transaction parameters (value, gas, nonce, etc.)
        */
-      async changeSuccessFeeReceiver(_successFeeReceiver: `0x${string}`, options?: {
+      async grantRole(role: `0x${string}`, account: `0x${string}`, options?: {
         accessList?: import('viem').AccessList;
         authorizationList?: import('viem').AuthorizationList;
         chain?: import('viem').Chain | null;
@@ -1233,14 +1211,14 @@ export class Vault_json {
         nonce?: number;
         value?: bigint;
       }): Promise<void> {
-        return contract.simulate.changeSuccessFeeReceiver([_successFeeReceiver] as const, options) as Promise<void>;
+        return contract.simulate.grantRole([role, account] as const, options) as Promise<void>;
       },
       /**
-       * Simulate createDeposit
+       * Simulate initialize
        * Returns gas estimate and result without sending transaction
        * @param options Optional transaction parameters (value, gas, nonce, etc.)
        */
-      async createDeposit(_tokens: `0x${string}`[], _amounts: bigint[], _term: bigint, receiver: `0x${string}`, options?: {
+      async initialize(options?: {
         accessList?: import('viem').AccessList;
         authorizationList?: import('viem').AuthorizationList;
         chain?: import('viem').Chain | null;
@@ -1251,15 +1229,15 @@ export class Vault_json {
         maxPriorityFeePerGas?: bigint;
         nonce?: number;
         value?: bigint;
-      }): Promise<bigint> {
-        return contract.simulate.createDeposit([_tokens, _amounts, _term, receiver] as const, options) as Promise<bigint>;
+      }): Promise<void> {
+        return contract.simulate.initialize(options) as Promise<void>;
       },
       /**
-       * Simulate emergencyWithdraw
+       * Simulate onERC721Received
        * Returns gas estimate and result without sending transaction
        * @param options Optional transaction parameters (value, gas, nonce, etc.)
        */
-      async emergencyWithdraw(_uid: bigint, options?: {
+      async onERC721Received(arg0: `0x${string}`, arg1: `0x${string}`, arg2: bigint, arg3: `0x${string}`, options?: {
         accessList?: import('viem').AccessList;
         authorizationList?: import('viem').AuthorizationList;
         chain?: import('viem').Chain | null;
@@ -1270,8 +1248,8 @@ export class Vault_json {
         maxPriorityFeePerGas?: bigint;
         nonce?: number;
         value?: bigint;
-      }): Promise<void> {
-        return contract.simulate.emergencyWithdraw([_uid] as const, options) as Promise<void>;
+      }): Promise<`0x${string}`> {
+        return contract.simulate.onERC721Received([arg0, arg1, arg2, arg3] as const, options) as Promise<`0x${string}`>;
       },
       /**
        * Simulate renounceOwnership
@@ -1293,11 +1271,87 @@ export class Vault_json {
         return contract.simulate.renounceOwnership(options) as Promise<void>;
       },
       /**
-       * Simulate setAllowedToken
+       * Simulate renounceRole
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async renounceRole(role: `0x${string}`, account: `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.renounceRole([role, account] as const, options) as Promise<void>;
+      },
+      /**
+       * Simulate revokeRole
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async revokeRole(role: `0x${string}`, account: `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.revokeRole([role, account] as const, options) as Promise<void>;
+      },
+      /**
+       * Simulate transferErc20
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async transferErc20(token: `0x${string}`, payee: `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.transferErc20([token, payee, amount] as const, options) as Promise<void>;
+      },
+      /**
+       * Simulate transferErc721
+       * Returns gas estimate and result without sending transaction
+       * @param options Optional transaction parameters (value, gas, nonce, etc.)
+       */
+      async transferErc721(token: `0x${string}`, payee: `0x${string}`, tokenId: 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.transferErc721([token, payee, tokenId] as const, options) as Promise<void>;
+      },
+      /**
+       * Simulate transferEther
        * Returns gas estimate and result without sending transaction
        * @param options Optional transaction parameters (value, gas, nonce, etc.)
        */
-      async setAllowedToken(_token: `0x${string}`, _stateView: `0x${string}`, _poolId: `0x${string}`, _isToken0: boolean, _status: boolean, options?: {
+      async transferEther(payee: `0x${string}`, amount: bigint, options?: {
         accessList?: import('viem').AccessList;
         authorizationList?: import('viem').AuthorizationList;
         chain?: import('viem').Chain | null;
@@ -1309,7 +1363,7 @@ export class Vault_json {
         nonce?: number;
         value?: bigint;
       }): Promise<void> {
-        return contract.simulate.setAllowedToken([_token, _stateView, _poolId, _isToken0, _status] as const, options) as Promise<void>;
+        return contract.simulate.transferEther([payee, amount] as const, options) as Promise<void>;
       },
       /**
        * Simulate transferOwnership
@@ -1331,11 +1385,30 @@ export class Vault_json {
         return contract.simulate.transferOwnership([newOwner] as const, options) as Promise<void>;
       },
       /**
-       * Simulate withdraw
+       * 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 withdraw(_uid: bigint, options?: {
+      async upgradeToAndCall(newImplementation: `0x${string}`, data: `0x${string}`, options?: {
         accessList?: import('viem').AccessList;
         authorizationList?: import('viem').AuthorizationList;
         chain?: import('viem').Chain | null;
@@ -1347,7 +1420,7 @@ export class Vault_json {
         nonce?: number;
         value?: bigint;
       }): Promise<void> {
-        return contract.simulate.withdraw([_uid] as const, options) as Promise<void>;
+        return contract.simulate.upgradeToAndCall([newImplementation, data] as const, options) as Promise<void>;
       }
     };
   }
@@ -1367,16 +1440,16 @@ export class Vault_json {
   get watch() {
     return {
       /**
-       * Watch NewDeposit events
+       * Watch AdminChanged events
        * @param callback Function to call when event is emitted
        * @param filter Optional filter for indexed parameters
        * @returns Unwatch function to stop listening
        */
-      NewDeposit: (callback: (event: { uid: bigint; startTimestamp: bigint; endTimestamp: bigint; tokens: `0x${string}`[]; amounts: bigint[]; prices: bigint[]; receiver: `0x${string}` }) => void) => {
+      AdminChanged: (callback: (event: { previousAdmin: `0x${string}`; newAdmin: `0x${string}` }) => void) => {
         return this.publicClient.watchContractEvent({
           address: this.contractAddress,
           abi: Vault_jsonAbi,
-          eventName: 'NewDeposit',
+          eventName: 'AdminChanged',
           
           onLogs: (logs: any[]) => {
             logs.forEach((log: any) => {
@@ -1386,16 +1459,16 @@ export class Vault_json {
         }) as () => void;
       },
       /**
-       * Watch OwnershipTransferred events
+       * Watch BeaconUpgraded 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}` }) => {
+      BeaconUpgraded: (callback: (event: { beacon: `0x${string}` }) => void, filter?: { beacon: `0x${string}` }) => {
         return this.publicClient.watchContractEvent({
           address: this.contractAddress,
           abi: Vault_jsonAbi,
-          eventName: 'OwnershipTransferred',
+          eventName: 'BeaconUpgraded',
           args: filter,
           onLogs: (logs: any[]) => {
             logs.forEach((log: any) => {
@@ -1405,35 +1478,16 @@ export class Vault_json {
         }) as () => void;
       },
       /**
-       * Watch SetEmergencyPenalty events
-       * @param callback Function to call when event is emitted
-       * @param filter Optional filter for indexed parameters
-       * @returns Unwatch function to stop listening
-       */
-      SetEmergencyPenalty: (callback: (event: { emergencyPenalty: bigint }) => void) => {
-        return this.publicClient.watchContractEvent({
-          address: this.contractAddress,
-          abi: Vault_jsonAbi,
-          eventName: 'SetEmergencyPenalty',
-          
-          onLogs: (logs: any[]) => {
-            logs.forEach((log: any) => {
-              callback(log.args as any);
-            });
-          },
-        }) as () => void;
-      },
-      /**
-       * Watch SetEmergencyPenaltyReceiver events
+       * Watch Initialized events
        * @param callback Function to call when event is emitted
        * @param filter Optional filter for indexed parameters
        * @returns Unwatch function to stop listening
        */
-      SetEmergencyPenaltyReceiver: (callback: (event: { emergencyPenaltyReceiver: `0x${string}` }) => void) => {
+      Initialized: (callback: (event: { version: bigint }) => void) => {
         return this.publicClient.watchContractEvent({
           address: this.contractAddress,
           abi: Vault_jsonAbi,
-          eventName: 'SetEmergencyPenaltyReceiver',
+          eventName: 'Initialized',
           
           onLogs: (logs: any[]) => {
             logs.forEach((log: any) => {
@@ -1443,17 +1497,17 @@ export class Vault_json {
         }) as () => void;
       },
       /**
-       * Watch SetSuccessFee events
+       * 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
        */
-      SetSuccessFee: (callback: (event: { successFee: bigint }) => void) => {
+      OwnershipTransferred: (callback: (event: { previousOwner: `0x${string}`; newOwner: `0x${string}` }) => void, filter?: { previousOwner: `0x${string}`; newOwner: `0x${string}` }) => {
         return this.publicClient.watchContractEvent({
           address: this.contractAddress,
           abi: Vault_jsonAbi,
-          eventName: 'SetSuccessFee',
-          
+          eventName: 'OwnershipTransferred',
+          args: filter,
           onLogs: (logs: any[]) => {
             logs.forEach((log: any) => {
               callback(log.args as any);
@@ -1462,17 +1516,17 @@ export class Vault_json {
         }) as () => void;
       },
       /**
-       * Watch SetSuccessFeeReceiver events
+       * Watch RoleAdminChanged events
        * @param callback Function to call when event is emitted
        * @param filter Optional filter for indexed parameters
        * @returns Unwatch function to stop listening
        */
-      SetSuccessFeeReceiver: (callback: (event: { successFeeReceiver: `0x${string}` }) => void) => {
+      RoleAdminChanged: (callback: (event: { role: `0x${string}`; previousAdminRole: `0x${string}`; newAdminRole: `0x${string}` }) => void, filter?: { role: `0x${string}`; previousAdminRole: `0x${string}`; newAdminRole: `0x${string}` }) => {
         return this.publicClient.watchContractEvent({
           address: this.contractAddress,
           abi: Vault_jsonAbi,
-          eventName: 'SetSuccessFeeReceiver',
-          
+          eventName: 'RoleAdminChanged',
+          args: filter,
           onLogs: (logs: any[]) => {
             logs.forEach((log: any) => {
               callback(log.args as any);
@@ -1481,17 +1535,17 @@ export class Vault_json {
         }) as () => void;
       },
       /**
-       * Watch SuccessFeeCharged events
+       * Watch RoleGranted events
        * @param callback Function to call when event is emitted
        * @param filter Optional filter for indexed parameters
        * @returns Unwatch function to stop listening
        */
-      SuccessFeeCharged: (callback: (event: { uid: bigint; token: `0x${string}`; amount: bigint }) => void) => {
+      RoleGranted: (callback: (event: { role: `0x${string}`; account: `0x${string}`; sender: `0x${string}` }) => void, filter?: { role: `0x${string}`; account: `0x${string}`; sender: `0x${string}` }) => {
         return this.publicClient.watchContractEvent({
           address: this.contractAddress,
           abi: Vault_jsonAbi,
-          eventName: 'SuccessFeeCharged',
-          
+          eventName: 'RoleGranted',
+          args: filter,
           onLogs: (logs: any[]) => {
             logs.forEach((log: any) => {
               callback(log.args as any);
@@ -1500,17 +1554,17 @@ export class Vault_json {
         }) as () => void;
       },
       /**
-       * Watch TokenUpdated events
+       * Watch RoleRevoked events
        * @param callback Function to call when event is emitted
        * @param filter Optional filter for indexed parameters
        * @returns Unwatch function to stop listening
        */
-      TokenUpdated: (callback: (event: { token: `0x${string}`; stateView: `0x${string}`; poolId: `0x${string}`; isToken0: boolean; status: boolean }) => void) => {
+      RoleRevoked: (callback: (event: { role: `0x${string}`; account: `0x${string}`; sender: `0x${string}` }) => void, filter?: { role: `0x${string}`; account: `0x${string}`; sender: `0x${string}` }) => {
         return this.publicClient.watchContractEvent({
           address: this.contractAddress,
           abi: Vault_jsonAbi,
-          eventName: 'TokenUpdated',
-          
+          eventName: 'RoleRevoked',
+          args: filter,
           onLogs: (logs: any[]) => {
             logs.forEach((log: any) => {
               callback(log.args as any);
@@ -1519,16 +1573,16 @@ export class Vault_json {
         }) as () => void;
       },
       /**
-       * Watch Withdraw events
+       * Watch Upgraded 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}`; uid: bigint; isEmergency: boolean }) => void, filter?: { user: `0x${string}` }) => {
+      Upgraded: (callback: (event: { implementation: `0x${string}` }) => void, filter?: { implementation: `0x${string}` }) => {
         return this.publicClient.watchContractEvent({
           address: this.contractAddress,
           abi: Vault_jsonAbi,
-          eventName: 'Withdraw',
+          eventName: 'Upgraded',
           args: filter,
           onLogs: (logs: any[]) => {
             logs.forEach((log: any) => {