[list actions] move list actions to sdk

Author: mike-diamond

README.md

@@ -16,6 +16,8 @@ import getExitQueuePositions from './requests/getExitQueuePositions'
 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'
 
 
 export default {
@@ -37,5 +39,7 @@ export default {
     deposit,
     withdraw,
     claimExitQueue,
+    updateWhitelist,
+    updateBlocklist,
   },
 } as const

src/methods/vault/index.ts

@@ -0,0 +1,43 @@
+import { UpdateBlocklistInput } from './types'
+import { validateArgs } from '../../../../utils'
+import { vaultMulticall } from '../../../../contracts'
+
+
+const validateList = (blocklist: UpdateBlocklistInput['blocklist']) => {
+  const isValid = blocklist.every((blocklistItem) => (
+    blocklistItem
+    && typeof blocklistItem === 'object'
+    && typeof blocklistItem.address === 'string'
+    && typeof blocklistItem.isNew === 'boolean'
+  ))
+
+  if (!isValid) {
+    throw new Error('The "blocklist" argument must be an array of objects with "address" and "isNew" properties')
+  }
+}
+
+export const commonLogic = (values: UpdateBlocklistInput) => {
+  const { options, contracts, userAddress, vaultAddress, blocklist } = values
+
+  validateArgs.array({ blocklist })
+  validateArgs.address({ vaultAddress, userAddress })
+  validateList(blocklist)
+
+  const multicallCommonArgs: Omit<Parameters<typeof vaultMulticall>[0], 'request'> = {
+    vaultContract: contracts.helpers.createBlocklistVault(vaultAddress),
+    keeperContract: contracts.base.keeper,
+    vaultAddress,
+    userAddress,
+    options,
+  }
+
+  const params: Parameters<typeof vaultMulticall>[0]['request']['params'] = blocklist.map(({ address, isNew }) => ({
+    method: 'updateBlocklist',
+    args: [ address, isNew ],
+  }))
+
+  return {
+    params,
+    multicallCommonArgs,
+  }
+}

src/methods/vault/transactions/updateBlocklist/common.ts

@@ -0,0 +1 @@
+export { default as updateBlocklist } from './updateBlocklist'

src/methods/vault/transactions/updateBlocklist/index.ts

@@ -0,0 +1,21 @@
+import updateBlocklistGas from './updateBlocklistGas'
+import updateBlocklistEncode from './updateBlocklistEncode'
+
+
+export type UpdateBlocklistInput = {
+  blocklist: Array<{
+    address: string
+    isNew: boolean
+  }>
+  userAddress: string
+  vaultAddress: string
+  options: StakeWise.Options
+  provider: StakeWise.Provider
+  contracts: StakeWise.Contracts
+}
+
+export interface UpdateBlocklist {
+  (values: UpdateBlocklistInput): Promise<StakeWise.TransactionHash>
+  estimateGas: typeof updateBlocklistGas
+  encode: typeof updateBlocklistEncode
+}

src/methods/vault/transactions/updateBlocklist/types.d.ts

@@ -0,0 +1,25 @@
+import { UpdateBlocklist } from './types'
+import { commonLogic } from './common'
+import updateBlocklistGas from './updateBlocklistGas'
+import updateBlocklistEncode from './updateBlocklistEncode'
+import { vaultMulticall } from '../../../../contracts'
+
+
+const updateBlocklist: UpdateBlocklist = async (values) => {
+  const { params, multicallCommonArgs } = commonLogic(values)
+
+  const result = await vaultMulticall<{ hash: string }>({
+    ...multicallCommonArgs,
+    request: {
+      params,
+    },
+  })
+
+  return result.hash
+}
+
+updateBlocklist.encode = updateBlocklistEncode
+updateBlocklist.estimateGas = updateBlocklistGas
+
+
+export default updateBlocklist

src/methods/vault/transactions/updateBlocklist/updateBlocklist.ts

@@ -0,0 +1,24 @@
+import { commonLogic } from './common'
+import { UpdateBlocklistInput } from './types'
+import { vaultMulticall } from '../../../../contracts'
+
+
+const updateBlocklistEncode = async (values: UpdateBlocklistInput): Promise<StakeWise.TransactionData> => {
+  const { params, multicallCommonArgs } = commonLogic(values)
+
+  const rx = await vaultMulticall<{ data: string, to: string }>({
+    ...multicallCommonArgs,
+    request: {
+      params,
+      transactionData: true,
+    },
+  })
+
+  return {
+    data: rx.data,
+    to: rx.to,
+  }
+}
+
+
+export default updateBlocklistEncode

src/methods/vault/transactions/updateBlocklist/updateBlocklistEncode.ts

@@ -0,0 +1,24 @@
+import { commonLogic } from './common'
+import { UpdateBlocklistInput } from './types'
+import { getGas } from '../../../../utils'
+import { vaultMulticall } from '../../../../contracts'
+
+
+const updateBlocklistGas = async (values: UpdateBlocklistInput) => {
+  const { params, multicallCommonArgs } = commonLogic(values)
+
+  const estimatedGas = await vaultMulticall<bigint>({
+    ...multicallCommonArgs,
+    request: {
+      estimateGas: true,
+      params,
+    },
+  })
+
+  const gas = await getGas({ estimatedGas, provider: values.provider })
+
+  return gas
+}
+
+
+export default updateBlocklistGas

src/methods/vault/transactions/updateBlocklist/updateBlocklistGas.ts

@@ -3,56 +3,38 @@ import { validateArgs } from '../../../../utils'
 import { vaultMulticall } from '../../../../contracts'
 
 
