@owney/sdk 0.7.16-beta.5 → 0.7.16-beta.7

package/README.md

@@ -572,14 +572,12 @@ interface AccountAgentApy {
   weightedApyAfterFee?: number;
   weightedApyAfterFeeDetails?: AgentApyDetails;
   apyByChainAndAsset?: ApyByChainAndAsset;
-  history?: ApyHistoryPoint[];
 }
 
 interface OwneyAccountApy {
   totalApy: string;
   agentApy: Record<AgentId, AccountAgentApy>;
   apyByChainAndAsset: ApyByChainAndAsset;
-  history?: ApyHistoryPoint[]; // balance-weighted aggregate daily series
 }
 
 type HistoryAction = "Rebalance" | "Deposit" | "Top up" | "Withdraw" | "Earned";

package/dist/chunk-5LU2SHO7.js

@@ -0,0 +1,50 @@
+// 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
+  };
+}
+function buildReceiveWithAuthorizationTypedData(input) {
+  const transfer = buildTransferWithAuthorizationTypedData(input);
+  return {
+    ...transfer,
+    types: { ReceiveWithAuthorization: transfer.types.TransferWithAuthorization },
+    primaryType: "ReceiveWithAuthorization"
+  };
+}
+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);
+}
+
+export {
+  buildTransferWithAuthorizationTypedData,
+  buildReceiveWithAuthorizationTypedData,
+  readTokenMeta,
+  randomAuthNonce
+};

package/dist/chunk-DBRXNDSB.js

@@ -0,0 +1,87 @@
+// src/lib/permit2.ts
+import { bytesToHex } from "viem";
+var PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+var MAX_UINT256 = 2n ** 256n - 1n;
+var ERC20_ALLOWANCE_ABI = [
+  {
+    type: "function",
+    name: "allowance",
+    stateMutability: "view",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "approve",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  }
+];
+function buildPermitTransferFromTypedData(input) {
+  return {
+    domain: {
+      name: "Permit2",
+      chainId: input.chainId,
+      verifyingContract: PERMIT2_ADDRESS
+    },
+    types: {
+      PermitTransferFrom: [
+        { name: "permitted", type: "TokenPermissions" },
+        { name: "spender", type: "address" },
+        { name: "nonce", type: "uint256" },
+        { name: "deadline", type: "uint256" }
+      ],
+      TokenPermissions: [
+        { name: "token", type: "address" },
+        { name: "amount", type: "uint256" }
+      ]
+    },
+    primaryType: "PermitTransferFrom",
+    message: input.message
+  };
+}
+function randomPermit2Nonce() {
+  const bytes = new Uint8Array(32);
+  globalThis.crypto.getRandomValues(bytes);
+  return BigInt(bytesToHex(bytes));
+}
+async function readPermit2Allowance(publicClient, token, owner) {
+  return publicClient.readContract({
+    address: token,
+    abi: ERC20_ALLOWANCE_ABI,
+    functionName: "allowance",
+    args: [owner, PERMIT2_ADDRESS]
+  });
+}
+async function readErc20Balance(publicClient, token, owner) {
+  return publicClient.readContract({
+    address: token,
+    abi: ERC20_ALLOWANCE_ABI,
+    functionName: "balanceOf",
+    args: [owner]
+  });
+}
+
+export {
+  PERMIT2_ADDRESS,
+  MAX_UINT256,
+  ERC20_ALLOWANCE_ABI,
+  buildPermitTransferFromTypedData,
+  randomPermit2Nonce,
+  readPermit2Allowance,
+  readErc20Balance
+};

package/dist/chunk-GMNQBWUB.js

