@owney/sdk 0.6.0-beta.0 → 0.6.0-beta.2

package/dist/index.js

@@ -1,12 +1,14 @@
 // src/agents/zyfai/zyfai.agent.ts
 import { ZyfaiSDK } from "@zyfai/sdk";
+import { createPublicClient, http } from "viem";
+import { base, arbitrum } from "viem/chains";
 
 // src/types/config.ts
 var P_SUPPORTED_CHAINS = {
   chainIds: [8453, 42161],
   chains: ["BASE", "ARBITRUM"]
 };
-var SUPPORTED_TOKENS = ["USDC", "USDT"];
+var SUPPORTED_TOKENS = ["USDC", "USDT", "WETH"];
 var SUPPORTED_CHAIN_IDS = P_SUPPORTED_CHAINS.chainIds;
 var SUPPORTED_CHAINS = P_SUPPORTED_CHAINS.chains;
 var SupportedAssets = [
@@ -27,6 +29,18 @@ var SupportedAssets = [
     symbol: "USDT",
     chainId: 42161,
     decimals: 6
+  },
+  {
+    address: `0x4200000000000000000000000000000000000006`,
+    symbol: "WETH",
+    chainId: 8453,
+    decimals: 18
+  },
+  {
+    address: `0x82aF49447D8a07e3bd95BD0d56f35241523fBab1`,
+    symbol: "WETH",
+    chainId: 42161,
+    decimals: 18
   }
 ];
 
@@ -125,6 +139,18 @@ var CHAIN_ID_TO_NAME = {
   8453: "BASE",
   42161: "ARBITRUM"
 };
+var NAME_TO_CHAIN_ID = Object.entries(
+  CHAIN_ID_TO_NAME
+).reduce((acc, [id, name]) => {
+  acc[name.toLowerCase()] = Number(id);
+  return acc;
+}, {});
+function resolveChainId(chain) {
+  const asNum = Number(chain);
+  if (Number.isFinite(asNum) && asNum > 0)
+    return asNum;
+  return NAME_TO_CHAIN_ID[chain.trim().toLowerCase()] ?? NaN;
+}
 function mapBalances(raw, _chainId, smartWallet) {
   const portfolio = raw.portfolio;
   const portfolioByChain = portfolio.portfolioByChain ?? {};
@@ -145,10 +171,27 @@ function mapBalances(raw, _chainId, smartWallet) {
       });
     }
   }
+  const positions = (portfolio.positions ?? []).map((p) => ({
+    chain: p.chain ?? "",
+    protocol: p.protocol_name ?? p.protocol_id ?? "",
+    protocolId: p.protocol_id,
+    pool: p.pool,
+    asset: p.token_symbol ?? "",
+    // Position amount is hex-encoded base units (like the token balances
+    // above). Supported assets (USDC/USDT) are 6-decimal — hexToDecimal's
+    // default — so no per-token decimals lookup is needed.
+    amount: String(hexToDecimal(p.amount || "0")),
+    apy: p.pool_apy,
+    tvl: p.pool_tvl,
+    // PositionSlot has no `liquidity` field yet; Zyfai will add it. Narrow
+    // structural read keeps it undefined today and auto-populates later.
+    liquidity: p.liquidity
+  }));
   return {
     smartWallet,
     totalBalance: String(totalBalance),
-    tokens
+    tokens,
+    positions
   };
 }
 function sumTokenValues(tokens) {
@@ -207,6 +250,14 @@ function mapApyHistory(raw) {
     apyByChainAndAsset: mapWeightedApyByChain(raw.weightedApyAfterFeeByChain)
   };
 }
