@oydual31/more-vaults-sdk 0.3.0 → 0.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oydual31/more-vaults-sdk",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "TypeScript SDK for MoreVaults protocol — viem/wagmi and ethers.js",
   "type": "module",
   "exports": {

package/src/viem/abis.ts

@@ -729,6 +729,57 @@ export const LZ_ADAPTER_ABI = [
   },
 ] as const
 
+/**
+ * ERC4626Facet ABI — synchronous deposit and redeem into whitelisted ERC-4626 vaults.
+ */
+export const ERC4626_FACET_ABI = [
+  {
+    type: 'function',
+    name: 'erc4626Deposit',
+    inputs: [
+      { name: 'vault', type: 'address' },
+      { name: 'assets', type: 'uint256' },
+    ],
+    outputs: [{ name: 'shares', type: 'uint256' }],
+    stateMutability: 'nonpayable',
+  },
+  {
+    type: 'function',
+    name: 'erc4626Redeem',
+    inputs: [
+      { name: 'vault', type: 'address' },
+      { name: 'shares', type: 'uint256' },
+    ],
+    outputs: [{ name: 'assets', type: 'uint256' }],
+    stateMutability: 'nonpayable',
+  },
+] as const
+
+/**
+ * Vault analysis ABIs — per-vault whitelist and registry reads.
+ */
+export const VAULT_ANALYSIS_ABI = [
+  // Asset management reads
+  { type: 'function', name: 'getAvailableAssets', inputs: [], outputs: [{ type: 'address[]' }], stateMutability: 'view' },
+  { type: 'function', name: 'getDepositableAssets', inputs: [], outputs: [{ type: 'address[]' }], stateMutability: 'view' },
+  { type: 'function', name: 'isAssetAvailable', inputs: [{ name: 'asset', type: 'address' }], outputs: [{ type: 'bool' }], stateMutability: 'view' },
+  { type: 'function', name: 'isAssetDepositable', inputs: [{ name: 'asset', type: 'address' }], outputs: [{ type: 'bool' }], stateMutability: 'view' },
+  // Deposit whitelist
+  { type: 'function', name: 'isDepositWhitelistEnabled', inputs: [], outputs: [{ type: 'bool' }], stateMutability: 'view' },
+  { type: 'function', name: 'getAvailableToDeposit', inputs: [{ name: 'depositor', type: 'address' }], outputs: [{ type: 'uint256' }], stateMutability: 'view' },
+  // Registry
+  { type: 'function', name: 'moreVaultsRegistry', inputs: [], outputs: [{ type: 'address' }], stateMutability: 'view' },
+] as const
+
+/**
+ * MoreVaultsRegistry ABI — global protocol and bridge whitelist checks.
+ */
+export const REGISTRY_ABI = [
+  { type: 'function', name: 'isWhitelisted', inputs: [{ name: 'protocol', type: 'address' }], outputs: [{ type: 'bool' }], stateMutability: 'view' },
+  { type: 'function', name: 'isBridgeAllowed', inputs: [{ name: 'bridge', type: 'address' }], outputs: [{ type: 'bool' }], stateMutability: 'view' },
+  { type: 'function', name: 'getAllowedFacets', inputs: [], outputs: [{ type: 'address[]' }], stateMutability: 'view' },
+] as const
+
 /**
  * Minimal LZ Endpoint V2 ABI for compose queue management.
  * Used by the Stargate 2-TX flow to check compose status and execute pending composes.

package/src/viem/chains.ts

@@ -261,6 +261,23 @@ export const LZ_TIMEOUTS = {
   FULL_SPOKE_REDEEM: 3_600_000, // 60 min
 } as const
 
+/**
+ * Uniswap V3 SwapRouter addresses per chain.
+ * Used by curator swap helpers to build calldata for on-chain swaps.
+ *
+ * Note on struct differences:
+ *   - SwapRouter (Eth/Arb/Op, 0xE592...): exactInputSingle struct includes `deadline`
+ *   - SwapRouter02 (Base, 0x2626...): exactInputSingle struct does NOT include `deadline`
+ *   - FlowSwap V3 (Flow EVM, 0xeEDC...): derived from original UniV3, includes `deadline`
+ */
+export const UNISWAP_V3_ROUTERS: Record<number, `0x${string}`> = {
+  [8453]:  '0x2626664c2603336E57B271c5C0b26F421741e481', // Base — SwapRouter02 (no deadline)
+  [1]:     '0xE592427A0AEce92De3Edee1F18E0157C05861564', // Ethereum — SwapRouter
+  [42161]: '0xE592427A0AEce92De3Edee1F18E0157C05861564', // Arbitrum — SwapRouter
+  [10]:    '0xE592427A0AEce92De3Edee1F18E0157C05861564', // Optimism — SwapRouter
+  [747]:   '0xeEDC6Ff75e1b10B903D9013c358e446a73d35341',  // Flow EVM — FlowSwap V3 SwapRouter
+}
+
 // ---------------------------------------------------------------------------
 // Legacy flat exports — kept for backwards compat, prefer OFT_ROUTES
 // ---------------------------------------------------------------------------

