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

package/dist/index.js

@@ -6,7 +6,7 @@ var P_SUPPORTED_CHAINS = {
   chainIds: [8453, 42161],
   chains: ["BASE", "ARBITRUM"]
 };
-var SUPPORTED_TOKENS = ["USDC", "USDT"];
+var SUPPORTED_TOKENS = ["USDC", "USDT", "WETH"];
 var SUPPORTED_CHAIN_IDS = P_SUPPORTED_CHAINS.chainIds;
 var SUPPORTED_CHAINS = P_SUPPORTED_CHAINS.chains;
 var SupportedAssets = [
@@ -27,6 +27,18 @@ var SupportedAssets = [
     symbol: "USDT",
     chainId: 42161,
     decimals: 6
+  },
+  {
+    address: `0x4200000000000000000000000000000000000006`,
+    symbol: "WETH",
+    chainId: 8453,
+    decimals: 18
+  },
+  {
+    address: `0x82aF49447D8a07e3bd95BD0d56f35241523fBab1`,
+    symbol: "WETH",
+    chainId: 42161,
+    decimals: 18
   }
 ];
 
@@ -125,6 +137,18 @@ var CHAIN_ID_TO_NAME = {
   8453: "BASE",
   42161: "ARBITRUM"
 };
+var NAME_TO_CHAIN_ID = Object.entries(
+  CHAIN_ID_TO_NAME
+).reduce((acc, [id, name]) => {
+  acc[name.toLowerCase()] = Number(id);
+  return acc;
+}, {});
+function resolveChainId(chain) {
+  const asNum = Number(chain);
+  if (Number.isFinite(asNum) && asNum > 0)
+    return asNum;
+  return NAME_TO_CHAIN_ID[chain.trim().toLowerCase()] ?? NaN;
+}
 function mapBalances(raw, _chainId, smartWallet) {
   const portfolio = raw.portfolio;
   const portfolioByChain = portfolio.portfolioByChain ?? {};
@@ -145,10 +169,27 @@ function mapBalances(raw, _chainId, smartWallet) {
       });
     }
   }
+  const positions = (portfolio.positions ?? []).map((p) => ({
+    chain: p.chain ?? "",
+    protocol: p.protocol_name ?? p.protocol_id ?? "",
+    protocolId: p.protocol_id,
+    pool: p.pool,
+    asset: p.token_symbol ?? "",
+    // Position amount is hex-encoded base units (like the token balances
+    // above). Supported assets (USDC/USDT) are 6-decimal — hexToDecimal's
+    // default — so no per-token decimals lookup is needed.
+    amount: String(hexToDecimal(p.amount || "0")),
+    apy: p.pool_apy,
+    tvl: p.pool_tvl,
+    // PositionSlot has no `liquidity` field yet; Zyfai will add it. Narrow
+    // structural read keeps it undefined today and auto-populates later.
+    liquidity: p.liquidity
+  }));
   return {
     smartWallet,
     totalBalance: String(totalBalance),
-    tokens
+    tokens,
+    positions
   };
 }
 function sumTokenValues(tokens) {
@@ -256,13 +297,6 @@ function mapEntries(rawEntries, chainId) {
     };
   });
 }
