@paxoslabs/amplify-sdk 0.5.1 → 0.5.3

package/dist/chunk-WD6QFSXZ.js

@@ -0,0 +1,701 @@
+'use strict';
+
+var chunk6JLKHV6O_js = require('./chunk-6JLKHV6O.js');
+var chunkFHE43NKY_js = require('./chunk-FHE43NKY.js');
+var chunkTNL23CO2_js = require('./chunk-TNL23CO2.js');
+var chunkGOJQYEJQ_js = require('./chunk-GOJQYEJQ.js');
+var viem = require('viem');
+
+async function getMinimumMint(params) {
+  try {
+    const normalizedChainId = chunkGOJQYEJQ_js.toChainId(params.chainId);
+    const config = await chunk6JLKHV6O_js.resolveVault({
+      vaultName: params.vaultName,
+      assetAddress: params.depositAssetAddress,
+      chainId: normalizedChainId,
+      callerEndpoint: "getMinimumMint"
+    });
+    if (!config.vault.accountantAddress) {
+      throw new chunkGOJQYEJQ_js.APIError(
+        `Accountant contract address not configured for vault ${config.id}`,
+        { endpoint: "getMinimumMint" }
+      );
+    }
+    if (!config.vault.boringVaultAddress) {
+      throw new chunkGOJQYEJQ_js.APIError(
+        `BoringVault contract address not configured for vault ${config.id}`,
+        { endpoint: "getMinimumMint" }
+      );
+    }
+    const rateResults = await chunkFHE43NKY_js.getRateInQuoteWithAssetDecimals({
+      assetAddress: params.depositAssetAddress,
+      accountantAddress: config.vault.accountantAddress,
+      chainId: normalizedChainId
+    });
+    const [assetDecimalsResult, exchangeRateResult] = rateResults;
+    if (assetDecimalsResult.status === "failure" || exchangeRateResult.status === "failure") {
+      throw new chunkGOJQYEJQ_js.APIError(
+        `Failed to get exchange rate or asset decimals: ${assetDecimalsResult.error?.message || exchangeRateResult.error?.message}`,
+        { endpoint: "getMinimumMint" }
+      );
+    }
+    const assetDecimals = assetDecimalsResult.result;
+    const exchangeRate = exchangeRateResult.result;
+    const shareDecimals = await chunkFHE43NKY_js.getErc20Decimals({
+      tokenAddress: config.vault.boringVaultAddress,
+      chainId: normalizedChainId
+    });
+    const depositAmountBigInt = viem.parseUnits(params.depositAmount, assetDecimals);
+    const expectedShares = chunkTNL23CO2_js.calculateExpectedSharesMinted(
+      depositAmountBigInt,
+      exchangeRate,
+      shareDecimals
+    );
+    return {
+      expectedShares,
+      exchangeRate,
+      shareDecimals,
+      assetDecimals
+    };
+  } catch (error) {
+    if (error instanceof chunkGOJQYEJQ_js.APIError) {
+      throw error;
+    }
+    throw new chunkGOJQYEJQ_js.APIError(
+      `Failed to calculate minimum mint: ${error instanceof Error ? error.message : String(error)}`,
+      { endpoint: "getMinimumMint", cause: error }
+    );
+  }
+}
+async function getDepositCap(params) {
+  try {
+    const normalizedChainId = chunkGOJQYEJQ_js.toChainId(params.chainId);
+    const config = await chunk6JLKHV6O_js.resolveVault({
+      vaultName: params.vaultName,
+      assetAddress: params.assetAddress,
+      chainId: normalizedChainId,
+      callerEndpoint: "getDepositCap"
+    });
+    if (!config.vault.communityCodeDepositorAddress || !config.vault.depositFeeModuleAddress) {
+      throw new chunkGOJQYEJQ_js.APIError(
+        `Deposit cap not available for vault ${config.id} \u2014 requires both CommunityCodeDepositor and deposit fee module`,
+        { endpoint: "getDepositCap" }
+      );
+    }
+    const [supplyCapInBase, depositFeeModuleAddress] = await Promise.all([
+      chunkGOJQYEJQ_js.readSupplyCapInBase(
+        config.vault.communityCodeDepositorAddress,
+        normalizedChainId
+      ),
+      chunkGOJQYEJQ_js.readFeeModuleFromDCD(
+        config.vault.communityCodeDepositorAddress,
+        normalizedChainId
+      )
+    ]);
+    return {
+      supplyCapInBase,
+      hasDepositCap: supplyCapInBase !== 0n && supplyCapInBase !== viem.maxUint256,
+      depositFeeModuleAddress,
+      hasFees: depositFeeModuleAddress !== viem.zeroAddress
+    };
+  } catch (error) {
+    if (error instanceof chunkGOJQYEJQ_js.APIError) {
+      throw error;
+    }
+    throw new chunkGOJQYEJQ_js.APIError(
+      `Failed to get deposit cap: ${error instanceof Error ? error.message : String(error)}`,
+      { endpoint: "getDepositCap", cause: error }
+    );
+  }
+}
+async function getCurrentSupply(params) {
+  try {
+    const normalizedChainId = chunkGOJQYEJQ_js.toChainId(params.chainId);
+    const config = await chunk6JLKHV6O_js.resolveVault({
+      vaultName: params.vaultName,
+      assetAddress: params.assetAddress,
+      chainId: normalizedChainId,
+      callerEndpoint: "getCurrentSupply"
+    });
+    if (!config.vault.boringVaultAddress) {
+      throw new chunkGOJQYEJQ_js.APIError(
+        `BoringVault contract address not configured for vault ${config.id}`,
+        { endpoint: "getCurrentSupply" }
+      );
+    }
+    if (!config.vault.accountantAddress) {
+      throw new chunkGOJQYEJQ_js.APIError(
+        `Accountant contract address not configured for vault ${config.id}`,
+        { endpoint: "getCurrentSupply" }
+      );
+    }
+    const client = await chunkGOJQYEJQ_js.getClient(normalizedChainId);
+    const results = await client.multicall({
+      contracts: [
+        {
+          abi: chunkFHE43NKY_js.BoringVaultAbi,
+          address: config.vault.boringVaultAddress,
+          functionName: "totalSupply"
+        },
+        {
+          abi: chunkFHE43NKY_js.AccountantAbi,
+          address: config.vault.accountantAddress,
+          functionName: "getRate"
+        },
+        {
+          abi: chunkFHE43NKY_js.AccountantAbi,
+          address: config.vault.accountantAddress,
+          functionName: "decimals"
+        }
+      ]
+    });
+    const [supplyResult, rateResult, decimalsResult] = results;
+    if (supplyResult.status === "failure" || rateResult.status === "failure" || decimalsResult.status === "failure") {
+      throw new chunkGOJQYEJQ_js.APIError("Failed to read supply data from vault contracts", {
+        endpoint: "getCurrentSupply"
+      });
+    }
+    const totalShareSupply = supplyResult.result;
+    const exchangeRate = rateResult.result;
+    const accountantDecimals = decimalsResult.result;
+    const totalValueInBase = totalShareSupply * exchangeRate / BigInt(10 ** accountantDecimals);
+    return {
+      totalShareSupply,
+      exchangeRate,
+      accountantDecimals,
+      totalValueInBase
+    };
+  } catch (error) {
+    if (error instanceof chunkGOJQYEJQ_js.APIError) {
+      throw error;
+    }
+    throw new chunkGOJQYEJQ_js.APIError(
+      `Failed to get current supply: ${error instanceof Error ? error.message : String(error)}`,
+      { endpoint: "getCurrentSupply", cause: error }
+    );
+  }
+}
+async function calculateDepositFee(params) {
+  try {
+    const normalizedChainId = chunkGOJQYEJQ_js.toChainId(params.chainId);
+    const config = await chunk6JLKHV6O_js.resolveVault({
+      vaultName: params.vaultName,
+      assetAddress: params.assetAddress,
+      chainId: normalizedChainId,
+      callerEndpoint: "calculateDepositFee"
+    });
+    const depositFeeModuleAddress = config.vault.depositFeeModuleAddress ?? viem.zeroAddress;
+    const hasFees = depositFeeModuleAddress !== viem.zeroAddress;
+    if (!hasFees) {
+      const assetDecimals2 = await chunkFHE43NKY_js.getErc20Decimals({
+        tokenAddress: params.assetAddress,
+        chainId: normalizedChainId
+      });
+      const depositAmountBigInt2 = viem.parseUnits(
+        params.depositAmount,
+        assetDecimals2
+      );
+      return {
+        hasFees: false,
+        depositFeeModuleAddress,
+        feePercentage: 0n,
+        oneHundredPercent: 0n,
+        flatFee: 0n,
+        variableFeeAmount: 0n,
+        totalFeeAmount: 0n,
+        depositAmountAfterFees: depositAmountBigInt2,
+        assetDecimals: assetDecimals2
+      };
+    }
+    const assetDecimals = await chunkFHE43NKY_js.getErc20Decimals({
+      tokenAddress: params.assetAddress,
+      chainId: normalizedChainId
+    });
+    const { feePercentage, flatFee, oneHundredPercent } = await chunkGOJQYEJQ_js.readDepositFeeStructure(
+      depositFeeModuleAddress,
+      params.assetAddress,
+      normalizedChainId
+    );
+    const depositAmountBigInt = viem.parseUnits(params.depositAmount, assetDecimals);
+    const variableFeeAmount = oneHundredPercent > 0n ? depositAmountBigInt * feePercentage / oneHundredPercent : 0n;
+    const totalFeeAmount = variableFeeAmount + flatFee;
+    const depositAmountAfterFees = depositAmountBigInt > totalFeeAmount ? depositAmountBigInt - totalFeeAmount : 0n;
+    return {
+      hasFees: true,
+      depositFeeModuleAddress,
+      feePercentage,
+      oneHundredPercent,
+      flatFee,
+      variableFeeAmount,
+      totalFeeAmount,
+      depositAmountAfterFees,
+      assetDecimals
+    };
+  } catch (error) {
+    if (error instanceof chunkGOJQYEJQ_js.APIError) {
+      throw error;
+    }
+    throw new chunkGOJQYEJQ_js.APIError(
+      `Failed to calculate deposit fee: ${error instanceof Error ? error.message : String(error)}`,
+      { endpoint: "calculateDepositFee", cause: error }
+    );
+  }
+}
+async function getShareValue(params) {
+  try {
+    if (!params.userAddress && !params.shareAmount) {
+      throw new chunkGOJQYEJQ_js.APIError(
+        "Either userAddress or shareAmount must be provided.",
+        { endpoint: "getShareValue" }
+      );
+    }
+    const normalizedChainId = chunkGOJQYEJQ_js.toChainId(params.chainId);
+    const config = await chunk6JLKHV6O_js.resolveVault({
+      vaultName: params.vaultName,
+      assetAddress: params.quoteAssetAddress,
+      chainId: normalizedChainId,
+      callerEndpoint: "getShareValue"
+    });
+    if (!config.vault.accountantAddress) {
+      throw new chunkGOJQYEJQ_js.APIError(
+        `Accountant contract address not configured for vault ${config.id}`,
+        { endpoint: "getShareValue" }
+      );
+    }
+    if (!config.vault.boringVaultAddress) {
+      throw new chunkGOJQYEJQ_js.APIError(
+        `BoringVault contract address not configured for vault ${config.id}`,
+        { endpoint: "getShareValue" }
+      );
+    }
+    const client = await chunkGOJQYEJQ_js.getClient(normalizedChainId);
+    const results = await client.multicall({
+      contracts: [
+        {
+          abi: viem.erc20Abi,
+          address: params.quoteAssetAddress,
+          functionName: "decimals"
+        },
+        {
+          abi: chunkFHE43NKY_js.BoringVaultAbi,
+          address: config.vault.boringVaultAddress,
+          functionName: "decimals"
+        },
+        {
+          abi: chunkFHE43NKY_js.AccountantAbi,
+          address: config.vault.accountantAddress,
+          functionName: "getRateInQuote",
+          args: [params.quoteAssetAddress]
+        }
+      ]
+    });
+    const [quoteDecimalsResult, shareDecimalsResult, rateResult] = results;
+    if (quoteDecimalsResult.status === "failure" || shareDecimalsResult.status === "failure" || rateResult.status === "failure") {
+      throw new chunkGOJQYEJQ_js.APIError(
+        "Failed to read share value data from vault contracts",
+        { endpoint: "getShareValue" }
+      );
+    }
+    const quoteAssetDecimals = quoteDecimalsResult.result;
+    const shareDecimals = shareDecimalsResult.result;
+    const exchangeRate = rateResult.result;
+    let shareBalance;
+    if (params.shareAmount) {
+      shareBalance = viem.parseUnits(params.shareAmount, shareDecimals);
+    } else {
+      const [balanceResult] = await client.multicall({
+        contracts: [
+          {
+            abi: viem.erc20Abi,
+            address: config.vault.boringVaultAddress,
+            functionName: "balanceOf",
+            args: [params.userAddress]
+          }
+        ]
+      });
+      if (balanceResult.status === "failure") {
+        throw new chunkGOJQYEJQ_js.APIError(
+          `Failed to read balanceOf for ${params.userAddress}`,
+          { endpoint: "getShareValue" }
+        );
+      }
+      shareBalance = balanceResult.result;
+    }
+    const ONE_SHARE = BigInt(10) ** BigInt(shareDecimals);
+    const value = shareBalance * exchangeRate / ONE_SHARE;
+    return {
+      shareBalance,
+      value,
+      exchangeRate,
+      shareDecimals,
+      quoteAssetDecimals
+    };
+  } catch (error) {
+    if (error instanceof chunkGOJQYEJQ_js.APIError) {
+      throw error;
+    }
+    throw new chunkGOJQYEJQ_js.APIError(
+      `Failed to get share value: ${error instanceof Error ? error.message : String(error)}`,
+      { endpoint: "getShareValue", cause: error }
+    );
+  }
+}
+
+// src/display/vault-display.ts
+async function resolveVaultAddressForDisplay(params, callerEndpoint) {
+  if (params.vaultAddress) {
+    if (!chunkGOJQYEJQ_js.isValidAddress(params.vaultAddress)) {
+      throw new chunkGOJQYEJQ_js.APIError(
+        `Invalid vaultAddress: ${params.vaultAddress}. Must be a valid Ethereum address.`,
+        { endpoint: callerEndpoint }
+      );
+    }
+    return params.vaultAddress;
+  }
+  if (params.vaultName) {
+    const cache = chunkGOJQYEJQ_js.getCache();
+    if (cache.isEmpty() || cache.isExpired()) {
+      await cache.refresh();
+    }
+    const vault = cache.getVaultByName(params.vaultName);
+    if (!vault) {
+      throw new chunk6JLKHV6O_js.VaultNotFoundByNameError(
+        `No vault found with name "${params.vaultName}". The vault may not exist or may not be available for your organization.`,
+        { vaultName: params.vaultName, endpoint: callerEndpoint }
+      );
+    }
+    return vault.vault.boringVaultAddress;
+  }
+  throw new chunkGOJQYEJQ_js.APIError("Either vaultAddress or vaultName must be provided.", {
+    endpoint: callerEndpoint
+  });
+}
+async function getVaultAPY(params) {
+  try {
+    const resolvedAddress = await resolveVaultAddressForDisplay(
+      params,
+      "getVaultAPY"
+    );
+    const queryParams = new URLSearchParams({
+      filter: `vaultAddress=${resolvedAddress}`,
+      orderByTimestamp: "desc",
+      pageSize: "1"
+    });
+    const url = `${chunkGOJQYEJQ_js.getRestV2BaseURL()}/amplify/vaultApys?${queryParams.toString()}`;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), chunkGOJQYEJQ_js.DEFAULT_TIMEOUT);
+    const response = await fetch(url, {
+      method: "GET",
+      headers: chunkGOJQYEJQ_js.getRequestHeaders(),
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+    if (!response.ok) {
+      throw new chunkGOJQYEJQ_js.APIError(
+        `Failed to fetch vault APY: ${response.status} ${response.statusText}`,
+        { endpoint: "getVaultAPY", statusCode: response.status }
+      );
+    }
+    const data = await response.json();
+    if (!data.vaultApys || data.vaultApys.length === 0) {
+      throw new chunkGOJQYEJQ_js.APIError(`No APY data found for vault ${resolvedAddress}`, {
+        endpoint: "getVaultAPY"
+      });
+    }
+    const latest = data.vaultApys[0];
+    const apyNumber = Number.parseFloat(latest.apy);
+    return {
+      apy: apyNumber,
+      apyFormatted: `${apyNumber.toFixed(2)}%`,
+      vaultAddress: latest.vaultAddress,
+      timestamp: latest.timestamp
+    };
+  } catch (error) {
+    if (error instanceof chunkGOJQYEJQ_js.APIError) {
+      throw error;
+    }
+    throw new chunkGOJQYEJQ_js.APIError(
+      `Failed to fetch vault APY: ${error instanceof Error ? error.message : String(error)}`,
+      { endpoint: "getVaultAPY", cause: error }
+    );
+  }
+}
+async function getVaultTVL(params) {
+  try {
+    const resolvedAddress = await resolveVaultAddressForDisplay(
+      params,
+      "getVaultTVL"
+    );
+    const filterParts = [`vaultAddress=${resolvedAddress}`];
+    if (params.chainId !== void 0) {
+      filterParts.push(`chainId=${params.chainId}`);
+    }
+    const queryParams = new URLSearchParams({
+      filter: filterParts.join(" AND "),
+      includeCurrent: "true",
+      orderByTimestamp: "desc",
+      pageSize: "1"
+    });
+    const url = `${chunkGOJQYEJQ_js.getRestV2BaseURL()}/amplify/vaultTvls?${queryParams.toString()}`;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), chunkGOJQYEJQ_js.DEFAULT_TIMEOUT);
+    const response = await fetch(url, {
+      method: "GET",
+      headers: chunkGOJQYEJQ_js.getRequestHeaders(),
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+    if (!response.ok) {
+      throw new chunkGOJQYEJQ_js.APIError(
+        `Failed to fetch vault TVL: ${response.status} ${response.statusText}`,
+        { endpoint: "getVaultTVL", statusCode: response.status }
+      );
+    }
+    const data = await response.json();
+    if (!data.vaultTvls || data.vaultTvls.length === 0) {
+      throw new chunkGOJQYEJQ_js.APIError(`No TVL data found for vault ${resolvedAddress}`, {
+        endpoint: "getVaultTVL"
+      });
+    }
+    const latest = data.vaultTvls[0];
+    return {
+      tvl: latest.tvl,
+      tvlAsset: latest.tvlAsset,
+      vaultAddress: latest.vaultAddress,
+      chainId: latest.chainId,
+      timestamp: latest.timestamp
+    };
+  } catch (error) {
+    if (error instanceof chunkGOJQYEJQ_js.APIError) {
+      throw error;
+    }
+    throw new chunkGOJQYEJQ_js.APIError(
+      `Failed to fetch vault TVL: ${error instanceof Error ? error.message : String(error)}`,
+      { endpoint: "getVaultTVL", cause: error }
+    );
+  }
+}
+function buildFilterString(params) {
+  return Object.entries(params).filter(([, v]) => v !== void 0).map(([k, v]) => `${k}=${v}`).join(" AND ");
+}
+async function getWithdrawalRequests(params) {
+  try {
+    if (!chunkGOJQYEJQ_js.isValidAddress(params.userAddress)) {
+      throw new chunkGOJQYEJQ_js.APIError(
+        `Invalid userAddress: ${params.userAddress}. Must be a valid Ethereum address.`,
+        { endpoint: "getWithdrawalRequests" }
+      );
+    }
+    let resolvedVaultAddress = params.vaultAddress;
+    if (!resolvedVaultAddress && params.vaultName) {
+      const cache = chunkGOJQYEJQ_js.getCache();
+      if (cache.isEmpty() || cache.isExpired()) {
+        await cache.refresh();
+      }
+      const vault = cache.getVaultByName(params.vaultName);
+      if (!vault) {
+        throw new chunk6JLKHV6O_js.VaultNotFoundByNameError(
+          `No vault found with name "${params.vaultName}". The vault may not exist or may not be available for your organization.`,
+          { vaultName: params.vaultName, endpoint: "getWithdrawalRequests" }
+        );
+      }
+      resolvedVaultAddress = vault.vault.boringVaultAddress;
+    }
+    const filter = buildFilterString({
+      userAddress: params.userAddress,
+      chainId: params.chainId,
+      vaultAddress: resolvedVaultAddress,
+      status: params.status
+    });
+    const queryParams = new URLSearchParams();
+    if (filter) queryParams.set("filter", filter);
+    if (params.pageSize) queryParams.set("pageSize", String(params.pageSize));
+    if (params.pageToken) queryParams.set("pageToken", params.pageToken);
+    const url = `${chunkGOJQYEJQ_js.getRestV2BaseURL()}/amplify/withdrawalRequests?${queryParams.toString()}`;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), chunkGOJQYEJQ_js.DEFAULT_TIMEOUT);
+    const response = await fetch(url, {
+      method: "GET",
+      headers: chunkGOJQYEJQ_js.getRequestHeaders(),
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+    if (!response.ok) {
+      throw new chunkGOJQYEJQ_js.APIError(
+        `Failed to fetch withdrawal requests: ${response.status} ${response.statusText}`,
+        {
+          endpoint: "getWithdrawalRequests",
+          statusCode: response.status
+        }
+      );
+    }
+    const data = await response.json();
+    return {
+      withdrawalRequests: data.withdrawalRequests ?? [],
+      nextPageToken: data.nextPageToken ?? null
+    };
+  } catch (error) {
+    if (error instanceof chunkGOJQYEJQ_js.APIError) {
+      throw error;
+    }
+    throw new chunkGOJQYEJQ_js.APIError(
+      `Failed to fetch withdrawal requests: ${error instanceof Error ? error.message : String(error)}`,
+      { endpoint: "getWithdrawalRequests", cause: error }
+    );
+  }
+}
+async function getWithdrawalFee(params) {
+  try {
+    const normalizedChainId = chunkGOJQYEJQ_js.toChainId(params.chainId);
+    const config = await chunk6JLKHV6O_js.resolveVault({
+      vaultName: params.vaultName,
+      assetAddress: params.assetAddress,
+      chainId: normalizedChainId,
+      callerEndpoint: "getWithdrawalFee"
+    });
+    if (!config.vault.withdrawQueueAddress) {
+      throw new chunkGOJQYEJQ_js.APIError(
+        `WithdrawQueue contract address not configured for vault ${config.id}`,
+        { endpoint: "getWithdrawalFee" }
+      );
+    }
+    if (!config.vault.boringVaultAddress) {
+      throw new chunkGOJQYEJQ_js.APIError(
+        `BoringVault contract address not configured for vault ${config.id}`,
+        { endpoint: "getWithdrawalFee" }
+      );
+    }
+    const client = await chunkGOJQYEJQ_js.getClient(normalizedChainId);
+    const feeModuleAddress = await client.readContract({
+      abi: chunkGOJQYEJQ_js.WithdrawQueueAbi,
+      address: config.vault.withdrawQueueAddress,
+      functionName: "feeModule"
+    });
+    const shareDecimals = await chunkFHE43NKY_js.getErc20Decimals({
+      tokenAddress: config.vault.boringVaultAddress,
+      chainId: normalizedChainId
+    });
+    const amountBigInt = viem.parseUnits(params.amount, shareDecimals);
+    const results = await client.multicall({
+      contracts: [
+        {
+          abi: chunkGOJQYEJQ_js.FeeModuleAbi,
+          address: feeModuleAddress,
+          functionName: "calculateOfferFees",
+          args: [
+            amountBigInt,
+            params.offerAsset,
+            params.wantAsset,
+            params.receiver
+          ]
+        },
+        {
+          abi: chunkGOJQYEJQ_js.FeeModuleAbi,
+          address: feeModuleAddress,
+          functionName: "offerFeePercentage"
+        }
+      ]
+    });
+    const [feeAmountResult, feePercentageResult] = results;
+    if (feeAmountResult.status === "failure" || feePercentageResult.status === "failure") {
+      throw new chunkGOJQYEJQ_js.APIError("Failed to read fee data from FeeModule contract", {
+        endpoint: "getWithdrawalFee"
+      });
+    }
+    return {
+      feeAmount: feeAmountResult.result,
+      feePercentage: feePercentageResult.result
+    };
+  } catch (error) {
+    if (error instanceof chunkGOJQYEJQ_js.APIError) {
+      throw error;
+    }
+    throw new chunkGOJQYEJQ_js.APIError(
+      `Failed to get withdrawal fee: ${error instanceof Error ? error.message : String(error)}`,
+      { endpoint: "getWithdrawalFee", cause: error }
+    );
+  }
+}
+async function getMinimumWithdrawalOrderSize(params) {
+  try {
+    const normalizedChainId = chunkGOJQYEJQ_js.toChainId(params.chainId);
+    const config = await chunk6JLKHV6O_js.resolveVault({
+      vaultName: params.vaultName,
+      assetAddress: params.assetAddress,
+      chainId: normalizedChainId,
+      callerEndpoint: "getMinimumWithdrawalOrderSize"
+    });
+    if (!config.vault.withdrawQueueAddress) {
+      throw new chunkGOJQYEJQ_js.APIError(
+        `WithdrawQueue contract address not configured for vault ${config.id}`,
+        { endpoint: "getMinimumWithdrawalOrderSize" }
+      );
+    }
+    if (!config.vault.boringVaultAddress) {
+      throw new chunkGOJQYEJQ_js.APIError(
+        `BoringVault contract address not configured for vault ${config.id}`,
+        { endpoint: "getMinimumWithdrawalOrderSize" }
+      );
+    }
+    const client = await chunkGOJQYEJQ_js.getClient(normalizedChainId);
+    const [minOrderResult, shareDecimalsResult] = await client.multicall({
+      contracts: [
+        {
+          abi: chunkGOJQYEJQ_js.WithdrawQueueAbi,
+          address: config.vault.withdrawQueueAddress,
+          functionName: "minimumOrderSize"
+        },
+        {
+          abi: [
+            {
+              inputs: [],
+              name: "decimals",
+              outputs: [
+                {
+                  internalType: "uint8",
+                  name: "",
+                  type: "uint8"
+                }
+              ],
+              stateMutability: "view",
+              type: "function"
+            }
+          ],
+          address: config.vault.boringVaultAddress,
+          functionName: "decimals"
+        }
+      ]
+    });
+    if (minOrderResult.status === "failure" || shareDecimalsResult.status === "failure") {
+      throw new chunkGOJQYEJQ_js.APIError(
+        "Failed to read minimum order size from WithdrawQueue contract",
+        { endpoint: "getMinimumWithdrawalOrderSize" }
+      );
+    }
+    return {
+      minimumOrderSize: minOrderResult.result,
+      shareDecimals: shareDecimalsResult.result
+    };
+  } catch (error) {
+    if (error instanceof chunkGOJQYEJQ_js.APIError) {
+      throw error;
+    }
+    throw new chunkGOJQYEJQ_js.APIError(
+      `Failed to get minimum withdrawal order size: ${error instanceof Error ? error.message : String(error)}`,
+      { endpoint: "getMinimumWithdrawalOrderSize", cause: error }
+    );
+  }
+}
+
+exports.calculateDepositFee = calculateDepositFee;
+exports.getCurrentSupply = getCurrentSupply;
+exports.getDepositCap = getDepositCap;
+exports.getMinimumMint = getMinimumMint;
+exports.getMinimumWithdrawalOrderSize = getMinimumWithdrawalOrderSize;
+exports.getShareValue = getShareValue;
+exports.getVaultAPY = getVaultAPY;
+exports.getVaultTVL = getVaultTVL;
+exports.getWithdrawalFee = getWithdrawalFee;
+exports.getWithdrawalRequests = getWithdrawalRequests;
+//# sourceMappingURL=chunk-WD6QFSXZ.js.map
+//# sourceMappingURL=chunk-WD6QFSXZ.js.map