@zerodev/smart-recipes 0.2.0

package/dist/index.js

@@ -0,0 +1,274 @@
+// src/errors.ts
+var SmartRecipeError = class extends Error {
+  constructor(code, message, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "SmartRecipeError";
+  }
+  code;
+  details;
+};
+var ERROR_MAP = /* @__PURE__ */ new Map();
+function defineError(name, code) {
+  const ctor = class extends SmartRecipeError {
+    constructor(message, details) {
+      super(code, message, details);
+      this.name = name;
+    }
+  };
+  Object.defineProperty(ctor, "name", { value: name });
+  ERROR_MAP.set(code, ctor);
+  return ctor;
+}
+var InvalidRequestError = defineError("InvalidRequestError", "INVALID_REQUEST");
+var ServiceUnavailableError = defineError(
+  "ServiceUnavailableError",
+  "SERVICE_UNAVAILABLE"
+);
+var InternalError = defineError("InternalError", "INTERNAL_ERROR");
+var SraNotFoundError = defineError("SraNotFoundError", "SRA_NOT_FOUND");
+var SraUnavailableError = defineError("SraUnavailableError", "SRA_UNAVAILABLE");
+var ChainNotSupportedError = defineError("ChainNotSupportedError", "CHAIN_NOT_SUPPORTED");
+var VaultCapExceededError = defineError("VaultCapExceededError", "VAULT_CAP_EXCEEDED");
+var AssetMismatchError = defineError("AssetMismatchError", "ASSET_MISMATCH");
+var UnknownProtocolError = defineError("UnknownProtocolError", "UNKNOWN_PROTOCOL");
+var VaultTypeMismatchError = defineError("VaultTypeMismatchError", "VAULT_TYPE_MISMATCH");
+var RpcUnavailableError = defineError("RpcUnavailableError", "RPC_UNAVAILABLE");
+var QuoterUnavailableError = defineError("QuoterUnavailableError", "QUOTER_UNAVAILABLE");
+var UnsupportedTokenError = defineError("UnsupportedTokenError", "UNSUPPORTED_TOKEN");
+var InsufficientAmountError = defineError(
+  "InsufficientAmountError",
+  "INSUFFICIENT_AMOUNT"
+);
+var SwapRouteNotFoundError = defineError("SwapRouteNotFoundError", "SWAP_ROUTE_NOT_FOUND");
+var QuoteExpiredError = defineError("QuoteExpiredError", "QUOTE_EXPIRED");
+var SanctionedAddressError = defineError("SanctionedAddressError", "SANCTIONED_ADDRESS");
+var VaultBlockedError = defineError("VaultBlockedError", "VAULT_BLOCKED");
+function mapErrorCode(code, message, details) {
+  const Ctor = ERROR_MAP.get(code);
+  if (Ctor) return new Ctor(message, details);
+  return new SmartRecipeError(code, message, details);
+}
+
+// src/client.ts
+var DEFAULT_WATCH_INTERVAL = 4e3;
+function createSmartRecipes(config) {
+  const { serverUrl, projectId } = config;
+  const fetchFn = config.fetch ?? globalThis.fetch;
+  const base = serverUrl.replace(/\/$/, "");
+  async function handleError(res) {
+    const errBody = await res.json().catch(() => ({ error: { code: "INTERNAL_ERROR", message: "Unknown error" } }));
+    throw mapErrorCode(errBody.error.code, errBody.error.message, errBody.error.details);
+  }
+  async function post(path, body) {
+    const res = await fetchFn(`${base}${path}`, {
+      method: "POST",
+      headers: { "content-type": "application/json", "x-project-id": projectId },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) return handleError(res);
+    return await res.json();
+  }
+  async function get(path) {
+    const res = await fetchFn(`${base}${path}`, {
+      method: "GET",
+      headers: { "x-project-id": projectId }
+    });
+    if (!res.ok) return handleError(res);
+    return await res.json();
+  }
+  function normalizeInto(into) {
+    if (into == null) return void 0;
+    return typeof into === "string" ? into : into.id;
+  }
+  function resolveDestChainId(p) {
+    if (p.into != null && typeof p.into !== "string") {
+      if (p.destChainId != null && p.destChainId !== p.into.chainId) {
+        throw new InvalidRequestError(
+          `destChainId ${p.destChainId} conflicts with vault.chainId ${p.into.chainId}`
+        );
+      }
+      return p.into.chainId;
+    }
+    if (p.destChainId == null) {
+      throw new InvalidRequestError(
+        "destChainId is required unless `into` is a Vault object (which carries its own chainId)"
+      );
+    }
+    return p.destChainId;
+  }
+  function toDepositBody(p, destChainId, protocol) {
+    return {
+      owner: p.owner,
+      amount: p.amount,
+      token: p.token,
+      srcChainId: p.srcChainId,
+      destChainId,
+      into: normalizeInto(p.into),
+      slippage: p.slippage,
+      protocol
+    };
+  }
+  function deposit(p, protocol) {
+    const destChainId = resolveDestChainId(p);
+    const path = p.srcChainId === destChainId ? "/api/v1/recipes/deposit-into-vault" : "/api/v1/recipes/bridge-and-deposit";
+    return post(path, toDepositBody(p, destChainId, protocol));
+  }
+  const aave = {
+    /** Aave V3 supply. Optional `into` = an Aave Earn listing selecting the reserve to supply. */
+    deposit: (p) => deposit(p, "aave")
+  };
+  const morpho = { deposit: (p) => deposit(p, "morpho") };
+  const fluid = { deposit: (p) => deposit(p, "fluid") };
+  const yearn = { deposit: (p) => deposit(p, "yearn") };
+  const erc4626 = { deposit: (p) => deposit(p, "erc4626") };
+  function depositIntoVault(p) {
+    return deposit(p, p.protocol);
+  }
+  function bridgeAndSwap(p) {
+    const body = {
+      owner: p.owner,
+      amount: p.amount,
+      token: p.token,
+      toToken: p.toToken,
+      srcChainId: p.srcChainId,
+      destChainId: p.destChainId,
+      slippage: p.slippage
+    };
+    return post("/api/v1/recipes/bridge-and-swap", body);
+  }
+  async function listVaults(params = {}) {
+    const q = new URLSearchParams();
+    if (params.asset) q.set("asset", params.asset);
+    if (params.protocol) q.set("protocol", params.protocol);
+    if (params.chains?.length) q.set("chains", params.chains.join(","));
+    const qs = q.toString();
+    const data = await get(`/api/v1/vaults${qs ? `?${qs}` : ""}`);
+    return data.vaults;
+  }
+  function getVault(vaultId) {
+    return get(`/api/v1/vaults/${vaultId}`);
+  }
+  function getStatus(sra) {
+    return get(`/api/v1/recipes/${sra}/status`);
+  }
+  function watchStatus(sra, opts) {
+    const interval = opts.interval ?? DEFAULT_WATCH_INTERVAL;
+    let lastState;
+    let stopped = false;
+    const tick = async () => {
+      if (stopped) return;
+      try {
+        const status = await getStatus(sra);
+        if (status.state !== lastState) {
+          lastState = status.state;
+          opts.onStatusChange(status);
+        }
+        if (status.state === "COMPLETED" || status.state === "FAILED") stop();
+      } catch {
+      }
+    };
+    const handle = setInterval(tick, interval);
+    void tick();
+    function stop() {
+      stopped = true;
+      clearInterval(handle);
+    }
+    return stop;
+  }
+  function getSraInfo(params) {
+    return post("/api/v1/recipes/sra/info", params);
+  }
+  function getWithdrawCalls(params) {
+    return post("/api/v1/recipes/sra/withdraw", params);
+  }
+  function getSraFeeEstimates(params) {
+    return post("/api/v1/recipes/sra/fee-estimates", params);
+  }
+  function getDepositStatus(params) {
+    return post("/api/v1/recipes/sra/deposit-status", params);
+  }
+  function preflight(params) {
+    return post("/api/v1/recipes/preflight", params);
+  }
+  function getBalances(params) {
+    return post("/api/v1/recipes/balances", params);
+  }
+  async function getChains() {
+    const data = await get("/api/v1/discovery/chains");
+    return data.chains;
+  }
+  async function getTokens(params) {
+    const data = await post("/api/v1/discovery/tokens", params ?? {});
+    return data.tokens;
+  }
+  function listOpportunities(params = {}) {
+    return post("/api/v1/recipes/earn/opportunities", params);
+  }
+  return {
+    aave,
+    morpho,
+    fluid,
+    yearn,
+    erc4626,
+    depositIntoVault,
+    bridgeAndSwap,
+    listVaults,
+    getVault,
+    getStatus,
+    watchStatus,
+    getSraInfo,
+    getWithdrawCalls,
+    getSraFeeEstimates,
+    getDepositStatus,
+    preflight,
+    getBalances,
+    getChains,
+    getTokens,
+    listOpportunities
+  };
+}
+
+// src/errors-codes.ts
+var ERROR_CODES = [
+  "INVALID_REQUEST",
+  "SERVICE_UNAVAILABLE",
+  "QUOTER_UNAVAILABLE",
+  "SRA_UNAVAILABLE",
+  "SRA_NOT_FOUND",
+  "VAULT_NOT_ALLOWLISTED",
+  "CHAIN_NOT_SUPPORTED",
+  "VAULT_CAP_EXCEEDED",
+  "ASSET_MISMATCH",
+  "UNKNOWN_PROTOCOL",
+  "VAULT_TYPE_MISMATCH",
+  "RPC_UNAVAILABLE",
+  "INTERNAL_ERROR",
+  // Doc-locked codes (SMART_RECIPES_SDK.md § Server error contract)
+  "UNSUPPORTED_TOKEN",
+  "INSUFFICIENT_AMOUNT",
+  "SWAP_ROUTE_NOT_FOUND",
+  "QUOTE_EXPIRED",
+  "SANCTIONED_ADDRESS",
+  "VAULT_BLOCKED"
+];
+function isErrorCode(code) {
+  return ERROR_CODES.includes(code);
+}
+
+// src/tokens.ts
+var TOKENS = {
+  USDC: "USDC",
+  USDT: "USDT",
+  DAI: "DAI",
+  WETH: "WETH",
+  WBTC: "WBTC",
+  EURC: "EURC",
+  NATIVE: "NATIVE"
+};
+function isTokenSymbol(value) {
+  return value in TOKENS;
+}
+
+export { AssetMismatchError, ChainNotSupportedError, ERROR_CODES, InsufficientAmountError, InternalError, InvalidRequestError, QuoteExpiredError, QuoterUnavailableError, RpcUnavailableError, SanctionedAddressError, ServiceUnavailableError, SmartRecipeError, SraNotFoundError, SraUnavailableError, SwapRouteNotFoundError, TOKENS, UnknownProtocolError, UnsupportedTokenError, VaultBlockedError, VaultCapExceededError, VaultTypeMismatchError, createSmartRecipes, isErrorCode, isTokenSymbol, mapErrorCode };

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@zerodev/smart-recipes",
+  "version": "0.2.0",
+  "description": "client sdk",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "viem": "^2.21.40"
+  },
+  "devDependencies": {
+    "@types/node": "^20.16.11",
+    "tsup": "^8.3.5",
+    "typescript": "^5.6.3",
+    "vitest": "3.2.6"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "lint": "biome check src",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}