@paxoslabs/amplify-sdk 0.0.1-alpha.1

package/dist/index.js

@@ -0,0 +1,1115 @@
+'use strict';
+
+var chunkITB7FXG4_js = require('./chunk-ITB7FXG4.js');
+var chunkO5P6SP2O_js = require('./chunk-O5P6SP2O.js');
+var chunkJLXNOGZB_js = require('./chunk-JLXNOGZB.js');
+require('./chunk-ICKDAKVS.js');
+var chunkRUIAH5HY_js = require('./chunk-RUIAH5HY.js');
+var chunkAFWUOS3M_js = require('./chunk-AFWUOS3M.js');
+var chunk3I3PYX2F_js = require('./chunk-3I3PYX2F.js');
+var chunkBDXS57YH_js = require('./chunk-BDXS57YH.js');
+var viem = require('viem');
+
+async function prepareApproveDepositTokenTxData({
+  yieldType,
+  depositToken,
+  approvalAmount,
+  chainId
+}) {
+  const normalizedChainId = chunkRUIAH5HY_js.toChainId(chainId);
+  try {
+    const config = await chunkBDXS57YH_js.findVaultByConfig({
+      assetAddress: depositToken,
+      yieldType,
+      chainId: normalizedChainId
+    });
+    if (!config) {
+      throw new chunkBDXS57YH_js.APIError(
+        `No vault found for token address ${depositToken} with yield type '${yieldType}' on chain ${normalizedChainId}. This combination may not be supported.`,
+        { endpoint: "prepareApproveDepositToken" }
+      );
+    }
+    const boringVaultAddress = config.vault.boringVaultAddress;
+    if (!boringVaultAddress) {
+      throw new chunkBDXS57YH_js.APIError(
+        `BoringVault contract address not configured for vault ${config.id}`,
+        { endpoint: "prepareApproveDepositToken" }
+      );
+    }
+    const assets = await chunkBDXS57YH_js.getAssetsFromCache({ address: depositToken });
+    if (assets.length === 0) {
+      throw new chunkBDXS57YH_js.APIError(
+        `Asset metadata not found for token ${depositToken} on chain ${normalizedChainId}`,
+        { endpoint: "prepareApproveDepositToken" }
+      );
+    }
+    const decimals = assets[0].decimals;
+    const amount = approvalAmount ? viem.parseUnits(approvalAmount, decimals) : chunkBDXS57YH_js.DEFAULT_APPROVAL_AMOUNT;
+    return {
+      abi: viem.erc20Abi,
+      address: depositToken,
+      functionName: "approve",
+      args: [boringVaultAddress, amount]
+    };
+  } catch (error) {
+    if (error instanceof chunkBDXS57YH_js.APIError) {
+      throw error;
+    }
+    throw new chunkBDXS57YH_js.APIError(
+      `Failed to prepare approval transaction: ${error instanceof Error ? error.message : String(error)}`,
+      {
+        endpoint: "prepareApproveDepositToken",
+        cause: error
+      }
+    );
+  }
+}
+
+// src/vaults/deposit/utils.ts
+var calculateMinimumMint = (depositAmount, rate, vaultTokenDecimals, slippage) => {
+  const slippageValue = slippage ?? chunkITB7FXG4_js.DEFAULT_SLIPPAGE_BPS;
+  const slippageAsBigInt = BigInt(slippageValue) * chunk3I3PYX2F_js.WAD.bigint / BigInt(1e4);
+  const minimumMint = depositAmount * chunk3I3PYX2F_js.WAD.bigint / rate;
+  const slippageAmount = minimumMint * slippageAsBigInt / chunk3I3PYX2F_js.WAD.bigint;
+  if (vaultTokenDecimals > 18) {
+    return (minimumMint - slippageAmount) * BigInt(10) ** (BigInt(vaultTokenDecimals) - BigInt(18));
+  }
+  return (minimumMint - slippageAmount) / BigInt(10) ** (BigInt(18) - BigInt(vaultTokenDecimals));
+};
+
+// src/vaults/deposit/deposit.ts
+async function prepareDepositTxData(params) {
+  const {
+    yieldType,
+    depositToken,
+    depositAmount,
+    chainId,
+    slippage = chunkITB7FXG4_js.DEFAULT_SLIPPAGE_BPS
+  } = params;
+  try {
+    const normalizedChainId = chunkRUIAH5HY_js.toChainId(chainId);
+    let vault;
+    try {
+      vault = await chunkBDXS57YH_js.findVaultByConfig({
+        assetAddress: depositToken,
+        yieldType,
+        chainId: normalizedChainId
+      });
+    } catch (error) {
+      throw new chunkBDXS57YH_js.APIError(
+        `Failed to resolve vault for token ${depositToken} with yield type ${yieldType} on chain ${normalizedChainId}: ${error instanceof Error ? error.message : "Unknown error"}`,
+        {
+          endpoint: "prepareDepositTransactionData",
+          cause: error
+        }
+      );
+    }
+    if (!vault) {
+      throw new chunkBDXS57YH_js.APIError(
+        `No vault found for token address ${depositToken} with yield type '${yieldType}' on chain ${normalizedChainId}. This combination may not be supported.`,
+        {
+          endpoint: "prepareDepositTransactionData"
+        }
+      );
+    }
+    let asset = null;
+    const assets = await chunkBDXS57YH_js.getAssetsFromCache({ address: depositToken });
+    if (assets.length > 0) {
+      asset = assets.find((a) => a.chains.includes(normalizedChainId)) || assets[0] || null;
+    }
+    if (!asset) {
+      throw new chunkBDXS57YH_js.APIError(
+        `Asset metadata not found for token ${depositToken} on chain ${normalizedChainId}`,
+        {
+          endpoint: "prepareDepositTransactionData"
+        }
+      );
+    }
+    const tellerAddress = vault.vault.tellerAddress;
+    const accountantAddress = vault.vault.accountantAddress;
+    const depositAssetAddress = asset.address;
+    const [depositAssetDecimalsResult, rateInQuoteResult] = await chunkJLXNOGZB_js.getRateInQuoteWithAssetDecimals({
+      assetAddress: depositAssetAddress,
+      accountantAddress,
+      chainId: normalizedChainId
+    });
+    if (depositAssetDecimalsResult.status === "failure") {
+      throw new chunkBDXS57YH_js.APIError(
+        `Failed to get asset decimals: ${depositAssetDecimalsResult.error?.message || "Unknown error"}`,
+        {
+          endpoint: "prepareDepositTransactionData",
+          cause: depositAssetDecimalsResult.error
+        }
+      );
+    }
+    if (rateInQuoteResult.status === "failure") {
+      throw new chunkBDXS57YH_js.APIError(
+        `Failed to get exchange rate: ${rateInQuoteResult.error?.message || "Unknown error"}`,
+        {
+          endpoint: "prepareDepositTransactionData",
+          cause: rateInQuoteResult.error
+        }
+      );
+    }
+    const depositAmountAsBigInt = viem.parseUnits(
+      depositAmount,
+      depositAssetDecimalsResult.result
+    );
+    const vaultSharesAssets = await chunkBDXS57YH_js.fetchSupportedAssets({
+      address: vault.vault.boringVaultAddress
+    });
+    if (vaultSharesAssets.length === 0) {
+      throw new chunkBDXS57YH_js.APIError(
+        `Vault shares token not found in supported assets: ${vault.vault.boringVaultAddress}`,
+        { endpoint: "prepareDepositTransactionData" }
+      );
+    }
+    const minimumMint = calculateMinimumMint(
+      depositAmountAsBigInt,
+      rateInQuoteResult.result,
+      depositAssetDecimalsResult.result,
+      slippage
+    );
+    return {
+      abi: chunkJLXNOGZB_js.TellerAbi,
+      address: tellerAddress,
+      functionName: "deposit",
+      args: [depositAssetAddress, depositAmountAsBigInt, minimumMint],
+      chainId: normalizedChainId
+    };
+  } catch (error) {
+    if (error instanceof chunkBDXS57YH_js.APIError) {
+      throw error;
+    }
+    throw new chunkBDXS57YH_js.APIError(
+      `Failed to prepare deposit transaction: ${error instanceof Error ? error.message : String(error)}`,
+      {
+        endpoint: "prepareDepositTransactionData",
+        cause: error
+      }
+    );
+  }
+}
+
+// src/abi/erc2612-abi.ts
+var erc2612Abi = [
+  // Standard ERC20 functions (subset needed for permit flow)
+  {
+    constant: true,
+    inputs: [{ name: "_owner", type: "address" }],
+    name: "nonces",
+    outputs: [{ name: "", type: "uint256" }],
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "DOMAIN_SEPARATOR",
+    outputs: [{ name: "", type: "bytes32" }],
+    type: "function"
+  },
+  {
+    constant: false,
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" },
+      { name: "value", type: "uint256" },
+      { name: "deadline", type: "uint256" },
+      { name: "v", type: "uint8" },
+      { name: "r", type: "bytes32" },
+      { name: "s", type: "bytes32" }
+    ],
+    name: "permit",
+    outputs: [],
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "name",
+    outputs: [{ name: "", type: "string" }],
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "version",
+    outputs: [{ name: "", type: "string" }],
+    type: "function"
+  }
+];
+
+// src/vaults/deposit/deposit-with-permit.ts
+var PERMIT_TYPES = {
+  Permit: [
+    { name: "owner", type: "address" },
+    { name: "spender", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint256" }
+  ]
+};
+async function prepareDepositPermitSignature(params) {
+  const {
+    yieldType,
+    depositToken,
+    depositAmount,
+    recipientAddress,
+    chainId,
+    deadline
+  } = params;
+  try {
+    const normalizedChainId = chunkRUIAH5HY_js.toChainId(chainId);
+    let vault;
+    try {
+      vault = await chunkBDXS57YH_js.findVaultByConfig({
+        assetAddress: depositToken,
+        yieldType,
+        chainId: normalizedChainId
+      });
+    } catch (error) {
+      throw new chunkBDXS57YH_js.APIError(
+        `Failed to resolve vault for token ${depositToken} with yield type ${yieldType} on chain ${normalizedChainId}: ${error instanceof Error ? error.message : "Unknown error"}`,
+        {
+          endpoint: "prepareDepositPermitSignature",
+          cause: error
+        }
+      );
+    }
+    if (!vault) {
+      throw new chunkBDXS57YH_js.APIError(
+        `No vault found for token address ${depositToken} with yield type '${yieldType}' on chain ${normalizedChainId}. This combination may not be supported.`,
+        {
+          endpoint: "prepareDepositPermitSignature"
+        }
+      );
+    }
+    const tellerAddress = vault.vault.tellerAddress;
+    const client = await chunkJLXNOGZB_js.getClient(normalizedChainId);
+    let tokenName;
+    let tokenVersion;
+    let nonce;
+    try {
+      const [nameResult, versionResult, nonceResult] = await Promise.allSettled(
+        [
+          client.readContract({
+            address: depositToken,
+            abi: erc2612Abi,
+            functionName: "name"
+          }),
+          client.readContract({
+            address: depositToken,
+            abi: erc2612Abi,
+            functionName: "version"
+          }),
+          client.readContract({
+            address: depositToken,
+            abi: erc2612Abi,
+            functionName: "nonces",
+            args: [recipientAddress]
+          })
+        ]
+      );
+      if (nameResult.status === "fulfilled") {
+        tokenName = nameResult.value;
+      } else {
+        throw new chunkBDXS57YH_js.APIError(`Failed to read token name from ${depositToken}`, {
+          endpoint: "prepareDepositPermitSignature",
+          cause: nameResult.reason
+        });
+      }
+      if (versionResult.status === "fulfilled") {
+        tokenVersion = versionResult.value;
+      } else {
+        tokenVersion = "1";
+      }
+      if (nonceResult.status === "fulfilled") {
+        nonce = nonceResult.value;
+      } else {
+        throw new chunkBDXS57YH_js.APIError(
+          `Token ${depositToken} does not support EIP-2612 permit. Missing required function: nonces()`,
+          {
+            endpoint: "prepareDepositPermitSignature",
+            cause: nonceResult.reason
+          }
+        );
+      }
+    } catch (error) {
+      if (error instanceof chunkBDXS57YH_js.APIError) {
+        throw error;
+      }
+      throw new chunkBDXS57YH_js.APIError(
+        `Failed to read token metadata: ${error instanceof Error ? error.message : "Unknown error"}`,
+        {
+          endpoint: "prepareDepositPermitSignature",
+          cause: error
+        }
+      );
+    }
+    const permitDeadline = deadline ?? BigInt(Math.floor(Date.now() / 1e3) + 3600);
+    const assets = await chunkBDXS57YH_js.fetchSupportedAssets({ address: depositToken });
+    if (assets.length === 0) {
+      throw new chunkBDXS57YH_js.APIError(`Asset metadata not found for token ${depositToken}`, {
+        endpoint: "prepareDepositPermitSignature"
+      });
+    }
+    const asset = assets[0];
+    const value = viem.parseUnits(depositAmount, asset.decimals);
+    const domain = {
+      name: tokenName,
+      version: tokenVersion,
+      chainId: normalizedChainId,
+      verifyingContract: depositToken
+    };
+    const message = {
+      owner: recipientAddress,
+      spender: tellerAddress,
+      value,
+      nonce,
+      deadline: permitDeadline
+    };
+    return {
+      domain,
+      message,
+      primaryType: "Permit",
+      types: PERMIT_TYPES
+    };
+  } catch (error) {
+    if (error instanceof chunkBDXS57YH_js.APIError) {
+      throw error;
+    }
+    throw new chunkBDXS57YH_js.APIError(
+      `Failed to prepare permit signature: ${error instanceof Error ? error.message : String(error)}`,
+      {
+        endpoint: "prepareDepositPermitSignature",
+        cause: error
+      }
+    );
+  }
+}
+function parsePermitSignature(signature) {
+  try {
+    const parsed = viem.hexToSignature(signature);
+    let v;
+    if (parsed.v !== void 0) {
+      v = Number(parsed.v);
+    } else if (parsed.yParity !== void 0) {
+      v = parsed.yParity + 27;
+    } else {
+      v = 27;
+    }
+    return {
+      v,
+      r: parsed.r,
+      s: parsed.s
+    };
+  } catch (error) {
+    throw new chunkBDXS57YH_js.APIError(
+      `Invalid permit signature format. Expected hex string but received: ${signature}. ${error instanceof Error ? error.message : "Unknown error"}`,
+      {
+        endpoint: "parsePermitSignature",
+        cause: error
+      }
+    );
+  }
+}
+async function prepareDepositWithPermitTransactionData(params) {
+  const {
+    yieldType,
+    depositToken,
+    depositAmount,
+    chainId,
+    signature,
+    deadline,
+    slippage = chunkITB7FXG4_js.DEFAULT_SLIPPAGE_BPS
+  } = params;
+  try {
+    const { v, r, s } = parsePermitSignature(signature);
+    if (slippage < 0 || slippage > 1e4) {
+      throw new chunkBDXS57YH_js.APIError(
+        `Invalid slippage value: ${slippage}. Slippage must be between 0 and 10000 basis points.`,
+        {
+          endpoint: "prepareDepositWithPermitTransactionData"
+        }
+      );
+    }
+    const normalizedChainId = chunkRUIAH5HY_js.toChainId(chainId);
+    let vault;
+    try {
+      vault = await chunkBDXS57YH_js.findVaultByConfig({
+        assetAddress: depositToken,
+        yieldType,
+        chainId: normalizedChainId
+      });
+    } catch (error) {
+      throw new chunkBDXS57YH_js.APIError(
+        `Failed to resolve vault for token ${depositToken} with yield type ${yieldType} on chain ${normalizedChainId}: ${error instanceof Error ? error.message : "Unknown error"}`,
+        {
+          endpoint: "prepareDepositWithPermitTransactionData",
+          cause: error
+        }
+      );
+    }
+    if (!vault) {
+      throw new chunkBDXS57YH_js.APIError(
+        `No vault found for token address ${depositToken} with yield type '${yieldType}' on chain ${normalizedChainId}. This combination may not be supported.`,
+        {
+          endpoint: "prepareDepositWithPermitTransactionData"
+        }
+      );
+    }
+    let asset = null;
+    const assets = await chunkBDXS57YH_js.fetchSupportedAssets({ address: depositToken });
+    if (assets.length > 0) {
+      asset = assets.find((a) => a.chains.includes(normalizedChainId)) || assets[0] || null;
+    }
+    if (!asset) {
+      throw new chunkBDXS57YH_js.APIError(
+        `Asset metadata not found for token ${depositToken} on chain ${normalizedChainId}`,
+        {
+          endpoint: "prepareDepositWithPermitTransactionData"
+        }
+      );
+    }
+    if (!asset.chains || !asset.chains.includes(normalizedChainId)) {
+      throw new chunkBDXS57YH_js.APIError(
+        `Token ${asset.symbol || depositToken} not supported on chain ${normalizedChainId}`,
+        {
+          endpoint: "prepareDepositWithPermitTransactionData"
+        }
+      );
+    }
+    const tellerAddress = vault.vault.tellerAddress;
+    const accountantAddress = vault.vault.accountantAddress;
+    const depositAssetAddress = asset.address;
+    const [depositAssetDecimalsResult, rateInQuoteResult] = await chunkJLXNOGZB_js.getRateInQuoteWithAssetDecimals({
+      assetAddress: depositAssetAddress,
+      accountantAddress,
+      chainId: normalizedChainId
+    });
+    if (depositAssetDecimalsResult.status === "failure") {
+      throw new chunkBDXS57YH_js.APIError(
+        `Failed to get asset decimals: ${depositAssetDecimalsResult.error?.message || "Unknown error"}`,
+        {
+          endpoint: "prepareDepositWithPermitTransactionData",
+          cause: depositAssetDecimalsResult.error
+        }
+      );
+    }
+    if (rateInQuoteResult.status === "failure") {
+      throw new chunkBDXS57YH_js.APIError(
+        `Failed to get exchange rate: ${rateInQuoteResult.error?.message || "Unknown error"}`,
+        {
+          endpoint: "prepareDepositWithPermitTransactionData",
+          cause: rateInQuoteResult.error
+        }
+      );
+    }
+    const depositAmountAsBigInt = viem.parseUnits(depositAmount, asset.decimals);
+    const vaultSharesAssets = await chunkBDXS57YH_js.fetchSupportedAssets({
+      address: vault.vault.boringVaultAddress
+    });
+    if (vaultSharesAssets.length === 0) {
+      throw new chunkBDXS57YH_js.APIError(
+        `Vault shares token not found in supported assets: ${vault.vault.boringVaultAddress}`,
+        { endpoint: "prepareDepositWithPermitTransactionData" }
+      );
+    }
+    const minimumMint = calculateMinimumMint(
+      depositAmountAsBigInt,
+      rateInQuoteResult.result,
+      vaultSharesAssets[0].decimals,
+      slippage
+    );
+    return {
+      data: {
+        abi: chunkJLXNOGZB_js.TellerAbi,
+        functionName: "depositWithPermit",
+        args: [
+          depositAssetAddress,
+          depositAmountAsBigInt,
+          minimumMint,
+          deadline,
+          v,
+          r,
+          s
+        ]
+      },
+      address: tellerAddress,
+      chainId: normalizedChainId
+    };
+  } catch (error) {
+    if (error instanceof chunkBDXS57YH_js.APIError) {
+      throw error;
+    }
+    throw new chunkBDXS57YH_js.APIError(
+      `Failed to prepare deposit with permit transaction: ${error instanceof Error ? error.message : String(error)}`,
+      {
+        endpoint: "prepareDepositWithPermitTransactionData",
+        cause: error
+      }
+    );
+  }
+}
+async function prepareApproveWithdrawTxData({
+  yieldType,
+  wantAssetAddress,
+  withdrawAmount,
+  chainId
+}) {
+  try {
+    const normalizedChainId = chunkRUIAH5HY_js.toChainId(chainId);
+    const config = await chunkBDXS57YH_js.findVaultByConfig({
+      assetAddress: wantAssetAddress,
+      yieldType,
+      chainId: normalizedChainId
+    });
+    if (!config || config.chainId !== normalizedChainId) {
+      throw new chunkBDXS57YH_js.APIError(
+        `Vault chain mismatch: vault is on chain ${config?.chainId}, requested chain ${normalizedChainId}`,
+        { endpoint: "prepareApproveWithdrawToken" }
+      );
+    }
+    if (!config.vault.boringVaultAddress) {
+      throw new chunkBDXS57YH_js.APIError(
+        `BoringVault contract address not configured for vault ${config.id}`,
+        { endpoint: "prepareApproveWithdrawToken" }
+      );
+    }
+    const boringVaultAddress = config.vault.boringVaultAddress;
+    const vaultSharesAssets = await chunkBDXS57YH_js.getAssetsFromCache({
+      address: boringVaultAddress
+    });
+    if (vaultSharesAssets.length === 0) {
+      throw new chunkBDXS57YH_js.APIError(
+        `Vault shares token not found in supported assets: ${boringVaultAddress}`,
+        { endpoint: "prepareApproveWithdrawToken" }
+      );
+    }
+    const withdrawAmountAsBigInt = withdrawAmount ? viem.parseUnits(withdrawAmount, vaultSharesAssets[0].decimals) : chunkBDXS57YH_js.DEFAULT_APPROVAL_AMOUNT;
+    return {
+      abi: chunkJLXNOGZB_js.BoringVaultAbi,
+      address: boringVaultAddress,
+      functionName: "approve",
+      args: [chunkBDXS57YH_js.ATOMIC_QUEUE_CONTRACT_ADDRESS, withdrawAmountAsBigInt]
+    };
+  } catch (error) {
+    if (error instanceof chunkBDXS57YH_js.APIError) {
+      throw error;
+    }
+    throw new chunkBDXS57YH_js.APIError(
+      `Failed to prepare approval transaction: ${error instanceof Error ? error.message : String(error)}`,
+      {
+        endpoint: "prepareApproveWithdrawToken",
+        cause: error
+      }
+    );
+  }
+}
+
+// src/vaults/withdraw/utils.ts
+var prepareUserRequest = (offerAmount, atomicPrice, deadline) => {
+  const deadlineTimeStamp = chunkAFWUOS3M_js.calculateDeadline(deadline);
+  return {
+    deadline: deadlineTimeStamp,
+    atomicPrice,
+    offerAmount,
+    inSolve: false
+  };
+};
+var calculateAtomicPrice = (rateInQuote, wantAssetDecimals, slippage) => {
+  const wantPrecision = BigInt(10 ** wantAssetDecimals);
+  const slippageAsBigInt = BigInt(slippage) * wantPrecision / BigInt(1e4);
+  return rateInQuote * (wantPrecision - slippageAsBigInt) / wantPrecision;
+};
+
+// src/vaults/withdraw/bulk-withdraw.ts
+async function prepareBulkWithdrawTxData(params) {
+  const {
+    yieldType,
+    wantAssetAddress,
+    shareAmount,
+    chainId,
+    slippage = chunkITB7FXG4_js.DEFAULT_SLIPPAGE_BPS,
+    userAddress
+  } = params;
+  try {
+    const normalizedChainId = chunkRUIAH5HY_js.toChainId(chainId);
+    const vault = await chunkBDXS57YH_js.findVaultByConfig({
+      assetAddress: wantAssetAddress,
+      yieldType,
+      chainId: normalizedChainId
+    });
+    if (vault && vault.chainId !== normalizedChainId) {
+      throw new chunkBDXS57YH_js.APIError(
+        `Vault chain mismatch: vault is on chain ${vault.chainId}, requested chain ${normalizedChainId}`,
+        { endpoint: "prepareBulkWithdrawTransactionData" }
+      );
+    }
+    if (!vault || !vault.vault.boringVaultAddress) {
+      throw new chunkBDXS57YH_js.APIError(
+        `BoringVault contract address not configured for vault ${vault?.vault.boringVaultAddress}`,
+        { endpoint: "prepareBulkWithdrawTransactionData" }
+      );
+    }
+    const boringVaultAddress = vault.vault.boringVaultAddress;
+    const accountantAddress = vault.vault.accountantAddress;
+    const wantAsset = await chunkBDXS57YH_js.getAssetsFromCache({
+      address: wantAssetAddress
+    });
+    if (wantAsset.length === 0) {
+      throw new chunkBDXS57YH_js.APIError(
+        `Vault shares token not found in supported assets: ${boringVaultAddress}`,
+        { endpoint: "prepareBulkWithdrawTransactionData" }
+      );
+    }
+    const [
+      wantAssetDecimalsResult,
+      sharesAssetDecimalsResult,
+      rateInQuoteResult
+    ] = await chunkJLXNOGZB_js.getRateInQuoteAndSharesAndWantAssetDecimals({
+      sharesAssetAddress: boringVaultAddress,
+      wantAssetAddress,
+      accountantAddress,
+      chainId: normalizedChainId
+    });
+    if (rateInQuoteResult.status === "failure" || wantAssetDecimalsResult.status === "failure" || sharesAssetDecimalsResult.status === "failure") {
+      throw new chunkBDXS57YH_js.APIError(
+        `Failed to get exchange rate: ${rateInQuoteResult?.error?.message || wantAssetDecimalsResult?.error?.message || sharesAssetDecimalsResult?.error?.message}`,
+        {
+          endpoint: "prepareBulkWithdrawTransactionData",
+          cause: rateInQuoteResult?.error || wantAssetDecimalsResult?.error || sharesAssetDecimalsResult?.error
+        }
+      );
+    }
+    const offerAmountAsBigInt = viem.parseUnits(
+      shareAmount,
+      sharesAssetDecimalsResult.result
+    );
+    const atomicPrice = calculateAtomicPrice(
+      rateInQuoteResult.result,
+      // rateInQuote bigint
+      wantAssetDecimalsResult.result,
+      // Want asset decimals from API
+      slippage
+    );
+    const minimumAssets = atomicPrice * offerAmountAsBigInt / BigInt(10 ** sharesAssetDecimalsResult.result);
+    return {
+      abi: chunkJLXNOGZB_js.TellerAbi,
+      address: vault.vault.tellerAddress,
+      functionName: "bulkWithdraw",
+      args: [wantAssetAddress, offerAmountAsBigInt, minimumAssets, userAddress],
+      chainId: normalizedChainId
+    };
+  } catch (error) {
+    if (error instanceof chunkBDXS57YH_js.APIError) {
+      throw error;
+    }
+    throw new chunkBDXS57YH_js.APIError(
+      `Failed to prepare withdrawal transaction: ${error instanceof Error ? error.message : String(error)}`,
+      {
+        endpoint: "prepareBulkWithdrawTransactionData",
+        cause: error
+      }
+    );
+  }
+}
+
+// src/abi/atomic-queue-abi.ts
+var AtomicQueueAbi = [
+  {
+    type: "function",
+    name: "getUserAtomicRequest",
+    inputs: [
+      { name: "user", type: "address", internalType: "address" },
+      { name: "offer", type: "address", internalType: "contract ERC20" },
+      { name: "want", type: "address", internalType: "contract ERC20" }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        internalType: "struct AtomicQueue.AtomicRequest",
+        components: [
+          { name: "deadline", type: "uint64", internalType: "uint64" },
+          { name: "atomicPrice", type: "uint88", internalType: "uint88" },
+          { name: "offerAmount", type: "uint96", internalType: "uint96" },
+          { name: "inSolve", type: "bool", internalType: "bool" }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "isAtomicRequestValid",
+    inputs: [
+      { name: "offer", type: "address", internalType: "contract ERC20" },
+      { name: "user", type: "address", internalType: "address" },
+      {
+        name: "userRequest",
+        type: "tuple",
+        internalType: "struct AtomicQueue.AtomicRequest",
+        components: [
+          { name: "deadline", type: "uint64", internalType: "uint64" },
+          { name: "atomicPrice", type: "uint88", internalType: "uint88" },
+          { name: "offerAmount", type: "uint96", internalType: "uint96" },
+          { name: "inSolve", type: "bool", internalType: "bool" }
+        ]
+      }
+    ],
+    outputs: [{ name: "", type: "bool", internalType: "bool" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "solve",
+    inputs: [
+      { name: "offer", type: "address", internalType: "contract ERC20" },
+      { name: "want", type: "address", internalType: "contract ERC20" },
+      { name: "users", type: "address[]", internalType: "address[]" },
+      { name: "runData", type: "bytes", internalType: "bytes" },
+      { name: "solver", type: "address", internalType: "address" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "updateAtomicRequest",
+    inputs: [
+      { name: "offer", type: "address", internalType: "contract ERC20" },
+      { name: "want", type: "address", internalType: "contract ERC20" },
+      {
+        name: "userRequest",
+        type: "tuple",
+        internalType: "struct AtomicQueue.AtomicRequest",
+        components: [
+          { name: "deadline", type: "uint64", internalType: "uint64" },
+          { name: "atomicPrice", type: "uint88", internalType: "uint88" },
+          { name: "offerAmount", type: "uint96", internalType: "uint96" },
+          { name: "inSolve", type: "bool", internalType: "bool" }
+        ]
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "userAtomicRequest",
+    inputs: [
+      { name: "", type: "address", internalType: "address" },
+      { name: "", type: "address", internalType: "contract ERC20" },
+      { name: "", type: "address", internalType: "contract ERC20" }
+    ],
+    outputs: [
+      { name: "deadline", type: "uint64", internalType: "uint64" },
+      { name: "atomicPrice", type: "uint88", internalType: "uint88" },
+      { name: "offerAmount", type: "uint96", internalType: "uint96" },
+      { name: "inSolve", type: "bool", internalType: "bool" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "viewSolveMetaData",
+    inputs: [
+      { name: "offer", type: "address", internalType: "contract ERC20" },
+      { name: "want", type: "address", internalType: "contract ERC20" },
+      { name: "users", type: "address[]", internalType: "address[]" }
+    ],
+    outputs: [
+      {
+        name: "metaData",
+        type: "tuple[]",
+        internalType: "struct AtomicQueue.SolveMetaData[]",
+        components: [
+          { name: "user", type: "address", internalType: "address" },
+          { name: "flags", type: "uint8", internalType: "uint8" },
+          { name: "assetsToOffer", type: "uint256", internalType: "uint256" },
+          { name: "assetsForWant", type: "uint256", internalType: "uint256" }
+        ]
+      },
+      { name: "totalAssetsForWant", type: "uint256", internalType: "uint256" },
+      { name: "totalAssetsToOffer", type: "uint256", internalType: "uint256" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "event",
+    name: "AtomicRequestFulfilled",
+    inputs: [
+      {
+        name: "user",
+        type: "address",
+        indexed: false,
+        internalType: "address"
+      },
+      {
+        name: "offerToken",
+        type: "address",
+        indexed: false,
+        internalType: "address"
+      },
+      {
+        name: "wantToken",
+        type: "address",
+        indexed: false,
+        internalType: "address"
+      },
+      {
+        name: "offerAmountSpent",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      },
+      {
+        name: "wantAmountReceived",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      },
+      {
+        name: "timestamp",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "AtomicRequestUpdated",
+    inputs: [
+      {
+        name: "user",
+        type: "address",
+        indexed: false,
+        internalType: "address"
+      },
+      {
+        name: "offerToken",
+        type: "address",
+        indexed: false,
+        internalType: "address"
+      },
+      {
+        name: "wantToken",
+        type: "address",
+        indexed: false,
+        internalType: "address"
+      },
+      {
+        name: "amount",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      },
+      {
+        name: "deadline",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      },
+      {
+        name: "minPrice",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      },
+      {
+        name: "timestamp",
+        type: "uint256",
+        indexed: false,
+        internalType: "uint256"
+      }
+    ],
+    anonymous: false
+  },
+  {
+    type: "error",
+    name: "AtomicQueue__RequestDeadlineExceeded",
+    inputs: [{ name: "user", type: "address", internalType: "address" }]
+  },
+  {
+    type: "error",
+    name: "AtomicQueue__UserNotInSolve",
+    inputs: [{ name: "user", type: "address", internalType: "address" }]
+  },
+  {
+    type: "error",
+    name: "AtomicQueue__UserRepeated",
+    inputs: [{ name: "user", type: "address", internalType: "address" }]
+  },
+  {
+    type: "error",
+    name: "AtomicQueue__ZeroOfferAmount",
+    inputs: [{ name: "user", type: "address", internalType: "address" }]
+  }
+];
+
+// src/vaults/withdraw/withdraw.ts
+var prepareWithdrawTxData = async ({
+  yieldType,
+  wantAssetAddress,
+  chainId,
+  offerAmount,
+  deadline = chunkBDXS57YH_js.DEFAULT_DEADLINE,
+  slippage = chunkITB7FXG4_js.DEFAULT_SLIPPAGE_BPS
+}) => {
+  try {
+    const normalizedChainId = chunkRUIAH5HY_js.toChainId(chainId);
+    const config = await chunkBDXS57YH_js.findVaultByConfig({
+      assetAddress: wantAssetAddress,
+      yieldType,
+      chainId: normalizedChainId
+    });
+    if (config && config.chainId !== normalizedChainId) {
+      throw new chunkBDXS57YH_js.APIError(
+        `Vault chain mismatch: vault is on chain ${config.chainId}, requested chain ${normalizedChainId}`,
+        { endpoint: "prepareWithdrawTransactionData" }
+      );
+    }
+    if (!config || !config.vault.boringVaultAddress) {
+      throw new chunkBDXS57YH_js.APIError(
+        `BoringVault contract address not configured for vault ${config?.id}`,
+        { endpoint: "prepareWithdrawTransactionData" }
+      );
+    }
+    if (!config.vault.accountantAddress) {
+      throw new chunkBDXS57YH_js.APIError(
+        `Accountant contract address not configured for vault ${config.id}`,
+        { endpoint: "prepareWithdrawTransactionData" }
+      );
+    }
+    const boringVaultAddress = config.vault.boringVaultAddress;
+    const accountantAddress = config.vault.accountantAddress;
+    const [
+      wantAssetDecimalsResult,
+      sharesAssetDecimalsResult,
+      rateInQuoteResult
+    ] = await chunkJLXNOGZB_js.getRateInQuoteAndSharesAndWantAssetDecimals({
+      sharesAssetAddress: boringVaultAddress,
+      wantAssetAddress,
+      accountantAddress,
+      chainId: normalizedChainId
+    });
+    if (rateInQuoteResult?.status === "failure" || wantAssetDecimalsResult?.status === "failure" || sharesAssetDecimalsResult?.status === "failure") {
+      throw new chunkBDXS57YH_js.APIError(
+        `Failed to get exchange rate: ${rateInQuoteResult?.error?.message || wantAssetDecimalsResult?.error?.message || sharesAssetDecimalsResult?.error?.message}`,
+        {
+          endpoint: "prepareWithdrawTransactionData",
+          cause: rateInQuoteResult?.error || wantAssetDecimalsResult?.error || sharesAssetDecimalsResult?.error
+        }
+      );
+    }
+    const atomicPrice = calculateAtomicPrice(
+      rateInQuoteResult.result,
+      // rateInQuote bigint
+      wantAssetDecimalsResult.result,
+      // Want asset decimals from API
+      slippage
+    );
+    const formattedOfferAmount = viem.parseUnits(
+      offerAmount,
+      sharesAssetDecimalsResult.result
+    );
+    const userRequest = prepareUserRequest(
+      formattedOfferAmount,
+      atomicPrice,
+      deadline
+    );
+    return {
+      abi: AtomicQueueAbi,
+      address: chunkBDXS57YH_js.ATOMIC_QUEUE_CONTRACT_ADDRESS,
+      functionName: "updateAtomicRequest",
+      args: [boringVaultAddress, wantAssetAddress, userRequest],
+      chainId: normalizedChainId
+    };
+  } catch (error) {
+    if (error instanceof chunkBDXS57YH_js.APIError) {
+      throw error;
+    }
+    throw new chunkBDXS57YH_js.APIError(
+      `Failed to prepare withdrawal transaction: ${error instanceof Error ? error.message : String(error)}`,
+      {
+        endpoint: "prepareWithdrawTransactionData",
+        cause: error
+      }
+    );
+  }
+};
+
+Object.defineProperty(exports, "YieldType", {
+  enumerable: true,
+  get: function () { return chunkITB7FXG4_js.YieldType; }
+});
+Object.defineProperty(exports, "getDepositExchangeRate", {
+  enumerable: true,
+  get: function () { return chunkO5P6SP2O_js.getDepositExchangeRate; }
+});
+Object.defineProperty(exports, "getWithdrawExchangeRate", {
+  enumerable: true,
+  get: function () { return chunkO5P6SP2O_js.getWithdrawExchangeRate; }
+});
+Object.defineProperty(exports, "isDepositSpendApproved", {
+  enumerable: true,
+  get: function () { return chunkO5P6SP2O_js.isDepositSpendApproved; }
+});
+Object.defineProperty(exports, "isWithdrawalSpendApproved", {
+  enumerable: true,
+  get: function () { return chunkO5P6SP2O_js.isWithdrawalSpendApproved; }
+});
+Object.defineProperty(exports, "APIError", {
+  enumerable: true,
+  get: function () { return chunkBDXS57YH_js.APIError; }
+});
+Object.defineProperty(exports, "fetchSupportedAssets", {
+  enumerable: true,
+  get: function () { return chunkBDXS57YH_js.fetchSupportedAssets; }
+});
+Object.defineProperty(exports, "fetchVaults", {
+  enumerable: true,
+  get: function () { return chunkBDXS57YH_js.fetchVaults; }
+});
+Object.defineProperty(exports, "findVaultByConfig", {
+  enumerable: true,
+  get: function () { return chunkBDXS57YH_js.findVaultByConfig; }
+});
+Object.defineProperty(exports, "getAssetsFromCache", {
+  enumerable: true,
+  get: function () { return chunkBDXS57YH_js.getAssetsFromCache; }
+});
+Object.defineProperty(exports, "getCache", {
+  enumerable: true,
+  get: function () { return chunkBDXS57YH_js.getCache; }
+});
+Object.defineProperty(exports, "getWithdrawSupportedAssets", {
+  enumerable: true,
+  get: function () { return chunkBDXS57YH_js.getWithdrawSupportedAssets; }
+});
+Object.defineProperty(exports, "initAmplifySDK", {
+  enumerable: true,
+  get: function () { return chunkBDXS57YH_js.initAmplifySDK; }
+});
+Object.defineProperty(exports, "initializeCache", {
+  enumerable: true,
+  get: function () { return chunkBDXS57YH_js.initializeCache; }
+});
+Object.defineProperty(exports, "refreshVaultCache", {
+  enumerable: true,
+  get: function () { return chunkBDXS57YH_js.refreshVaultCache; }
+});
+exports.PERMIT_TYPES = PERMIT_TYPES;
+exports.parsePermitSignature = parsePermitSignature;
+exports.prepareApproveDepositTokenTxData = prepareApproveDepositTokenTxData;
+exports.prepareApproveWithdrawTxData = prepareApproveWithdrawTxData;
+exports.prepareBulkWithdrawTxData = prepareBulkWithdrawTxData;
+exports.prepareDepositPermitSignature = prepareDepositPermitSignature;
+exports.prepareDepositTxData = prepareDepositTxData;
+exports.prepareDepositWithPermitTransactionData = prepareDepositWithPermitTransactionData;
+exports.prepareWithdrawTxData = prepareWithdrawTxData;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map