@oydual31/more-vaults-sdk 0.4.2 → 0.6.0

package/dist/react/index.js

@@ -1,6 +1,6 @@
 import { useQuery, useMutation } from '@tanstack/react-query';
 import { usePublicClient, useChainId, useWalletClient } from 'wagmi';
-import { getAddress, zeroAddress, encodeAbiParameters, createPublicClient, http, fallback, encodeFunctionData } from 'viem';
+import { keccak256, toHex, getAddress, zeroAddress, encodeAbiParameters, createPublicClient, http, fallback, encodeFunctionData } from 'viem';
 import { useState, useCallback, useMemo } from 'react';
 
 // src/react/useVaultStatus.ts
@@ -908,6 +908,41 @@ var DEX_ABI = [
     stateMutability: "nonpayable"
   }
 ];
+var BRIDGE_FACET_ABI = [
+  {
+    type: "function",
+    name: "executeBridging",
+    inputs: [
+      { name: "adapter", type: "address" },
+      { name: "token", type: "address" },
+      { name: "amount", type: "uint256" },
+      { name: "bridgeSpecificParams", type: "bytes" }
+    ],
+    outputs: [],
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "initVaultActionRequest",
+    inputs: [
+      { name: "actionType", type: "uint8" },
+      { name: "actionCallData", type: "bytes" },
+      { name: "amountLimit", type: "uint256" },
+      { name: "extraOptions", type: "bytes" }
+    ],
+    outputs: [{ name: "guid", type: "bytes32" }],
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "executeRequest",
+    inputs: [
+      { name: "guid", type: "bytes32" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  }
+];
 var ERC7540_FACET_ABI = [
   {
     type: "function",
@@ -994,6 +1029,37 @@ var CURATOR_CONFIG_ABI = [
     stateMutability: "view"
   }
 ];
+var LZ_ADAPTER_ABI = [
+  {
+    type: "function",
+    name: "quoteBridgeFee",
+    inputs: [
+      { name: "bridgeSpecificParams", type: "bytes" }
+    ],
+    outputs: [{ name: "nativeFee", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "quoteReadFee",
+    inputs: [
+      { name: "vaults", type: "address[]" },
+      { name: "eids", type: "uint32[]" },
+      { name: "_extraOptions", type: "bytes" }
+    ],
+    outputs: [
+      {
+        name: "fee",
+        type: "tuple",
+        components: [
+          { name: "nativeFee", type: "uint256" },
+          { name: "lzTokenFee", type: "uint256" }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  }
+];
 var ERC4626_FACET_ABI = [
   {
     type: "function",
@@ -1033,6 +1099,23 @@ var REGISTRY_ABI = [
   { type: "function", name: "isBridgeAllowed", inputs: [{ name: "bridge", type: "address" }], outputs: [{ type: "bool" }], stateMutability: "view" },
   { type: "function", name: "getAllowedFacets", inputs: [], outputs: [{ type: "address[]" }], stateMutability: "view" }
 ];
+var SUB_VAULT_ABI = [
+  // ConfigurationFacet reads — called on the MoreVaults diamond proxy
+  { type: "function", name: "tokensHeld", inputs: [{ name: "id", type: "bytes32" }], outputs: [{ name: "", type: "address[]" }], stateMutability: "view" },
+  { type: "function", name: "lockedTokensAmountOfAsset", inputs: [{ name: "asset", type: "address" }], outputs: [{ name: "", type: "uint256" }], stateMutability: "view" },
+  // ERC4626 standard reads — called on the sub-vault contract
+  { type: "function", name: "convertToAssets", inputs: [{ name: "shares", type: "uint256" }], outputs: [{ name: "", type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "convertToShares", inputs: [{ name: "assets", type: "uint256" }], outputs: [{ name: "", type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "previewDeposit", inputs: [{ name: "assets", type: "uint256" }], outputs: [{ name: "", type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "previewRedeem", inputs: [{ name: "shares", type: "uint256" }], outputs: [{ name: "", type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "maxDeposit", inputs: [{ name: "receiver", type: "address" }], outputs: [{ name: "", type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "maxRedeem", inputs: [{ name: "owner", type: "address" }], outputs: [{ name: "", type: "uint256" }], stateMutability: "view" },
+  // ERC7540 async reads — called on the sub-vault contract
+  { type: "function", name: "pendingDepositRequest", inputs: [{ name: "requestId", type: "uint256" }, { name: "controller", type: "address" }], outputs: [{ name: "", type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "claimableDepositRequest", inputs: [{ name: "requestId", type: "uint256" }, { name: "controller", type: "address" }], outputs: [{ name: "", type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "pendingRedeemRequest", inputs: [{ name: "requestId", type: "uint256" }, { name: "controller", type: "address" }], outputs: [{ name: "", type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "claimableRedeemRequest", inputs: [{ name: "requestId", type: "uint256" }, { name: "controller", type: "address" }], outputs: [{ name: "", type: "uint256" }], stateMutability: "view" }
+];
 
 // src/viem/types.ts
 var ActionType = {
@@ -2458,6 +2541,237 @@ async function vetoActions(walletClient, publicClient, vault, nonces) {
   });
   return { txHash };
 }
+function encodeBridgeParams(params) {
+  return encodeAbiParameters(
+    [
+      { type: "address" },
+      { type: "uint32" },
+      { type: "uint256" },
+      { type: "address" },
+      { type: "address" }
+    ],
+    [
+      getAddress(params.oftToken),
+      params.dstEid,
+      params.amount,
+      getAddress(params.dstVault),
+      getAddress(params.refundAddress)
+    ]
+  );
+}
+function encodeBridgeParamsForQuote(params) {
+  return encodeAbiParameters(
+    [
+      { type: "address" },
+      { type: "uint32" },
+      { type: "uint256" },
+      { type: "address" }
+    ],
+    [
+      getAddress(params.oftToken),
+      params.dstEid,
+      params.amount,
+      getAddress(params.dstVault)
+    ]
+  );
+}
+async function quoteCuratorBridgeFee(publicClient, vault, params) {
+  const status = await getCuratorVaultStatus(publicClient, vault);
+  const lzAdapter = status.lzAdapter;
+  const bridgeSpecificParams = encodeBridgeParamsForQuote(params);
+  const nativeFee = await publicClient.readContract({
+    address: lzAdapter,
+    abi: LZ_ADAPTER_ABI,
+    functionName: "quoteBridgeFee",
+    args: [bridgeSpecificParams]
+  });
+  return nativeFee;
+}
+async function executeCuratorBridge(walletClient, publicClient, vault, token, params) {
+  const account = walletClient.account;
+  const v = getAddress(vault);
+  const status = await getCuratorVaultStatus(publicClient, vault);
+  const lzAdapter = status.lzAdapter;
+  const fee = await quoteCuratorBridgeFee(publicClient, vault, params);
+  const bridgeSpecificParams = encodeBridgeParams(params);
+  const txHash = await walletClient.writeContract({
+    address: v,
+    abi: BRIDGE_FACET_ABI,
+    functionName: "executeBridging",
+    args: [
+      lzAdapter,
+      getAddress(token),
+      params.amount,
+      bridgeSpecificParams
+    ],
+    value: fee,
+    account,
+    chain: walletClient.chain
+  });
+  return txHash;
+}
+var ERC4626_ID = keccak256(toHex("ERC4626_ID"));
+var ERC7540_ID = keccak256(toHex("ERC7540_ID"));
+async function getSubVaultPositions(publicClient, vault) {
+  const v = getAddress(vault);
+  const [erc4626Raw, erc7540Raw] = await Promise.all([
+    publicClient.readContract({
+      address: v,
+      abi: SUB_VAULT_ABI,
+      functionName: "tokensHeld",
+      args: [ERC4626_ID]
+    }).catch(() => []),
+    publicClient.readContract({
+      address: v,
+      abi: SUB_VAULT_ABI,
+      functionName: "tokensHeld",
+      args: [ERC7540_ID]
+    }).catch(() => [])
+  ]);
+  const erc4626Vaults = erc4626Raw.map(getAddress);
+  const erc7540Vaults = erc7540Raw.map(getAddress);
+  const allSubVaults = [
+    ...erc4626Vaults.map((a) => ({ address: a, type: "erc4626" })),
+    ...erc7540Vaults.map((a) => ({ address: a, type: "erc7540" }))
+  ];
+  if (allSubVaults.length === 0) return [];
+  const PER_SV = 5;
+  const subVaultCalls = allSubVaults.flatMap(({ address: sv }) => [
+    { address: sv, abi: ERC20_ABI, functionName: "balanceOf", args: [v] },
+    { address: sv, abi: VAULT_ABI, functionName: "asset" },
+    { address: sv, abi: METADATA_ABI, functionName: "name" },
+    { address: sv, abi: METADATA_ABI, functionName: "symbol" },
+    { address: sv, abi: METADATA_ABI, functionName: "decimals" }
+  ]);
+  const subVaultResults = await publicClient.multicall({
+    contracts: subVaultCalls,
+    allowFailure: true
+  });
+  const partials = allSubVaults.map(({ address: sv, type }, i) => {
+    const base = i * PER_SV;
+    const sharesBalance = subVaultResults[base]?.status === "success" ? subVaultResults[base].result : 0n;
+    const underlyingAsset = subVaultResults[base + 1]?.status === "success" ? getAddress(subVaultResults[base + 1].result) : zeroAddress;
+    const name = subVaultResults[base + 2]?.status === "success" ? subVaultResults[base + 2].result : "";
+    const symbol = subVaultResults[base + 3]?.status === "success" ? subVaultResults[base + 3].result : "";
+    const decimals = subVaultResults[base + 4]?.status === "success" ? subVaultResults[base + 4].result : 18;
+    return { address: sv, type, sharesBalance, underlyingAsset, name, symbol, decimals };
+  });
+  const active = partials.filter((p) => p.sharesBalance > 0n);
+  if (active.length === 0) return [];
+  const PER_ACTIVE = 4;
+  const activeCalls = active.flatMap(({ address: sv, sharesBalance, underlyingAsset }) => [
+    { address: sv, abi: SUB_VAULT_ABI, functionName: "convertToAssets", args: [sharesBalance] },
+    { address: underlyingAsset, abi: METADATA_ABI, functionName: "name" },
+    { address: underlyingAsset, abi: METADATA_ABI, functionName: "symbol" },
+    { address: underlyingAsset, abi: METADATA_ABI, functionName: "decimals" }
+  ]);
+  const activeResults = await publicClient.multicall({
+    contracts: activeCalls,
+    allowFailure: true
+  });
+  return active.map((p, i) => {
+    const base = i * PER_ACTIVE;
+    const underlyingValue = activeResults[base]?.status === "success" ? activeResults[base].result : 0n;
+    const underlyingSymbol = activeResults[base + 2]?.status === "success" ? activeResults[base + 2].result : "";
+    const underlyingDecimals = activeResults[base + 3]?.status === "success" ? activeResults[base + 3].result : 18;
+    return {
+      address: p.address,
+      type: p.type,
+      name: p.name,
+      symbol: p.symbol,
+      decimals: p.decimals,
+      sharesBalance: p.sharesBalance,
+      underlyingValue,
+      underlyingAsset: p.underlyingAsset,
+      underlyingSymbol,
+      underlyingDecimals
+    };
+  });
+}
+async function getERC7540RequestStatus(publicClient, vault, subVault) {
+  const v = getAddress(vault);
+  const sv = getAddress(subVault);
+  const results = await publicClient.multicall({
+    contracts: [
+      { address: sv, abi: SUB_VAULT_ABI, functionName: "pendingDepositRequest", args: [0n, v] },
+      { address: sv, abi: SUB_VAULT_ABI, functionName: "claimableDepositRequest", args: [0n, v] },
+      { address: sv, abi: SUB_VAULT_ABI, functionName: "pendingRedeemRequest", args: [0n, v] },
+      { address: sv, abi: SUB_VAULT_ABI, functionName: "claimableRedeemRequest", args: [0n, v] }
+    ],
+    allowFailure: true
+  });
+  const pendingDeposit = results[0]?.status === "success" ? results[0].result : 0n;
+  const claimableDeposit = results[1]?.status === "success" ? results[1].result : 0n;
+  const pendingRedeem = results[2]?.status === "success" ? results[2].result : 0n;
+  const claimableRedeem = results[3]?.status === "success" ? results[3].result : 0n;
+  return {
+    subVault: sv,
+    pendingDeposit,
+    claimableDeposit,
+    pendingRedeem,
+    claimableRedeem,
+    canFinalizeDeposit: claimableDeposit > 0n,
+    canFinalizeRedeem: claimableRedeem > 0n
+  };
+}
+async function getVaultPortfolio(publicClient, vault) {
+  const v = getAddress(vault);
+  const [availableRaw, subVaultPositions, vaultTotals] = await Promise.all([
+    publicClient.readContract({ address: v, abi: VAULT_ANALYSIS_ABI, functionName: "getAvailableAssets" }).catch(() => []),
+    getSubVaultPositions(publicClient, v),
+    publicClient.multicall({
+      contracts: [
+        { address: v, abi: VAULT_ABI, functionName: "totalAssets" },
+        { address: v, abi: VAULT_ABI, functionName: "totalSupply" },
+        { address: v, abi: VAULT_ABI, functionName: "asset" }
+      ],
+      allowFailure: true
+    })
+  ]);
+  const totalAssets = vaultTotals[0]?.status === "success" ? vaultTotals[0].result : 0n;
+  const totalSupply = vaultTotals[1]?.status === "success" ? vaultTotals[1].result : 0n;
+  const underlyingAsset = vaultTotals[2]?.status === "success" ? getAddress(vaultTotals[2].result) : zeroAddress;
+  const availableAddresses = availableRaw.map(getAddress);
+  const subVaultAddressSet = new Set(subVaultPositions.map((p) => p.address.toLowerCase()));
+  const liquidAddresses = availableAddresses.filter(
+    (addr) => !subVaultAddressSet.has(addr.toLowerCase())
+  );
+  const PER_ASSET = 4;
+  const liquidCalls = liquidAddresses.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" }
+  ]);
+  const liquidResults = liquidAddresses.length > 0 ? await publicClient.multicall({ contracts: liquidCalls, allowFailure: true }) : [];
+  const liquidAssets = liquidAddresses.map((addr, i) => {
+    const base = i * PER_ASSET;
+    const balance = liquidResults[base]?.status === "success" ? liquidResults[base].result : 0n;
+    const name = liquidResults[base + 1]?.status === "success" ? liquidResults[base + 1].result : "";
+    const symbol = liquidResults[base + 2]?.status === "success" ? liquidResults[base + 2].result : "";
+    const decimals = liquidResults[base + 3]?.status === "success" ? liquidResults[base + 3].result : 18;
+    return { address: addr, name, symbol, decimals, balance };
+  });
+  const lockedAssets = await publicClient.readContract({
+    address: v,
+    abi: SUB_VAULT_ABI,
+    functionName: "lockedTokensAmountOfAsset",
+    args: [underlyingAsset]
+  }).catch(() => 0n);
+  const subVaultTotal = subVaultPositions.reduce((sum, p) => sum + p.underlyingValue, 0n);
+  const underlyingBalance = liquidAssets.find(
+    (a) => a.address.toLowerCase() === underlyingAsset.toLowerCase()
+  )?.balance ?? 0n;
+  const totalValue = underlyingBalance + subVaultTotal;
+  return {
+    liquidAssets,
+    subVaultPositions,
+    totalValue,
+    totalAssets,
+    totalSupply,
+    lockedAssets
+  };
+}
 
 // src/viem/wagmiCompat.ts
 function asSdkClient(client) {
@@ -2918,7 +3232,63 @@ function useVetoActions(vault, chainId) {
     }
   });
 }
+function useCuratorBridgeQuote(vault, chainId, params) {
+  const publicClient = usePublicClient({ chainId });
+  const query = useQuery({
+    queryKey: ["curatorBridgeQuote", vault, chainId, params],
+    queryFn: () => quoteCuratorBridgeFee(asSdkClient(publicClient), vault, params),
+    enabled: !!vault && !!publicClient && !!params,
+    refetchInterval: 6e4,
+    staleTime: 3e4
+  });
+  return {
+    ...query,
+    fee: query.data
+  };
+}
+function useExecuteBridge(vault, token, chainId) {
+  const publicClient = usePublicClient({ chainId });
+  const { data: walletClient } = useWalletClient({ chainId });
+  return useMutation({
+    mutationFn: async (params) => {
+      if (!walletClient || !publicClient) {
+        throw new Error("Wallet or public client not available");
+      }
+      return executeCuratorBridge(walletClient, asSdkClient(publicClient), vault, token, params);
+    }
+  });
+}
+function useSubVaultPositions(vault, chainId, options) {
+  const publicClient = usePublicClient({ chainId });
+  return useQuery({
+    queryKey: ["subVaultPositions", vault, chainId],
+    queryFn: () => getSubVaultPositions(asSdkClient(publicClient), vault),
+    enabled: !!vault && !!publicClient,
+    refetchInterval: options?.refetchInterval ?? 3e4,
+    staleTime: 15e3
+  });
+}
+function useVaultPortfolio(vault, chainId, options) {
+  const publicClient = usePublicClient({ chainId });
+  return useQuery({
+    queryKey: ["vaultPortfolio", vault, chainId],
+    queryFn: () => getVaultPortfolio(asSdkClient(publicClient), vault),
+    enabled: !!vault && !!publicClient,
+    refetchInterval: options?.refetchInterval ?? 3e4,
+    staleTime: 15e3
+  });
+}
+function useERC7540RequestStatus(vault, chainId, subVault, options) {
+  const publicClient = usePublicClient({ chainId });
+  return useQuery({
+    queryKey: ["erc7540RequestStatus", vault, chainId, subVault],
+    queryFn: () => getERC7540RequestStatus(asSdkClient(publicClient), vault, subVault),
+    enabled: !!vault && !!publicClient && !!subVault,
+    refetchInterval: options?.refetchInterval ?? 15e3,
+    staleTime: 1e4
+  });
+}
 
-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 };
+export { getRouteTokenDecimals, useAsyncRequestStatus, useCuratorBridgeQuote, useCuratorVaultStatus, useDepositSimple, useERC7540RequestStatus, useExecuteActions, useExecuteBridge, useInboundRoutes, useIsCurator, useLzFee, useOmniDeposit, useOmniRedeem, usePendingActions, useProtocolWhitelist, useRedeemShares, useSmartDeposit, useSmartRedeem, useSubVaultPositions, useSubmitActions, useUserPosition, useUserPositionMultiChain, useVaultAnalysis, useVaultAssetBreakdown, useVaultDistribution, useVaultMetadata, useVaultPortfolio, useVaultStatus, useVaultTopology, useVetoActions };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map