@paxoslabs/amplify-sdk 0.4.2 → 0.4.3-alpha.1

package/dist/{chunk-BQG3XKTU.js → chunk-PKGFLHZA.js}

@@ -3,6 +3,14 @@
 var viem = require('viem');
 var chains = require('viem/chains');
 
+// src/utils/fetch.ts
+var DEFAULT_TIMEOUT = 1e4;
+function createTimeoutSignal(timeoutMs) {
+  const controller = new AbortController();
+  setTimeout(() => controller.abort(), timeoutMs);
+  return controller.signal;
+}
+
 // src/types/telemetry.ts
 var LogLevel = {
   DEBUG: 0,
@@ -80,16 +88,8 @@ function setLogLevel(level) {
   }
 }
 
-// src/utils/fetch.ts
-var DEFAULT_TIMEOUT = 1e4;
-function createTimeoutSignal(timeoutMs) {
-  const controller = new AbortController();
-  setTimeout(() => controller.abort(), timeoutMs);
-  return controller.signal;
-}
-
 // src/constants/environment.ts
-var BASE_URL = "https://api.paxoslabs.com";
+var BASE_URL = "https://paxos-labs-monorepo.onrender.com";
 function getGraphQLEndpoint() {
   return `${BASE_URL}/graphql`;
 }
