@debros/network-ts-sdk 0.1.5 → 0.3.1

package/dist/index.js

@@ -27,32 +27,63 @@ var SDKError = class _SDKError extends Error {
 var HttpClient = class {
   constructor(config) {
     this.baseURL = config.baseURL.replace(/\/$/, "");
-    this.timeout = config.timeout ?? 3e4;
+    this.timeout = config.timeout ?? 6e4;
     this.maxRetries = config.maxRetries ?? 3;
     this.retryDelayMs = config.retryDelayMs ?? 1e3;
     this.fetch = config.fetch ?? globalThis.fetch;
   }
   setApiKey(apiKey) {
     this.apiKey = apiKey;
-    this.jwt = void 0;
   }
   setJwt(jwt) {
     this.jwt = jwt;
-    this.apiKey = void 0;
+    if (typeof console !== "undefined") {
+      console.log(
+        "[HttpClient] JWT set:",
+        !!jwt,
+        "API key still present:",
+        !!this.apiKey
+      );
+    }
   }
-  getAuthHeaders() {
+  getAuthHeaders(path) {
     const headers = {};
-    if (this.jwt) {
-      headers["Authorization"] = `Bearer ${this.jwt}`;
-    } else if (this.apiKey) {
-      headers["X-API-Key"] = this.apiKey;
+    const isDbOperation = path.includes("/v1/rqlite/");
+    const isPubSubOperation = path.includes("/v1/pubsub/");
+    const isProxyOperation = path.includes("/v1/proxy/");
+    const isCacheOperation = path.includes("/v1/cache/");
+    const isAuthOperation = path.includes("/v1/auth/");
+    if (isDbOperation || isPubSubOperation || isProxyOperation || isCacheOperation) {
+      if (this.apiKey) {
+        headers["X-API-Key"] = this.apiKey;
+      } else if (this.jwt) {
+        headers["Authorization"] = `Bearer ${this.jwt}`;
+      }
+    } else if (isAuthOperation) {
+      if (this.apiKey) {
+        headers["X-API-Key"] = this.apiKey;
+      }
+      if (this.jwt) {
+        headers["Authorization"] = `Bearer ${this.jwt}`;
+      }
+    } else {
+      if (this.jwt) {
+        headers["Authorization"] = `Bearer ${this.jwt}`;
+      }
+      if (this.apiKey) {
+        headers["X-API-Key"] = this.apiKey;
+      }
     }
     return headers;
   }
   getAuthToken() {
     return this.jwt || this.apiKey;
   }
+  getApiKey() {
+    return this.apiKey;
+  }
   async request(method, path, options = {}) {
+    const startTime = performance.now();
     const url = new URL(this.baseURL + path);
     if (options.query) {
       Object.entries(options.query).forEach(([key, value]) => {
@@ -61,20 +92,70 @@ var HttpClient = class {
     }
     const headers = {
       "Content-Type": "application/json",
-      ...this.getAuthHeaders(),
+      ...this.getAuthHeaders(path),
       ...options.headers
     };
+    const controller = new AbortController();
+    const requestTimeout = options.timeout ?? this.timeout;
+    const timeoutId = setTimeout(() => controller.abort(), requestTimeout);
     const fetchOptions = {
       method,
       headers,
-      signal: AbortSignal.timeout(this.timeout)
+      signal: controller.signal
     };
     if (options.body !== void 0) {
       fetchOptions.body = JSON.stringify(options.body);
     }
-    return this.requestWithRetry(url.toString(), fetchOptions);
+    try {
+      const result = await this.requestWithRetry(
+        url.toString(),
+        fetchOptions,
+        0,
+        startTime
+      );
+      const duration = performance.now() - startTime;
+      if (typeof console !== "undefined") {
+        console.log(
+          `[HttpClient] ${method} ${path} completed in ${duration.toFixed(2)}ms`
+        );
+      }
+      return result;
+    } catch (error) {
+      const duration = performance.now() - startTime;
+      if (typeof console !== "undefined") {
+        const isCacheGetNotFound = path === "/v1/cache/get" && error instanceof SDKError && (error.httpStatus === 404 || error.httpStatus === 500 && error.message?.toLowerCase().includes("key not found"));
+        const isBlockedUsersNotFound = path === "/v1/rqlite/find-one" && error instanceof SDKError && error.httpStatus === 404 && options.body && (() => {
+          try {
+            const body = typeof options.body === "string" ? JSON.parse(options.body) : options.body;
+            return body.table === "blocked_users";
+          } catch {
+            return false;
+          }
+        })();
+        const isConversationParticipantNotFound = path === "/v1/rqlite/find-one" && error instanceof SDKError && error.httpStatus === 404 && options.body && (() => {
+          try {
+            const body = typeof options.body === "string" ? JSON.parse(options.body) : options.body;
+            return body.table === "conversation_participants";
+          } catch {
+            return false;
+          }
+        })();
+        if (isCacheGetNotFound || isBlockedUsersNotFound || isConversationParticipantNotFound) {
+        } else {
+          console.error(
+            `[HttpClient] ${method} ${path} failed after ${duration.toFixed(
+              2
+            )}ms:`,
+            error
+          );
+        }
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeoutId);
+    }
   }
-  async requestWithRetry(url, options, attempt = 0) {
+  async requestWithRetry(url, options, attempt = 0, startTime) {
     try {
       const response = await this.fetch(url, options);
       if (!response.ok) {
@@ -96,7 +177,7 @@ var HttpClient = class {
         await new Promise(
           (resolve) => setTimeout(resolve, this.retryDelayMs * (attempt + 1))
         );
-        return this.requestWithRetry(url, options, attempt + 1);
+        return this.requestWithRetry(url, options, attempt + 1, startTime);
       }
       throw error;
     }
@@ -113,6 +194,90 @@ var HttpClient = class {
   async delete(path, options) {
     return this.request("DELETE", path, options);
   }
+  /**
+   * Upload a file using multipart/form-data
+   * This is a special method for file uploads that bypasses JSON serialization
+   */
+  async uploadFile(path, formData, options) {
+    const startTime = performance.now();
+    const url = new URL(this.baseURL + path);
+    const headers = {
+      ...this.getAuthHeaders(path)
+      // Don't set Content-Type - browser will set it with boundary
+    };
+    const controller = new AbortController();
+    const requestTimeout = options?.timeout ?? this.timeout * 5;
+    const timeoutId = setTimeout(() => controller.abort(), requestTimeout);
+    const fetchOptions = {
+      method: "POST",
+      headers,
+      body: formData,
+      signal: controller.signal
+    };
+    try {
+      const result = await this.requestWithRetry(
+        url.toString(),
+        fetchOptions,
+        0,
+        startTime
+      );
+      const duration = performance.now() - startTime;
+      if (typeof console !== "undefined") {
+        console.log(
+          `[HttpClient] POST ${path} (upload) completed in ${duration.toFixed(
+            2
+          )}ms`
+        );
+      }
+      return result;
+    } catch (error) {
+      const duration = performance.now() - startTime;
+      if (typeof console !== "undefined") {
+        console.error(
+          `[HttpClient] POST ${path} (upload) failed after ${duration.toFixed(
+            2
+          )}ms:`,
+          error
+        );
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Get a binary response (returns Response object for streaming)
+   */
+  async getBinary(path) {
+    const url = new URL(this.baseURL + path);
+    const headers = {
+      ...this.getAuthHeaders(path)
+    };
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout * 5);
+    const fetchOptions = {
+      method: "GET",
+      headers,
+      signal: controller.signal
+    };
+    try {
+      const response = await this.fetch(url.toString(), fetchOptions);
+      if (!response.ok) {
+        clearTimeout(timeoutId);
+        const error = await response.json().catch(() => ({
+          error: response.statusText
+        }));
+        throw SDKError.fromResponse(response.status, error);
+      }
+      return response;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof SDKError) {
+        throw error;
+      }
+      throw error;
+    }
+  }
   getToken() {
     return this.getAuthToken();
   }
@@ -178,13 +343,11 @@ var AuthClient = class {
   }
   setApiKey(apiKey) {
     this.currentApiKey = apiKey;
-    this.currentJwt = void 0;
     this.httpClient.setApiKey(apiKey);
     this.storage.set("apiKey", apiKey);
   }
   setJwt(jwt) {
     this.currentJwt = jwt;
-    this.currentApiKey = void 0;
     this.httpClient.setJwt(jwt);
     this.storage.set("jwt", jwt);
   }
@@ -207,12 +370,50 @@ var AuthClient = class {
     this.setJwt(token);
     return token;
   }
+  /**
+   * Logout user and clear JWT, but preserve API key
+   * Use this for user logout in apps where API key is app-level credential
+   */
+  async logoutUser() {
+    if (this.currentJwt) {
+      try {
+        await this.httpClient.post("/v1/auth/logout", { all: true });
+      } catch (error) {
+        console.warn(
+          "Server-side logout failed, continuing with local cleanup:",
+          error
+        );
+      }
+    }
+    this.currentJwt = void 0;
+    this.httpClient.setJwt(void 0);
+    await this.storage.set("jwt", "");
+    if (!this.currentApiKey) {
+      const storedApiKey = await this.storage.get("apiKey");
+      if (storedApiKey) {
+        this.currentApiKey = storedApiKey;
+      }
+    }
+    if (this.currentApiKey) {
+      this.httpClient.setApiKey(this.currentApiKey);
+      console.log("[Auth] API key restored after user logout");
+    } else {
+      console.warn("[Auth] No API key available after logout");
+    }
+  }
+  /**
+   * Full logout - clears both JWT and API key
+   * Use this to completely reset authentication state
+   */
   async logout() {
     if (this.currentJwt) {
       try {
         await this.httpClient.post("/v1/auth/logout", { all: true });
       } catch (error) {
-        console.warn("Server-side logout failed, continuing with local cleanup:", error);
+        console.warn(
+          "Server-side logout failed, continuing with local cleanup:",
+          error
+        );
       }
     }
     this.currentApiKey = void 0;
@@ -228,6 +429,51 @@ var AuthClient = class {
     this.httpClient.setJwt(void 0);
     await this.storage.clear();
   }
+  /**
+   * Request a challenge nonce for wallet authentication
+   */
+  async challenge(params) {
+    const response = await this.httpClient.post("/v1/auth/challenge", {
+      wallet: params.wallet,
+      purpose: params.purpose || "authentication",
+      namespace: params.namespace || "default"
+    });
+    return response;
+  }
+  /**
+   * Verify wallet signature and get JWT token
+   */
+  async verify(params) {
+    const response = await this.httpClient.post("/v1/auth/verify", {
+      wallet: params.wallet,
+      nonce: params.nonce,
+      signature: params.signature,
+      namespace: params.namespace || "default",
+      chain_type: params.chain_type || "ETH"
+    });
+    this.setJwt(response.access_token);
+    if (response.api_key) {
+      this.setApiKey(response.api_key);
+    }
+    if (response.refresh_token) {
+      await this.storage.set("refreshToken", response.refresh_token);
+    }
+    return response;
+  }
+  /**
+   * Get API key for wallet (creates namespace ownership)
+   */
+  async getApiKey(params) {
+    const response = await this.httpClient.post("/v1/auth/api-key", {
+      wallet: params.wallet,
+      nonce: params.nonce,
+      signature: params.signature,
+      namespace: params.namespace || "default",
+      chain_type: params.chain_type || "ETH"
+    });
+    this.setApiKey(response.api_key);
+    return response;
+  }
 };
 
 // src/db/qb.ts
@@ -397,7 +643,9 @@ var Repository = class {
   buildInsertSql(entity) {
     const columns = Object.keys(entity).filter((k) => entity[k] !== void 0);
     const placeholders = columns.map(() => "?").join(", ");
-    return `INSERT INTO ${this.tableName} (${columns.join(", ")}) VALUES (${placeholders})`;
+    return `INSERT INTO ${this.tableName} (${columns.join(
+      ", "
+    )}) VALUES (${placeholders})`;
   }
   buildInsertArgs(entity) {
     return Object.entries(entity).filter(([, v]) => v !== void 0).map(([, v]) => v);
@@ -506,33 +754,35 @@ var DBClient = class {
 import WebSocket from "isomorphic-ws";
 var WSClient = class {
   constructor(config) {
-    this.reconnectAttempts = 0;
     this.messageHandlers = /* @__PURE__ */ new Set();
     this.errorHandlers = /* @__PURE__ */ new Set();
     this.closeHandlers = /* @__PURE__ */ new Set();
-    this.isManuallyClosed = false;
+    this.openHandlers = /* @__PURE__ */ new Set();
+    this.isClosed = false;
     this.url = config.wsURL;
     this.timeout = config.timeout ?? 3e4;
-    this.maxReconnectAttempts = config.maxReconnectAttempts ?? 5;
-    this.reconnectDelayMs = config.reconnectDelayMs ?? 1e3;
-    this.heartbeatIntervalMs = config.heartbeatIntervalMs ?? 3e4;
-    this.authMode = config.authMode ?? "header";
     this.authToken = config.authToken;
     this.WebSocketClass = config.WebSocket ?? WebSocket;
   }
+  /**
+   * Connect to WebSocket server
+   */
   connect() {
     return new Promise((resolve, reject) => {
       try {
         const wsUrl = this.buildWSUrl();
         this.ws = new this.WebSocketClass(wsUrl);
+        this.isClosed = false;
         const timeout = setTimeout(() => {
           this.ws?.close();
-          reject(new SDKError("WebSocket connection timeout", 408, "WS_TIMEOUT"));
+          reject(
+            new SDKError("WebSocket connection timeout", 408, "WS_TIMEOUT")
+          );
         }, this.timeout);
         this.ws.addEventListener("open", () => {
           clearTimeout(timeout);
-          this.reconnectAttempts = 0;
-          this.startHeartbeat();
+          console.log("[WSClient] Connected to", this.url);
+          this.openHandlers.forEach((handler) => handler());
           resolve();
         });
         this.ws.addEventListener("message", (event) => {
@@ -540,29 +790,24 @@ var WSClient = class {
           this.messageHandlers.forEach((handler) => handler(msgEvent.data));
         });
         this.ws.addEventListener("error", (event) => {
+          console.error("[WSClient] WebSocket error:", event);
           clearTimeout(timeout);
-          const error = new SDKError(
-            "WebSocket error",
-            500,
-            "WS_ERROR",
-            event
-          );
+          const error = new SDKError("WebSocket error", 500, "WS_ERROR", event);
           this.errorHandlers.forEach((handler) => handler(error));
         });
         this.ws.addEventListener("close", () => {
           clearTimeout(timeout);
-          this.stopHeartbeat();
-          if (!this.isManuallyClosed) {
-            this.attemptReconnect();
-          } else {
-            this.closeHandlers.forEach((handler) => handler());
-          }
+          console.log("[WSClient] Connection closed");
+          this.closeHandlers.forEach((handler) => handler());
         });
       } catch (error) {
         reject(error);
       }
     });
   }
+  /**
+   * Build WebSocket URL with auth token
+   */
   buildWSUrl() {
     let url = this.url;
     if (this.authToken) {
@@ -572,85 +817,152 @@ var WSClient = class {
     }
     return url;
   }
-  startHeartbeat() {
-    this.heartbeatInterval = setInterval(() => {
-      if (this.ws?.readyState === WebSocket.OPEN) {
-        this.ws.send(JSON.stringify({ type: "ping" }));
-      }
-    }, this.heartbeatIntervalMs);
-  }
-  stopHeartbeat() {
-    if (this.heartbeatInterval) {
-      clearInterval(this.heartbeatInterval);
-      this.heartbeatInterval = void 0;
-    }
-  }
-  attemptReconnect() {
-    if (this.reconnectAttempts < this.maxReconnectAttempts) {
-      this.reconnectAttempts++;
-      const delayMs = this.reconnectDelayMs * this.reconnectAttempts;
-      setTimeout(() => {
-        this.connect().catch((error) => {
-          this.errorHandlers.forEach((handler) => handler(error));
-        });
-      }, delayMs);
-    } else {
-      this.closeHandlers.forEach((handler) => handler());
-    }
-  }
+  /**
+   * Register message handler
+   */
   onMessage(handler) {
     this.messageHandlers.add(handler);
     return () => this.messageHandlers.delete(handler);
   }
+  /**
+   * Unregister message handler
+   */
+  offMessage(handler) {
+    this.messageHandlers.delete(handler);
+  }
+  /**
+   * Register error handler
+   */
   onError(handler) {
     this.errorHandlers.add(handler);
     return () => this.errorHandlers.delete(handler);
   }
+  /**
+   * Unregister error handler
+   */
+  offError(handler) {
+    this.errorHandlers.delete(handler);
+  }
+  /**
+   * Register close handler
+   */
   onClose(handler) {
     this.closeHandlers.add(handler);
     return () => this.closeHandlers.delete(handler);
   }
+  /**
+   * Unregister close handler
+   */
+  offClose(handler) {
+    this.closeHandlers.delete(handler);
+  }
+  /**
+   * Register open handler
+   */
+  onOpen(handler) {
+    this.openHandlers.add(handler);
+    return () => this.openHandlers.delete(handler);
+  }
+  /**
+   * Send data through WebSocket
+   */
   send(data) {
     if (this.ws?.readyState !== WebSocket.OPEN) {
-      throw new SDKError(
-        "WebSocket is not connected",
-        500,
-        "WS_NOT_CONNECTED"
-      );
+      throw new SDKError("WebSocket is not connected", 500, "WS_NOT_CONNECTED");
     }
     this.ws.send(data);
   }
+  /**
+   * Close WebSocket connection
+   */
   close() {
-    this.isManuallyClosed = true;
-    this.stopHeartbeat();
+    if (this.isClosed) {
+      return;
+    }
+    this.isClosed = true;
     this.ws?.close();
   }
+  /**
+   * Check if WebSocket is connected
+   */
   isConnected() {
-    return this.ws?.readyState === WebSocket.OPEN;
+    return !this.isClosed && this.ws?.readyState === WebSocket.OPEN;
   }
+  /**
+   * Update auth token
+   */
   setAuthToken(token) {
     this.authToken = token;
   }
 };
 
 // src/pubsub/client.ts
+function base64Encode(str) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(str).toString("base64");
+  } else if (typeof btoa !== "undefined") {
+    return btoa(
+      encodeURIComponent(str).replace(
+        /%([0-9A-F]{2})/g,
+        (match, p1) => String.fromCharCode(parseInt(p1, 16))
+      )
+    );
+  }
+  throw new Error("No base64 encoding method available");
+}
+function base64EncodeBytes(bytes) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(bytes).toString("base64");
+  } else if (typeof btoa !== "undefined") {
+    let binary = "";
+    for (let i = 0; i < bytes.length; i++) {
+      binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+  }
+  throw new Error("No base64 encoding method available");
+}
+function base64Decode(b64) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(b64, "base64").toString("utf-8");
+  } else if (typeof atob !== "undefined") {
+    const binary = atob(b64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    return new TextDecoder().decode(bytes);
+  }
+  throw new Error("No base64 decoding method available");
+}
 var PubSubClient = class {
   constructor(httpClient, wsConfig = {}) {
     this.httpClient = httpClient;
     this.wsConfig = wsConfig;
   }
   /**
-   * Publish a message to a topic.
+   * Publish a message to a topic via HTTP
    */
   async publish(topic, data) {
-    const dataBase64 = typeof data === "string" ? Buffer.from(data).toString("base64") : Buffer.from(data).toString("base64");
-    await this.httpClient.post("/v1/pubsub/publish", {
-      topic,
-      data_base64: dataBase64
-    });
+    let dataBase64;
+    if (typeof data === "string") {
+      dataBase64 = base64Encode(data);
+    } else {
+      dataBase64 = base64EncodeBytes(data);
+    }
+    await this.httpClient.post(
+      "/v1/pubsub/publish",
+      {
+        topic,
+        data_base64: dataBase64
+      },
+      {
+        timeout: 3e4
+      }
+    );
   }
   /**
-   * List active topics in the current namespace.
+   * List active topics in the current namespace
    */
   async topics() {
     const response = await this.httpClient.get(
@@ -659,18 +971,20 @@ var PubSubClient = class {
     return response.topics || [];
   }
   /**
-   * Subscribe to a topic via WebSocket.
-   * Returns a subscription object with event handlers.
+   * Subscribe to a topic via WebSocket
+   * Creates one WebSocket connection per topic
    */
   async subscribe(topic, handlers = {}) {
-    const wsUrl = new URL(this.wsConfig.wsURL || "ws://localhost:6001");
+    const wsUrl = new URL(this.wsConfig.wsURL || "ws://127.0.0.1:6001");
     wsUrl.pathname = "/v1/pubsub/ws";
     wsUrl.searchParams.set("topic", topic);
+    const authToken = this.httpClient.getApiKey() ?? this.httpClient.getToken();
     const wsClient = new WSClient({
       ...this.wsConfig,
       wsURL: wsUrl.toString(),
-      authToken: this.httpClient.getToken()
+      authToken
     });
+    await wsClient.connect();
     const subscription = new Subscription(wsClient, topic);
     if (handlers.onMessage) {
       subscription.onMessage(handlers.onMessage);
@@ -681,7 +995,6 @@ var PubSubClient = class {
     if (handlers.onClose) {
       subscription.onClose(handlers.onClose);
     }
-    await wsClient.connect();
     return subscription;
   }
 };
@@ -690,46 +1003,105 @@ var Subscription = class {
     this.messageHandlers = /* @__PURE__ */ new Set();
     this.errorHandlers = /* @__PURE__ */ new Set();
     this.closeHandlers = /* @__PURE__ */ new Set();
+    this.isClosed = false;
+    this.wsMessageHandler = null;
+    this.wsErrorHandler = null;
+    this.wsCloseHandler = null;
     this.wsClient = wsClient;
     this.topic = topic;
-    this.wsClient.onMessage((data) => {
+    this.wsMessageHandler = (data) => {
       try {
+        const envelope = JSON.parse(data);
+        if (!envelope || typeof envelope !== "object") {
+          throw new Error("Invalid envelope: not an object");
+        }
+        if (!envelope.data || typeof envelope.data !== "string") {
+          throw new Error("Invalid envelope: missing or invalid data field");
+        }
+        if (!envelope.topic || typeof envelope.topic !== "string") {
+          throw new Error("Invalid envelope: missing or invalid topic field");
+        }
+        if (typeof envelope.timestamp !== "number") {
+          throw new Error(
+            "Invalid envelope: missing or invalid timestamp field"
+          );
+        }
+        const messageData = base64Decode(envelope.data);
         const message = {
-          topic: this.topic,
-          data,
-          timestamp: Date.now()
+          topic: envelope.topic,
+          data: messageData,
+          timestamp: envelope.timestamp
         };
+        console.log("[Subscription] Received message on topic:", this.topic);
         this.messageHandlers.forEach((handler) => handler(message));
       } catch (error) {
+        console.error("[Subscription] Error processing message:", error);
         this.errorHandlers.forEach(
           (handler) => handler(error instanceof Error ? error : new Error(String(error)))
         );
       }
-    });
-    this.wsClient.onError((error) => {
+    };
+    this.wsClient.onMessage(this.wsMessageHandler);
+    this.wsErrorHandler = (error) => {
       this.errorHandlers.forEach((handler) => handler(error));
-    });
-    this.wsClient.onClose(() => {
+    };
+    this.wsClient.onError(this.wsErrorHandler);
+    this.wsCloseHandler = () => {
       this.closeHandlers.forEach((handler) => handler());
-    });
+    };
+    this.wsClient.onClose(this.wsCloseHandler);
   }
+  /**
+   * Register message handler
+   */
   onMessage(handler) {
     this.messageHandlers.add(handler);
     return () => this.messageHandlers.delete(handler);
   }
+  /**
+   * Register error handler
+   */
   onError(handler) {
     this.errorHandlers.add(handler);
     return () => this.errorHandlers.delete(handler);
   }
+  /**
+   * Register close handler
+   */
   onClose(handler) {
     this.closeHandlers.add(handler);
     return () => this.closeHandlers.delete(handler);
   }
+  /**
+   * Close subscription and underlying WebSocket
+   */
   close() {
+    if (this.isClosed) {
+      return;
+    }
+    this.isClosed = true;
+    if (this.wsMessageHandler) {
+      this.wsClient.offMessage(this.wsMessageHandler);
+      this.wsMessageHandler = null;
+    }
+    if (this.wsErrorHandler) {
+      this.wsClient.offError(this.wsErrorHandler);
+      this.wsErrorHandler = null;
+    }
+    if (this.wsCloseHandler) {
+      this.wsClient.offClose(this.wsCloseHandler);
+      this.wsCloseHandler = null;
+    }
+    this.messageHandlers.clear();
+    this.errorHandlers.clear();
+    this.closeHandlers.clear();
     this.wsClient.close();
   }
+  /**
+   * Check if subscription is active
+   */
   isConnected() {
-    return this.wsClient.isConnected();
+    return !this.isClosed && this.wsClient.isConnected();
   }
 };
 
@@ -753,7 +1125,9 @@ var NetworkClient = class {
    * Get network status.
    */
   async status() {
-    const response = await this.httpClient.get("/v1/status");
+    const response = await this.httpClient.get(
+      "/v1/network/status"
+    );
     return response;
   }
   /**
@@ -777,6 +1151,325 @@ var NetworkClient = class {
   async disconnect(peerId) {
     await this.httpClient.post("/v1/network/disconnect", { peer_id: peerId });
   }
+  /**
+   * Proxy an HTTP request through the Anyone network.
+   * Requires authentication (API key or JWT).
+   *
+   * @param request - The proxy request configuration
+   * @returns The proxied response
+   * @throws {SDKError} If the Anyone proxy is not available or the request fails
+   *
+   * @example
+   * ```ts
+   * const response = await client.network.proxyAnon({
+   *   url: 'https://api.example.com/data',
+   *   method: 'GET',
+   *   headers: {
+   *     'Accept': 'application/json'
+   *   }
+   * });
+   *
+   * console.log(response.status_code); // 200
+   * console.log(response.body); // Response data
+   * ```
+   */
+  async proxyAnon(request) {
+    const response = await this.httpClient.post(
+      "/v1/proxy/anon",
+      request
+    );
+    if (response.error) {
+      throw new Error(`Proxy request failed: ${response.error}`);
+    }
+    return response;
+  }
+};
+
+// src/cache/client.ts
+var CacheClient = class {
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+  }
+  /**
+   * Check cache service health
+   */
+  async health() {
+    return this.httpClient.get("/v1/cache/health");
+  }
+  /**
+   * Get a value from cache
+   * Returns null if the key is not found (cache miss/expired), which is normal behavior
+   */
+  async get(dmap, key) {
+    try {
+      return await this.httpClient.post("/v1/cache/get", {
+        dmap,
+        key
+      });
+    } catch (error) {
+      if (error instanceof SDKError && (error.httpStatus === 404 || error.httpStatus === 500 && error.message?.toLowerCase().includes("key not found"))) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Put a value into cache
+   */
+  async put(dmap, key, value, ttl) {
+    return this.httpClient.post("/v1/cache/put", {
+      dmap,
+      key,
+      value,
+      ttl
+    });
+  }
+  /**
+   * Delete a value from cache
+   */
+  async delete(dmap, key) {
+    return this.httpClient.post("/v1/cache/delete", {
+      dmap,
+      key
+    });
+  }
+  /**
+   * Get multiple values from cache in a single request
+   * Returns a map of key -> value (or null if not found)
+   * Gracefully handles 404 errors (endpoint not implemented) by returning empty results
+   */
+  async multiGet(dmap, keys) {
+    try {
+      if (keys.length === 0) {
+        return /* @__PURE__ */ new Map();
+      }
+      const response = await this.httpClient.post(
+        "/v1/cache/mget",
+        {
+          dmap,
+          keys
+        }
+      );
+      const resultMap = /* @__PURE__ */ new Map();
+      keys.forEach((key) => {
+        resultMap.set(key, null);
+      });
+      if (response.results) {
+        response.results.forEach(({ key, value }) => {
+          resultMap.set(key, value);
+        });
+      }
+      return resultMap;
+    } catch (error) {
+      if (error instanceof SDKError && error.httpStatus === 404) {
+        const resultMap2 = /* @__PURE__ */ new Map();
+        keys.forEach((key) => {
+          resultMap2.set(key, null);
+        });
+        return resultMap2;
+      }
+      const resultMap = /* @__PURE__ */ new Map();
+      keys.forEach((key) => {
+        resultMap.set(key, null);
+      });
+      console.error(`[CacheClient] Error in multiGet for ${dmap}:`, error);
+      return resultMap;
+    }
+  }
+  /**
+   * Scan keys in a distributed map, optionally matching a regex pattern
+   */
+  async scan(dmap, match) {
+    return this.httpClient.post("/v1/cache/scan", {
+      dmap,
+      match
+    });
+  }
+};
+
+// src/storage/client.ts
+var StorageClient = class {
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+  }
+  /**
+   * Upload content to IPFS and optionally pin it.
+   * Supports both File objects (browser) and Buffer/ReadableStream (Node.js).
+   *
+   * @param file - File to upload (File, Blob, or Buffer)
+   * @param name - Optional filename
+   * @param options - Optional upload options
+   * @param options.pin - Whether to pin the content (default: true). Pinning happens asynchronously on the backend.
+   * @returns Upload result with CID
+   *
+   * @example
+   * ```ts
+   * // Browser
+   * const fileInput = document.querySelector('input[type="file"]');
+   * const file = fileInput.files[0];
+   * const result = await client.storage.upload(file, file.name);
+   * console.log(result.cid);
+   *
+   * // Node.js
+   * const fs = require('fs');
+   * const fileBuffer = fs.readFileSync('image.jpg');
+   * const result = await client.storage.upload(fileBuffer, 'image.jpg', { pin: true });
+   * ```
+   */
+  async upload(file, name, options) {
+    const formData = new FormData();
+    if (file instanceof File) {
+      formData.append("file", file);
+    } else if (file instanceof Blob) {
+      formData.append("file", file, name);
+    } else if (file instanceof ArrayBuffer) {
+      const blob = new Blob([file]);
+      formData.append("file", blob, name);
+    } else if (file instanceof Uint8Array) {
+      const buffer = file.buffer.slice(
+        file.byteOffset,
+        file.byteOffset + file.byteLength
+      );
+      const blob = new Blob([buffer], { type: "application/octet-stream" });
+      formData.append("file", blob, name);
+    } else if (file instanceof ReadableStream) {
+      const chunks = [];
+      const reader = file.getReader();
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        const buffer = value.buffer.slice(
+          value.byteOffset,
+          value.byteOffset + value.byteLength
+        );
+        chunks.push(buffer);
+      }
+      const blob = new Blob(chunks);
+      formData.append("file", blob, name);
+    } else {
+      throw new Error(
+        "Unsupported file type. Use File, Blob, ArrayBuffer, Uint8Array, or ReadableStream."
+      );
+    }
+    const shouldPin = options?.pin !== false;
+    formData.append("pin", shouldPin ? "true" : "false");
+    return this.httpClient.uploadFile(
+      "/v1/storage/upload",
+      formData,
+      { timeout: 3e5 }
+      // 5 minute timeout for large files
+    );
+  }
+  /**
+   * Pin an existing CID
+   *
+   * @param cid - Content ID to pin
+   * @param name - Optional name for the pin
+   * @returns Pin result
+   */
+  async pin(cid, name) {
+    return this.httpClient.post("/v1/storage/pin", {
+      cid,
+      name
+    });
+  }
+  /**
+   * Get the pin status for a CID
+   *
+   * @param cid - Content ID to check
+   * @returns Pin status information
+   */
+  async status(cid) {
+    return this.httpClient.get(`/v1/storage/status/${cid}`);
+  }
+  /**
+   * Retrieve content from IPFS by CID
+   *
+   * @param cid - Content ID to retrieve
+   * @returns ReadableStream of the content
+   *
+   * @example
+   * ```ts
+   * const stream = await client.storage.get(cid);
+   * const reader = stream.getReader();
+   * while (true) {
+   *   const { done, value } = await reader.read();
+   *   if (done) break;
+   *   // Process chunk
+   * }
+   * ```
+   */
+  async get(cid) {
+    const maxAttempts = 8;
+    let lastError = null;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        const response = await this.httpClient.getBinary(
+          `/v1/storage/get/${cid}`
+        );
+        if (!response.body) {
+          throw new Error("Response body is null");
+        }
+        return response.body;
+      } catch (error) {
+        lastError = error;
+        const isNotFound = error?.httpStatus === 404 || error?.message?.includes("not found") || error?.message?.includes("404");
+        if (!isNotFound || attempt === maxAttempts) {
+          throw error;
+        }
+        const backoffMs = attempt * 2500;
+        await new Promise((resolve) => setTimeout(resolve, backoffMs));
+      }
+    }
+    throw lastError || new Error("Failed to retrieve content");
+  }
+  /**
+   * Retrieve content from IPFS by CID and return the full Response object
+   * Useful when you need access to response headers (e.g., content-length)
+   *
+   * @param cid - Content ID to retrieve
+   * @returns Response object with body stream and headers
+   *
+   * @example
+   * ```ts
+   * const response = await client.storage.getBinary(cid);
+   * const contentLength = response.headers.get('content-length');
+   * const reader = response.body.getReader();
+   * // ... read stream
+   * ```
+   */
+  async getBinary(cid) {
+    const maxAttempts = 8;
+    let lastError = null;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        const response = await this.httpClient.getBinary(
+          `/v1/storage/get/${cid}`
+        );
+        if (!response) {
+          throw new Error("Response is null");
+        }
+        return response;
+      } catch (error) {
+        lastError = error;
+        const isNotFound = error?.httpStatus === 404 || error?.message?.includes("not found") || error?.message?.includes("404");
+        if (!isNotFound || attempt === maxAttempts) {
+          throw error;
+        }
+        const backoffMs = attempt * 2500;
+        await new Promise((resolve) => setTimeout(resolve, backoffMs));
+      }
+    }
+    throw lastError || new Error("Failed to retrieve content");
+  }
+  /**
+   * Unpin a CID
+   *
+   * @param cid - Content ID to unpin
+   */
+  async unpin(cid) {
+    await this.httpClient.delete(`/v1/storage/unpin/${cid}`);
+  }
 };
 
 // src/index.ts
@@ -801,15 +1494,20 @@ function createClient(config) {
     wsURL
   });
   const network = new NetworkClient(httpClient);
+  const cache = new CacheClient(httpClient);
+  const storage = new StorageClient(httpClient);
   return {
     auth,
     db,
     pubsub,
-    network
+    network,
+    cache,
+    storage
   };
 }
 export {
   AuthClient,
+  CacheClient,
   DBClient,
   HttpClient,
   LocalStorageAdapter,
@@ -819,6 +1517,7 @@ export {
   QueryBuilder,
   Repository,
   SDKError,
+  StorageClient,
   Subscription,
   WSClient,
   createClient