@medialane/sdk 0.85.12 → 0.86.0

package/dist/index.cjs

@@ -495,8 +495,9 @@ var ApiClient = class {
     if (query.limit !== void 0) params.set("limit", String(query.limit));
     return this.get(`/v1/orders/counter-offers?${params}`);
   }
-  getMetadataSignedUrl() {
-    return this.get("/v1/metadata/signed-url");
+  getMetadataSignedUrl(kind) {
+    const params = kind ? `?kind=${kind}` : "";
+    return this.get(`/v1/metadata/signed-url${params}`);
   }
   uploadMetadata(metadata) {
     return this.post("/v1/metadata/upload", metadata);
@@ -1307,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;
@@ -1359,28 +1319,14 @@ function isSameOrigin(req) {
     return false;
   }
 }
+
+// src/server/rpc-proxy.ts
 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;
-  }
-}
 function createRpcProxyHandler(config) {
-  const allowed = new Set(config.allowedMethods ?? DEFAULT_STARKNET_RPC_METHODS);
+  const doFetch = config.fetchImpl ?? fetch;
+  const endpoint = `${config.backendUrl.replace(/\/$/, "")}/v1/rpc`;
   return async function handleRpcProxy(req) {
     if (!isSameOrigin(req)) {
       return rpcError(-32600, "Cross-origin requests are not allowed", 403);
@@ -1388,66 +1334,29 @@ function createRpcProxyHandler(config) {
     if (!config.checkRateLimit(requestIp(req))) {
       return rpcError(-32005, "Too many requests", 429);
     }
+    if (!config.apiKey) {
+      return rpcError(-32003, "No API key configured \u2014 RPC call not forwarded", 402);
+    }
     let body;
     try {
       body = await req.json();
     } catch {
       return rpcError(-32700, "Parse error");
     }
-    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 rpcError(-32603, "RPC backend unreachable");
     }
-    return rpcError(-32603, lastError);
   };
 }
 
@@ -1535,7 +1444,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;
@@ -1595,6 +1503,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;