SDK vault methods

README.md

@@ -120,13 +120,12 @@ promise.abort()
 ```
 
 ##### Table of transactions:
-| **Vault**                                             | **osToken** |
-|-------------------------------------------------------|------|
-| [sdk.vault.deposit](#sdkvaultdeposit)                 | [sdk.osToken.mint](#sdkostokenmint) |
-| [sdk.vault.withdraw](#sdkvaultwithdraw)               | [sdk.osToken.burn](#sdkostokenburn) |
-| [sdk.vault.claimExitQueue](#sdkvaultclaimexitqueue)   |
-| [sdk.vault.updateWhitelist](#sdkvaultupdatewhitelist) |
-| [sdk.vault.updateBlocklist](#sdkvaultupdateblocklist)     |
+| **Vault**                                                                   | **osToken** |
+|-----------------------------------------------------------------------------|------|
+| [sdk.vault.deposit](#sdkvaultdeposit)                                       | [sdk.osToken.mint](#sdkostokenmint) |
+| [sdk.vault.withdraw](#sdkvaultwithdraw)                                     | [sdk.osToken.burn](#sdkostokenburn) |
+| [sdk.claimExitQueue](#sdkvaultclaimexitqueue)                               |
+| [sdk.vault.operate](#sdkvaultoperate)                     |
 
 ## API-Vault
 
@@ -1099,95 +1098,92 @@ const { data, to } = await sdk.vault.claimExitQueue.encode(params)
 const gas = await sdk.vault.claimExitQueue.estimateGas(params)
 ```
 ---
-### `sdk.vault.updateWhitelist`
+### `sdk.vault.operate`
 
 #### Description:
 
-Update the whitelist of addresses for a private vault.
-The whitelist contains addresses allowed to stake or mint within
-the private vault. This method can only be called by the vault
-access manager.
+Updates the vault by authorized personnel such as the vault admin, whitelister, blocklist manager, or keys manager.
 
 
 #### Arguments:
 
-| Name | Type                                         | Required | Description                                                                                                                 |
-|------|----------------------------------------------|-------------|-----------------------------------------------------------------------------------------------------------------------------|
-| whitelist | `Array<{ address: string, isNew: boolean }>` | **Yes** | List of addresses to update the whitelist. Use `isNew: true` to add a new address, `isNew: false` to remove an existing one |
-| userAddress | `string`                                     | **Yes** | The address of the user making the update (access manager)                                                                                 |
-| vaultAddress | `string`                                     | **Yes** | The address of the private vault                                                                                            |
+| Name         | Type                                         | Required | Access            | Description                                                                                                                 |
+|--------------|----------------------------------------------|----------|-------------------|-----------------------------------------------------------------------------------------------------------------------------|
+| whitelist    | `Array<{ address: string, isNew: boolean }>` | **No**   | Whitelister       | List of addresses to update the whitelist. Use `isNew: true` to add a new address, `isNew: false` to remove an existing one |
+| blocklist    | `Array<{ address: string, isNew: boolean }>` | **No**   | Blocklist manager | List of addresses to update the blocklist. Use `isNew: true` to add a new address, `isNew: false` to remove an existing one |
+| keysManager  | `string`                                     | **No**   | Admin             | Address of the vault keys manager                                                                                           |
+| whitelister  | `string`                                     | **No**   | Admin             | Address of the vault whitelister                                                                                            |
+| feeRecipient  | `string`                                     | **No**   | Admin             | Address of the vault fee recipient                                                                                          |
+| validatorsRoot  | `string`                                     | **No**   | Keys manager      | The vault validators merkle tree root                                                                                       |
+| blocklistManager  | `string`                                     | **No**   | Admin             | The blocklisted vault blocklist manager                                                                                     |
+| metadataIpfsHash    | `string`                                     | **No**   | Admin             | The vault metadata IPFS hash                                                                                                |
+| userAddress  | `string`                                     | **Yes**  | -                 | The address of the user making the update (admin, whitelister, blocklist manager or keys manager)                           |
+| vaultAddress | `string`                                     | **Yes**  | -                 | The address of the vault                                                                                                    |
 
 #### Example:
 
 ```ts
-const whitelist = [
-  {
-    address: '0x...',
-    isNew: true,
-  },
-  {
-    address: '0x...',
-    isNew: false,
-  },
-]
-
+// Data to update the vault by admin.
 const params = {
-  whitelist,
+  keysManager: '0x...',
+  whitelister: '0x...',
+  feeRecipient: '0x...',
+  validatorsRoot: '0x...',
+  blocklistManager: '0x...',
+  metadataIpfsHash: '...',
   vaultAddress: '0x...',
   userAddress: '0x...',
 }
 
-// Send transaction
-const hash = await sdk.vault.updateWhitelist(params)
-// When you sign transactions on the backend (for custodians)
-const { data, to } = await sdk.vault.updateWhitelist.encode(params)
-// Get an approximate gas per transaction
-const gas = await sdk.vault.updateWhitelist.estimateGas(params)
-```
----
-### `sdk.vault.updateBlocklist`
-
-#### Description:
-
-Update the blocklist of addresses for a blocklisted vault.
-The blocklist contains addresses disallowed to stake or mint within
-the blocklisted vault. This method can only be called by the vault
-access manager.
-
-#### Arguments:
-
-| Name         | Type                                         | Required | Description                                                                                                                  |
-|--------------|----------------------------------------------|-------------|------------------------------------------------------------------------------------------------------------------------------|
-| blocklist    | `Array<{ address: string, isNew: boolean }>` | **Yes** | List of addresses to update the blocklist. Use `isNew: true` to add a new address, `isNew: false` to remove an existing one  |
-| userAddress  | `string`                                     | **Yes** | The address of the user making the update (access manager)                                                                   |
-| vaultAddress | `string`                                     | **Yes** | The address of the blocklisted vault                                                                                         |
-
-#### Example:
+// Data to update the vault by vault keys manager.
+const params = {
+  validatorsRoot: '...',
+  vaultAddress: '0x...',
+  userAddress: '0x...',
+}
 
