@paxoslabs/amplify-sdk 0.5.2 → 0.5.3

package/dist/{chunk-HU5CTL4C.mjs → chunk-LMNADWTH.mjs}

@@ -1,9 +1,111 @@
-import { resolveVault, WithdrawQueueAbi } from './chunk-7JQQ2TH4.mjs';
-import { getTokenPermitInfoWithAllowance, getErc20AllowanceWithDecimals, getRateInQuoteWithAssetDecimals, erc2612Abi, getErc20Decimals, BoringVaultAbi } from './chunk-Q5FXJU5Y.mjs';
+import { resolveVault, InvalidChainIdError, TransactionDataError, WithdrawError } from './chunk-Y5LBT2WT.mjs';
+import { getTokenPermitInfoWithAllowance, getErc20AllowanceWithDecimals, getRateInQuoteWithAssetDecimals, erc2612Abi, getErc20Decimals, BoringVaultAbi, AccountantAbi } from './chunk-UY2WD7MF.mjs';
 import { WAD } from './chunk-6CU533DM.mjs';
-import { toChainId, APIError, getSupportedAssets, DEFAULT_APPROVAL_AMOUNT, DEFAULT_SLIPPAGE_BPS, getLogger, getClient } from './chunk-WK7EJRBB.mjs';
-import { formatUnits, parseUnits, erc20Abi, stringToHex, zeroAddress, hexToSignature } from 'viem';
+import { getLogger, APIError, getRestV2BaseURL, getRequestHeaders, createTimeoutSignal, DEFAULT_TIMEOUT, toChainId, getSupportedAssets, DEFAULT_APPROVAL_AMOUNT, DEFAULT_SLIPPAGE_BPS, DistributorCodeDepositorAbiV0, getClient, WithdrawQueueAbi, readDepositFeeStructure, readSupplyCapInBase } from './chunk-ODXJYXUH.mjs';
+import { formatUnits, parseUnits, erc20Abi, stringToHex, zeroAddress, hexToSignature, maxUint256 } from 'viem';
 