@@ -108,6 +108,8 @@ var VaultCache = class {
   constructor(ttl = DEFAULT_TTL) {
     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;
@@ -124,6 +126,20 @@ var VaultCache = class {
   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
    *
@@ -145,9 +161,15 @@ var VaultCache = class {
    * @returns Array of all AmplifyVault objects
    */
   getAllVaults() {
+    const seen = /* @__PURE__ */ new Set();
     const allVaults = [];
     for (const vaultArray of this.vaults.values()) {
-      allVaults.push(...vaultArray);
+      for (const vault of vaultArray) {
+        if (!seen.has(vault.id)) {
+          seen.add(vault.id);
+          allVaults.push(vault);
+        }
+      }
     }
     return allVaults;
   }
@@ -224,13 +246,26 @@ var VaultCache = class {
     const { vaults, assets } = await fetchVaultDataFromGraphQL();
     this.vaults.clear();
     this.assets.clear();
+    this.vaultsByAddress.clear();
+    this.vaultsByName.clear();
     for (const vault of vaults) {
-      const tokenAddress = vault.vault.baseTokenAddress;
-      const existing = this.vaults.get(tokenAddress);
-      if (existing) {
-        existing.push(vault);
-      } else {
-        this.vaults.set(tokenAddress, [vault]);
+      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) {
@@ -255,6 +290,8 @@ var VaultCache = class {
   clear() {
     this.vaults.clear();
     this.assets.clear();
+    this.vaultsByAddress.clear();
+    this.vaultsByName.clear();
     this.lastFetch = 0;
   }
   /**
@@ -506,6 +543,20 @@ var VAULT_FIELDS = `
     symbol
     coinGeckoApiId
   }
+  withdrawalSla {
+    withdrawAssetAddress
+    externalWithdrawalQueueDelaySLA
+    externalAccountantRateUpdateSLA
+  }
+  supportedAssets {
+    address
+    chainId
+    depositable
+    withdrawable
+    symbol
+    tokenName
+    decimals
+  }
 `;
 var DEPOSIT_TOKEN_FIELDS = `
   id
@@ -513,6 +564,22 @@ var DEPOSIT_TOKEN_FIELDS = `
   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
@@ -531,6 +598,16 @@ function buildSdkConfigsQuery(options) {
       `depositTokenAddress { ${options.depositTokenAddress} }`
     );
   }
+  if (options.tokenMetadata) {
+    nestedFields.push(
+      `tokenMetadata { ${options.tokenMetadata} }`
+    );
+  }
+  if (options.vaultAssetFlags) {
+    nestedFields.push(
+      `vaultAssetFlags { ${options.vaultAssetFlags} }`
+    );
+  }
   const allFields = [
     ...options.fields,
     ...nestedFields
@@ -607,7 +684,9 @@ async function fetchAmplifySdkConfigs(endpoint, variables) {
   const query = buildSdkConfigsQuery({
     fields: SDK_CONFIG_CORE_FIELDS.trim().split(/\s+/),
     vault: VAULT_FIELDS,
-    depositTokenAddress: DEPOSIT_TOKEN_FIELDS
+    depositTokenAddress: DEPOSIT_TOKEN_FIELDS,
+    tokenMetadata: TOKEN_METADATA_FIELDS,
+    vaultAssetFlags: VAULT_ASSET_FLAGS_FIELDS
   });
   return executeGraphQLQuery(
     endpoint,
@@ -654,10 +733,30 @@ function mapGraphQLConfigToVault(config) {
     return null;
   }
   const { vault, depositTokenAddress } = config;
+  const indexerAssets = vault.supportedAssets && vault.supportedAssets.length > 0 ? vault.supportedAssets.map((a) => ({
+    address: a.address,
+    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,
     vault: {
       boringVaultAddress: vault.boringVaultAddress,
       tellerAddress: vault.tellerModuleId,
@@ -669,14 +768,25 @@ function mapGraphQLConfigToVault(config) {
       withdrawQueueAddress: vault.withdrawQueueModuleId ? vault.withdrawQueueModuleId : void 0,
       communityCodeDepositorAddress: vault.communityCodeDepositorModuleId ? vault.communityCodeDepositorModuleId : void 0
     },
-    supportedAssets: {
-      address: depositTokenAddress.address,
-      symbol: depositTokenAddress.name,
-      name: depositTokenAddress.name,
-      decimals: 0
-    }
+    supportedAssets: indexerAssets,
+    sla: vault.withdrawalSla && vault.withdrawalSla.length > 0 ? {
+      externalWithdrawalQueueDelaySLA: vault.withdrawalSla[0].externalWithdrawalQueueDelaySLA,
+      externalAccountantRateUpdateSLA: vault.withdrawalSla[0].externalAccountantRateUpdateSLA
+    } : 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) {
@@ -685,12 +795,17 @@ function extractSupportedAssetsFromConfigs(configs) {
     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.depositTokenAddress.name,
-        name: config.depositTokenAddress.name,
-        decimals: 0,
+        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])
       });
     }
@@ -704,174 +819,6 @@ function extractSupportedAssetsFromConfigs(configs) {
   }));
 }
 
-// src/client/vault-assets-client.ts
-var PAGE_SIZE = 100;
-var MAX_PAGES = 50;
-var ENDPOINT_PATH = "/amplify/vaultAssets";
-async function fetchVaultAssets() {
-  const baseUrl = getRestV2BaseURL();
-  const allVaultAssets = [];
-  let allTokenMetadata = {};
-  let pageToken = null;
-  let pageCount = 0;
-  do {
-    let urlStr = `${baseUrl}${ENDPOINT_PATH}?pageSize=${PAGE_SIZE}`;
-    if (pageToken) {
-      urlStr += `&pageToken=${encodeURIComponent(pageToken)}`;
-    }
-    let response;
-    try {
-      response = await fetch(urlStr, {
-        method: "GET",
-        headers: getRequestHeaders(),
-        signal: createTimeoutSignal(DEFAULT_TIMEOUT)
-      });
-    } catch (error) {
-      if (error instanceof Error && error.name === "AbortError") {
-        throw new APIError(
-          "vaultAssets request timed out",
-          { endpoint: ENDPOINT_PATH, cause: error }
-        );
-      }
-      throw new APIError(
-        `vaultAssets network error: ${error instanceof Error ? error.message : String(error)}`,
-        { endpoint: ENDPOINT_PATH, cause: error }
-      );
-    }
-    if (!response.ok) {
-      throw new APIError(
-        `vaultAssets HTTP error: ${response.status} ${response.statusText}`,
-        {
-          endpoint: ENDPOINT_PATH,
-          statusCode: response.status
-        }
-      );
-    }
-    let body;
-    try {
-      body = await response.json();
-    } catch (error) {
-      throw new APIError(
-        "vaultAssets response is not valid JSON",
-        { endpoint: ENDPOINT_PATH, cause: error }
-      );
-    }
-    allVaultAssets.push(...body.vaultAssets);
-    allTokenMetadata = {
-      ...allTokenMetadata,
-      ...body.tokenMetadata
-    };
-    pageToken = body.nextPageToken ?? null;
-    pageCount++;
-    if (pageCount >= MAX_PAGES && pageToken) {
-      throw new APIError(
-        `vaultAssets pagination safety limit reached (${pageCount} of ${MAX_PAGES} pages)`,
-        {
-          endpoint: ENDPOINT_PATH,
-          statusCode: 0,
-          cause: new Error(
-            `Pagination exceeded ${MAX_PAGES} pages with nextPageToken still present`
-          )
-        }
-      );
-    }
-  } while (pageToken);
-  return {
-    vaultAssets: allVaultAssets,
-    nextPageToken: null,
-    tokenMetadata: allTokenMetadata
-  };
-}
-
-// src/client/vault-data-merger.ts
-function buildVaultAssetKey(boringVaultAddress, chainId, assetAddress) {
-  return `${boringVaultAddress.toLowerCase()}:${chainId}:${assetAddress.toLowerCase()}`;
-}
-function buildMetadataMap(tokenMetadata) {
-  const map = /* @__PURE__ */ new Map();
-  for (const [address, metadata] of Object.entries(
-    tokenMetadata
-  )) {
-    map.set(address.toLowerCase(), metadata);
-  }
-  return map;
-}
-function enrichVaultsWithAssetData(vaults, vaultAssetsResponse) {
-  const logger = getLogger();
-  const vaultAssetMap = /* @__PURE__ */ new Map();
-  for (const entry of vaultAssetsResponse.vaultAssets) {
-    const key = buildVaultAssetKey(
-      entry.vaultAddress,
-      entry.chainId,
-      entry.assetAddress
-    );
-    vaultAssetMap.set(key, {
-      depositable: entry.depositable,
-      withdrawable: entry.withdrawable
-    });
-  }
-  const metadataMap = buildMetadataMap(
-    vaultAssetsResponse.tokenMetadata
-  );
-  return vaults.map((vault) => {
-    const assetAddress = vault.supportedAssets.address;
-    const key = buildVaultAssetKey(
-      vault.vault.boringVaultAddress,
-      vault.chainId,
-      assetAddress
-    );
-    const vaultAssetEntry = vaultAssetMap.get(key);
-    const tokenMeta = metadataMap.get(
-      assetAddress.toLowerCase()
-    );
-    if (!vaultAssetEntry && !tokenMeta) {
-      logger.debug(
-        `No vaultAssets match for vault ${vault.id}`
-      );
-      return vault;
-    }
-    return {
-      ...vault,
-      supportedAssets: {
-        ...vault.supportedAssets,
-        ...tokenMeta && {
-          symbol: tokenMeta.symbol,
-          name: tokenMeta.name,
-          decimals: Number.parseInt(
-            tokenMeta.decimals,
-            10
-          ),
-          coinGeckoTokenId: tokenMeta.coin_gecko_id || void 0
-        },
-        ...vaultAssetEntry && {
-          depositable: vaultAssetEntry.depositable,
-          withdrawable: vaultAssetEntry.withdrawable
-        }
-      }
-    };
-  });
-}
-function enrichAssetsWithMetadata(assets, vaultAssetsResponse) {
-  const metadataMap = buildMetadataMap(
-    vaultAssetsResponse.tokenMetadata
-  );
-  return assets.map((asset) => {
-    const tokenMeta = metadataMap.get(
-      asset.address.toLowerCase()
-    );
-    if (!tokenMeta) {
-      return asset;
-    }
-    return {
-      ...asset,
-      symbol: tokenMeta.symbol,
-      name: tokenMeta.name,
-      decimals: Number.parseInt(tokenMeta.decimals, 10),
-      coinGeckoTokenId: tokenMeta.coin_gecko_id || void 0
-    };
-  });
-}
-
 // src/client/amplify-sdk-client.ts
 function validateVaultFilterOptions(options) {
   if (!options) return;
@@ -932,58 +879,27 @@ function validateAssetFilterOptions(options) {
 }
 async function fetchVaultDataFromGraphQL() {
   const endpoint = getGraphQLEndpoint();
-  const logger = getLogger();
-  const [graphqlResult, restResult] = await Promise.allSettled([
-    fetchAmplifySdkConfigs(endpoint),
-    fetchVaultAssets()
-  ]);
-  if (graphqlResult.status === "rejected") {
-    throw graphqlResult.reason;
-  }
-  const configs = graphqlResult.value.amplifySdkConfigs;
-  let vaults = [];
-  for (const config of configs) {
-    const vault = mapGraphQLConfigToVault(config);
-    if (vault) {
-      vaults.push(vault);
-    }
-  }
-  let assets = extractSupportedAssetsFromConfigs(configs);
-  if (restResult.status === "fulfilled") {
-    vaults = enrichVaultsWithAssetData(
-      vaults,
-      restResult.value
-    );
-    assets = enrichAssetsWithMetadata(
-      assets,
-      restResult.value
-    );
-    logger.debug(
-      "Enriched vault data with vaultAssets metadata"
-    );
-  } else {
-    logger.warn(
-      `Failed to fetch vaultAssets, using GraphQL-only data: ${restResult.reason instanceof Error ? restResult.reason.message : String(restResult.reason)}`
-    );
-  }
+  const response = await fetchAmplifySdkConfigs(endpoint);
+  const configs = response.amplifySdkConfigs;
+  const vaults = aggregateVaultConfigs(configs);
+  const assets = extractSupportedAssetsFromConfigs(configs);
   return { vaults, 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
-    );
+    filtered = filtered.filter((v) => v.chainId === options.chainId);
   }
   if (options.yieldType) {
-    filtered = filtered.filter(
-      (v) => v.yieldType === options.yieldType
-    );
+    filtered = filtered.filter((v) => v.yieldType === options.yieldType);
   }
   if (options.depositTokenAddress) {
+    const normalized = options.depositTokenAddress.toLowerCase();
     filtered = filtered.filter(
-      (v) => v.vault.baseTokenAddress === options.depositTokenAddress
+      (v) => v.supportedAssets.some(
+        (a) => a.address.toLowerCase() === normalized
+      )
     );
   }
   return filtered;
@@ -993,9 +909,7 @@ function applyAssetFilters(assets, options) {
   let filtered = assets;
   if (options.chains !== void 0 && options.chains.length > 0) {
     filtered = filtered.filter(
-      (asset) => options.chains?.some(
-        (chainId) => asset.chains.includes(chainId)
-      )
+      (asset) => options.chains?.some((chainId) => asset.chains.includes(chainId))
     );
   }
   if (options.address) {
@@ -1005,9 +919,7 @@ function applyAssetFilters(assets, options) {
     );
   }
   if (options.symbol) {
-    filtered = filtered.filter(
-      (asset) => asset.symbol === options.symbol
-    );
+    filtered = filtered.filter((asset) => asset.symbol === options.symbol);
   }
   return filtered;
 }
@@ -1080,7 +992,9 @@ async function findVaultByConfig(params) {
   if (!vaultsByToken) {
     const allVaults = cache.getAllVaults();
     const matchingVaults = allVaults.filter(
-      (vault) => vault.vault.baseTokenAddress.toLowerCase() === normalizedAddress
+      (vault) => vault.supportedAssets.some(
+        (a) => a.address.toLowerCase() === normalizedAddress
+      )
     );
     vaultsByToken = matchingVaults.length > 0 ? matchingVaults : void 0;
   }
@@ -1092,6 +1006,74 @@ async function findVaultByConfig(params) {
   );
   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()) {
@@ -1106,16 +1088,18 @@ async function getWithdrawSupportedAssets() {
   }
   const assetVaultMap = /* @__PURE__ */ new Map();
   for (const vault of vaults) {
-    const assetAddress = vault.vault.baseTokenAddress.toLowerCase();
-    if (!assetVaultMap.has(assetAddress)) {
-      assetVaultMap.set(assetAddress, []);
+    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
+      });
     }
-    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);
@@ -1468,15 +1452,17 @@ exports.getClient = getClient;
 exports.getLogger = getLogger;
 exports.getRequestHeaders = getRequestHeaders;
 exports.getRestV2BaseURL = getRestV2BaseURL;
+exports.getVaultsByConfig = getVaultsByConfig;
 exports.getWithdrawSupportedAssets = getWithdrawSupportedAssets;
 exports.initAmplifySDK = initAmplifySDK;
 exports.initializeCache = initializeCache;
 exports.isCacheReady = isCacheReady;
 exports.isValidAddress = isValidAddress;
+exports.isValidChainId = isValidChainId;
 exports.refreshVaultCache = refreshVaultCache;
 exports.setLogLevel = setLogLevel;
 exports.setLogger = setLogger;
 exports.toChainId = toChainId;
 exports.waitForCacheReady = waitForCacheReady;
-//# sourceMappingURL=chunk-BQG3XKTU.js.map
-//# sourceMappingURL=chunk-BQG3XKTU.js.map
+//# sourceMappingURL=chunk-PKGFLHZA.js.map
+//# sourceMappingURL=chunk-PKGFLHZA.js.map