@teneo-protocol/sdk 2.2.2 → 3.0.1

package/src/managers/room-manager.ts

@@ -27,18 +27,20 @@ export class RoomManager extends EventEmitter<SDKEvents> {
    * Validates room ID and sends subscribe message to the server.
    * The actual subscription state is updated when the server confirms via room:subscribed event.
    *
-   * @param roomId - The ID of the room to subscribe to
-   * @returns Promise that resolves when subscribed
+   * Note: This only applies to public rooms. Private rooms are automatically available after authentication.
+   *
+   * @param roomId - The ID of the public room to subscribe to
+   * @returns Promise that resolves when subscription request is sent
    * @throws {SDKError} If not connected to the network
    * @throws {ValidationError} If roomId is empty or invalid
    *
    * @example
    * ```typescript
-   * await roomManager.subscribeToRoom('general');
-   * console.log('Subscription request sent to general room');
+   * await roomManager.subscribeToPublicRoom('room-id');
+   * console.log('Subscription request sent');
    * ```
    */
-  public async subscribeToRoom(roomId: string): Promise<void> {
+  public async subscribeToPublicRoom(roomId: string): Promise<void> {
     if (!this.wsClient.isConnected) {
       throw new SDKError("Not connected to Teneo Protocol", ErrorCode.NOT_CONNECTED);
     }
@@ -46,12 +48,25 @@ export class RoomManager extends EventEmitter<SDKEvents> {
     // Validate room ID
     const validatedRoomId = RoomIdSchema.parse(roomId);
 
-    this.logger.info("RoomManager: Subscribing to room", { roomId: validatedRoomId });
+    this.logger.info("RoomManager: Subscribing to public room", { roomId: validatedRoomId });
 
     const message = createSubscribe(validatedRoomId);
     await this.wsClient.sendMessage(message);
   }
 
+  /**
+   * @deprecated Use subscribeToPublicRoom() instead. This method only affects public rooms.
+   * Private rooms are automatically available after authentication without subscription.
+   *
+   * Subscribes to a public room in the Teneo Protocol.
+   *
+   * @param roomId - The ID of the public room to subscribe to
+   * @returns Promise that resolves when subscription request is sent
+   */
+  public async subscribeToRoom(roomId: string): Promise<void> {
+    return this.subscribeToPublicRoom(roomId);
+  }
+
   /**
    * Unsubscribes from a public room in the Teneo Protocol.
    * Validates room ID and sends unsubscribe message to the server.
@@ -66,11 +81,11 @@ export class RoomManager extends EventEmitter<SDKEvents> {
    *
    * @example
    * ```typescript
-   * await roomManager.unsubscribeFromRoom('public-announcements');
+   * await roomManager.unsubscribeFromPublicRoom('public-room-id');
    * console.log('Unsubscription request sent for public room');
    * ```
    */
-  public async unsubscribeFromRoom(roomId: string): Promise<void> {
+  public async unsubscribeFromPublicRoom(roomId: string): Promise<void> {
     if (!this.wsClient.isConnected) {
       throw new SDKError("Not connected to Teneo Protocol", ErrorCode.NOT_CONNECTED);
     }
@@ -78,12 +93,25 @@ export class RoomManager extends EventEmitter<SDKEvents> {
     // Validate room ID
     const validatedRoomId = RoomIdSchema.parse(roomId);
 
-    this.logger.info("RoomManager: Unsubscribing from room", { roomId: validatedRoomId });
+    this.logger.info("RoomManager: Unsubscribing from public room", { roomId: validatedRoomId });
 
     const message = createUnsubscribe(validatedRoomId);
     await this.wsClient.sendMessage(message);
   }
 
+  /**
+   * @deprecated Use unsubscribeFromPublicRoom() instead. This method only affects public rooms.
+   * Private rooms cannot be unsubscribed from.
+   *
+   * Unsubscribes from a public room in the Teneo Protocol.
+   *
+   * @param roomId - The ID of the public room to unsubscribe from
+   * @returns Promise that resolves when unsubscribed
+   */
+  public async unsubscribeFromRoom(roomId: string): Promise<void> {
+    return this.unsubscribeFromPublicRoom(roomId);
+  }
+
   /**
    * Updates the subscription state from server response.
    * This is the authoritative source of which rooms you're subscribed to.
@@ -95,7 +123,7 @@ export class RoomManager extends EventEmitter<SDKEvents> {
    * @example
    * ```typescript
    * // Internal SDK usage
-   * roomManager.updateSubscriptions(['general', 'support', 'trading']);
+   * roomManager.updateSubscriptions(['room-id-1', 'room-id-2', 'room-id-3']);
    * ```
    */
   public updateSubscriptions(subscriptions: string[]): void {
@@ -150,7 +178,7 @@ export class RoomManager extends EventEmitter<SDKEvents> {
    *
    * @example
    * ```typescript
-   * const room = roomManager.getRoom('general');
+   * const room = roomManager.getRoom('room-id');
    * if (room) {
    *   console.log(`Room: ${room.name}`);
    *   console.log(`Members: ${room.members?.length ?? 0}`);

package/src/payments/index.ts

@@ -1,22 +1,37 @@
 /**
  * Payment module exports for quote-approve flow (v2.2.0)
+ * Multi-network support added in v2.3.0
  */
 
 export {
   PaymentClient,
   type PaymentClientConfig,
-  // Constants
+  // Constants (legacy, for backwards compatibility)
   USDC_CONTRACT,
   PEAQ_CHAIN_ID,
   USDC_DECIMALS,
   X402_VERSION,
   DEFAULT_PAYMENT_TIMEOUT_SECONDS,
   DEFAULT_PAY_TO_ADDRESS,
-  DEFAULT_RPC_URL,
   // Utilities
   buildX402ResourceUrl,
   usdcToUnits,
-  unitsToUsdc,
-  // Types
-  type SupportedChain
+  unitsToUsdc
 } from "./payment-client";
+
+// Multi-network support (v2.3.0)
+export {
+  type NetworkConfig,
+  NETWORKS,
+  CHAIN_ID_TO_NETWORK,
+  CAIP2_TO_NETWORK,
+  getNetwork,
+  getDefaultNetwork,
+  createChainDefinition,
+  isNetworkSupported,
+  getSupportedNetworks,
+  // Network config fetching (v2.4.0)
+  setNetworkConfigUrl,
+  fetchNetworkConfigs,
+  initializeNetworks
+} from "./networks";

package/src/payments/networks.ts

@@ -0,0 +1,208 @@
+import { defineChain, type Chain } from "viem";
+import { z } from "zod";
+
+// Zod schema for runtime validation
+const NetworkConfigSchema = z.object({
+  chainId: z.number(),
+  name: z.string(),
+  caip2: z.string(),
+  rpcUrl: z.string().url(),
+  usdcContract: z.string(),
+  settlementRouter: z.string(),
+  transferHook: z.string(),
+  eip712: z.object({
+    name: z.string(),
+    version: z.string()
+  })
+});
+
+export type NetworkConfig = z.infer<typeof NetworkConfigSchema>;
+
+let cachedNetworks: Record<string, NetworkConfig> | null = null;
+let networksFetchPromise: Promise<Record<string, NetworkConfig>> | null = null;
+let lastFetchTime = 0;
+const CACHE_TTL_MS = 60 * 60 * 1000;
+
+export let NETWORKS: Record<string, NetworkConfig> = {};
+
+// Dynamic lookup mappings - populated from backend response in fetchNetworkConfigs()
+export let CHAIN_ID_TO_NETWORK: Record<number, string> = {};
+export let CAIP2_TO_NETWORK: Record<string, string> = {};
+
+let backendUrl: string | null = null;
+
+export function setNetworkConfigUrl(url: string): void {
+  backendUrl = url
+    .replace(/^wss:/, "https:")
+    .replace(/^ws:/, "http:")
+    .replace(/\/ws\/?$/, "");
+}
+
+export async function fetchNetworkConfigs(): Promise<Record<string, NetworkConfig>> {
+  if (cachedNetworks && Date.now() - lastFetchTime < CACHE_TTL_MS) {
+    return cachedNetworks;
+  }
+
+  if (networksFetchPromise) {
+    return networksFetchPromise;
+  }
+
+  if (!backendUrl) {
+    throw new Error("Backend URL not set. Call setNetworkConfigUrl() before initializing networks.");
+  }
+
+  networksFetchPromise = (async () => {
+    try {
+      const response = await fetch(`${backendUrl}/api/networks`, {
+        method: "GET",
+        headers: { "Accept": "application/json" }
+      });
+
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status} ${response.statusText}`);
+      }
+
+      const data = await response.json();
+      if (!data.networks || typeof data.networks !== "object" || Object.keys(data.networks).length === 0) {
+        throw new Error("Invalid or empty network config response");
+      }
+
+      // Validate each network config gracefully - skip invalid ones
+      const validatedNetworks: Record<string, NetworkConfig> = {};
+      const invalidNetworks: string[] = [];
+
+      for (const [name, config] of Object.entries(data.networks)) {
+        const result = NetworkConfigSchema.safeParse(config);
+        if (result.success) {
+          validatedNetworks[name] = result.data;
+        } else {
+          invalidNetworks.push(name);
+          console.warn(`[Networks] Skipping invalid network "${name}":`, result.error.issues.map(i => i.message).join(", "));
+        }
+      }
+
+      // If no valid networks, fall back to cache or throw
+      if (Object.keys(validatedNetworks).length === 0) {
+        if (cachedNetworks) {
+          console.warn("[Networks] All networks invalid, using cached config");
+          return cachedNetworks;
+        }
+        throw new Error(`All network configs failed validation. Invalid: ${invalidNetworks.join(", ")}`);
+      }
+
+      // Log warnings if some networks were invalid
+      if (invalidNetworks.length > 0) {
+        console.warn(`[Networks] ${invalidNetworks.length} network(s) failed validation and were skipped: ${invalidNetworks.join(", ")}`);
+      }
+
+      cachedNetworks = validatedNetworks;
+      lastFetchTime = Date.now();
+      NETWORKS = { ...validatedNetworks };
+
+      // Build dynamic lookup mappings from validated networks
+      CHAIN_ID_TO_NETWORK = {};
+      CAIP2_TO_NETWORK = {};
+      for (const [name, config] of Object.entries(validatedNetworks)) {
+        CHAIN_ID_TO_NETWORK[config.chainId] = name;
+        CAIP2_TO_NETWORK[config.caip2] = name;
+      }
+
+      console.log("[Networks] Fetched from backend:", Object.keys(validatedNetworks).join(", "));
+      return validatedNetworks;
+    } catch (error) {
+      if (cachedNetworks) {
+        console.warn("[Networks] Backend unavailable, using cached config");
+        return cachedNetworks;
+      }
+      throw new Error(`Failed to fetch network configs and no cache available: ${error}`);
+    } finally {
+      networksFetchPromise = null;
+    }
+  })();
+
+  return networksFetchPromise;
+}
+
+export async function initializeNetworks(): Promise<void> {
+  await fetchNetworkConfigs();
+}
+
+export function getNetwork(nameOrChainId: string | number): NetworkConfig {
+  if (Object.keys(NETWORKS).length === 0) {
+    throw new Error("Networks not initialized. Call initializeNetworks() first.");
+  }
+
+  if (typeof nameOrChainId === "number") {
+    const name = CHAIN_ID_TO_NETWORK[nameOrChainId];
+    if (!name) {
+      throw new Error(`Unknown chain ID: ${nameOrChainId}. Supported: ${Object.keys(CHAIN_ID_TO_NETWORK).join(", ")}`);
+    }
+    return NETWORKS[name];
+  }
+
+  if (nameOrChainId.startsWith("eip155:")) {
+    const name = CAIP2_TO_NETWORK[nameOrChainId];
+    if (!name) {
+      throw new Error(`Unknown CAIP-2 network: ${nameOrChainId}. Supported: ${Object.keys(CAIP2_TO_NETWORK).join(", ")}`);
+    }
+    return NETWORKS[name];
+  }
+
+  const network = NETWORKS[nameOrChainId.toLowerCase()];
+  if (!network) {
+    throw new Error(`Unknown network: ${nameOrChainId}. Supported: ${Object.keys(NETWORKS).join(", ")}`);
+  }
+  return network;
+}
+
+export function getDefaultNetwork(): NetworkConfig {
+  const networkKeys = Object.keys(NETWORKS);
+  if (networkKeys.length === 0) {
+    throw new Error("Networks not initialized. Call initializeNetworks() first.");
+  }
+
+  const envNetwork = process.env.TENEO_NETWORK;
+  if (envNetwork) {
+    try {
+      return getNetwork(envNetwork);
+    } catch {
+      console.warn(`Invalid TENEO_NETWORK: ${envNetwork}, using default`);
+    }
+  }
+
+  // Prefer "peaq" if available, otherwise use first available network
+  if (NETWORKS["peaq"]) {
+    return NETWORKS["peaq"];
+  }
+  return NETWORKS[networkKeys[0]];
+}
+
+export function createChainDefinition(network: NetworkConfig): Chain {
+  return defineChain({
+    id: network.chainId,
+    name: network.name,
+    network: network.name.toLowerCase().replace(/\s+/g, "-"),
+    nativeCurrency: {
+      decimals: 18,
+      name: network.name.split(" ")[0],
+      symbol: network.name === "PEAQ Mainnet" ? "PEAQ" : network.name === "Avalanche Mainnet" ? "AVAX" : "ETH"
+    },
+    rpcUrls: {
+      default: { http: [network.rpcUrl] },
+      public: { http: [network.rpcUrl] }
+    }
+  });
+}
+
+export function isNetworkSupported(nameOrChainId: string | number): boolean {
+  try {
+    getNetwork(nameOrChainId);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function getSupportedNetworks(): string[] {
+  return Object.keys(NETWORKS);
+}