+// src/client/kyt-client.ts
+var CHAIN_ID_TO_PREDICATE_CHAIN = {
+  1: "ethereum",
+  11155111: "sepolia",
+  8453: "base",
+  84532: "base-sepolia",
+  999: "hyperevm",
+  2201: "stable-testnet"
+};
+async function fetchKytAttestation(params) {
+  const { to, from, chainId } = params;
+  const logger = getLogger();
+  const chain = CHAIN_ID_TO_PREDICATE_CHAIN[chainId];
+  if (!chain) {
+    throw new APIError(
+      `KYT attestation not supported for chain ID ${chainId}. Supported chains: ${Object.keys(CHAIN_ID_TO_PREDICATE_CHAIN).join(", ")}`,
+      { endpoint: "kytAttestation" }
+    );
+  }
+  const url = `${getRestV2BaseURL()}/kytAttestation`;
+  const headers = getRequestHeaders();
+  logger.debug("Fetching KYT attestation", { to, from, chain });
+  let response;
+  try {
+    response = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ to, from, chain }),
+      signal: createTimeoutSignal(DEFAULT_TIMEOUT)
+    });
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new APIError("KYT attestation request timed out", {
+        endpoint: "kytAttestation",
+        cause: error
+      });
+    }
+    throw new APIError(
+      `KYT attestation request failed: ${error instanceof Error ? error.message : String(error)}`,
+      { endpoint: "kytAttestation", cause: error }
+    );
+  }
+  if (!response.ok) {
+    let serverMessage;
+    try {
+      const errorBody = await response.json();
+      serverMessage = errorBody?.error?.message;
+    } catch {
+    }
+    if (response.status === 403) {
+      throw new APIError(
+        serverMessage ?? "Deposit blocked: transaction is not compliant with KYT policy",
+        { endpoint: "kytAttestation", statusCode: 403 }
+      );
+    }
+    if (response.status === 400) {
+      throw new APIError(
+        serverMessage ?? "KYT attestation request was rejected: invalid parameters",
+        { endpoint: "kytAttestation", statusCode: 400 }
+      );
+    }
+    throw new APIError(
+      serverMessage ?? `KYT attestation request failed (HTTP ${response.status})`,
+      { endpoint: "kytAttestation", statusCode: response.status }
+    );
+  }
+  let body;
+  try {
+    body = await response.json();
+  } catch (error) {
+    throw new APIError("KYT attestation response contained invalid JSON", {
+      endpoint: "kytAttestation",
+      cause: error
+    });
+  }
+  if (!body.attestation) {
+    throw new APIError("KYT attestation response missing attestation field", {
+      endpoint: "kytAttestation"
+    });
+  }
+  const { attestation } = body;
+  const missingFields = ["uuid", "attester", "signature", "expiration"].filter((f) => attestation[f] == null);
+  if (missingFields.length > 0) {
+    throw new APIError(
+      `KYT attestation response missing required fields: ${missingFields.join(", ")}`,
+      { endpoint: "kytAttestation" }
+    );
+  }
+  if (typeof attestation.expiration !== "number" && typeof attestation.expiration !== "string") {
+    throw new APIError(
+      "KYT attestation response has invalid expiration value",
+      { endpoint: "kytAttestation" }
+    );
+  }
+  const sig = attestation.signature.startsWith("0x") ? attestation.signature : `0x${attestation.signature}`;
+  return {
+    uuid: attestation.uuid,
+    expiration: BigInt(attestation.expiration),
+    attester: attestation.attester,
+    signature: sig
+  };
+}
 var isDepositSpendApproved = async ({
   vaultName,
   chainId,
@@ -189,235 +291,6 @@ async function prepareApproveDepositTokenTxData({
   }
 }
 
-// src/abi/distributor-code-depositor-abi-v0.ts
-var DistributorCodeDepositorAbiV0 = [
-  {
-    inputs: [
-      {
-        internalType: "contract TellerWithMultiAssetSupport",
-        name: "_teller",
-        type: "address"
-      },
-      {
-        internalType: "contract INativeWrapper",
-        name: "_nativeWrapper",
-        type: "address"
-      },
-      {
-        internalType: "contract Authority",
-        name: "_rolesAuthority",
-        type: "address"
-      },
-      { internalType: "bool", name: "_isNativeDepositSupported", type: "bool" },
-      { internalType: "address", name: "_owner", type: "address" }
-    ],
-    stateMutability: "nonpayable",
-    type: "constructor"
-  },
-  { inputs: [], name: "IncorrectNativeDepositAmount", type: "error" },
-  { inputs: [], name: "NativeDepositNotSupported", type: "error" },
-  {
-    inputs: [],
-    name: "NativeWrapperAccountantDecimalsMismatch",
-    type: "error"
-  },
-  { inputs: [], name: "PermitFailedAndAllowanceTooLow", type: "error" },
-  { inputs: [], name: "ZeroAddress", type: "error" },
-  {
-    anonymous: false,
-    inputs: [
-      { indexed: true, internalType: "address", name: "user", type: "address" },
-      {
-        indexed: true,
-        internalType: "contract Authority",
-        name: "newAuthority",
-        type: "address"
-      }
-    ],
-    name: "AuthorityUpdated",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: true,
-        internalType: "address",
-        name: "depositor",
-        type: "address"
-      },
-      {
-        indexed: true,
-        internalType: "contract ERC20",
-        name: "depositAsset",
-        type: "address"
-      },
-      {
-        indexed: false,
-        internalType: "uint256",
-        name: "depositAmount",
-        type: "uint256"
-      },
-      {
-        indexed: false,
-        internalType: "uint256",
-        name: "minimumMint",
-        type: "uint256"
-      },
-      { indexed: false, internalType: "address", name: "to", type: "address" },
-      {
-        indexed: false,
-        internalType: "bytes32",
-        name: "depositHash",
-        type: "bytes32"
-      },
-      {
-        indexed: true,
-        internalType: "bytes",
-        name: "distributorCode",
-        type: "bytes"
-      }
-    ],
-    name: "DepositWithDistributorCode",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      { indexed: true, internalType: "address", name: "user", type: "address" },
-      {
-        indexed: true,
-        internalType: "address",
-        name: "newOwner",
-        type: "address"
-      }
-    ],
-    name: "OwnershipTransferred",
-    type: "event"
-  },
-  {
-    inputs: [],
-    name: "authority",
-    outputs: [
-      { internalType: "contract Authority", name: "", type: "address" }
-    ],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "boringVault",
-    outputs: [{ internalType: "address", name: "", type: "address" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      { internalType: "contract ERC20", name: "depositAsset", type: "address" },
-      { internalType: "uint256", name: "depositAmount", type: "uint256" },
-      { internalType: "uint256", name: "minimumMint", type: "uint256" },
-      { internalType: "address", name: "to", type: "address" },
-      { internalType: "bytes", name: "distributorCode", type: "bytes" }
-    ],
-    name: "deposit",
-    outputs: [{ internalType: "uint256", name: "shares", type: "uint256" }],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [
-      { internalType: "uint256", name: "depositAmount", type: "uint256" },
-      { internalType: "uint256", name: "minimumMint", type: "uint256" },
-      { internalType: "address", name: "to", type: "address" },
-      { internalType: "bytes", name: "distributorCode", type: "bytes" }
-    ],
-    name: "depositNative",
-    outputs: [{ internalType: "uint256", name: "shares", type: "uint256" }],
-    stateMutability: "payable",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "depositNonce",
-    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      { internalType: "contract ERC20", name: "depositAsset", type: "address" },
-      { internalType: "uint256", name: "depositAmount", type: "uint256" },
-      { internalType: "uint256", name: "minimumMint", type: "uint256" },
-      { internalType: "address", name: "to", type: "address" },
-      { internalType: "bytes", name: "distributorCode", type: "bytes" },
-      { internalType: "uint256", name: "deadline", type: "uint256" },
-      { internalType: "uint8", name: "v", type: "uint8" },
-      { internalType: "bytes32", name: "r", type: "bytes32" },
-      { internalType: "bytes32", name: "s", type: "bytes32" }
-    ],
-    name: "depositWithPermit",
-    outputs: [{ internalType: "uint256", name: "shares", type: "uint256" }],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "isNativeDepositSupported",
-    outputs: [{ internalType: "bool", name: "", type: "bool" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "nativeWrapper",
-    outputs: [
-      { internalType: "contract INativeWrapper", name: "", type: "address" }
-    ],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "owner",
-    outputs: [{ internalType: "address", name: "", type: "address" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      {
-        internalType: "contract Authority",
-        name: "newAuthority",
-        type: "address"
-      }
-    ],
-    name: "setAuthority",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "teller",
-    outputs: [
-      {
-        internalType: "contract TellerWithMultiAssetSupport",
-        name: "",
-        type: "address"
-      }
-    ],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "address", name: "newOwner", type: "address" }],
-    name: "transferOwnership",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  }
-];
-
 // src/abi/distributor-code-depositor-abi-v1.ts
 var DistributorCodeDepositorAbiV1 = [
   {
@@ -910,8 +783,6 @@ var DistributorCodeDepositorAbiV1 = [
     type: "function"
   }
 ];
-
-// src/vaults/deposit/utils.ts
 var calculateMinimumMint = (depositAmount, rate, vaultTokenDecimals, slippage) => {
   const slippageValue = slippage ?? DEFAULT_SLIPPAGE_BPS;
   const slippageAsBigInt = BigInt(slippageValue) * WAD.bigint / BigInt(1e4);
@@ -922,6 +793,75 @@ var calculateMinimumMint = (depositAmount, rate, vaultTokenDecimals, slippage) =
   }
   return (minimumMint - slippageAmount) / BigInt(10) ** (BigInt(18) - BigInt(vaultTokenDecimals));
 };
