@medialane/sdk 0.85.13 → 0.87.0

package/dist/index.cjs

@@ -1308,48 +1308,7 @@ function requestIp(req) {
   return req.headers.get("x-forwarded-for")?.split(",")[0].trim() ?? "unknown";
 }
 
-// src/server/rpc-proxy.ts
-var DEFAULT_STARKNET_RPC_METHODS = [
-  "starknet_call",
-  "starknet_addInvokeTransaction",
-  "starknet_getTransactionReceipt",
-  "starknet_getTransactionStatus",
-  "starknet_getTransactionByHash",
-  "starknet_getTransaction",
-  "starknet_getBlockWithReceipts",
-  "starknet_estimateFee",
-  "starknet_getNonce",
-  "starknet_simulateTransactions",
-  "starknet_specVersion",
-  "starknet_chainId",
-  "starknet_blockNumber",
-  "starknet_blockHashAndNumber",
-  "starknet_getClassAt",
-  "starknet_getClass",
-  "starknet_getClassHashAt",
-  "starknet_getStorageAt",
-  "starknet_getBlockWithTxHashes",
-  "starknet_getBlockWithTxs",
-  "starknet_getEvents"
-];
-function isAllowedMethod(body, allowed) {
-  if (Array.isArray(body)) {
-    return body.every((item) => isAllowedMethod(item, allowed));
-  }
-  if (body && typeof body === "object") {
-    const method = body.method;
-    return typeof method === "string" && allowed.has(method);
-  }
-  return false;
-}
-function extractMethod(body) {
-  if (Array.isArray(body)) return "batch";
-  if (body && typeof body === "object") {
-    const method = body.method;
-    if (typeof method === "string") return method;
-  }
-  return "unknown";
-}
+// src/server/origin.ts
 function isSameOrigin(req) {
   const origin = req.headers.get("origin");
   if (!origin) return true;
@@ -1360,98 +1319,52 @@ function isSameOrigin(req) {
     return false;
   }
 }
-function rpcError(code, message, status = 200, id = null) {
-  return Response.json({ jsonrpc: "2.0", error: { code, message }, id }, { status });
-}
-async function billRpcCall(backendUrl, apiKey, method) {
-  if (!apiKey) {
-    console.error("[rpc-proxy] no API key configured \u2014 refusing to bill/forward");
-    return false;
-  }
-  try {
-    const res = await fetch(`${backendUrl.replace(/\/$/, "")}/v1/rpc/meter`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json", "x-api-key": apiKey },
-      body: JSON.stringify({ method })
-    });
-    return res.ok;
-  } catch (err) {
-    console.error("[rpc-proxy] billing call failed", { err: err instanceof Error ? err.message : String(err) });
-    return false;
-  }
+
+// src/server/backend-proxy.ts
+function proxyError(code, message, status) {
+  return Response.json({ jsonrpc: "2.0", error: { code, message }, id: null }, { status });
 }