+function splitOpportunity(opportunity) {
+  const match = opportunity.match(/^(.*?)\s*\(([^)]*)\)\s*$/);
+  if (match) {
+    const pool = match[2].trim();
+    return { protocol: match[1].trim(), pool: pool || void 0 };
+  }
+  return { protocol: opportunity.trim() };
+}
 function mapEntries(rawEntries, chainId) {
   const actionMap = {
     "Top up wallet": "Top up",
@@ -226,21 +277,26 @@ function mapEntries(rawEntries, chainId) {
       );
       oldApy = Number(rawLog.oldApy);
       newApy = Number(rawLog.newApy);
+      const from = splitOpportunity(rawLog.oldOpportunity);
+      const to = splitOpportunity(rawLog.newOpportunity);
       rebalanceLog = [
         {
-          fromProtocol: rawLog.oldOpportunity.replace(/\s*\(.*?\)/g, "").trim(),
-          toProtocol: rawLog.newOpportunity.replace(/\s*\(.*?\)/g, "").trim(),
+          fromProtocol: from.protocol,
+          toProtocol: to.protocol,
+          fromPool: from.pool,
+          toPool: to.pool,
           tokenSymbol: matched?.token_symbol ?? "",
           amount: matched ? String(hexToDecimal(matched.amount || "0x")) : "",
           status: "success"
         }
       ];
     }
+    const mappedAction = (entry.action ? actionMap[entry.action] : void 0) ?? entry.action;
     const rawAmount = entry?.positions?.[0]?.amount;
-    const hasAmount = typeof rawAmount === "string" && rawAmount !== "" && rawAmount !== "0x" && rawAmount !== "0x0" && rawAmount !== "0";
+    const hasAmount = mappedAction !== "Withdraw" && typeof rawAmount === "string" && rawAmount !== "" && rawAmount !== "0x" && rawAmount !== "0x0" && rawAmount !== "0";
     return {
       agent: "zyfai",
-      action: (entry.action ? actionMap[entry.action] : void 0) ?? entry.action,
+      action: mappedAction,
       date: entry.date || "",
       newApy: newApy === null ? null : String(newApy),
       oldApy: oldApy === null ? null : String(oldApy),
@@ -256,13 +312,6 @@ function mapEntries(rawEntries, chainId) {
     };
   });
 }
