@owney/sdk 0.7.9 → 0.7.10-beta.0

package/dist/surfliquid.agent-VNGQUSXN.js

@@ -0,0 +1,473 @@
+import {
+  ERC20_ALLOWANCE_ABI,
+  OwneyError
+} from "./chunk-PWIKIQOX.js";
+
+// src/agents/surfliquid/surfliquid.agent.ts
+import { SurfClient } from "@surf_liquid/core-sdk";
+import {
+  createPublicClient,
+  createWalletClient,
+  custom,
+  formatUnits
+} from "viem";
+import { base } from "viem/chains";
+
+// src/agents/surfliquid/surfliquid.constants.ts
+var SURFLIQUID_CHAIN_ID = 8453;
+var SURFLIQUID_CHAIN_NAME = "BASE";
+var SURFLIQUID_USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+var SURFLIQUID_USDC_DECIMALS = 6;
+var SURFLIQUID_MIN_DEPOSIT = "0";
+var SURFLIQUID_APPROVAL_TARGET = 100000000000n;
+var SURFLIQUID_SUPPORTED_ASSETS = [
+  {
+    chainId: SURFLIQUID_CHAIN_ID,
+    chain: SURFLIQUID_CHAIN_NAME,
+    assets: [{ symbol: "USDC", minDepositAmount: SURFLIQUID_MIN_DEPOSIT }]
+  }
+];
+var SURFLIQUID_ACTION_MAP = {
+  // INITIAL_DEPOSIT is the user's real first deposit, so surface it like any
+  // other funding ("Top up"). The mini-app intentionally hides the "Deposit"
+  // action (it marks Zyfai's smart-account-creation event), which would
+  // otherwise drop a SurfLiquid user's only history row.
+  INITIAL_DEPOSIT: "Top up",
+  DEPOSIT: "Top up",
+  USER_DEPOSIT: "Top up",
+  WITHDRAWAL: "Withdraw",
+  USER_WITHDRAWAL: "Withdraw",
+  REBALANCE: "Rebalance",
+  REBALANCE_COMPLETED: "Rebalance",
+  CROSS_CHAIN_REBALANCE: "Rebalance",
+  MERKL_CLAIM: "Earned"
+};
+
+// 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.wallet-adapter.ts
+import { BaseWalletAdapter } from "@surf_liquid/core-sdk";
+var OwneyWalletAdapter = class extends BaseWalletAdapter {
+  constructor(eip1193Provider) {
+    super();
+    this.eip1193Provider = eip1193Provider;
+  }
+  eip1193Provider;
+  name = "owney";
+  get installed() {
+    return true;
+  }
+  resolveProvider() {
+    return this.eip1193Provider;
+  }
+};
+
+// 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 APY_WINDOW_KEY2 = {
+  "7D": "apy7d",
+  "14D": "apy14d",
+  "30D": "apy30d"
+};
+var SurfLiquidAgent = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  id = "surfliquid";
+  supportedChainIds = [SURFLIQUID_CHAIN_ID];
+  supportedAssets = SURFLIQUID_SUPPORTED_ASSETS;
+  surf = null;
+  connectedAddress = null;
+  // In-flight connect+auth, shared by concurrent callers to dedupe SIWE.
+  connectPromise = null;
+  ensureSurf() {
+    if (this.surf) return this.surf;
+    this.surf = SurfClient.create({
+      projectName: this.config.projectName,
+      appId: this.config.appId,
+      environment: "mainnet",
+      chainId: SURFLIQUID_CHAIN_ID,
+      apiBaseUrl: this.config.apiBaseUrl,
+      rpcUrl: this.config.rpcUrl,
+      // Let the SDK auto-approve USDC to the vault before depositing.
+      autoApprove: true
+    });
+    return this.surf;
+  }
+  /**
+   * Connects + authenticates the SurfClient against owney's provider. Skips the
+   * SIWE prompt when already authenticated for this wallet (cookie session).
+   */
+  async connect(state) {
+    const surf = this.ensureSurf();
+    const sameWallet = this.connectedAddress?.toLowerCase() === state.walletAddress.toLowerCase();
+    if (sameWallet && surf.getAuthState().authenticated) {
+      return surf;
+    }
+    if (this.connectPromise) return this.connectPromise;
+    this.connectPromise = (async () => {
+      surf.registerWalletAdapter(
+        "owney",
+        new OwneyWalletAdapter(state.provider)
+      );
+      await surf.connectWallet("owney");
+      await surf.authenticate();
+      this.connectedAddress = state.walletAddress;
+      return surf;
+    })();
+    try {
+      return await this.connectPromise;
+    } finally {
+      this.connectPromise = null;
+    }
+  }
+  /**
+   * Returns the user's vault address, deploying one on first use. SurfLiquid's
+   * deposit requires the vault to exist, so this must run before depositing.
+   * Existing vault → returned as-is; otherwise `deployVault()` is sent
+   * (user-pays) and the freshly deployed address is returned.
+   */
+  async resolveVaultAddress(surf, owner) {
+    const vault = await surf.getVault(owner).catch(() => null);
+    if (vault?.exists && vault.userVaultAddress) {
+      return vault.userVaultAddress;
+    }
+    const { vaultAddress } = await surf.deployVault();
+    return vaultAddress;
+  }
+  /**
+   * Grants the user's vault a standing USDC allowance so SurfLiquid's
+   * `autoApprove` has nothing to do — see {@link SURFLIQUID_APPROVAL_TARGET}
+   * for why one prompt per deposit is worth removing.
+   *
+   * Fails OPEN on a read error: if the allowance can't be checked we simply
+   * return and let SurfLiquid's own per-deposit approve run, because a flaky
+   * RPC must never block a deposit. A failed or rejected APPROVE does
+   * propagate — the user declined a transaction, and letting SurfLiquid
+   * immediately ask again for a smaller one is exactly the double prompt this
+   * removes.
+   */
+  async ensureVaultAllowance(state, vaultAddress, amount) {
+    const spender = vaultAddress;
+    const transport = custom(state.provider);
+    const publicClient = createPublicClient({ chain: base, transport });
+    let allowance;
+    try {
+      allowance = await publicClient.readContract({
+        address: SURFLIQUID_USDC_ADDRESS,
+        abi: ERC20_ALLOWANCE_ABI,
+        functionName: "allowance",
+        args: [state.walletAddress, spender]
+      });
+    } catch (error) {
+      console.warn(
+        "[owney-sdk] SurfLiquid allowance pre-check failed; deferring to its per-deposit approve:",
+        error instanceof Error ? error.message : String(error)
+      );
+      return;
+    }
+    if (allowance >= amount) return;
+    const target = amount > SURFLIQUID_APPROVAL_TARGET ? amount : SURFLIQUID_APPROVAL_TARGET;
+    const wallet = createWalletClient({
+      account: state.walletAddress,
+      chain: base,
+      transport
+    });
+    const hash = await wallet.writeContract({
+      address: SURFLIQUID_USDC_ADDRESS,
+      abi: ERC20_ALLOWANCE_ABI,
+      functionName: "approve",
+      args: [spender, target],
+      account: state.walletAddress,
+      chain: base
+    });
+    const receipt = await publicClient.waitForTransactionReceipt({
+      hash,
+      confirmations: 1
+    });
+    if (receipt.status !== "success") {
+      throw new Error(`SurfLiquid USDC approval reverted (tx ${hash})`);
+    }
+  }
+  // --- IAgent: lifecycle ---
+  async disconnect() {
+    if (this.surf) {
+      await this.surf.disconnectWallet();
+    }
+    this.connectedAddress = null;
+  }
+  async activateAgent(state) {
+    await this.connect(state);
+  }
+  // --- IAgent: funds (user-pays; asset is always USDC, callback ignored) ---
+  async deposit(state, _chainId, amount, _asset, _depositCallback) {
+    const surf = await this.connect(state);
+    const human = formatUnits(BigInt(amount), SURFLIQUID_USDC_DECIMALS);
+    const smartWallet = await this.resolveVaultAddress(
+      surf,
+      state.walletAddress
+    );
+    await this.ensureVaultAllowance(state, smartWallet, BigInt(amount));
+    const tx = await surf.deposit({
+      asset: SURFLIQUID_USDC_ADDRESS,
+      amount: human
+    });
+    await tx.wait();
+    return { txHash: tx.hash, smartWallet, amount };
+  }
+  async withdraw(state, _chainId, _token, amount) {
+    const surf = await this.connect(state);
+    const human = amount != null ? formatUnits(BigInt(amount), SURFLIQUID_USDC_DECIMALS) : void 0;
+    try {
+      const tx = await surf.withdraw({
+        asset: SURFLIQUID_USDC_ADDRESS,
+        amount: human
+      });
+      await tx.wait();
+      return {
+        txHash: tx.hash,
+        type: amount != null ? "partial" : "full",
+        amount: amount ?? "0"
+      };
+    } catch (error) {
+      throw new OwneyError(
+        "WITHDRAW_FAILED",
+        error instanceof Error ? error.message : "SurfLiquid withdraw failed.",
+        { chainId: SURFLIQUID_CHAIN_ID, amount },
+        this.id
+      );
+    }
+  }
+  // --- IAgent: portfolio reads ---
+  async getBalances(state, chainId) {
+    const surf = await this.connect(state);
+    const vault = await surf.getVault(state.walletAddress);
+    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 surf = await this.connect(state);
+    const vault = await surf.getVault(state.walletAddress);
+    return mapEarnings(vault, vault.userVaultAddress ?? state.walletAddress);
+  }
+  async getAccountApy(state, _chainId, days, _tokenSymbol) {
+    const surf = await this.connect(state);
+    const vault = await surf.getVault(state.walletAddress);
+    return mapAccountApy(vault, days);
+  }
+  async getHistory(state, chainId, options) {
+    const surf = await this.connect(state);
+    const page = options?.cursor ? Number(options.cursor) : 1;
+    const limit = options?.limit ?? 10;
+    const result = await surf.getAgentMessages(
+      state.walletAddress,
+      page,
+      limit,
+      options?.fromDate,
+      options?.toDate
+    );
+    return mapHistory(result, chainId);
+  }
+  async getUserProfile(state) {
+    const surf = await this.connect(state);
+    const vault = await surf.getVault(state.walletAddress);
+    return mapUserProfile(vault, state.walletAddress);
+  }
+  // --- IAgent: discovery (no wallet) ---
+  async getAgentApy(days, _options) {
+    const surf = this.ensureSurf();
+    const assets = await surf.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
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@owney/sdk",
-  "version": "0.7.9",
+  "version": "0.7.10-beta.0",
   "type": "module",
   "main": "dist/index.cjs",
   "module": "dist/index.js",
@@ -23,7 +23,9 @@
     "test:watch": "vitest"
   },
   "dependencies": {
+    "@surf_liquid/core-sdk": "^0.4.0",
     "@zyfai/sdk": "0.2.48",
+    "ethers": "^6.17.0",
     "siwe": "^3.0.0",
     "viem": "^2.48.1"
   },