SDK vault methods (#84)

* [sdk vault methods] update transactions

* [sdk vault methods] update check access

* [sdk vault methods] update methods

* [sdk vault methods] add operate multicall

* [sdk vault methods] update sdk multicall

* [sdk vault methods] update sdk multicall

* [sdk vault methods] update readme

* [sdk vault methods] update sdk

* [sdk vault methods] update sdk

* [sdk vault methods] fix types

* [sdk vault methods] update readme

* [sdk vault methods] update deps

* [sdk vault methods] update validation

* [sdk vault methods] update operate contract

* [sdk vault methods] update v3 sdk

* [sdk vault methods] update v3 sdk

* [sdk vault methods] update v3 sdk

Author: mike-diamond

src/methods/vault/transactions/operate/util/check/checkAdminAccess.ts

@@ -0,0 +1,18 @@
+import type { CheckInput } from './types'
+
+
+const checkAdminAccess = async ({ userAddress, vaultAddress, contracts }: CheckInput) => {
+  try {
+    const vaultContract = await contracts.helpers.createVault(vaultAddress)
+    const admin = await vaultContract.admin()
+    const hasAccess = admin.toLowerCase() === userAddress.toLowerCase()
+
+    if (!hasAccess) {
+      return Promise.reject('User must be the vault admin to perform this action')
+    }
+  }
+  catch {}
+}
+
+
+export default checkAdminAccess

src/methods/vault/transactions/operate/util/check/checkBlocklistManagerAccess.ts

@@ -0,0 +1,18 @@
+import type { CheckInput } from './types'
+
+
+const checkBlocklistManagerAccess = async ({ userAddress, vaultAddress, contracts }: CheckInput) => {
+  try {
+    const vaultContract = await contracts.helpers.createBlocklistedVault(vaultAddress)
+    const blocklistManager = await vaultContract.blocklistManager()
+    const hasAccess = blocklistManager.toLowerCase() === userAddress.toLowerCase()
+
+    if (!hasAccess) {
+      return Promise.reject('User must be the vault blocklist manager to perform this action')
+    }
+  }
+  catch {}
+}
+
+
+export default checkBlocklistManagerAccess

src/methods/vault/transactions/operate/util/check/checkKeysManagerAccess.ts

@@ -0,0 +1,18 @@
+import type { CheckInput } from './types'
+
+
+const checkKeysManagerAccess = async ({ userAddress, vaultAddress, contracts }: CheckInput) => {
+  try {
+    const vaultContract = await contracts.helpers.createVault(vaultAddress)
+    const keysManager = await vaultContract.keysManager()
+    const hasAccess = keysManager.toLowerCase() === userAddress.toLowerCase()
+
+    if (!hasAccess) {
+      return Promise.reject('User must be the vault keys manager to perform this action')
+    }
+  }
+  catch {}
+}
+
+
+export default checkKeysManagerAccess

src/methods/vault/transactions/operate/util/check/checkWhitelisterAccess.ts

@@ -0,0 +1,18 @@
+import type { CheckInput } from './types'
+
+
+const checkWhitelisterAccess = async ({ userAddress, vaultAddress, contracts }: CheckInput) => {
+  try {
+    const vaultContract = await contracts.helpers.createPrivateVault(vaultAddress)
+    const whitelister = await vaultContract.whitelister()
+    const hasAccess = whitelister.toLowerCase() === userAddress.toLowerCase()
+
+    if (!hasAccess) {
+      return Promise.reject('User must be the vault whitelister to perform this action')
+    }
+  }
+  catch {}
+}
+
+
+export default checkWhitelisterAccess

src/methods/vault/transactions/operate/util/check/index.ts

@@ -0,0 +1,4 @@
+export { default as checkAdminAccess } from './checkAdminAccess'
+export { default as checkKeysManagerAccess } from './checkKeysManagerAccess'
+export { default as checkWhitelisterAccess } from './checkWhitelisterAccess'
+export { default as checkBlocklistManagerAccess } from './checkBlocklistManagerAccess'

src/methods/vault/transactions/operate/util/check/types.d.ts

@@ -0,0 +1,5 @@
+export type CheckInput = {
+  userAddress: string
+  vaultAddress: string
+  contracts: StakeWise.Contracts
+}

src/methods/vault/transactions/operate/util/index.ts

@@ -0,0 +1,2 @@
+export * from './check'
+export * from './params'

src/methods/vault/transactions/operate/util/params/getBlocklistManagerParams.ts

@@ -0,0 +1,24 @@
+import { validateArgs } from '../../../../../../utils'
+import { vaultMulticall } from '../../../../../../contracts'
+
+
+export type SetBlocklistManagerParams = {
+  blocklistManager: string
+}
+
+const getBlocklistManagerParams = (values: SetBlocklistManagerParams) => {
+  const { blocklistManager } = values
+
+  validateArgs.address({ blocklistManager })
+
+  const params: Parameters<typeof vaultMulticall>[0]['request']['params'] = [
+    {
+      method: 'setBlocklistManager', args: [ blocklistManager ],
+    },
+  ]
+
+  return params
+}
+
+
+export default getBlocklistManagerParams

src/methods/vault/transactions/operate/util/params/getBlocklistParams.ts

@@ -0,0 +1,26 @@
+import validateList from './validateList'
+import { vaultMulticall } from '../../../../../../contracts'
+
+
+export type UpdateBlocklistParams = {
+  blocklist: Array<{
+    address: string
+    isNew: boolean
+  }>
+}
+
+const getBlocklistParams = (values: UpdateBlocklistParams) => {
+  const { blocklist } = values
+
+  validateList({ blocklist })
+
+  const params: Parameters<typeof vaultMulticall>[0]['request']['params'] = blocklist.map(({ address, isNew }) => ({
+    method: 'updateBlocklist',
+    args: [ address, isNew ],
+  }))
+
+  return params
+}
+
+
+export default getBlocklistParams

src/methods/vault/transactions/operate/util/params/getFeeRecipientParams.ts

@@ -0,0 +1,24 @@
+import { validateArgs } from '../../../../../../utils'
+import { vaultMulticall } from '../../../../../../contracts'
+
+
+export type SetFeeRecipientParams = {
+  feeRecipient: string
+}
+
+const getFeeRecipientParams = (values: SetFeeRecipientParams) => {
+  const { feeRecipient } = values
+
+  validateArgs.address({ feeRecipient })
+
+  const params: Parameters<typeof vaultMulticall>[0]['request']['params'] = [
+    {
+      method: 'setFeeRecipient', args: [ feeRecipient ],
+    },
+  ]
+
+  return params
+}
+
+
+export default getFeeRecipientParams

src/methods/vault/transactions/operate/util/params/getKeysManagerParams.ts

@@ -0,0 +1,24 @@
+import { validateArgs } from '../../../../../../utils'
+import { vaultMulticall } from '../../../../../../contracts'
+
+
+export type SetKeysManagerParams = {
+  keysManager: string
+}
+
+const getKeysManagerParams = (values: SetKeysManagerParams) => {
+  const { keysManager } = values
+
+  validateArgs.address({ keysManager })
+
+  const params: Parameters<typeof vaultMulticall>[0]['request']['params'] = [
+    {
+      method: 'setKeysManager', args: [ keysManager ],
+    },
+  ]
+
+  return params
+}
+
+
+export default getKeysManagerParams

src/methods/vault/transactions/operate/util/params/getMetadataParams.ts

@@ -0,0 +1,25 @@
+import { validateArgs } from '../../../../../../utils'
+import { vaultMulticall } from '../../../../../../contracts'
+
+
+export type SetMetadataParams = {
+  metadataIpfsHash: string
+}
+
+const getMetadataParams = (values: SetMetadataParams) => {
+  const { metadataIpfsHash } = values
+
+  validateArgs.string({ metadataIpfsHash })
+
+  const params: Parameters<typeof vaultMulticall>[0]['request']['params'] = [
+    {
+      method: 'setMetadata', args: [ metadataIpfsHash ],
+    },
+  ]
+
+  return params
+}
+
+
+export default getMetadataParams
+

src/methods/vault/transactions/operate/util/params/getValidatorsRootParams.ts

@@ -0,0 +1,24 @@
+import { validateArgs } from '../../../../../../utils'
+import { vaultMulticall } from '../../../../../../contracts'
+
+
+export type SetValidatorsRootParams = {
+  validatorsRoot: string
+}
+
+const getValidatorsRootParams = (values: SetValidatorsRootParams) => {
+  const { validatorsRoot } = values
+
+  validateArgs.string({ validatorsRoot })
+
+  const params: Parameters<typeof vaultMulticall>[0]['request']['params'] = [
+    {
+      method: 'setValidatorsRoot', args: [ validatorsRoot ],
+    },
+  ]
+
+  return params
+}
+
+
+export default getValidatorsRootParams

src/methods/vault/transactions/operate/util/params/getWhitelistParams.ts

@@ -0,0 +1,26 @@
+import validateList from './validateList'
+import { vaultMulticall } from '../../../../../../contracts'
+
+
+export type UpdateWhitelistParams = {
+  whitelist: Array<{
+    address: string
+    isNew: boolean
+  }>
+}
+
+const getWhitelistParams = (values: UpdateWhitelistParams) => {
+  const { whitelist } = values
+
+  validateList({ whitelist })
+
+  const params: Parameters<typeof vaultMulticall>[0]['request']['params'] = whitelist.map(({ address, isNew }) => ({
+    method: 'updateWhitelist',
+    args: [ address, isNew ],
+  }))
+
+  return params
+}
+
+
+export default getWhitelistParams

src/methods/vault/transactions/operate/util/params/getWhitelisterParams.ts

@@ -0,0 +1,24 @@
+import { validateArgs } from '../../../../../../utils'
+import { vaultMulticall } from '../../../../../../contracts'
+
+
+export type SetWhitelisterParams = {
+  whitelister: string
+}
+
+const getWhitelisterParams = (values: SetWhitelisterParams) => {
+  const { whitelister } = values
+
+  validateArgs.address({ whitelister })
+
+  const params: Parameters<typeof vaultMulticall>[0]['request']['params'] = [
+    {
+      method: 'setWhitelister', args: [ whitelister ],
+    },
+  ]
+
+  return params
+}
+
+
+export default getWhitelisterParams

src/methods/vault/transactions/operate/util/params/index.ts

@@ -0,0 +1,8 @@
+export { default as getMetadataParams }  from './getMetadataParams'
+export { default as getBlocklistParams }  from './getBlocklistParams'
+export { default as getWhitelistParams }  from './getWhitelistParams'
+export { default as getKeysManagerParams }  from './getKeysManagerParams'
+export { default as getWhitelisterParams }  from './getWhitelisterParams'
+export { default as getFeeRecipientParams }  from './getFeeRecipientParams'
+export { default as getValidatorsRootParams }  from './getValidatorsRootParams'
+export { default as getBlocklistManagerParams }  from './getBlocklistManagerParams'

src/methods/vault/transactions/operate/util/params/validateList.ts

@@ -0,0 +1,27 @@
+import { validateArgs } from '../../../../../../utils'
+
+
+type ListItem = {
+  address: string
+  isNew: boolean
+}
+
+const validateList = (values: Record<string, ListItem[]>) => {
+  Object.keys(values).forEach((key) => {
+    validateArgs.array({ [key]: values[key] })
+
+    const isValid = values[key].every((listItem) => (
+      listItem
+      && typeof listItem === 'object'
+      && typeof listItem.address === 'string'
+      && typeof listItem.isNew === 'boolean'
+    ))
+
+    if (!isValid) {
+      throw new Error(`The "${key}" argument must be an array of objects with "address" and "isNew" properties`)
+    }
+  })
+}
+
+
+export default validateList

src/methods/vault/utils/getMulticallEncode.ts

@@ -0,0 +1,22 @@
+import { vaultMulticall } from '../../../contracts'
+
+
+type Input = Parameters<typeof vaultMulticall>[0]
+
+const getMulticallEncode = async (values: Input): Promise<StakeWise.TransactionData> => {
+  const rx = await vaultMulticall<{ data: string, to: string }>({
+    ...values,
+    request: {
+      ...values.request,
+      transactionData: true,
+    },
+  })
+
+  return {
+    data: rx.data,
+    to: rx.to,
+  }
+}
+
+
+export default getMulticallEncode

src/methods/vault/utils/getMulticallGas.ts

@@ -0,0 +1,24 @@
+import { getGas } from '../../../utils'
+import { vaultMulticall } from '../../../contracts'
+
+
+type Input = Parameters<typeof vaultMulticall>[0] & {
+  provider: StakeWise.Provider
+}
+
+const getMulticallGas = async (values: Input) => {
+  const { provider } = values
+
+  const estimatedGas = await vaultMulticall<bigint>({
+    ...values,
+    request: {
+      ...values.request,
+      estimateGas: true,
+    },
+  })
+
+  return getGas({ estimatedGas, provider })
+}
+
+
+export default getMulticallGas

src/methods/vault/utils/index.ts

@@ -0,0 +1,3 @@
+export { default as getMulticallGas } from './getMulticallGas'
+export { default as getMulticallEncode } from './getMulticallEncode'
+export type { BaseInput } from './types'

src/methods/vault/utils/types.d.ts

@@ -0,0 +1,7 @@
+export type BaseInput = {
+  userAddress: string
+  vaultAddress: string
+  options: StakeWise.Options
+  contracts: StakeWise.Contracts
+  provider: StakeWise.Provider
+}