@@ -0,0 +1,55 @@
+// src/errors.ts
+var OwneyError = class extends Error {
+  code;
+  details;
+  agentId;
+  constructor(code, message, details, agentId) {
+    const prefix = agentId ? `[${code}][agent:${agentId}]` : `[${code}]`;
+    super(`${prefix} ${message}`);
+    this.name = "OwneyError";
+    this.code = code;
+    this.details = details;
+    this.agentId = agentId;
+  }
+};
+var AgentNotFoundError = class extends OwneyError {
+  constructor(agentId, available) {
+    super(
+      "AGENT_NOT_FOUND",
+      `Unknown agent "${agentId}". Available agents: ${available.join(", ")}`,
+      { agentId, available },
+      agentId
+    );
+    this.name = "AgentNotFoundError";
+  }
+};
+var NotConnectedError = class extends OwneyError {
+  constructor() {
+    super("NOT_CONNECTED", "Not connected. Call sdk.connect(provider) first.");
+    this.name = "NotConnectedError";
+  }
+};
+var AgentChainIncompatibleError = class extends OwneyError {
+  incompatibleAgents;
+  connectedChainId;
+  constructor(incompatibleAgents, connectedChainId) {
+    const details = incompatibleAgents.map(
+      ({ agentId, supportedChainIds }) => `"${agentId}" supports chains [${supportedChainIds.join(", ")}]`
+    ).join("; ");
+    super(
+      "AGENT_CHAIN_INCOMPATIBLE",
+      `Chain ${connectedChainId} is not supported by the following agents: ${details}`,
+      { incompatibleAgents, connectedChainId }
+    );
+    this.name = "AgentChainIncompatibleError";
+    this.incompatibleAgents = incompatibleAgents;
+    this.connectedChainId = connectedChainId;
+  }
+};
+
+export {
+  OwneyError,
+  AgentNotFoundError,
+  NotConnectedError,
+  AgentChainIncompatibleError
+};

package/dist/chunk-QA7JUSDB.js

