@paxoslabs/amplify-sdk 0.5.2 → 0.5.3

package/dist/chunk-GOJQYEJQ.js

@@ -0,0 +1,3212 @@
+'use strict';
+
+var viem = require('viem');
+var chains = require('viem/chains');
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// 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: "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: "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: [],
+    name: "supplyCapInBase",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    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/fee-module-abi.ts
+var DCDAssetSpecificFeeModuleAbi = [
+  {
+    inputs: [{ internalType: "contract IERC20", name: "", type: "address" }],
+    name: "depositTokenFeeData",
+    outputs: [
+      { internalType: "uint256", name: "feePercentage", type: "uint256" },
+      { internalType: "uint256", name: "flatFee", type: "uint256" }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "ONE_HUNDRED_PERCENT",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+var FeeModuleAbi = [
+  {
+    inputs: [
+      { internalType: "uint256", name: "_offerFeePercentage", type: "uint256" }
+    ],
+    stateMutability: "nonpayable",
+    type: "constructor"
+  },
+  {
+    inputs: [
+      { internalType: "uint256", name: "feePercentage", type: "uint256" },
+      { internalType: "uint256", name: "maxAllowed", type: "uint256" }
+    ],
+    name: "FeePercentageTooHigh",
+    type: "error"
+  },
+  {
+    inputs: [
+      { internalType: "uint256", name: "amount", type: "uint256" },
+      { internalType: "contract IERC20", name: "offerAsset", type: "address" },
+      { internalType: "contract IERC20", name: "wantAsset", type: "address" },
+      { internalType: "address", name: "receiver", type: "address" }
+    ],
+    name: "calculateOfferFees",
+    outputs: [{ internalType: "uint256", name: "feeAmount", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "offerFeePercentage",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+
+// src/abi/withdraw-queue-abi.ts
+var WithdrawQueueAbi = [
+  {
+    inputs: [
+      { internalType: "string", name: "_name", type: "string" },
+      { internalType: "string", name: "_symbol", type: "string" },
+      { internalType: "address", name: "_feeRecipient", type: "address" },
+      {
+        internalType: "contract TellerWithMultiAssetSupport",
+        name: "_tellerWithMultiAssetSupport",
+        type: "address"
+      },
+      {
+        internalType: "contract IFeeModule",
+        name: "_feeModule",
+        type: "address"
+      },
+      { internalType: "uint256", name: "_minimumOrderSize", type: "uint256" },
+      { internalType: "address", name: "_owner", type: "address" }
+    ],
+    stateMutability: "nonpayable",
+    type: "constructor"
+  },
+  { inputs: [], name: "ECDSAInvalidSignature", type: "error" },
+  {
+    inputs: [{ internalType: "uint256", name: "length", type: "uint256" }],
+    name: "ECDSAInvalidSignatureLength",
+    type: "error"
+  },
+  {
+    inputs: [{ internalType: "bytes32", name: "s", type: "bytes32" }],
+    name: "ECDSAInvalidSignatureS",
+    type: "error"
+  },
+  { inputs: [], name: "ERC721EnumerableForbiddenBatchMint", type: "error" },
+  {
+    inputs: [
+      { internalType: "address", name: "sender", type: "address" },
+      { internalType: "uint256", name: "tokenId", type: "uint256" },
+      { internalType: "address", name: "owner", type: "address" }
+    ],
+    name: "ERC721IncorrectOwner",
+    type: "error"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "operator", type: "address" },
+      { internalType: "uint256", name: "tokenId", type: "uint256" }
+    ],
+    name: "ERC721InsufficientApproval",
+    type: "error"
+  },
+  {
+    inputs: [{ internalType: "address", name: "approver", type: "address" }],
+    name: "ERC721InvalidApprover",
+    type: "error"
+  },
+  {
+    inputs: [{ internalType: "address", name: "operator", type: "address" }],
+    name: "ERC721InvalidOperator",
+    type: "error"
+  },
+  {
+    inputs: [{ internalType: "address", name: "owner", type: "address" }],
+    name: "ERC721InvalidOwner",
+    type: "error"
+  },
+  {
+    inputs: [{ internalType: "address", name: "receiver", type: "address" }],
+    name: "ERC721InvalidReceiver",
+    type: "error"
+  },
+  {
+    inputs: [{ internalType: "address", name: "sender", type: "address" }],
+    name: "ERC721InvalidSender",
+    type: "error"
+  },
+  {
+    inputs: [{ internalType: "uint256", name: "tokenId", type: "uint256" }],
+    name: "ERC721NonexistentToken",
+    type: "error"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "owner", type: "address" },
+      { internalType: "uint256", name: "index", type: "uint256" }
+    ],
+    name: "ERC721OutOfBoundsIndex",
+    type: "error"
+  },
+  {
+    inputs: [{ internalType: "address", name: "token", type: "address" }],
+    name: "SafeERC20FailedOperation",
+    type: "error"
+  },
+  { inputs: [], name: "Unauthorized", type: "error" },
+  { inputs: [], name: "ZeroAddress", type: "error" },
+  {
+    inputs: [{ internalType: "uint256", name: "orderIndex", type: "uint256" }],
+    name: "OrderAlreadyProcessed",
+    type: "error"
+  },
+  {
+    inputs: [
+      { internalType: "uint256", name: "orderIndex", type: "uint256" },
+      {
+        internalType: "enum WithdrawQueue.OrderType",
+        name: "currentStatus",
+        type: "uint8"
+      }
+    ],
+    name: "InvalidOrderType",
+    type: "error"
+  },
+  {
+    inputs: [{ internalType: "uint256", name: "orderIndex", type: "uint256" }],
+    name: "InvalidOrderIndex",
+    type: "error"
+  },
+  {
+    inputs: [
+      { internalType: "uint256", name: "amount", type: "uint256" },
+      { internalType: "uint256", name: "minimum", type: "uint256" }
+    ],
+    name: "AmountBelowMinimum",
+    type: "error"
+  },
+  {
+    inputs: [
+      { internalType: "uint256", name: "deadline", type: "uint256" },
+      { internalType: "uint256", name: "currentTimestamp", type: "uint256" }
+    ],
+    name: "SignatureExpired",
+    type: "error"
+  },
+  {
+    inputs: [
+      { internalType: "uint256", name: "ordersToProcess", type: "uint256" },
+      { internalType: "uint256", name: "latestOrder", type: "uint256" }
+    ],
+    name: "NotEnoughOrdersToProcess",
+    type: "error"
+  },
+  {
+    inputs: [
+      { internalType: "uint256", name: "ordersToProcess", type: "uint256" }
+    ],
+    name: "InvalidOrdersCount",
+    type: "error"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "intendedDepositor", type: "address" },
+      { internalType: "address", name: "depositor", type: "address" }
+    ],
+    name: "InvalidEip2612Signature",
+    type: "error"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "intendedDepositor", type: "address" },
+      { internalType: "address", name: "depositor", type: "address" }
+    ],
+    name: "InvalidDepositor",
+    type: "error"
+  },
+  { inputs: [], name: "PermitFailedAndAllowanceTooLow", type: "error" },
+  { inputs: [], name: "TellerVaultMissmatch", type: "error" },
+  {
+    inputs: [
+      { internalType: "address", name: "attemptedToCancel", type: "address" },
+      { internalType: "address", name: "orderOwner", type: "address" }
+    ],
+    name: "OnlyOrderOwnerCanCancel",
+    type: "error"
+  },
+  { inputs: [], name: "QueueMustBeEmpty", type: "error" },
+  {
+    inputs: [
+      { internalType: "contract IERC20", name: "asset", type: "address" }
+    ],
+    name: "AssetNotSupported",
+    type: "error"
+  },
+  { inputs: [], name: "InvalidAssetsOut", type: "error" },
+  { inputs: [], name: "EmptyArray", type: "error" },
+  {
+    inputs: [
+      { internalType: "contract IERC20", name: "wantAsset", type: "address" },
+      { internalType: "uint256", name: "expectedAssetsOut", type: "uint256" },
+      {
+        internalType: "uint256",
+        name: "vaultBalanceOfWantAsset",
+        type: "uint256"
+      }
+    ],
+    name: "VaultInsufficientBalance",
+    type: "error"
+  },
+  { inputs: [], name: "TellerIsPaused", type: "error" },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "owner",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "approved",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "tokenId",
+        type: "uint256"
+      }
+    ],
+    name: "Approval",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "owner",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "operator",
+        type: "address"
+      },
+      { indexed: false, internalType: "bool", name: "approved", type: "bool" }
+    ],
+    name: "ApprovalForAll",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "user",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "newAuthority",
+        type: "address"
+      }
+    ],
+    name: "AuthorityUpdated",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "contract IFeeModule",
+        name: "oldFeeModule",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "contract IFeeModule",
+        name: "newFeeModule",
+        type: "address"
+      }
+    ],
+    name: "FeeModuleUpdated",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "oldFeeRecipient",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "newFeeRecipient",
+        type: "address"
+      }
+    ],
+    name: "FeeRecipientUpdated",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "oldMinimum",
+        type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "newMinimum",
+        type: "uint256"
+      }
+    ],
+    name: "MinimumOrderSizeUpdated",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "orderIndex",
+        type: "uint256"
+      },
+      {
+        components: [
+          { internalType: "uint256", name: "amountOffer", type: "uint256" },
+          {
+            internalType: "contract IERC20",
+            name: "wantAsset",
+            type: "address"
+          },
+          { internalType: "address", name: "refundReceiver", type: "address" },
+          {
+            internalType: "enum WithdrawQueue.OrderType",
+            name: "orderType",
+            type: "uint8"
+          },
+          {
+            internalType: "bool",
+            name: "didOrderFailTransfer",
+            type: "bool"
+          }
+        ],
+        indexed: false,
+        internalType: "struct WithdrawQueue.Order",
+        name: "order",
+        type: "tuple"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "receiver",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "depositor",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "bool",
+        name: "isSubmittedViaSignature",
+        type: "bool"
+      }
+    ],
+    name: "OrderSubmitted",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "startIndex",
+        type: "uint256"
+      },
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "endIndex",
+        type: "uint256"
+      }
+    ],
+    name: "OrdersProcessedInRange",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "orderIndex",
+        type: "uint256"
+      },
+      {
+        components: [
+          { internalType: "uint256", name: "amountOffer", type: "uint256" },
+          {
+            internalType: "contract IERC20",
+            name: "wantAsset",
+            type: "address"
+          },
+          { internalType: "address", name: "refundReceiver", type: "address" },
+          {
+            internalType: "enum WithdrawQueue.OrderType",
+            name: "orderType",
+            type: "uint8"
+          },
+          {
+            internalType: "bool",
+            name: "didOrderFailTransfer",
+            type: "bool"
+          }
+        ],
+        indexed: false,
+        internalType: "struct WithdrawQueue.Order",
+        name: "order",
+        type: "tuple"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "receiver",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "bool",
+        name: "isForceProcessed",
+        type: "bool"
+      }
+    ],
+    name: "OrderProcessed",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "orderIndex",
+        type: "uint256"
+      },
+      {
+        components: [
+          { internalType: "uint256", name: "amountOffer", type: "uint256" },
+          {
+            internalType: "contract IERC20",
+            name: "wantAsset",
+            type: "address"
+          },
+          { internalType: "address", name: "refundReceiver", type: "address" },
+          {
+            internalType: "enum WithdrawQueue.OrderType",
+            name: "orderType",
+            type: "uint8"
+          },
+          {
+            internalType: "bool",
+            name: "didOrderFailTransfer",
+            type: "bool"
+          }
+        ],
+        indexed: false,
+        internalType: "struct WithdrawQueue.Order",
+        name: "order",
+        type: "tuple"
+      }
+    ],
+    name: "OrderRefunded",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "orderIndex",
+        type: "uint256"
+      },
+      {
+        indexed: true,
+        internalType: "bool",
+        name: "isMarkedByUser",
+        type: "bool"
+      }
+    ],
+    name: "OrderMarkedForRefund",
+    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: true,
+        internalType: "contract TellerWithMultiAssetSupport",
+        name: "oldTeller",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "contract TellerWithMultiAssetSupport",
+        name: "newTeller",
+        type: "address"
+      }
+    ],
+    name: "TellerUpdated",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "from",
+        type: "address"
+      },
+      { indexed: true, internalType: "address", name: "to", type: "address" },
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "tokenId",
+        type: "uint256"
+      }
+    ],
+    name: "Transfer",
+    type: "event"
+  },
+  {
+    inputs: [],
+    name: "CANCEL_ORDER_TYPEHASH",
+    outputs: [{ internalType: "bytes32", name: "", type: "bytes32" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "authority",
+    outputs: [
+      { internalType: "contract Authority", name: "", type: "address" }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "address", name: "owner", type: "address" }],
+    name: "balanceOf",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "uint256", name: "tokenId", type: "uint256" }],
+    name: "ownerOf",
+    outputs: [{ internalType: "address", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "uint256", name: "orderIndex", type: "uint256" }],
+    name: "cancelOrder",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "uint256", name: "orderIndex", type: "uint256" },
+      { internalType: "uint256", name: "deadline", type: "uint256" },
+      { internalType: "bytes", name: "cancelSignature", type: "bytes" }
+    ],
+    name: "cancelOrderWithSignature",
+    outputs: [],
+    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: [{ internalType: "uint256", name: "orderIndex", type: "uint256" }],
+    name: "forceProcess",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "uint256[]", name: "orderIndices", type: "uint256[]" }
+    ],
+    name: "forceProcessOrders",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "uint256", name: "orderIndex", type: "uint256" }],
+    name: "getOrderStatus",
+    outputs: [
+      {
+        internalType: "enum WithdrawQueue.OrderStatus",
+        name: "",
+        type: "uint8"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "uint256", name: "tokenId", type: "uint256" }],
+    name: "getApproved",
+    outputs: [{ internalType: "address", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "lastProcessedOrder",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "latestOrder",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "contract IERC20", name: "token", type: "address" },
+      { internalType: "uint256", name: "amount", type: "uint256" },
+      { internalType: "address", name: "receiver", type: "address" }
+    ],
+    name: "manageERC20",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "minimumOrderSize",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "name",
+    outputs: [{ internalType: "string", name: "", type: "string" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "address", name: "", type: "address" }],
+    name: "nonces",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "offerAsset",
+    outputs: [{ internalType: "contract IERC20", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "owner",
+    outputs: [{ internalType: "address", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    name: "orderAtQueueIndex",
+    outputs: [
+      {
+        components: [
+          { internalType: "uint256", name: "amountOffer", type: "uint256" },
+          {
+            internalType: "contract IERC20",
+            name: "wantAsset",
+            type: "address"
+          },
+          { internalType: "address", name: "refundReceiver", type: "address" },
+          {
+            internalType: "enum WithdrawQueue.OrderType",
+            name: "orderType",
+            type: "uint8"
+          },
+          {
+            internalType: "bool",
+            name: "didOrderFailTransfer",
+            type: "bool"
+          }
+        ],
+        internalType: "struct WithdrawQueue.Order",
+        name: "",
+        type: "tuple"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "owner", type: "address" },
+      { internalType: "address", name: "operator", type: "address" }
+    ],
+    name: "isApprovedForAll",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "uint256", name: "orderIndex", type: "uint256" }],
+    name: "refundOrder",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "uint256[]", name: "orderIndices", type: "uint256[]" }
+    ],
+    name: "refundOrders",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "uint256", name: "ordersToProcess", type: "uint256" }
+    ],
+    name: "processOrders",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          { internalType: "uint256", name: "amountOffer", type: "uint256" },
+          {
+            internalType: "contract IERC20",
+            name: "wantAsset",
+            type: "address"
+          },
+          {
+            internalType: "address",
+            name: "intendedDepositor",
+            type: "address"
+          },
+          { internalType: "address", name: "receiver", type: "address" },
+          { internalType: "address", name: "refundReceiver", type: "address" },
+          {
+            components: [
+              {
+                internalType: "enum WithdrawQueue.ApprovalMethod",
+                name: "approvalMethod",
+                type: "uint8"
+              },
+              { internalType: "uint8", name: "approvalV", type: "uint8" },
+              { internalType: "bytes32", name: "approvalR", type: "bytes32" },
+              { internalType: "bytes32", name: "approvalS", type: "bytes32" },
+              {
+                internalType: "bool",
+                name: "submitWithSignature",
+                type: "bool"
+              },
+              { internalType: "uint256", name: "deadline", type: "uint256" },
+              {
+                internalType: "bytes",
+                name: "eip2612Signature",
+                type: "bytes"
+              }
+            ],
+            internalType: "struct WithdrawQueue.SignatureParams",
+            name: "signatureParams",
+            type: "tuple"
+          }
+        ],
+        internalType: "struct WithdrawQueue.SubmitOrderParams",
+        name: "params",
+        type: "tuple"
+      }
+    ],
+    name: "submitOrder",
+    outputs: [{ internalType: "uint256", name: "orderIndex", type: "uint256" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          { internalType: "uint256", name: "amountOffer", type: "uint256" },
+          {
+            internalType: "contract IERC20",
+            name: "wantAsset",
+            type: "address"
+          },
+          {
+            internalType: "address",
+            name: "intendedDepositor",
+            type: "address"
+          },
+          { internalType: "address", name: "receiver", type: "address" },
+          { internalType: "address", name: "refundReceiver", type: "address" },
+          {
+            components: [
+              {
+                internalType: "enum WithdrawQueue.ApprovalMethod",
+                name: "approvalMethod",
+                type: "uint8"
+              },
+              { internalType: "uint8", name: "approvalV", type: "uint8" },
+              { internalType: "bytes32", name: "approvalR", type: "bytes32" },
+              { internalType: "bytes32", name: "approvalS", type: "bytes32" },
+              {
+                internalType: "bool",
+                name: "submitWithSignature",
+                type: "bool"
+              },
+              { internalType: "uint256", name: "deadline", type: "uint256" },
+              {
+                internalType: "bytes",
+                name: "eip2612Signature",
+                type: "bytes"
+              }
+            ],
+            internalType: "struct WithdrawQueue.SignatureParams",
+            name: "signatureParams",
+            type: "tuple"
+          }
+        ],
+        internalType: "struct WithdrawQueue.SubmitOrderParams",
+        name: "params",
+        type: "tuple"
+      },
+      { internalType: "uint256", name: "ordersToProcess", type: "uint256" }
+    ],
+    name: "submitOrderAndProcess",
+    outputs: [{ internalType: "uint256", name: "orderIndex", type: "uint256" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          { internalType: "uint256", name: "amountOffer", type: "uint256" },
+          {
+            internalType: "contract IERC20",
+            name: "wantAsset",
+            type: "address"
+          },
+          {
+            internalType: "address",
+            name: "intendedDepositor",
+            type: "address"
+          },
+          { internalType: "address", name: "receiver", type: "address" },
+          { internalType: "address", name: "refundReceiver", type: "address" },
+          {
+            components: [
+              {
+                internalType: "enum WithdrawQueue.ApprovalMethod",
+                name: "approvalMethod",
+                type: "uint8"
+              },
+              { internalType: "uint8", name: "approvalV", type: "uint8" },
+              { internalType: "bytes32", name: "approvalR", type: "bytes32" },
+              { internalType: "bytes32", name: "approvalS", type: "bytes32" },
+              {
+                internalType: "bool",
+                name: "submitWithSignature",
+                type: "bool"
+              },
+              { internalType: "uint256", name: "deadline", type: "uint256" },
+              {
+                internalType: "bytes",
+                name: "eip2612Signature",
+                type: "bytes"
+              }
+            ],
+            internalType: "struct WithdrawQueue.SignatureParams",
+            name: "signatureParams",
+            type: "tuple"
+          }
+        ],
+        internalType: "struct WithdrawQueue.SubmitOrderParams",
+        name: "params",
+        type: "tuple"
+      }
+    ],
+    name: "submitOrderAndProcessAll",
+    outputs: [{ internalType: "uint256", name: "orderIndex", type: "uint256" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "symbol",
+    outputs: [{ internalType: "string", name: "", type: "string" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "bytes4", name: "interfaceId", type: "bytes4" }],
+    name: "supportsInterface",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "tellerWithMultiAssetSupport",
+    outputs: [
+      {
+        internalType: "contract TellerWithMultiAssetSupport",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "uint256", name: "tokenId", type: "uint256" }],
+    name: "tokenByIndex",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "owner", type: "address" },
+      { internalType: "uint256", name: "index", type: "uint256" }
+    ],
+    name: "tokenOfOwnerByIndex",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "uint256", name: "tokenId", type: "uint256" }],
+    name: "tokenURI",
+    outputs: [{ internalType: "string", name: "", type: "string" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "totalSupply",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "from", type: "address" },
+      { internalType: "address", name: "to", type: "address" },
+      { internalType: "uint256", name: "tokenId", type: "uint256" }
+    ],
+    name: "transferFrom",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "from", type: "address" },
+      { internalType: "address", name: "to", type: "address" },
+      { internalType: "uint256", name: "tokenId", type: "uint256" }
+    ],
+    name: "safeTransferFrom",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "from", type: "address" },
+      { internalType: "address", name: "to", type: "address" },
+      { internalType: "uint256", name: "tokenId", type: "uint256" },
+      { internalType: "bytes", name: "_data", type: "bytes" }
+    ],
+    name: "safeTransferFrom",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "operator", type: "address" },
+      { internalType: "bool", name: "approved", type: "bool" }
+    ],
+    name: "setApprovalForAll",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "contract IFeeModule",
+        name: "_feeModule",
+        type: "address"
+      }
+    ],
+    name: "setFeeModule",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "_feeRecipient", type: "address" }
+    ],
+    name: "setFeeRecipient",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "contract TellerWithMultiAssetSupport",
+        name: "_newTeller",
+        type: "address"
+      }
+    ],
+    name: "setTellerWithMultiAssetSupport",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "address", name: "newOwner", type: "address" }],
+    name: "setOwner",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "contract Authority",
+        name: "newAuthority",
+        type: "address"
+      }
+    ],
+    name: "setAuthority",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "uint256", name: "_newMinimum", type: "uint256" }],
+    name: "updateAssetMinimumOrderSize",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "to", type: "address" },
+      { internalType: "uint256", name: "tokenId", type: "uint256" }
+    ],
+    name: "approve",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+
+// src/constants/environment.ts
+var BASE_URL = "https://api.paxoslabs.com";
+function getGraphQLEndpoint() {
+  return `${BASE_URL}/graphql`;
+}
+function getRestV2BaseURL() {
+  return `${BASE_URL}/v2`;
+}
+
+// src/types/telemetry.ts
+var LogLevel = {
+  DEBUG: 0,
+  INFO: 1,
+  WARN: 2,
+  ERROR: 3,
+  NONE: 4
+};
+
+// src/lib/logger.ts
+var ConsoleLogger = class {
+  constructor(level = LogLevel.ERROR) {
+    __publicField(this, "level");
+    this.level = level;
+  }
+  /**
+   * Update log level
+   */
+  setLevel(level) {
+    this.level = level;
+  }
+  /**
+   * Get current log level
+   */
+  getLevel() {
+    return this.level;
+  }
+  debug(message, context) {
+    if (this.level <= LogLevel.DEBUG) {
+      if (context) {
+        console.debug("[Amplify SDK]", message, context);
+      } else {
+        console.debug("[Amplify SDK]", message);
+      }
+    }
+  }
+  info(message, context) {
+    if (this.level <= LogLevel.INFO) {
+      if (context) {
+        console.info("[Amplify SDK]", message, context);
+      } else {
+        console.info("[Amplify SDK]", message);
+      }
+    }
+  }
+  warn(message, context) {
+    if (this.level <= LogLevel.WARN) {
+      if (context) {
+        console.warn("[Amplify SDK]", message, context);
+      } else {
+        console.warn("[Amplify SDK]", message);
+      }
+    }
+  }
+  error(message, context) {
+    if (this.level <= LogLevel.ERROR) {
+      if (context) {
+        console.error("[Amplify SDK]", message, context);
+      } else {
+        console.error("[Amplify SDK]", message);
+      }
+    }
+  }
+};
+var currentLogger = new ConsoleLogger(LogLevel.ERROR);
+var defaultLogger = currentLogger;
+function setLogger(logger) {
+  currentLogger = logger;
+}
+function getLogger() {
+  return currentLogger;
+}
+function setLogLevel(level) {
+  if (defaultLogger && typeof defaultLogger.setLevel === "function") {
+    defaultLogger.setLevel(level);
+  }
+}
+
+// src/lib/vault-cache.ts
+var DEFAULT_TTL = 6e5;
+var VaultCache = class {
+  /**
+   * Creates a new VaultCache instance
+   *
+   * @param ttl - Time-to-live in milliseconds (default: 600000 = 10 minutes)
+   */
+  constructor(ttl = DEFAULT_TTL) {
+    /**
+     * Vaults keyed by baseTokenAddress
+     * One key can map to multiple vaults (different chains/yield types)
+     */
+    __publicField(this, "vaults");
+    /**
+     * Assets keyed by token address
+     */
+    __publicField(this, "assets");
+    /**
+     * Vaults keyed by boringVaultAddress (lowercase, for case-insensitive lookup)
+     */
+    __publicField(this, "vaultsByAddress");
+    /**
+     * Vaults keyed by vault name (lowercase, for case-insensitive lookup)
+     */
+    __publicField(this, "vaultsByName");
+    /**
+     * Unix timestamp (milliseconds) of last successful fetch
+     */
+    __publicField(this, "lastFetch");
+    /**
+     * Time-to-live in milliseconds
+     */
+    __publicField(this, "ttl");
+    /**
+     * Current refresh promise (prevents duplicate concurrent refreshes)
+     * When non-null, a refresh is in progress and callers should await this promise
+     */
+    __publicField(this, "refreshPromise");
+    /**
+     * Unix timestamp (milliseconds) when current refresh started.
+     * Used to detect stale refresh promises.
+     */
+    __publicField(this, "refreshStartedAt");
+    this.vaults = /* @__PURE__ */ new Map();
+    this.assets = /* @__PURE__ */ new Map();
+    this.vaultsByAddress = /* @__PURE__ */ new Map();
+    this.vaultsByName = /* @__PURE__ */ new Map();
+    this.lastFetch = 0;
+    this.ttl = ttl;
+    this.refreshPromise = null;
+    this.refreshStartedAt = 0;
+  }
+  /**
+   * Gets vaults by deposit token address
+   *
+   * Returns undefined if no vaults found for the given token address.
+   * Does NOT automatically refresh if cache is expired; use refresh() for that.
+   *
+   * @param tokenAddress - Deposit token address (baseTokenAddress)
+   * @returns Array of AmplifyVault objects, or undefined if not found
+   */
+  getVault(tokenAddress) {
+    return this.vaults.get(tokenAddress);
+  }
+  /**
+   * Gets a vault by its boringVaultAddress (on-chain vault contract).
+   * Case-insensitive lookup.
+   */
+  getVaultByAddress(address) {
+    return this.vaultsByAddress.get(address.toLowerCase());
+  }
+  /**
+   * Gets a vault by its human-readable name.
+   * Case-insensitive lookup.
+   */
+  getVaultByName(name) {
+    return this.vaultsByName.get(name.toLowerCase());
+  }
+  /**
+   * Gets asset by token address
+   *
+   * Returns undefined if asset not found.
+   * Does NOT automatically refresh if cache is expired; use refresh() for that.
+   *
+   * @param tokenAddress - Token address
+   * @returns SupportedAsset object, or undefined if not found
+   */
+  getAsset(tokenAddress) {
+    return this.assets.get(tokenAddress);
+  }
+  /**
+   * Gets all cached vaults
+   *
+   * Returns an array of all vaults across all deposit tokens.
+   * Does NOT automatically refresh if cache is expired; use refresh() for that.
+   *
+   * @returns Array of all AmplifyVault objects
+   */
+  getAllVaults() {
+    const seen = /* @__PURE__ */ new Set();
+    const allVaults = [];
+    for (const vaultArray of this.vaults.values()) {
+      for (const vault of vaultArray) {
+        if (!seen.has(vault.id)) {
+          seen.add(vault.id);
+          allVaults.push(vault);
+        }
+      }
+    }
+    return allVaults;
+  }
+  /**
+   * Gets all cached assets
+   *
+   * Returns an array of all assets.
+   * Does NOT automatically refresh if cache is expired; use refresh() for that.
+   *
+   * @returns Array of all SupportedAsset objects
+   */
+  getAllAssets() {
+    return Array.from(this.assets.values());
+  }
+  /**
+   * Checks if cache is expired
+   *
+   * Cache is considered expired if current time exceeds lastFetch + ttl.
+   *
+   * @returns true if cache is expired, false otherwise
+   */
+  isExpired() {
+    return Date.now() > this.lastFetch + this.ttl;
+  }
+  /**
+   * Gets the time until cache expires
+   *
+   * @returns Milliseconds until expiry, or 0 if already expired
+   */
+  getTimeUntilExpiry() {
+    const expiryTime = this.lastFetch + this.ttl;
+    const now = Date.now();
+    return Math.max(0, expiryTime - now);
+  }
+  /**
+   * Checks if cache is empty (never populated)
+   *
+   * @returns true if cache has never been populated, false otherwise
+   */
+  isEmpty() {
+    return this.lastFetch === 0;
+  }
+  /**
+   * Manually refreshes the cache
+   *
+   * Fetches fresh data from the API and updates both vaults and assets maps.
+   * Updates lastFetch timestamp on success.
+   *
+   * If a refresh is already in progress, this method returns the existing
+   * promise instead of starting a concurrent refresh. This is more efficient
+   * than polling and ensures all callers wait for the same refresh operation.
+   *
+   * @throws {APIError} If the API request fails
+   */
+  async refresh() {
+    const STALE_REFRESH_MS = 3e4;
+    if (this.refreshPromise) {
+      if (Date.now() - this.refreshStartedAt < STALE_REFRESH_MS) {
+        return this.refreshPromise;
+      }
+      this.refreshPromise = null;
+    }
+    this.refreshStartedAt = Date.now();
+    this.refreshPromise = this._doRefresh();
+    try {
+      await this.refreshPromise;
+    } finally {
+      this.refreshPromise = null;
+    }
+  }
+  /**
+   * Internal refresh implementation
+   * Separated to allow promise reuse in refresh()
+   *
+   * Fetches data via GraphQL and derives both vaults and assets
+   * from the same response.
+   */
+  async _doRefresh() {
+    const { vaults, assets } = await fetchVaultDataFromGraphQL();
+    this.vaults.clear();
+    this.assets.clear();
+    this.vaultsByAddress.clear();
+    this.vaultsByName.clear();
+    for (const vault of vaults) {
+      for (const asset of vault.supportedAssets) {
+        const tokenAddress = asset.address;
+        const existing = this.vaults.get(tokenAddress);
+        if (existing) {
+          if (!existing.includes(vault)) {
+            existing.push(vault);
+          }
+        } else {
+          this.vaults.set(tokenAddress, [vault]);
+        }
+      }
+      this.vaultsByAddress.set(
+        vault.vault.boringVaultAddress.toLowerCase(),
+        vault
+      );
+      if (vault.name) {
+        this.vaultsByName.set(vault.name.toLowerCase(), vault);
+      }
+    }
+    for (const asset of assets) {
+      this.assets.set(asset.address, asset);
+    }
+    this.lastFetch = Date.now();
+  }
+  /**
+   * Check if a refresh is currently in progress
+   *
+   * @returns true if cache is being refreshed, false otherwise
+   */
+  isRefreshing() {
+    return this.refreshPromise !== null;
+  }
+  /**
+   * Clears the cache
+   *
+   * Removes all cached data and resets lastFetch timestamp.
+   * Does not affect TTL setting.
+   */
+  clear() {
+    this.vaults.clear();
+    this.assets.clear();
+    this.vaultsByAddress.clear();
+    this.vaultsByName.clear();
+    this.lastFetch = 0;
+  }
+  /**
+   * Gets cache statistics
+   *
+   * @returns Object with cache statistics
+   */
+  getStats() {
+    return {
+      vaultCount: this.getAllVaults().length,
+      assetCount: this.assets.size,
+      tokenCount: this.vaults.size,
+      lastFetch: this.lastFetch,
+      ttl: this.ttl,
+      isExpired: this.isExpired(),
+      isEmpty: this.isEmpty(),
+      timeUntilExpiry: this.getTimeUntilExpiry()
+    };
+  }
+};
+
+// src/constants/index.ts
+var DEFAULT_DEADLINE = 3;
+var CHAINLINK_ADDRESS = "0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419";
+var DEFAULT_APPROVAL_AMOUNT = BigInt(2) ** BigInt(256) - BigInt(1);
+var API_BASE_URL = "https://api.paxoslabs.com";
+
+// src/utils/fetch.ts
+var DEFAULT_TIMEOUT = 1e4;
+function createTimeoutSignal(timeoutMs) {
+  const controller = new AbortController();
+  setTimeout(() => controller.abort(), timeoutMs);
+  return controller.signal;
+}
+
+// src/lib/sdk-config.ts
+var MAX_CACHE_RETRIES = 3;
+var RETRY_DELAYS = [1e3, 2e3, 4e3];
+var sdkConfig = {
+  apiKey: null,
+  isInitialized: false,
+  initializedAt: null,
+  isInitializing: false,
+  initPromise: null,
+  telemetryEnabled: true,
+  cachePopulationPromise: null,
+  isCacheReady: false,
+  rpcUrls: {}
+};
+var ERROR_MESSAGES = {
+  INVALID_API_KEY: "Invalid API key format. Expected format: pxl_<type>_<string>",
+  EMPTY_API_KEY: "API key cannot be empty. Provide a valid API key from Paxos Labs.",
+  UNKNOWN_ERROR: "Unexpected initialization error. Contact support if issue persists."};
+function validateAPIKey(apiKey) {
+  if (!apiKey || apiKey.trim().length === 0) {
+    throw new APIError(ERROR_MESSAGES.EMPTY_API_KEY, {
+      endpoint: "initAmplifySDK",
+      statusCode: void 0
+    });
+  }
+  if (apiKey.length < 10) {
+    throw new APIError(ERROR_MESSAGES.INVALID_API_KEY, {
+      endpoint: "initAmplifySDK",
+      statusCode: void 0
+    });
+  }
+  if (!apiKey.startsWith("pxl_")) {
+    getLogger().warn(
+      'API key does not start with expected prefix "pxl_". It may not be valid.'
+    );
+  }
+}
+function setAPIKey(apiKey) {
+  sdkConfig.apiKey = apiKey;
+}
+function getAPIKey() {
+  return sdkConfig.apiKey;
+}
+function getRpcUrls() {
+  return { ...sdkConfig.rpcUrls };
+}
+function clearConfig() {
+  sdkConfig.apiKey = null;
+  sdkConfig.isInitialized = false;
+  sdkConfig.initializedAt = null;
+  sdkConfig.isInitializing = false;
+  sdkConfig.initPromise = null;
+  sdkConfig.telemetryEnabled = true;
+  sdkConfig.cachePopulationPromise = null;
+  sdkConfig.isCacheReady = false;
+  sdkConfig.rpcUrls = {};
+  clearClients();
+  resetTelemetry();
+}
+function getRequestHeaders() {
+  const apiKey = getAPIKey();
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (apiKey) {
+    headers["x-api-key"] = apiKey;
+  }
+  return headers;
+}
+async function populateCacheInBackground(cache) {
+  const logger = getLogger();
+  for (let attempt = 0; attempt < MAX_CACHE_RETRIES; attempt++) {
+    try {
+      await cache.refresh();
+      sdkConfig.isCacheReady = true;
+      logger.debug("Background cache population completed", {
+        attempt: attempt + 1
+      });
+      return;
+    } catch (error) {
+      const isLastAttempt = attempt === MAX_CACHE_RETRIES - 1;
+      if (isLastAttempt) {
+        logger.warn(
+          "Background cache population failed after all retries, falling back to on-demand fetching",
+          {
+            error: error instanceof Error ? error.message : String(error),
+            attempts: MAX_CACHE_RETRIES
+          }
+        );
+        return;
+      }
+      logger.debug(
+        `Cache population attempt ${attempt + 1} failed, retrying...`,
+        {
+          error: error instanceof Error ? error.message : String(error),
+          nextRetryIn: RETRY_DELAYS[attempt]
+        }
+      );
+      await new Promise((resolve) => setTimeout(resolve, RETRY_DELAYS[attempt]));
+    }
+  }
+}
+function isCacheReady() {
+  return sdkConfig.isCacheReady;
+}
+async function waitForCacheReady() {
+  if (sdkConfig.isCacheReady) {
+    return;
+  }
+  if (sdkConfig.cachePopulationPromise) {
+    await sdkConfig.cachePopulationPromise;
+    if (sdkConfig.isCacheReady) {
+      return;
+    }
+  }
+  const cache = getCache();
+  await cache.refresh();
+  sdkConfig.isCacheReady = true;
+}
+async function initAmplifySDK(apiKey, options) {
+  validateAPIKey(apiKey);
+  if (sdkConfig.isInitialized && sdkConfig.apiKey === apiKey) {
+    const nextRpcUrls = options?.rpcUrls ?? {};
+    const hasRpcUrlChange = Object.keys(nextRpcUrls).length !== Object.keys(sdkConfig.rpcUrls).length || Object.entries(nextRpcUrls).some(
+      ([chainId, url]) => sdkConfig.rpcUrls[Number(chainId)] !== url
+    );
+    if (hasRpcUrlChange) {
+      sdkConfig.rpcUrls = { ...nextRpcUrls };
+      clearClients();
+    }
+    return;
+  }
+  if (sdkConfig.isInitializing && sdkConfig.initPromise) {
+    await sdkConfig.initPromise;
+    return;
+  }
+  if (sdkConfig.isInitialized && sdkConfig.apiKey !== apiKey) {
+    clearConfig();
+    clearCache();
+  }
+  if (options?.logger) {
+    setLogger(options.logger);
+  }
+  if (options?.logLevel !== void 0) {
+    setLogLevel(options.logLevel);
+  }
+  sdkConfig.telemetryEnabled = options?.telemetry !== false;
+  sdkConfig.rpcUrls = options?.rpcUrls ?? {};
+  sdkConfig.isInitializing = true;
+  sdkConfig.initPromise = (async () => {
+    try {
+      setAPIKey(apiKey);
+      const cache = initializeCache();
+      sdkConfig.isInitialized = true;
+      sdkConfig.initializedAt = /* @__PURE__ */ new Date();
+      sdkConfig.isCacheReady = false;
+      sdkConfig.cachePopulationPromise = populateCacheInBackground(cache);
+      if (sdkConfig.telemetryEnabled) {
+        initTelemetry(apiKey).catch(() => {
+        });
+      }
+      getLogger().info(
+        "Amplify SDK initialized (cache populating in background)"
+      );
+    } catch (error) {
+      clearConfig();
+      clearCache();
+      if (error instanceof APIError) {
+        throw error;
+      }
+      throw new APIError(ERROR_MESSAGES.UNKNOWN_ERROR, {
+        endpoint: "initAmplifySDK",
+        cause: error
+      });
+    } finally {
+      sdkConfig.isInitializing = false;
+      sdkConfig.initPromise = null;
+    }
+  })();
+  await sdkConfig.initPromise;
+}
+
+// src/lib/telemetry.ts
+var SDK_VERSION = "0.1.1-beta.1";
+var MAX_ERROR_BUFFER_SIZE = 10;
+var CONFIG_FETCH_TIMEOUT = 5e3;
+var telemetryState = {
+  enabled: false,
+  isInitialized: false,
+  isInitializing: false,
+  initPromise: null,
+  config: null,
+  apiKey: null
+};
+var posthogClient = null;
+var errorBuffer = [];
+var bufferFullWarningLogged = false;
+function hashApiKey(apiKey) {
+  const FNV_OFFSET = BigInt("0xcbf29ce484222325");
+  const FNV_PRIME = BigInt("0x100000001b3");
+  let hash = FNV_OFFSET;
+  for (let i = 0; i < apiKey.length; i++) {
+    hash ^= BigInt(apiKey.charCodeAt(i));
+    hash = hash * FNV_PRIME & BigInt("0xffffffffffffffff");
+  }
+  return `sdk_${hash.toString(16).slice(0, 12)}`;
+}
+async function fetchTelemetryConfig(apiKey) {
+  const endpoint = "/v1/earn-sdk/config";
+  const url = `${API_BASE_URL}${endpoint}`;
+  try {
+    const headers = getRequestHeaders();
+    if (!headers["x-api-key"]) {
+      headers["x-api-key"] = apiKey;
+    }
+    const response = await fetch(url, {
+      method: "GET",
+      headers,
+      signal: createTimeoutSignal(CONFIG_FETCH_TIMEOUT)
+    });
+    if (!response.ok) {
+      return null;
+    }
+    const data = await response.json();
+    if (!data || typeof data.posthogApiKey !== "string") {
+      return null;
+    }
+    return {
+      posthogApiKey: data.posthogApiKey,
+      posthogHost: data.posthogHost || "https://us.i.posthog.com"
+    };
+  } catch {
+    return null;
+  }
+}
+async function flushErrorBuffer() {
+  if (errorBuffer.length === 0 || !posthogClient) {
+    return;
+  }
+  for (const bufferedError of errorBuffer) {
+    const payload = {
+      error_type: bufferedError.name,
+      error_message: bufferedError.message,
+      error_code: bufferedError.code,
+      sdk_version: SDK_VERSION,
+      buffered: true,
+      ...bufferedError.context
+    };
+    posthogClient.capture("sdk_error", payload);
+  }
+  errorBuffer.length = 0;
+}
+async function initTelemetry(apiKey) {
+  if (telemetryState.isInitialized) {
+    return;
+  }
+  if (telemetryState.isInitializing && telemetryState.initPromise) {
+    await telemetryState.initPromise;
+    return;
+  }
+  telemetryState.isInitializing = true;
+  telemetryState.apiKey = apiKey;
+  telemetryState.initPromise = (async () => {
+    try {
+      const config = await fetchTelemetryConfig(apiKey);
+      if (!config) {
+        telemetryState.enabled = false;
+        telemetryState.isInitialized = true;
+        return;
+      }
+      telemetryState.config = config;
+      const posthogModule = await import('posthog-js');
+      const posthog = posthogModule.default;
+      posthog.init(config.posthogApiKey, {
+        api_host: config.posthogHost,
+        autocapture: false,
+        capture_pageview: false,
+        capture_pageleave: false,
+        disable_session_recording: true,
+        persistence: "memory",
+        // Don't persist to localStorage
+        loaded: (ph) => {
+          ph.identify(hashApiKey(apiKey));
+        }
+      });
+      posthogClient = posthog;
+      telemetryState.enabled = true;
+      telemetryState.isInitialized = true;
+      await flushErrorBuffer();
+      posthog.capture("sdk_initialized", {
+        sdk_version: SDK_VERSION
+      });
+    } catch (error) {
+      const logger = getLogger();
+      logger.warn("Telemetry initialization failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      telemetryState.enabled = false;
+      telemetryState.isInitialized = true;
+    } finally {
+      telemetryState.isInitializing = false;
+      telemetryState.initPromise = null;
+    }
+  })();
+  await telemetryState.initPromise;
+}
+function trackError(error, context) {
+  const logger = getLogger();
+  logger.error(error.message, {
+    name: error.name,
+    stack: error.stack,
+    ...context
+  });
+  const errorDetails = {
+    name: error.name,
+    message: error.message,
+    code: error.code,
+    context: context || {},
+    timestamp: Date.now()
+  };
+  if (!posthogClient || !telemetryState.enabled) {
+    if (errorBuffer.length < MAX_ERROR_BUFFER_SIZE) {
+      errorBuffer.push(errorDetails);
+    } else if (!bufferFullWarningLogged) {
+      logger.warn(
+        `Telemetry error buffer full (${MAX_ERROR_BUFFER_SIZE} errors). Additional errors will not be tracked until telemetry initializes.`
+      );
+      bufferFullWarningLogged = true;
+    }
+    return;
+  }
+  const payload = {
+    error_type: error.name,
+    error_message: error.message,
+    error_code: error.code,
+    endpoint: error.endpoint,
+    status_code: error.statusCode,
+    sdk_version: SDK_VERSION,
+    ...context
+  };
+  posthogClient.capture("sdk_error", payload);
+}
+function resetTelemetry() {
+  telemetryState.enabled = false;
+  telemetryState.isInitialized = false;
+  telemetryState.isInitializing = false;
+  telemetryState.initPromise = null;
+  telemetryState.config = null;
+  telemetryState.apiKey = null;
+  posthogClient = null;
+  errorBuffer.length = 0;
+  bufferFullWarningLogged = false;
+}
+
+// src/types/amplify-sdk-api.ts
+var APIError = class _APIError extends Error {
+  constructor(message, options) {
+    super(message);
+    /**
+     * HTTP status code (if available)
+     */
+    __publicField(this, "statusCode");
+    /**
+     * API endpoint that failed
+     */
+    __publicField(this, "endpoint");
+    /**
+     * Original error cause
+     */
+    __publicField(this, "cause");
+    this.name = "APIError";
+    this.statusCode = options?.statusCode;
+    this.endpoint = options?.endpoint;
+    this.cause = options?.cause;
+    Object.setPrototypeOf(this, _APIError.prototype);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _APIError);
+    }
+    try {
+      trackError(this, {
+        endpoint: this.endpoint,
+        statusCode: this.statusCode
+      });
+    } catch {
+    }
+  }
+};
+function isValidYieldType(value) {
+  return typeof value === "string" && (value === "CORE" || value === "TREASURY" || value === "FRONTIER");
+}
+function isValidAddress(value) {
+  return typeof value === "string" && /^0x[a-fA-F0-9]{40}$/.test(value);
+}
+function isValidChainId(value) {
+  return typeof value === "number" && value > 0 && Number.isInteger(value);
+}
+
+// src/client/graphql-client.ts
+var VAULT_FIELDS = `
+  id
+  name
+  chainId
+  isDeleted
+  inDeprecation
+  boringVaultModuleId
+  boringVaultAddress
+  rolesAuthorityModuleId
+  tellerModuleId
+  accountantModuleId
+  managerModuleId
+  withdrawQueueModuleId
+  communityCodeDepositorModuleId
+  depositFeeModuleId
+  withdrawFeeModuleId
+  enterpriseConfig {
+    predicatePolicyId
+  }
+  baseTokenAddressId
+  baseTokenStandInId
+  baseTokenStandIn {
+    decimals
+    symbol
+    coinGeckoApiId
+  }
+  withdrawalSla {
+    withdrawAssetAddress
+    externalWithdrawalQueueDelaySLA
+    externalAccountantRateUpdateSLA
+  }
+  supportedAssets {
+    address
+    chainId
+    depositable
+    withdrawable
+    symbol
+    tokenName
+    decimals
+  }
+  depositFeeConfigs {
+    feeModuleAddress
+    depositAsset
+    feePercentage
+    flatFee
+  }
+  withdrawQueueFeeConfig {
+    queueAddress
+    feeModule
+    offerFeeBps
+    offerFeeRate
+  }
+  atomicWithdrawal
+`;
+var DEPOSIT_TOKEN_FIELDS = `
+  id
+  address
+  chainId
+  name
+`;
+var TOKEN_METADATA_FIELDS = `
+  address
+  chainId
+  symbol
+  tokenName
+  decimals
+  coinGeckoTokenId
+  tokenStandard
+  source
+  firstSeenAt
+  metadataRefreshedAt
+`;
+var VAULT_ASSET_FLAGS_FIELDS = `
+  depositable
+  withdrawable
+`;
+var SDK_CONFIG_CORE_FIELDS = `
+  id
+  chainId
+  environment
+  yieldType
+  vaultId
+  depositTokenAddressId
+`;
+function buildSdkConfigsQuery(options) {
+  const nestedFields = [];
+  if (options.vault) {
+    nestedFields.push(`vault { ${options.vault} }`);
+  }
+  if (options.depositTokenAddress) {
+    nestedFields.push(`depositTokenAddress { ${options.depositTokenAddress} }`);
+  }
+  if (options.tokenMetadata) {
+    nestedFields.push(`tokenMetadata { ${options.tokenMetadata} }`);
+  }
+  if (options.vaultAssetFlags) {
+    nestedFields.push(`vaultAssetFlags { ${options.vaultAssetFlags} }`);
+  }
+  const allFields = [...options.fields, ...nestedFields].join("\n    ");
+  return `
+  query AmplifySdkConfigs(
+    $environment: Environment
+    $chainId: Int
+    $yieldType: YieldType
+  ) {
+    amplifySdkConfigs(
+      environment: $environment
+      chainId: $chainId
+      yieldType: $yieldType
+    ) {
+      ${allFields}
+    }
+  }
+`;
+}
+async function executeGraphQLQuery(endpoint, query, variables) {
+  const headers = getRequestHeaders();
+  let response;
+  try {
+    response = await fetch(endpoint, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ query, variables }),
+      signal: createTimeoutSignal(DEFAULT_TIMEOUT)
+    });
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new APIError("GraphQL request timed out", {
+        endpoint,
+        cause: error
+      });
+    }
+    throw new APIError(
+      `GraphQL network error: ${error instanceof Error ? error.message : String(error)}`,
+      { endpoint, cause: error }
+    );
+  }
+  if (!response.ok) {
+    throw new APIError(
+      `GraphQL HTTP error: ${response.status} ${response.statusText}`,
+      { endpoint, statusCode: response.status }
+    );
+  }
+  let body;
+  try {
+    body = await response.json();
+  } catch (error) {
+    throw new APIError("GraphQL response is not valid JSON", {
+      endpoint,
+      cause: error
+    });
+  }
+  if (body.errors && body.errors.length > 0) {
+    const messages = body.errors.map((e) => e.message).join("; ");
+    throw new APIError(`GraphQL errors: ${messages}`, {
+      endpoint,
+      cause: body.errors
+    });
+  }
+  if (!body.data) {
+    throw new APIError("GraphQL response missing data field", { endpoint });
+  }
+  return body.data;
+}
+async function fetchAmplifySdkConfigs(endpoint, variables) {
+  const query = buildSdkConfigsQuery({
+    fields: SDK_CONFIG_CORE_FIELDS.trim().split(/\s+/),
+    vault: VAULT_FIELDS,
+    depositTokenAddress: DEPOSIT_TOKEN_FIELDS,
+    tokenMetadata: TOKEN_METADATA_FIELDS,
+    vaultAssetFlags: VAULT_ASSET_FLAGS_FIELDS
+  });
+  return executeGraphQLQuery(
+    endpoint,
+    query,
+    variables
+  );
+}
+
+// src/constants/config.ts
+var YieldType = {
+  CORE: "CORE",
+  TREASURY: "TREASURY",
+  FRONTIER: "FRONTIER"
+};
+var DEFAULT_SLIPPAGE_BPS = 50;
+
+// src/client/graphql-mapper.ts
+function mapYieldType(graphqlYieldType) {
+  switch (graphqlYieldType) {
+    case "CORE":
+    case "PRIME":
+      return YieldType.CORE;
+    case "TREASURY":
+    case "TBILL":
+      return YieldType.TREASURY;
+    case "FRONTIER":
+    case "LENDING":
+      return YieldType.FRONTIER;
+    default: {
+      const logger = getLogger();
+      logger.warn(`Unknown GraphQL yield type: ${graphqlYieldType}, skipping`);
+      return null;
+    }
+  }
+}
+function mapGraphQLConfigToVault(config) {
+  if (!config.vault || !config.depositTokenAddress) {
+    return null;
+  }
+  const yieldType = mapYieldType(config.yieldType);
+  if (!yieldType) {
+    return null;
+  }
+  const { vault, depositTokenAddress } = config;
+  const indexerAssets = vault.supportedAssets && vault.supportedAssets.length > 0 ? vault.supportedAssets.map((a) => ({
+    address: a.address,
+    chainId: a.chainId,
+    symbol: a.symbol ?? a.address,
+    name: a.tokenName ?? a.symbol ?? a.address,
+    decimals: a.decimals ?? 0,
+    depositable: a.depositable,
+    withdrawable: a.withdrawable
+  })) : [
+    {
+      address: depositTokenAddress.address,
+      symbol: config.tokenMetadata?.symbol ?? depositTokenAddress.name,
+      name: config.tokenMetadata?.tokenName ?? depositTokenAddress.name,
+      decimals: config.tokenMetadata?.decimals ?? 0,
+      ...config.vaultAssetFlags && {
+        depositable: config.vaultAssetFlags.depositable,
+        withdrawable: config.vaultAssetFlags.withdrawable
+      }
+    }
+  ];
+  return {
+    id: config.id,
+    chainId: config.chainId,
+    yieldType,
+    name: vault.name,
+    inDeprecation: vault.inDeprecation,
+    vault: {
+      boringVaultAddress: vault.boringVaultAddress,
+      tellerAddress: vault.tellerModuleId,
+      accountantAddress: vault.accountantModuleId,
+      managerAddress: vault.managerModuleId,
+      rolesAuthorityAddress: vault.rolesAuthorityModuleId,
+      baseTokenAddress: vault.baseTokenAddressId,
+      baseTokenStandIn: vault.baseTokenStandInId ? vault.baseTokenStandInId : void 0,
+      withdrawQueueAddress: vault.withdrawQueueModuleId ? vault.withdrawQueueModuleId : void 0,
+      communityCodeDepositorAddress: vault.communityCodeDepositorModuleId ? vault.communityCodeDepositorModuleId : void 0,
+      depositFeeModuleAddress: vault.depositFeeModuleId ? vault.depositFeeModuleId : void 0,
+      withdrawFeeModuleAddress: vault.withdrawFeeModuleId ? vault.withdrawFeeModuleId : void 0
+    },
+    atomicWithdrawal: vault.atomicWithdrawal ?? false,
+    enterpriseConfig: vault.enterpriseConfig ? { predicatePolicyId: vault.enterpriseConfig.predicatePolicyId } : void 0,
+    supportedAssets: indexerAssets,
+    sla: vault.withdrawalSla && vault.withdrawalSla.length > 0 ? {
+      externalWithdrawalQueueDelaySLA: vault.withdrawalSla[0].externalWithdrawalQueueDelaySLA,
+      externalAccountantRateUpdateSLA: vault.withdrawalSla[0].externalAccountantRateUpdateSLA
+    } : void 0,
+    depositFees: (() => {
+      const configs = vault.depositFeeConfigs ?? [];
+      if (configs.length > 0) {
+        return {
+          hasFees: true,
+          feeModuleAddress: configs[0].feeModuleAddress,
+          fees: configs.map((fc) => ({
+            depositAsset: fc.depositAsset ? fc.depositAsset : null,
+            feePercentage: BigInt(fc.feePercentage ?? "0"),
+            flatFee: BigInt(fc.flatFee ?? "0")
+          }))
+        };
+      }
+      if (vault.depositFeeModuleId) {
+        return {
+          hasFees: false,
+          feeModuleAddress: vault.depositFeeModuleId,
+          fees: []
+        };
+      }
+      return void 0;
+    })(),
+    withdrawFees: vault.withdrawQueueFeeConfig && (vault.withdrawQueueFeeConfig.feeModule != null || vault.withdrawQueueFeeConfig.offerFeeBps != null || vault.withdrawQueueFeeConfig.offerFeeRate != null) ? {
+      hasFees: true,
+      feeModuleAddress: vault.withdrawQueueFeeConfig.feeModule || vault.withdrawFeeModuleId || null,
+      offerFeeBps: vault.withdrawQueueFeeConfig.offerFeeBps != null ? BigInt(vault.withdrawQueueFeeConfig.offerFeeBps) : 0n,
+      offerFeeRate: BigInt(
+        vault.withdrawQueueFeeConfig.offerFeeRate ?? "0"
+      )
+    } : vault.withdrawFeeModuleId ? {
+      hasFees: false,
+      feeModuleAddress: vault.withdrawFeeModuleId,
+      offerFeeBps: 0n,
+      offerFeeRate: 0n
+    } : void 0
+  };
+}
+function aggregateVaultConfigs(configs) {
+  const vaultMap = /* @__PURE__ */ new Map();
+  for (const config of configs) {
+    if (!config.vault || !config.depositTokenAddress) continue;
+    if (vaultMap.has(config.vaultId)) continue;
+    const mapped = mapGraphQLConfigToVault(config);
+    if (mapped) {
+      vaultMap.set(config.vaultId, mapped);
+    }
+  }
+  return Array.from(vaultMap.values());
+}
+function extractSupportedAssetsFromConfigs(configs) {
+  const assetMap = /* @__PURE__ */ new Map();
+  for (const config of configs) {
+    if (!config.depositTokenAddress) continue;
+    const key = config.depositTokenAddress.address.toLowerCase();
+    const existing = assetMap.get(key);
+    if (existing) {
+      existing.chains.add(config.chainId);
+      if (existing.decimals === 0 && config.tokenMetadata?.decimals) {
+        existing.decimals = config.tokenMetadata.decimals;
+        existing.symbol = config.tokenMetadata.symbol ?? existing.symbol;
+        existing.name = config.tokenMetadata.tokenName ?? existing.name;
+      }
+    } else {
+      assetMap.set(key, {
+        address: config.depositTokenAddress.address,
+        symbol: config.tokenMetadata?.symbol ?? config.depositTokenAddress.name,
+        name: config.tokenMetadata?.tokenName ?? config.depositTokenAddress.name,
+        decimals: config.tokenMetadata?.decimals ?? 0,
+        chains: /* @__PURE__ */ new Set([config.chainId])
+      });
+    }
+  }
+  return Array.from(assetMap.values()).map((asset) => ({
+    address: asset.address,
+    symbol: asset.symbol,
+    name: asset.name,
+    decimals: asset.decimals,
+    chains: Array.from(asset.chains)
+  }));
+}
+
+// src/client/amplify-sdk-client.ts
+function validateVaultFilterOptions(options) {
+  if (!options) return;
+  if (options.chainId !== void 0 && !isValidChainId(options.chainId)) {
+    throw new APIError(
+      `Invalid chainId: ${options.chainId}. Must be a positive integer.`,
+      { endpoint: "/v1/earn-sdk/vaults" }
+    );
+  }
+  if (options.yieldType !== void 0 && !isValidYieldType(options.yieldType)) {
+    throw new APIError(
+      `Invalid yieldType: ${options.yieldType}. Must be one of: CORE, TREASURY, FRONTIER.`,
+      { endpoint: "/v1/earn-sdk/vaults" }
+    );
+  }
+  if (options.depositTokenAddress !== void 0 && !isValidAddress(options.depositTokenAddress)) {
+    throw new APIError(
+      `Invalid depositTokenAddress: ${options.depositTokenAddress}. Must be a valid Ethereum address.`,
+      { endpoint: "/v1/earn-sdk/vaults" }
+    );
+  }
+}
+function validateAssetFilterOptions(options) {
+  if (!options) return;
+  if (options.chains !== void 0) {
+    if (!Array.isArray(options.chains) || options.chains.length === 0) {
+      throw new APIError(
+        "Invalid chains: Must be a non-empty array of chain IDs.",
+        { endpoint: "/v1/earn-sdk/supported-assets-by-chains" }
+      );
+    }
+    for (const chainId of options.chains) {
+      if (!isValidChainId(chainId)) {
+        throw new APIError(
+          `Invalid chainId in chains array: ${chainId}. Must be a positive integer.`,
+          { endpoint: "/v1/earn-sdk/supported-assets-by-chains" }
+        );
+      }
+    }
+  }
+  if (options.yieldType !== void 0 && !isValidYieldType(options.yieldType)) {
+    throw new APIError(
+      `Invalid yieldType: ${options.yieldType}. Must be one of: CORE, TREASURY, FRONTIER.`,
+      { endpoint: "/v1/earn-sdk/supported-assets-by-chains" }
+    );
+  }
+  if (options.address !== void 0 && !isValidAddress(options.address)) {
+    throw new APIError(
+      `Invalid address: ${options.address}. Must be a valid Ethereum address.`,
+      { endpoint: "/v1/earn-sdk/supported-assets-by-chains" }
+    );
+  }
+  if (options.symbol !== void 0 && typeof options.symbol !== "string") {
+    throw new APIError(`Invalid symbol: ${options.symbol}. Must be a string.`, {
+      endpoint: "/v1/earn-sdk/supported-assets-by-chains"
+    });
+  }
+}
+async function fetchVaultDataFromGraphQL() {
+  const endpoint = getGraphQLEndpoint();
+  const response = await fetchAmplifySdkConfigs(endpoint);
+  const configs = response.amplifySdkConfigs;
+  const vaults = aggregateVaultConfigs(configs);
+  const assets = extractSupportedAssetsFromConfigs(configs);
+  let enrichedVaults = vaults;
+  try {
+    enrichedVaults = await enrichVaultsWithSupplyCapsAndFees(vaults);
+  } catch (err) {
+    getLogger().debug(
+      `enrichVaultsWithSupplyCapsAndFees failed for ${vaults.length} vault(s)`,
+      { error: err instanceof Error ? err.message : String(err) }
+    );
+  }
+  return { vaults: enrichedVaults, assets };
+}
+function applyVaultFilters(vaults, options) {
+  if (!options) return vaults;
+  let filtered = vaults;
+  if (options.chainId !== void 0) {
+    filtered = filtered.filter((v) => v.chainId === options.chainId);
+  }
+  if (options.yieldType) {
+    filtered = filtered.filter((v) => v.yieldType === options.yieldType);
+  }
+  if (options.depositTokenAddress) {
+    const normalized = options.depositTokenAddress.toLowerCase();
+    filtered = filtered.filter(
+      (v) => v.supportedAssets.some((a) => a.address.toLowerCase() === normalized)
+    );
+  }
+  return filtered;
+}
+function applyAssetFilters(assets, options) {
+  if (!options) return assets;
+  let filtered = assets;
+  if (options.chains !== void 0 && options.chains.length > 0) {
+    filtered = filtered.filter(
+      (asset) => options.chains?.some((chainId) => asset.chains.includes(chainId))
+    );
+  }
+  if (options.address) {
+    const normalizedAddress = options.address.toLowerCase();
+    filtered = filtered.filter(
+      (asset) => asset.address.toLowerCase() === normalizedAddress
+    );
+  }
+  if (options.symbol) {
+    filtered = filtered.filter((asset) => asset.symbol === options.symbol);
+  }
+  return filtered;
+}
+async function getVaults(options) {
+  validateVaultFilterOptions(options);
+  const cache = getCache();
+  if (cache.isEmpty() || cache.isExpired()) {
+    await cache.refresh();
+  }
+  return applyVaultFilters(cache.getAllVaults(), options);
+}
+async function getSupportedAssets(options) {
+  validateAssetFilterOptions(options);
+  const cache = getCache();
+  if (cache.isEmpty() || cache.isExpired()) {
+    await cache.refresh();
+  }
+  return applyAssetFilters(cache.getAllAssets(), options);
+}
+var globalCache = null;
+function initializeCache(ttl) {
+  globalCache = new VaultCache(ttl);
+  return globalCache;
+}
+function getCache() {
+  if (!globalCache) {
+    globalCache = new VaultCache();
+  }
+  return globalCache;
+}
+async function refreshVaultCache() {
+  const cache = getCache();
+  await cache.refresh();
+}
+function clearCache() {
+  const cache = getCache();
+  cache.clear();
+}
+async function getAssetsFromCache(options) {
+  return getSupportedAssets(options);
+}
+async function findVaultByConfig(params) {
+  if (!isValidAddress(params.assetAddress)) {
+    throw new APIError(
+      `Invalid assetAddress: ${params.assetAddress}. Must be a valid Ethereum address.`,
+      { endpoint: "findVaultByConfig" }
+    );
+  }
+  if (!isValidYieldType(params.yieldType)) {
+    throw new APIError(
+      `Invalid yieldType: ${params.yieldType}. Must be one of: CORE, TREASURY, FRONTIER.`,
+      { endpoint: "findVaultByConfig" }
+    );
+  }
+  if (!isValidChainId(params.chainId)) {
+    throw new APIError(
+      `Invalid chainId: ${params.chainId}. Must be a positive integer.`,
+      { endpoint: "findVaultByConfig" }
+    );
+  }
+  const cache = getCache();
+  if (cache.isEmpty() || cache.isExpired()) {
+    await cache.refresh();
+  }
+  const normalizedAddress = params.assetAddress.toLowerCase();
+  let vaultsByToken = cache.getVault(params.assetAddress);
+  if (!vaultsByToken) {
+    vaultsByToken = cache.getVault(normalizedAddress);
+  }
+  if (!vaultsByToken) {
+    const allVaults = cache.getAllVaults();
+    const matchingVaults = allVaults.filter(
+      (vault) => vault.supportedAssets.some(
+        (a) => a.address.toLowerCase() === normalizedAddress
+      )
+    );
+    vaultsByToken = matchingVaults.length > 0 ? matchingVaults : void 0;
+  }
+  if (!vaultsByToken || vaultsByToken.length === 0) {
+    return null;
+  }
+  const matchingVault = vaultsByToken.find(
+    (vault) => vault.yieldType === params.yieldType && vault.chainId === params.chainId
+  );
+  return matchingVault || null;
+}
+async function getVaultsByConfig(params) {
+  const cache = getCache();
+  if (cache.isEmpty() || cache.isExpired()) {
+    await cache.refresh();
+  }
+  let vaults = cache.getAllVaults();
+  if (params?.yieldType) {
+    if (!isValidYieldType(params.yieldType)) {
+      throw new APIError(
+        `Invalid yieldType: ${params.yieldType}. Must be one of: CORE, TREASURY, FRONTIER.`,
+        { endpoint: "getVaultsByConfig" }
+      );
+    }
+    vaults = vaults.filter((v) => v.yieldType === params.yieldType);
+  }
+  if (params?.chainId !== void 0) {
+    if (!isValidChainId(params.chainId)) {
+      throw new APIError(
+        `Invalid chainId: ${params.chainId}. Must be a positive integer.`,
+        { endpoint: "getVaultsByConfig" }
+      );
+    }
+    vaults = vaults.filter((v) => v.chainId === params.chainId);
+  }
+  if (params?.depositAssetAddress) {
+    if (!isValidAddress(params.depositAssetAddress)) {
+      throw new APIError(
+        `Invalid depositAssetAddress: ${params.depositAssetAddress}.`,
+        { endpoint: "getVaultsByConfig" }
+      );
+    }
+    const normalized = params.depositAssetAddress.toLowerCase();
+    vaults = vaults.filter(
+      (v) => v.supportedAssets.some((a) => a.address.toLowerCase() === normalized)
+    );
+  }
+  if (params?.withdrawAssetAddress) {
+    if (!isValidAddress(params.withdrawAssetAddress)) {
+      throw new APIError(
+        `Invalid withdrawAssetAddress: ${params.withdrawAssetAddress}.`,
+        { endpoint: "getVaultsByConfig" }
+      );
+    }
+    const normalized = params.withdrawAssetAddress.toLowerCase();
+    vaults = vaults.filter(
+      (v) => v.supportedAssets.some(
+        (a) => a.withdrawable !== false && a.address.toLowerCase() === normalized
+      )
+    );
+  }
+  if (params?.settlementAssetAddress) {
+    if (!isValidAddress(params.settlementAssetAddress)) {
+      throw new APIError(
+        `Invalid settlementAssetAddress: ${params.settlementAssetAddress}.`,
+        { endpoint: "getVaultsByConfig" }
+      );
+    }
+    const normalized = params.settlementAssetAddress.toLowerCase();
+    vaults = vaults.filter(
+      (v) => v.supportedAssets.some((a) => a.address.toLowerCase() === normalized)
+    );
+  }
+  return vaults;
+}
+async function getWithdrawSupportedAssets() {
+  const cache = getCache();
+  if (cache.isEmpty() || cache.isExpired()) {
+    await cache.refresh();
+  }
+  const vaults = cache.getAllVaults();
+  const assets = cache.getAllAssets();
+  const result = [];
+  const assetMap = /* @__PURE__ */ new Map();
+  for (const asset of assets) {
+    assetMap.set(asset.address.toLowerCase(), asset);
+  }
+  const assetVaultMap = /* @__PURE__ */ new Map();
+  for (const vault of vaults) {
+    for (const asset of vault.supportedAssets) {
+      const assetAddress = asset.address.toLowerCase();
+      if (!assetVaultMap.has(assetAddress)) {
+        assetVaultMap.set(assetAddress, []);
+      }
+      assetVaultMap.get(assetAddress)?.push({
+        id: vault.id,
+        yieldType: vault.yieldType,
+        chainId: vault.chainId,
+        vaultId: vault.id
+      });
+    }
+  }
+  for (const [assetAddress, vaultsData] of assetVaultMap.entries()) {
+    const asset = assetMap.get(assetAddress);
+    if (asset) {
+      result.push({
+        address: asset.address,
+        symbol: asset.symbol,
+        decimals: asset.decimals,
+        vaults: vaultsData
+      });
+    }
+  }
+  return result;
+}
+var hyperEvm = viem.defineChain({
+  id: 999,
+  name: "HyperEVM",
+  nativeCurrency: {
+    decimals: 18,
+    name: "Hyperliquid",
+    symbol: "HYPE"
+  },
+  rpcUrls: {
+    default: {
+      http: ["https://rpc.hyperliquid.xyz/evm"],
+      webSocket: ["wss://hyperliquid.drpc.org"]
+    }
+  },
+  blockExplorers: {
+    default: { name: "Explorer", url: "https://purrsec.com/" }
+  },
+  contracts: {
+    multicall3: {
+      address: "0xcA11bde05977b3631167028862bE2a173976CA11",
+      blockCreated: 13051
+    }
+  }
+});
+var stableTestnet = viem.defineChain({
+  id: 2201,
+  name: "Stable Testnet",
+  nativeCurrency: {
+    decimals: 18,
+    name: "Ether",
+    symbol: "ETH"
+  },
+  rpcUrls: {
+    default: {
+      http: ["https://rpc.testnet.stable.xyz"]
+    }
+  },
+  blockExplorers: {
+    default: { name: "Stablescan", url: "https://testnet.stablescan.xyz" }
+  },
+  contracts: {
+    multicall3: {
+      address: "0xcA11bde05977b3631167028862bE2a173976CA11",
+      blockCreated: 0
+    }
+  },
+  testnet: true
+});
+var CHAIN_ID_TO_CHAIN_MAP = {
+  [chains.mainnet.id]: chains.mainnet,
+  [chains.sepolia.id]: chains.sepolia,
+  [chains.base.id]: chains.base,
+  [hyperEvm.id]: hyperEvm,
+  [stableTestnet.id]: stableTestnet,
+  [chains.baseSepolia.id]: chains.baseSepolia
+};
+
+// src/utils/chain-utils.ts
+function toChainId(value) {
+  return typeof value === "number" ? value : Number(value);
+}
+var chainsCache = null;
+async function getChainFromConfig(chainId, config) {
+  if (chainsCache && !config) {
+    const chain2 = chainsCache.get(Number(chainId));
+    if (chain2) {
+      return chain2;
+    }
+  }
+  const vaults = config ?? await getVaults();
+  const numericChainId = Number(chainId);
+  const knownChain = CHAIN_ID_TO_CHAIN_MAP[numericChainId];
+  const vaultForChain = vaults.find((v) => v.chainId === numericChainId);
+  if (!knownChain && !vaultForChain) {
+    throw new Error(`Vault not found for ID: ${chainId}`);
+  }
+  if (config && !chainsCache) {
+    const cache = /* @__PURE__ */ new Map();
+    for (const v of vaults) {
+      const chainConfig = CHAIN_ID_TO_CHAIN_MAP[v.chainId];
+      if (!chainConfig) {
+        throw new Error(`Chain config not found for ID: ${v.chainId}`);
+      }
+      cache.set(v.chainId, {
+        id: v.chainId,
+        name: chainConfig.name,
+        nativeCurrency: chainConfig.nativeCurrency,
+        rpcUrls: chainConfig.rpcUrls,
+        contracts: chainConfig.contracts
+      });
+    }
+    if (knownChain && !cache.has(numericChainId)) {
+      cache.set(numericChainId, {
+        id: numericChainId,
+        name: knownChain.name,
+        nativeCurrency: knownChain.nativeCurrency,
+        rpcUrls: knownChain.rpcUrls,
+        contracts: knownChain.contracts
+      });
+    }
+    chainsCache = cache;
+  }
+  const chain = chainsCache ? chainsCache.get(numericChainId) : void 0;
+  if (!chain) {
+    throw new Error(`Chain not found for ID: ${chainId}`);
+  }
+  return chain;
+}
+function getChainNameById(chainId) {
+  return CHAIN_ID_TO_CHAIN_MAP[chainId]?.name || null;
+}
+function clearChainsCache() {
+  chainsCache = null;
+}
+
+// src/lib/viem/client.ts
+var clients = /* @__PURE__ */ new Map();
+var directClients = /* @__PURE__ */ new Map();
+var warnedChains = /* @__PURE__ */ new Set();
+var getClient = async (chainId) => {
+  if (!chainId) {
+    throw new Error("Chain ID is required");
+  }
+  const numericChainId = toChainId(chainId);
+  if (!clients.has(numericChainId)) {
+    const chain = await getChainFromConfig(numericChainId, await getVaults());
+    const customRpcUrl = getRpcUrls()[numericChainId];
+    if (!customRpcUrl && !warnedChains.has(numericChainId)) {
+      warnedChains.add(numericChainId);
+      getLogger().warn(
+        `No custom RPC URL provided for chain ${numericChainId} (${chain.name}). Using default public RPC. Public RPCs may be unreliable \u2014 pass rpcUrls in initAmplifySDK() options for better reliability.`
+      );
+    }
+    const rpcUrl = customRpcUrl ?? chain.rpcUrls.default.http[0];
+    const client2 = viem.createPublicClient({
+      chain,
+      transport: viem.http(rpcUrl)
+    });
+    clients.set(numericChainId, client2);
+  }
+  const client = clients.get(numericChainId);
+  if (!client) {
+    throw new Error(`Client not found for chain ID ${chainId}`);
+  }
+  return client;
+};
+var getClientDirect = async (chainId) => {
+  if (!chainId) {
+    throw new Error("Chain ID is required");
+  }
+  const numericChainId = toChainId(chainId);
+  if (!directClients.has(numericChainId)) {
+    const chain = CHAIN_ID_TO_CHAIN_MAP[numericChainId];
+    if (!chain) {
+      throw new Error(`Chain config not found for ID: ${numericChainId}`);
+    }
+    const customRpcUrl = getRpcUrls()[numericChainId];
+    if (!customRpcUrl && !warnedChains.has(numericChainId)) {
+      warnedChains.add(numericChainId);
+      getLogger().warn(
+        `No custom RPC URL provided for chain ${numericChainId} (${chain.name}). Using default public RPC. Public RPCs may be unreliable \u2014 pass rpcUrls in initAmplifySDK() options for better reliability.`
+      );
+    }
+    const rpcUrl = customRpcUrl ?? chain.rpcUrls.default.http[0];
+    const client2 = viem.createPublicClient({
+      chain,
+      transport: viem.http(rpcUrl)
+    });
+    directClients.set(numericChainId, client2);
+  }
+  const client = directClients.get(numericChainId);
+  if (!client) {
+    throw new Error(`Client not found for chain ID ${chainId}`);
+  }
+  return client;
+};
+function clearClients() {
+  clients.clear();
+  directClients.clear();
+  warnedChains.clear();
+}
+
+// src/api/fees-and-supply-cap.ts
+async function readSupplyCapInBase(dcdAddress, chainId) {
+  const client = await getClientDirect(chainId);
+  const result = await client.readContract({
+    abi: DistributorCodeDepositorAbiV0,
+    address: dcdAddress,
+    functionName: "supplyCapInBase"
+  });
+  return result;
+}
+async function readFeeModuleFromDCD(dcdAddress, chainId) {
+  try {
+    const client = await getClientDirect(chainId);
+    const result = await client.readContract({
+      abi: DistributorCodeDepositorAbiV0,
+      address: dcdAddress,
+      functionName: "feeModule"
+    });
+    return result || viem.zeroAddress;
+  } catch {
+    return viem.zeroAddress;
+  }
+}
+async function readDepositFeeStructure(feeModuleAddress, depositAsset, chainId) {
+  const client = await getClientDirect(chainId);
+  const results = await client.multicall({
+    contracts: [
+      {
+        abi: DCDAssetSpecificFeeModuleAbi,
+        address: feeModuleAddress,
+        functionName: "depositTokenFeeData",
+        args: [depositAsset]
+      },
+      {
+        abi: DCDAssetSpecificFeeModuleAbi,
+        address: feeModuleAddress,
+        functionName: "ONE_HUNDRED_PERCENT"
+      }
+    ]
+  });
+  const [feeDataResult, oneHundredPercentResult] = results;
+  if (feeDataResult.status === "failure" || oneHundredPercentResult.status === "failure") {
+    throw new Error(
+      "Failed to read fee data from fee module contract: RPC call failed"
+    );
+  }
+  const [feePercentage, flatFee] = feeDataResult.result;
+  const oneHundredPercent = oneHundredPercentResult.result;
+  return { feePercentage, flatFee, oneHundredPercent };
+}
+async function readOneHundredPercent(feeModuleAddress, chainId) {
+  const client = await getClientDirect(chainId);
+  const result = await client.readContract({
+    abi: DCDAssetSpecificFeeModuleAbi,
+    address: feeModuleAddress,
+    functionName: "ONE_HUNDRED_PERCENT"
+  });
+  return result;
+}
+async function readWithdrawFeePercentage(withdrawQueueAddress, chainId) {
+  const client = await getClientDirect(chainId);
+  const feeModuleAddress = await client.readContract({
+    abi: WithdrawQueueAbi,
+    address: withdrawQueueAddress,
+    functionName: "feeModule"
+  });
+  if (!feeModuleAddress || feeModuleAddress === viem.zeroAddress) {
+    return null;
+  }
+  const result = await client.readContract({
+    abi: FeeModuleAbi,
+    address: feeModuleAddress,
+    functionName: "offerFeePercentage"
+  });
+  return {
+    feeModuleAddress,
+    offerFeePercentage: result
+  };
+}
+async function enrichVaultsWithSupplyCapsAndFees(vaults) {
+  const enrichmentPromises = vaults.map(async (vault) => {
+    const enriched = { ...vault };
+    if (vault.vault.communityCodeDepositorAddress && vault.vault.depositFeeModuleAddress) {
+      try {
+        const supplyCapInBase = await readSupplyCapInBase(
+          vault.vault.communityCodeDepositorAddress,
+          vault.chainId
+        );
+        enriched.depositCap = {
+          supplyCapInBase,
+          hasDepositCap: supplyCapInBase !== 0n && supplyCapInBase !== viem.maxUint256
+        };
+      } catch {
+      }
+    }
+    const depositFeeModuleAddr = vault.vault.depositFeeModuleAddress;
+    if (depositFeeModuleAddr && depositFeeModuleAddr !== viem.zeroAddress) {
+      if (!vault.depositFees?.hasFees || vault.depositFees.fees.length === 0) {
+        const defaultFees = vault.supportedAssets.filter((a) => a.depositable !== false).map((a) => ({
+          depositAsset: a.address,
+          feePercentage: 0n,
+          flatFee: 0n
+        }));
+        enriched.depositFees = {
+          hasFees: true,
+          feeModuleAddress: depositFeeModuleAddr,
+          fees: defaultFees
+        };
+      }
+      if (!enriched.depositFees?.oneHundredPercent) {
+        try {
+          const oneHundredPercentFromFeeModule = await readOneHundredPercent(
+            depositFeeModuleAddr,
+            vault.chainId
+          );
+          enriched.depositFees = {
+            ...enriched.depositFees,
+            oneHundredPercent: oneHundredPercentFromFeeModule
+          };
+        } catch {
+        }
+      }
+    }
+    const wfAddr = vault.vault.withdrawFeeModuleAddress;
+    if (wfAddr && wfAddr !== viem.zeroAddress) {
+      if (!vault.withdrawFees?.hasFees) {
+        enriched.withdrawFees = {
+          hasFees: true,
+          feeModuleAddress: wfAddr,
+          offerFeeBps: 0n,
+          offerFeeRate: 0n
+        };
+      } else if (!enriched.withdrawFees?.feeModuleAddress) {
+        enriched.withdrawFees = {
+          ...enriched.withdrawFees,
+          feeModuleAddress: wfAddr
+        };
+      }
+    }
+    return enriched;
+  });
+  return Promise.all(enrichmentPromises);
+}
+
+exports.APIError = APIError;
+exports.API_BASE_URL = API_BASE_URL;
+exports.CHAINLINK_ADDRESS = CHAINLINK_ADDRESS;
+exports.DEFAULT_APPROVAL_AMOUNT = DEFAULT_APPROVAL_AMOUNT;
+exports.DEFAULT_DEADLINE = DEFAULT_DEADLINE;
+exports.DEFAULT_SLIPPAGE_BPS = DEFAULT_SLIPPAGE_BPS;
+exports.DEFAULT_TIMEOUT = DEFAULT_TIMEOUT;
+exports.DistributorCodeDepositorAbiV0 = DistributorCodeDepositorAbiV0;
+exports.FeeModuleAbi = FeeModuleAbi;
+exports.LogLevel = LogLevel;
+exports.WithdrawQueueAbi = WithdrawQueueAbi;
+exports.YieldType = YieldType;
+exports.__publicField = __publicField;
+exports.clearChainsCache = clearChainsCache;
+exports.createTimeoutSignal = createTimeoutSignal;
+exports.enrichVaultsWithSupplyCapsAndFees = enrichVaultsWithSupplyCapsAndFees;
+exports.findVaultByConfig = findVaultByConfig;
+exports.getAssetsFromCache = getAssetsFromCache;
+exports.getCache = getCache;
+exports.getChainFromConfig = getChainFromConfig;
+exports.getChainNameById = getChainNameById;
+exports.getClient = getClient;
+exports.getLogger = getLogger;
+exports.getRequestHeaders = getRequestHeaders;
+exports.getRestV2BaseURL = getRestV2BaseURL;
+exports.getSupportedAssets = getSupportedAssets;
+exports.getVaults = getVaults;
+exports.getVaultsByConfig = getVaultsByConfig;
+exports.getWithdrawSupportedAssets = getWithdrawSupportedAssets;
+exports.initAmplifySDK = initAmplifySDK;
+exports.initializeCache = initializeCache;
+exports.isCacheReady = isCacheReady;
+exports.isValidAddress = isValidAddress;
+exports.isValidChainId = isValidChainId;
+exports.readDepositFeeStructure = readDepositFeeStructure;
+exports.readFeeModuleFromDCD = readFeeModuleFromDCD;
+exports.readSupplyCapInBase = readSupplyCapInBase;
+exports.readWithdrawFeePercentage = readWithdrawFeePercentage;
+exports.refreshVaultCache = refreshVaultCache;
+exports.setLogLevel = setLogLevel;
+exports.setLogger = setLogger;
+exports.toChainId = toChainId;
+exports.waitForCacheReady = waitForCacheReady;
+//# sourceMappingURL=chunk-GOJQYEJQ.js.map
+//# sourceMappingURL=chunk-GOJQYEJQ.js.map