-```ts
-const blocklist = [
-  {
-    address: '0x...',
-    isNew: true,
-  },
-  {
-    address: '0x...',
-    isNew: false,
-  },
-]
+// Data to update the private vault by whitelister.
+// The whitelist contains addresses allowed to stake or mint within
+// the vault.
+const params = {
+  whitelist: [
+    {
+      address: '0x...',
+      isNew: true,
+    },
+    {
+      address: '0x...',
+      isNew: false,
+    },
+  ],
+  vaultAddress: '0x...',
+  userAddress: '0x...',
+}
 
+// Data to update blocklisted vault by blocklist manager. 
+// The blocklist contains addresses disallowed to stake or mint within
+// the vault.
 const params = {
-  blocklist,
+  blocklist: [
+    {
+      address: '0x...',
+      isNew: true,
+    },
+    {
+      address: '0x...',
+      isNew: false,
+    },
+  ],
   vaultAddress: '0x...',
   userAddress: '0x...',
 }
 
 // Send transaction
-const hash = await sdk.vault.updateBlocklist(params)
+const hash = await sdk.vault.operate(params)
 // When you sign transactions on the backend (for custodians)
-const { data, to } = await sdk.vault.updateBlocklist.encode(params)
+const { data, to } = await sdk.vault.operate.encode(params)
 // Get an approximate gas per transaction
-const gas = await sdk.vault.updateBlockList.estimateGas(params)
+const gas = await sdk.vault.operate.estimateGas(params)
 ```
 ---
 ### `sdk.osToken.mint`

src/contracts/abis/BlocklistVaultDiffAbi.json

