@chitchat/sdk-react-native 0.2.0-dev.0 → 0.2.0-dev.2

package/README.md

@@ -46,8 +46,8 @@ const tokenProvider = createBackendTokenProvider({
 });
 
 const client = createChitChatNativeClient({
-  // TLS TCP host and port only. It is not http://, https://, ws://, or wss://.
-  endpoint: 'realtime.example.com:5223',
+  // TLS TCP hostname. Port 443 is applied when the port is omitted.
+  endpoint: 'realtime.example.com',
   tokenProvider,
   nativeModule,
   storage: durableNativeOutbox
@@ -57,14 +57,15 @@ client.on('connected', () => setRealtimeState('connected'));
 client.on('message', (frame) => handleChitChatFrame(frame));
 client.on('error', (error) => reportNonSensitiveRealtimeError(error));
 
-await client.connect();
+client.connect().catch(reportNonSensitiveRealtimeError);
 ```
 
 On logout or account switch:
 
 ```js
-await client.close();
-tokenProvider.invalidate();
+client.close()
+  .then(() => tokenProvider.invalidate())
+  .catch(reportNonSensitiveRealtimeError);
 ```
 
 ## Native bridge contract
@@ -91,7 +92,7 @@ The bridge must encode/decode the gateway’s actual generated Protobuf envelope
 
 ## Durable outbox
 
-The default core outbox is memory-only. To preserve queued messages when the app is restarted, pass a durable store with async `put(record)`, `remove(id)`, and `list()` methods. Use an encrypted/device-appropriate storage provider and return records sorted by `createdAt`.
+The default core outbox is memory-only. To preserve queued messages when the app is restarted, pass a durable store with Promise-returning `put(record)`, `remove(id)`, and `list()` methods. Use an encrypted/device-appropriate storage provider and return records sorted by `createdAt`.
 
 ## TLS requirements
 
@@ -106,7 +107,7 @@ The default core outbox is memory-only. To preserve queued messages when the app
 | Problem | Fix |
 | --- | --- |
 | `official ChitChat native TCP module is required` | Link/provide the native bridge and rebuild the app. Expo Go is not enough. |
-| `TLS host:port endpoint is required` | Use `realtime.example.com:5223`; do not pass an HTTP or WebSocket URL. |
+| `TLS host endpoint is required` | Use `realtime.example.com` (defaults to 443) or an explicit `host:port`; do not pass an HTTP or WebSocket URL. |
 | iOS SSL / certificate error | Check the hostname, SAN, trusted CA, device time, and gateway certificate chain. |
 | Repeated reconnects | Check token issuance/expiry, gateway reachability, bridge frame codec, and `error`/`reconnectFailed` events. |
 | Queued messages disappear after restart | Provide durable `storage`; the default is memory-only. |

package/index.d.ts

@@ -1,6 +1,7 @@
 import type { ReliableRealtimeClient, ReliableRealtimeClientOptions, RealtimeFrame } from '@chitchat/sdk-core';
 export interface ChitChatNativeConnection { onFrame(listener: (frame: RealtimeFrame) => void): void; onClose(listener: (reason?: unknown) => void): void; send(frame: RealtimeFrame): Promise<void> | void; close(): Promise<void> | void; }
-export interface ChitChatNativeModule { connect(input: { endpoint: string; token: string; protocol: 'chitchat.protobuf.v1'; tls: true }): Promise<ChitChatNativeConnection>; }
+export interface ChitChatNativeModule { connect(input: { endpoint: string; token: string; protocol: 'chitchat.protobuf.v1'; tls: true; minimumTlsVersion: 'TLSv1.2' | 'TLSv1.3'; pinnedPublicKeyHashes: string[] }): Promise<ChitChatNativeConnection>; }
 export function validateNativeTlsEndpoint(endpoint: string): string;
-export function createNativeTcpTransportFactory(options: { nativeModule: ChitChatNativeModule }): ReliableRealtimeClientOptions['nativeTransportFactory'];
-export function createChitChatNativeClient(options: Omit<ReliableRealtimeClientOptions, 'runtime' | 'nativeTransportFactory'> & { nativeModule: ChitChatNativeModule }): ReliableRealtimeClient;
+export function validatePinnedPublicKeyHashes(value?: string[]): string[];
+export function createNativeTcpTransportFactory(options: { nativeModule: ChitChatNativeModule; pinnedPublicKeyHashes?: string[]; minimumTlsVersion?: 'TLSv1.2' | 'TLSv1.3' }): ReliableRealtimeClientOptions['nativeTransportFactory'];
+export function createChitChatNativeClient(options: Omit<ReliableRealtimeClientOptions, 'runtime' | 'nativeTransportFactory'> & { nativeModule: ChitChatNativeModule; pinnedPublicKeyHashes?: string[]; minimumTlsVersion?: 'TLSv1.2' | 'TLSv1.3' }): ReliableRealtimeClient;

package/package.json

@@ -1,13 +1,19 @@
 {
   "name": "@chitchat/sdk-react-native",
-  "version": "0.2.0-dev.0",
+  "version": "0.2.0-dev.2",
+  "description": "React Native TLS transport adapter for the ChitChat Developer Platform",
+  "repository": { "type": "git", "url": "git+https://github.com/07Akashh/E2E-Chat.git", "directory": "developer-web/sdk/chitchat-native" },
+  "bugs": { "url": "https://github.com/07Akashh/E2E-Chat/issues" },
+  "homepage": "https://github.com/07Akashh/E2E-Chat/tree/main/docs/developer-platform",
   "main": "src/index.js",
-  "exports": { ".": { "types": "./index.d.ts", "require": "./src/index.js" } },
+  "exports": { ".": { "types": "./index.d.ts", "require": "./src/index.js", "import": "./src/index.js" } },
   "types": "index.d.ts",
-  "files": ["src", "index.d.ts", "README.md", "LICENSE"],
+  "files": ["src", "index.d.ts", "README.md"],
   "engines": { "node": ">=18" },
   "scripts": { "test": "node test/transport.test.js" },
-  "dependencies": { "@chitchat/sdk-core": "0.2.0-dev.0" },
+  "dependencies": { "@chitchat/sdk-core": "0.2.0-dev.2" },
+  "keywords": ["chitchat", "realtime", "react-native", "tls", "protobuf"],
+  "sideEffects": false,
   "license": "UNLICENSED",
   "publishConfig": { "access": "public", "tag": "development" }
 }

package/src/index.js

@@ -4,12 +4,13 @@ let ReliableRealtimeClient;
 try { ({ ReliableRealtimeClient } = require('@chitchat/sdk-core')); } catch (_) { ({ ReliableRealtimeClient } = require('../../chitchat-core/src')); }
 
 const validateNativeTlsEndpoint = (endpoint) => {
-  if (typeof endpoint !== 'string' || !endpoint.trim() || /\s/.test(endpoint)) throw new Error('A TLS host:port endpoint is required');
+  if (typeof endpoint !== 'string' || !endpoint.trim() || /\s/.test(endpoint)) throw new Error('A TLS host endpoint is required');
   if (/^(https?|wss?):\/\//i.test(endpoint)) throw new Error('React Native realtime requires a TLS TCP host:port endpoint, not a HTTP/WebSocket URL');
   let parsed;
-  try { parsed = new URL(`tls://${endpoint}`); } catch (_) { throw new Error('A valid TLS host:port endpoint is required'); }
-  if (!parsed.hostname || !parsed.port || Number(parsed.port) < 1 || Number(parsed.port) > 65535 || parsed.username || parsed.password || (parsed.pathname && parsed.pathname !== '/')) throw new Error('A valid TLS host:port endpoint is required');
-  return endpoint;
+  try { parsed = new URL(`tls://${endpoint}`); } catch (_) { throw new Error('A valid TLS host endpoint is required'); }
+  const port = parsed.port ? Number(parsed.port) : 443;
+  if (!parsed.hostname || port < 1 || port > 65535 || parsed.username || parsed.password || parsed.search || parsed.hash || (parsed.pathname && parsed.pathname !== '/')) throw new Error('A valid TLS host endpoint is required');
+  return `${parsed.hostname}:${port}`;
 };
 
 const assertConnection = (connection) => {
@@ -17,25 +18,37 @@ const assertConnection = (connection) => {
   return connection;
 };
 
-const createNativeTcpTransportFactory = ({ nativeModule }) => {
+const validatePinnedPublicKeyHashes = (value) => {
+  if (value === undefined) return [];
+  if (!Array.isArray(value) || value.length === 0 || value.length > 10 || value.some((hash) => typeof hash !== 'string' || !/^sha256\/[A-Za-z0-9+/]{43}=$/.test(hash))) {
+    throw new Error('pinnedPublicKeyHashes must contain one to ten sha256/base64 SPKI hashes');
+  }
+  return [...new Set(value)];
+};
+
+const createNativeTcpTransportFactory = ({ nativeModule, pinnedPublicKeyHashes, minimumTlsVersion = 'TLSv1.2' }) => {
   if (!nativeModule || typeof nativeModule.connect !== 'function') throw new Error('The official ChitChat native TCP module is required');
-  return async ({ endpoint, token, protocol }) => {
-    validateNativeTlsEndpoint(endpoint);
+  if (!['TLSv1.2', 'TLSv1.3'].includes(minimumTlsVersion)) throw new Error('minimumTlsVersion must be TLSv1.2 or TLSv1.3');
+  const pins = validatePinnedPublicKeyHashes(pinnedPublicKeyHashes);
+  return ({ endpoint, token, protocol }) => {
+    const normalizedEndpoint = validateNativeTlsEndpoint(endpoint);
     let connection; let onMessage = () => {}; let onClose = () => {};
-    return {
+    return Promise.resolve({
       onMessage: (listener) => { onMessage = listener; },
       onClose: (listener) => { onClose = listener; },
-      open: async () => {
-        connection = assertConnection(await nativeModule.connect({ endpoint, token, protocol, tls: true }));
-        connection.onFrame((frame) => onMessage(frame));
-        connection.onClose((reason) => onClose(reason));
-      },
+      open: () => Promise.resolve(nativeModule.connect({ endpoint: normalizedEndpoint, token, protocol, tls: true, minimumTlsVersion, pinnedPublicKeyHashes: pins }))
+        .then(assertConnection)
+        .then((openedConnection) => {
+          connection = openedConnection;
+          connection.onFrame((frame) => onMessage(frame));
+          connection.onClose((reason) => onClose(reason));
+        }),
       send: (frame) => connection ? Promise.resolve(connection.send(frame)) : Promise.reject(new Error('Native TCP transport is not open')),
       close: () => connection ? Promise.resolve(connection.close()) : Promise.resolve()
-    };
+    });
   };
 };
 
-const createChitChatNativeClient = ({ endpoint, tokenProvider, nativeModule, ...options }) => new ReliableRealtimeClient({ endpoint, tokenProvider, runtime: 'native', nativeTransportFactory: createNativeTcpTransportFactory({ nativeModule }), ...options });
+const createChitChatNativeClient = ({ endpoint, tokenProvider, nativeModule, pinnedPublicKeyHashes, minimumTlsVersion, ...options }) => new ReliableRealtimeClient({ endpoint, tokenProvider, runtime: 'native', nativeTransportFactory: createNativeTcpTransportFactory({ nativeModule, pinnedPublicKeyHashes, minimumTlsVersion }), ...options });
 
-module.exports = { createChitChatNativeClient, createNativeTcpTransportFactory, validateNativeTlsEndpoint };
+module.exports = { createChitChatNativeClient, createNativeTcpTransportFactory, validateNativeTlsEndpoint, validatePinnedPublicKeyHashes };