-export const commonLogic = async (values: UpdateWhitelistInput) => {
-  const { options, contracts, assets, vaultAddress, userAddress } = values
+const validateList = (whitelist: UpdateWhitelistInput['whitelist']) => {
+  const isValid = whitelist.every((whitelistItem) => (
+    whitelistItem
+    && typeof whitelistItem === 'object'
+    && typeof whitelistItem.address === 'string'
+    && typeof whitelistItem.isNew === 'boolean'
+  ))
+
+  if (!isValid) {
+    throw new Error('The "whitelist" argument must be an array of objects with "address" and "isNew" properties')
+  }
+}
 
-  validateArgs.bigint({ assets })
-  validateArgs.address({ vaultAddress, userAddress })
+export const commonLogic = (values: UpdateWhitelistInput) => {
+  const { options, contracts, userAddress, vaultAddress, whitelist } = values
 
-  const params: Parameters<typeof vaultMulticall>[0]['request']['params'] = []
+  validateArgs.array({ whitelist })
+  validateArgs.address({ vaultAddress, userAddress })
+  validateList(whitelist)
 
   const multicallCommonArgs: Omit<Parameters<typeof vaultMulticall>[0], 'request'> = {
-    vaultContract: contracts.helpers.createVault(vaultAddress),
+    vaultContract: contracts.helpers.createPrivateVault(vaultAddress),
     keeperContract: contracts.base.keeper,
     vaultAddress,
     userAddress,
     options,
   }
 
-  const isCollateralized = await contracts.base.keeper.isCollateralized(vaultAddress)
-
-  if (isCollateralized) {
-    const result = await vaultMulticall<[ { shares: bigint } ]>({
-      ...multicallCommonArgs,
-      request: {
-        params: [ { method: 'convertToShares', args: [ assets ] } ],
-        callStatic: true,
-      },
-    })
-
-    const exitQueueShares = result[0].shares
-
-    params.push({
-      method: 'enterExitQueue',
-      args: [ exitQueueShares, userAddress ],
-    })
-  }
-  else {
-    const result = await vaultMulticall<[ { shares: bigint } ]>({
-      ...multicallCommonArgs,
-      request: {
-        params: [ { method: 'convertToShares', args: [ assets ] } ],
-        callStatic: true,
-      },
-    })
-
-    const shares = result[0].shares
-
-    params.push({
-       method: 'redeem',
-       args: [ shares, userAddress ],
-    })
-  }
+  const params: Parameters<typeof vaultMulticall>[0]['request']['params'] = whitelist.map(({ address, isNew }) => ({
+    method: 'updateWhitelist',
+    args: [ address, isNew ],
+  }))
 
   return {
     params,

src/methods/vault/transactions/updateWhitelist/common.ts

@@ -7,6 +7,7 @@ export type UpdateWhitelistInput = {
     address: string
     isNew: boolean
   }>
+  userAddress: string
   vaultAddress: string
   options: StakeWise.Options
   provider: StakeWise.Provider

src/methods/vault/transactions/updateWhitelist/types.d.ts

@@ -6,7 +6,7 @@ import { vaultMulticall } from '../../../../contracts'
 
 
 const updateWhitelist: UpdateWhitelist = async (values) => {
-  const { params, multicallCommonArgs } = await commonLogic(values)
+  const { params, multicallCommonArgs } = commonLogic(values)
 
   const result = await vaultMulticall<{ hash: string }>({
     ...multicallCommonArgs,

src/methods/vault/transactions/updateWhitelist/updateWhitelist.ts

@@ -1,10 +1,10 @@
 import { commonLogic } from './common'
-import { WithdrawInput } from './types'
+import { UpdateWhitelistInput } from './types'
 import { vaultMulticall } from '../../../../contracts'
 
 
-const updateWhitelistEncode = async (values: WithdrawInput): Promise<StakeWise.TransactionData> => {
-  const { params, multicallCommonArgs } = await commonLogic(values)
+const updateWhitelistEncode = async (values: UpdateWhitelistInput): Promise<StakeWise.TransactionData> => {
+  const { params, multicallCommonArgs } = commonLogic(values)
 
   const rx = await vaultMulticall<{ data: string, to: string }>({
     ...multicallCommonArgs,

src/methods/vault/transactions/updateWhitelist/updateWhitelistEncode.ts

@@ -1,11 +1,11 @@
 import { commonLogic } from './common'
-import { WithdrawInput } from './types'
+import { UpdateWhitelistInput } from './types'
 import { getGas } from '../../../../utils'
 import { vaultMulticall } from '../../../../contracts'
 
 
-const updateWhitelistGas = async (values: WithdrawInput) => {
-  const { params, multicallCommonArgs } = await commonLogic(values)
+const updateWhitelistGas = async (values: UpdateWhitelistInput) => {
+  const { params, multicallCommonArgs } = commonLogic(values)
 
   const estimatedGas = await vaultMulticall<bigint>({
     ...multicallCommonArgs,

src/methods/vault/transactions/updateWhitelist/updateWhitelistGas.ts

@@ -33,8 +33,17 @@ const number = (values: Record<string, number>) => {
   })
 }
 
+const array = (values: Record<string, any[]>) => {
+  Object.keys(values).forEach((key) => {
+    if (!Array.isArray(values[key])) {
+      throw new Error(`The "${key}" argument must be an array`)
+    }
+  })
+}
+
 
 export default {
+  array,
   bigint,
   string,
   number,