package/src/viem/curatorMulticall.ts

@@ -0,0 +1,299 @@
+/**
+ * Curator MulticallFacet write operations for the MoreVaults SDK.
+ *
+ * Provides typed helpers to submit, execute, and veto curator action batches
+ * on any MoreVaults diamond that has the MulticallFacet installed.
+ *
+ * All write functions use the simulate-then-write pattern:
+ *   1. `publicClient.simulateContract` — validates on-chain, catches reverts early
+ *   2. `walletClient.writeContract`    — sends the actual transaction
+ *
+ * @module curatorMulticall
+ */
+
+import {
+  type Address,
+  type PublicClient,
+  type WalletClient,
+  encodeFunctionData,
+  getAddress,
+} from 'viem'
+import {
+  MULTICALL_ABI,
+  DEX_ABI,
+  ERC7540_FACET_ABI,
+  ERC4626_FACET_ABI,
+} from './abis.js'
+import type {
+  CuratorAction,
+  SubmitActionsResult,
+} from './types.js'
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Encoding helpers
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Encode a single typed CuratorAction into raw calldata bytes suitable for
+ * passing into `submitActions(bytes[] actionsData)`.
+ *
+ * The encoded bytes are the full ABI-encoded function call (4-byte selector +
+ * arguments) targeting the vault diamond itself — the MulticallFacet will
+ * call `address(this).call(actionsData[i])` for each entry.
+ *
+ * @param action  A discriminated-union CuratorAction describing what to do
+ * @returns       ABI-encoded calldata bytes (`0x`-prefixed hex string)
+ */
+export function encodeCuratorAction(action: CuratorAction): `0x${string}` {
+  switch (action.type) {
+    case 'swap':
+      return encodeFunctionData({
+        abi: DEX_ABI,
+        functionName: 'executeSwap',
+        args: [
+          {
+            targetContract: getAddress(action.params.targetContract),
+            tokenIn: getAddress(action.params.tokenIn),
+            tokenOut: getAddress(action.params.tokenOut),
+            maxAmountIn: action.params.maxAmountIn,
+            minAmountOut: action.params.minAmountOut,
+            swapCallData: action.params.swapCallData,
+          },
+        ],
+      })
+
+    case 'batchSwap':
+      return encodeFunctionData({
+        abi: DEX_ABI,
+        functionName: 'executeBatchSwap',
+        args: [
+          {
+            swaps: action.params.swaps.map((s) => ({
+              targetContract: getAddress(s.targetContract),
+              tokenIn: getAddress(s.tokenIn),
+              tokenOut: getAddress(s.tokenOut),
+              maxAmountIn: s.maxAmountIn,
+              minAmountOut: s.minAmountOut,
+              swapCallData: s.swapCallData,
+            })),
+          },
+        ],
+      })
+
+    case 'erc4626Deposit':
+      return encodeFunctionData({
+        abi: ERC4626_FACET_ABI,
+        functionName: 'erc4626Deposit',
+        args: [getAddress(action.vault), action.assets],
+      })
+
+    case 'erc4626Redeem':
+      return encodeFunctionData({
+        abi: ERC4626_FACET_ABI,
+        functionName: 'erc4626Redeem',
+        args: [getAddress(action.vault), action.shares],
+      })
+
+    case 'erc7540RequestDeposit':
+      return encodeFunctionData({
+        abi: ERC7540_FACET_ABI,
+        functionName: 'erc7540RequestDeposit',
+        args: [getAddress(action.vault), action.assets],
+      })
+
+    case 'erc7540Deposit':
+      return encodeFunctionData({
+        abi: ERC7540_FACET_ABI,
+        functionName: 'erc7540Deposit',
+        args: [getAddress(action.vault), action.assets],
+      })
+
+    case 'erc7540RequestRedeem':
+      return encodeFunctionData({
+        abi: ERC7540_FACET_ABI,
+        functionName: 'erc7540RequestRedeem',
+        args: [getAddress(action.vault), action.shares],
+      })
+
+    case 'erc7540Redeem':
+      return encodeFunctionData({
+        abi: ERC7540_FACET_ABI,
+        functionName: 'erc7540Redeem',
+        args: [getAddress(action.vault), action.shares],
+      })
+
+    default: {
+      // TypeScript exhaustiveness check — this branch is never reached at runtime
+      const _exhaustive: never = action
+      throw new Error(`[MoreVaults] Unknown CuratorAction type: ${(_exhaustive as any).type}`)
+    }
+  }
+}
+
+/**
+ * Encode an array of CuratorActions into a calldata array ready for
+ * `submitActions`.
+ *
+ * @param actions  Array of typed CuratorAction objects
+ * @returns        Array of ABI-encoded calldata hex strings
+ */
+export function buildCuratorBatch(actions: CuratorAction[]): `0x${string}`[] {
+  return actions.map(encodeCuratorAction)
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Write operations
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Submit a batch of curator actions to the vault's MulticallFacet.
+ *
+ * When `timeLockPeriod == 0` the contract immediately executes the actions
+ * inside `submitActions` itself. When a timelock is configured the actions
+ * are queued and must be executed later with `executeActions`.
+ *
+ * Uses the simulate-then-write pattern: simulation runs first so any on-chain
+ * revert (wrong curator, bad selector, slippage limit, etc.) surfaces before
+ * any gas is spent on a failing transaction.
+ *
+ * After the write succeeds, the function reads `getCurrentNonce` to determine
+ * which nonce was assigned to this batch (nonce - 1 after the submit increments it).
+ *
+ * @param walletClient  Wallet client with curator account attached
+ * @param publicClient  Public client for reads and simulation
+ * @param vault         Vault address (diamond proxy)
+ * @param actions       Array of raw calldata bytes — use `buildCuratorBatch` to build
+ * @returns             Transaction hash and the nonce assigned to this batch
+ * @throws              If the caller is not the curator, or any action selector is
+ *                      not allowed, or any action would revert
+ */
+export async function submitActions(
+  walletClient: WalletClient,
+  publicClient: PublicClient,
+  vault: Address,
+  actions: `0x${string}`[],
+): Promise<SubmitActionsResult> {
+  const account = walletClient.account!
+  const v = getAddress(vault)
+
+  // Simulate first — catches permission errors and reverts before spending gas
+  await publicClient.simulateContract({
+    address: v,
+    abi: MULTICALL_ABI,
+    functionName: 'submitActions',
+    args: [actions],
+    account: account.address,
+  })
+
+  const txHash = await walletClient.writeContract({
+    address: v,
+    abi: MULTICALL_ABI,
+    functionName: 'submitActions',
+    args: [actions],
+    account,
+    chain: walletClient.chain,
+  })
+
+  // Read the nonce that was assigned: the contract increments actionNonce after storing,
+  // so getCurrentNonce now returns (assignedNonce + 1). Subtract 1 to recover it.
+  const nextNonce = await publicClient.readContract({
+    address: v,
+    abi: MULTICALL_ABI,
+    functionName: 'getCurrentNonce',
+  })
+
+  const nonce = nextNonce - 1n
+
+  return { txHash, nonce }
+}
+
+/**
+ * Execute pending actions after their timelock period has expired.
+ *
+ * Can only be called when `block.timestamp >= pendingUntil`. The contract
+ * reverts with `ActionsStillPending` if the timelock has not expired.
+ *
+ * Caller must be the curator (or any address when timeLockPeriod == 0, since
+ * in that case `submitActions` auto-executes and there is nothing to execute here).
+ *
+ * Uses simulate-then-write to surface on-chain reverts early.
+ *
+ * @param walletClient  Wallet client with curator account attached
+ * @param publicClient  Public client for reads and simulation
+ * @param vault         Vault address (diamond proxy)
+ * @param nonce         The action batch nonce to execute
+ * @returns             Transaction hash
+ */
+export async function executeActions(
+  walletClient: WalletClient,
+  publicClient: PublicClient,
+  vault: Address,
+  nonce: bigint,
+): Promise<{ txHash: `0x${string}` }> {
+  const account = walletClient.account!
+  const v = getAddress(vault)
+
+  // Simulate to surface reverts (NoSuchActions, ActionsStillPending, slippage)
+  await publicClient.simulateContract({
+    address: v,
+    abi: MULTICALL_ABI,
+    functionName: 'executeActions',
+    args: [nonce],
+    account: account.address,
+  })
+
+  const txHash = await walletClient.writeContract({
+    address: v,
+    abi: MULTICALL_ABI,
+    functionName: 'executeActions',
+    args: [nonce],
+    account,
+    chain: walletClient.chain,
+  })
+
+  return { txHash }
+}
+
+/**
+ * Guardian-only: cancel (veto) one or more pending action batches.
+ *
+ * Deletes the pending actions from storage, preventing them from ever being
+ * executed. Only the vault guardian can call this.
+ *
+ * Uses simulate-then-write to catch `NoSuchActions` and permission errors early.
+ *
+ * @param walletClient  Wallet client with guardian account attached
+ * @param publicClient  Public client for reads and simulation
+ * @param vault         Vault address (diamond proxy)
+ * @param nonces        Array of action nonces to cancel
+ * @returns             Transaction hash
+ */
+export async function vetoActions(
+  walletClient: WalletClient,
+  publicClient: PublicClient,
+  vault: Address,
+  nonces: bigint[],
+): Promise<{ txHash: `0x${string}` }> {
+  const account = walletClient.account!
+  const v = getAddress(vault)
+
+  // Simulate to catch NotGuardian, NoSuchActions, etc.
+  await publicClient.simulateContract({
+    address: v,
+    abi: MULTICALL_ABI,
+    functionName: 'vetoActions',
+    args: [nonces],
+    account: account.address,
+  })
+
+  const txHash = await walletClient.writeContract({
+    address: v,
+    abi: MULTICALL_ABI,
+    functionName: 'vetoActions',
+    args: [nonces],
+    account,
+    chain: walletClient.chain,
+  })
+
+  return { txHash }
+}

package/src/viem/curatorStatus.ts

@@ -6,8 +6,8 @@
  */
 
 import { type Address, type PublicClient, getAddress } from 'viem'
-import { MULTICALL_ABI, CURATOR_CONFIG_ABI } from './abis.js'
-import type { CuratorVaultStatus, PendingAction } from './types.js'
+import { MULTICALL_ABI, CURATOR_CONFIG_ABI, VAULT_ANALYSIS_ABI, REGISTRY_ABI, METADATA_ABI, ERC20_ABI, VAULT_ABI } from './abis.js'
+import type { CuratorVaultStatus, PendingAction, VaultAnalysis, AssetInfo, AssetBalance, VaultAssetBreakdown } from './types.js'
 
 // ─────────────────────────────────────────────────────────────────────────────
 
@@ -122,3 +122,198 @@ export async function isCurator(
 
   return getAddress(curatorAddress as Address) === getAddress(address)
 }
+
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Full vault analysis — available assets with metadata, depositable assets, whitelist config.
+ * Useful for curator dashboards to understand what the vault can do.
+ *
+ * @param publicClient  Viem public client (must be on the vault's chain)
+ * @param vault         Vault address (diamond proxy)
+ * @returns             VaultAnalysis snapshot
+ */
+export async function getVaultAnalysis(
+  publicClient: PublicClient,
+  vault: Address,
+): Promise<VaultAnalysis> {
+  const v = getAddress(vault)
+
+  // Batch 1: fetch asset lists, whitelist flag, and registry address in parallel
+  const [availableRaw, depositableRaw, depositWhitelistEnabled, registryResult] =
+    await Promise.all([
+      publicClient.readContract({
+        address: v,
+        abi: VAULT_ANALYSIS_ABI,
+        functionName: 'getAvailableAssets',
+      }),
+      publicClient.readContract({
+        address: v,
+        abi: VAULT_ANALYSIS_ABI,
+        functionName: 'getDepositableAssets',
+      }),
+      publicClient.readContract({
+        address: v,
+        abi: VAULT_ANALYSIS_ABI,
+        functionName: 'isDepositWhitelistEnabled',
+      }),
+      publicClient.readContract({
+        address: v,
+        abi: VAULT_ANALYSIS_ABI,
+        functionName: 'moreVaultsRegistry',
+      }).catch(() => null),
+    ])
+
+  const availableAddresses = (availableRaw as Address[]).map(getAddress)
+  const depositableAddresses = (depositableRaw as Address[]).map(getAddress)
+
+  // Deduplicated set of all asset addresses we need metadata for
+  const allAddresses = Array.from(new Set([...availableAddresses, ...depositableAddresses]))
+
+  // Batch 2: multicall for name/symbol/decimals on all unique assets
+  const metadataCalls = allAddresses.flatMap((addr) => [
+    { address: addr, abi: METADATA_ABI, functionName: 'name' as const },
+    { address: addr, abi: METADATA_ABI, functionName: 'symbol' as const },
+    { address: addr, abi: METADATA_ABI, functionName: 'decimals' as const },
+  ])
+
+  const metadataResults = allAddresses.length > 0
+    ? await publicClient.multicall({ contracts: metadataCalls, allowFailure: true })
+    : []
+
+  // Map address → AssetInfo
+  const assetInfoMap = new Map<Address, AssetInfo>()
+  for (let i = 0; i < allAddresses.length; i++) {
+    const addr = allAddresses[i]
+    const nameResult    = metadataResults[i * 3]
+    const symbolResult  = metadataResults[i * 3 + 1]
+    const decimalsResult = metadataResults[i * 3 + 2]
+
+    assetInfoMap.set(addr, {
+      address: addr,
+      name:     nameResult?.status === 'success'     ? (nameResult.result as string)  : '',
+      symbol:   symbolResult?.status === 'success'   ? (symbolResult.result as string) : '',
+      decimals: decimalsResult?.status === 'success' ? (decimalsResult.result as number) : 18,
+    })
+  }
+
+  const registryAddress = registryResult ? getAddress(registryResult as Address) : null
+
+  return {
+    availableAssets:       availableAddresses.map((a) => assetInfoMap.get(a)!),
+    depositableAssets:     depositableAddresses.map((a) => assetInfoMap.get(a)!),
+    depositWhitelistEnabled: depositWhitelistEnabled as boolean,
+    registryAddress,
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Check if specific protocol addresses are whitelisted in the global registry.
+ * Useful for curators to verify DEX routers before building swap calldata.
+ *
+ * @param publicClient  Viem public client (must be on the vault's chain)
+ * @param vault         Vault address (diamond proxy)
+ * @param protocols     Protocol addresses to check
+ * @returns             Record mapping address → whitelisted boolean
+ */
+export async function checkProtocolWhitelist(
+  publicClient: PublicClient,
+  vault: Address,
+  protocols: Address[],
+): Promise<Record<string, boolean>> {
+  const v = getAddress(vault)
+
+  const registryRaw = await publicClient.readContract({
+    address: v,
+    abi: VAULT_ANALYSIS_ABI,
+    functionName: 'moreVaultsRegistry',
+  })
+
+  const registry = getAddress(registryRaw as Address)
+
+  if (protocols.length === 0) return {}
+
+  const results = await publicClient.multicall({
+    contracts: protocols.map((protocol) => ({
+      address: registry,
+      abi: REGISTRY_ABI,
+      functionName: 'isWhitelisted' as const,
+      args: [getAddress(protocol)] as [Address],
+    })),
+    allowFailure: true,
+  })
+
+  const out: Record<string, boolean> = {}
+  for (let i = 0; i < protocols.length; i++) {
+    const r = results[i]
+    out[getAddress(protocols[i])] = r?.status === 'success' ? (r.result as boolean) : false
+  }
+  return out
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Get the vault's per-asset balance breakdown on the hub chain.
+ *
+ * Returns the balance of every available asset held by the vault, plus
+ * totalAssets and totalSupply for context. Useful for portfolio views
+ * that need to show individual holdings rather than a single USD-denominated total.
+ *
+ * @param publicClient  Viem public client (must be on the vault's hub chain)
+ * @param vault         Vault address (diamond proxy)
+ * @returns             VaultAssetBreakdown with per-asset balances
+ */
+export async function getVaultAssetBreakdown(
+  publicClient: PublicClient,
+  vault: Address,
+): Promise<VaultAssetBreakdown> {
+  const v = getAddress(vault)
+
+  // Step 1: get available assets list
+  const availableRaw = await publicClient.readContract({
+    address: v,
+    abi: VAULT_ANALYSIS_ABI,
+    functionName: 'getAvailableAssets',
+  }) as Address[]
+
+  const addresses = availableRaw.map(getAddress)
+
+  // Step 2: multicall — balanceOf + metadata for each asset + totalAssets + totalSupply + vault decimals
+  const results = await publicClient.multicall({
+    contracts: [
+      // Per-asset: balanceOf, name, symbol, decimals
+      ...addresses.flatMap((addr) => [
+        { address: addr, abi: ERC20_ABI, functionName: 'balanceOf' as const, args: [v] as [Address] },
+        { address: addr, abi: METADATA_ABI, functionName: 'name' as const },
+        { address: addr, abi: METADATA_ABI, functionName: 'symbol' as const },
+        { address: addr, abi: METADATA_ABI, functionName: 'decimals' as const },
+      ]),
+      // Vault totals
+      { address: v, abi: VAULT_ABI, functionName: 'totalAssets' as const },
+      { address: v, abi: VAULT_ABI, functionName: 'totalSupply' as const },
+      { address: v, abi: METADATA_ABI, functionName: 'decimals' as const },
+    ],
+    allowFailure: true,
+  })
+
+  const perAssetFields = 4 // balanceOf, name, symbol, decimals
+  const assets: AssetBalance[] = addresses.map((addr, i) => {
+    const base = i * perAssetFields
+    const balance  = results[base]?.status === 'success'     ? (results[base].result as bigint)   : 0n
+    const name     = results[base + 1]?.status === 'success' ? (results[base + 1].result as string) : ''
+    const symbol   = results[base + 2]?.status === 'success' ? (results[base + 2].result as string) : ''
+    const decimals = results[base + 3]?.status === 'success' ? (results[base + 3].result as number) : 18
+
+    return { address: addr, name, symbol, decimals, balance }
+  })
+
+  const totalsBase = addresses.length * perAssetFields
+  const totalAssets      = results[totalsBase]?.status === 'success'     ? (results[totalsBase].result as bigint)   : 0n
+  const totalSupply      = results[totalsBase + 1]?.status === 'success' ? (results[totalsBase + 1].result as bigint) : 0n
+  const underlyingDecimals = results[totalsBase + 2]?.status === 'success' ? (results[totalsBase + 2].result as number) : 6
+
+  return { assets, totalAssets, totalSupply, underlyingDecimals }
+}