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

package/dist/routing-api-KAILDWMD.js

@@ -0,0 +1,11 @@
+import {
+  ROUTING_API_BASE_URL,
+  fetchAgentKeys,
+  fetchOrgAgentConfig
+} from "./chunk-QA7JUSDB.js";
+import "./chunk-GMNQBWUB.js";
+export {
+  ROUTING_API_BASE_URL,
+  fetchAgentKeys,
+  fetchOrgAgentConfig
+};

package/dist/surfliquid.agent-5GY7A6HY.js

@@ -0,0 +1,532 @@
+import {
+  ERC20_ALLOWANCE_ABI
+} from "./chunk-DBRXNDSB.js";
+import {
+  OwneyError
+} from "./chunk-GMNQBWUB.js";
+import {
+  SURFLIQUID_ACTION_MAP,
+  SURFLIQUID_APPROVAL_TARGET,
+  SURFLIQUID_CHAIN_ID,
+  SURFLIQUID_CHAIN_NAME,
+  SURFLIQUID_SUPPORTED_ASSETS,
+  SURFLIQUID_USDC_ADDRESS,
+  SURFLIQUID_USDC_DECIMALS
+} from "./chunk-VHQ4VXY7.js";
+
+// src/agents/surfliquid/surfliquid.agent.ts
+import { SurfClient } from "@surf_liquid/core-sdk";
+import {
+  createPublicClient,
+  createWalletClient,
+  custom,
+  formatUnits
+} from "viem";
+import { base } from "viem/chains";
+
+// src/agents/surfliquid/surfliquid.mapper.ts
+function mapMessage(message) {
+  const action = SURFLIQUID_ACTION_MAP[message.transactionType];
+  if (!action) return null;
+  return {
+    agent: "surfliquid",
+    action,
+    date: message.timestamp,
+    oldApy: message.apyBefore != null ? String(message.apyBefore) : null,
+    newApy: message.apyAfter != null ? String(message.apyAfter) : null,
+    transactions: [
+      {
+        txHashes: [message.txHash],
+        chainId: message.chainId,
+        tokenSymbol: message.token ?? void 0,
+        amount: message.amount != null ? String(message.amount) : void 0
+      }
+    ],
+    rebalanceLog: []
+  };
+}
+function mapHistory(result, _chainId) {
+  const data = result.messages.map(mapMessage).filter((entry) => entry !== null);
+  const hasMore = result.page < result.pages;
+  return {
+    data,
+    hasMore,
+    nextCursor: hasMore ? String(result.page + 1) : void 0
+  };
+}
+function mapBalances(vault, chainId, morphoStats) {
+  const assets = (vault.assets ?? []).filter(
+    (asset) => asset.assetSymbol === "USDC" && asset.chainId === chainId
+  );
+  const tokens = assets.map((asset) => ({
+    chain: SURFLIQUID_CHAIN_NAME,
+    chainId: SURFLIQUID_CHAIN_ID,
+    asset: "USDC",
+    amount: String(asset.currentValueUSD)
+  }));
+  const positions = assets.map((asset) => {
+    const stats = morphoStats?.get(asset.morphoVaultAddress?.toLowerCase() ?? "");
+    return {
+      chain: SURFLIQUID_CHAIN_NAME,
+      protocol: "Morpho",
+      // The specific MetaMorpho vault (e.g. "Gauntlet USDC Frontier"), read from
+      // Morpho — renders as "Morpho <vault>" alongside zyfai's vault detail.
+      pool: stats?.name ?? void 0,
+      asset: "USDC",
+      amount: String(asset.currentValueUSD),
+      apy: asset.currentAPY,
+      // TVL + liquidity come straight from Morpho (SurfLiquid's API omits them).
+      tvl: stats?.tvlUsd,
+      liquidity: stats?.liquidityUsd
+    };
+  });
+  const total = assets.reduce(
+    (sum, asset) => sum + asset.currentValueUSD,
+    0
+  );
+  return {
+    smartWallet: vault.userVaultAddress ?? void 0,
+    totalBalance: String(total),
+    totalBalanceAsset: "usdc",
+    tokens,
+    positions
+  };
+}
+var APY_WINDOW_KEY = {
+  "7D": "apy7d",
+  "14D": "apy14d",
+  "30D": "apy30d"
+};
+function mapAccountApy(vault, days) {
+  const breakdown = vault.apyBreakdown;
+  const windowed = breakdown ? breakdown[APY_WINDOW_KEY[days]] : void 0;
+  const apy = windowed != null ? windowed : breakdown?.currentAPY ?? 0;
+  return {
+    walletAddress: vault.walletAddress ?? "",
+    weightedApyAfterFee: apy,
+    apyByChainAndAsset: { [SURFLIQUID_CHAIN_ID]: { USDC: apy } },
+    // Parity with Sail: SurfLiquid's core-sdk exposes no daily net-APY series.
+    history: []
+  };
+}
+function mapEarnings(vault, vaultAddress) {
+  return {
+    smartWallet: vaultAddress,
+    lifetimeEarnings: vault.earned?.totalEarningsUSD ?? 0,
+    tokens: []
+  };
+}
+function mapUserProfile(vault, address) {
+  return {
+    address,
+    smartWallet: vault.userVaultAddress ?? "",
+    chains: [SURFLIQUID_CHAIN_ID],
+    // SurfLiquid uses cookie-based session auth — no session-key concept.
+    hasActiveSessionKey: false,
+    protocols: ["SurfLiquid"]
+  };
+}
+
+// src/agents/surfliquid/surfliquid.wallet-adapter.ts
+import { BaseWalletAdapter } from "@surf_liquid/core-sdk";
+var OwneyWalletAdapter = class extends BaseWalletAdapter {
+  constructor(eip1193Provider) {
+    super();
+    this.eip1193Provider = eip1193Provider;
+  }
+  eip1193Provider;
+  name = "owney";
+  get installed() {
+    return true;
+  }
+  resolveProvider() {
+    return this.eip1193Provider;
+  }
+};
+
+// src/agents/surfliquid/surfliquid.morpho.ts
+var MORPHO_API_URL = "https://api.morpho.org/graphql";
+var VAULT_STATS_QUERY = `
+  query VaultStats($address: String!, $chainId: Int!) {
+    vaultByAddress(address: $address, chainId: $chainId) {
+      name
+      state { totalAssetsUsd }
+      liquidity { usd }
+    }
+  }
+`;
+var VAULT_V2_STATS_QUERY = `
+  query VaultV2Stats($address: String!, $chainId: Int!) {
+    vaultV2ByAddress(address: $address, chainId: $chainId) {
+      name
+      totalAssetsUsd
+      liquidityUsd
+    }
+  }
+`;
+async function queryMorpho(query, vaultAddress, chainId) {
+  try {
+    const res = await fetch(MORPHO_API_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        query,
+        variables: { address: vaultAddress, chainId }
+      })
+    });
+    if (!res.ok) return null;
+    const json = await res.json();
+    if (json.errors) return null;
+    return json.data ?? null;
+  } catch (error) {
+    console.warn("surfliquid: Morpho vault stats fetch failed", {
+      vaultAddress,
+      chainId,
+      error
+    });
+    return null;
+  }
+}
+function toStats(name, tvlUsd, liquidityUsd) {
+  if (typeof tvlUsd !== "number" || typeof liquidityUsd !== "number") {
+    return null;
+  }
+  return {
+    name: typeof name === "string" ? name : null,
+    tvlUsd,
+    liquidityUsd
+  };
+}
+async function fetchMorphoVaultStats(vaultAddress, chainId) {
+  const v1 = await queryMorpho(VAULT_STATS_QUERY, vaultAddress, chainId);
+  const vault = v1?.vaultByAddress;
+  const v1Stats = toStats(
+    vault?.name,
+    vault?.state?.totalAssetsUsd,
+    vault?.liquidity?.usd
+  );
+  if (v1Stats) return v1Stats;
+  const v2 = await queryMorpho(VAULT_V2_STATS_QUERY, vaultAddress, chainId);
+  const vaultV2 = v2?.vaultV2ByAddress;
+  return toStats(vaultV2?.name, vaultV2?.totalAssetsUsd, vaultV2?.liquidityUsd);
+}
+async function fetchMorphoStatsByVault(vaultAddresses, chainId) {
+  const unique = [...new Set(vaultAddresses.map((a) => a.toLowerCase()))];
+  const entries = await Promise.all(
+    unique.map(
+      async (address) => [address, await fetchMorphoVaultStats(address, chainId)]
+    )
+  );
+  const byVault = /* @__PURE__ */ new Map();
+  for (const [address, stats] of entries) {
+    if (stats) byVault.set(address, stats);
+  }
+  return byVault;
+}
+
+// src/agents/surfliquid/surfliquid.agent.ts
+var APY_WINDOW_KEY2 = {
+  "7D": "apy7d",
+  "14D": "apy14d",
+  "30D": "apy30d"
+};
+var SurfLiquidAgent = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  id = "surfliquid";
+  supportedChainIds = [SURFLIQUID_CHAIN_ID];
+  supportedAssets = SURFLIQUID_SUPPORTED_ASSETS;
+  surf = null;
+  connectedAddress = null;
+  // In-flight connect+auth, shared by concurrent callers to dedupe SIWE.
+  connectPromise = null;
+  ensureSurf() {
+    if (this.surf) return this.surf;
+    this.surf = SurfClient.create({
+      projectName: this.config.projectName,
+      appId: this.config.appId,
+      environment: "mainnet",
+      chainId: SURFLIQUID_CHAIN_ID,
+      apiBaseUrl: this.config.apiBaseUrl,
+      rpcUrl: this.config.rpcUrl,
+      // Let the SDK auto-approve USDC to the vault before depositing.
+      autoApprove: true
+    });
+    return this.surf;
+  }
+  /**
+   * Connects + authenticates the SurfClient against owney's provider. Skips the
+   * SIWE prompt when already authenticated for this wallet (cookie session).
+   */
+  async connect(state) {
+    const surf = this.ensureSurf();
+    const sameWallet = this.connectedAddress?.toLowerCase() === state.walletAddress.toLowerCase();
+    if (sameWallet && surf.getAuthState().authenticated) {
+      return surf;
+    }
+    if (this.connectPromise) return this.connectPromise;
+    this.connectPromise = (async () => {
+      surf.registerWalletAdapter(
+        "owney",
+        new OwneyWalletAdapter(state.provider)
+      );
+      await surf.connectWallet("owney");
+      await surf.authenticate();
+      this.connectedAddress = state.walletAddress;
+      return surf;
+    })();
+    try {
+      return await this.connectPromise;
+    } finally {
+      this.connectPromise = null;
+    }
+  }
+  /**
+   * Returns the user's vault address, deploying one on first use. SurfLiquid's
+   * deposit requires the vault to exist, so this must run before depositing.
+   * Existing vault → returned as-is; otherwise `deployVault()` is sent
+   * (user-pays) and the freshly deployed address is returned.
+   */
+  async resolveVaultAddress(surf, owner) {
+    const vault = await surf.getVault(owner).catch(() => null);
+    if (vault?.exists && vault.userVaultAddress) {
+      return vault.userVaultAddress;
+    }
+    const { vaultAddress } = await surf.deployVault();
+    return vaultAddress;
+  }
+  /**
+   * Grants the user's vault a standing USDC allowance so SurfLiquid's
+   * `autoApprove` has nothing to do — see {@link SURFLIQUID_APPROVAL_TARGET}
+   * for why one prompt per deposit is worth removing.
+   *
+   * Fails OPEN on a read error: if the allowance can't be checked we simply
+   * return and let SurfLiquid's own per-deposit approve run, because a flaky
+   * RPC must never block a deposit. A failed or rejected APPROVE does
+   * propagate — the user declined a transaction, and letting SurfLiquid
+   * immediately ask again for a smaller one is exactly the double prompt this
+   * removes.
+   */
+  async ensureVaultAllowance(state, vaultAddress, amount) {
+    const spender = vaultAddress;
+    const transport = custom(state.provider);
+    const publicClient = createPublicClient({ chain: base, transport });
+    let allowance;
+    try {
+      allowance = await publicClient.readContract({
+        address: SURFLIQUID_USDC_ADDRESS,
+        abi: ERC20_ALLOWANCE_ABI,
+        functionName: "allowance",
+        args: [state.walletAddress, spender]
+      });
+    } catch (error) {
+      console.warn(
+        "[owney-sdk] SurfLiquid allowance pre-check failed; deferring to its per-deposit approve:",
+        error instanceof Error ? error.message : String(error)
+      );
+      return;
+    }
+    if (allowance >= amount) return;
+    const target = amount > SURFLIQUID_APPROVAL_TARGET ? amount : SURFLIQUID_APPROVAL_TARGET;
+    const wallet = createWalletClient({
+      account: state.walletAddress,
+      chain: base,
+      transport
+    });
+    const hash = await wallet.writeContract({
+      address: SURFLIQUID_USDC_ADDRESS,
+      abi: ERC20_ALLOWANCE_ABI,
+      functionName: "approve",
+      args: [spender, target],
+      account: state.walletAddress,
+      chain: base
+    });
+    const receipt = await publicClient.waitForTransactionReceipt({
+      hash,
+      confirmations: 1
+    });
+    if (receipt.status !== "success") {
+      throw new Error(`SurfLiquid USDC approval reverted (tx ${hash})`);
+    }
+  }
+  // --- IAgent: lifecycle ---
+  async disconnect() {
+    if (this.surf) {
+      await this.surf.disconnectWallet();
+    }
+    this.connectedAddress = null;
+  }
+  async activateAgent(state) {
+    await this.connect(state);
+  }
+  /** Their exported client, so `prepare`/`confirm` ride the SIWE cookie this session already holds. */
+  async vaultApi() {
+    const { HttpClient, VaultApiService } = await import("@surf_liquid/core-sdk");
+    return new VaultApiService(
+      new HttpClient({
+        baseUrl: this.config.apiBaseUrl ?? "https://api.surfliquid.com",
+        projectName: this.config.projectName,
+        projectId: this.config.projectName,
+        appId: this.config.appId ?? ""
+      })
+    );
+  }
+  async sponsoredWallet(state) {
+    if (!this.config.apiKey) return null;
+    const { createSponsoredWallet } = await import("./surfliquid.smart-account-ZTZV7HUD.js");
+    const { ROUTING_API_BASE_URL } = await import("./routing-api-KAILDWMD.js");
+    return createSponsoredWallet({
+      provider: state.provider,
+      ownerAddress: state.walletAddress,
+      // Apps rarely set this; without the default, sponsorship silently never runs in production.
+      routingApiBaseUrl: this.config.routingApiBaseUrl ?? ROUTING_API_BASE_URL,
+      apiKey: this.config.apiKey,
+      rpcUrl: this.config.rpcUrl
+    });
+  }
+  /** Null means nothing happened on-chain, so the caller is free to retry as user-pays. */
+  async trySponsoredDeposit(state, amount) {
+    const wallet = await this.sponsoredWallet(state).catch(() => null);
+    if (!wallet) return null;
+    const { depositSponsored, isSafeToRetry } = await import("./surfliquid.sponsorship-BFAL2O3B.js");
+    const { createSponsoredChain } = await import("./surfliquid.smart-account-ZTZV7HUD.js");
+    try {
+      const { txHash, vault } = await depositSponsored({
+        amount,
+        api: await this.vaultApi(),
+        chain: createSponsoredChain(this.config.rpcUrl),
+        wallet
+      });
+      return { txHash, smartWallet: vault };
+    } catch (error) {
+      if (!isSafeToRetry(error)) throw error;
+      console.warn(
+        "[owney-sdk] SurfLiquid sponsored deposit unavailable; falling back to user-pays:",
+        error instanceof Error ? error.message : String(error)
+      );
+      return null;
+    }
+  }
+  async trySponsoredWithdraw(state, amount) {
+    const wallet = await this.sponsoredWallet(state).catch(() => null);
+    if (!wallet) return null;
+    const { withdrawSponsored, isSafeToRetry } = await import("./surfliquid.sponsorship-BFAL2O3B.js");
+    const { createSponsoredChain } = await import("./surfliquid.smart-account-ZTZV7HUD.js");
+    try {
+      const result = await withdrawSponsored({
+        amount: amount != null ? BigInt(amount) : void 0,
+        api: await this.vaultApi(),
+        chain: createSponsoredChain(this.config.rpcUrl),
+        wallet
+      });
+      return {
+        txHash: result.txHash,
+        type: amount != null ? "partial" : "full",
+        amount: result.amount
+      };
+    } catch (error) {
+      if (!isSafeToRetry(error)) throw error;
+      console.warn(
+        "[owney-sdk] SurfLiquid sponsored withdraw unavailable; falling back to user-pays:",
+        error instanceof Error ? error.message : String(error)
+      );
+      return null;
+    }
+  }
+  // --- IAgent: funds (gasless when sponsorship is reachable, else user-pays) ---
+  async deposit(state, _chainId, amount, _asset, _depositCallback) {
+    const surf = await this.connect(state);
+    const sponsored = await this.trySponsoredDeposit(state, BigInt(amount));
+    if (sponsored) return { ...sponsored, amount };
+    const human = formatUnits(BigInt(amount), SURFLIQUID_USDC_DECIMALS);
+    const smartWallet = await this.resolveVaultAddress(
+      surf,
+      state.walletAddress
+    );
+    await this.ensureVaultAllowance(state, smartWallet, BigInt(amount));
+    const tx = await surf.deposit({
+      asset: SURFLIQUID_USDC_ADDRESS,
+      amount: human
+    });
+    await tx.wait();
+    return { txHash: tx.hash, smartWallet, amount };
+  }
+  async withdraw(state, _chainId, _token, amount) {
+    const surf = await this.connect(state);
+    const sponsored = await this.trySponsoredWithdraw(state, amount);
+    if (sponsored) return sponsored;
+    const human = amount != null ? formatUnits(BigInt(amount), SURFLIQUID_USDC_DECIMALS) : void 0;
+    try {
+      const tx = await surf.withdraw({
+        asset: SURFLIQUID_USDC_ADDRESS,
+        amount: human
+      });
+      await tx.wait();
+      return {
+        txHash: tx.hash,
+        type: amount != null ? "partial" : "full",
+        amount: amount ?? "0"
+      };
+    } catch (error) {
+      throw new OwneyError(
+        "WITHDRAW_FAILED",
+        error instanceof Error ? error.message : "SurfLiquid withdraw failed.",
+        { chainId: SURFLIQUID_CHAIN_ID, amount },
+        this.id
+      );
+    }
+  }
+  // --- IAgent: portfolio reads ---
+  async getBalances(state, chainId) {
+    const surf = await this.connect(state);
+    const vault = await surf.getVault(state.walletAddress);
+    const morphoVaultAddresses = (vault.assets ?? []).filter((asset) => asset.assetSymbol === "USDC" && asset.chainId === chainId).map((asset) => asset.morphoVaultAddress).filter((address) => Boolean(address));
+    const morphoStats = await fetchMorphoStatsByVault(
+      morphoVaultAddresses,
+      chainId
+    );
+    return mapBalances(vault, chainId, morphoStats);
+  }
+  async getEarnings(state) {
+    const surf = await this.connect(state);
+    const vault = await surf.getVault(state.walletAddress);
+    return mapEarnings(vault, vault.userVaultAddress ?? state.walletAddress);
+  }
+  async getAccountApy(state, _chainId, days, _tokenSymbol) {
+    const surf = await this.connect(state);
+    const vault = await surf.getVault(state.walletAddress);
+    return mapAccountApy(vault, days);
+  }
+  async getHistory(state, chainId, options) {
+    const surf = await this.connect(state);
+    const page = options?.cursor ? Number(options.cursor) : 1;
+    const limit = options?.limit ?? 10;
+    const result = await surf.getAgentMessages(
+      state.walletAddress,
+      page,
+      limit,
+      options?.fromDate,
+      options?.toDate
+    );
+    return mapHistory(result, chainId);
+  }
+  async getUserProfile(state) {
+    const surf = await this.connect(state);
+    const vault = await surf.getVault(state.walletAddress);
+    return mapUserProfile(vault, state.walletAddress);
+  }
+  // --- IAgent: discovery (no wallet) ---
+  async getAgentApy(days, _options) {
+    const surf = this.ensureSurf();
+    const assets = await surf.getSupportedAssets(SURFLIQUID_CHAIN_ID);
+    const usdc = assets.find((asset) => asset.assetSymbol === "USDC");
+    if (!usdc) return { averageApy: 0 };
+    const windowed = usdc[APY_WINDOW_KEY2[days]];
+    return { averageApy: windowed != null ? windowed : usdc.currentAPY };
+  }
+};
+export {
+  SurfLiquidAgent
+};

