@owney/sdk 0.7.16-beta.1 → 0.7.16-beta.3

package/dist/index.js

@@ -147,18 +147,18 @@ function tokenDecimals(symbol, explicit) {
     return explicit;
   return DECIMALS_BY_SYMBOL[(symbol ?? "").toLowerCase()] ?? 6;
 }
-function mapDeposit(raw) {
+function mapDeposit(raw2) {
   return {
-    txHash: raw.txHash,
-    smartWallet: raw.smartWallet,
-    amount: raw.amount
+    txHash: raw2.txHash,
+    smartWallet: raw2.smartWallet,
+    amount: raw2.amount
   };
 }
-function mapWithdraw(raw) {
+function mapWithdraw(raw2) {
   return {
-    txHash: raw.txHash,
-    type: raw.type,
-    amount: raw.amount
+    txHash: raw2.txHash,
+    type: raw2.type,
+    amount: raw2.amount
   };
 }
 var CHAIN_ID_TO_NAME = {
@@ -177,10 +177,10 @@ function resolveChainId(chain) {
   if (Number.isFinite(asNum) && asNum > 0) return asNum;
   return NAME_TO_CHAIN_ID[chain.trim().toLowerCase()] ?? NaN;
 }
-function mapPendingAllocations(raw) {
-  if (!Array.isArray(raw)) return void 0;
+function mapPendingAllocations(raw2) {
+  if (!Array.isArray(raw2)) return void 0;
   const pending = [];
-  for (const entry of raw) {
+  for (const entry of raw2) {
     if (typeof entry !== "object" || entry === null) continue;
     const e = entry;
     if (typeof e.chainId !== "number" || !Number.isFinite(e.chainId)) continue;
@@ -203,8 +203,8 @@ function mapPendingAllocations(raw) {
   }
   return pending.length > 0 ? pending : void 0;
 }
-function mapBalances(raw, _chainId, smartWallet) {
-  const portfolio = raw.portfolio;
+function mapBalances(raw2, _chainId, smartWallet) {
+  const portfolio = raw2.portfolio;
   const portfolioByChain = portfolio.portfolioByChain ?? {};
   let totalBalance = 0;
   const tokens = [];
@@ -273,8 +273,8 @@ function sumTokenValues(tokens) {
 function sumTokenEarnings(tokens) {
   return Object.values(tokens).reduce((sum, val) => sum + Number(val), 0);
 }
-function mapEarnings(raw, smartWallet) {
-  const totalEarningsByChain = raw.data.totalEarningsByChainWithFee ?? raw.data.totalEarningsByChain ?? {};
+function mapEarnings(raw2, smartWallet) {
+  const totalEarningsByChain = raw2.data.totalEarningsByChainWithFee ?? raw2.data.totalEarningsByChain ?? {};
   const tokens = [];
   for (const [chainIdKey, tokensBySymbol] of Object.entries(
     totalEarningsByChain
@@ -293,22 +293,22 @@ function mapEarnings(raw, smartWallet) {
   return {
     smartWallet,
     lifetimeEarnings: sumTokenEarnings(
-      raw.data.totalEarningsByTokenWithFee ?? raw.data.totalEarningsByToken
+      raw2.data.totalEarningsByTokenWithFee ?? raw2.data.totalEarningsByToken
     ),
     tokens
   };
 }
-function mapWeightedApyByChain(raw) {
-  if (!raw) return void 0;
+function mapWeightedApyByChain(raw2) {
+  if (!raw2) return void 0;
   const out = {};
-  for (const [chainKey, tokenApy] of Object.entries(raw)) {
+  for (const [chainKey, tokenApy] of Object.entries(raw2)) {
     const chainId = Number(chainKey);
     if (!SUPPORTED_CHAIN_IDS.includes(chainId)) continue;
     const perAsset = {};
     for (const [symbol, apy] of Object.entries(tokenApy)) {
-      const token2 = symbol;
-      if (!SUPPORTED_TOKENS.includes(token2)) continue;
-      perAsset[token2] = apy;
+      const token = symbol;
+      if (!SUPPORTED_TOKENS.includes(token)) continue;
+      perAsset[token] = apy;
     }
     if (Object.keys(perAsset).length > 0) out[chainId] = perAsset;
   }
@@ -327,15 +327,15 @@ function rawPoolApyForChain(entry, chainId, tokenSymbol) {
   }
   return totalBalance > 0 ? weightedSum / totalBalance : null;
 }
-function mapApyHistory(raw, chainId, tokenSymbol) {
-  const history = Object.entries(raw.history ?? {}).map(([date, entry]) => ({
+function mapApyHistory(raw2, chainId, tokenSymbol) {
+  const history = Object.entries(raw2.history ?? {}).map(([date, entry]) => ({
     date,
     apy: rawPoolApyForChain(entry, chainId, tokenSymbol)
   })).filter((p) => p.apy !== null).sort((a, b) => a.date.localeCompare(b.date));
   return {
-    walletAddress: raw.walletAddress,
-    weightedApyAfterFee: raw.weightedApyAfterFee ? sumTokenValues(raw.weightedApyAfterFee) : void 0,
-    apyByChainAndAsset: mapWeightedApyByChain(raw.weightedApyAfterFeeByChain),
+    walletAddress: raw2.walletAddress,
+    weightedApyAfterFee: raw2.weightedApyAfterFee ? sumTokenValues(raw2.weightedApyAfterFee) : void 0,
+    apyByChainAndAsset: mapWeightedApyByChain(raw2.weightedApyAfterFeeByChain),
     history
   };
 }
@@ -427,23 +427,23 @@ function mapEntries(rawEntries, chainId) {
     };
   });
 }
-function mapUserProfile(raw, userAddress) {
+function mapUserProfile(raw2, userAddress) {
   return {
     address: userAddress,
-    smartWallet: raw.smartWallet || "",
-    chains: raw.chains || [],
-    strategy: raw.strategy,
-    hasActiveSessionKey: raw.hasActiveSessionKey || false,
-    protocols: raw.protocols || [],
-    splitting: raw.splitting,
-    minSplits: raw.minSplits
+    smartWallet: raw2.smartWallet || "",
+    chains: raw2.chains || [],
+    strategy: raw2.strategy,
+    hasActiveSessionKey: raw2.hasActiveSessionKey || false,
+    protocols: raw2.protocols || [],
+    splitting: raw2.splitting,
+    minSplits: raw2.minSplits
   };
 }
-function mapApyByStrategy(raw) {
+function mapApyByStrategy(raw2) {
   const apyPerAsset = {};
   let apySum = 0;
   let apyCount = 0;
-  for (const entry of raw.data) {
+  for (const entry of raw2.data) {
     const supported = SupportedAssets.find(
       (asset) => asset.chainId === entry.chain_id && asset.symbol === entry.token_symbol
     );
@@ -477,23 +477,23 @@ function computeAllocationApy(positions) {
     weightedSum += apy * value;
     totalValue += value;
     const chainId = resolveChainId(p.chain);
-    const token2 = p.asset;
+    const token = p.asset;
     if (!SUPPORTED_CHAIN_IDS.includes(chainId)) continue;
-    if (!SUPPORTED_TOKENS.includes(token2)) continue;
+    if (!SUPPORTED_TOKENS.includes(token)) continue;
     const perAsset = buckets[chainId] ?? {};
-    const cell = perAsset[token2] ?? { weightedSum: 0, value: 0 };
+    const cell = perAsset[token] ?? { weightedSum: 0, value: 0 };
     cell.weightedSum += apy * value;
     cell.value += value;
-    perAsset[token2] = cell;
+    perAsset[token] = cell;
     buckets[chainId] = perAsset;
   }
   const apyByChainAndAsset = {};
   for (const [chainKey, perAsset] of Object.entries(buckets)) {
     const chainId = Number(chainKey);
     const out = {};
-    for (const [token2, cell] of Object.entries(perAsset ?? {})) {
+    for (const [token, cell] of Object.entries(perAsset ?? {})) {
       if (cell && cell.value > 0) {
-        out[token2] = cell.weightedSum / cell.value;
+        out[token] = cell.weightedSum / cell.value;
       }
     }
     if (Object.keys(out).length > 0) apyByChainAndAsset[chainId] = out;
@@ -507,9 +507,9 @@ var TRANSFER_TOPIC = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4d
 function topicToAddress(topic) {
   return `0x${(topic ?? "").slice(-40)}`.toLowerCase();
 }
-function extractWithdrawnAmount(logs, recipient, token2, decimals) {
+function extractWithdrawnAmount(logs, recipient, token, decimals) {
   const wantRecipient = recipient.toLowerCase();
-  const wantToken = token2.toLowerCase();
+  const wantToken = token.toLowerCase();
   let total = 0n;
   let matched = false;
   for (const log of logs) {
@@ -535,11 +535,11 @@ var InvalidHistoryCursorError = class extends Error {
 function encodeHistoryCursor(payload) {
   return Buffer.from(JSON.stringify(payload), "utf8").toString("base64");
 }
-function decodeHistoryCursor(token2) {
-  if (!token2) throw new InvalidHistoryCursorError("Cursor is empty.");
+function decodeHistoryCursor(token) {
+  if (!token) throw new InvalidHistoryCursorError("Cursor is empty.");
   let parsed;
   try {
-    const json = Buffer.from(token2, "base64").toString("utf8");
+    const json = Buffer.from(token, "base64").toString("utf8");
     parsed = JSON.parse(json);
   } catch {
     throw new InvalidHistoryCursorError("Cursor is not valid base64 JSON.");
@@ -562,8 +562,8 @@ var storage = () => {
 };
 var buildKey = (address) => `${KEY_PREFIX}:${address.toLowerCase()}`;
 var legacyKeyPrefix = (address) => `${KEY_PREFIX}:${address.toLowerCase()}:`;
-var isJwtExpired = (token2) => {
-  const parts = token2.split(".");
+var isJwtExpired = (token) => {
+  const parts = token.split(".");
   if (parts.length !== 3) return false;
   try {
     const payload = parts[1].replace(/-/g, "+").replace(/_/g, "/");
@@ -610,15 +610,15 @@ var readSession = (address, _chainId) => {
   if (typeof window === "undefined") return null;
   const key2 = buildKey(address);
   const store = storage();
-  let raw = null;
+  let raw2 = null;
   try {
-    raw = store?.getItem(key2) ?? null;
+    raw2 = store?.getItem(key2) ?? null;
   } catch {
-    raw = null;
+    raw2 = null;
   }
-  if (raw) {
+  if (raw2) {
     try {
-      const parsed = JSON.parse(raw);
+      const parsed = JSON.parse(raw2);
       if (isFreshSession(parsed)) return parsed;
     } catch {
     }
@@ -786,8 +786,8 @@ function buildChainsByProtocol(protocols, dashboardChainIds) {
   }
   return result;
 }
-function flattenAvailablePools(raw) {
-  const byChain = raw ?? {};
+function flattenAvailablePools(raw2) {
+  const byChain = raw2 ?? {};
   const names = [];
   for (const byToken of Object.values(byChain ?? {})) {
     for (const entry of Object.values(byToken ?? {})) {
@@ -1298,8 +1298,8 @@ var ZyfaiAgent = class _ZyfaiAgent {
       const poolResults = await Promise.all(
         universe.map(async (protocol) => {
           try {
-            const raw = await this.sdk.getAvailablePools(protocol.id, strategy);
-            return [protocol.id, flattenAvailablePools(raw)];
+            const raw2 = await this.sdk.getAvailablePools(protocol.id, strategy);
+            return [protocol.id, flattenAvailablePools(raw2)];
           } catch (error) {
             console.warn(
               `[zyfai] applyPoolPolicy: getAvailablePools(${protocol.id}) failed, skipping this protocol (non-fatal):`,
@@ -1365,14 +1365,14 @@ var ZyfaiAgent = class _ZyfaiAgent {
   async readWalletState(ownerAddress) {
     try {
       const { portfolio } = await this.sdk.getPositions(ownerAddress);
-      const raw = portfolio;
+      const raw2 = portfolio;
       debugLog("zyfai:onboard", "wallet state from getPositions", {
-        predeployed: raw?.predeployed,
-        hasActiveSessionKey: raw?.hasActiveSessionKey
+        predeployed: raw2?.predeployed,
+        hasActiveSessionKey: raw2?.hasActiveSessionKey
       });
       return {
-        predeployed: raw?.predeployed,
-        hasActiveSessionKey: raw?.hasActiveSessionKey
+        predeployed: raw2?.predeployed,
+        hasActiveSessionKey: raw2?.hasActiveSessionKey
       };
     } catch (error) {
       console.warn(
@@ -1652,48 +1652,48 @@ var ZyfaiAgent = class _ZyfaiAgent {
         return { txHash, smartWallet, amount };
       }
       await this.ensureWalletDeployed(this.getAddress(), validChainId);
-      const raw = await this.sdk.depositFunds(
+      const raw2 = await this.sdk.depositFunds(
         this.getAddress(),
         validChainId,
         amount,
         asset,
         "aggressive"
       );
-      return mapDeposit(raw);
+      return mapDeposit(raw2);
     } catch (error) {
       throw error;
     }
   }
   // --- IAgent: Fund operations ---
-  async withdraw(state, chainId, token2, amount) {
+  async withdraw(state, chainId, token, amount) {
     const validChainId = isValidChainId(chainId);
     await this.ensureConnected(state, validChainId);
-    const raw = await this.sdk.withdrawFunds(
+    const raw2 = await this.sdk.withdrawFunds(
       this.getAddress(),
       validChainId,
       amount,
-      token2
+      token
     );
-    if (!raw.success) {
+    if (!raw2.success) {
       throw new OwneyError(
         "WITHDRAW_FAILED",
-        raw.message || "Zyfai withdraw failed.",
-        { chainId: validChainId, token: token2, amount, response: raw },
+        raw2.message || "Zyfai withdraw failed.",
+        { chainId: validChainId, token, amount, response: raw2 },
         this.id
       );
     }
-    return mapWithdraw(raw);
+    return mapWithdraw(raw2);
   }
   // --- IAgent: Portfolio reads ---
   async getBalances(state, chainId) {
     const { smartWallet, chainId: validChainId } = await this.resolveSmartWallet(state, chainId);
-    const raw = await this.sdk.getPortfolio(this.getAddress());
-    return mapBalances(raw, validChainId, smartWallet);
+    const raw2 = await this.sdk.getPortfolio(this.getAddress());
+    return mapBalances(raw2, validChainId, smartWallet);
   }
   async getEarnings(state, chainId) {
     const { smartWallet } = await this.resolveSmartWallet(state, chainId);
-    const raw = await this.sdk.getOnchainEarnings(smartWallet);
-    return mapEarnings(raw, smartWallet);
+    const raw2 = await this.sdk.getOnchainEarnings(smartWallet);
+    return mapEarnings(raw2, smartWallet);
   }
   async refreshEarnings(state, chainId) {
     if (this.earningsRefreshInFlight) return this.earningsRefreshInFlight;
@@ -1713,8 +1713,8 @@ var ZyfaiAgent = class _ZyfaiAgent {
   }
   async getAccountApy(state, chainId, days, tokenSymbol) {
     const { smartWallet } = await this.resolveSmartWallet(state, chainId);
-    const raw = await this.sdk.getDailyApyHistory(smartWallet, days);
-    return mapApyHistory(raw, chainId, tokenSymbol);
+    const raw2 = await this.sdk.getDailyApyHistory(smartWallet, days);
+    return mapApyHistory(raw2, chainId, tokenSymbol);
   }
   /**
    * Owney speaks asset symbols ("USDC" / "WETH"); Zyfai's history endpoint
@@ -1749,7 +1749,7 @@ var ZyfaiAgent = class _ZyfaiAgent {
     const matched = [];
     let backendExhausted = false;
     for (let i = 0; i < MAX_BACKEND_CALLS && matched.length < limit; i++) {
-      const raw = await this.sdk.getHistory(smartWallet, validChainId, {
+      const raw2 = await this.sdk.getHistory(smartWallet, validChainId, {
         limit: backendPageSize,
         offset,
         fromDate: options?.fromDate,
@@ -1760,13 +1760,13 @@ var ZyfaiAgent = class _ZyfaiAgent {
         // asset's rows and handing back a page that filters to nothing.
         assetType
       });
-      raw.data.forEach((entry, idx) => {
+      raw2.data.forEach((entry, idx) => {
         if (entry.chainId === validChainId) {
           matched.push({ entry, rawIdx: offset + idx });
         }
       });
-      offset += raw.data.length;
-      if (raw.data.length < backendPageSize) {
+      offset += raw2.data.length;
+      if (raw2.data.length < backendPageSize) {
         backendExhausted = true;
         break;
       }
@@ -1788,18 +1788,18 @@ var ZyfaiAgent = class _ZyfaiAgent {
   }
   async getUserProfile(state, chainId) {
     await this.connectAuth(state, chainId);
-    const raw = await this.sdk.getUserDetails();
+    const raw2 = await this.sdk.getUserDetails();
     debugLog("zyfai:profile", "getUserProfile \u2014 Zyfai reports", {
       asset: "USDC (default \u2014 no asset passed)",
-      splitting: raw.splitting,
-      minSplits: raw.minSplits,
-      strategy: raw.strategy,
-      chains: raw.chains,
-      protocolCount: raw.protocols?.length,
-      hasActiveSessionKey: raw.hasActiveSessionKey,
-      smartWallet: raw.smartWallet
+      splitting: raw2.splitting,
+      minSplits: raw2.minSplits,
+      strategy: raw2.strategy,
+      chains: raw2.chains,
+      protocolCount: raw2.protocols?.length,
+      hasActiveSessionKey: raw2.hasActiveSessionKey,
+      smartWallet: raw2.smartWallet
     });
-    return mapUserProfile(raw, this.connectedAddress);
+    return mapUserProfile(raw2, this.connectedAddress);
   }
   async ensureAutoSelectProtocols(state, chainId, asset) {
     await this.connectAuth(state, chainId);
@@ -1818,14 +1818,14 @@ var ZyfaiAgent = class _ZyfaiAgent {
   }
   // --- IAgent: Discovery (no wallet required) ---
   async getAgentApy(days, options) {
-    const raw = await this.sdk.getAPYPerStrategy(
+    const raw2 = await this.sdk.getAPYPerStrategy(
       false,
       DayFilterMapping[days],
       "aggressive",
       options?.chainId,
       options?.tokenSymbol
     );
-    return mapApyByStrategy(raw);
+    return mapApyByStrategy(raw2);
   }
 };
 
@@ -1834,9 +1834,10 @@ import {
   createPublicClient as createPublicClient3,
   createWalletClient as createWalletClient2,
   custom as custom2,
+  encodeFunctionData,
+  erc20Abi,
   getAddress as getAddress2,
-  isAddress,
-  parseUnits
+  isAddress as isAddress2
 } from "viem";
 import { base as base3 } from "viem/chains";
 
@@ -1898,10 +1899,10 @@ function buildTransferWithAuthorizationTypedData(input) {
     message: input.message
   };
 }
-async function readTokenMeta(publicClient, token2) {
+async function readTokenMeta(publicClient, token) {
   const [tokenName, tokenVersion] = await Promise.all([
-    publicClient.readContract({ address: token2, abi: ERC20_META_ABI, functionName: "name" }),
-    publicClient.readContract({ address: token2, abi: ERC20_META_ABI, functionName: "version" }).catch(() => "2")
+    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 };
 }
@@ -1913,6 +1914,45 @@ function randomAuthNonce() {
 
 // src/lib/sponsor-client.ts
 var ROUTING_API_BASE_URL = "https://owney-routing-api-243946518160.europe-west4.run.app";
+async function postPaymasterIntent(input) {
+  const base5 = input.baseUrl ?? ROUTING_API_BASE_URL;
+  let res;
+  try {
+    res = await fetch(`${base5}/api/v1/sponsor/paymaster-intent`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-owney-api-key": input.apiKey,
+        Authorization: `Signature ${input.yieldseekerSignature}`
+      },
+      body: JSON.stringify(input.body)
+    });
+  } catch (networkError) {
+    throw new OwneyError(
+      "SPONSOR_REQUEST_FAILED",
+      `Paymaster intent network error: ${networkError instanceof Error ? networkError.message : String(networkError)}`,
+      { cause: String(networkError), safeToFallback: true }
+    );
+  }
+  const text = await res.text();
+  let parsed = null;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+  }
+  if (!res.ok || !parsed?.success || typeof parsed.data?.intent !== "string" || typeof parsed.data.expiresAt !== "number") {
+    throw new OwneyError(
+      "SPONSOR_REQUEST_FAILED",
+      `Paymaster intent API error ${res.status}: ${parsed?.message ?? text.slice(0, 500)}`,
+      {
+        statusCode: res.status,
+        responseBody: text.slice(0, 500),
+        safeToFallback: true
+      }
+    );
+  }
+  return parsed.data;
+}
 async function postSponsorTransferAuth(input) {
   const base5 = input.baseUrl ?? ROUTING_API_BASE_URL;
   let res;
@@ -1922,7 +1962,7 @@ async function postSponsorTransferAuth(input) {
       headers: {
         "content-type": "application/json",
         "x-owney-api-key": input.apiKey,
-        ...input.yieldseekerSignature ? { "x-signature": input.yieldseekerSignature } : {}
+        ...input.yieldseekerSignature ? { Authorization: `Signature ${input.yieldseekerSignature}` } : {}
       },
       body: JSON.stringify(input.body)
     });
@@ -1963,7 +2003,7 @@ async function postSponsorPermit2Transfer(input) {
       headers: {
         "content-type": "application/json",
         "x-owney-api-key": input.apiKey,
-        ...input.yieldseekerSignature ? { "x-signature": input.yieldseekerSignature } : {}
+        ...input.yieldseekerSignature ? { Authorization: `Signature ${input.yieldseekerSignature}` } : {}
       },
       body: JSON.stringify(input.body)
     });
@@ -2091,17 +2131,17 @@ function randomPermit2Nonce() {
   globalThis.crypto.getRandomValues(bytes);
   return BigInt(bytesToHex2(bytes));
 }
-async function readPermit2Allowance(publicClient, token2, owner) {
+async function readPermit2Allowance(publicClient, token, owner) {
   return publicClient.readContract({
-    address: token2,
+    address: token,
     abi: ERC20_ALLOWANCE_ABI,
     functionName: "allowance",
     args: [owner, PERMIT2_ADDRESS]
   });
 }
-async function readErc20Balance(publicClient, token2, owner) {
+async function readErc20Balance(publicClient, token, owner) {
   return publicClient.readContract({
-    address: token2,
+    address: token,
     abi: ERC20_ALLOWANCE_ABI,
     functionName: "balanceOf",
     args: [owner]
@@ -2133,8 +2173,8 @@ function makeSponsoredDepositCallback(deps) {
   return makeVerificationAwareDepositCallback(
     async (smartWallet, chainId, amount, verification) => {
       const cid = chainId;
-      const token2 = deps.tokenAddressByChain[cid];
-      if (!token2) {
+      const token = deps.tokenAddressByChain[cid];
+      if (!token) {
         throw new OwneyError(
           "CHAIN_UNSUPPORTED",
           `No sponsored token configured for chain ${chainId}`
@@ -2144,12 +2184,12 @@ function makeSponsoredDepositCallback(deps) {
       const wallet = deps.getWalletClient(cid);
       await ensureWalletOnChain(pub, wallet, cid);
       try {
-        const balance = await readErc20Balance(pub, token2, deps.ownerAddress);
+        const balance = await readErc20Balance(pub, token, deps.ownerAddress);
         if (balance < BigInt(amount)) {
           throw new OwneyError(
             "DEPOSIT_INSUFFICIENT_BALANCE",
             "Insufficient balance for this deposit.",
-            { token: token2, chainId: cid, balance: balance.toString(), amount }
+            { token, chainId: cid, balance: balance.toString(), amount }
           );
         }
       } catch (err) {
@@ -2159,14 +2199,14 @@ function makeSponsoredDepositCallback(deps) {
           err instanceof Error ? err.message : String(err)
         );
       }
-      const { tokenName, tokenVersion } = await readTokenMeta(pub, token2);
+      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: token2,
+        token,
         chainId: cid,
         tokenName,
         tokenVersion,
@@ -2190,7 +2230,7 @@ function makeSponsoredDepositCallback(deps) {
         ...verification?.agentId === "yieldseeker" ? { yieldseekerSignature: verification.signature } : {},
         body: {
           chainId: cid,
-          token: token2,
+          token,
           from: deps.ownerAddress,
           to: smartWallet,
           value: amount,
@@ -2199,7 +2239,11 @@ function makeSponsoredDepositCallback(deps) {
           nonce,
           authSignature,
           tokenName,
-          tokenVersion
+          tokenVersion,
+          ...verification?.agentId === "yieldseeker" ? {
+            yieldseekerUserId: verification.userId,
+            yieldseekerAgentId: verification.yieldseekerAgentId
+          } : {}
         }
       });
       return result.txHash;
@@ -2218,7 +2262,11 @@ import {
 import { base as base2 } from "viem/chains";
 
 // src/agents/yieldseeker/yieldseeker.auth-cache.ts
-var KEY_PREFIX2 = "owney.yieldseeker.session";
+var KEY_PREFIX2 = "owney.yieldseeker.session.v4";
+var INVALIDATED_KEY_PREFIXES = [
+  "owney.yieldseeker.session",
+  "owney.yieldseeker.session.v3"
+];
 var storage2 = () => {
   if (typeof window === "undefined") return null;
   try {
@@ -2228,6 +2276,18 @@ var storage2 = () => {
   }
 };
 var buildKey2 = (address, chainId) => `${KEY_PREFIX2}:${address.toLowerCase()}:${chainId}`;
+var invalidatedKeys = (address, chainId) => INVALIDATED_KEY_PREFIXES.map(
+  (prefix) => `${prefix}:${address.toLowerCase()}:${chainId}`
+);
+var clearInvalidatedSessions = (store, address, chainId) => {
+  for (const key2 of invalidatedKeys(address, chainId)) {
+    memorySessions2.delete(key2);
+    try {
+      store?.removeItem(key2);
+    } catch {
+    }
+  }
+};
 var memorySessions2 = /* @__PURE__ */ new Map();
 var isValidSession = (session) => {
   if (!session?.token) return false;
@@ -2242,15 +2302,16 @@ var readYieldseekerSession = (address, chainId) => {
   if (typeof window === "undefined") return null;
   const key2 = buildKey2(address, chainId);
   const store = storage2();
-  let raw = null;
+  clearInvalidatedSessions(store, address, chainId);
+  let raw2 = null;
   try {
-    raw = store?.getItem(key2) ?? null;
+    raw2 = store?.getItem(key2) ?? null;
   } catch {
-    raw = null;
+    raw2 = null;
   }
-  if (raw) {
+  if (raw2) {
     try {
-      const parsed = JSON.parse(raw);
+      const parsed = JSON.parse(raw2);
       if (isValidSession(parsed)) return parsed.token;
     } catch {
     }
@@ -2266,9 +2327,9 @@ var readYieldseekerSession = (address, chainId) => {
   if (cached) memorySessions2.delete(key2);
   return null;
 };
-var writeYieldseekerSession = (address, chainId, token2) => {
+var writeYieldseekerSession = (address, chainId, token) => {
   if (typeof window === "undefined") return;
-  const session = { token: token2 };
+  const session = { token };
   if (!isValidSession(session)) return;
   const key2 = buildKey2(address, chainId);
   memorySessions2.set(key2, session);
@@ -2282,6 +2343,7 @@ var clearYieldseekerSession = (address, chainId) => {
   const key2 = buildKey2(address, chainId);
   memorySessions2.delete(key2);
   const store = storage2();
+  clearInvalidatedSessions(store, address, chainId);
   try {
     store?.removeItem(key2);
   } catch {
@@ -2300,8 +2362,8 @@ function createYieldseekerSiweMessage(address, chainId, dependencies = {}) {
     issuedAt: (dependencies.now ?? (() => /* @__PURE__ */ new Date()))().toISOString()
   }).prepareMessage();
 }
-function encodeYieldseekerAuthToken(token2) {
-  const bytes = new TextEncoder().encode(JSON.stringify(token2));
+function encodeYieldseekerAuthToken(token) {
+  const bytes = new TextEncoder().encode(JSON.stringify(token));
   let binary = "";
   for (const byte of bytes) binary += String.fromCharCode(byte);
   return btoa(binary);
@@ -2330,10 +2392,10 @@ var YieldseekerAuth = class {
     }
     const inFlight = this.pending.get(key2);
     if (inFlight) return inFlight;
-    const request = this.sign(state, chainId).then((token2) => {
-      this.tokens.set(key2, token2);
-      writeYieldseekerSession(scope.address, scope.chainId, token2);
-      return token2;
+    const request = this.sign(state, chainId).then((token) => {
+      this.tokens.set(key2, token);
+      writeYieldseekerSession(scope.address, scope.chainId, token);
+      return token;
     });
     this.pending.set(key2, request);
     try {
@@ -2384,6 +2446,72 @@ var YieldseekerAuth = class {
   }
 };
 
+// src/agents/yieldseeker/yieldseeker.identity-cache.ts
+var KEY_PREFIX3 = "owney.yieldseeker.identity.v1";
+var YIELDSEEKER_IDENTITY_TTL_MS = 24 * 60 * 60 * 1e3;
+var memoryIdentities = /* @__PURE__ */ new Map();
+var storage3 = () => {
+  if (typeof window === "undefined") return null;
+  try {
+    return window.localStorage;
+  } catch {
+    return null;
+  }
+};
+var keyFor = (walletAddress, chainId) => `${KEY_PREFIX3}:${walletAddress.toLowerCase()}:${chainId}`;
+function valid(value, walletAddress, chainId, now) {
+  return Boolean(
+    value && typeof value.userId === "string" && /^[a-zA-Z0-9_-]{1,128}$/.test(value.userId) && value.walletAddress.toLowerCase() === walletAddress.toLowerCase() && value.chainId === chainId && Number.isSafeInteger(value.expiresAt) && value.expiresAt > now
+  );
+}
+function readYieldseekerIdentity(walletAddress, chainId, now = Date.now()) {
+  if (typeof window === "undefined") return null;
+  const key2 = keyFor(walletAddress, chainId);
+  const store = storage3();
+  let parsed = null;
+  try {
+    const raw2 = store?.getItem(key2);
+    parsed = raw2 ? JSON.parse(raw2) : null;
+  } catch {
+    parsed = null;
+  }
+  const candidate = parsed ?? memoryIdentities.get(key2);
+  if (valid(candidate, walletAddress, chainId, now)) {
+    memoryIdentities.set(key2, candidate);
+    return { userId: candidate.userId };
+  }
+  memoryIdentities.delete(key2);
+  try {
+    store?.removeItem(key2);
+  } catch {
+  }
+  return null;
+}
+function writeYieldseekerIdentity(walletAddress, chainId, userId, now = Date.now()) {
+  if (typeof window === "undefined") return;
+  const identity = {
+    userId,
+    walletAddress,
+    chainId,
+    expiresAt: now + YIELDSEEKER_IDENTITY_TTL_MS
+  };
+  if (!valid(identity, walletAddress, chainId, now)) return;
+  const key2 = keyFor(walletAddress, chainId);
+  memoryIdentities.set(key2, identity);
+  try {
+    storage3()?.setItem(key2, JSON.stringify(identity));
+  } catch {
+  }
+}
+function clearYieldseekerIdentity(walletAddress, chainId) {
+  const key2 = keyFor(walletAddress, chainId);
+  memoryIdentities.delete(key2);
+  try {
+    storage3()?.removeItem(key2);
+  } catch {
+  }
+}
+
 // src/agents/yieldseeker/yieldseeker.client.ts
 var DEFAULT_ROUTING_API_BASE_URL = "https://owney-routing-api-243946518160.europe-west4.run.app";
 function getYieldseekerProxyBaseUrl(routingApiBaseUrl = DEFAULT_ROUTING_API_BASE_URL) {
@@ -2434,7 +2562,7 @@ var YieldseekerApiClient = class {
         headers: {
           "Content-Type": "application/json",
           "x-owney-api-key": this.owneyApiKey,
-          ...options.signature ? { "X-Signature": options.signature } : {}
+          ...options.signature ? { Authorization: `Signature ${options.signature}` } : {}
         },
         body: options.body ? JSON.stringify(options.body) : void 0,
         signal: controller.signal
@@ -2467,25 +2595,21 @@ var YieldseekerApiClient = class {
 };
 
 // src/agents/yieldseeker/yieldseeker.mapper.ts
-import { formatUnits } from "viem";
-var REBALANCE_AMOUNT_DECIMALS = {
-  USDC: 6,
-  WETH: 18
-};
-function rebalanceAmount(value, tokenSymbol) {
-  const decimals = REBALANCE_AMOUNT_DECIMALS[tokenSymbol.toUpperCase()];
-  if (decimals === void 0) {
-    return invalid(
-      "history",
-      `unsupported rebalance token ${tokenSymbol || "<empty>"}`
-    );
-  }
-  try {
-    return formatUnits(BigInt(value), decimals);
-  } catch {
-    return invalid("history", `invalid rebalance amount ${value}`);
+import { formatUnits, isAddress } from "viem";
+
+// src/agents/yieldseeker/yieldseeker.types.ts
+var YIELDSEEKER_ASSET_METADATA = {
+  USDC: {
+    address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    decimals: 6
+  },
+  WETH: {
+    address: "0x4200000000000000000000000000000000000006",
+    decimals: 18
   }
-}
+};
+
+// src/agents/yieldseeker/yieldseeker.mapper.ts
 function invalid(endpoint, detail) {
   throw new OwneyError(
     "AGENT_INVALID_RESPONSE",
@@ -2494,193 +2618,346 @@ function invalid(endpoint, detail) {
     "yieldseeker"
   );
 }
-function requireObject(value, endpoint) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return invalid(endpoint, "expected an object");
+function raw(value, endpoint) {
+  if (typeof value !== "string" || !/^-?[0-9]+$/.test(value)) {
+    return invalid(endpoint, "expected a base-10 integer string");
   }
-  return value;
+  return BigInt(value);
 }
-function requireEnvelope(value, key2, endpoint) {
-  const root = requireObject(value, endpoint);
-  return requireObject(root[key2], endpoint);
+function decimal(value, decimals, endpoint) {
+  return formatUnits(raw(value, endpoint), decimals);
 }
-function token(value) {
-  return {
-    chain: value.chain,
-    chainId: value.chainId,
-    asset: value.asset,
-    amount: String(value.amount)
-  };
+function usd(rawAmount, decimals, price) {
+  return Number(formatUnits(rawAmount, decimals)) * price;
 }
-function position(value) {
-  return {
-    chain: String(value.chain),
-    protocol: String(value.protocol),
-    ...value.protocolId ? { protocolId: value.protocolId } : {},
-    ...value.pool ? { pool: value.pool } : {},
-    asset: String(value.asset),
-    amount: String(value.amount),
-    ...value.amountRaw !== void 0 ? { amountRaw: value.amountRaw } : {},
-    ...typeof value.apy === "number" ? { apy: value.apy } : {},
-    ...typeof value.tvl === "number" ? { tvl: value.tvl } : {},
-    ...typeof value.liquidity === "number" ? { liquidity: value.liquidity } : {}
-  };
+function percent(value) {
+  const result = Number(value);
+  return Number.isFinite(result) ? result * 100 : 0;
 }
-function mapApyMatrix(matrix) {
-  const mapped = {};
-  for (const [chain, assets] of Object.entries(matrix ?? {})) {
-    const chainId = Number(chain);
-    if (chainId !== 8453 || !assets || typeof assets !== "object") continue;
-    mapped[8453] = {};
-    for (const [asset, apy] of Object.entries(assets)) {
-      if ((asset === "USDC" || asset === "WETH") && typeof apy === "number") {
-        mapped[8453][asset] = apy;
-      }
-    }
-  }
-  return mapped;
+var YIELDSEEKER_POSITIVE_YIELD_FEE_RATE = 0.1;
+function publicApyAfterYieldseekerFee(value) {
+  const grossPercent = percent(value);
+  if (grossPercent <= 0) return grossPercent;
+  const netPercent = grossPercent * (1 - YIELDSEEKER_POSITIVE_YIELD_FEE_RATE);
+  return Math.round(netPercent * 1e12) / 1e12;
+}
+function riskAdjustedApyForDays(option, days) {
+  if (days === "7D") return option.riskAdjustedApy7dAverage;
+  if (days === "30D") return option.riskAdjustedApy30dAverage;
+  return (option.riskAdjustedApy7dAverage + option.riskAdjustedApy30dAverage) / 2;
 }
-function mapYieldseekerProfile(value) {
-  const profile = requireEnvelope(
-    value,
-    "profile",
-    "profile"
+function assetAddressValue(record, address) {
+  const entry = Object.entries(record).find(
+    ([key2]) => key2.toLowerCase() === address.toLowerCase()
   );
-  if (typeof profile.address !== "string" || typeof profile.smartWallet !== "string" || !Array.isArray(profile.chains) || typeof profile.hasActiveSessionKey !== "boolean" || !Array.isArray(profile.protocols)) {
-    return invalid("profile", "missing required fields");
+  return entry?.[1] ?? "0";
+}
+function position(value, asset) {
+  const option = value?.yieldOption;
+  if (!option || typeof option.provider !== "string" || typeof option.name !== "string" || typeof option.address !== "string" || !isAddress(option.address)) {
+    return invalid("yield positions", "missing vault metadata");
   }
+  const decimals = YIELDSEEKER_ASSET_METADATA[asset].decimals;
   return {
-    address: profile.address,
-    smartWallet: profile.smartWallet,
-    chains: profile.chains.map(Number),
-    hasActiveSessionKey: profile.hasActiveSessionKey,
-    protocols: profile.protocols.map(String)
+    chain: "BASE",
+    protocol: option.provider,
+    protocolId: option.address,
+    pool: option.name,
+    asset,
+    amount: decimal(value.assetsRaw, decimals, "yield positions"),
+    amountRaw: String(value.assetsRaw),
+    apy: percent(option.riskAdjustedApy),
+    tvl: Number(option.totalDepositsUsd),
+    liquidity: Number(option.withdrawableDepositsUsd)
   };
 }
-function mapYieldseekerBalances(value) {
-  const balances = requireEnvelope(
-    value,
-    "balances",
-    "balances"
-  );
-  if (typeof balances.smartWallet !== "string" || typeof balances.totalBalance !== "string" || typeof balances.totalBalanceAsset !== "string" || !Array.isArray(balances.tokens) || !Array.isArray(balances.positions)) {
-    return invalid("balances", "missing required fields");
+function mapYieldseekerBalances(contexts) {
+  const tokens = [];
+  const positions = [];
+  let totalUsd = 0;
+  for (const context of contexts) {
+    const metadata = YIELDSEEKER_ASSET_METADATA[context.asset];
+    const idle = assetAddressValue(
+      context.snapshot.tokenBalances,
+      metadata.address
+    );
+    tokens.push({
+      chain: "BASE",
+      chainId: 8453,
+      asset: context.asset,
+      amount: decimal(idle, metadata.decimals, "snapshot")
+    });
+    positions.push(
+      ...context.positions.map((entry) => position(entry, context.asset))
+    );
+    totalUsd += usd(
+      raw(context.snapshot.totalValueBase, "snapshot"),
+      context.snapshot.baseAssetDecimals,
+      context.snapshot.baseAssetPriceUsd
+    );
   }
   return {
-    smartWallet: balances.smartWallet,
-    totalBalance: balances.totalBalance,
-    totalBalanceAsset: balances.totalBalanceAsset.toLowerCase(),
-    tokens: balances.tokens.map(token),
-    positions: balances.positions.map(position)
+    ...contexts.length === 1 ? { smartWallet: contexts[0].wallet.walletAddress } : {},
+    totalBalance: String(totalUsd),
+    totalBalanceAsset: "usdc",
+    tokens,
+    positions
   };
 }
-function mapYieldseekerEarnings(value) {
-  const earnings = requireEnvelope(
-    value,
-    "earnings",
-    "earnings"
-  );
-  if (typeof earnings.smartWallet !== "string" || typeof earnings.lifetimeEarnings !== "number" || !Array.isArray(earnings.tokens)) {
-    return invalid("earnings", "missing required fields");
+function mapYieldseekerEarnings(contexts) {
+  const tokens = [];
+  let lifetimeEarnings = 0;
+  for (const context of contexts) {
+    const amount = raw(context.snapshot.cumulativeYieldBase, "snapshot");
+    tokens.push({
+      chain: "BASE",
+      chainId: 8453,
+      asset: context.asset,
+      amount: formatUnits(amount, context.snapshot.baseAssetDecimals)
+    });
+    lifetimeEarnings += usd(
+      amount,
+      context.snapshot.baseAssetDecimals,
+      context.snapshot.baseAssetPriceUsd
+    );
   }
   return {
-    smartWallet: earnings.smartWallet,
-    lifetimeEarnings: earnings.lifetimeEarnings,
-    tokens: earnings.tokens.map(token)
+    smartWallet: contexts[0]?.wallet.walletAddress ?? "0x0000000000000000000000000000000000000000",
+    lifetimeEarnings,
+    tokens
   };
 }
-function mapYieldseekerApy(value) {
-  const apy = requireEnvelope(
-    value,
-    "apy",
-    "apy"
-  );
-  if (typeof apy.walletAddress !== "string" || typeof apy.weightedApyAfterFee !== "number" || !apy.apyByChainAndAsset || typeof apy.apyByChainAndAsset !== "object" || !Array.isArray(apy.history)) {
-    return invalid("apy", "missing required fields");
+function apyForDays(snapshot, days) {
+  if (days === "7D") return percent(snapshot.apy7d);
+  if (days === "30D") return percent(snapshot.apy30d);
+  return percent((snapshot.apy7d + snapshot.apy30d) / 2);
+}
+function dailyApy(point) {
+  const total = raw(point.totalValueBase, "historic position");
+  const earned = raw(point.dailyYieldBase, "historic position");
+  const principal = total - earned;
+  if (principal <= 0n || earned === 0n) return 0;
+  return Number(earned) / Number(principal) * 365 * 100;
+}
+function aggregateHistory(contexts, dayCount) {
+  const byDate = /* @__PURE__ */ new Map();
+  for (const context of contexts) {
+    const points = context.historic?.dailyYieldSnapshots ?? [];
+    for (const point of points.slice(-dayCount)) {
+      const valueUsd = usd(
+        raw(point.totalValueBase, "historic position"),
+        point.baseAssetDecimals,
+        point.baseAssetPriceUsd
+      );
+      const current = byDate.get(point.date) ?? { weighted: 0, valueUsd: 0 };
+      current.weighted += dailyApy(point) * valueUsd;
+      current.valueUsd += valueUsd;
+      byDate.set(point.date, current);
+    }
   }
+  return [...byDate.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([date, value]) => ({
+    date,
+    apy: value.valueUsd > 0 ? value.weighted / value.valueUsd : 0
+  }));
+}
+function mapYieldseekerApy(walletAddress, contexts, days) {
+  let weighted = 0;
+  let totalUsd = 0;
+  const byAsset = {};
+  for (const context of contexts) {
+    const valueUsd = usd(
+      raw(context.snapshot.totalValueBase, "snapshot"),
+      context.snapshot.baseAssetDecimals,
+      context.snapshot.baseAssetPriceUsd
+    );
+    const apy = apyForDays(context.snapshot, days);
+    weighted += apy * valueUsd;
+    totalUsd += valueUsd;
+    byAsset[context.asset] = apy;
+  }
+  const dayCount = Number(days.slice(0, -1));
   return {
-    walletAddress: apy.walletAddress,
-    weightedApyAfterFee: apy.weightedApyAfterFee,
-    apyByChainAndAsset: mapApyMatrix(apy.apyByChainAndAsset),
-    history: apy.history.map((point) => ({
-      date: String(point.date),
-      apy: Number(point.apy)
-    }))
+    walletAddress,
+    weightedApyAfterFee: totalUsd > 0 ? weighted / totalUsd : 0,
+    apyByChainAndAsset: { 8453: byAsset },
+    history: aggregateHistory(contexts, dayCount)
   };
 }
-function historyAction(value) {
-  const normalized = value.trim().toLowerCase();
-  if (normalized === "rebalance") return "Rebalance";
-  if (normalized === "deposit") return "Deposit";
-  if (normalized === "top up" || normalized === "topup") return "Top up";
-  if (normalized === "withdraw" || normalized === "withdrawal")
-    return "Withdraw";
-  if (normalized === "earned" || normalized === "earnings") return "Earned";
-  return invalid("history", `unsupported action ${value}`);
+function actionType(value) {
+  const normalized = value.toLowerCase();
+  if (normalized.includes("deposit")) return "Deposit";
+  if (normalized.includes("withdraw")) return "Withdraw";
+  if (normalized.includes("yield") || normalized.includes("earn"))
+    return "Earned";
+  return "Rebalance";
+}
+function transactionHashes(details) {
+  if (!details) return [];
+  const values = [
+    details.transactionHash,
+    details.txHash,
+    ...Array.isArray(details.transactionHashes) ? details.transactionHashes : [],
+    ...Array.isArray(details.txHashes) ? details.txHashes : []
+  ];
+  return values.filter(
+    (value) => typeof value === "string" && /^0x[a-fA-F0-9]{64}$/.test(value)
+  ).filter((value, index, all) => all.indexOf(value) === index);
 }
-function historyItem(value) {
+function actionEntry(action) {
+  if (action.actionType.toLowerCase().includes("withdraw")) return void 0;
   return {
     agent: "yieldseeker",
-    action: historyAction(value.action),
-    date: String(value.date),
-    oldApy: value.oldApy === null ? null : String(value.oldApy),
-    newApy: value.newApy === null ? null : String(value.newApy),
-    transactions: (value.transactions ?? []).map((transaction) => ({
-      txHashes: transaction.txHashes.map(String),
-      ...typeof transaction.chainId === "number" ? { chainId: transaction.chainId } : {},
-      ...typeof transaction.tokenSymbol === "string" ? { tokenSymbol: transaction.tokenSymbol } : {},
-      ...typeof transaction.amount === "string" ? { amount: transaction.amount } : {}
-    })),
-    rebalanceLog: (value.rebalanceLog ?? []).map((entry) => ({
-      fromProtocol: String(entry.fromProtocol),
-      toProtocol: String(entry.toProtocol),
-      ...entry.fromPool ? { fromPool: entry.fromPool } : {},
-      ...entry.toPool ? { toPool: entry.toPool } : {},
-      tokenSymbol: String(entry.tokenSymbol),
-      // Unlike Yieldseeker's other read-response amounts, live history
-      // rebalance amounts are returned in the token's smallest unit. Normalize
-      // them at the adapter boundary so every Owney consumer receives the
-      // shared human-readable decimal shape.
-      amount: rebalanceAmount(String(entry.amount), String(entry.tokenSymbol)),
-      status: entry.status
-    }))
+    action: actionType(action.actionType),
+    date: action.createdDate,
+    oldApy: null,
+    newApy: null,
+    transactions: [
+      {
+        txHashes: transactionHashes(action.details),
+        chainId: 8453
+      }
+    ],
+    rebalanceLog: []
   };
 }
-function mapYieldseekerHistory(value) {
-  const history = requireEnvelope(
-    value,
-    "history",
-    "history"
-  );
-  if (!Array.isArray(history.data) || typeof history.hasMore !== "boolean") {
-    return invalid("history", "missing required fields");
+function movementEntry(movement, wallet, agent, asset, ownerAddress, vaultAddresses) {
+  const from = movement.fromAddress.toLowerCase();
+  const to = movement.toAddress.toLowerCase();
+  const owner = ownerAddress.toLowerCase();
+  const agentWallet = wallet.walletAddress.toLowerCase();
+  const baseAsset = agent.assetAddress.toLowerCase();
+  if (movement.chainId !== agent.chainId || movement.assetAddress.toLowerCase() !== baseAsset) {
+    return void 0;
+  }
+  let action;
+  if (from === owner && to === agentWallet) {
+    action = "Top up";
+  } else if (from === agentWallet && to === owner) {
+    action = "Withdraw";
+  } else if (from === agentWallet && vaultAddresses.has(to)) {
+    action = "Deposit";
+  }
+  if (!action) return void 0;
+  return {
+    agent: "yieldseeker",
+    action,
+    date: movement.blockDate,
+    oldApy: null,
+    newApy: null,
+    transactions: [
+      {
+        txHashes: [movement.transactionHash],
+        chainId: agent.chainId,
+        tokenSymbol: asset,
+        amount: decimal(
+          movement.assetAmount,
+          YIELDSEEKER_ASSET_METADATA[asset].decimals,
+          "historic position"
+        )
+      }
+    ],
+    rebalanceLog: []
+  };
+}
+function mapYieldseekerHistory(contexts, options) {
+  const entries = contexts.flatMap((context) => {
+    const vaultAddresses = new Set(
+      context.positions.map(
+        (position2) => position2.yieldOption.address.toLowerCase()
+      )
+    );
+    return [
+      ...(context.historic?.movements ?? []).map(
+        (movement) => movementEntry(
+          movement,
+          context.wallet,
+          context.agent,
+          context.asset,
+          options.ownerAddress,
+          vaultAddresses
+        )
+      ),
+      ...(context.actions ?? []).map(actionEntry)
+    ].filter((entry) => entry !== void 0);
+  });
+  const filtered = entries.filter(
+    (entry) => (!options.fromDate || entry.date >= options.fromDate) && (!options.toDate || entry.date <= options.toDate)
+  ).filter((entry, index, all) => {
+    const transactionHash = entry.transactions[0]?.txHashes[0];
+    if (!transactionHash) return true;
+    return all.findIndex(
+      (candidate) => candidate.action === entry.action && candidate.transactions[0]?.txHashes[0] === transactionHash
+    ) === index;
+  }).sort((left, right) => right.date.localeCompare(left.date));
+  return {
+    data: filtered.slice(0, options.limit),
+    // v1 returns the whole action/movement collection and defines no cursor.
+    // Report a terminal page so callers never loop over the same prefix.
+    hasMore: false
+  };
+}
+function mapYieldseekerProfile(address, contexts) {
+  const protocols = /* @__PURE__ */ new Set();
+  for (const context of contexts) {
+    for (const current of context.positions) {
+      if (current.yieldOption?.provider) {
+        protocols.add(String(current.yieldOption.provider));
+      }
+    }
   }
   return {
-    data: history.data.map(historyItem),
-    hasMore: history.hasMore,
-    ...history.hasMore && typeof history.nextCursor === "string" ? { nextCursor: history.nextCursor } : {}
+    address,
+    smartWallet: contexts[0]?.wallet.walletAddress ?? "0x0000000000000000000000000000000000000000",
+    chains: contexts.length > 0 ? [8453] : [],
+    hasActiveSessionKey: contexts.some(
+      (context) => context.wallet.initializedDate != null
+    ),
+    protocols: [...protocols]
   };
 }
-function mapYieldseekerAgentApy(value) {
-  const agentApy = requireEnvelope(
-    value,
-    "agentApy",
-    "agent APY"
-  );
-  if (typeof agentApy.averageApy !== "number") {
-    return invalid("agent APY", "missing averageApy");
+function mapYieldseekerAgentApy(options, days) {
+  const perAsset = {};
+  const all = [];
+  for (const entry of options) {
+    const apys = entry.yieldOptions.map(
+      (option) => publicApyAfterYieldseekerFee(riskAdjustedApyForDays(option, days))
+    ).filter(Number.isFinite);
+    if (apys.length === 0) continue;
+    const average = apys.reduce((sum, value) => sum + value, 0) / apys.length;
+    perAsset[entry.asset] = average;
+    all.push(average);
   }
   return {
-    averageApy: agentApy.averageApy,
-    ...agentApy.detailedApys ? {
-      detailedApys: {
-        apyPerAsset: mapApyMatrix(agentApy.detailedApys.apyPerAsset)
-      }
-    } : {}
+    averageApy: all.length > 0 ? all.reduce((sum, value) => sum + value, 0) / all.length : 0,
+    detailedApys: { apyPerAsset: { 8453: perAsset } }
   };
 }
 
 // src/agents/yieldseeker/yieldseeker.agent.ts
+var OWNEY_AGENT_NAME = "owney";
+var YIELDSEEKER_AGENT_WALLET_ABI = [
+  {
+    type: "function",
+    name: "withdrawAssetToUser",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "recipient", type: "address" },
+      { name: "asset", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "withdrawAllAssetToUser",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "recipient", type: "address" },
+      { name: "asset", type: "address" }
+    ],
+    outputs: []
+  }
+];
 function query(params) {
   const search = new URLSearchParams();
   for (const [key2, value] of Object.entries(params)) {
@@ -2698,7 +2975,7 @@ var YieldseekerAgent = class {
       chainId: 8453,
       chain: "BASE",
       assets: [
-        { symbol: "USDC", minDepositAmount: "1" },
+        { symbol: "USDC", minDepositAmount: "10000000" },
         { symbol: "WETH", minDepositAmount: "1" }
       ]
     }
@@ -2707,7 +2984,9 @@ var YieldseekerAgent = class {
   auth;
   transactionExecutor;
   unwindReceiptWaiter;
-  activated = /* @__PURE__ */ new Set();
+  agentContexts = /* @__PURE__ */ new Map();
+  users = /* @__PURE__ */ new Map();
+  pendingAgents = /* @__PURE__ */ new Map();
   constructor(owneyApiKey, options = {}) {
     this.api = new YieldseekerApiClient(
       owneyApiKey,
@@ -2720,14 +2999,19 @@ var YieldseekerAgent = class {
   }
   async disconnect() {
     this.auth.clear();
-    this.activated.clear();
+    for (const key2 of this.users.keys()) {
+      const [walletAddress, chainId] = key2.split(":");
+      clearYieldseekerIdentity(walletAddress, Number(chainId));
+    }
+    this.users.clear();
+    this.agentContexts.clear();
+    this.pendingAgents.clear();
   }
   async activateAgent(state, chainId, asset) {
     this.assertChain(chainId);
-    await this.auth.getToken(state, chainId);
-    if (asset === "USDC" || asset === "WETH") {
-      await this.ensureActivated(state, chainId, asset);
-    }
+    const targetAsset = asset ?? "USDC";
+    this.assertAsset(targetAsset);
+    await this.ensureAgent(state, chainId, targetAsset);
   }
   async deposit(state, chainId, amount, asset, depositCallback) {
     this.assertChain(chainId);
@@ -2740,42 +3024,48 @@ var YieldseekerAgent = class {
         this.id
       );
     }
-    await this.ensureActivated(state, chainId, asset);
-    const response = await this.walletRequest(
-      state,
-      chainId,
-      "/deposits",
-      { method: "POST", body: { chainId, asset, amount } }
-    );
-    const deposit = response?.deposit;
-    if (!deposit?.transaction || typeof deposit.amount !== "string" || deposit.amount !== amount || typeof deposit.smartWallet !== "string" || !isAddress(deposit.smartWallet)) {
-      throw this.invalidResponse("deposit");
-    }
-    if (depositCallback) {
-      provideDepositVerificationContext(depositCallback, {
-        agentId: "yieldseeker",
-        // Re-read after /deposits so an authentication retry cannot forward
-        // the stale token that Yieldseeker just rejected.
-        signature: await this.auth.getToken(state, chainId)
-      });
-    }
-    const txHash = depositCallback ? await depositCallback(deposit.smartWallet, chainId, amount) : await this.submitTransaction(state, chainId, deposit.transaction);
-    const confirmation = await this.walletRequest(
-      state,
-      chainId,
-      "/deposits/confirm",
-      { method: "POST", body: { chainId, asset } }
-    );
-    if (typeof confirmation?.confirmation?.autoseekQueued !== "boolean") {
-      throw this.invalidResponse("deposit confirmation", {
-        transactionHash: txHash,
-        transactionConfirmed: true
-      });
+    const context = await this.ensureAgent(state, chainId, asset);
+    let txHash;
+    try {
+      if (depositCallback) {
+        provideDepositVerificationContext(depositCallback, {
+          agentId: "yieldseeker",
+          signature: await this.auth.getToken(state, chainId),
+          userId: context.user.userId,
+          yieldseekerAgentId: context.agent.agentId
+        });
+        txHash = await depositCallback(
+          context.wallet.walletAddress,
+          chainId,
+          amount
+        );
+        await this.waitForReceipt(state, chainId, txHash);
+      } else {
+        txHash = await this.submitTransaction(state, chainId, {
+          from: getAddress2(state.walletAddress),
+          to: YIELDSEEKER_ASSET_METADATA[asset].address,
+          data: encodeFunctionData({
+            abi: erc20Abi,
+            functionName: "transfer",
+            args: [getAddress2(context.wallet.walletAddress), BigInt(amount)]
+          }),
+          value: "0",
+          chainId
+        });
+      }
+      await this.deployAfterFunding(state, chainId, context);
+    } finally {
+      await this.refreshSnapshotAfterMovement(
+        state,
+        chainId,
+        context,
+        "deposit"
+      );
     }
     return {
       txHash,
-      smartWallet: deposit.smartWallet,
-      amount: deposit.amount
+      smartWallet: context.wallet.walletAddress,
+      amount
     };
   }
   async withdraw(state, chainId, asset, amount) {
@@ -2789,198 +3079,455 @@ var YieldseekerAgent = class {
         this.id
       );
     }
-    const balances = await this.getBalances(state, chainId);
-    const decimals = asset === "USDC" ? 6 : 18;
-    const targetAsset = asset.toUpperCase();
-    const idle = balances.tokens.filter(
-      (token2) => token2.chainId === chainId && token2.asset.toUpperCase() === targetAsset
-    ).reduce((total, token2) => total + parseUnits(token2.amount, decimals), 0n);
-    const positions = (balances.positions ?? []).filter(
-      (position2) => this.positionMatchesChain(position2.chain, chainId) && position2.asset.toUpperCase() === targetAsset
-    ).map((position2) => ({
-      position: position2,
-      amount: position2.amountRaw !== void 0 ? BigInt(position2.amountRaw) : parseUnits(position2.amount, decimals)
-    }));
-    const deployed = positions.reduce(
-      (total, position2) => total + position2.amount,
-      0n
-    );
-    const totalAvailable = idle + deployed;
-    const requested = amount === void 0 ? totalAvailable : BigInt(amount);
-    if (requested > totalAvailable) {
+    const context = await this.findAgent(state, chainId, asset);
+    if (!context) {
       throw new OwneyError(
         "WITHDRAW_INSUFFICIENT_BALANCE",
-        `Requested withdrawal "${requested.toString()}" exceeds available Yieldseeker balance "${totalAvailable.toString()}" for asset "${asset}".`,
-        {
-          asset,
-          requested: requested.toString(),
-          available: totalAvailable.toString()
-        },
+        `No Yieldseeker ${asset} agent exists for this wallet.`,
+        { asset, available: "0" },
         this.id
       );
     }
-    const requiredFromPositions = requested > idle ? requested - idle : 0n;
-    const unwindPlans = [];
-    let remainingToUnwind = requiredFromPositions;
-    for (const { position: position2, amount: positionAmount } of positions) {
-      if (remainingToUnwind === 0n) break;
-      if (positionAmount <= 0n) continue;
-      if (!position2.protocolId || !isAddress(position2.protocolId)) {
-        throw this.invalidResponse("position", {
-          reason: "A deployed position is missing its vault address.",
-          protocol: position2.protocol,
-          pool: position2.pool
+    try {
+      const portfolio = await this.loadPortfolioContext(
+        state,
+        chainId,
+        context
+      );
+      const metadata = YIELDSEEKER_ASSET_METADATA[asset];
+      const idleEntry = Object.entries(portfolio.snapshot.tokenBalances).find(
+        ([address]) => address.toLowerCase() === metadata.address.toLowerCase()
+      );
+      const idle = BigInt(idleEntry?.[1] ?? "0");
+      const deployed = portfolio.positions.reduce(
+        (total, position2) => total + BigInt(position2.withdrawableAssetsRaw),
+        0n
+      );
+      const totalAvailable = idle + deployed;
+      const requested = amount === void 0 ? totalAvailable : BigInt(amount);
+      if (requested > totalAvailable) {
+        throw new OwneyError(
+          "WITHDRAW_INSUFFICIENT_BALANCE",
+          `Requested withdrawal "${requested}" exceeds available Yieldseeker balance "${totalAvailable}" for asset "${asset}".`,
+          {
+            asset,
+            requested: requested.toString(),
+            available: totalAvailable.toString()
+          },
+          this.id
+        );
+      }
+      let remaining = requested > idle ? requested - idle : 0n;
+      for (const position2 of portfolio.positions) {
+        if (remaining === 0n) break;
+        const available = BigInt(position2.withdrawableAssetsRaw);
+        if (available <= 0n) continue;
+        const assetsRaw = available < remaining ? available : remaining;
+        const response = await this.walletRequest(
+          state,
+          chainId,
+          this.agentPath(context, "withdraw-from-position"),
+          {
+            method: "POST",
+            body: {
+              chainId,
+              vaultAddress: position2.yieldOption.address,
+              assetsRaw: assetsRaw.toString()
+            }
+          }
+        );
+        if (!this.isTransactionHash(response?.transactionHash)) {
+          throw this.invalidResponse("position withdrawal");
+        }
+        await this.waitForReceipt(state, chainId, response.transactionHash);
+        remaining -= assetsRaw;
+      }
+      if (remaining > 0n) {
+        throw this.invalidResponse("yield positions", {
+          reason: "Withdrawable positions could not cover the request.",
+          remaining: remaining.toString()
         });
       }
-      const unwindAmount = positionAmount < remainingToUnwind ? positionAmount : remainingToUnwind;
-      unwindPlans.push({
-        vaultAddress: getAddress2(position2.protocolId),
-        amount: unwindAmount
+      const account = getAddress2(state.walletAddress);
+      const txHash = await this.submitTransaction(state, chainId, {
+        from: account,
+        to: getAddress2(context.wallet.walletAddress),
+        data: amount === void 0 ? encodeFunctionData({
+          abi: YIELDSEEKER_AGENT_WALLET_ABI,
+          functionName: "withdrawAllAssetToUser",
+          args: [account, metadata.address]
+        }) : encodeFunctionData({
+          abi: YIELDSEEKER_AGENT_WALLET_ABI,
+          functionName: "withdrawAssetToUser",
+          args: [account, metadata.address, requested]
+        }),
+        value: "0",
+        chainId
       });
-      remainingToUnwind -= unwindAmount;
+      return {
+        txHash,
+        type: amount === void 0 ? "full" : "partial",
+        amount: requested.toString()
+      };
+    } finally {
+      await this.refreshSnapshotAfterMovement(
+        state,
+        chainId,
+        context,
+        "withdrawal"
+      );
     }
-    if (remainingToUnwind > 0n) {
-      throw this.invalidResponse("balances", {
-        reason: "Deployed position balances could not cover the unwind.",
-        required: requiredFromPositions.toString(),
-        planned: (requiredFromPositions - remainingToUnwind).toString()
-      });
+  }
+  async getBalances(state, chainId) {
+    this.assertChain(chainId);
+    return mapYieldseekerBalances(await this.loadPortfolio(state, chainId, {}));
+  }
+  async getEarnings(state, chainId) {
+    this.assertChain(chainId);
+    return mapYieldseekerEarnings(await this.loadPortfolio(state, chainId, {}));
+  }
+  async getAccountApy(state, chainId, days, tokenSymbol) {
+    this.assertChain(chainId);
+    const asset = tokenSymbol?.toUpperCase();
+    if (asset !== void 0) this.assertAsset(asset);
+    const contexts = await this.loadPortfolio(state, chainId, {
+      ...asset ? { asset } : {},
+      historic: true
+    });
+    return mapYieldseekerApy(state.walletAddress, contexts, days);
+  }
+  async getHistory(state, chainId, options) {
+    this.assertChain(chainId);
+    const asset = options?.tokenSymbol?.toUpperCase();
+    if (asset !== void 0) this.assertAsset(asset);
+    const contexts = await this.loadPortfolio(state, chainId, {
+      ...asset ? { asset } : {},
+      historic: true,
+      actions: true
+    });
+    return mapYieldseekerHistory(contexts, {
+      limit: options?.limit ?? 10,
+      ownerAddress: state.walletAddress,
+      ...options?.fromDate ? { fromDate: options.fromDate } : {},
+      ...options?.toDate ? { toDate: options.toDate } : {}
+    });
+  }
+  async getUserProfile(state, chainId) {
+    this.assertChain(chainId);
+    return mapYieldseekerProfile(
+      state.walletAddress,
+      await this.loadPortfolio(state, chainId, {})
+    );
+  }
+  async getAgentApy(days, options) {
+    this.assertOptionalChain(options?.chainId);
+    const requested = options?.tokenSymbol?.toUpperCase();
+    if (requested !== void 0) this.assertAsset(requested);
+    const assets = requested ? [requested] : ["USDC", "WETH"];
+    const values = await Promise.all(
+      assets.map(async (asset) => {
+        const metadata = YIELDSEEKER_ASSET_METADATA[asset];
+        const response = await this.api.request(
+          `/chains/8453/assets/${metadata.address}/yield-options`
+        );
+        if (!Array.isArray(response?.yieldOptions)) {
+          throw this.invalidResponse("yield options");
+        }
+        return { asset, yieldOptions: response.yieldOptions };
+      })
+    );
+    return mapYieldseekerAgentApy(values, days);
+  }
+  userKey(state, chainId) {
+    return `${state.walletAddress.toLowerCase()}:${chainId}`;
+  }
+  contextKey(state, chainId, asset) {
+    return `${this.userKey(state, chainId)}:${asset}`;
+  }
+  async resolveUser(state, chainId) {
+    const key2 = this.userKey(state, chainId);
+    const inMemory = this.users.get(key2);
+    if (inMemory) return inMemory;
+    const persisted = readYieldseekerIdentity(state.walletAddress, chainId);
+    if (persisted) {
+      this.users.set(key2, persisted);
+      return persisted;
     }
-    for (const plan of unwindPlans) {
-      const response2 = await this.walletRequest(
+    const walletAddress = getAddress2(state.walletAddress);
+    let user = null;
+    try {
+      const login = await this.providerRequest(
         state,
         chainId,
-        "/positions/unwind",
+        "/users/login-with-wallet",
+        { method: "POST", body: { walletAddress } }
+      );
+      user = login?.user ?? null;
+      if (!user) {
+        throw this.invalidResponse("wallet login", {
+          reason: "A successful login returned no user."
+        });
+      }
+    } catch (error) {
+      if (!(error instanceof YieldseekerApiError) || error.providerCode !== "NO_USER") {
+        if (error instanceof OwneyError) throw error;
+        throw this.mapApiError(error);
+      }
+      let created;
+      try {
+        created = await this.providerRequest(
+          state,
+          chainId,
+          "/users",
+          {
+            method: "POST",
+            body: {
+              walletAddress,
+              username: `owney-${walletAddress.slice(2).toLowerCase()}`
+            }
+          }
+        );
+      } catch (createError) {
+        throw this.mapApiError(createError);
+      }
+      user = created?.user ?? null;
+    }
+    if (!user || !/^[a-zA-Z0-9_-]{1,128}$/.test(user.userId)) {
+      throw this.invalidResponse("wallet identity");
+    }
+    const resolved = { userId: user.userId };
+    this.users.set(key2, resolved);
+    writeYieldseekerIdentity(state.walletAddress, chainId, resolved.userId);
+    return resolved;
+  }
+  forgetUser(state, chainId) {
+    this.users.delete(this.userKey(state, chainId));
+    clearYieldseekerIdentity(state.walletAddress, chainId);
+  }
+  async ensureAgent(state, chainId, asset) {
+    const key2 = this.contextKey(state, chainId, asset);
+    const cached = this.agentContexts.get(key2);
+    if (cached) return cached;
+    const pending = this.pendingAgents.get(key2);
+    if (pending) return pending;
+    const request = this.resolveAgent(state, chainId, asset, true).then(
+      (context) => {
+        if (!context) throw this.invalidResponse("agent creation");
+        this.agentContexts.set(key2, context);
+        return context;
+      }
+    );
+    this.pendingAgents.set(key2, request);
+    try {
+      return await request;
+    } finally {
+      this.pendingAgents.delete(key2);
+    }
+  }
+  async findAgent(state, chainId, asset) {
+    const key2 = this.contextKey(state, chainId, asset);
+    const cached = this.agentContexts.get(key2);
+    if (cached) return cached;
+    const context = await this.resolveAgent(state, chainId, asset, false);
+    if (context) this.agentContexts.set(key2, context);
+    return context;
+  }
+  async resolveAgent(state, chainId, asset, createIfMissing) {
+    const user = await this.resolveUser(state, chainId);
+    const response = await this.walletRequest(
+      state,
+      chainId,
+      `/users/${user.userId}/agents`
+    );
+    if (!Array.isArray(response?.agents)) {
+      throw this.invalidResponse("agent list");
+    }
+    const metadata = YIELDSEEKER_ASSET_METADATA[asset];
+    let agent = response.agents.find(
+      (candidate) => this.isOwneyAgent(candidate) && candidate.chainId === chainId && candidate.type === "vault" && candidate.assetAddress.toLowerCase() === metadata.address.toLowerCase()
+    );
+    if (!agent && createIfMissing) {
+      const created = await this.walletRequest(
+        state,
+        chainId,
+        `/users/${user.userId}/agents`,
         {
           method: "POST",
           body: {
+            name: OWNEY_AGENT_NAME,
+            emoji: "\u{1F989}",
             chainId,
-            asset,
-            vaultAddress: plan.vaultAddress,
-            amount: plan.amount.toString()
+            assetAddress: metadata.address,
+            type: "vault",
+            rulePreset: null
           }
         }
       );
-      const transactionHash = response2?.unwind?.transactionHash;
-      if (!this.isTransactionHash(transactionHash)) {
-        throw this.invalidResponse("position unwind");
-      }
-      await this.waitForUnwindReceipt(state, chainId, transactionHash);
+      agent = created?.agent;
     }
-    const response = await this.walletRequest(
+    if (!agent) return null;
+    this.assertAgent(agent);
+    const walletResponse = await this.walletRequest(
       state,
       chainId,
-      "/withdrawals",
-      {
-        method: "POST",
-        body: { chainId, asset, ...amount !== void 0 ? { amount } : {} }
-      }
+      `/users/${user.userId}/agents/${agent.agentId}/wallet`
     );
-    const withdrawal = response?.withdrawal;
-    if (!withdrawal?.transaction || typeof withdrawal.amount !== "string") {
-      throw this.invalidResponse("withdrawal");
+    if (!walletResponse?.agentWallet || !isAddress2(walletResponse.agentWallet.walletAddress)) {
+      throw this.invalidResponse("agent wallet");
     }
-    const txHash = await this.submitTransaction(
+    return { user, agent, wallet: walletResponse.agentWallet, asset };
+  }
+  async loadPortfolio(state, chainId, options) {
+    const user = await this.resolveUser(state, chainId);
+    const response = await this.walletRequest(
       state,
       chainId,
-      withdrawal.transaction
+      `/users/${user.userId}/agents`
     );
-    return {
-      txHash,
-      type: amount === void 0 ? "full" : "partial",
-      amount: withdrawal.amount
-    };
-  }
-  async getBalances(state, chainId) {
-    return mapYieldseekerBalances(
-      await this.walletRequest(
+    if (!Array.isArray(response?.agents)) {
+      throw this.invalidResponse("agent list");
+    }
+    const contexts = [];
+    for (const agent of response.agents) {
+      const asset = this.assetForAgent(agent);
+      if (!this.isOwneyAgent(agent) || !asset || agent.chainId !== chainId || agent.type !== "vault" || options.asset && options.asset !== asset) {
+        continue;
+      }
+      this.assertAgent(agent);
+      const walletResponse = await this.walletRequest(
         state,
         chainId,
-        `/balances${query({ chainId })}`
+        `/users/${user.userId}/agents/${agent.agentId}/wallet`
+      );
+      if (!walletResponse?.agentWallet || !isAddress2(walletResponse.agentWallet.walletAddress)) {
+        throw this.invalidResponse("agent wallet");
+      }
+      const context = {
+        user,
+        agent,
+        wallet: walletResponse.agentWallet,
+        asset
+      };
+      this.agentContexts.set(this.contextKey(state, chainId, asset), context);
+      contexts.push(context);
+    }
+    return Promise.all(
+      contexts.map(
+        (context) => this.loadPortfolioContext(state, chainId, context, options)
       )
     );
   }
-  async getEarnings(state, chainId) {
-    return mapYieldseekerEarnings(
-      await this.walletRequest(
+  async loadPortfolioContext(state, chainId, context, options = {}) {
+    const [snapshot, positions, historic, actions] = await Promise.all([
+      this.walletRequest(
         state,
         chainId,
-        `/earnings${query({ chainId })}`
-      )
-    );
+        `${this.agentPath(context, "snapshot")}${query({
+          shouldOnlyUseRecentValue: true,
+          shouldAllowStaleOnError: true
+        })}`
+      ),
+      this.walletRequest(
+        state,
+        chainId,
+        this.agentPath(context, "yield-positions")
+      ),
+      options.historic ? this.walletRequest(
+        state,
+        chainId,
+        this.agentPath(context, "wallet/historic-position")
+      ) : Promise.resolve(void 0),
+      options.actions ? this.walletRequest(
+        state,
+        chainId,
+        this.agentPath(context, "actions")
+      ) : Promise.resolve(void 0)
+    ]);
+    if (!snapshot?.agentSnapshot) {
+      throw this.invalidResponse("agent snapshot");
+    }
+    if (!Array.isArray(positions?.yieldPositions)) {
+      throw this.invalidResponse("yield positions");
+    }
+    return {
+      ...context,
+      snapshot: snapshot.agentSnapshot,
+      positions: positions.yieldPositions,
+      ...historic?.position ? { historic: historic.position } : {},
+      ...actions?.actions ? { actions: actions.actions } : {}
+    };
   }
-  async getAccountApy(state, chainId, days, tokenSymbol) {
-    return mapYieldseekerApy(
-      await this.walletRequest(
+  async deployAfterFunding(state, chainId, context) {
+    if (context.wallet.initializedDate != null) return;
+    try {
+      const deployed = await this.walletRequest(
         state,
         chainId,
-        `/apy${query({ chainId, days, tokenSymbol })}`
-      )
-    );
+        this.agentPath(context, "deploy"),
+        { method: "POST", body: {} }
+      );
+      if (deployed?.agentWallet) {
+        context.wallet = deployed.agentWallet;
+      }
+    } catch (error) {
+      console.warn(
+        "[owney-sdk] Yieldseeker deposit is funded but not deployable yet:",
+        error
+      );
+    }
   }
-  async getHistory(state, chainId, options) {
-    return mapYieldseekerHistory(
-      await this.walletRequest(
+  async refreshSnapshotAfterMovement(state, chainId, context, movement) {
+    try {
+      const response = await this.walletRequest(
         state,
         chainId,
-        `/history${query({
-          chainId,
-          limit: options?.limit ?? 10,
-          cursor: options?.cursor,
-          fromDate: options?.fromDate,
-          toDate: options?.toDate
+        `${this.agentPath(context, "snapshot")}${query({
+          shouldForceRefresh: true
         })}`
-      )
-    );
-  }
-  async getUserProfile(state, chainId) {
-    return mapYieldseekerProfile(
-      await this.walletRequest(state, chainId, `/profile${query({ chainId })}`)
-    );
+      );
+      if (!response?.agentSnapshot) {
+        throw this.invalidResponse("agent snapshot refresh");
+      }
+    } catch (error) {
+      console.warn(
+        `[owney-sdk] Yieldseeker ${movement} snapshot refresh failed:`,
+        error
+      );
+    }
   }
-  async getAgentApy(days, options) {
-    this.assertOptionalChain(options?.chainId);
-    return mapYieldseekerAgentApy(
-      await this.api.request(
-        `/agent/apy${query({
-          days,
-          tokenSymbol: options?.tokenSymbol,
-          chainId: options?.chainId
-        })}`
-      )
-    );
+  agentPath(context, suffix) {
+    return `/users/${context.user.userId}/agents/${context.agent.agentId}/${suffix}`;
   }
-  async ensureActivated(state, chainId, asset) {
-    const key2 = `${state.walletAddress.toLowerCase()}:${chainId}:${asset}`;
-    if (this.activated.has(key2)) return;
-    const response = await this.walletRequest(
-      state,
-      chainId,
-      "/activation",
-      { method: "POST", body: { chainId, asset } }
-    );
-    if (typeof response?.activation?.smartWallet !== "string" || typeof response.activation.deployed !== "boolean" || typeof response.activation.hasActiveSessionKey !== "boolean") {
-      throw this.invalidResponse("activation");
+  async walletRequest(state, chainId, path, options = {}) {
+    try {
+      return await this.providerRequest(state, chainId, path, options);
+    } catch (error) {
+      throw this.mapApiError(error);
     }
-    this.activated.add(key2);
   }
-  async walletRequest(state, chainId, path, options = {}) {
+  async providerRequest(state, chainId, path, options = {}) {
     this.assertChain(chainId);
+    const request = (signature2) => this.api.request(path, {
+      ...options,
+      signature: signature2
+    });
     let signature = await this.auth.getToken(state, chainId);
     try {
-      return await this.api.request(path, { ...options, signature });
+      return await request(signature);
     } catch (error) {
       if (!(error instanceof YieldseekerApiError)) throw error;
-      if (error.isAuthenticationError) {
-        this.auth.clear(state, chainId);
-        signature = await this.auth.getToken(state, chainId);
-        try {
-          return await this.api.request(path, { ...options, signature });
-        } catch (retryError) {
-          throw this.mapApiError(retryError);
+      if (error.providerCode === "NO_USER") throw error;
+      if (!error.isAuthenticationError) throw error;
+      this.auth.clear(state, chainId);
+      signature = await this.auth.getToken(state, chainId);
+      try {
+        return await request(signature);
+      } catch (retryError) {
+        if (retryError instanceof YieldseekerApiError && retryError.isAuthenticationError) {
+          this.forgetUser(state, chainId);
         }
+        throw retryError;
       }
-      throw this.mapApiError(error);
     }
   }
   mapApiError(error) {
@@ -3008,15 +3555,8 @@ var YieldseekerAgent = class {
     if (this.transactionExecutor) {
       return this.transactionExecutor(state, chainId, transaction);
     }
-    if (typeof transaction.from !== "string" || typeof transaction.to !== "string" || typeof transaction.data !== "string" || typeof transaction.value !== "string" || transaction.chainId !== chainId) {
-      throw this.invalidResponse("transaction");
-    }
+    this.assertTransaction(transaction, state, chainId);
     const account = getAddress2(state.walletAddress);
-    if (getAddress2(transaction.from) !== account) {
-      throw this.invalidResponse("transaction", {
-        reason: "transaction.from does not match the connected wallet"
-      });
-    }
     const walletClient = createWalletClient2({
       account,
       chain: base3,
@@ -3052,7 +3592,7 @@ var YieldseekerAgent = class {
     }
     return hash;
   }
-  async waitForUnwindReceipt(state, chainId, transactionHash) {
+  async waitForReceipt(state, chainId, transactionHash) {
     if (this.unwindReceiptWaiter) {
       await this.unwindReceiptWaiter(state, chainId, transactionHash);
       return;
@@ -3068,15 +3608,32 @@ var YieldseekerAgent = class {
     if (receipt.status !== "success") {
       throw new OwneyError(
         "AGENT_TRANSACTION_REVERTED",
-        `Yieldseeker position unwind reverted (${transactionHash}).`,
+        `Yieldseeker transaction reverted (${transactionHash}).`,
         { transactionHash },
         this.id
       );
     }
   }
-  positionMatchesChain(chain, chainId) {
-    const normalized = chain.trim().toUpperCase();
-    return normalized === String(chainId) || normalized === "BASE";
+  assertTransaction(transaction, state, chainId) {
+    if (!transaction || typeof transaction.from !== "string" || !isAddress2(transaction.from) || typeof transaction.to !== "string" || !isAddress2(transaction.to) || typeof transaction.data !== "string" || !/^0x[a-fA-F0-9]*$/.test(transaction.data) || typeof transaction.value !== "string" || !/^[0-9]+$/.test(transaction.value) || transaction.chainId !== chainId || getAddress2(transaction.from) !== getAddress2(state.walletAddress)) {
+      throw this.invalidResponse("transaction");
+    }
+  }
+  assertAgent(agent) {
+    if (typeof agent.agentId !== "string" || typeof agent.assetAddress !== "string" || !isAddress2(agent.assetAddress) || agent.chainId !== 8453) {
+      throw this.invalidResponse("agent");
+    }
+  }
+  isOwneyAgent(agent) {
+    return typeof agent.name === "string" && agent.name.trim().toLowerCase() === OWNEY_AGENT_NAME;
+  }
+  assetForAgent(agent) {
+    for (const asset of ["USDC", "WETH"]) {
+      if (agent.assetAddress.toLowerCase() === YIELDSEEKER_ASSET_METADATA[asset].address.toLowerCase()) {
+        return asset;
+      }
+    }
+    return null;
   }
   isTransactionHash(value) {
     return typeof value === "string" && /^0x[a-fA-F0-9]{64}$/.test(value);
@@ -3098,8 +3655,12 @@ var YieldseekerAgent = class {
     if (asset !== "USDC" && asset !== "WETH") {
       throw new OwneyError(
         "ASSET_UNSUPPORTED",
-        `Yieldseeker does not support asset ${asset}.`,
-        { asset, supportedAssets: ["USDC", "WETH"] },
+        `Yieldseeker does not support asset ${asset} in the Owney rollout.`,
+        {
+          asset,
+          supportedAssets: ["USDC", "WETH"],
+          providerAlsoAdvertises: ["cbBTC"]
+        },
         this.id
       );
     }
@@ -3212,7 +3773,7 @@ async function withFailureReporting(apiKey, agentType, fn, baseUrl) {
 }
 
 // src/lib/helpers/withdraw-helper.ts
-import { parseUnits as parseUnits2 } from "viem";
+import { parseUnits } from "viem";
 function projectAgentBalancesForAsset(agents, aggregated, chainId, asset, decimals) {
   const target = asset.toUpperCase();
   return agents.map((agent) => {
@@ -3220,7 +3781,7 @@ function projectAgentBalancesForAsset(agents, aggregated, chainId, asset, decima
     const tokenBalance = agentBalance?.tokens.find(
       (t) => t.chainId === chainId && t.asset.toUpperCase() === target
     );
-    let balance = tokenBalance ? parseUnits2(tokenBalance.amount, decimals) : 0n;
+    let balance = tokenBalance ? parseUnits(tokenBalance.amount, decimals) : 0n;
     if (agent.balanceComposition === "tokens-plus-positions") {
       const chainNameById = {
         1: "ETHEREUM",
@@ -3239,7 +3800,7 @@ function projectAgentBalancesForAsset(agents, aggregated, chainId, asset, decima
           } catch {
           }
         }
-        balance += parseUnits2(position2.amount, decimals);
+        balance += parseUnits(position2.amount, decimals);
       }
     }
     return { agent, balance };
@@ -3321,11 +3882,11 @@ function balanceForApyScope(balance, chainId, tokenSymbol) {
     return Number.isFinite(total) && total > 0 ? total : 0;
   }
   const normalizedToken = tokenSymbol.toUpperCase();
-  return balance.tokens.reduce((total, token2) => {
-    if (Number(token2.chainId) !== chainId || String(token2.asset).toUpperCase() !== normalizedToken) {
+  return balance.tokens.reduce((total, token) => {
+    if (Number(token.chainId) !== chainId || String(token.asset).toUpperCase() !== normalizedToken) {
       return total;
     }
-    const amount = Number(token2.amount);
+    const amount = Number(token.amount);
     return Number.isFinite(amount) && amount > 0 ? total + amount : total;
   }, 0);
 }
@@ -3399,8 +3960,8 @@ function makeSponsoredWethCallback(deps) {
   return makeVerificationAwareDepositCallback(
     async (smartWallet, chainId, amount, verification) => {
       const cid = chainId;
-      const token2 = deps.tokenAddressByChain[cid];
-      if (!token2) {
+      const token = deps.tokenAddressByChain[cid];
+      if (!token) {
         throw new OwneyError(
           "CHAIN_UNSUPPORTED",
           `No sponsored WETH configured for chain ${chainId}`
@@ -3411,12 +3972,12 @@ function makeSponsoredWethCallback(deps) {
       const wallet = deps.getWalletClient(cid);
       await ensureWalletOnChain(pub, wallet, cid);
       try {
-        const balance = await readErc20Balance(pub, token2, deps.ownerAddress);
+        const balance = await readErc20Balance(pub, token, deps.ownerAddress);
         if (balance < amountWei) {
           throw new OwneyError(
             "DEPOSIT_INSUFFICIENT_BALANCE",
             "Insufficient WETH balance for this deposit.",
-            { token: token2, chainId: cid, balance: balance.toString(), amount }
+            { token, chainId: cid, balance: balance.toString(), amount }
           );
         }
       } catch (err) {
@@ -3428,14 +3989,14 @@ function makeSponsoredWethCallback(deps) {
       }
       const allowance = await readPermit2Allowance(
         pub,
-        token2,
+        token,
         deps.ownerAddress
       );
       if (allowance < amountWei) {
         throw new OwneyError(
           "PERMIT2_APPROVAL_REQUIRED",
           "WETH gasless deposits need a one-time Permit2 approval; call approvePermit2() first",
-          { token: token2, chainId: cid, allowance: allowance.toString(), amount }
+          { token, chainId: cid, allowance: allowance.toString(), amount }
         );
       }
       const relayer = await get({
@@ -3450,7 +4011,7 @@ function makeSponsoredWethCallback(deps) {
       const typedData = buildPermitTransferFromTypedData({
         chainId: cid,
         message: {
-          permitted: { token: token2, amount: amountWei },
+          permitted: { token, amount: amountWei },
           spender: relayer,
           nonce,
           deadline
@@ -3467,13 +4028,17 @@ function makeSponsoredWethCallback(deps) {
         ...verification?.agentId === "yieldseeker" ? { yieldseekerSignature: verification.signature } : {},
         body: {
           chainId: cid,
-          token: token2,
+          token,
           from: deps.ownerAddress,
           to: smartWallet,
           amount,
           nonce: nonce.toString(),
           deadline: deadline.toString(),
-          signature
+          signature,
+          ...verification?.agentId === "yieldseeker" ? {
+            yieldseekerUserId: verification.userId,
+            yieldseekerAgentId: verification.yieldseekerAgentId
+          } : {}
         }
       });
       return result.txHash;
@@ -3482,7 +4047,7 @@ function makeSponsoredWethCallback(deps) {
 }
 
 // src/lib/sponsored-calls-deposit.ts
-import { encodeFunctionData, erc20Abi, toHex } from "viem";
+import { encodeFunctionData as encodeFunctionData2, erc20Abi as erc20Abi2, toHex } from "viem";
 var DEFAULT_POLL_INTERVAL_MS = 1500;
 var DEFAULT_MAX_POLLS = 30;
 async function paymasterSupported(provider, owner, chainId) {
@@ -3508,10 +4073,10 @@ function makeSponsoredCallsCallback(deps) {
     }
     return new URL(configured, origin).toString();
   };
-  return async (smartWallet, chainId, amount) => {
+  return makeVerificationAwareDepositCallback(async (smartWallet, chainId, amount, verification) => {
     const cid = chainId;
-    const token2 = deps.tokenAddressByChain[cid];
-    if (!token2) {
+    const token = deps.tokenAddressByChain[cid];
+    if (!token) {
       throw new OwneyError(
         "CHAIN_UNSUPPORTED",
         `No sponsored token configured for chain ${chainId}`
@@ -3524,11 +4089,37 @@ function makeSponsoredCallsCallback(deps) {
         { chainId }
       );
     }
-    const data = encodeFunctionData({
-      abi: erc20Abi,
+    const data = encodeFunctionData2({
+      abi: erc20Abi2,
       functionName: "transfer",
       args: [smartWallet, BigInt(amount)]
     });
+    let paymasterUrl = absolutePaymasterUrl();
+    if (verification?.agentId === "yieldseeker") {
+      if (chainId !== 8453) {
+        throw new OwneyError(
+          "CHAIN_UNSUPPORTED",
+          `Yieldseeker Base Account sponsorship is not available on chain ${chainId}.`
+        );
+      }
+      const { intent } = await postPaymasterIntent({
+        baseUrl: deps.routingApiBaseUrl,
+        apiKey: deps.apiKey,
+        yieldseekerSignature: verification.signature,
+        body: {
+          chainId,
+          token,
+          from: deps.ownerAddress,
+          to: smartWallet,
+          amount,
+          yieldseekerUserId: verification.userId,
+          yieldseekerAgentId: verification.yieldseekerAgentId
+        }
+      });
+      const url = new URL(paymasterUrl);
+      url.searchParams.set("owneyIntent", intent);
+      paymasterUrl = url.toString();
+    }
     const sendResult = await deps.provider.request({
       method: "wallet_sendCalls",
       params: [
@@ -3537,9 +4128,9 @@ function makeSponsoredCallsCallback(deps) {
           from: deps.ownerAddress,
           chainId: toHex(chainId),
           atomicRequired: false,
-          calls: [{ to: token2, value: "0x0", data }],
+          calls: [{ to: token, value: "0x0", data }],
           capabilities: {
-            paymasterService: { url: absolutePaymasterUrl() }
+            paymasterService: { url: paymasterUrl }
           }
         }
       ]
@@ -3569,17 +4160,17 @@ function makeSponsoredCallsCallback(deps) {
       `No receipt for calls ${callsId} after ${maxPolls} polls; the deposit may still settle.`,
       { chainId, callsId }
     );
-  };
+  });
 }
 
 // src/client.ts
 function encodeMultiAgentCursor(map) {
   return Buffer.from(JSON.stringify(map), "utf8").toString("base64");
 }
-function decodeMultiAgentCursor(token2) {
+function decodeMultiAgentCursor(token) {
   let parsed;
   try {
-    const json = Buffer.from(token2, "base64").toString("utf8");
+    const json = Buffer.from(token, "base64").toString("utf8");
     parsed = JSON.parse(json);
   } catch {
     throw new InvalidHistoryCursorError(
@@ -3768,6 +4359,8 @@ var OwneySDK = class {
     if (!onApproved && cached) return cached;
     const provider = this.requireConnectedProvider();
     const callback = makeSponsoredCallsCallback({
+      apiKey: this.apiKey,
+      routingApiBaseUrl: this.routingApiBaseUrl,
       provider,
       ownerAddress: this.state.walletAddress,
       paymasterServiceUrl: this.paymasterServiceUrl,
@@ -4210,15 +4803,15 @@ var OwneySDK = class {
       agent,
       amount: i === agents.length - 1 ? perAgent + remainder : perAgent
     }));
-    const valid = splits.filter(
+    const valid2 = splits.filter(
       (s) => exempt.has(s.agent.id) || s.amount >= this.getMinDepositAmount(s.agent, chainId, asset)
     );
-    if (valid.length === agents.length) {
+    if (valid2.length === agents.length) {
       return splits.map((s) => ({ agent: s.agent, amount: String(s.amount) }));
     }
     return this.splitDepositAmount(
       totalAmount,
-      valid.map((s) => s.agent),
+      valid2.map((s) => s.agent),
       chainId,
       asset,
       exempt
@@ -4251,10 +4844,10 @@ var OwneySDK = class {
     try {
       const balance = await agent.getBalances(state, chainId);
       const target = asset.toLowerCase();
-      const token2 = balance.tokens.find(
+      const token = balance.tokens.find(
         (t) => t.chainId === chainId && t.asset.toLowerCase() === target
       );
-      return !!token2 && Number(token2.amount) > 0;
+      return !!token && Number(token.amount) > 0;
     } catch {
       return false;
     }
@@ -4305,9 +4898,9 @@ var OwneySDK = class {
     const { asset, amount, agentId } = options;
     const state = this.requireState();
     const chainId = this.requireChainId();
-    const token2 = asset;
+    const token = asset;
     const assetInfo = SupportedAssets.find(
-      (a) => a.chainId === chainId && a.symbol === token2
+      (a) => a.chainId === chainId && a.symbol === token
     );
     if (!assetInfo) {
       throw new OwneyError(
@@ -4321,7 +4914,7 @@ var OwneySDK = class {
       return withFailureReporting(
         this.apiKey,
         agent.id,
-        () => agent.withdraw(state, chainId, token2, amount),
+        () => agent.withdraw(state, chainId, token, amount),
         this.routingApiBaseUrl
       );
     }
@@ -4331,7 +4924,7 @@ var OwneySDK = class {
       const agentErrors2 = {};
       for (const agent of eligibleAgents) {
         try {
-          results2[agent.id] = await agent.withdraw(state, chainId, token2);
+          results2[agent.id] = await agent.withdraw(state, chainId, token);
         } catch (err) {
           console.error(`withdraw failed for agent "${agent.id}":`, err);
           agentErrors2[agent.id] = err instanceof Error ? err.message : String(err);
@@ -4421,7 +5014,7 @@ var OwneySDK = class {
         results[p.agent.id] = await p.agent.withdraw(
           state,
           chainId,
-          token2,
+          token,
           p.planned.toString()
         );
       } catch (err) {
@@ -4772,8 +5365,8 @@ var OwneySDK = class {
     const state = this.requireState();
     const chainId = this.requireChainId();
     this.validateAssetSupport(this.getAgent("zyfai"), chainId, "WETH");
-    const token2 = SPONSORED_WETH_BY_CHAIN[chainId];
-    if (!token2) {
+    const token = SPONSORED_WETH_BY_CHAIN[chainId];
+    if (!token) {
       throw new OwneyError(
         "CHAIN_UNSUPPORTED",
         `No sponsored WETH on chain ${chainId}`
@@ -4786,7 +5379,7 @@ var OwneySDK = class {
       transport: custom3(provider)
     });
     const hash = await wallet.writeContract({
-      address: token2,
+      address: token,
       abi: ERC20_ALLOWANCE_ABI,
       functionName: "approve",
       args: [PERMIT2_ADDRESS, MAX_UINT256],
@@ -4911,8 +5504,8 @@ import { SiweMessage as SiweMessage2 } from "siwe";
 import { ZyfaiSDK as ZyfaiSDK2 } from "@zyfai/sdk";
 
 // src/agents/zyfai/zyfai.siwx-cache.ts
-var KEY_PREFIX3 = "owney.siwx.session";
-var storage3 = () => {
+var KEY_PREFIX4 = "owney.siwx.session";
+var storage4 = () => {
   if (typeof window === "undefined") return null;
   try {
     return window.localStorage;
@@ -4920,8 +5513,8 @@ var storage3 = () => {
     return null;
   }
 };
-var buildKey3 = (address) => `${KEY_PREFIX3}:${address.toLowerCase()}`;
-var legacyKeyPrefix2 = (address) => `${KEY_PREFIX3}:${address.toLowerCase()}:`;
+var buildKey3 = (address) => `${KEY_PREFIX4}:${address.toLowerCase()}`;
+var legacyKeyPrefix2 = (address) => `${KEY_PREFIX4}:${address.toLowerCase()}:`;
 var memorySiwxSessions = /* @__PURE__ */ new Map();
 var readLegacySiwxSession = (store, address) => {
   if (!store) return null;
@@ -4953,16 +5546,16 @@ var readLegacySiwxSession = (store, address) => {
 var readSiwxSession = (address, chainId) => {
   if (typeof window === "undefined") return null;
   const key2 = buildKey3(address);
-  const store = storage3();
-  let raw = null;
+  const store = storage4();
+  let raw2 = null;
   try {
-    raw = store?.getItem(key2) ?? null;
+    raw2 = store?.getItem(key2) ?? null;
   } catch {
-    raw = null;
+    raw2 = null;
   }
-  if (raw) {
+  if (raw2) {
     try {
-      return JSON.parse(raw);
+      return JSON.parse(raw2);
     } catch {
       memorySiwxSessions.delete(key2);
       try {
@@ -4983,7 +5576,7 @@ var writeSiwxSession = (address, _chainId, session) => {
   if (typeof window === "undefined") return;
   const key2 = buildKey3(address);
   memorySiwxSessions.set(key2, session);
-  const store = storage3();
+  const store = storage4();
   try {
     store?.setItem(key2, JSON.stringify(session));
   } catch {
@@ -4992,7 +5585,7 @@ var writeSiwxSession = (address, _chainId, session) => {
 var clearSiwxSession = (address, _chainId) => {
   const key2 = buildKey3(address);
   memorySiwxSessions.delete(key2);
-  const store = storage3();
+  const store = storage4();
   try {
     store?.removeItem(key2);
   } catch {