@@ -1,4 +1,17 @@
 [
+  {
+    "inputs": [],
+    "name": "blocklistManager",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
   {
     "inputs": [
       {

src/contracts/abis/PrivateVaultDiffAbi.json

@@ -1,4 +1,17 @@
 [
+  {
+    "inputs": [],
+    "name": "whitelister",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
   {
     "inputs": [
       {

src/contracts/abis/VaultAbi.json

@@ -441,6 +441,32 @@
     "stateMutability": "nonpayable",
     "type": "function"
   },
+  {
+    "inputs": [],
+    "name": "admin",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "keysManager",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
   {
     "inputs": [
       {

src/contracts/createContracts.ts

@@ -119,7 +119,7 @@ export const createContracts = (input: CreateContractsInput) => {
       createVault: (address: string) => createContract<StakeWise.ABI.Vault>(address, VaultAbi, provider),
       createUniswapPool: (address: string) => createContract<StakeWise.ABI.UniswapPool>(address, UniswapPoolAbi, provider),
       createPrivateVault: (address: string) => createContract<StakeWise.ABI.PrivateVault>(address, PrivateVaultAbi, provider),
-      createBlocklistVault: (address: string) => createContract<StakeWise.ABI.BlocklistVault>(address, BlocklistVaultAbi, provider),
+      createBlocklistedVault: (address: string) => createContract<StakeWise.ABI.BlocklistVault>(address, BlocklistVaultAbi, provider),
       createRewardSplitter: (address: string) => createContract<StakeWise.ABI.RewardSplitter>(address, RewardSplitterAbi, provider),
       createOtherTokenVault: (address: string) => createContract<StakeWise.ABI.OtherTokenVault>(address, OtherTokenVaultAbi, provider),
       createVestingEscrowDirect: (address: string) => createContract<StakeWise.ABI.VestingEscrow>(address, VestingEscrowAbi, provider),

src/contracts/vaultMulticall.ts

@@ -24,6 +24,15 @@ type VaultMulticallInput = {
   vaultContract: VaultAbi | OtherTokenVaultAbi
 }
 
+// Methods with _checkHarvested() call
+const harvestCheckMethods = [
+  'deposit',
+  'mintOsToken',
+  'enterExitQueue',
+  'setFeeRecipient',
+  'claimExitedAssets',
+]
+
 const vaultMulticall = async <T extends unknown>(values: VaultMulticallInput): Promise<T> => {
   const { options, vaultAddress, userAddress, request, vaultContract, keeperContract } = values
   const { params, callStatic, estimateGas, transactionData } = request
@@ -44,15 +53,21 @@ const vaultMulticall = async <T extends unknown>(values: VaultMulticallInput): P
     contract = vaultContract.connect(signer)
   }
 
-  const [ harvestParams, canHarvest ] = await Promise.all([
-    getHarvestParams({ options, vaultAddress }),
-    keeperContract.canHarvest(vaultAddress),
-  ])
+  let canHarvest = false
 
-  if (canHarvest) {
-    const fragment = contract.interface.encodeFunctionData('updateState', [ harvestParams ])
+  const needHarvest = params.some(({ method }) => harvestCheckMethods.includes(method))
 
-    calls.push(fragment)
+  if (needHarvest) {
+    const [ harvestParams ] = await Promise.all([
+      getHarvestParams({ options, vaultAddress }),
+      keeperContract.canHarvest(vaultAddress).then((value) => canHarvest = value),
+    ])
+
+    if (canHarvest) {
+      const fragment = contract.interface.encodeFunctionData('updateState', [ harvestParams ])
+
+      calls.push(fragment)
+    }
   }
 
   params.forEach(({ method, args }) => {

src/methods/vault/index.ts

@@ -13,11 +13,10 @@ import getScorePercentiles from './requests/getScorePercentiles'
 import getExitQueuePositions from './requests/getExitQueuePositions'
 
 // Transactions
-import { deposit } from './transactions/deposit'
-import { withdraw } from './transactions/withdraw'
-import { claimExitQueue } from './transactions/claimExitQueue'
-import { updateWhitelist } from './transactions/updateWhitelist'
-import { updateBlocklist } from './transactions/updateBlocklist'
+import { default as deposit } from './transactions/deposit'
+import { default as operate } from './transactions/operate'
+import { default as withdraw } from './transactions/withdraw'
+import { default as claimExitQueue } from './transactions/claimExitQueue'
 
 
 export default {
@@ -37,9 +36,8 @@ export default {
   },
   transactions: {
     deposit,
+    operate,
     withdraw,
     claimExitQueue,
-    updateWhitelist,
-    updateBlocklist,
   },
 } as const

src/methods/vault/requests/getExitQueuePositions/index.ts

@@ -1,6 +1,7 @@
 import { validateArgs } from '../../../../utils'
 import parseExitRequests from './parseExitRequests'
 import fetchExitQueuePositions from './fetchExitQueuePositions'
+import type { ParseExitRequestsOutput } from './parseExitRequests'
 import type { FetchExitQueuePositionsInput } from './fetchExitQueuePositions'
 
 
@@ -16,7 +17,7 @@ const mock = {
   withdrawable: 0n,
 }
 
-const getExitQueuePositions = async (input: GetExitQueuePositionsInput) => {
+const getExitQueuePositions = async (input: GetExitQueuePositionsInput): Promise<ParseExitRequestsOutput> => {
   const { options, contracts, provider, vaultAddress, userAddress } = input
 
   validateArgs.address({ vaultAddress, userAddress })

src/methods/vault/requests/getExitQueuePositions/parseExitRequests.ts

@@ -22,7 +22,7 @@ type Position = {
   timestamp: string
 }
 
-type ParseExitRequestsOutput = {
+export type ParseExitRequestsOutput = {
   total: bigint
   withdrawable: bigint
   positions: Position[]