-function mapAgentStatus(raw) {
-  return {
-    success: raw.success,
-    strategy: raw.strategy,
-    protocols: raw.protocols
-  };
-}
 function mapUserProfile(raw, userAddress) {
   return {
     address: userAddress,
@@ -298,6 +347,73 @@ function mapApyByStrategy(raw) {
     detailedApys: hasDetails ? { apyPerAsset } : void 0
   };
 }
+function computeAllocationApy(positions) {
+  let weightedSum = 0;
+  let totalValue = 0;
+  const buckets = {};
+  for (const p of positions) {
+    const apy = p.apy;
+    const value = Number(p.amount);
+    if (typeof apy !== "number" || !Number.isFinite(value) || value <= 0) {
+      continue;
+    }
+    weightedSum += apy * value;
+    totalValue += value;
+    const chainId = resolveChainId(p.chain);
+    const token = p.asset;
+    if (!SUPPORTED_CHAIN_IDS.includes(chainId))
+      continue;
+    if (!SUPPORTED_TOKENS.includes(token))
+      continue;
+    const perAsset = buckets[chainId] ?? {};
+    const cell = perAsset[token] ?? { weightedSum: 0, value: 0 };
+    cell.weightedSum += apy * value;
+    cell.value += value;
+    perAsset[token] = cell;
+    buckets[chainId] = perAsset;
+  }
+  const apyByChainAndAsset = {};
+  for (const [chainKey, perAsset] of Object.entries(buckets)) {
+    const chainId = Number(chainKey);
+    const out = {};
+    for (const [token, cell] of Object.entries(perAsset ?? {})) {
+      if (cell && cell.value > 0) {
+        out[token] = cell.weightedSum / cell.value;
+      }
+    }
+    if (Object.keys(out).length > 0)
+      apyByChainAndAsset[chainId] = out;
+  }
+  const totalApy = totalValue > 0 ? String(weightedSum / totalValue) : "0";
+  return { totalApy, apyByChainAndAsset };
+}
+
+// src/agents/zyfai/zyfai.withdraw-amount.ts
+var TRANSFER_TOPIC = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
+function topicToAddress(topic) {
+  return `0x${(topic ?? "").slice(-40)}`.toLowerCase();
+}
+function extractWithdrawnAmount(logs, recipient, token, decimals) {
+  const wantRecipient = recipient.toLowerCase();
+  const wantToken = token.toLowerCase();
+  let total = 0n;
+  let matched = false;
+  for (const log of logs) {
+    if (log.address.toLowerCase() !== wantToken)
+      continue;
+    if ((log.topics[0] ?? "").toLowerCase() !== TRANSFER_TOPIC)
+      continue;
+    if (topicToAddress(log.topics[2]) !== wantRecipient)
+      continue;
+    if (!log.data || log.data === "0x")
+      continue;
+    total += BigInt(log.data);
+    matched = true;
+  }
+  if (!matched)
+    return void 0;
+  return String(hexToDecimal(`0x${total.toString(16)}`, decimals));
+}
 
 // src/agents/zyfai/zyfai.history-cursor.ts
 var InvalidHistoryCursorError = class extends Error {
@@ -397,6 +513,11 @@ var DEFAULT_ZYFAI_RPC_URLS = {
   8453: "https://base-mainnet.g.alchemy.com/v2/ZWyVU-9XfS3z8Rn-xkq7V",
   42161: "https://arb-mainnet.g.alchemy.com/v2/ZWyVU-9XfS3z8Rn-xkq7V"
 };
+var WETH_ADDRESS_BY_CHAIN = {
+  8453: "0x4200000000000000000000000000000000000006",
+  42161: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1"
+};
+var VIEM_CHAIN = { 8453: base, 42161: arbitrum };
 var ZyfaiAgent = class {
   id = "zyfai";
   supportedChainIds = [8453, 42161];
@@ -404,12 +525,18 @@ var ZyfaiAgent = class {
     {
       chainId: 8453,
       chain: "BASE",
-      assets: [{ symbol: "USDC", minDepositAmount: "1500000" }]
+      assets: [
+        { symbol: "USDC", minDepositAmount: "1500000" },
+        { symbol: "WETH", minDepositAmount: "500000000000000" }
+      ]
     },
     {
       chainId: 42161,
       chain: "ARBITRUM",
-      assets: [{ symbol: "USDC", minDepositAmount: "1500000" }]
+      assets: [
+        { symbol: "USDC", minDepositAmount: "1500000" },
+        { symbol: "WETH", minDepositAmount: "500000000000000" }
+      ]
     }
   ];
   sdk;
@@ -417,13 +544,83 @@ var ZyfaiAgent = class {
   connectedChainId = null;
   smartWalletCache = /* @__PURE__ */ new Map();
   connectAuthPromise = null;
+  rpcUrls;
+  publicClients = /* @__PURE__ */ new Map();
+  // txHash -> resolved withdrawn amount. Receipts are immutable, so a
+  // successful decode is cached forever; failures are NOT cached so a transient
+  // RPC error retries on the next fetch.
+  withdrawAmountCache = /* @__PURE__ */ new Map();
   constructor(apiKey, rpcUrls) {
+    this.rpcUrls = rpcUrls ?? DEFAULT_ZYFAI_RPC_URLS;
     this.sdk = new ZyfaiSDK({
       apiKey,
-      rpcUrls: rpcUrls ?? DEFAULT_ZYFAI_RPC_URLS
+      rpcUrls: this.rpcUrls
     });
     this.installAuthCache();
   }
+  getPublicClient(chainId) {
+    const cached = this.publicClients.get(chainId);
+    if (cached)
+      return cached;
+    const client = createPublicClient({
+      chain: VIEM_CHAIN[chainId],
+      transport: http(this.rpcUrls[chainId])
+    });
+    this.publicClients.set(chainId, client);
+    return client;
+  }
+  /**
+   * Fills in the true withdrawn amount for `Withdraw` entries by decoding the
+   * USDC `Transfer` that lands in the user's wallet on-chain. The Zyfai history
+   * payload only reports the *remaining* position for a partial withdraw (see
+   * the note in `mapEntries`), so without this the UI shows the leftover
+   * balance instead of the amount withdrawn.
+   *
+   * Mutates `entries` in place. Runs all lookups concurrently and is tolerant
+   * of RPC failures: an entry whose amount can't be resolved keeps
+   * `amount: undefined`, which consumers render as a hidden/retryable row
+   * rather than a wrong number.
+   */
+  async resolveWithdrawnAmounts(entries, chainId, recipient) {
+    const asset = SupportedAssets.find(
+      (a) => a.chainId === chainId && a.symbol === "USDC"
+    );
+    if (!asset)
+      return;
+    const withdrawals = entries.filter(
+      (e) => e.action === "Withdraw" && e.transactions[0]?.txHashes[0]
+    );
+    if (withdrawals.length === 0)
+      return;
+    const client = this.getPublicClient(chainId);
+    await Promise.all(
+      withdrawals.map(async (entry) => {
+        const tx = entry.transactions[0];
+        const txHash = tx.txHashes[0];
+        const cached = this.withdrawAmountCache.get(txHash);
+        if (cached !== void 0) {
+          tx.amount = cached;
+          return;
+        }
+        try {
+          const receipt = await client.getTransactionReceipt({
+            hash: txHash
+          });
+          const amount = extractWithdrawnAmount(
+            receipt.logs,
+            recipient,
+            asset.address,
+            asset.decimals
+          );
+          if (amount !== void 0) {
+            this.withdrawAmountCache.set(txHash, amount);
+            tx.amount = amount;
+          }
+        } catch {
+        }
+      })
+    );
+  }
   /**
    * Patches `sdk.authenticateUser` so a fresh page can reuse the JWT from a
    * prior session instead of triggering a new SIWE prompt. Runs inside
@@ -575,7 +772,7 @@ var ZyfaiAgent = class {
       throw error;
     }
   }
-  async deposit(state, chainId, amount, depositCallback) {
+  async deposit(state, chainId, amount, asset, depositCallback) {
     try {
       await this.connectFull(state, chainId);
       const validChainId = isValidChainId(chainId);
@@ -589,13 +786,15 @@ var ZyfaiAgent = class {
           validChainId,
           amount
         );
-        await this.sdk.logDeposit(validChainId, txHash, amount);
+        const tokenAddress = asset === "WETH" ? WETH_ADDRESS_BY_CHAIN[validChainId] : void 0;
+        await (tokenAddress ? this.sdk.logDeposit(validChainId, txHash, amount, tokenAddress) : this.sdk.logDeposit(validChainId, txHash, amount));
         return { txHash, smartWallet: wallet.address, amount };
       }
       const raw = await this.sdk.depositFunds(
         this.getAddress(),
         validChainId,
-        amount
+        amount,
+        asset
       );
       return mapDeposit(raw);
     } catch (error) {
@@ -674,23 +873,14 @@ var ZyfaiAgent = class {
       toDate,
       rawOffset: firstOvershoot ? firstOvershoot.rawIdx : offset
     }) : void 0;
+    const data = mapEntries(pageData, validChainId);
+    await this.resolveWithdrawnAmounts(data, validChainId, state.walletAddress);
     return {
-      data: mapEntries(pageData, validChainId),
+      data,
       hasMore,
       nextCursor
     };
   }
-  // --- IAgent: Agent control ---
-  async pause(state, chainId) {
-    await this.connectAuth(state, chainId);
-    const raw = await this.sdk.pauseAgent();
-    return mapAgentStatus(raw);
-  }
-  async resume(state, chainId) {
-    await this.connectAuth(state, chainId);
-    const raw = await this.sdk.resumeAgent();
-    return mapAgentStatus(raw);
-  }
   async getUserProfile(state, chainId) {
     await this.connectAuth(state, chainId);
     const validChainId = isValidChainId(chainId);
@@ -902,6 +1092,134 @@ function aggregateApyByChainAndAsset(agentApys, agentBalances) {
   return out;
 }
 
+// src/client.ts
+import {
+  createPublicClient as createPublicClient2,
+  createWalletClient,
+  custom
+} from "viem";
+import { base as base2, arbitrum as arbitrum2 } from "viem/chains";
+
+// src/lib/transfer-auth.ts
+import { bytesToHex } from "viem";
+var ERC20_META_ABI = [
+  { type: "function", name: "name", stateMutability: "view", inputs: [], outputs: [{ name: "", type: "string" }] },
+  { type: "function", name: "version", stateMutability: "view", inputs: [], outputs: [{ name: "", type: "string" }] }
+];
+function buildTransferWithAuthorizationTypedData(input) {
+  return {
+    domain: { name: input.tokenName, version: input.tokenVersion, chainId: input.chainId, verifyingContract: input.token },
+    types: {
+      TransferWithAuthorization: [
+        { name: "from", type: "address" },
+        { name: "to", type: "address" },
+        { name: "value", type: "uint256" },
+        { name: "validAfter", type: "uint256" },
+        { name: "validBefore", type: "uint256" },
+        { name: "nonce", type: "bytes32" }
+      ]
+    },
+    primaryType: "TransferWithAuthorization",
+    message: input.message
+  };
+}
+async function readTokenMeta(publicClient, token) {
+  const [tokenName, tokenVersion] = await Promise.all([
+    publicClient.readContract({ address: token, abi: ERC20_META_ABI, functionName: "name" }),
+    publicClient.readContract({ address: token, abi: ERC20_META_ABI, functionName: "version" }).catch(() => "2")
+  ]);
+  return { tokenName, tokenVersion };
+}
+function randomAuthNonce() {
+  const bytes = new Uint8Array(32);
+  globalThis.crypto.getRandomValues(bytes);
+  return bytesToHex(bytes);
+}
+
+// src/lib/sponsor-client.ts
+var ROUTING_API_BASE_URL3 = "https://owney-routing-api-243946518160.europe-west4.run.app";
+async function postSponsorTransferAuth(input) {
+  const base3 = input.baseUrl ?? ROUTING_API_BASE_URL3;
+  let res;
+  try {
+    res = await fetch(`${base3}/api/v1/sponsor/erc20-transfer-auth`, {
+      method: "POST",
+      headers: { "content-type": "application/json", "x-owney-api-key": input.apiKey },
+      body: JSON.stringify(input.body)
+    });
+  } catch (networkError) {
+    throw new OwneyError(
+      "SPONSOR_REQUEST_FAILED",
+      `Sponsor API network error: ${networkError instanceof Error ? networkError.message : String(networkError)}`,
+      { cause: String(networkError) }
+    );
+  }
+  const text = await res.text();
+  let parsed = null;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+  }
+  if (!res.ok || !parsed?.success || !parsed.data) {
+    throw new OwneyError(
+      "SPONSOR_REQUEST_FAILED",
+      `Sponsor API error ${res.status}: ${parsed?.message ?? text.slice(0, 500)}`,
+      { statusCode: res.status, responseBody: text.slice(0, 500) }
+    );
+  }
+  return parsed.data;
+}
+
+// src/lib/sponsored-deposit.ts
+var AUTH_WINDOW_SECONDS = 15 * 60;
+function makeSponsoredDepositCallback(deps) {
+  const post = deps.httpPost ?? postSponsorTransferAuth;
+  return async (smartWallet, chainId, amount) => {
+    const cid = chainId;
+    const token = deps.tokenAddressByChain[cid];
+    if (!token) {
+      throw new OwneyError(
+        "CHAIN_UNSUPPORTED",
+        `No sponsored token configured for chain ${chainId}`
+      );
+    }
+    const pub = deps.getPublicClient(cid);
+    const wallet = deps.getWalletClient(cid);
+    const { tokenName, tokenVersion } = await readTokenMeta(pub, token);
+    const validAfter = 0n;
+    const validBefore = BigInt(Math.floor(Date.now() / 1e3) + AUTH_WINDOW_SECONDS);
+    const nonce = randomAuthNonce();
+    const typedData = buildTransferWithAuthorizationTypedData({
+      token,
+      chainId: cid,
+      tokenName,
+      tokenVersion,
+      message: { from: deps.ownerAddress, to: smartWallet, value: BigInt(amount), validAfter, validBefore, nonce }
+    });
+    const authSignature = await wallet.signTypedData(
+      { account: deps.ownerAddress, ...typedData }
+    );
+    const result = await post({
+      baseUrl: deps.baseUrl,
+      apiKey: deps.apiKey,
+      body: {
+        chainId: cid,
+        token,
+        from: deps.ownerAddress,
+        to: smartWallet,
+        value: amount,
+        validAfter: validAfter.toString(),
+        validBefore: validBefore.toString(),
+        nonce,
+        authSignature,
+        tokenName,
+        tokenVersion
+      }
+    });
+    return result.txHash;
+  };
+}
+
 // src/client.ts
 function encodeMultiAgentCursor(map) {
   return Buffer.from(JSON.stringify(map), "utf8").toString("base64");
@@ -923,6 +1241,14 @@ function decodeMultiAgentCursor(token) {
   }
   return parsed;
 }
+var SPONSORED_USDC_BY_CHAIN = {
+  8453: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+  42161: "0xaf88d065e77c8cc2239327c5edb3a432268e5831"
+};
+var VIEM_CHAIN2 = {
+  8453: base2,
+  42161: arbitrum2
+};
 var OwneySDK = class {
   agents = /* @__PURE__ */ new Map();
   activeAgents = /* @__PURE__ */ new Set();
@@ -935,6 +1261,7 @@ var OwneySDK = class {
   state = null;
   apiKey;
   zyfaiRpcUrls;
+  cachedSponsoredCallback = null;
   initializingAgentsPromise = null;
   constructor(config) {
     this.apiKey = config.apiKey;
@@ -958,6 +1285,7 @@ var OwneySDK = class {
       );
     }
     this.state = { provider, walletAddress, chainId: null };
+    this.cachedSponsoredCallback = null;
   }
   /**
    * Disconnect from all agents and clear connection state.
@@ -970,6 +1298,7 @@ var OwneySDK = class {
     this.activeAgents.clear();
     this.disabledAgents.clear();
     this.state = null;
+    this.cachedSponsoredCallback = null;
   }
   isAgentDisabled(agentId) {
     return this.disabledAgents.has(agentId);
@@ -1003,6 +1332,46 @@ var OwneySDK = class {
     }
     return chainId;
   }
+  requireConnectedProvider() {
+    if (!this.state?.provider) {
+      throw new OwneyError(
+        "NOT_CONNECTED",
+        "connect(provider) must be called before deposit",
+        {}
+      );
+    }
+    return this.state.provider;
+  }
+  /**
+   * Lazily builds (and caches) the default EIP-3009 sponsored deposit callback
+   * used when the caller omits `depositCallback`. Wraps the connected EIP-1193
+   * provider with viem `custom(provider)` to read token meta and sign the
+   * `TransferWithAuthorization`, then POSTs to the sponsor API.
+   */
+  getDefaultSponsoredCallback() {
+    if (this.cachedSponsoredCallback)
+      return this.cachedSponsoredCallback;
+    const provider = this.requireConnectedProvider();
+    const owner = this.state.walletAddress;
+    this.cachedSponsoredCallback = makeSponsoredDepositCallback({
+      apiKey: this.apiKey,
+      ownerAddress: owner,
+      tokenAddressByChain: SPONSORED_USDC_BY_CHAIN,
+      // Casts work around viem's chain-narrowed Client vs the generic
+      // PublicClient/WalletClient param types — structurally identical at
+      // runtime, but the two share a name TS treats as unrelated.
+      getPublicClient: (cid) => createPublicClient2({
+        chain: VIEM_CHAIN2[cid],
+        transport: custom(provider)
+      }),
+      getWalletClient: (cid) => createWalletClient({
+        account: owner,
+        chain: VIEM_CHAIN2[cid],
+        transport: custom(provider)
+      })
+    });
+    return this.cachedSponsoredCallback;
+  }
   getAgent(agentId) {
     const agent = this.agents.get(agentId);
     if (!agent) {
@@ -1156,6 +1525,7 @@ var OwneySDK = class {
     }
     const state = this.requireState();
     const chainId = this.requireChainId();
+    const effectiveCallback = depositCallback ?? (asset === "WETH" ? void 0 : this.getDefaultSponsoredCallback());
     if (agentId) {
       if (this.isAgentDisabled(agentId)) {
         throw new OwneyError(
@@ -1170,7 +1540,13 @@ var OwneySDK = class {
       return withFailureReporting(
         this.apiKey,
         agent.id,
-        () => agent.deposit(state, chainId, amount, depositCallback)
+        () => agent.deposit(
+          state,
+          chainId,
+          amount,
+          asset,
+          effectiveCallback
+        )
       );
     }
     const totalAmount = BigInt(amount);
@@ -1204,7 +1580,13 @@ var OwneySDK = class {
       agentResults[agent.id] = await withFailureReporting(
         this.apiKey,
         agent.id,
-        () => agent.deposit(state, chainId, agentAmount, depositCallback)
+        () => agent.deposit(
+          state,
+          chainId,
+          agentAmount,
+          asset,
+          effectiveCallback
+        )
       );
     }
     return { agentResults };
@@ -1398,10 +1780,7 @@ var OwneySDK = class {
       disabledBalances,
       requested
     );
-    const enabledTotal = enabledBalances.reduce(
-      (s, b) => s + b.balance,
-      0n
-    );
+    const enabledTotal = enabledBalances.reduce((s, b) => s + b.balance, 0n);
     const enabledPlans = afterDrain > 0n ? planProportionalShares(enabledBalances, afterDrain, enabledTotal) : enabledBalances.map(({ agent, balance }) => ({
       agent,
       balance,
@@ -1672,27 +2051,6 @@ var OwneySDK = class {
       nextCursor: hasMore ? encodeMultiAgentCursor(nextCursorMap) : void 0
     };
   }
-  // --- Agent control ---
-  /**
-   * Pause an agent's automated operations. The agent will stop rebalancing until resumed.
-   * @param agentId - The agent to pause (e.g. "zyfai")
-   * @returns OwneyAgentStatus with success flag
-   */
-  async pauseAgent(agentId) {
-    const state = this.requireState();
-    const chainId = this.requireChainId();
-    return this.getAgent(agentId).pause(state, chainId);
-  }
-  /**
-   * Resume an agent's automated operations.
-   * @param agentId - The agent to resume (e.g. "zyfai")
-   * @returns OwneyAgentStatus with success flag
-   */
-  async resumeAgent(agentId) {
-    const state = this.requireState();
-    const chainId = this.requireChainId();
-    return this.getAgent(agentId).resume(state, chainId);
-  }
   /**
    * Get the user's profile for a specific agent, or all agents.
    * @param agentId - Optional. Agent to query. Omit for all agents.
@@ -1767,12 +2125,13 @@ var OwneySDK = class {
     const chainId = this.requireChainId();
     const activeAgents = this.getActiveAgents();
     const balances = {};
+    const positionsByAgent = {};
     let totalBalance = 0;
     const entries = [...activeAgents.entries()];
     const balanceResults = await Promise.allSettled(
       entries.map(async ([id, agent]) => {
         const b = await agent.getBalances(state, chainId);
-        return [id, Number(b.totalBalance)];
+        return [id, Number(b.totalBalance), b.positions ?? []];
       })
     );
     let successCount = 0;
@@ -1781,8 +2140,9 @@ var OwneySDK = class {
       const settledResult = balanceResults[i];
       const [agentId] = entries[i];
       if (settledResult.status === "fulfilled") {
-        const [id, bal] = settledResult.value;
+        const [id, bal, agentPositions] = settledResult.value;
         balances[id] = bal;
+        positionsByAgent[id] = agentPositions;
         totalBalance += bal;
         successCount += 1;
       } else {
@@ -1816,7 +2176,64 @@ var OwneySDK = class {
       }
     }
     return {
-      agentAllocation: allocation
+      agentAllocation: allocation,
+      agentPositions: positionsByAgent
+    };
+  }
+  /**
+   * Allocation-weighted APY from the current portfolio: each pool's APY
+   * weighted by the user's position value in it. More accurate per-user than
+   * the historical 30D APY. (ROUT-228)
+   * @param options.agentId - Optional. Scope to one agent. Omit to aggregate
+   *   positions across all active agents.
+   */
+  async getAllocationApy({
+    agentId
+  } = {}) {
+    const state = this.requireState();
+    const chainId = this.requireChainId();
+    const activeAgents = agentId ? /* @__PURE__ */ new Map([[agentId, this.getAgent(agentId)]]) : this.getActiveAgents();
+    const entries = [...activeAgents.entries()];
+    const balanceResults = await Promise.allSettled(
+      entries.map(async ([id, agent]) => {
+        const b = await agent.getBalances(state, chainId);
+        return [id, b.positions ?? []];
+      })
+    );
+    const agentApy = {};
+    const allPositions = [];
+    let successCount = 0;
+    const agentErrors = {};
+    for (let i = 0; i < balanceResults.length; i++) {
+      const settled = balanceResults[i];
+      const [aid] = entries[i];
+      if (settled.status === "fulfilled") {
+        const [id, positions] = settled.value;
+        const per = computeAllocationApy(positions);
+        agentApy[id] = {
+          totalApy: per.totalApy,
+          apyByChainAndAsset: per.apyByChainAndAsset
+        };
+        allPositions.push(...positions);
+        successCount += 1;
+      } else {
+        const reason = settled.reason;
+        agentErrors[aid] = reason instanceof Error ? reason.message : String(reason);
+        console.error(`getAllocationApy agent "${aid}" failed:`, reason);
+      }
+    }
+    if (successCount === 0) {
+      throw new OwneyError(
+        "ALLOCATION_ALL_FAILED",
+        "Failed to fetch allocation APY: all agents failed.",
+        { agentErrors }
+      );
+    }
+    const overall = computeAllocationApy(allPositions);
+    return {
+      totalApy: overall.totalApy,
+      apyByChainAndAsset: overall.apyByChainAndAsset,
+      agentApy
     };
   }
 };
@@ -1980,9 +2397,9 @@ function buildSIWXConfig(deps) {
 }
 function createOwneySIWX(config) {
   const zyfai = new ZyfaiSDK2({ apiKey: config.apiKey });
-  const http = zyfai.httpClient;
+  const http2 = zyfai.httpClient;
   return buildSIWXConfig({
-    post: (url, data) => http.post(url, data),
+    post: (url, data) => http2.post(url, data),
     referralSource: config.referralSource
   });
 }