@paxoslabs/amplify-sdk 0.5.3 → 1.0.1

package/dist/chunk-LMNADWTH.mjs

@@ -1,2073 +0,0 @@
-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,
-  depositAssetAddress,
-  recipientAddress
-}) => {
-  try {
-    const normalizedChainId = toChainId(chainId);
-    const config = await resolveVault({
-      vaultName,
-      chainId: normalizedChainId,
-      assetAddress: depositAssetAddress,
-      callerEndpoint: "isDepositSpendApproved"
-    });
-    const communityCodeDepositorAddress = config.vault.communityCodeDepositorAddress;
-    if (!communityCodeDepositorAddress) {
-      throw new APIError(
-        `Community code depositor contract address not configured for vault ${config.id}`,
-        {
-          endpoint: "isDepositSpendApproved"
-        }
-      );
-    }
-    const {
-      decimals,
-      allowance,
-      supportsPermit,
-      nonce,
-      domainSeparator,
-      tokenName,
-      tokenVersion
-    } = await getTokenPermitInfoWithAllowance({
-      chainId: normalizedChainId,
-      tokenAddress: depositAssetAddress,
-      owner: recipientAddress,
-      spender: communityCodeDepositorAddress
-    });
-    return {
-      isApproved: allowance > 0n,
-      allowance: formatUnits(allowance, decimals),
-      allowanceAsBigInt: allowance.toString(),
-      decimals,
-      supportsPermit,
-      nonce,
-      domainSeparator,
-      tokenName,
-      tokenVersion,
-      error: null
-    };
-  } catch (error) {
-    if (error instanceof APIError) {
-      throw error;
-    }
-    throw new APIError(
-      `Failed to check deposit approval: ${error instanceof Error ? error.message : String(error)}`,
-      {
-        endpoint: "isDepositSpendApproved",
-        cause: error
-      }
-    );
-  }
-};
-var isWithdrawalSpendApproved = async ({
-  vaultName,
-  chainId,
-  wantAssetAddress,
-  recipientAddress
-}) => {
-  try {
-    const normalizedChainId = toChainId(chainId);
-    const config = await resolveVault({
-      vaultName,
-      chainId: normalizedChainId,
-      assetAddress: wantAssetAddress,
-      callerEndpoint: "isWithdrawalSpendApproved"
-    });
-    const boringVaultAddress = config.vault.boringVaultAddress;
-    if (!boringVaultAddress) {
-      throw new APIError(
-        `BoringVault contract address not configured for vault ${config.id}`,
-        {
-          endpoint: "isWithdrawalSpendApproved"
-        }
-      );
-    }
-    const withdrawQueueAddress = config.vault.withdrawQueueAddress;
-    if (!withdrawQueueAddress) {
-      throw new APIError(
-        `WithdrawQueue contract address not configured for vault ${config.id}`,
-        {
-          endpoint: "isWithdrawalSpendApproved"
-        }
-      );
-    }
-    const [allowance, decimals] = await getErc20AllowanceWithDecimals({
-      chainId: normalizedChainId,
-      tokenAddress: boringVaultAddress,
-      recipientAddress,
-      spenderAddress: withdrawQueueAddress
-    });
-    if (allowance.status === "failure" || decimals.status === "failure") {
-      return {
-        isApproved: false,
-        allowance: "0",
-        allowanceAsBigInt: "0",
-        decimals: "0",
-        error: allowance.error || decimals.error
-      };
-    }
-    return {
-      isApproved: allowance.result > 0n,
-      allowance: formatUnits(allowance.result, decimals.result),
-      allowanceAsBigInt: allowance.result.toString(),
-      decimals: decimals.result,
-      error: null
-    };
-  } catch (error) {
-    if (error instanceof APIError) {
-      throw error;
-    }
-    throw new APIError(
-      `Failed to check withdrawal approval: ${error instanceof Error ? error.message : String(error)}`,
-      { endpoint: "isWithdrawalSpendApproved", cause: error }
-    );
-  }
-};
-async function prepareApproveDepositTokenTxData({
-  vaultName,
-  depositAsset,
-  approvalAmount,
-  chainId
-}) {
-  const normalizedChainId = toChainId(chainId);
-  try {
-    const config = await resolveVault({
-      vaultName,
-      assetAddress: depositAsset,
-      chainId: normalizedChainId,
-      callerEndpoint: "prepareApproveDepositToken"
-    });
-    const communityCodeDepositorAddress = config.vault.communityCodeDepositorAddress;
-    if (!communityCodeDepositorAddress) {
-      throw new APIError(
-        `Community Code Depositor contract address not configured for vault ${config.id}`,
-        { endpoint: "prepareApproveDepositToken" }
-      );
-    }
-    const assets = await getSupportedAssets({ address: depositAsset });
-    if (assets.length === 0) {
-      throw new APIError(
-        `Asset metadata not found for token ${depositAsset} on chain ${normalizedChainId}`,
-        { endpoint: "prepareApproveDepositToken" }
-      );
-    }
-    const verifiedAsset = assets.find(
-      (asset) => asset.address.toLowerCase() === depositAsset.toLowerCase() && asset.chains.includes(normalizedChainId)
-    );
-    if (!verifiedAsset) {
-      throw new APIError(
-        `Asset ${depositAsset} not verified on chain ${normalizedChainId}`,
-        { endpoint: "prepareApproveDepositToken" }
-      );
-    }
-    const decimals = verifiedAsset.decimals;
-    const amount = approvalAmount ? parseUnits(approvalAmount, decimals) : DEFAULT_APPROVAL_AMOUNT;
-    return {
-      abi: erc20Abi,
-      address: depositAsset,
-      functionName: "approve",
-      args: [communityCodeDepositorAddress, amount]
-    };
-  } catch (error) {
-    if (error instanceof APIError) {
-      throw error;
-    }
-    throw new APIError(
-      `Failed to prepare approval transaction: ${error instanceof Error ? error.message : String(error)}`,
-      {
-        endpoint: "prepareApproveDepositToken",
-        cause: error
-      }
-    );
-  }
-}
-
-// src/abi/distributor-code-depositor-abi-v1.ts
-var DistributorCodeDepositorAbiV1 = [
-  {
-    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: "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,
-    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: "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: [
-      { indexed: true, internalType: "address", name: "user", type: "address" },
-      {
-        indexed: true,
-        internalType: "address",
-        name: "newOwner",
-        type: "address"
-      }
-    ],
-    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",
-    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" },
-      {
-        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" }],
-    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" },
-      {
-        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" }],
-    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" },
-      {
-        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" },
-      { internalType: "bytes32", name: "s", type: "bytes32" }
-    ],
-    name: "depositWithPermit",
-    outputs: [{ internalType: "uint256", name: "shares", type: "uint256" }],
-    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",
-    outputs: [{ internalType: "bool", name: "", type: "bool" }],
-    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",
-    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: [{ 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",
-    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"
-  },
-  {
-    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"
-  }
-];
-var calculateMinimumMint = (depositAmount, rate, vaultTokenDecimals, slippage) => {
-  const slippageValue = slippage ?? DEFAULT_SLIPPAGE_BPS;
-  const slippageAsBigInt = BigInt(slippageValue) * WAD.bigint / BigInt(1e4);
-  const minimumMint = depositAmount * WAD.bigint / rate;
-  const slippageAmount = minimumMint * slippageAsBigInt / WAD.bigint;
-  if (vaultTokenDecimals > 18) {
-    return (minimumMint - slippageAmount) * BigInt(10) ** (BigInt(vaultTokenDecimals) - BigInt(18));
-  }
-  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,
-    depositAsset,
-    depositAmount,
-    chainId,
-    slippage = DEFAULT_SLIPPAGE_BPS,
-    to,
-    distributorCode
-  } = params;
-  try {
-    const normalizedChainId = toChainId(chainId);
-    const vault = await resolveVault({
-      vaultName,
-      assetAddress: depositAsset,
-      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) {
-      throw new APIError(
-        `Asset metadata not found for token ${depositAsset} on chain ${normalizedChainId}`,
-        {
-          endpoint: "prepareDepositTransactionData"
-        }
-      );
-    }
-    const communityCodeDepositorAddress = vault.vault.communityCodeDepositorAddress;
-    if (!communityCodeDepositorAddress) {
-      throw new APIError(
-        `Community Code Depositor contract address not found for vault ${vault.id}`,
-        { endpoint: "prepareDepositTransactionData" }
-      );
-    }
-    const accountantAddress = vault.vault.accountantAddress;
-    if (!accountantAddress) {
-      throw new APIError(
-        `Accountant contract address not found for vault ${vault.id}`,
-        { endpoint: "prepareDepositTransactionData" }
-      );
-    }
-    const depositAssetAddress = asset.address;
-    const [depositAssetDecimalsResult, rateInQuoteResult] = await getRateInQuoteWithAssetDecimals({
-      assetAddress: depositAssetAddress,
-      accountantAddress,
-      chainId: normalizedChainId
-    });
-    if (depositAssetDecimalsResult.status === "failure") {
-      throw new APIError(
-        `Failed to get asset decimals: ${depositAssetDecimalsResult.error?.message || "Unknown error"}`,
-        {
-          endpoint: "prepareDepositTransactionData",
-          cause: depositAssetDecimalsResult.error
-        }
-      );
-    }
-    if (rateInQuoteResult.status === "failure") {
-      throw new APIError(
-        `Failed to get exchange rate: ${rateInQuoteResult.error?.message || "Unknown error"}`,
-        {
-          endpoint: "prepareDepositTransactionData",
-          cause: rateInQuoteResult.error
-        }
-      );
-    }
-    const depositAmountAsBigInt = parseUnits(
-      depositAmount,
-      depositAssetDecimalsResult.result
-    );
-    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 || "");
-    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 {
-      depositType: DepositType.KYT,
-      address: communityCodeDepositorAddress,
-      abi: DistributorCodeDepositorAbiV1,
-      functionName: "deposit",
-      args: [
-        depositAssetAddress,
-        depositAmountAsBigInt,
-        minimumMint,
-        to,
-        distributorCodeHex,
-        attestation
-      ],
-      chainId: normalizedChainId
-    };
-  } catch (error) {
-    if (error instanceof APIError) {
-      throw error;
-    }
-    throw new APIError(
-      `Failed to prepare deposit transaction: ${error instanceof Error ? error.message : String(error)}`,
-      {
-        endpoint: "prepareDepositTransactionData",
-        cause: error
-      }
-    );
-  }
-}
-var PERMIT_TYPES = {
-  Permit: [
-    { name: "owner", type: "address" },
-    { name: "spender", type: "address" },
-    { name: "value", type: "uint256" },
-    { name: "nonce", type: "uint256" },
-    { name: "deadline", type: "uint256" }
-  ]
-};
-var EIP712_DOMAIN_TYPE = [
-  { name: "name", type: "string" },
-  { name: "version", type: "string" },
-  { name: "chainId", type: "uint256" },
-  { name: "verifyingContract", type: "address" }
-];
-function toEthSignTypedDataV4(permitData) {
-  return JSON.stringify({
-    domain: permitData.domain,
-    types: {
-      EIP712Domain: EIP712_DOMAIN_TYPE,
-      ...permitData.types
-    },
-    primaryType: permitData.primaryType,
-    message: {
-      owner: permitData.message.owner,
-      spender: permitData.message.spender,
-      value: permitData.message.value.toString(),
-      nonce: permitData.message.nonce.toString(),
-      deadline: permitData.message.deadline.toString()
-    }
-  });
-}
-async function prepareDepositPermitSignature(params) {
-  const {
-    vaultName,
-    depositAsset,
-    depositAmount,
-    to,
-    chainId,
-    deadline,
-    // Optional pre-fetched data to skip RPC calls
-    nonce: prefetchedNonce,
-    decimals: prefetchedDecimals,
-    tokenName: prefetchedTokenName,
-    tokenVersion: prefetchedTokenVersion
-  } = params;
-  try {
-    const normalizedChainId = toChainId(chainId);
-    const vault = await resolveVault({
-      vaultName,
-      assetAddress: depositAsset,
-      chainId: normalizedChainId,
-      callerEndpoint: "prepareDepositPermitSignature"
-    });
-    const communityCodeDepositorAddress = vault.vault.communityCodeDepositorAddress;
-    if (!communityCodeDepositorAddress) {
-      throw new APIError(
-        `CommunityCodeDepositor contract address not found for vault ${vault.id}`,
-        { endpoint: "prepareDepositPermitSignature" }
-      );
-    }
-    let resolvedTokenName;
-    let resolvedTokenVersion;
-    let resolvedNonce;
-    const hasAllPrefetchedData = prefetchedTokenName !== void 0 && prefetchedTokenVersion !== void 0 && prefetchedNonce !== void 0;
-    if (hasAllPrefetchedData) {
-      resolvedTokenName = prefetchedTokenName;
-      resolvedTokenVersion = prefetchedTokenVersion;
-      resolvedNonce = prefetchedNonce;
-    } else {
-      const client = await getClient(normalizedChainId);
-      try {
-        const [nameResult, versionResult, nonceResult] = await client.multicall(
-          {
-            contracts: [
-              {
-                address: depositAsset,
-                abi: erc2612Abi,
-                functionName: "name"
-              },
-              {
-                address: depositAsset,
-                abi: erc2612Abi,
-                functionName: "version"
-              },
-              {
-                address: depositAsset,
-                abi: erc2612Abi,
-                functionName: "nonces",
-                args: [to]
-              }
-            ]
-          }
-        );
-        if (prefetchedTokenName !== void 0) {
-          resolvedTokenName = prefetchedTokenName;
-        } else if (nameResult.status === "success") {
-          resolvedTokenName = nameResult.result;
-        } else {
-          throw new APIError(`Failed to read token name from ${depositAsset}`, {
-            endpoint: "prepareDepositPermitSignature",
-            cause: nameResult.error
-          });
-        }
-        if (prefetchedTokenVersion !== void 0) {
-          resolvedTokenVersion = prefetchedTokenVersion;
-        } else if (versionResult.status === "success") {
-          resolvedTokenVersion = versionResult.result;
-        } else {
-          resolvedTokenVersion = "1";
-        }
-        if (prefetchedNonce !== void 0) {
-          resolvedNonce = prefetchedNonce;
-        } else if (nonceResult.status === "success") {
-          resolvedNonce = nonceResult.result;
-        } else {
-          throw new APIError(
-            `Token ${depositAsset} does not support EIP-2612 permit. Missing required function: nonces()`,
-            {
-              endpoint: "prepareDepositPermitSignature",
-              cause: nonceResult.error
-            }
-          );
-        }
-      } catch (error) {
-        if (error instanceof APIError) {
-          throw error;
-        }
-        throw new 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);
-    let resolvedDecimals;
-    if (prefetchedDecimals !== void 0) {
-      resolvedDecimals = prefetchedDecimals;
-    } else {
-      resolvedDecimals = await getErc20Decimals({
-        tokenAddress: depositAsset,
-        chainId: normalizedChainId
-      });
-    }
-    const value = parseUnits(depositAmount, resolvedDecimals);
-    const domain = {
-      name: resolvedTokenName,
-      version: resolvedTokenVersion,
-      chainId: normalizedChainId,
-      verifyingContract: depositAsset
-    };
-    const message = {
-      owner: to,
-      spender: communityCodeDepositorAddress,
-      value,
-      nonce: resolvedNonce,
-      deadline: permitDeadline
-    };
-    return {
-      account: to,
-      domain,
-      types: PERMIT_TYPES,
-      primaryType: "Permit",
-      message
-    };
-  } catch (error) {
-    if (error instanceof APIError) {
-      throw error;
-    }
-    throw new APIError(
-      `Failed to prepare permit signature: ${error instanceof Error ? error.message : String(error)}`,
-      {
-        endpoint: "prepareDepositPermitSignature",
-        cause: error
-      }
-    );
-  }
-}
-function parsePermitSignature(signature) {
-  try {
-    const parsed = 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 APIError(
-      `Invalid permit signature format. Expected hex string but received: ${signature}. ${error instanceof Error ? error.message : "Unknown error"}`,
-      {
-        endpoint: "parsePermitSignature",
-        cause: error
-      }
-    );
-  }
-}
-async function prepareDepositWithPermitTxData(params) {
-  const {
-    vaultName,
-    depositAsset,
-    depositAmount,
-    chainId,
-    signature,
-    deadline,
-    slippage = DEFAULT_SLIPPAGE_BPS,
-    to,
-    distributorCode
-  } = params;
-  try {
-    const { v, r, s } = parsePermitSignature(signature);
-    if (slippage < 0 || slippage > 1e4) {
-      throw new APIError(
-        `Invalid slippage value: ${slippage}. Slippage must be between 0 and 10000 basis points.`,
-        {
-          endpoint: "prepareDepositWithPermitTxData"
-        }
-      );
-    }
-    const normalizedChainId = toChainId(chainId);
-    const vault = await resolveVault({
-      vaultName,
-      assetAddress: depositAsset,
-      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) {
-      asset = assets.find((a) => a.chains.includes(normalizedChainId)) || assets[0] || null;
-    }
-    if (!asset) {
-      throw new APIError(
-        `Asset metadata not found for token ${depositAsset} on chain ${normalizedChainId}`,
-        {
-          endpoint: "prepareDepositWithPermitTxData"
-        }
-      );
-    }
-    if (!asset.chains || !asset.chains.includes(normalizedChainId)) {
-      throw new APIError(
-        `Token ${asset.symbol || depositAsset} not supported on chain ${normalizedChainId}`,
-        {
-          endpoint: "prepareDepositWithPermitTxData"
-        }
-      );
-    }
-    const communityCodeDepositorAddress = vault.vault.communityCodeDepositorAddress;
-    const accountantAddress = vault.vault.accountantAddress;
-    const depositAssetAddress = depositAsset;
-    if (!communityCodeDepositorAddress) {
-      throw new APIError(
-        `CommunityCodeDepositor contract address not found for vault ${vault.id}`,
-        { endpoint: "prepareDepositWithPermitTxData" }
-      );
-    }
-    if (!accountantAddress) {
-      throw new APIError(
-        `Accountant contract address not found for vault ${vault.id}`,
-        { endpoint: "prepareDepositWithPermitTxData" }
-      );
-    }
-    const rateAndDecimalResults = await getRateInQuoteWithAssetDecimals({
-      assetAddress: depositAssetAddress,
-      accountantAddress,
-      chainId: normalizedChainId
-    });
-    const [depositAssetDecimalsResult, rateInQuoteResult] = rateAndDecimalResults;
-    if (depositAssetDecimalsResult.status === "failure") {
-      throw new APIError(
-        `Failed to get asset decimals: ${depositAssetDecimalsResult.error?.message || "Unknown error"}`,
-        {
-          endpoint: "prepareDepositWithPermitTxData",
-          cause: depositAssetDecimalsResult.error
-        }
-      );
-    }
-    if (rateInQuoteResult.status === "failure") {
-      throw new APIError(
-        `Failed to get exchange rate: ${rateInQuoteResult.error?.message || "Unknown error"}`,
-        {
-          endpoint: "prepareDepositWithPermitTxData",
-          cause: rateInQuoteResult.error
-        }
-      );
-    }
-    const onChainDecimals = depositAssetDecimalsResult.result;
-    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(
-      depositAmountAfterFees,
-      rateInQuoteResult.result,
-      onChainDecimals,
-      slippage
-    );
-    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,
-          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) {
-    if (error instanceof APIError) {
-      throw error;
-    }
-    throw new APIError(
-      `Failed to prepare deposit with permit transaction: ${error instanceof Error ? error.message : String(error)}`,
-      {
-        endpoint: "prepareDepositWithPermitTxData",
-        cause: error
-      }
-    );
-  }
-}
-
-// src/utils/wallet.ts
-async function isSmartContractWallet(address, chainId) {
-  const client = await getClient(chainId);
-  const code = await client.getCode({ address });
-  return !!code && code !== "0x";
-}
-
-// src/vaults/deposit/index.ts
-var DepositAuthMethod = {
-  PERMIT: "permit",
-  APPROVAL: "approval",
-  ALREADY_APPROVED: "already_approved"
-};
-function isPermitAuth(result) {
-  return result.method === DepositAuthMethod.PERMIT;
-}
-function isApprovalAuth(result) {
-  return result.method === DepositAuthMethod.APPROVAL;
-}
-function isAlreadyApprovedAuth(result) {
-  return result.method === DepositAuthMethod.ALREADY_APPROVED;
-}
-async function prepareDepositAuthorization(params) {
-  const {
-    vaultName,
-    depositAsset,
-    depositAmount,
-    to,
-    chainId,
-    deadline,
-    forceMethod
-  } = params;
-  try {
-    const normalizedChainId = toChainId(chainId);
-    const vault = await resolveVault({
-      vaultName,
-      assetAddress: depositAsset,
-      chainId: normalizedChainId,
-      callerEndpoint: "prepareDepositAuthorization"
-    });
-    if (forceMethod === "approval") {
-      const txData2 = await prepareApproveDepositTokenTxData({
-        vaultName,
-        depositAsset,
-        approvalAmount: depositAmount,
-        chainId: normalizedChainId
-      });
-      return {
-        method: DepositAuthMethod.APPROVAL,
-        txData: txData2
-      };
-    }
-    if (forceMethod === "permit") {
-      const tokenInfo2 = await isDepositSpendApproved({
-        vaultName: vault.name,
-        chainId: normalizedChainId,
-        depositAssetAddress: depositAsset,
-        recipientAddress: to
-      });
-      const permitData = await prepareDepositPermitSignature({
-        vaultName,
-        depositAsset,
-        depositAmount,
-        to,
-        chainId: normalizedChainId,
-        deadline,
-        nonce: tokenInfo2.nonce ?? void 0,
-        decimals: tokenInfo2.decimals,
-        tokenName: tokenInfo2.tokenName,
-        tokenVersion: tokenInfo2.tokenVersion
-      });
-      return {
-        method: DepositAuthMethod.PERMIT,
-        permitData
-      };
-    }
-    const smartWallet = await isSmartContractWallet(to, normalizedChainId);
-    if (smartWallet) {
-      const txData2 = await prepareApproveDepositTokenTxData({
-        vaultName,
-        depositAsset,
-        approvalAmount: depositAmount,
-        chainId: normalizedChainId
-      });
-      return {
-        method: DepositAuthMethod.APPROVAL,
-        txData: txData2
-      };
-    }
-    const tokenInfo = await isDepositSpendApproved({
-      vaultName: vault.name,
-      chainId: normalizedChainId,
-      depositAssetAddress: depositAsset,
-      recipientAddress: to
-    });
-    if (tokenInfo.supportsPermit) {
-      const permitData = await prepareDepositPermitSignature({
-        vaultName,
-        depositAsset,
-        depositAmount,
-        to,
-        chainId: normalizedChainId,
-        deadline,
-        nonce: tokenInfo.nonce ?? void 0,
-        decimals: tokenInfo.decimals,
-        tokenName: tokenInfo.tokenName,
-        tokenVersion: tokenInfo.tokenVersion
-      });
-      return {
-        method: DepositAuthMethod.PERMIT,
-        permitData
-      };
-    }
-    const depositAmountBigInt = parseUnits(depositAmount, tokenInfo.decimals);
-    const currentAllowanceBigInt = BigInt(tokenInfo.allowanceAsBigInt);
-    if (tokenInfo.isApproved && currentAllowanceBigInt >= depositAmountBigInt) {
-      return {
-        method: DepositAuthMethod.ALREADY_APPROVED,
-        allowance: tokenInfo.allowance,
-        allowanceAsBigInt: tokenInfo.allowanceAsBigInt
-      };
-    }
-    const txData = await prepareApproveDepositTokenTxData({
-      vaultName,
-      depositAsset,
-      approvalAmount: depositAmount,
-      chainId: normalizedChainId
-    });
-    return {
-      method: DepositAuthMethod.APPROVAL,
-      txData
-    };
-  } catch (error) {
-    if (error instanceof APIError) {
-      throw error;
-    }
-    throw new APIError(
-      `Failed to prepare deposit authorization: ${error instanceof Error ? error.message : String(error)}`,
-      {
-        endpoint: "prepareDepositAuthorization",
-        cause: error
-      }
-    );
-  }
-}
-async function prepareDeposit(params) {
-  const {
-    vaultName,
-    depositAsset,
-    depositAmount,
-    to,
-    chainId,
-    slippage,
-    distributorCode,
-    signature,
-    deadline,
-    forceMethod
-  } = params;
-  try {
-    if (forceMethod === "permit" && (!signature || deadline === void 0)) {
-      throw new APIError(
-        "Permit deposit requires both signature and deadline parameters when forceMethod is 'permit'",
-        { endpoint: "prepareDeposit" }
-      );
-    }
-    const usePermit = forceMethod === "permit" || forceMethod !== "approval" && signature !== void 0 && deadline !== void 0;
-    if (usePermit) {
-      if (!signature || deadline === void 0) {
-        throw new APIError(
-          "Permit deposit requires both signature and deadline parameters",
-          { endpoint: "prepareDeposit" }
-        );
-      }
-      const txData2 = await prepareDepositWithPermitTxData({
-        vaultName,
-        depositAsset,
-        depositAmount,
-        to,
-        chainId,
-        signature,
-        deadline,
-        slippage,
-        distributorCode
-      });
-      return {
-        method: DepositAuthMethod.PERMIT,
-        txData: txData2
-      };
-    }
-    const txData = await prepareDepositTxData({
-      vaultName,
-      depositAsset,
-      depositAmount,
-      to,
-      chainId,
-      slippage,
-      distributorCode
-    });
-    return {
-      method: DepositAuthMethod.APPROVAL,
-      txData
-    };
-  } catch (error) {
-    if (error instanceof APIError) {
-      throw error;
-    }
-    throw new APIError(
-      `Failed to prepare deposit: ${error instanceof Error ? error.message : String(error)}`,
-      {
-        endpoint: "prepareDeposit",
-        cause: error
-      }
-    );
-  }
-}
-async function prepareApproveWithdrawOrderTxData({
-  vaultName,
-  wantAssetAddress,
-  withdrawAmount,
-  chainId,
-  shareDecimals
-}) {
-  try {
-    const normalizedChainId = toChainId(chainId);
-    const config = await resolveVault({
-      vaultName,
-      assetAddress: wantAssetAddress,
-      chainId: normalizedChainId,
-      callerEndpoint: "prepareApproveWithdrawOrderTxData"
-    });
-    if (!config.vault.boringVaultAddress) {
-      throw new APIError(
-        `BoringVault contract address not configured for vault ${config.id}`,
-        { endpoint: "prepareApproveWithdrawOrderTxData" }
-      );
-    }
-    if (!config.vault.withdrawQueueAddress) {
-      throw new APIError(
-        `WithdrawQueue contract address not configured for vault ${config.id}`,
-        { endpoint: "prepareApproveWithdrawOrderTxData" }
-      );
-    }
-    const boringVaultAddress = config.vault.boringVaultAddress;
-    const withdrawQueueAddress = config.vault.withdrawQueueAddress;
-    const decimals = shareDecimals ?? await getErc20Decimals({
-      tokenAddress: boringVaultAddress,
-      chainId: normalizedChainId
-    });
-    const withdrawAmountAsBigInt = withdrawAmount ? parseUnits(withdrawAmount, decimals) : DEFAULT_APPROVAL_AMOUNT;
-    return {
-      abi: BoringVaultAbi,
-      address: boringVaultAddress,
-      functionName: "approve",
-      args: [withdrawQueueAddress, withdrawAmountAsBigInt]
-    };
-  } catch (error) {
-    if (error instanceof APIError) {
-      throw error;
-    }
-    throw new APIError(
-      `Failed to prepare approval transaction: ${error instanceof Error ? error.message : String(error)}`,
-      {
-        endpoint: "prepareApproveWithdrawOrderTxData",
-        cause: error
-      }
-    );
-  }
-}
-
-// src/vaults/withdraw/cancel-withdraw.ts
-var prepareCancelWithdrawOrderTxData = async ({
-  vaultName,
-  wantAsset,
-  chainId,
-  orderIndex
-}) => {
-  try {
-    const normalizedChainId = toChainId(chainId);
-    const config = await resolveVault({
-      vaultName,
-      assetAddress: wantAsset,
-      chainId: normalizedChainId,
-      callerEndpoint: "prepareCancelWithdrawOrderTxData"
-    });
-    if (config.chainId !== normalizedChainId) {
-      throw new APIError(
-        `Vault chain mismatch: vault is on chain ${config.chainId}, requested chain ${normalizedChainId}`,
-        { endpoint: "prepareCancelWithdrawOrderTxData" }
-      );
-    }
-    if (!config.vault.withdrawQueueAddress) {
-      throw new APIError(
-        `WithdrawQueue contract address not configured for vault ${config.id}`,
-        { endpoint: "prepareCancelWithdrawOrderTxData" }
-      );
-    }
-    return {
-      abi: WithdrawQueueAbi,
-      address: config.vault.withdrawQueueAddress,
-      functionName: "cancelOrder",
-      args: [orderIndex],
-      chainId: normalizedChainId
-    };
-  } catch (error) {
-    if (error instanceof APIError) {
-      throw error;
-    }
-    throw new APIError(
-      `Failed to prepare cancel order transaction: ${error instanceof Error ? error.message : String(error)}`,
-      {
-        endpoint: "prepareCancelWithdrawOrderTxData",
-        cause: error
-      }
-    );
-  }
-};
-var ApprovalMethod = {
-  /** Standard ERC20 approve (user has pre-approved via approve()) */
-  EIP20_APPROVE: 0};
-var EMPTY_SIGNATURE_PARAMS = {
-  approvalMethod: ApprovalMethod.EIP20_APPROVE,
-  approvalV: 0,
-  approvalR: "0x0000000000000000000000000000000000000000000000000000000000000000",
-  approvalS: "0x0000000000000000000000000000000000000000000000000000000000000000",
-  submitWithSignature: false,
-  deadline: 0n,
-  eip2612Signature: "0x"
-};
-var prepareWithdrawOrderTxData = async ({
-  vaultName,
-  wantAsset,
-  userAddress,
-  chainId,
-  amountOffer
-}) => {
-  try {
-    const normalizedChainId = toChainId(chainId);
-    const config = await resolveVault({
-      vaultName,
-      assetAddress: wantAsset,
-      chainId: normalizedChainId,
-      callerEndpoint: "prepareWithdrawOrderTxData"
-    });
-    if (config.chainId !== normalizedChainId) {
-      throw new APIError(
-        `Vault chain mismatch: vault is on chain ${config.chainId}, requested chain ${normalizedChainId}`,
-        { endpoint: "prepareWithdrawOrderTxData" }
-      );
-    }
-    if (!config.vault.withdrawQueueAddress) {
-      throw new APIError(
-        `WithdrawQueue contract address not configured for vault ${config.id}`,
-        { endpoint: "prepareWithdrawOrderTxData" }
-      );
-    }
-    if (!config.vault.boringVaultAddress) {
-      throw new APIError(
-        `BoringVault contract address not configured for vault ${config.id}`,
-        { endpoint: "prepareWithdrawOrderTxData" }
-      );
-    }
-    const sharesDecimals = await getErc20Decimals({
-      tokenAddress: config.vault.boringVaultAddress,
-      chainId: normalizedChainId
-    });
-    const formattedAmountOffer = parseUnits(amountOffer, sharesDecimals);
-    return {
-      abi: WithdrawQueueAbi,
-      address: config.vault.withdrawQueueAddress,
-      functionName: "submitOrder",
-      args: [
-        {
-          amountOffer: formattedAmountOffer,
-          wantAsset,
-          intendedDepositor: userAddress,
-          receiver: userAddress,
-          refundReceiver: userAddress,
-          signatureParams: EMPTY_SIGNATURE_PARAMS
-        }
-      ],
-      chainId: normalizedChainId
-    };
-  } catch (error) {
-    if (error instanceof APIError) {
-      throw error;
-    }
-    throw new APIError(
-      `Failed to prepare withdraw order transaction: ${error instanceof Error ? error.message : String(error)}`,
-      {
-        endpoint: "prepareWithdrawOrderTxData",
-        cause: error
-      }
-    );
-  }
-};
-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"
-};
-function isWithdrawApprovalAuth(result) {
-  return result.method === WithdrawAuthMethod.APPROVAL;
-}
-function isWithdrawAlreadyApprovedAuth(result) {
-  return result.method === WithdrawAuthMethod.ALREADY_APPROVED;
-}
-async function prepareWithdrawal(params) {
-  const { vaultName, wantAsset, withdrawAmount, userAddress, chainId } = params;
-  try {
-    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;
-    }
-    throw new APIError(
-      `Failed to prepare withdrawal: ${error instanceof Error ? error.message : String(error)}`,
-      {
-        endpoint: "prepareWithdrawal",
-        cause: error
-      }
-    );
-  }
-}
-async function prepareWithdrawalAuthorization(params) {
-  const {
-    vaultName,
-    wantAsset,
-    withdrawAmount,
-    userAddress,
-    chainId,
-    forceMethod
-  } = params;
-  try {
-    const normalizedChainId = toChainId(chainId);
-    const vault = await resolveVault({
-      vaultName,
-      assetAddress: wantAsset,
-      chainId: normalizedChainId,
-      callerEndpoint: "prepareWithdrawalAuthorization"
-    });
-    if (forceMethod === "approval") {
-      const txData2 = await prepareApproveWithdrawOrderTxData({
-        vaultName,
-        wantAssetAddress: wantAsset,
-        withdrawAmount,
-        chainId: normalizedChainId
-      });
-      return {
-        method: WithdrawAuthMethod.APPROVAL,
-        txData: txData2
-      };
-    }
-    if (forceMethod !== "allowance_check") {
-      const smartWallet = await isSmartContractWallet(
-        userAddress,
-        normalizedChainId
-      );
-      if (smartWallet) {
-        const txData2 = await prepareApproveWithdrawOrderTxData({
-          vaultName,
-          wantAssetAddress: wantAsset,
-          withdrawAmount,
-          chainId: normalizedChainId
-        });
-        return {
-          method: WithdrawAuthMethod.APPROVAL,
-          txData: txData2
-        };
-      }
-    }
-    const approvalInfo = await isWithdrawalSpendApproved({
-      vaultName: vault.name,
-      chainId: normalizedChainId,
-      wantAssetAddress: wantAsset,
-      recipientAddress: userAddress
-    });
-    if (approvalInfo.error) {
-      throw new APIError(
-        `Failed to check withdrawal approval: ${approvalInfo.error}`,
-        { endpoint: "prepareWithdrawalAuthorization" }
-      );
-    }
-    const decimals = typeof approvalInfo.decimals === "string" ? Number(approvalInfo.decimals) : approvalInfo.decimals;
-    const withdrawAmountBigInt = parseUnits(withdrawAmount, decimals);
-    const currentAllowanceBigInt = BigInt(approvalInfo.allowanceAsBigInt);
-    if (approvalInfo.isApproved && currentAllowanceBigInt >= withdrawAmountBigInt) {
-      return {
-        method: WithdrawAuthMethod.ALREADY_APPROVED,
-        allowance: approvalInfo.allowance,
-        allowanceAsBigInt: approvalInfo.allowanceAsBigInt
-      };
-    }
-    const txData = await prepareApproveWithdrawOrderTxData({
-      vaultName,
-      wantAssetAddress: wantAsset,
-      withdrawAmount,
-      chainId: normalizedChainId,
-      shareDecimals: decimals
-    });
-    return {
-      method: WithdrawAuthMethod.APPROVAL,
-      txData
-    };
-  } catch (error) {
-    if (error instanceof APIError) {
-      throw error;
-    }
-    throw new APIError(
-      `Failed to prepare withdrawal authorization: ${error instanceof Error ? error.message : String(error)}`,
-      {
-        endpoint: "prepareWithdrawalAuthorization",
-        cause: error
-      }
-    );
-  }
-}
-
-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