@oydual31/more-vaults-sdk 0.4.0 → 0.4.2

package/dist/react/index.js

@@ -1,6 +1,6 @@
-import { useQuery } from '@tanstack/react-query';
+import { useQuery, useMutation } from '@tanstack/react-query';
 import { usePublicClient, useChainId, useWalletClient } from 'wagmi';
-import { getAddress, zeroAddress, encodeAbiParameters, createPublicClient, http, fallback } from 'viem';
+import { getAddress, zeroAddress, encodeAbiParameters, createPublicClient, http, fallback, encodeFunctionData } from 'viem';
 import { useState, useCallback, useMemo } from 'react';
 
 // src/react/useVaultStatus.ts
@@ -812,6 +812,227 @@ var OFT_ABI = [
     stateMutability: "view"
   }
 ];
+var MULTICALL_ABI = [
+  {
+    type: "function",
+    name: "submitActions",
+    inputs: [
+      { name: "actionsData", type: "bytes[]" }
+    ],
+    outputs: [{ name: "nonce", type: "uint256" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "executeActions",
+    inputs: [
+      { name: "actionsNonce", type: "uint256" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "getPendingActions",
+    inputs: [
+      { name: "actionsNonce", type: "uint256" }
+    ],
+    outputs: [
+      { name: "actionsData", type: "bytes[]" },
+      { name: "pendingUntil", type: "uint256" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getCurrentNonce",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "vetoActions",
+    inputs: [
+      { name: "actionsNonces", type: "uint256[]" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  }
+];
+var DEX_ABI = [
+  {
+    type: "function",
+    name: "executeSwap",
+    inputs: [
+      {
+        name: "params",
+        type: "tuple",
+        components: [
+          { name: "targetContract", type: "address" },
+          { name: "tokenIn", type: "address" },
+          { name: "tokenOut", type: "address" },
+          { name: "maxAmountIn", type: "uint256" },
+          { name: "minAmountOut", type: "uint256" },
+          { name: "swapCallData", type: "bytes" }
+        ]
+      }
+    ],
+    outputs: [{ name: "amountOut", type: "uint256" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "executeBatchSwap",
+    inputs: [
+      {
+        name: "params",
+        type: "tuple",
+        components: [
+          {
+            name: "swaps",
+            type: "tuple[]",
+            components: [
+              { name: "targetContract", type: "address" },
+              { name: "tokenIn", type: "address" },
+              { name: "tokenOut", type: "address" },
+              { name: "maxAmountIn", type: "uint256" },
+              { name: "minAmountOut", type: "uint256" },
+              { name: "swapCallData", type: "bytes" }
+            ]
+          }
+        ]
+      }
+    ],
+    outputs: [{ name: "amountsOut", type: "uint256[]" }],
+    stateMutability: "nonpayable"
+  }
+];
+var ERC7540_FACET_ABI = [
+  {
+    type: "function",
+    name: "erc7540RequestDeposit",
+    inputs: [
+      { name: "vault", type: "address" },
+      { name: "assets", type: "uint256" }
+    ],
+    outputs: [{ name: "requestId", type: "uint256" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "erc7540RequestRedeem",
+    inputs: [
+      { name: "vault", type: "address" },
+      { name: "shares", type: "uint256" }
+    ],
+    outputs: [{ name: "requestId", type: "uint256" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "erc7540Deposit",
+    inputs: [
+      { name: "vault", type: "address" },
+      { name: "assets", type: "uint256" }
+    ],
+    outputs: [{ name: "shares", type: "uint256" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "erc7540Redeem",
+    inputs: [
+      { name: "vault", type: "address" },
+      { name: "shares", type: "uint256" }
+    ],
+    outputs: [{ name: "assets", type: "uint256" }],
+    stateMutability: "nonpayable"
+  }
+];
+var CURATOR_CONFIG_ABI = [
+  {
+    type: "function",
+    name: "curator",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "timeLockPeriod",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getAvailableAssets",
+    inputs: [],
+    outputs: [{ name: "", type: "address[]" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getMaxSlippagePercent",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getCrossChainAccountingManager",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "paused",
+    inputs: [],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "view"
+  }
+];
+var 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"
+  }
+];
+var 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" }
+];
+var 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" }
+];
 
 // src/viem/types.ts
 var ActionType = {
@@ -1914,6 +2135,329 @@ async function getVaultDistribution(hubClient, vault, spokeClients) {
     oracleAccountingEnabled: hubStatus.oracleAccountingEnabled
   };
 }
+async function getCuratorVaultStatus(publicClient, vault) {
+  const v = getAddress(vault);
+  const [
+    curator,
+    timeLockPeriod,
+    maxSlippagePercent,
+    currentNonce,
+    availableAssets,
+    lzAdapter,
+    paused
+  ] = await publicClient.multicall({
+    contracts: [
+      { address: v, abi: CURATOR_CONFIG_ABI, functionName: "curator" },
+      { address: v, abi: CURATOR_CONFIG_ABI, functionName: "timeLockPeriod" },
+      { address: v, abi: CURATOR_CONFIG_ABI, functionName: "getMaxSlippagePercent" },
+      { address: v, abi: MULTICALL_ABI, functionName: "getCurrentNonce" },
+      { address: v, abi: CURATOR_CONFIG_ABI, functionName: "getAvailableAssets" },
+      { address: v, abi: CURATOR_CONFIG_ABI, functionName: "getCrossChainAccountingManager" },
+      { address: v, abi: CURATOR_CONFIG_ABI, functionName: "paused" }
+    ],
+    allowFailure: false
+  });
+  return {
+    curator: getAddress(curator),
+    timeLockPeriod,
+    maxSlippagePercent,
+    currentNonce,
+    availableAssets: availableAssets.map(getAddress),
+    lzAdapter: getAddress(lzAdapter),
+    paused
+  };
+}
+async function getPendingActions(publicClient, vault, nonce) {
+  const v = getAddress(vault);
+  const [actionsResult, block] = await Promise.all([
+    publicClient.readContract({
+      address: v,
+      abi: MULTICALL_ABI,
+      functionName: "getPendingActions",
+      args: [nonce]
+    }),
+    publicClient.getBlock()
+  ]);
+  const [actionsData, pendingUntil] = actionsResult;
+  const isExecutable = pendingUntil > 0n && block.timestamp >= pendingUntil;
+  return {
+    nonce,
+    actionsData,
+    pendingUntil,
+    isExecutable
+  };
+}
+async function isCurator(publicClient, vault, address) {
+  const curatorAddress = await publicClient.readContract({
+    address: getAddress(vault),
+    abi: CURATOR_CONFIG_ABI,
+    functionName: "curator"
+  });
+  return getAddress(curatorAddress) === getAddress(address);
+}
+async function getVaultAnalysis(publicClient, vault) {
+  const v = getAddress(vault);
+  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.map(getAddress);
+  const depositableAddresses = depositableRaw.map(getAddress);
+  const allAddresses = Array.from(/* @__PURE__ */ new Set([...availableAddresses, ...depositableAddresses]));
+  const metadataCalls = allAddresses.flatMap((addr) => [
+    { address: addr, abi: METADATA_ABI, functionName: "name" },
+    { address: addr, abi: METADATA_ABI, functionName: "symbol" },
+    { address: addr, abi: METADATA_ABI, functionName: "decimals" }
+  ]);
+  const metadataResults = allAddresses.length > 0 ? await publicClient.multicall({ contracts: metadataCalls, allowFailure: true }) : [];
+  const assetInfoMap = /* @__PURE__ */ new Map();
+  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 : "",
+      symbol: symbolResult?.status === "success" ? symbolResult.result : "",
+      decimals: decimalsResult?.status === "success" ? decimalsResult.result : 18
+    });
+  }
+  const registryAddress = registryResult ? getAddress(registryResult) : null;
+  return {
+    availableAssets: availableAddresses.map((a) => assetInfoMap.get(a)),
+    depositableAssets: depositableAddresses.map((a) => assetInfoMap.get(a)),
+    depositWhitelistEnabled,
+    registryAddress
+  };
+}
+async function checkProtocolWhitelist(publicClient, vault, protocols) {
+  const v = getAddress(vault);
+  const registryRaw = await publicClient.readContract({
+    address: v,
+    abi: VAULT_ANALYSIS_ABI,
+    functionName: "moreVaultsRegistry"
+  });
+  const registry = getAddress(registryRaw);
+  if (protocols.length === 0) return {};
+  const results = await publicClient.multicall({
+    contracts: protocols.map((protocol) => ({
+      address: registry,
+      abi: REGISTRY_ABI,
+      functionName: "isWhitelisted",
+      args: [getAddress(protocol)]
+    })),
+    allowFailure: true
+  });
+  const out = {};
+  for (let i = 0; i < protocols.length; i++) {
+    const r = results[i];
+    out[getAddress(protocols[i])] = r?.status === "success" ? r.result : false;
+  }
+  return out;
+}
+async function getVaultAssetBreakdown(publicClient, vault) {
+  const v = getAddress(vault);
+  const availableRaw = await publicClient.readContract({
+    address: v,
+    abi: VAULT_ANALYSIS_ABI,
+    functionName: "getAvailableAssets"
+  });
+  const addresses = availableRaw.map(getAddress);
+  const results = await publicClient.multicall({
+    contracts: [
+      // Per-asset: balanceOf, name, symbol, decimals
+      ...addresses.flatMap((addr) => [
+        { address: addr, abi: ERC20_ABI, functionName: "balanceOf", args: [v] },
+        { address: addr, abi: METADATA_ABI, functionName: "name" },
+        { address: addr, abi: METADATA_ABI, functionName: "symbol" },
+        { address: addr, abi: METADATA_ABI, functionName: "decimals" }
+      ]),
+      // Vault totals
+      { address: v, abi: VAULT_ABI, functionName: "totalAssets" },
+      { address: v, abi: VAULT_ABI, functionName: "totalSupply" },
+      { address: v, abi: METADATA_ABI, functionName: "decimals" }
+    ],
+    allowFailure: true
+  });
+  const perAssetFields = 4;
+  const assets = addresses.map((addr, i) => {
+    const base = i * perAssetFields;
+    const balance = results[base]?.status === "success" ? results[base].result : 0n;
+    const name = results[base + 1]?.status === "success" ? results[base + 1].result : "";
+    const symbol = results[base + 2]?.status === "success" ? results[base + 2].result : "";
+    const decimals = results[base + 3]?.status === "success" ? results[base + 3].result : 18;
+    return { address: addr, name, symbol, decimals, balance };
+  });
+  const totalsBase = addresses.length * perAssetFields;
+  const totalAssets = results[totalsBase]?.status === "success" ? results[totalsBase].result : 0n;
+  const totalSupply = results[totalsBase + 1]?.status === "success" ? results[totalsBase + 1].result : 0n;
+  const underlyingDecimals = results[totalsBase + 2]?.status === "success" ? results[totalsBase + 2].result : 6;
+  return { assets, totalAssets, totalSupply, underlyingDecimals };
+}
+function encodeCuratorAction(action) {
+  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: {
+      const _exhaustive = action;
+      throw new Error(`[MoreVaults] Unknown CuratorAction type: ${_exhaustive.type}`);
+    }
+  }
+}
+function buildCuratorBatch(actions) {
+  return actions.map(encodeCuratorAction);
+}
+async function submitActions(walletClient, publicClient, vault, actions) {
+  const account = walletClient.account;
+  const v = getAddress(vault);
+  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
+  });
+  const nextNonce = await publicClient.readContract({
+    address: v,
+    abi: MULTICALL_ABI,
+    functionName: "getCurrentNonce"
+  });
+  const nonce = nextNonce - 1n;
+  return { txHash, nonce };
+}
+async function executeActions(walletClient, publicClient, vault, nonce) {
+  const account = walletClient.account;
+  const v = getAddress(vault);
+  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 };
+}
+async function vetoActions(walletClient, publicClient, vault, nonces) {
+  const account = walletClient.account;
+  const v = getAddress(vault);
+  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 };
+}
 
 // src/viem/wagmiCompat.ts
 function asSdkClient(client) {
@@ -2283,7 +2827,98 @@ function useInboundRoutes(hubChainId, vault, vaultAsset, userAddress) {
     error: error ?? null
   };
 }
+function useCuratorVaultStatus(vault, chainId, options) {
+  const publicClient = usePublicClient({ chainId });
+  return useQuery({
+    queryKey: ["curatorVaultStatus", vault, chainId],
+    queryFn: () => getCuratorVaultStatus(asSdkClient(publicClient), vault),
+    enabled: !!vault && !!publicClient,
+    refetchInterval: options?.refetchInterval ?? 3e4,
+    staleTime: 15e3
+  });
+}
+function useVaultAnalysis(vault, chainId, options) {
+  const publicClient = usePublicClient({ chainId });
+  return useQuery({
+    queryKey: ["vaultAnalysis", vault, chainId],
+    queryFn: () => getVaultAnalysis(asSdkClient(publicClient), vault),
+    enabled: !!vault && !!publicClient,
+    refetchInterval: options?.refetchInterval ?? 3e4,
+    staleTime: 15e3
+  });
+}
+function useVaultAssetBreakdown(vault, chainId, options) {
+  const publicClient = usePublicClient({ chainId });
+  return useQuery({
+    queryKey: ["vaultAssetBreakdown", vault, chainId],
+    queryFn: () => getVaultAssetBreakdown(asSdkClient(publicClient), vault),
+    enabled: !!vault && !!publicClient,
+    refetchInterval: options?.refetchInterval ?? 3e4,
+    staleTime: 15e3
+  });
+}
+function usePendingActions(vault, chainId, nonce, options) {
+  const publicClient = usePublicClient({ chainId });
+  return useQuery({
+    queryKey: ["pendingActions", vault, chainId, nonce?.toString()],
+    queryFn: () => getPendingActions(asSdkClient(publicClient), vault, nonce),
+    enabled: !!vault && !!publicClient && nonce !== void 0,
+    refetchInterval: options?.refetchInterval ?? 3e4,
+    staleTime: 15e3
+  });
+}
+function useIsCurator(vault, chainId, address, options) {
+  const publicClient = usePublicClient({ chainId });
+  return useQuery({
+    queryKey: ["isCurator", vault, chainId, address],
+    queryFn: () => isCurator(asSdkClient(publicClient), vault, address),
+    enabled: !!vault && !!publicClient && !!address,
+    refetchInterval: options?.refetchInterval ?? 3e4,
+    staleTime: 15e3
+  });
+}
+function useProtocolWhitelist(vault, chainId, protocols, options) {
+  const publicClient = usePublicClient({ chainId });
+  return useQuery({
+    queryKey: ["protocolWhitelist", vault, chainId, protocols],
+    queryFn: () => checkProtocolWhitelist(asSdkClient(publicClient), vault, protocols),
+    enabled: !!vault && !!publicClient,
+    refetchInterval: options?.refetchInterval ?? 3e4,
+    staleTime: 15e3
+  });
+}
+function useSubmitActions(vault, chainId) {
+  const publicClient = usePublicClient({ chainId });
+  const { data: walletClient } = useWalletClient({ chainId });
+  return useMutation({
+    mutationFn: async ({ actions }) => {
+      if (!walletClient || !publicClient) throw new Error("Wallet or public client not available");
+      const encodedActions = buildCuratorBatch(actions);
+      return submitActions(walletClient, asSdkClient(publicClient), vault, encodedActions);
+    }
+  });
+}
+function useExecuteActions(vault, chainId) {
+  const publicClient = usePublicClient({ chainId });
+  const { data: walletClient } = useWalletClient({ chainId });
+  return useMutation({
+    mutationFn: async ({ nonce }) => {
+      if (!walletClient || !publicClient) throw new Error("Wallet or public client not available");
+      return executeActions(walletClient, asSdkClient(publicClient), vault, nonce);
+    }
+  });
+}
+function useVetoActions(vault, chainId) {
+  const publicClient = usePublicClient({ chainId });
+  const { data: walletClient } = useWalletClient({ chainId });
+  return useMutation({
+    mutationFn: async ({ nonces }) => {
+      if (!walletClient || !publicClient) throw new Error("Wallet or public client not available");
+      return vetoActions(walletClient, asSdkClient(publicClient), vault, nonces);
+    }
+  });
+}
 
-export { getRouteTokenDecimals, useAsyncRequestStatus, useDepositSimple, useInboundRoutes, useLzFee, useOmniDeposit, useOmniRedeem, useRedeemShares, useSmartDeposit, useSmartRedeem, useUserPosition, useUserPositionMultiChain, useVaultDistribution, useVaultMetadata, useVaultStatus, useVaultTopology };
+export { getRouteTokenDecimals, useAsyncRequestStatus, useCuratorVaultStatus, useDepositSimple, useExecuteActions, useInboundRoutes, useIsCurator, useLzFee, useOmniDeposit, useOmniRedeem, usePendingActions, useProtocolWhitelist, useRedeemShares, useSmartDeposit, useSmartRedeem, useSubmitActions, useUserPosition, useUserPositionMultiChain, useVaultAnalysis, useVaultAssetBreakdown, useVaultDistribution, useVaultMetadata, useVaultStatus, useVaultTopology, useVetoActions };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map