@owney/sdk 0.7.21-beta.2 → 0.7.22-beta.0

package/dist/surfliquid.agent-XDJ672GM.js

@@ -0,0 +1,638 @@
+import {
+  OwneyError,
+  ROUTING_API_BASE_URL
+} from "./chunk-XBDJWZXY.js";
+import {
+  SURFLIQUID_ACTION_MAP,
+  SURFLIQUID_CHAIN_ID,
+  SURFLIQUID_CHAIN_NAME,
+  SURFLIQUID_SUPPORTED_ASSETS,
+  SubmittedError,
+  VaultNotSponsorableError,
+  depositSponsored,
+  withdrawSponsored
+} from "./chunk-W3FYRJLJ.js";
+import "./chunk-5LU2SHO7.js";
+
+// src/agents/surfliquid/surfliquid.agent.ts
+import { createWalletClient, custom } from "viem";
+import { base } from "viem/chains";
+
+// src/agents/surfliquid/surfliquid.session-store.ts
+var KEY_PREFIX = "owney.surfliquid.session";
+var EXPIRY_SKEW_MS = 3e4;
+var memorySessions = /* @__PURE__ */ new Map();
+var storage = () => {
+  if (typeof window === "undefined") return null;
+  try {
+    return window.localStorage;
+  } catch {
+    return null;
+  }
+};
+var buildKey = (apiKey, wallet) => `${KEY_PREFIX}:${apiKey}:${wallet.toLowerCase()}`;
+var isFresh = (session) => {
+  if (!session?.token) return false;
+  if (!session.expiresAt) return true;
+  const expiresAt = Date.parse(session.expiresAt);
+  if (Number.isNaN(expiresAt)) return true;
+  return Date.now() < expiresAt - EXPIRY_SKEW_MS;
+};
+var readSurfSession = (apiKey, wallet) => {
+  const key = buildKey(apiKey, wallet);
+  let raw = null;
+  try {
+    raw = storage()?.getItem(key) ?? null;
+  } catch {
+    raw = null;
+  }
+  if (raw) {
+    try {
+      const parsed = JSON.parse(raw);
+      if (isFresh(parsed)) return parsed;
+    } catch {
+    }
+    clearSurfSession(apiKey, wallet);
+    return null;
+  }
+  const cached = memorySessions.get(key);
+  if (isFresh(cached)) return cached;
+  if (cached) memorySessions.delete(key);
+  return null;
+};
+var writeSurfSession = (apiKey, wallet, session) => {
+  const key = buildKey(apiKey, wallet);
+  memorySessions.set(key, session);
+  try {
+    storage()?.setItem(key, JSON.stringify(session));
+  } catch {
+  }
+};
+var clearSurfSession = (apiKey, wallet) => {
+  const key = buildKey(apiKey, wallet);
+  memorySessions.delete(key);
+  try {
+    storage()?.removeItem(key);
+  } catch {
+  }
+};
+
+// src/agents/surfliquid/surfliquid.broker.ts
+var SURF_SESSION_HEADER = "x-surf-session";
+var SURF_BROKER_TIMEOUT_MS = 7e4;
+var VAULT_MEMO_TTL_MS = 1e4;
+var AGENT_ID = "surfliquid";
+var DISCOVERY_WALLET = "0x";
+var SurfSessionExpiredError = class extends Error {
+  constructor() {
+    super("SurfLiquid session expired");
+    this.name = "SurfSessionExpiredError";
+  }
+};
+var asRecord = (value) => value && typeof value === "object" ? value : {};
+var unavailable = (message, details) => new OwneyError("SURF_UNAVAILABLE", message, details, AGENT_ID);
+function parseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function normalizeVault(json) {
+  const root = asRecord(json);
+  const data = asRecord(root.data);
+  const vault = asRecord(root.vault ?? data.vault ?? root.data ?? root);
+  const userVaultAddress = vault.userVaultAddress ?? null;
+  return {
+    userVaultAddress,
+    deploymentSalt: vault.deploymentSalt ?? null,
+    exists: Boolean(userVaultAddress),
+    walletAddress: vault.walletAddress ?? null,
+    homeChainId: vault.homeChainId ?? null,
+    vaultVersion: vault.vaultVersion ?? null,
+    isActive: vault.isActive,
+    totalValueUSD: vault.totalValueUSD ?? null,
+    totalDepositedUSD: vault.totalDepositedUSD ?? null,
+    earned: vault.earned ?? null,
+    apyBreakdown: vault.apyBreakdown ?? null,
+    league: vault.league ?? null,
+    assets: vault.assets ?? [],
+    chainAddresses: vault.chainAddresses ?? []
+  };
+}
+function normalizeSupportedAssets(json, chainId) {
+  const root = asRecord(json);
+  const data = asRecord(root.data);
+  const vault = asRecord(root.vault ?? data.vault ?? root.data ?? root);
+  const source = vault.assets ?? vault.defaultAssets ?? root.defaultAssets ?? data.defaultAssets ?? [];
+  const assets = source.map((asset) => ({
+    assetAddress: asset.assetAddress,
+    assetSymbol: asset.assetSymbol,
+    assetDecimals: asset.assetDecimals,
+    chainId: asset.chainId,
+    chainStatus: asset.chainStatus,
+    currentAPY: asset.currentAPY,
+    nativeAPY: asset.nativeAPY,
+    merklAPY: asset.merklAPY,
+    leagueAPY: asset.leagueAPY,
+    apy7d: asset.apy7d ?? null,
+    apy14d: asset.apy14d ?? null,
+    apy30d: asset.apy30d ?? null
+  }));
+  return chainId === void 0 ? assets : assets.filter((asset) => asset.chainId === chainId);
+}
+function createSurfBroker(options) {
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const now = options.now ?? Date.now;
+  const base2 = `${options.routingApiBaseUrl.replace(/\/$/, "")}/api/v1/surf`;
+  const wallet = options.walletAddress;
+  let session = readSurfSession(options.apiKey, wallet);
+  const vaultMemo = /* @__PURE__ */ new Map();
+  const storeSession = (next) => {
+    session = next;
+    writeSurfSession(options.apiKey, wallet, next);
+  };
+  const dropSession = () => {
+    session = null;
+    clearSurfSession(options.apiKey, wallet);
+  };
+  async function call(method, path, body, isAuthCall = false) {
+    const headers = { "x-owney-api-key": options.apiKey };
+    if (session?.token) headers[SURF_SESSION_HEADER] = session.token;
+    if (body !== void 0) headers["content-type"] = "application/json";
+    if (options.origin) headers["origin"] = options.origin;
+    let response;
+    try {
+      response = await fetchImpl(`${base2}${path}`, {
+        method,
+        headers,
+        body: body === void 0 ? void 0 : JSON.stringify(body),
+        signal: AbortSignal.timeout(SURF_BROKER_TIMEOUT_MS)
+      });
+    } catch (error) {
+      throw unavailable(
+        `SurfLiquid broker unreachable: ${error instanceof Error ? error.message : String(error)}`,
+        { path }
+      );
+    }
+    const rotated = response.headers.get(SURF_SESSION_HEADER);
+    if (rotated && rotated !== session?.token) {
+      storeSession({ token: rotated, expiresAt: session?.expiresAt ?? null });
+    }
+    if (response.status === 401 && !isAuthCall) {
+      dropSession();
+      throw new SurfSessionExpiredError();
+    }
+    const text = await response.text();
+    const json = parseJson(text);
+    if (!response.ok) {
+      throw unavailable(`SurfLiquid broker responded ${response.status} on ${path}`, {
+        status: response.status,
+        body: json ?? text
+      });
+    }
+    return json;
+  }
+  const sessionFrom = (json) => {
+    const body = asRecord(json);
+    if (typeof body.token !== "string") throw unavailable("SurfLiquid login returned no session token");
+    const next = { token: body.token, expiresAt: typeof body.expiresAt === "string" ? body.expiresAt : null };
+    storeSession(next);
+    return next;
+  };
+  return {
+    hasSession: () => session !== null,
+    clearSession: dropSession,
+    nonce: async () => {
+      const json = await call("POST", "/auth/nonce", { walletAddress: wallet }, true);
+      const message = json?.data?.message;
+      if (typeof message !== "string") throw unavailable("SurfLiquid nonce response had no message");
+      return message;
+    },
+    login: async (message, signature) => sessionFrom(await call("POST", "/auth/login", { walletAddress: wallet, message, signature }, true)),
+    getVault: (walletAddress) => {
+      const key = walletAddress.toLowerCase();
+      const hit = vaultMemo.get(key);
+      if (hit && now() - hit.at < VAULT_MEMO_TTL_MS) return hit.value;
+      const query = new URLSearchParams({ walletAddress });
+      const value = (async () => normalizeVault(await call("GET", `/vault?${query.toString()}`)))();
+      vaultMemo.set(key, { at: now(), value });
+      value.catch(() => vaultMemo.delete(key));
+      return value;
+    },
+    invalidateVault: () => vaultMemo.clear(),
+    prepare: async (homeChainId) => {
+      const json = asRecord(await call("POST", "/vault/prepare", { homeChainId }));
+      const prepared = asRecord(json.data ?? json);
+      if (typeof prepared.salt !== "string") throw unavailable("SurfLiquid prepare returned no salt");
+      return { salt: prepared.salt };
+    },
+    confirm: async (input) => {
+      await call("POST", "/vault/confirm", input);
+      vaultMemo.clear();
+    },
+    getBestVault: async (assetSymbol) => {
+      const json = await call("GET", `/vaults/best?assetSymbol=${encodeURIComponent(assetSymbol)}`);
+      const root = asRecord(json);
+      const list = root.vaults ?? root.data ?? json;
+      return Array.isArray(list) ? list : [];
+    },
+    getAgentMessages: async (walletAddress, page, limit, fromDate, toDate) => {
+      const query = new URLSearchParams({ walletAddress, page: String(page), limit: String(limit) });
+      if (fromDate) query.set("from", fromDate);
+      if (toDate) query.set("to", toDate);
+      const json = asRecord(await call("GET", `/agent-messages?${query.toString()}`));
+      const data = asRecord(json.data ?? json);
+      return {
+        page: data.page ?? page,
+        limit: data.limit ?? limit,
+        total: data.total ?? 0,
+        pages: data.pages ?? 1,
+        messages: data.messages ?? []
+      };
+    },
+    getSupportedAssets: async (chainId) => normalizeSupportedAssets(
+      await call("GET", `/vault?${new URLSearchParams({ walletAddress: DISCOVERY_WALLET }).toString()}`),
+      chainId
+    )
+  };
+}
+
+// src/agents/surfliquid/surfliquid.mapper.ts
+function mapMessage(message) {
+  const action = SURFLIQUID_ACTION_MAP[message.transactionType];
+  if (!action) return null;
+  return {
+    agent: "surfliquid",
+    action,
+    date: message.timestamp,
+    oldApy: message.apyBefore != null ? String(message.apyBefore) : null,
+    newApy: message.apyAfter != null ? String(message.apyAfter) : null,
+    transactions: [
+      {
+        txHashes: [message.txHash],
+        chainId: message.chainId,
+        tokenSymbol: message.token ?? void 0,
+        amount: message.amount != null ? String(message.amount) : void 0
+      }
+    ],
+    rebalanceLog: []
+  };
+}
+function mapHistory(result, _chainId) {
+  const data = result.messages.map(mapMessage).filter((entry) => entry !== null);
+  const hasMore = result.page < result.pages;
+  return {
+    data,
+    hasMore,
+    nextCursor: hasMore ? String(result.page + 1) : void 0
+  };
+}
+function mapBalances(vault, chainId, morphoStats) {
+  const assets = (vault.assets ?? []).filter(
+    (asset) => asset.assetSymbol === "USDC" && asset.chainId === chainId
+  );
+  const tokens = assets.map((asset) => ({
+    chain: SURFLIQUID_CHAIN_NAME,
+    chainId: SURFLIQUID_CHAIN_ID,
+    asset: "USDC",
+    amount: String(asset.currentValueUSD)
+  }));
+  const positions = assets.map((asset) => {
+    const stats = morphoStats?.get(asset.morphoVaultAddress?.toLowerCase() ?? "");
+    return {
+      chain: SURFLIQUID_CHAIN_NAME,
+      protocol: "Morpho",
+      // The specific MetaMorpho vault (e.g. "Gauntlet USDC Frontier"), read from
+      // Morpho — renders as "Morpho <vault>" alongside zyfai's vault detail.
+      pool: stats?.name ?? void 0,
+      asset: "USDC",
+      amount: String(asset.currentValueUSD),
+      apy: asset.currentAPY,
+      // TVL + liquidity come straight from Morpho (SurfLiquid's API omits them).
+      tvl: stats?.tvlUsd,
+      liquidity: stats?.liquidityUsd
+    };
+  });
+  const total = assets.reduce(
+    (sum, asset) => sum + asset.currentValueUSD,
+    0
+  );
+  return {
+    smartWallet: vault.userVaultAddress ?? void 0,
+    totalBalance: String(total),
+    totalBalanceAsset: "usdc",
+    tokens,
+    positions
+  };
+}
+var APY_WINDOW_KEY = {
+  "7D": "apy7d",
+  "14D": "apy14d",
+  "30D": "apy30d"
+};
+function mapAccountApy(vault, days) {
+  const breakdown = vault.apyBreakdown;
+  const windowed = breakdown ? breakdown[APY_WINDOW_KEY[days]] : void 0;
+  const apy = windowed != null ? windowed : breakdown?.currentAPY ?? 0;
+  return {
+    walletAddress: vault.walletAddress ?? "",
+    weightedApyAfterFee: apy,
+    apyByChainAndAsset: { [SURFLIQUID_CHAIN_ID]: { USDC: apy } },
+    // Parity with Sail: SurfLiquid's core-sdk exposes no daily net-APY series.
+    history: []
+  };
+}
+function mapEarnings(vault, vaultAddress) {
+  return {
+    smartWallet: vaultAddress,
+    lifetimeEarnings: vault.earned?.totalEarningsUSD ?? 0,
+    tokens: []
+  };
+}
+function mapUserProfile(vault, address) {
+  return {
+    address,
+    smartWallet: vault.userVaultAddress ?? "",
+    chains: [SURFLIQUID_CHAIN_ID],
+    // SurfLiquid uses cookie-based session auth — no session-key concept.
+    hasActiveSessionKey: false,
+    protocols: ["SurfLiquid"]
+  };
+}
+
+// src/agents/surfliquid/surfliquid.morpho.ts
+var MORPHO_API_URL = "https://api.morpho.org/graphql";
+var VAULT_STATS_QUERY = `
+  query VaultStats($address: String!, $chainId: Int!) {
+    vaultByAddress(address: $address, chainId: $chainId) {
+      name
+      state { totalAssetsUsd }
+      liquidity { usd }
+    }
+  }
+`;
+var VAULT_V2_STATS_QUERY = `
+  query VaultV2Stats($address: String!, $chainId: Int!) {
+    vaultV2ByAddress(address: $address, chainId: $chainId) {
+      name
+      totalAssetsUsd
+      liquidityUsd
+    }
+  }
+`;
+async function queryMorpho(query, vaultAddress, chainId) {
+  try {
+    const res = await fetch(MORPHO_API_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        query,
+        variables: { address: vaultAddress, chainId }
+      })
+    });
+    if (!res.ok) return null;
+    const json = await res.json();
+    if (json.errors) return null;
+    return json.data ?? null;
+  } catch (error) {
+    console.warn("surfliquid: Morpho vault stats fetch failed", {
+      vaultAddress,
+      chainId,
+      error
+    });
+    return null;
+  }
+}
+function toStats(name, tvlUsd, liquidityUsd) {
+  if (typeof tvlUsd !== "number" || typeof liquidityUsd !== "number") {
+    return null;
+  }
+  return {
+    name: typeof name === "string" ? name : null,
+    tvlUsd,
+    liquidityUsd
+  };
+}
+async function fetchMorphoVaultStats(vaultAddress, chainId) {
+  const v1 = await queryMorpho(VAULT_STATS_QUERY, vaultAddress, chainId);
+  const vault = v1?.vaultByAddress;
+  const v1Stats = toStats(
+    vault?.name,
+    vault?.state?.totalAssetsUsd,
+    vault?.liquidity?.usd
+  );
+  if (v1Stats) return v1Stats;
+  const v2 = await queryMorpho(VAULT_V2_STATS_QUERY, vaultAddress, chainId);
+  const vaultV2 = v2?.vaultV2ByAddress;
+  return toStats(vaultV2?.name, vaultV2?.totalAssetsUsd, vaultV2?.liquidityUsd);
+}
+async function fetchMorphoStatsByVault(vaultAddresses, chainId) {
+  const unique = [...new Set(vaultAddresses.map((a) => a.toLowerCase()))];
+  const entries = await Promise.all(
+    unique.map(
+      async (address) => [address, await fetchMorphoVaultStats(address, chainId)]
+    )
+  );
+  const byVault = /* @__PURE__ */ new Map();
+  for (const [address, stats] of entries) {
+    if (stats) byVault.set(address, stats);
+  }
+  return byVault;
+}
+
+// src/agents/surfliquid/surfliquid.agent.ts
+var AGENT_ID2 = "surfliquid";
+var WALLET_REJECTED_CODE = 4001;
+var DISCOVERY_WALLET2 = "0x";
+var HISTORY_DEFAULT_LIMIT = 10;
+var APY_WINDOW_KEY2 = {
+  "7D": "apy7d",
+  "14D": "apy14d",
+  "30D": "apy30d"
+};
+function toOwneyError(error) {
+  if (error instanceof OwneyError) return error;
+  if (error instanceof SubmittedError) {
+    return new OwneyError("OPERATION_PENDING", error.message, { userOpHash: error.userOpHash }, AGENT_ID2);
+  }
+  if (error instanceof VaultNotSponsorableError) {
+    return new OwneyError("VAULT_NOT_SPONSORABLE", error.message, void 0, AGENT_ID2);
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  const code = error?.code;
+  if (code === WALLET_REJECTED_CODE || /user rejected|user denied/i.test(message)) {
+    return new OwneyError("USER_REJECTED", message, void 0, AGENT_ID2);
+  }
+  return new OwneyError("SPONSORSHIP_UNAVAILABLE", message, void 0, AGENT_ID2);
+}
+var SurfLiquidAgent = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  id = AGENT_ID2;
+  supportedChainIds = [SURFLIQUID_CHAIN_ID];
+  supportedAssets = SURFLIQUID_SUPPORTED_ASSETS;
+  broker = null;
+  brokerWallet = null;
+  // Dedicated instance for the anonymous "0x" asset probe — never shares a slot
+  // with the user's broker, so discovery can never evict or overwrite a session.
+  discoveryBroker = null;
+  // In-flight SIWE, shared by concurrent callers: SurfLiquid's nonce is single-use.
+  connectPromise = null;
+  get routingApiBaseUrl() {
+    return this.config.routingApiBaseUrl ?? ROUTING_API_BASE_URL;
+  }
+  // Synchronous so the check-and-assign below cannot interleave with a concurrent call.
+  brokerFor(walletAddress) {
+    if (this.broker && this.brokerWallet === walletAddress.toLowerCase()) return this.broker;
+    this.broker = createSurfBroker({
+      routingApiBaseUrl: this.routingApiBaseUrl,
+      apiKey: this.config.apiKey,
+      walletAddress,
+      fetchImpl: this.config.fetchImpl
+    });
+    this.brokerWallet = walletAddress.toLowerCase();
+    return this.broker;
+  }
+  async connect(state, shouldForce = false) {
+    const broker = this.brokerFor(state.walletAddress);
+    if (!shouldForce && broker.hasSession()) return broker;
+    if (this.connectPromise) return this.connectPromise;
+    this.connectPromise = (async () => {
+      const message = await broker.nonce();
+      const walletClient = createWalletClient({
+        account: state.walletAddress,
+        chain: base,
+        transport: custom(state.provider)
+      });
+      const signature = await walletClient.signMessage({ account: state.walletAddress, message });
+      await broker.login(message, signature);
+      return broker;
+    })();
+    try {
+      return await this.connectPromise;
+    } finally {
+      this.connectPromise = null;
+    }
+  }
+  /** A 401 can only surface before any signature (SurfLiquid is never called between sign and submit). */
+  async withSession(state, run) {
+    try {
+      return await run();
+    } catch (error) {
+      if (!(error instanceof SurfSessionExpiredError)) throw error;
+      await this.connect(state, true);
+      try {
+        return await run();
+      } catch (retryError) {
+        if (!(retryError instanceof SurfSessionExpiredError)) throw retryError;
+        throw new OwneyError("SURF_UNAVAILABLE", "SurfLiquid session could not be re-established", void 0, AGENT_ID2);
+      }
+    }
+  }
+  async sponsoredWallet(state) {
+    const { createSponsoredWallet } = await import("./surfliquid.smart-account-DWV5B3D5.js");
+    return createSponsoredWallet({
+      provider: state.provider,
+      ownerAddress: state.walletAddress,
+      routingApiBaseUrl: this.routingApiBaseUrl,
+      apiKey: this.config.apiKey,
+      rpcUrl: this.config.rpcUrl
+    });
+  }
+  // --- IAgent: lifecycle ---
+  async disconnect() {
+    this.broker?.clearSession();
+    this.broker = null;
+    this.brokerWallet = null;
+  }
+  async activateAgent(state, _chainId) {
+    await this.connect(state);
+  }
+  // --- IAgent: funds (gasless only) ---
+  async deposit(state, _chainId, amount, _asset, _depositCallback) {
+    const broker = await this.connect(state);
+    const wallet = await this.sponsoredWallet(state);
+    const { createSponsoredChain } = await import("./surfliquid.smart-account-DWV5B3D5.js");
+    try {
+      const { txHash, vault } = await this.withSession(
+        state,
+        () => depositSponsored({ amount: BigInt(amount), api: broker, chain: createSponsoredChain(this.config.rpcUrl), wallet })
+      );
+      broker.invalidateVault();
+      return { txHash, smartWallet: vault, amount };
+    } catch (error) {
+      throw toOwneyError(error);
+    }
+  }
+  async withdraw(state, _chainId, _token, amount) {
+    const broker = await this.connect(state);
+    const wallet = await this.sponsoredWallet(state);
+    const { createSponsoredChain } = await import("./surfliquid.smart-account-DWV5B3D5.js");
+    try {
+      const result = await this.withSession(
+        state,
+        () => withdrawSponsored({
+          amount: amount != null ? BigInt(amount) : void 0,
+          api: broker,
+          chain: createSponsoredChain(this.config.rpcUrl),
+          wallet
+        })
+      );
+      broker.invalidateVault();
+      return { txHash: result.txHash, type: amount != null ? "partial" : "full", amount: result.amount };
+    } catch (error) {
+      throw toOwneyError(error);
+    }
+  }
+  // --- IAgent: portfolio reads ---
+  async vault(state) {
+    const broker = await this.connect(state);
+    return this.withSession(state, () => broker.getVault(state.walletAddress));
+  }
+  async getBalances(state, chainId) {
+    const vault = await this.vault(state);
+    const morphoVaultAddresses = (vault.assets ?? []).filter((asset) => asset.assetSymbol === "USDC" && asset.chainId === chainId).map((asset) => asset.morphoVaultAddress).filter((address) => Boolean(address));
+    const morphoStats = await fetchMorphoStatsByVault(morphoVaultAddresses, chainId);
+    return mapBalances(vault, chainId, morphoStats);
+  }
+  async getEarnings(state) {
+    const vault = await this.vault(state);
+    return mapEarnings(vault, vault.userVaultAddress ?? state.walletAddress);
+  }
+  async getAccountApy(state, _chainId, days) {
+    return mapAccountApy(await this.vault(state), days);
+  }
+  async getHistory(state, chainId, options) {
+    const broker = await this.connect(state);
+    const page = options?.cursor ? Number(options.cursor) : 1;
+    const limit = options?.limit ?? HISTORY_DEFAULT_LIMIT;
+    const result = await this.withSession(
+      state,
+      () => broker.getAgentMessages(state.walletAddress, page, limit, options?.fromDate, options?.toDate)
+    );
+    return mapHistory(result, chainId);
+  }
+  async getUserProfile(state) {
+    return mapUserProfile(await this.vault(state), state.walletAddress);
+  }
+  // --- IAgent: discovery (no wallet, no session) ---
+  async getAgentApy(days, _options) {
+    this.discoveryBroker ??= createSurfBroker({
+      routingApiBaseUrl: this.routingApiBaseUrl,
+      apiKey: this.config.apiKey,
+      walletAddress: DISCOVERY_WALLET2,
+      fetchImpl: this.config.fetchImpl
+    });
+    const assets = await this.discoveryBroker.getSupportedAssets(SURFLIQUID_CHAIN_ID);
+    const usdc = assets.find((asset) => asset.assetSymbol === "USDC");
+    if (!usdc) return { averageApy: 0 };
+    const windowed = usdc[APY_WINDOW_KEY2[days]];
+    return { averageApy: windowed != null ? windowed : usdc.currentAPY };
+  }
+};
+export {
+  SurfLiquidAgent
+};