package/dist/surfliquid.smart-account-ZTZV7HUD.js

@@ -0,0 +1,125 @@
+import {
+  SURFLIQUID_FACTORY_ABI,
+  SURFLIQUID_FACTORY_ADDRESS,
+  SURFLIQUID_VAULT_ABI,
+  SubmittedError,
+  USDC_ABI
+} from "./chunk-V2LNMTE6.js";
+import {
+  readTokenMeta
+} from "./chunk-5LU2SHO7.js";
+import {
+  SURFLIQUID_CHAIN_ID,
+  SURFLIQUID_USDC_ADDRESS
+} from "./chunk-VHQ4VXY7.js";
+
+// src/agents/surfliquid/surfliquid.smart-account.ts
+import { createSmartAccountClient } from "permissionless";
+import { toSimpleSmartAccount } from "permissionless/accounts";
+import { createPimlicoClient } from "permissionless/clients/pimlico";
+import {
+  createPublicClient,
+  createWalletClient,
+  custom,
+  http
+} from "viem";
+import { entryPoint08Address } from "viem/account-abstraction";
+import { base } from "viem/chains";
+var sponsorProxyUrl = (routingApiBaseUrl) => `${routingApiBaseUrl.replace(/\/$/, "")}/api/v1/sponsor/pimlico-rpc/${SURFLIQUID_CHAIN_ID}`;
+function publicClientFor(rpcUrl) {
+  return createPublicClient({ chain: base, transport: http(rpcUrl) });
+}
+function createSponsoredChain(rpcUrl) {
+  const client = publicClientFor(rpcUrl);
+  return {
+    computeVaultAddress: (owner, salt) => client.readContract({
+      address: SURFLIQUID_FACTORY_ADDRESS,
+      abi: SURFLIQUID_FACTORY_ABI,
+      functionName: "computeVaultAddress",
+      args: [owner, salt]
+    }),
+    isDeployed: async (address) => {
+      const code = await client.getCode({ address });
+      return Boolean(code && code !== "0x");
+    },
+    readVaultOwner: (vault) => client.readContract({ address: vault, abi: SURFLIQUID_VAULT_ABI, functionName: "owner" }),
+    hasInitialDeposit: (vault, asset) => client.readContract({
+      address: vault,
+      abi: SURFLIQUID_VAULT_ABI,
+      functionName: "assetHasInitialDeposit",
+      args: [asset]
+    }),
+    usdcBalanceOf: (address) => client.readContract({
+      address: SURFLIQUID_USDC_ADDRESS,
+      abi: USDC_ABI,
+      functionName: "balanceOf",
+      args: [address]
+    }),
+    // Cast: viem's OP-stack tx union does not match the generic PublicClient
+    // the helper is typed against, though every method it uses is present.
+    readTokenMeta: () => readTokenMeta(client, SURFLIQUID_USDC_ADDRESS)
+  };
+}
+function pinAccount(provider, address) {
+  return {
+    ...provider,
+    request: (args) => args.method === "eth_accounts" || args.method === "eth_requestAccounts" ? Promise.resolve([address]) : provider.request(args)
+  };
+}
+async function createSponsoredWallet(input) {
+  const entryPoint = { address: entryPoint08Address, version: "0.8" };
+  const account = await toSimpleSmartAccount({
+    client: publicClientFor(input.rpcUrl),
+    owner: pinAccount(input.provider, input.ownerAddress),
+    entryPoint
+  });
+  const bundlerTransport = http(sponsorProxyUrl(input.routingApiBaseUrl), {
+    fetchOptions: { headers: { "x-owney-api-key": input.apiKey } }
+  });
+  const pimlico = createPimlicoClient({ transport: bundlerTransport, entryPoint });
+  const smartAccountClient = createSmartAccountClient({
+    account,
+    chain: base,
+    bundlerTransport,
+    paymaster: pimlico,
+    userOperation: {
+      estimateFeesPerGas: async () => (await pimlico.getUserOperationGasPrice()).fast
+    }
+  });
+  const walletClient = createWalletClient({
+    account: input.ownerAddress,
+    chain: base,
+    transport: custom(input.provider)
+  });
+  return {
+    smartAccountAddress: account.address,
+    ownerAddress: input.ownerAddress,
+    // The EOA signs, not the smart account: USDC verifies ECDSA from the token holder.
+    signTransferAuthorization: (typedData) => walletClient.signTypedData({
+      account: input.ownerAddress,
+      domain: typedData.domain,
+      types: typedData.types,
+      primaryType: typedData.primaryType,
+      message: typedData.message
+    }),
+    sendCalls: async (calls) => {
+      const userOpHash = await smartAccountClient.sendUserOperation({
+        calls: calls.map((c) => ({ to: c.to, data: c.data, value: 0n }))
+      });
+      try {
+        const receipt = await smartAccountClient.waitForUserOperationReceipt({ hash: userOpHash });
+        return receipt.receipt.transactionHash;
+      } catch (error) {
+        throw new SubmittedError(
+          `user operation ${userOpHash} was submitted but its receipt never arrived`,
+          userOpHash
+        );
+      }
+    }
+  };
+}
+export {
+  createSponsoredChain,
+  createSponsoredWallet,
+  pinAccount
+};

package/dist/surfliquid.sponsorship-BFAL2O3B.js

@@ -0,0 +1,14 @@
+import {
+  SubmittedError,
+  depositSponsored,
+  isSafeToRetry,
+  withdrawSponsored
+} from "./chunk-V2LNMTE6.js";
+import "./chunk-5LU2SHO7.js";
+import "./chunk-VHQ4VXY7.js";
+export {
+  SubmittedError,
+  depositSponsored,
+  isSafeToRetry,
+  withdrawSponsored
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@owney/sdk",
-  "version": "0.7.16-beta.5",
+  "version": "0.7.16-beta.7",
   "type": "module",
   "main": "dist/index.cjs",
   "module": "dist/index.js",
@@ -23,7 +23,10 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@zyfai/sdk": "0.2.50",
+    "@surf_liquid/core-sdk": "^0.4.0",
+    "@zyfai/sdk": "0.2.52",
+    "ethers": "^6.17.0",
+    "permissionless": "^0.4.0",
     "siwe": "^3.0.0",
     "viem": "^2.48.1"
   },