-function mapAgentStatus(raw) {
-  return {
-    success: raw.success,
-    strategy: raw.strategy,
-    protocols: raw.protocols
-  };
-}
 function mapUserProfile(raw, userAddress) {
   return {
     address: userAddress,
@@ -298,6 +332,46 @@ function mapApyByStrategy(raw) {
     detailedApys: hasDetails ? { apyPerAsset } : void 0
   };
 }
+function computeAllocationApy(positions) {
+  let weightedSum = 0;
+  let totalValue = 0;
+  const buckets = {};
+  for (const p of positions) {
+    const apy = p.apy;
+    const value = Number(p.amount);
+    if (typeof apy !== "number" || !Number.isFinite(value) || value <= 0) {
+      continue;
+    }
+    weightedSum += apy * value;
+    totalValue += value;
+    const chainId = resolveChainId(p.chain);
+    const token = p.asset;
+    if (!SUPPORTED_CHAIN_IDS.includes(chainId))
+      continue;
+    if (!SUPPORTED_TOKENS.includes(token))
+      continue;
+    const perAsset = buckets[chainId] ?? {};
+    const cell = perAsset[token] ?? { weightedSum: 0, value: 0 };
+    cell.weightedSum += apy * value;
+    cell.value += value;
+    perAsset[token] = cell;
+    buckets[chainId] = perAsset;
+  }
+  const apyByChainAndAsset = {};
+  for (const [chainKey, perAsset] of Object.entries(buckets)) {
+    const chainId = Number(chainKey);
+    const out = {};
+    for (const [token, cell] of Object.entries(perAsset ?? {})) {
+      if (cell && cell.value > 0) {
+        out[token] = cell.weightedSum / cell.value;
+      }
+    }
+    if (Object.keys(out).length > 0)
+      apyByChainAndAsset[chainId] = out;
+  }
+  const totalApy = totalValue > 0 ? String(weightedSum / totalValue) : "0";
+  return { totalApy, apyByChainAndAsset };
+}
 
 // src/agents/zyfai/zyfai.history-cursor.ts
 var InvalidHistoryCursorError = class extends Error {
@@ -397,6 +471,10 @@ var DEFAULT_ZYFAI_RPC_URLS = {
   8453: "https://base-mainnet.g.alchemy.com/v2/ZWyVU-9XfS3z8Rn-xkq7V",
   42161: "https://arb-mainnet.g.alchemy.com/v2/ZWyVU-9XfS3z8Rn-xkq7V"
 };
+var WETH_ADDRESS_BY_CHAIN = {
+  8453: "0x4200000000000000000000000000000000000006",
+  42161: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1"
+};
 var ZyfaiAgent = class {
   id = "zyfai";
   supportedChainIds = [8453, 42161];
@@ -404,12 +482,18 @@ var ZyfaiAgent = class {
     {
       chainId: 8453,
       chain: "BASE",
-      assets: [{ symbol: "USDC", minDepositAmount: "1500000" }]
+      assets: [
+        { symbol: "USDC", minDepositAmount: "1500000" },
+        { symbol: "WETH", minDepositAmount: "500000000000000" }
+      ]
     },
     {
       chainId: 42161,
       chain: "ARBITRUM",
-      assets: [{ symbol: "USDC", minDepositAmount: "1500000" }]
+      assets: [
+        { symbol: "USDC", minDepositAmount: "1500000" },
+        { symbol: "WETH", minDepositAmount: "500000000000000" }
+      ]
     }
   ];
   sdk;
@@ -575,7 +659,7 @@ var ZyfaiAgent = class {
       throw error;
     }
   }
-  async deposit(state, chainId, amount, depositCallback) {
+  async deposit(state, chainId, amount, asset, depositCallback) {
     try {
       await this.connectFull(state, chainId);
       const validChainId = isValidChainId(chainId);
@@ -589,13 +673,15 @@ var ZyfaiAgent = class {
           validChainId,
           amount
         );
-        await this.sdk.logDeposit(validChainId, txHash, amount);
+        const tokenAddress = asset === "WETH" ? WETH_ADDRESS_BY_CHAIN[validChainId] : void 0;
+        await (tokenAddress ? this.sdk.logDeposit(validChainId, txHash, amount, tokenAddress) : this.sdk.logDeposit(validChainId, txHash, amount));
         return { txHash, smartWallet: wallet.address, amount };
       }
       const raw = await this.sdk.depositFunds(
         this.getAddress(),
         validChainId,
-        amount
+        amount,
+        asset
       );
       return mapDeposit(raw);
     } catch (error) {
@@ -680,17 +766,6 @@ var ZyfaiAgent = class {
       nextCursor
     };
   }
-  // --- IAgent: Agent control ---
-  async pause(state, chainId) {
-    await this.connectAuth(state, chainId);
-    const raw = await this.sdk.pauseAgent();
-    return mapAgentStatus(raw);
-  }
-  async resume(state, chainId) {
-    await this.connectAuth(state, chainId);
-    const raw = await this.sdk.resumeAgent();
-    return mapAgentStatus(raw);
-  }
   async getUserProfile(state, chainId) {
     await this.connectAuth(state, chainId);
     const validChainId = isValidChainId(chainId);
@@ -902,6 +977,134 @@ function aggregateApyByChainAndAsset(agentApys, agentBalances) {
   return out;
 }
 
+// src/client.ts
+import {
+  createPublicClient,
+  createWalletClient,
+  custom
+} from "viem";
+import { base, arbitrum } from "viem/chains";
+
+// src/lib/transfer-auth.ts
+import { bytesToHex } from "viem";
+var ERC20_META_ABI = [
+  { type: "function", name: "name", stateMutability: "view", inputs: [], outputs: [{ name: "", type: "string" }] },
+  { type: "function", name: "version", stateMutability: "view", inputs: [], outputs: [{ name: "", type: "string" }] }
+];
+function buildTransferWithAuthorizationTypedData(input) {
+  return {
+    domain: { name: input.tokenName, version: input.tokenVersion, chainId: input.chainId, verifyingContract: input.token },
+    types: {
+      TransferWithAuthorization: [
+        { name: "from", type: "address" },
+        { name: "to", type: "address" },
+        { name: "value", type: "uint256" },
+        { name: "validAfter", type: "uint256" },
+        { name: "validBefore", type: "uint256" },
+        { name: "nonce", type: "bytes32" }
+      ]
+    },
+    primaryType: "TransferWithAuthorization",
+    message: input.message
+  };
+}
+async function readTokenMeta(publicClient, token) {
+  const [tokenName, tokenVersion] = await Promise.all([
+    publicClient.readContract({ address: token, abi: ERC20_META_ABI, functionName: "name" }),
+    publicClient.readContract({ address: token, abi: ERC20_META_ABI, functionName: "version" }).catch(() => "2")
+  ]);
+  return { tokenName, tokenVersion };
+}
+function randomAuthNonce() {
+  const bytes = new Uint8Array(32);
+  globalThis.crypto.getRandomValues(bytes);
+  return bytesToHex(bytes);
+}
+
+// src/lib/sponsor-client.ts
+var ROUTING_API_BASE_URL3 = "https://owney-routing-api-243946518160.europe-west4.run.app";
+async function postSponsorTransferAuth(input) {
+  const base2 = input.baseUrl ?? ROUTING_API_BASE_URL3;
+  let res;
+  try {
+    res = await fetch(`${base2}/api/v1/sponsor/erc20-transfer-auth`, {
+      method: "POST",
+      headers: { "content-type": "application/json", "x-owney-api-key": input.apiKey },
+      body: JSON.stringify(input.body)
+    });
+  } catch (networkError) {
+    throw new OwneyError(
+      "SPONSOR_REQUEST_FAILED",
+      `Sponsor API network error: ${networkError instanceof Error ? networkError.message : String(networkError)}`,
+      { cause: String(networkError) }
+    );
+  }
+  const text = await res.text();
+  let parsed = null;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+  }
+  if (!res.ok || !parsed?.success || !parsed.data) {
+    throw new OwneyError(
+      "SPONSOR_REQUEST_FAILED",
+      `Sponsor API error ${res.status}: ${parsed?.message ?? text.slice(0, 500)}`,
+      { statusCode: res.status, responseBody: text.slice(0, 500) }
+    );
+  }
+  return parsed.data;
+}
+
+// src/lib/sponsored-deposit.ts
+var AUTH_WINDOW_SECONDS = 15 * 60;
+function makeSponsoredDepositCallback(deps) {
+  const post = deps.httpPost ?? postSponsorTransferAuth;
+  return async (smartWallet, chainId, amount) => {
+    const cid = chainId;
+    const token = deps.tokenAddressByChain[cid];
+    if (!token) {
+      throw new OwneyError(
+        "CHAIN_UNSUPPORTED",
+        `No sponsored token configured for chain ${chainId}`
+      );
+    }
+    const pub = deps.getPublicClient(cid);
+    const wallet = deps.getWalletClient(cid);
+    const { tokenName, tokenVersion } = await readTokenMeta(pub, token);
+    const validAfter = 0n;
+    const validBefore = BigInt(Math.floor(Date.now() / 1e3) + AUTH_WINDOW_SECONDS);
+    const nonce = randomAuthNonce();
+    const typedData = buildTransferWithAuthorizationTypedData({
+      token,
+      chainId: cid,
+      tokenName,
+      tokenVersion,
+      message: { from: deps.ownerAddress, to: smartWallet, value: BigInt(amount), validAfter, validBefore, nonce }
+    });
+    const authSignature = await wallet.signTypedData(
+      { account: deps.ownerAddress, ...typedData }
+    );
+    const result = await post({
+      baseUrl: deps.baseUrl,
+      apiKey: deps.apiKey,
+      body: {
+        chainId: cid,
+        token,
+        from: deps.ownerAddress,
+        to: smartWallet,
+        value: amount,
+        validAfter: validAfter.toString(),
+        validBefore: validBefore.toString(),
+        nonce,
+        authSignature,
+        tokenName,
+        tokenVersion
+      }
+    });
+    return result.txHash;
+  };
+}
+
 // src/client.ts
 function encodeMultiAgentCursor(map) {
   return Buffer.from(JSON.stringify(map), "utf8").toString("base64");
@@ -923,6 +1126,14 @@ function decodeMultiAgentCursor(token) {
   }
   return parsed;
 }
+var SPONSORED_USDC_BY_CHAIN = {
+  8453: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+  42161: "0xaf88d065e77c8cc2239327c5edb3a432268e5831"
+};
+var VIEM_CHAIN = {
+  8453: base,
+  42161: arbitrum
+};
 var OwneySDK = class {
   agents = /* @__PURE__ */ new Map();
   activeAgents = /* @__PURE__ */ new Set();
@@ -935,6 +1146,7 @@ var OwneySDK = class {
   state = null;
   apiKey;
   zyfaiRpcUrls;
+  cachedSponsoredCallback = null;
   initializingAgentsPromise = null;
   constructor(config) {
     this.apiKey = config.apiKey;
@@ -958,6 +1170,7 @@ var OwneySDK = class {
       );
     }
     this.state = { provider, walletAddress, chainId: null };
+    this.cachedSponsoredCallback = null;
   }
   /**
    * Disconnect from all agents and clear connection state.
@@ -970,6 +1183,7 @@ var OwneySDK = class {
     this.activeAgents.clear();
     this.disabledAgents.clear();
     this.state = null;
+    this.cachedSponsoredCallback = null;
   }
   isAgentDisabled(agentId) {
     return this.disabledAgents.has(agentId);
@@ -1003,6 +1217,46 @@ var OwneySDK = class {
     }
     return chainId;
   }
+  requireConnectedProvider() {
+    if (!this.state?.provider) {
+      throw new OwneyError(
+        "NOT_CONNECTED",
+        "connect(provider) must be called before deposit",
+        {}
+      );
+    }
+    return this.state.provider;
+  }
+  /**
+   * Lazily builds (and caches) the default EIP-3009 sponsored deposit callback
+   * used when the caller omits `depositCallback`. Wraps the connected EIP-1193
+   * provider with viem `custom(provider)` to read token meta and sign the
+   * `TransferWithAuthorization`, then POSTs to the sponsor API.
+   */
+  getDefaultSponsoredCallback() {
+    if (this.cachedSponsoredCallback)
+      return this.cachedSponsoredCallback;
+    const provider = this.requireConnectedProvider();
+    const owner = this.state.walletAddress;
+    this.cachedSponsoredCallback = makeSponsoredDepositCallback({
+      apiKey: this.apiKey,
+      ownerAddress: owner,
+      tokenAddressByChain: SPONSORED_USDC_BY_CHAIN,
+      // Casts work around viem's chain-narrowed Client vs the generic
+      // PublicClient/WalletClient param types — structurally identical at
+      // runtime, but the two share a name TS treats as unrelated.
+      getPublicClient: (cid) => createPublicClient({
+        chain: VIEM_CHAIN[cid],
+        transport: custom(provider)
+      }),
+      getWalletClient: (cid) => createWalletClient({
+        account: owner,
+        chain: VIEM_CHAIN[cid],
+        transport: custom(provider)
+      })
+    });
+    return this.cachedSponsoredCallback;
+  }
   getAgent(agentId) {
     const agent = this.agents.get(agentId);
     if (!agent) {
@@ -1156,6 +1410,7 @@ var OwneySDK = class {
     }
     const state = this.requireState();
     const chainId = this.requireChainId();
+    const effectiveCallback = depositCallback ?? (asset === "WETH" ? void 0 : this.getDefaultSponsoredCallback());
     if (agentId) {
       if (this.isAgentDisabled(agentId)) {
         throw new OwneyError(
@@ -1170,7 +1425,13 @@ var OwneySDK = class {
       return withFailureReporting(
         this.apiKey,
         agent.id,
-        () => agent.deposit(state, chainId, amount, depositCallback)
+        () => agent.deposit(
+          state,
+          chainId,
+          amount,
+          asset,
+          effectiveCallback
+        )
       );
     }
     const totalAmount = BigInt(amount);
@@ -1204,7 +1465,13 @@ var OwneySDK = class {
       agentResults[agent.id] = await withFailureReporting(
         this.apiKey,
         agent.id,
-        () => agent.deposit(state, chainId, agentAmount, depositCallback)
+        () => agent.deposit(
+          state,
+          chainId,
+          agentAmount,
+          asset,
+          effectiveCallback
+        )
       );
     }
     return { agentResults };
@@ -1398,10 +1665,7 @@ var OwneySDK = class {
       disabledBalances,
       requested
     );
-    const enabledTotal = enabledBalances.reduce(
-      (s, b) => s + b.balance,
-      0n
-    );
+    const enabledTotal = enabledBalances.reduce((s, b) => s + b.balance, 0n);
     const enabledPlans = afterDrain > 0n ? planProportionalShares(enabledBalances, afterDrain, enabledTotal) : enabledBalances.map(({ agent, balance }) => ({
       agent,
       balance,
@@ -1672,27 +1936,6 @@ var OwneySDK = class {
       nextCursor: hasMore ? encodeMultiAgentCursor(nextCursorMap) : void 0
     };
   }
-  // --- Agent control ---
-  /**
-   * Pause an agent's automated operations. The agent will stop rebalancing until resumed.
-   * @param agentId - The agent to pause (e.g. "zyfai")
-   * @returns OwneyAgentStatus with success flag
-   */
-  async pauseAgent(agentId) {
-    const state = this.requireState();
-    const chainId = this.requireChainId();
-    return this.getAgent(agentId).pause(state, chainId);
-  }
-  /**
-   * Resume an agent's automated operations.
-   * @param agentId - The agent to resume (e.g. "zyfai")
-   * @returns OwneyAgentStatus with success flag
-   */
-  async resumeAgent(agentId) {
-    const state = this.requireState();
-    const chainId = this.requireChainId();
-    return this.getAgent(agentId).resume(state, chainId);
-  }
   /**
    * Get the user's profile for a specific agent, or all agents.
    * @param agentId - Optional. Agent to query. Omit for all agents.
@@ -1767,12 +2010,13 @@ var OwneySDK = class {
     const chainId = this.requireChainId();
     const activeAgents = this.getActiveAgents();
     const balances = {};
+    const positionsByAgent = {};
     let totalBalance = 0;
     const entries = [...activeAgents.entries()];
     const balanceResults = await Promise.allSettled(
       entries.map(async ([id, agent]) => {
         const b = await agent.getBalances(state, chainId);
-        return [id, Number(b.totalBalance)];
+        return [id, Number(b.totalBalance), b.positions ?? []];
       })
     );
     let successCount = 0;
@@ -1781,8 +2025,9 @@ var OwneySDK = class {
       const settledResult = balanceResults[i];
       const [agentId] = entries[i];
       if (settledResult.status === "fulfilled") {
-        const [id, bal] = settledResult.value;
+        const [id, bal, agentPositions] = settledResult.value;
         balances[id] = bal;
+        positionsByAgent[id] = agentPositions;
         totalBalance += bal;
         successCount += 1;
       } else {
@@ -1816,7 +2061,64 @@ var OwneySDK = class {
       }
     }
     return {
-      agentAllocation: allocation
+      agentAllocation: allocation,
+      agentPositions: positionsByAgent
+    };
+  }
+  /**
+   * Allocation-weighted APY from the current portfolio: each pool's APY
+   * weighted by the user's position value in it. More accurate per-user than
+   * the historical 30D APY. (ROUT-228)
+   * @param options.agentId - Optional. Scope to one agent. Omit to aggregate
+   *   positions across all active agents.
+   */
+  async getAllocationApy({
+    agentId
+  } = {}) {
+    const state = this.requireState();
+    const chainId = this.requireChainId();
+    const activeAgents = agentId ? /* @__PURE__ */ new Map([[agentId, this.getAgent(agentId)]]) : this.getActiveAgents();
+    const entries = [...activeAgents.entries()];
+    const balanceResults = await Promise.allSettled(
+      entries.map(async ([id, agent]) => {
+        const b = await agent.getBalances(state, chainId);
+        return [id, b.positions ?? []];
+      })
+    );
+    const agentApy = {};
+    const allPositions = [];
+    let successCount = 0;
+    const agentErrors = {};
+    for (let i = 0; i < balanceResults.length; i++) {
+      const settled = balanceResults[i];
+      const [aid] = entries[i];
+      if (settled.status === "fulfilled") {
+        const [id, positions] = settled.value;
+        const per = computeAllocationApy(positions);
+        agentApy[id] = {
+          totalApy: per.totalApy,
+          apyByChainAndAsset: per.apyByChainAndAsset
+        };
+        allPositions.push(...positions);
+        successCount += 1;
+      } else {
+        const reason = settled.reason;
+        agentErrors[aid] = reason instanceof Error ? reason.message : String(reason);
+        console.error(`getAllocationApy agent "${aid}" failed:`, reason);
+      }
+    }
+    if (successCount === 0) {
+      throw new OwneyError(
+        "ALLOCATION_ALL_FAILED",
+        "Failed to fetch allocation APY: all agents failed.",
+        { agentErrors }
+      );
+    }
+    const overall = computeAllocationApy(allPositions);
+    return {
+      totalApy: overall.totalApy,
+      apyByChainAndAsset: overall.apyByChainAndAsset,
+      agentApy
     };
   }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@owney/sdk",
-  "version": "0.6.0-beta.0",
+  "version": "0.6.0-beta.1",
   "type": "module",
   "main": "dist/index.cjs",
   "module": "dist/index.js",