@owney/sdk 0.7.22-beta.1 → 0.7.23-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@owney/sdk",
-  "version": "0.7.22-beta.1",
+  "version": "0.7.23-beta.1",
   "type": "module",
   "main": "dist/index.cjs",
   "module": "dist/index.js",
@@ -20,12 +20,10 @@
     "build": "tsup",
     "dev": "tsup --watch",
     "test": "vitest run",
-    "test:watch": "vitest",
-    "typecheck": "tsc -p tsconfig.test.json --noEmit"
+    "test:watch": "vitest"
   },
   "dependencies": {
-    "@zyfai/sdk": "0.2.52",
-    "permissionless": "^0.4.0",
+    "@zyfai/sdk": "0.2.55",
     "siwe": "^3.0.0",
     "viem": "^2.48.1"
   },

package/dist/chunk-3HL52KM7.js

@@ -1,283 +0,0 @@
-import {
-  buildPermitTypedData
-} from "./chunk-AURO3C3R.js";
-
-// src/agents/surfliquid/surfliquid.constants.ts
-var SURFLIQUID_CHAIN_ID = 8453;
-var SURFLIQUID_CHAIN_NAME = "BASE";
-var SURFLIQUID_USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
-var SURFLIQUID_PERMIT_CAP = 10000000000n;
-var SURFLIQUID_PERMIT_TTL_SECONDS = 3600n;
-var SURFLIQUID_MIN_DEPOSIT = "0";
-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"
-};
-
-// 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 transferFrom(address from, address to, uint256 value)",
-  "function balanceOf(address account) view returns (uint256)",
-  "function allowance(address owner, address spender) view returns (uint256)",
-  "function nonces(address owner) view returns (uint256)",
-  "function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s)"
-]);
-
-// src/agents/surfliquid/surfliquid.sponsorship.ts
-import { parseSignature } from "viem";
-
-// src/agents/surfliquid/surfliquid.calls.ts
-import { encodeFunctionData } from "viem";
-var call = (to, abi, functionName, args) => ({
-  to,
-  data: encodeFunctionData({ abi, functionName, args })
-});
-function buildDepositCalls(input) {
-  const { smartAccount, owner, vault, amount, permit, deploySalt } = input;
-  if (permit && permit.owner.toLowerCase() !== owner.toLowerCase()) {
-    throw new Error("Permit must be signed by the smart account's owner");
-  }
-  if (permit && permit.value < amount) {
-    throw new Error("Permit allowance 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
-      ])
-    );
-  }
-  if (permit) {
-    calls.push(
-      call(SURFLIQUID_USDC_ADDRESS, USDC_ABI, "permit", [
-        permit.owner,
-        smartAccount,
-        permit.value,
-        permit.deadline,
-        permit.v,
-        permit.r,
-        permit.s
-      ])
-    );
-  }
-  calls.push(
-    call(SURFLIQUID_USDC_ADDRESS, USDC_ABI, "transferFrom", [owner, smartAccount, amount]),
-    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 SubmittedError = class extends Error {
-  constructor(message, userOpHash) {
-    super(message);
-    this.userOpHash = userOpHash;
-    this.name = "SubmittedError";
-  }
-  userOpHash;
-};
-var VaultNotSponsorableError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "VaultNotSponsorableError";
-  }
-};
-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 VaultNotSponsorableError(`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 VaultNotSponsorableError(`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 permitIfShort(input) {
-  const { chain, wallet, amount } = input;
-  const allowance = await chain.readAllowance(wallet.ownerAddress, wallet.smartAccountAddress);
-  if (allowance >= amount) return void 0;
-  const [{ tokenName, tokenVersion }, nonce] = await Promise.all([
-    chain.readTokenMeta(),
-    chain.readPermitNonce(wallet.ownerAddress)
-  ]);
-  const message = {
-    owner: wallet.ownerAddress,
-    spender: wallet.smartAccountAddress,
-    value: amount > SURFLIQUID_PERMIT_CAP ? amount : SURFLIQUID_PERMIT_CAP,
-    nonce,
-    deadline: BigInt(Math.floor(Date.now() / 1e3)) + SURFLIQUID_PERMIT_TTL_SECONDS
-  };
-  const signature = await wallet.signPermit(
-    buildPermitTypedData({
-      token: SURFLIQUID_USDC_ADDRESS,
-      chainId: SURFLIQUID_CHAIN_ID,
-      tokenName,
-      tokenVersion,
-      message
-    })
-  );
-  const { r, s, v, yParity } = parseSignature(signature);
-  return {
-    owner: message.owner,
-    value: message.value,
-    deadline: message.deadline,
-    v: Number(v ?? BigInt(yParity + 27)),
-    r,
-    s
-  };
-}
-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 permit = await permitIfShort({ chain, wallet, amount });
-  const txHash = await wallet.sendCalls(
-    buildDepositCalls({
-      smartAccount: wallet.smartAccountAddress,
-      owner: wallet.ownerAddress,
-      vault,
-      amount,
-      permit,
-      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 VaultNotSponsorableError(`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_CHAIN_ID,
-  SURFLIQUID_CHAIN_NAME,
-  SURFLIQUID_USDC_ADDRESS,
-  SURFLIQUID_SUPPORTED_ASSETS,
-  SURFLIQUID_ACTION_MAP,
-  SURFLIQUID_FACTORY_ADDRESS,
-  SURFLIQUID_FACTORY_ABI,
-  SURFLIQUID_VAULT_ABI,
-  USDC_ABI,
-  SubmittedError,
-  VaultNotSponsorableError,
-  depositSponsored,
-  withdrawSponsored
-};

package/dist/chunk-AURO3C3R.js

@@ -1,58 +0,0 @@
-// 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);
-}
-function buildPermitTypedData(input) {
-  return {
-    domain: { name: input.tokenName, version: input.tokenVersion, chainId: input.chainId, verifyingContract: input.token },
-    types: {
-      Permit: [
-        { name: "owner", type: "address" },
-        { name: "spender", type: "address" },
-        { name: "value", type: "uint256" },
-        { name: "nonce", type: "uint256" },
-        { name: "deadline", type: "uint256" }
-      ]
-    },
-    primaryType: "Permit",
-    message: input.message
-  };
-}
-
-export {
-  buildTransferWithAuthorizationTypedData,
-  readTokenMeta,
-  randomAuthNonce,
-  buildPermitTypedData
-};

package/dist/chunk-XBDJWZXY.js

@@ -1,141 +0,0 @@
-// 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;
-  }
-};
-
-// 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 {
-  OwneyError,
-  AgentNotFoundError,
-  NotConnectedError,
-  AgentChainIncompatibleError,
-  setOwneyDebug,
-  debugLog,
-  ROUTING_API_BASE_URL,
-  fetchOrgAgentConfig,
-  fetchAgentKeys
-};