@decentrl/sdk 0.0.1

package/src/websocket-transport.ts

@@ -0,0 +1,233 @@
+import { type DecentrlIdentityKeys, signJsonObject } from '@decentrl/crypto';
+
+export type ConnectionStatus = 'disconnected' | 'connecting' | 'authenticating' | 'connected';
+
+export interface WebSocketTransportCallbacks {
+	onPendingEvents: (events: Array<{ id: string; sender_did: string; payload: string }>) => void;
+	onContractsUpdated: () => void;
+	onStatusChange: (status: ConnectionStatus) => void;
+}
+
+export interface WebSocketTransportIdentity {
+	did: string;
+	keys: DecentrlIdentityKeys;
+}
+
+type WsMessage =
+	| { type: 'AUTH_SUCCESS' }
+	| { type: 'AUTH_FAILED'; error_code: string }
+	| { type: 'PENDING_EVENTS'; events: Array<{ id: string; sender_did: string; payload: string }> }
+	| { type: 'CONTRACTS_UPDATED' }
+	| { type: 'PING' };
+
+const MAX_RECONNECT_ATTEMPTS = 10;
+const BASE_RECONNECT_MS = 1000;
+const MAX_RECONNECT_MS = 30_000;
+const JITTER_FACTOR = 0.2;
+
+export class WebSocketTransport {
+	private ws: WebSocket | null = null;
+	private status: ConnectionStatus = 'disconnected';
+	private reconnectAttempt = 0;
+	private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+	private shouldReconnect = false;
+
+	constructor(
+		private getIdentity: () => WebSocketTransportIdentity | null,
+		private getWsUrl: () => string | null,
+		private callbacks: WebSocketTransportCallbacks,
+	) {}
+
+	connect(): void {
+		if (this.ws) {
+			return;
+		}
+
+		const wsUrl = this.getWsUrl();
+		const identity = this.getIdentity();
+
+		if (!wsUrl || !identity) {
+			console.warn('[Decentrl:WS] connect() skipped — wsUrl:', !!wsUrl, 'identity:', !!identity);
+
+			return;
+		}
+
+		console.debug('[Decentrl:WS] Connecting to', wsUrl);
+		this.shouldReconnect = true;
+		this.setStatus('connecting');
+
+		try {
+			this.ws = new WebSocket(wsUrl);
+		} catch (err) {
+			console.error('[Decentrl:WS] WebSocket constructor failed:', err);
+			this.setStatus('disconnected');
+			this.scheduleReconnect();
+
+			return;
+		}
+
+		this.ws.onopen = () => {
+			console.debug('[Decentrl:WS] Socket opened, authenticating...');
+			this.setStatus('authenticating');
+			this.sendAuthenticate(identity);
+		};
+
+		this.ws.onmessage = (event) => {
+			let data: WsMessage;
+
+			try {
+				data = JSON.parse(event.data as string);
+			} catch {
+				return;
+			}
+
+			this.handleMessage(data);
+		};
+
+		this.ws.onclose = (event) => {
+			console.debug(
+				'[Decentrl:WS] Socket closed — code:',
+				event.code,
+				'reason:',
+				event.reason,
+				'willReconnect:',
+				this.shouldReconnect,
+			);
+			this.ws = null;
+			this.setStatus('disconnected');
+
+			if (this.shouldReconnect) {
+				this.scheduleReconnect();
+			}
+		};
+
+		this.ws.onerror = () => {
+			console.error('[Decentrl:WS] Socket error (onclose will follow)');
+		};
+	}
+
+	disconnect(): void {
+		this.shouldReconnect = false;
+
+		if (this.reconnectTimer) {
+			clearTimeout(this.reconnectTimer);
+			this.reconnectTimer = null;
+		}
+
+		if (this.ws) {
+			this.ws.onclose = null;
+			this.ws.close();
+			this.ws = null;
+		}
+
+		this.reconnectAttempt = 0;
+		this.setStatus('disconnected');
+	}
+
+	getStatus(): ConnectionStatus {
+		return this.status;
+	}
+
+	private sendAuthenticate(identity: WebSocketTransportIdentity): void {
+		const payload = {
+			did: identity.did,
+			signing_key_id: `${identity.did}#signing`,
+			timestamp: Date.now(),
+			nonce: crypto.randomUUID(),
+		};
+
+		const signature = signJsonObject(payload, identity.keys.signing.privateKey);
+
+		this.send({
+			type: 'AUTHENTICATE',
+			...payload,
+			signature,
+		});
+	}
+
+	private handleMessage(data: WsMessage): void {
+		if (data.type !== 'PING') {
+			console.debug(
+				'[Decentrl:WS] Received:',
+				data.type,
+				data.type === 'PENDING_EVENTS' ? `(${data.events.length} events)` : '',
+			);
+		}
+
+		switch (data.type) {
+			case 'AUTH_SUCCESS':
+				this.reconnectAttempt = 0;
+				this.setStatus('connected');
+				break;
+
+			case 'AUTH_FAILED':
+				console.error('[Decentrl:WS] Auth failed:', data.error_code);
+				// Don't reconnect on auth failure — would fail again
+				this.shouldReconnect = false;
+				this.ws?.close();
+				break;
+
+			case 'PENDING_EVENTS':
+				this.callbacks.onPendingEvents(data.events);
+				break;
+
+			case 'CONTRACTS_UPDATED':
+				this.callbacks.onContractsUpdated();
+				break;
+
+			case 'PING':
+				this.send({ type: 'PONG', timestamp: Date.now() });
+				break;
+		}
+	}
+
+	private send(message: object): void {
+		if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+			this.ws.send(JSON.stringify(message));
+		}
+	}
+
+	private setStatus(status: ConnectionStatus): void {
+		if (this.status !== status) {
+			console.debug('[Decentrl:WS] Status:', this.status, '→', status);
+			this.status = status;
+			this.callbacks.onStatusChange(status);
+		}
+	}
+
+	private scheduleReconnect(): void {
+		if (this.reconnectAttempt >= MAX_RECONNECT_ATTEMPTS) {
+			console.warn(
+				'[Decentrl:WS] Max reconnect attempts reached (%d), giving up',
+				MAX_RECONNECT_ATTEMPTS,
+			);
+
+			return;
+		}
+
+		const backoff = Math.min(BASE_RECONNECT_MS * 2 ** this.reconnectAttempt, MAX_RECONNECT_MS);
+		const jitter = backoff * JITTER_FACTOR * (Math.random() * 2 - 1);
+		const delay = Math.max(0, backoff + jitter);
+
+		this.reconnectAttempt++;
+		console.debug(
+			'[Decentrl:WS] Reconnecting in %dms (attempt %d/%d)',
+			Math.round(delay),
+			this.reconnectAttempt,
+			MAX_RECONNECT_ATTEMPTS,
+		);
+		this.reconnectTimer = setTimeout(() => {
+			this.reconnectTimer = null;
+			this.ws = null;
+			this.connect();
+		}, delay);
+	}
+}
+
+export function deriveWsUrl(httpEndpoint: string): string {
+	const url = new URL(httpEndpoint);
+	url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
+	url.pathname = `${url.pathname.replace(/\/$/, '')}/ws`;
+
+	return url.toString();
+}