+async function getDepositFeeForAmount(depositFeeModuleAddress, depositAsset, depositAmount, chainId) {
+  if (!depositFeeModuleAddress || depositFeeModuleAddress === zeroAddress) {
+    return 0n;
+  }
+  const { feePercentage, flatFee, oneHundredPercent } = await readDepositFeeStructure(
+    depositFeeModuleAddress,
+    depositAsset,
+    chainId
+  );
+  const variableFee = oneHundredPercent > 0n ? depositAmount * feePercentage / oneHundredPercent : 0n;
+  return variableFee + flatFee;
+}
+async function assertDepositWithinCap(vault, depositAmountRaw, depositAssetAddress, chainId, callerEndpoint) {
+  let supplyCapInBase = null;
+  let hasDepositCap = false;
+  if (vault.depositCap) {
+    supplyCapInBase = vault.depositCap.supplyCapInBase;
+    hasDepositCap = vault.depositCap.hasDepositCap;
+  } else if (vault.vault.communityCodeDepositorAddress && vault.vault.depositFeeModuleAddress) {
+    const onChainCap = await readSupplyCapInBase(
+      vault.vault.communityCodeDepositorAddress,
+      chainId
+    );
+    supplyCapInBase = onChainCap;
+    hasDepositCap = onChainCap !== 0n && onChainCap !== maxUint256;
+  }
+  if (!hasDepositCap || supplyCapInBase == null) return;
+  const client = await getClient(chainId);
+  const [supplyResult, baseRateResult, quoteRateResult, decResult] = await client.multicall({
+    contracts: [
+      {
+        abi: BoringVaultAbi,
+        address: vault.vault.boringVaultAddress,
+        functionName: "totalSupply"
+      },
+      {
+        abi: AccountantAbi,
+        address: vault.vault.accountantAddress,
+        functionName: "getRate"
+      },
+      {
+        abi: AccountantAbi,
+        address: vault.vault.accountantAddress,
+        functionName: "getRateInQuote",
+        args: [depositAssetAddress]
+      },
+      {
+        abi: AccountantAbi,
+        address: vault.vault.accountantAddress,
+        functionName: "decimals"
+      }
+    ]
+  });
+  if (supplyResult.status !== "success" || baseRateResult.status !== "success" || quoteRateResult.status !== "success" || decResult.status !== "success") {
+    throw new APIError(
+      "Unable to verify deposit against supply cap: on-chain read failed",
+      { endpoint: callerEndpoint }
+    );
+  }
+  const currentValueInBase = supplyResult.result * baseRateResult.result / 10n ** BigInt(decResult.result);
+  const depositAmountInBase = quoteRateResult.result > 0n ? depositAmountRaw * baseRateResult.result / quoteRateResult.result : depositAmountRaw;
+  const remaining = supplyCapInBase > currentValueInBase ? supplyCapInBase - currentValueInBase : 0n;
+  if (depositAmountInBase > remaining) {
+    throw new APIError(
+      `Deposit would exceed vault supply cap. Remaining capacity: ${remaining}, deposit amount (in base): ${depositAmountInBase}`,
+      { endpoint: callerEndpoint }
+    );
+  }
+}
 
 // src/vaults/deposit/deposit.ts
 var DepositType = {
@@ -1009,15 +949,52 @@ async function prepareDepositTxData(params) {
       depositAmount,
       depositAssetDecimalsResult.result
     );
-    const minimumMint = calculateMinimumMint(
+    const totalFee = await getDepositFeeForAmount(
+      vault.vault.depositFeeModuleAddress,
+      depositAssetAddress,
       depositAmountAsBigInt,
+      normalizedChainId
+    );
+    if (totalFee >= depositAmountAsBigInt) {
+      throw new APIError(
+        "Deposit amount is entirely consumed by fees. Increase the deposit amount.",
+        { endpoint: "prepareDepositTransactionData" }
+      );
+    }
+    const depositAmountAfterFees = depositAmountAsBigInt - totalFee;
+    await assertDepositWithinCap(
+      vault,
+      depositAmountAfterFees,
+      depositAssetAddress,
+      normalizedChainId,
+      "prepareDepositTransactionData"
+    );
+    const minimumMint = calculateMinimumMint(
+      depositAmountAfterFees,
       rateInQuoteResult.result,
       depositAssetDecimalsResult.result,
       slippage
     );
     const distributorCodeHex = stringToHex(distributorCode || "");
-    if (vault.enterpriseConfig?.predicatePolicyId != null) {
-      const attestation = {
+    const policyId = vault.enterpriseConfig?.predicatePolicyId;
+    if (policyId === void 0) {
+      return {
+        depositType: DepositType.STANDARD,
+        abi: DistributorCodeDepositorAbiV0,
+        address: communityCodeDepositorAddress,
+        functionName: "deposit",
+        args: [
+          depositAssetAddress,
+          depositAmountAsBigInt,
+          minimumMint,
+          to,
+          distributorCodeHex
+        ],
+        chainId: normalizedChainId
+      };
+    }
+    if (policyId === null) {
+      const emptyAttestation = {
         uuid: "",
         expiration: 0n,
         attester: zeroAddress,
@@ -1034,22 +1011,28 @@ async function prepareDepositTxData(params) {
           minimumMint,
           to,
           distributorCodeHex,
-          attestation
+          emptyAttestation
         ],
         chainId: normalizedChainId
       };
     }
+    const attestation = await fetchKytAttestation({
+      to: communityCodeDepositorAddress,
+      from: to,
+      chainId: normalizedChainId
+    });
     return {
-      depositType: DepositType.STANDARD,
-      abi: DistributorCodeDepositorAbiV0,
+      depositType: DepositType.KYT,
       address: communityCodeDepositorAddress,
+      abi: DistributorCodeDepositorAbiV1,
       functionName: "deposit",
       args: [
         depositAssetAddress,
         depositAmountAsBigInt,
         minimumMint,
         to,
-        distributorCodeHex
+        distributorCodeHex,
+        attestation
       ],
       chainId: normalizedChainId
     };
@@ -1369,15 +1352,56 @@ async function prepareDepositWithPermitTxData(params) {
     }
     const onChainDecimals = depositAssetDecimalsResult.result;
     const depositAmountAsBigInt = parseUnits(depositAmount, onChainDecimals);
-    const minimumMint = calculateMinimumMint(
+    const totalFee = await getDepositFeeForAmount(
+      vault.vault.depositFeeModuleAddress,
+      depositAssetAddress,
       depositAmountAsBigInt,
+      normalizedChainId
+    );
+    if (totalFee >= depositAmountAsBigInt) {
+      throw new APIError(
+        "Deposit amount is entirely consumed by fees. Increase the deposit amount.",
+        { endpoint: "prepareDepositWithPermitTxData" }
+      );
+    }
+    const depositAmountAfterFees = depositAmountAsBigInt - totalFee;
+    await assertDepositWithinCap(
+      vault,
+      depositAmountAfterFees,
+      depositAssetAddress,
+      normalizedChainId,
+      "prepareDepositWithPermitTxData"
+    );
+    const minimumMint = calculateMinimumMint(
+      depositAmountAfterFees,
       rateInQuoteResult.result,
       onChainDecimals,
       slippage
     );
     const distributorCodeHex = stringToHex(distributorCode || "");
-    if (vault.enterpriseConfig?.predicatePolicyId != null) {
-      const attestation = {
+    const policyId = vault.enterpriseConfig?.predicatePolicyId;
+    if (policyId === void 0) {
+      return {
+        depositType: DepositType.STANDARD,
+        abi: DistributorCodeDepositorAbiV0,
+        address: communityCodeDepositorAddress,
+        functionName: "depositWithPermit",
+        args: [
+          depositAssetAddress,
+          depositAmountAsBigInt,
+          minimumMint,
+          to,
+          distributorCodeHex,
+          deadline,
+          v,
+          r,
+          s
+        ],
+        chainId: normalizedChainId
+      };
+    }
+    if (policyId === null) {
+      const emptyAttestation = {
         uuid: "",
         expiration: 0n,
         attester: zeroAddress,
@@ -1394,7 +1418,7 @@ async function prepareDepositWithPermitTxData(params) {
           minimumMint,
           to,
           distributorCodeHex,
-          attestation,
+          emptyAttestation,
           deadline,
           v,
           r,
@@ -1403,9 +1427,14 @@ async function prepareDepositWithPermitTxData(params) {
         chainId: normalizedChainId
       };
     }
+    const attestation = await fetchKytAttestation({
+      to: communityCodeDepositorAddress,
+      from: to,
+      chainId: normalizedChainId
+    });
     return {
-      depositType: DepositType.STANDARD,
-      abi: DistributorCodeDepositorAbiV0,
+      depositType: DepositType.KYT,
+      abi: DistributorCodeDepositorAbiV1,
       address: communityCodeDepositorAddress,
       functionName: "depositWithPermit",
       args: [
@@ -1414,6 +1443,7 @@ async function prepareDepositWithPermitTxData(params) {
         minimumMint,
         to,
         distributorCodeHex,
+        attestation,
         deadline,
         v,
         r,
@@ -1830,6 +1860,79 @@ var prepareWithdrawOrderTxData = async ({
     );
   }
 };
+var prepareAtomicWithdrawOrderTxData = async ({
+  vaultName,
+  wantAsset,
+  userAddress,
+  chainId,
+  amountOffer
+}) => {
+  try {
+    const normalizedChainId = toChainId(chainId);
+    const config = await resolveVault({
+      vaultName,
+      assetAddress: wantAsset,
+      chainId: normalizedChainId,
+      callerEndpoint: "prepareAtomicWithdrawOrderTxData"
+    });
+    if (config.chainId !== normalizedChainId) {
+      throw new InvalidChainIdError(
+        `Vault chain mismatch: vault is on chain ${config.chainId}, requested chain ${normalizedChainId}`,
+        {
+          vaultId: config.id,
+          vaultChainId: config.chainId,
+          requestedChainId: normalizedChainId
+        }
+      );
+    }
+    if (!config.vault.withdrawQueueAddress) {
+      throw new TransactionDataError(
+        `WithdrawQueue contract address not configured for vault ${config.id}`,
+        { vaultId: config.id, field: "withdrawQueueAddress" }
+      );
+    }
+    if (!config.vault.boringVaultAddress) {
+      throw new TransactionDataError(
+        `BoringVault contract address not configured for vault ${config.id}`,
+        { vaultId: config.id, field: "boringVaultAddress" }
+      );
+    }
+    const sharesDecimals = await getErc20Decimals({
+      tokenAddress: config.vault.boringVaultAddress,
+      chainId: normalizedChainId
+    });
+    const formattedAmountOffer = parseUnits(amountOffer, sharesDecimals);
+    return {
+      abi: WithdrawQueueAbi,
+      address: config.vault.withdrawQueueAddress,
+      functionName: "submitOrderAndProcessAll",
+      args: [
+        {
+          amountOffer: formattedAmountOffer,
+          wantAsset,
+          intendedDepositor: userAddress,
+          receiver: userAddress,
+          refundReceiver: userAddress,
+          signatureParams: EMPTY_SIGNATURE_PARAMS
+        }
+      ],
+      chainId: normalizedChainId
+    };
+  } catch (error) {
+    if (error instanceof WithdrawError) {
+      throw error;
+    }
+    throw new TransactionDataError(
+      `Failed to prepare atomic withdraw order transaction: ${error instanceof Error ? error.message : String(error)}`,
+      {
+        endpoint: "prepareAtomicWithdrawOrderTxData",
+        cause: error
+      }
+    );
+  }
+};
+
+// src/vaults/withdraw/index.ts
 var WithdrawAuthMethod = {
   APPROVAL: "approval",
   ALREADY_APPROVED: "already_approved"
@@ -1843,13 +1946,21 @@ function isWithdrawAlreadyApprovedAuth(result) {
 async function prepareWithdrawal(params) {
   const { vaultName, wantAsset, withdrawAmount, userAddress, chainId } = params;
   try {
-    return await prepareWithdrawOrderTxData({
+    const normalizedChainId = toChainId(chainId);
+    const vault = await resolveVault({
+      vaultName,
+      assetAddress: wantAsset,
+      chainId: normalizedChainId,
+      callerEndpoint: "prepareWithdrawal"
+    });
+    const builderParams = {
       vaultName,
       wantAsset,
       userAddress,
       chainId,
       amountOffer: withdrawAmount
-    });
+    };
+    return vault.atomicWithdrawal ? await prepareAtomicWithdrawOrderTxData(builderParams) : await prepareWithdrawOrderTxData(builderParams);
   } catch (error) {
     if (error instanceof APIError) {
       throw error;
@@ -1957,6 +2068,6 @@ async function prepareWithdrawalAuthorization(params) {
   }
 }
 
-export { DepositAuthMethod, DepositType, PERMIT_TYPES, WithdrawAuthMethod, isAlreadyApprovedAuth, isApprovalAuth, isDepositSpendApproved, isKytDeposit, isPermitAuth, isStandardDeposit, isWithdrawAlreadyApprovedAuth, isWithdrawApprovalAuth, isWithdrawalSpendApproved, parsePermitSignature, prepareApproveDepositTokenTxData, prepareApproveWithdrawOrderTxData, prepareCancelWithdrawOrderTxData, prepareDeposit, prepareDepositAuthorization, prepareDepositPermitSignature, prepareDepositTxData, prepareDepositWithPermitTxData, prepareWithdrawOrderTxData, prepareWithdrawal, prepareWithdrawalAuthorization, toEthSignTypedDataV4 };
-//# sourceMappingURL=chunk-HU5CTL4C.mjs.map
-//# sourceMappingURL=chunk-HU5CTL4C.mjs.map
+export { DepositAuthMethod, DepositType, PERMIT_TYPES, WithdrawAuthMethod, fetchKytAttestation, isAlreadyApprovedAuth, isApprovalAuth, isDepositSpendApproved, isKytDeposit, isPermitAuth, isStandardDeposit, isWithdrawAlreadyApprovedAuth, isWithdrawApprovalAuth, isWithdrawalSpendApproved, parsePermitSignature, prepareApproveDepositTokenTxData, prepareApproveWithdrawOrderTxData, prepareCancelWithdrawOrderTxData, prepareDeposit, prepareDepositAuthorization, prepareDepositPermitSignature, prepareDepositTxData, prepareDepositWithPermitTxData, prepareWithdrawOrderTxData, prepareWithdrawal, prepareWithdrawalAuthorization, toEthSignTypedDataV4 };
+//# sourceMappingURL=chunk-LMNADWTH.mjs.map
+//# sourceMappingURL=chunk-LMNADWTH.mjs.map