-function createRpcProxyHandler(config) {
-  const allowed = new Set(config.allowedMethods ?? DEFAULT_STARKNET_RPC_METHODS);
-  return async function handleRpcProxy(req) {
+function createBackendProxyHandler(config) {
+  const doFetch = config.fetchImpl ?? fetch;
+  const endpoint = `${config.backendUrl.replace(/\/$/, "")}/${config.path.replace(/^\//, "")}`;
+  return async function handleBackendProxy(req) {
     if (!isSameOrigin(req)) {
-      return rpcError(-32600, "Cross-origin requests are not allowed", 403);
+      return proxyError(-32600, "Cross-origin requests are not allowed", 403);
     }
     if (!config.checkRateLimit(requestIp(req))) {
-      return rpcError(-32005, "Too many requests", 429);
+      return proxyError(-32005, "Too many requests", 429);
+    }
+    if (!config.apiKey) {
+      return proxyError(-32003, "No API key configured \u2014 request not forwarded", 402);
     }
     let body;
     try {
       body = await req.json();
     } catch {
-      return rpcError(-32700, "Parse error");
+      return proxyError(-32700, "Parse error", 400);
     }
-    if (!isAllowedMethod(body, allowed)) {
-      const method2 = !Array.isArray(body) && body && typeof body === "object" ? String(body.method ?? "<unknown>") : "<batch or invalid>";
-      return rpcError(-32601, `Method not allowed: ${method2}`);
-    }
-    const method = extractMethod(body);
-    if (!await billRpcCall(config.backendUrl, config.apiKey, method)) {
-      return rpcError(-32003, "Insufficient credits or billing unavailable \u2014 RPC call not forwarded", 402);
-    }
-    let lastError = "No RPC upstream configured";
-    for (const rpcUrl of config.rpcUrls) {
-      try {
-        const response = await fetch(rpcUrl, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify(body)
-        });
-        const text = await response.text();
-        const upstream = rpcUrl.split("/")[2];
-        if (!text) {
-          lastError = `Upstream RPC returned empty body (HTTP ${response.status})`;
-          console.warn("[rpc-proxy] upstream returned empty body", { status: response.status, upstream });
-          continue;
-        }
-        try {
-          const data = JSON.parse(text);
-          if (isTransientRpcError({ status: response.status, body: data })) {
-            const errObj = data.error;
-            lastError = `Upstream RPC returned transient JSON-RPC error: ${String(errObj?.message ?? "(no message)")}`;
-            console.warn("[rpc-proxy] upstream returned transient JSON-RPC error", {
-              upstream,
-              code: errObj?.code,
-              message: errObj?.message
-            });
-            continue;
-          }
-          return Response.json(data, { status: 200 });
-        } catch {
-          lastError = `Upstream RPC returned non-JSON (HTTP ${response.status})`;
-          console.warn("[rpc-proxy] upstream returned non-JSON", {
-            status: response.status,
-            upstream,
-            bodyPreview: text.slice(0, 200)
-          });
-          continue;
-        }
-      } catch (err) {
-        lastError = `Upstream RPC unreachable: ${err instanceof Error ? err.message : "unknown error"}`;
-        console.warn("[rpc-proxy] upstream fetch failed", {
-          upstream: rpcUrl.split("/")[2],
-          err: err instanceof Error ? err.message : String(err)
-        });
-      }
+    try {
+      const upstream = await doFetch(endpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", "x-api-key": config.apiKey },
+        body: JSON.stringify(body)
+      });
+      const text = await upstream.text();
+      return new Response(text, {
+        status: upstream.status,
+        headers: { "Content-Type": "application/json" }
+      });
+    } catch {
+      return proxyError(-32603, "Backend unreachable", 502);
     }
-    return rpcError(-32603, lastError);
   };
 }
 
+// src/server/rpc-proxy.ts
+function createRpcProxyHandler(config) {
+  return createBackendProxyHandler({ ...config, path: "/v1/rpc" });
+}
+
 // src/metadata.ts
 var RESERVED_TRAITS = /* @__PURE__ */ new Set([
   "Creator",
@@ -1536,7 +1449,6 @@ exports.ApiClient = ApiClient;
 exports.CHAINS = CHAINS;
 exports.DEFAULT_CHAIN = DEFAULT_CHAIN;
 exports.DEFAULT_CURRENCY = DEFAULT_CURRENCY;
-exports.DEFAULT_STARKNET_RPC_METHODS = DEFAULT_STARKNET_RPC_METHODS;
 exports.FeeConfigSchema = FeeConfigSchema;
 exports.IPFS_SAFE_CONTENT_TYPE_PREFIXES = IPFS_SAFE_CONTENT_TYPE_PREFIXES;
 exports.MAX_IPFS_GATEWAY_RESPONSE_BYTES = MAX_IPFS_GATEWAY_RESPONSE_BYTES;
@@ -1583,6 +1495,7 @@ exports.chainFromSlug = chainFromSlug;
 exports.chainSlug = chainSlug;
 exports.coinHref = coinHref;
 exports.collectionHref = collectionHref;
+exports.createBackendProxyHandler = createBackendProxyHandler;
 exports.createFailoverFetch = createFailoverFetch;
 exports.createRateLimiter = createRateLimiter;
 exports.createRpcProxyHandler = createRpcProxyHandler;
@@ -1596,6 +1509,7 @@ exports.getStarknetCoordinates = getStarknetCoordinates;
 exports.getTokenByAddress = getTokenByAddress;
 exports.getTokenBySymbol = getTokenBySymbol;
 exports.hasCapability = hasCapability;
+exports.isSameOrigin = isSameOrigin;
 exports.isServiceId = isServiceId;
 exports.isTransientRpcError = isTransientRpcError;
 exports.isValidIpfsCidPath = isValidIpfsCidPath;