@paxoslabs/amplify-sdk 0.5.2 → 1.0.0

package/dist/chunk-HU5CTL4C.mjs

@@ -1,1962 +0,0 @@
-import { resolveVault, WithdrawQueueAbi } from './chunk-7JQQ2TH4.mjs';
-import { getTokenPermitInfoWithAllowance, getErc20AllowanceWithDecimals, getRateInQuoteWithAssetDecimals, erc2612Abi, getErc20Decimals, BoringVaultAbi } from './chunk-Q5FXJU5Y.mjs';
-import { WAD } from './chunk-6CU533DM.mjs';
-import { toChainId, APIError, getSupportedAssets, DEFAULT_APPROVAL_AMOUNT, DEFAULT_SLIPPAGE_BPS, getLogger, getClient } from './chunk-WK7EJRBB.mjs';
-import { formatUnits, parseUnits, erc20Abi, stringToHex, zeroAddress, hexToSignature } from 'viem';
-
-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-v0.ts
-var DistributorCodeDepositorAbiV0 = [
-  {
-    inputs: [
-      {
-        internalType: "contract TellerWithMultiAssetSupport",
-        name: "_teller",
-        type: "address"
-      },
-      {
-        internalType: "contract INativeWrapper",
-        name: "_nativeWrapper",
-        type: "address"
-      },
-      {
-        internalType: "contract Authority",
-        name: "_rolesAuthority",
-        type: "address"
-      },
-      { internalType: "bool", name: "_isNativeDepositSupported", type: "bool" },
-      { internalType: "address", name: "_owner", type: "address" }
-    ],
-    stateMutability: "nonpayable",
-    type: "constructor"
-  },
-  { inputs: [], name: "IncorrectNativeDepositAmount", type: "error" },
-  { inputs: [], name: "NativeDepositNotSupported", type: "error" },
-  {
-    inputs: [],
-    name: "NativeWrapperAccountantDecimalsMismatch",
-    type: "error"
-  },
-  { inputs: [], name: "PermitFailedAndAllowanceTooLow", type: "error" },
-  { inputs: [], name: "ZeroAddress", type: "error" },
-  {
-    anonymous: false,
-    inputs: [
-      { indexed: true, internalType: "address", name: "user", type: "address" },
-      {
-        indexed: true,
-        internalType: "contract Authority",
-        name: "newAuthority",
-        type: "address"
-      }
-    ],
-    name: "AuthorityUpdated",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: true,
-        internalType: "address",
-        name: "depositor",
-        type: "address"
-      },
-      {
-        indexed: true,
-        internalType: "contract ERC20",
-        name: "depositAsset",
-        type: "address"
-      },
-      {
-        indexed: false,
-        internalType: "uint256",
-        name: "depositAmount",
-        type: "uint256"
-      },
-      {
-        indexed: false,
-        internalType: "uint256",
-        name: "minimumMint",
-        type: "uint256"
-      },
-      { indexed: false, internalType: "address", name: "to", type: "address" },
-      {
-        indexed: false,
-        internalType: "bytes32",
-        name: "depositHash",
-        type: "bytes32"
-      },
-      {
-        indexed: true,
-        internalType: "bytes",
-        name: "distributorCode",
-        type: "bytes"
-      }
-    ],
-    name: "DepositWithDistributorCode",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      { indexed: true, internalType: "address", name: "user", type: "address" },
-      {
-        indexed: true,
-        internalType: "address",
-        name: "newOwner",
-        type: "address"
-      }
-    ],
-    name: "OwnershipTransferred",
-    type: "event"
-  },
-  {
-    inputs: [],
-    name: "authority",
-    outputs: [
-      { internalType: "contract Authority", name: "", type: "address" }
-    ],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "boringVault",
-    outputs: [{ internalType: "address", name: "", type: "address" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      { internalType: "contract ERC20", name: "depositAsset", type: "address" },
-      { internalType: "uint256", name: "depositAmount", type: "uint256" },
-      { internalType: "uint256", name: "minimumMint", type: "uint256" },
-      { internalType: "address", name: "to", type: "address" },
-      { internalType: "bytes", name: "distributorCode", type: "bytes" }
-    ],
-    name: "deposit",
-    outputs: [{ internalType: "uint256", name: "shares", type: "uint256" }],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [
-      { internalType: "uint256", name: "depositAmount", type: "uint256" },
-      { internalType: "uint256", name: "minimumMint", type: "uint256" },
-      { internalType: "address", name: "to", type: "address" },
-      { internalType: "bytes", name: "distributorCode", type: "bytes" }
-    ],
-    name: "depositNative",
-    outputs: [{ internalType: "uint256", name: "shares", type: "uint256" }],
-    stateMutability: "payable",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "depositNonce",
-    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      { internalType: "contract ERC20", name: "depositAsset", type: "address" },
-      { internalType: "uint256", name: "depositAmount", type: "uint256" },
-      { internalType: "uint256", name: "minimumMint", type: "uint256" },
-      { internalType: "address", name: "to", type: "address" },
-      { internalType: "bytes", name: "distributorCode", type: "bytes" },
-      { internalType: "uint256", name: "deadline", type: "uint256" },
-      { internalType: "uint8", name: "v", type: "uint8" },
-      { internalType: "bytes32", name: "r", type: "bytes32" },
-      { internalType: "bytes32", name: "s", type: "bytes32" }
-    ],
-    name: "depositWithPermit",
-    outputs: [{ internalType: "uint256", name: "shares", type: "uint256" }],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "isNativeDepositSupported",
-    outputs: [{ internalType: "bool", name: "", type: "bool" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "nativeWrapper",
-    outputs: [
-      { internalType: "contract INativeWrapper", name: "", type: "address" }
-    ],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "owner",
-    outputs: [{ internalType: "address", name: "", type: "address" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      {
-        internalType: "contract Authority",
-        name: "newAuthority",
-        type: "address"
-      }
-    ],
-    name: "setAuthority",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "teller",
-    outputs: [
-      {
-        internalType: "contract TellerWithMultiAssetSupport",
-        name: "",
-        type: "address"
-      }
-    ],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "address", name: "newOwner", type: "address" }],
-    name: "transferOwnership",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  }
-];
-
-// src/abi/distributor-code-depositor-abi-v1.ts
-var DistributorCodeDepositorAbiV1 = [
-  {
-    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"
-  }
-];
-
-// 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);
-  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));
-};
-
-// 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 minimumMint = calculateMinimumMint(
-      depositAmountAsBigInt,
-      rateInQuoteResult.result,
-      depositAssetDecimalsResult.result,
-      slippage
-    );
-    const distributorCodeHex = stringToHex(distributorCode || "");
-    if (vault.enterpriseConfig?.predicatePolicyId != null) {
-      const attestation = {
-        uuid: "",
-        expiration: 0n,
-        attester: zeroAddress,
-        signature: "0x"
-      };
-      return {
-        depositType: DepositType.KYT,
-        address: communityCodeDepositorAddress,
-        abi: DistributorCodeDepositorAbiV1,
-        functionName: "deposit",
-        args: [
-          depositAssetAddress,
-          depositAmountAsBigInt,
-          minimumMint,
-          to,
-          distributorCodeHex,
-          attestation
-        ],
-        chainId: normalizedChainId
-      };
-    }
-    return {
-      depositType: DepositType.STANDARD,
-      abi: DistributorCodeDepositorAbiV0,
-      address: communityCodeDepositorAddress,
-      functionName: "deposit",
-      args: [
-        depositAssetAddress,
-        depositAmountAsBigInt,
-        minimumMint,
-        to,
-        distributorCodeHex
-      ],
-      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 minimumMint = calculateMinimumMint(
-      depositAmountAsBigInt,
-      rateInQuoteResult.result,
-      onChainDecimals,
-      slippage
-    );
-    const distributorCodeHex = stringToHex(distributorCode || "");
-    if (vault.enterpriseConfig?.predicatePolicyId != null) {
-      const attestation = {
-        uuid: "",
-        expiration: 0n,
-        attester: zeroAddress,
-        signature: "0x"
-      };
-      return {
-        depositType: DepositType.KYT,
-        abi: DistributorCodeDepositorAbiV1,
-        address: communityCodeDepositorAddress,
-        functionName: "depositWithPermit",
-        args: [
-          depositAssetAddress,
-          depositAmountAsBigInt,
-          minimumMint,
-          to,
-          distributorCodeHex,
-          attestation,
-          deadline,
-          v,
-          r,
-          s
-        ],
-        chainId: normalizedChainId
-      };
-    }
-    return {
-      depositType: DepositType.STANDARD,
-      abi: DistributorCodeDepositorAbiV0,
-      address: communityCodeDepositorAddress,
-      functionName: "depositWithPermit",
-      args: [
-        depositAssetAddress,
-        depositAmountAsBigInt,
-        minimumMint,
-        to,
-        distributorCodeHex,
-        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 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 {
-    return await prepareWithdrawOrderTxData({
-      vaultName,
-      wantAsset,
-      userAddress,
-      chainId,
-      amountOffer: withdrawAmount
-    });
-  } 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, isAlreadyApprovedAuth, isApprovalAuth, isDepositSpendApproved, isKytDeposit, isPermitAuth, isStandardDeposit, isWithdrawAlreadyApprovedAuth, isWithdrawApprovalAuth, isWithdrawalSpendApproved, parsePermitSignature, prepareApproveDepositTokenTxData, prepareApproveWithdrawOrderTxData, prepareCancelWithdrawOrderTxData, prepareDeposit, prepareDepositAuthorization, prepareDepositPermitSignature, prepareDepositTxData, prepareDepositWithPermitTxData, prepareWithdrawOrderTxData, prepareWithdrawal, prepareWithdrawalAuthorization, toEthSignTypedDataV4 };
-//# sourceMappingURL=chunk-HU5CTL4C.mjs.map
-//# sourceMappingURL=chunk-HU5CTL4C.mjs.map