@paxoslabs/amplify-sdk 0.5.1 → 0.5.3

package/dist/{chunk-3D6EDR3Z.mjs → chunk-LMNADWTH.mjs}

@@ -1,9 +1,111 @@
-import { resolveVault, WithdrawQueueAbi } from './chunk-Y6RXVDQN.mjs';
-import { getTokenPermitInfoWithAllowance, getErc20AllowanceWithDecimals, getRateInQuoteWithAssetDecimals, erc2612Abi, getErc20Decimals, BoringVaultAbi } from './chunk-E6SBQNDA.mjs';
-import { WAD } from './chunk-7RWWVUHP.mjs';
-import { toChainId, APIError, getSupportedAssets, DEFAULT_APPROVAL_AMOUNT, DEFAULT_SLIPPAGE_BPS, getClient } from './chunk-JLZL25CY.mjs';
-import { formatUnits, parseUnits, erc20Abi, stringToHex, hexToSignature } from 'viem';
+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 { 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,8 +291,8 @@ async function prepareApproveDepositTokenTxData({
   }
 }
 
-// src/abi/community-code-depositor-abi.ts
-var CommunityCodeDepositorAbi = [
+// src/abi/distributor-code-depositor-abi-v1.ts
+var DistributorCodeDepositorAbiV1 = [
   {
     inputs: [
       {
@@ -209,19 +311,53 @@ var CommunityCodeDepositorAbi = [
         type: "address"
       },
       { internalType: "bool", name: "_isNativeDepositSupported", type: "bool" },
+      { internalType: "uint256", name: "_supplyCap", type: "uint256" },
+      {
+        internalType: "contract IFeeModule",
+        name: "_feeModule",
+        type: "address"
+      },
+      { internalType: "address", name: "_feeRecipient", type: "address" },
+      { internalType: "address", name: "_registry", type: "address" },
+      { internalType: "string", name: "_policyID", type: "string" },
       { internalType: "address", name: "_owner", type: "address" }
     ],
     stateMutability: "nonpayable",
     type: "constructor"
   },
+  { inputs: [], name: "FeesExceedOrEqualAmount", type: "error" },
   { inputs: [], name: "IncorrectNativeDepositAmount", type: "error" },
+  {
+    inputs: [
+      { internalType: "uint256", name: "actual", type: "uint256" },
+      { internalType: "uint256", name: "minimum", type: "uint256" }
+    ],
+    name: "InsufficientSharesAfterFees",
+    type: "error"
+  },
   { inputs: [], name: "NativeDepositNotSupported", type: "error" },
   {
     inputs: [],
     name: "NativeWrapperAccountantDecimalsMismatch",
     type: "error"
   },
+  {
+    inputs: [
+      { internalType: "address", name: "addressEmptyCode", type: "address" }
+    ],
+    name: "NoCode",
+    type: "error"
+  },
   { inputs: [], name: "PermitFailedAndAllowanceTooLow", type: "error" },
+  {
+    inputs: [
+      { internalType: "uint256", name: "resultingValue", type: "uint256" },
+      { internalType: "uint256", name: "supplyCapInBase", type: "uint256" }
+    ],
+    name: "SupplyCapInBaseError",
+    type: "error"
+  },
+  { inputs: [], name: "UnauthorizedTransaction", type: "error" },
   { inputs: [], name: "ZeroAddress", type: "error" },
   {
     anonymous: false,
@@ -281,6 +417,46 @@ var CommunityCodeDepositorAbi = [
     name: "DepositWithDistributorCode",
     type: "event"
   },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "contract IFeeModule",
+        name: "newFeeModule",
+        type: "address"
+      }
+    ],
+    name: "FeeModuleUpdated",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "newFeeRecipient",
+        type: "address"
+      }
+    ],
+    name: "FeeRecipientUpdated",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "contract ERC20",
+        name: "depositAsset",
+        type: "address"
+      },
+      { indexed: true, internalType: "bool", name: "enabled", type: "bool" }
+    ],
+    name: "KytStatusUpdated",
+    type: "event"
+  },
   {
     anonymous: false,
     inputs: [
@@ -295,6 +471,64 @@ var CommunityCodeDepositorAbi = [
     name: "OwnershipTransferred",
     type: "event"
   },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "string",
+        name: "oldPolicyID",
+        type: "string"
+      },
+      {
+        indexed: false,
+        internalType: "string",
+        name: "newPolicyID",
+        type: "string"
+      }
+    ],
+    name: "PredicatePolicyIDUpdated",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "oldRegistry",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "newRegistry",
+        type: "address"
+      }
+    ],
+    name: "PredicateRegistryUpdated",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "newSupplyCapInBase",
+        type: "uint256"
+      }
+    ],
+    name: "SupplyCapInBaseUpdated",
+    type: "event"
+  },
+  {
+    inputs: [],
+    name: "PREDICATE_DEPOSIT_SIGNATURE",
+    outputs: [{ internalType: "string", name: "", type: "string" }],
+    stateMutability: "view",
+    type: "function"
+  },
   {
     inputs: [],
     name: "authority",
@@ -317,7 +551,18 @@ var CommunityCodeDepositorAbi = [
       { 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: "bytes", name: "distributorCode", type: "bytes" },
+      {
+        components: [
+          { internalType: "string", name: "uuid", type: "string" },
+          { internalType: "uint256", name: "expiration", type: "uint256" },
+          { internalType: "address", name: "attester", type: "address" },
+          { internalType: "bytes", name: "signature", type: "bytes" }
+        ],
+        internalType: "struct Attestation",
+        name: "_attestation",
+        type: "tuple"
+      }
     ],
     name: "deposit",
     outputs: [{ internalType: "uint256", name: "shares", type: "uint256" }],
@@ -329,7 +574,18 @@ var CommunityCodeDepositorAbi = [
       { 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: "bytes", name: "distributorCode", type: "bytes" },
+      {
+        components: [
+          { internalType: "string", name: "uuid", type: "string" },
+          { internalType: "uint256", name: "expiration", type: "uint256" },
+          { internalType: "address", name: "attester", type: "address" },
+          { internalType: "bytes", name: "signature", type: "bytes" }
+        ],
+        internalType: "struct Attestation",
+        name: "_attestation",
+        type: "tuple"
+      }
     ],
     name: "depositNative",
     outputs: [{ internalType: "uint256", name: "shares", type: "uint256" }],
@@ -350,6 +606,17 @@ var CommunityCodeDepositorAbi = [
       { internalType: "uint256", name: "minimumMint", type: "uint256" },
       { internalType: "address", name: "to", type: "address" },
       { internalType: "bytes", name: "distributorCode", type: "bytes" },
+      {
+        components: [
+          { internalType: "string", name: "uuid", type: "string" },
+          { internalType: "uint256", name: "expiration", type: "uint256" },
+          { internalType: "address", name: "attester", type: "address" },
+          { internalType: "bytes", name: "signature", type: "bytes" }
+        ],
+        internalType: "struct Attestation",
+        name: "_attestation",
+        type: "tuple"
+      },
       { internalType: "uint256", name: "deadline", type: "uint256" },
       { internalType: "uint8", name: "v", type: "uint8" },
       { internalType: "bytes32", name: "r", type: "bytes32" },
@@ -360,6 +627,36 @@ var CommunityCodeDepositorAbi = [
     stateMutability: "nonpayable",
     type: "function"
   },
+  {
+    inputs: [],
+    name: "feeModule",
+    outputs: [
+      { internalType: "contract IFeeModule", name: "", type: "address" }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "feeRecipient",
+    outputs: [{ internalType: "address", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "getPolicyID",
+    outputs: [{ internalType: "string", name: "policyID", type: "string" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "getRegistry",
+    outputs: [{ internalType: "address", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
   {
     inputs: [],
     name: "isNativeDepositSupported",
@@ -367,6 +664,13 @@ var CommunityCodeDepositorAbi = [
     stateMutability: "view",
     type: "function"
   },
+  {
+    inputs: [{ internalType: "contract ERC20", name: "", type: "address" }],
+    name: "kytEnabled",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function"
+  },
   {
     inputs: [],
     name: "nativeWrapper",
@@ -396,6 +700,27 @@ var CommunityCodeDepositorAbi = [
     stateMutability: "nonpayable",
     type: "function"
   },
+  {
+    inputs: [{ internalType: "string", name: "_policyID", type: "string" }],
+    name: "setPolicyID",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "address", name: "_registry", type: "address" }],
+    name: "setRegistry",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "supplyCapInBase",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
   {
     inputs: [],
     name: "teller",
@@ -415,10 +740,49 @@ var CommunityCodeDepositorAbi = [
     outputs: [],
     stateMutability: "nonpayable",
     type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "contract IFeeModule",
+        name: "newFeeModule",
+        type: "address"
+      }
+    ],
+    name: "updateFeeModule",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "newFeeRecipient", type: "address" }
+    ],
+    name: "updateFeeRecipient",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "contract ERC20", name: "depositAsset", type: "address" },
+      { internalType: "bool", name: "enabled", type: "bool" }
+    ],
+    name: "updateKytStatus",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "uint256", name: "newSupplyCapInBase", type: "uint256" }
+    ],
+    name: "updateSupplyCapInBase",
+    outputs: [],
+    stateMutability: "nonpayable",
+    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);
@@ -429,8 +793,87 @@ 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 = {
+  STANDARD: "standard",
+  KYT: "kyt"
+};
+function isKytDeposit(data) {
+  return data.depositType === DepositType.KYT;
+}
+function isStandardDeposit(data) {
+  return data.depositType === DepositType.STANDARD;
+}
 async function prepareDepositTxData(params) {
   const {
     vaultName,
@@ -449,6 +892,11 @@ async function prepareDepositTxData(params) {
       chainId: normalizedChainId,
       callerEndpoint: "prepareDepositTransactionData"
     });
+    if (vault.inDeprecation) {
+      getLogger().warn(
+        `Vault "${vault.name}" is being deprecated. Please contact the Paxos Labs team for migration guidance.`
+      );
+    }
     const assets = await getSupportedAssets({ address: depositAsset });
     const asset = assets.find((a) => a.chains.includes(normalizedChainId)) || assets.find((a) => a.address.toLowerCase() === depositAsset.toLowerCase());
     if (!asset) {
@@ -501,28 +949,90 @@ async function prepareDepositTxData(params) {
       depositAmount,
       depositAssetDecimalsResult.result
     );
-    const minimumMint = calculateMinimumMint(
+    const totalFee = await getDepositFeeForAmount(
+      vault.vault.depositFeeModuleAddress,
+      depositAssetAddress,
       depositAmountAsBigInt,
-      rateInQuoteResult.result,
-      depositAssetDecimalsResult.result,
-      slippage
+      normalizedChainId
     );
-    if (!communityCodeDepositorAddress) {
+    if (totalFee >= depositAmountAsBigInt) {
       throw new APIError(
-        `CommunityCodeDepositor contract address not found for vault ${vault.id}`,
+        "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 || "");
+    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,
+        signature: "0x"
+      };
+      return {
+        depositType: DepositType.KYT,
+        address: communityCodeDepositorAddress,
+        abi: DistributorCodeDepositorAbiV1,
+        functionName: "deposit",
+        args: [
+          depositAssetAddress,
+          depositAmountAsBigInt,
+          minimumMint,
+          to,
+          distributorCodeHex,
+          emptyAttestation
+        ],
+        chainId: normalizedChainId
+      };
+    }
+    const attestation = await fetchKytAttestation({
+      to: communityCodeDepositorAddress,
+      from: to,
+      chainId: normalizedChainId
+    });
     return {
-      abi: CommunityCodeDepositorAbi,
+      depositType: DepositType.KYT,
       address: communityCodeDepositorAddress,
+      abi: DistributorCodeDepositorAbiV1,
       functionName: "deposit",
       args: [
         depositAssetAddress,
         depositAmountAsBigInt,
         minimumMint,
         to,
-        stringToHex(distributorCode || "")
+        distributorCodeHex,
+        attestation
       ],
       chainId: normalizedChainId
     };
@@ -775,6 +1285,11 @@ async function prepareDepositWithPermitTxData(params) {
       chainId: normalizedChainId,
       callerEndpoint: "prepareDepositWithPermitTxData"
     });
+    if (vault.inDeprecation) {
+      getLogger().warn(
+        `Vault "${vault.name}" is being deprecated. Please contact the Paxos Labs team for migration guidance.`
+      );
+    }
     let asset = null;
     const assets = await getSupportedAssets({ address: depositAsset });
     if (assets.length > 0) {
@@ -836,33 +1351,104 @@ async function prepareDepositWithPermitTxData(params) {
       );
     }
     const onChainDecimals = depositAssetDecimalsResult.result;
-    const depositAmountAsBigInt = parseUnits(
-      depositAmount,
-      onChainDecimals
+    const depositAmountAsBigInt = parseUnits(depositAmount, onChainDecimals);
+    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(
-      depositAmountAsBigInt,
+      depositAmountAfterFees,
       rateInQuoteResult.result,
       onChainDecimals,
       slippage
     );
-    return {
-      data: {
-        abi: CommunityCodeDepositorAbi,
+    const distributorCodeHex = stringToHex(distributorCode || "");
+    const policyId = vault.enterpriseConfig?.predicatePolicyId;
+    if (policyId === void 0) {
+      return {
+        depositType: DepositType.STANDARD,
+        abi: DistributorCodeDepositorAbiV0,
+        address: communityCodeDepositorAddress,
         functionName: "depositWithPermit",
         args: [
           depositAssetAddress,
           depositAmountAsBigInt,
           minimumMint,
           to,
-          stringToHex(distributorCode || ""),
+          distributorCodeHex,
           deadline,
           v,
           r,
           s
-        ]
-      },
+        ],
+        chainId: normalizedChainId
+      };
+    }
+    if (policyId === null) {
+      const emptyAttestation = {
+        uuid: "",
+        expiration: 0n,
+        attester: zeroAddress,
+        signature: "0x"
+      };
+      return {
+        depositType: DepositType.KYT,
+        abi: DistributorCodeDepositorAbiV1,
+        address: communityCodeDepositorAddress,
+        functionName: "depositWithPermit",
+        args: [
+          depositAssetAddress,
+          depositAmountAsBigInt,
+          minimumMint,
+          to,
+          distributorCodeHex,
+          emptyAttestation,
+          deadline,
+          v,
+          r,
+          s
+        ],
+        chainId: normalizedChainId
+      };
+    }
+    const attestation = await fetchKytAttestation({
+      to: communityCodeDepositorAddress,
+      from: to,
+      chainId: normalizedChainId
+    });
+    return {
+      depositType: DepositType.KYT,
+      abi: DistributorCodeDepositorAbiV1,
       address: communityCodeDepositorAddress,
+      functionName: "depositWithPermit",
+      args: [
+        depositAssetAddress,
+        depositAmountAsBigInt,
+        minimumMint,
+        to,
+        distributorCodeHex,
+        attestation,
+        deadline,
+        v,
+        r,
+        s
+      ],
       chainId: normalizedChainId
     };
   } catch (error) {
@@ -955,10 +1541,7 @@ async function prepareDepositAuthorization(params) {
         permitData
       };
     }
-    const smartWallet = await isSmartContractWallet(
-      to,
-      normalizedChainId
-    );
+    const smartWallet = await isSmartContractWallet(to, normalizedChainId);
     if (smartWallet) {
       const txData2 = await prepareApproveDepositTokenTxData({
         vaultName,
@@ -1277,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"
@@ -1290,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;
@@ -1371,9 +2035,7 @@ async function prepareWithdrawalAuthorization(params) {
     }
     const decimals = typeof approvalInfo.decimals === "string" ? Number(approvalInfo.decimals) : approvalInfo.decimals;
     const withdrawAmountBigInt = parseUnits(withdrawAmount, decimals);
-    const currentAllowanceBigInt = BigInt(
-      approvalInfo.allowanceAsBigInt
-    );
+    const currentAllowanceBigInt = BigInt(approvalInfo.allowanceAsBigInt);
     if (approvalInfo.isApproved && currentAllowanceBigInt >= withdrawAmountBigInt) {
       return {
         method: WithdrawAuthMethod.ALREADY_APPROVED,
@@ -1406,6 +2068,6 @@ async function prepareWithdrawalAuthorization(params) {
   }
 }
 
-export { DepositAuthMethod, PERMIT_TYPES, WithdrawAuthMethod, isAlreadyApprovedAuth, isApprovalAuth, isDepositSpendApproved, isPermitAuth, isWithdrawAlreadyApprovedAuth, isWithdrawApprovalAuth, isWithdrawalSpendApproved, parsePermitSignature, prepareApproveDepositTokenTxData, prepareApproveWithdrawOrderTxData, prepareCancelWithdrawOrderTxData, prepareDeposit, prepareDepositAuthorization, prepareDepositPermitSignature, prepareDepositTxData, prepareDepositWithPermitTxData, prepareWithdrawOrderTxData, prepareWithdrawal, prepareWithdrawalAuthorization, toEthSignTypedDataV4 };
-//# sourceMappingURL=chunk-3D6EDR3Z.mjs.map
-//# sourceMappingURL=chunk-3D6EDR3Z.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