@@ -0,0 +1,92 @@
+import {
+  OwneyError
+} from "./chunk-GMNQBWUB.js";
+
+// src/lib/debug.ts
+var configuredDebug = false;
+function setOwneyDebug(enabled) {
+  configuredDebug = enabled;
+}
+function isOwneyDebug() {
+  return globalThis.__OWNEY_DEBUG__ === true || configuredDebug;
+}
+function debugLog(scope, message, data) {
+  if (!isOwneyDebug()) return;
+  if (data === void 0) {
+    console.log(`[${scope}] ${message}`);
+  } else {
+    console.log(`[${scope}] ${message}`, data);
+  }
+}
+
+// src/lib/routing-api.ts
+var ROUTING_API_BASE_URL = "https://owney-routing-api-243946518160.europe-west4.run.app";
+async function fetchOrgAgentConfig(apiKey, baseUrl = ROUTING_API_BASE_URL) {
+  const url = `${baseUrl}/api/v1/agent/org-config`;
+  try {
+    const res = await fetch(url, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+        "x-owney-api-key": `${apiKey}`
+      }
+    });
+    if (!res.ok) {
+      if (res.status !== 404) {
+        console.warn(
+          `[owney-sdk] Could not read org agent config (${res.status}); leaving user profiles unchanged.`
+        );
+      }
+      return null;
+    }
+    const json = await res.json();
+    const policy = json.success ? json.data ?? null : null;
+    debugLog(
+      "owney-sdk",
+      policy ? "org agent config: loaded" : "org agent config: none set by this partner \u2014 user profiles will be left as they are",
+      policy ?? void 0
+    );
+    return policy;
+  } catch (error) {
+    console.warn(
+      "[owney-sdk] Could not read org agent config (non-fatal):",
+      error instanceof Error ? error.message : String(error)
+    );
+    return null;
+  }
+}
+async function fetchAgentKeys(apiKey, baseUrl = ROUTING_API_BASE_URL) {
+  const url = `${baseUrl}/api/v1/agent/keys`;
+  const res = await fetch(url, {
+    method: "GET",
+    headers: {
+      "Content-Type": "application/json",
+      "x-owney-api-key": `${apiKey}`
+    }
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new OwneyError(
+      "API_ROUTING_ERROR",
+      `Routing API error ${res.status}: ${text}`,
+      { statusCode: res.status, responseBody: text }
+    );
+  }
+  const json = await res.json();
+  if (!json.success) {
+    throw new OwneyError(
+      "API_ROUTING_FAILED",
+      `Routing API request failed: ${json.message}`,
+      { message: json.message }
+    );
+  }
+  return json.data;
+}
+
+export {
+  setOwneyDebug,
+  debugLog,
+  ROUTING_API_BASE_URL,
+  fetchOrgAgentConfig,
+  fetchAgentKeys
+};

package/dist/chunk-V2LNMTE6.js

@@ -0,0 +1,222 @@
+import {
+  buildReceiveWithAuthorizationTypedData,
+  randomAuthNonce
+} from "./chunk-5LU2SHO7.js";
+import {
+  SURFLIQUID_CHAIN_ID,
+  SURFLIQUID_USDC_ADDRESS
+} from "./chunk-VHQ4VXY7.js";
+
+// src/agents/surfliquid/surfliquid.calls.ts
+import { encodeFunctionData } from "viem";
+
+// src/agents/surfliquid/surfliquid.contracts.ts
+import { parseAbi } from "viem";
+var SURFLIQUID_FACTORY_ADDRESS = "0x8fa50DeA8DB10987D7d22ac092001c3613C18779";
+var SURFLIQUID_FACTORY_ABI = parseAbi([
+  "function deployVault(address vaultOwner, bytes32 salt) returns (address)",
+  "function computeVaultAddress(address vaultOwner, bytes32 salt) view returns (address)"
+]);
+var SURFLIQUID_VAULT_ABI = parseAbi([
+  "function initialDeposit(address asset, address vault, uint256 amount)",
+  "function userDeposit(address asset, uint256 amount)",
+  // amount 0 withdraws everything; proceeds go to the vault's owner.
+  "function withdraw(address asset, uint256 amount)",
+  "function assetHasInitialDeposit(address asset) view returns (bool)",
+  "function owner() view returns (address)"
+]);
+var USDC_ABI = parseAbi([
+  "function approve(address spender, uint256 amount)",
+  "function transfer(address to, uint256 amount)",
+  "function balanceOf(address account) view returns (uint256)",
+  "function receiveWithAuthorization(address from, address to, uint256 value, uint256 validAfter, uint256 validBefore, bytes32 nonce, bytes signature)"
+]);
+
+// src/agents/surfliquid/surfliquid.calls.ts
+var call = (to, abi, functionName, args) => ({
+  to,
+  data: encodeFunctionData({ abi, functionName, args })
+});
+function buildDepositCalls(input) {
+  const { smartAccount, vault, amount, authorization, deploySalt } = input;
+  if (authorization.to.toLowerCase() !== smartAccount.toLowerCase()) {
+    throw new Error("Transfer authorization must pay the smart account");
+  }
+  if (authorization.value < amount) {
+    throw new Error("Transfer authorization is worth less than the deposit");
+  }
+  if (!input.hasInitialDeposit && !input.morphoVault) {
+    throw new Error("A first deposit needs a target morpho vault");
+  }
+  const calls = [];
+  if (deploySalt) {
+    calls.push(
+      call(SURFLIQUID_FACTORY_ADDRESS, SURFLIQUID_FACTORY_ABI, "deployVault", [
+        smartAccount,
+        deploySalt
+      ])
+    );
+  }
+  calls.push(
+    call(SURFLIQUID_USDC_ADDRESS, USDC_ABI, "receiveWithAuthorization", [
+      authorization.from,
+      authorization.to,
+      authorization.value,
+      authorization.validAfter,
+      authorization.validBefore,
+      authorization.nonce,
+      authorization.signature
+    ]),
+    call(SURFLIQUID_USDC_ADDRESS, USDC_ABI, "approve", [vault, amount]),
+    input.hasInitialDeposit ? call(vault, SURFLIQUID_VAULT_ABI, "userDeposit", [SURFLIQUID_USDC_ADDRESS, amount]) : call(vault, SURFLIQUID_VAULT_ABI, "initialDeposit", [
+      SURFLIQUID_USDC_ADDRESS,
+      input.morphoVault,
+      amount
+    ])
+  );
+  return calls;
+}
+function buildWithdrawCalls(input) {
+  return [
+    call(input.vault, SURFLIQUID_VAULT_ABI, "withdraw", [
+      SURFLIQUID_USDC_ADDRESS,
+      input.amount ?? 0n
+    ])
+  ];
+}
+function buildSweepCalls(input) {
+  return [call(SURFLIQUID_USDC_ADDRESS, USDC_ABI, "transfer", [input.owner, input.amount])];
+}
+
+// src/agents/surfliquid/surfliquid.sponsorship.ts
+var AUTHORIZATION_TTL_SECONDS = 3600n;
+var SubmittedError = class extends Error {
+  constructor(message, userOpHash) {
+    super(message);
+    this.userOpHash = userOpHash;
+    this.name = "SubmittedError";
+  }
+  userOpHash;
+};
+var isSafeToRetry = (error) => !(error instanceof SubmittedError);
+async function resolveVault(ctx) {
+  const registered = await ctx.api.getVault(ctx.wallet.ownerAddress);
+  const smartAccount = ctx.wallet.smartAccountAddress;
+  if (!registered.userVaultAddress) {
+    const salt2 = registered.deploymentSalt ?? (await ctx.api.prepare(SURFLIQUID_CHAIN_ID)).salt;
+    return {
+      vault: await ctx.chain.computeVaultAddress(smartAccount, salt2),
+      deploySalt: salt2,
+      registerAfterDeposit: true
+    };
+  }
+  const vault = registered.userVaultAddress;
+  if (await ctx.chain.isDeployed(vault)) {
+    const owner = await ctx.chain.readVaultOwner(vault);
+    if (owner.toLowerCase() !== smartAccount.toLowerCase()) {
+      throw new Error(`SurfLiquid vault ${vault} is not owned by the smart account`);
+    }
+    return { vault, registerAfterDeposit: false };
+  }
+  const salt = registered.deploymentSalt;
+  const deployable = salt ? await ctx.chain.computeVaultAddress(smartAccount, salt) : void 0;
+  if (!salt || deployable?.toLowerCase() !== vault.toLowerCase()) {
+    throw new Error(`Registered SurfLiquid vault ${vault} does not match this smart account`);
+  }
+  return { vault, deploySalt: salt, registerAfterDeposit: false };
+}
+async function pickMorphoVault(api) {
+  const candidates = await api.getBestVault("USDC");
+  const candidate = candidates.find((option) => option.chainId === SURFLIQUID_CHAIN_ID);
+  if (!candidate) {
+    throw new Error(`SurfLiquid has no morpho vault for USDC on chain ${SURFLIQUID_CHAIN_ID}`);
+  }
+  return candidate.vaultAddress;
+}
+async function depositSponsored(input) {
+  const { api, chain, wallet, amount } = input;
+  const { vault, deploySalt, registerAfterDeposit } = await resolveVault(input);
+  const hasInitialDeposit = deploySalt ? false : await chain.hasInitialDeposit(vault, SURFLIQUID_USDC_ADDRESS);
+  const morphoVault = hasInitialDeposit ? void 0 : await pickMorphoVault(api);
+  const { tokenName, tokenVersion } = await chain.readTokenMeta();
+  const message = {
+    from: wallet.ownerAddress,
+    to: wallet.smartAccountAddress,
+    value: amount,
+    validAfter: 0n,
+    validBefore: BigInt(Math.floor(Date.now() / 1e3)) + AUTHORIZATION_TTL_SECONDS,
+    nonce: randomAuthNonce()
+  };
+  const signature = await wallet.signTransferAuthorization(
+    buildReceiveWithAuthorizationTypedData({
+      token: SURFLIQUID_USDC_ADDRESS,
+      chainId: SURFLIQUID_CHAIN_ID,
+      tokenName,
+      tokenVersion,
+      message
+    })
+  );
+  const txHash = await wallet.sendCalls(
+    buildDepositCalls({
+      smartAccount: wallet.smartAccountAddress,
+      vault,
+      amount,
+      authorization: { ...message, signature },
+      hasInitialDeposit,
+      morphoVault,
+      deploySalt
+    })
+  );
+  if (registerAfterDeposit && deploySalt) {
+    try {
+      await api.confirm({
+        userVaultAddress: vault,
+        homeChainId: SURFLIQUID_CHAIN_ID,
+        deploymentSalt: deploySalt,
+        initialAssets: []
+      });
+    } catch (error) {
+      console.warn(
+        "[owney-sdk] SurfLiquid vault registration failed after a successful deposit:",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  return { txHash, vault };
+}
+async function withdrawSponsored(input) {
+  const { api, chain, wallet, amount } = input;
+  const registered = await api.getVault(wallet.ownerAddress);
+  if (!registered.userVaultAddress) {
+    throw new Error("SurfLiquid has no vault registered for this wallet");
+  }
+  const vault = registered.userVaultAddress;
+  const owner = await chain.readVaultOwner(vault);
+  if (owner.toLowerCase() !== wallet.smartAccountAddress.toLowerCase()) {
+    throw new Error(`SurfLiquid vault ${vault} is not owned by the smart account`);
+  }
+  const withdrawHash = await wallet.sendCalls(buildWithdrawCalls({ vault, amount }));
+  try {
+    const proceeds = await chain.usdcBalanceOf(wallet.smartAccountAddress);
+    if (proceeds === 0n) return { txHash: withdrawHash, amount: "0" };
+    const sweepHash = await wallet.sendCalls(
+      buildSweepCalls({ owner: wallet.ownerAddress, amount: proceeds })
+    );
+    return { txHash: sweepHash, amount: proceeds.toString() };
+  } catch (error) {
+    throw new SubmittedError(
+      `SurfLiquid withdrawal ${withdrawHash} landed but the sweep did not: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+
+export {
+  SURFLIQUID_FACTORY_ADDRESS,
+  SURFLIQUID_FACTORY_ABI,
+  SURFLIQUID_VAULT_ABI,
+  USDC_ABI,
+  SubmittedError,
+  isSafeToRetry,
+  depositSponsored,
+  withdrawSponsored
+};

package/dist/chunk-VHQ4VXY7.js

@@ -0,0 +1,39 @@
+// src/agents/surfliquid/surfliquid.constants.ts
+var SURFLIQUID_CHAIN_ID = 8453;
+var SURFLIQUID_CHAIN_NAME = "BASE";
+var SURFLIQUID_USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+var SURFLIQUID_USDC_DECIMALS = 6;
+var SURFLIQUID_MIN_DEPOSIT = "0";
+var SURFLIQUID_APPROVAL_TARGET = 100000000000n;
+var SURFLIQUID_SUPPORTED_ASSETS = [
+  {
+    chainId: SURFLIQUID_CHAIN_ID,
+    chain: SURFLIQUID_CHAIN_NAME,
+    assets: [{ symbol: "USDC", minDepositAmount: SURFLIQUID_MIN_DEPOSIT }]
+  }
+];
+var SURFLIQUID_ACTION_MAP = {
+  // INITIAL_DEPOSIT is the user's real first deposit, so surface it like any
+  // other funding ("Top up"). The mini-app intentionally hides the "Deposit"
+  // action (it marks Zyfai's smart-account-creation event), which would
+  // otherwise drop a SurfLiquid user's only history row.
+  INITIAL_DEPOSIT: "Top up",
+  DEPOSIT: "Top up",
+  USER_DEPOSIT: "Top up",
+  WITHDRAWAL: "Withdraw",
+  USER_WITHDRAWAL: "Withdraw",
+  REBALANCE: "Rebalance",
+  REBALANCE_COMPLETED: "Rebalance",
+  CROSS_CHAIN_REBALANCE: "Rebalance",
+  MERKL_CLAIM: "Earned"
+};
+
+export {
+  SURFLIQUID_CHAIN_ID,
+  SURFLIQUID_CHAIN_NAME,
+  SURFLIQUID_USDC_ADDRESS,
+  SURFLIQUID_USDC_DECIMALS,
+  SURFLIQUID_APPROVAL_TARGET,
+  SURFLIQUID_SUPPORTED_ASSETS,
+  SURFLIQUID_ACTION_MAP
+};