@xtr-dev/rondevu-client 0.13.0 → 0.17.0

package/dist/api.js

@@ -1,322 +1,279 @@
 /**
- * Rondevu API Client - Single class for all API endpoints
+ * Rondevu API Client - RPC interface
  */
-import * as ed25519 from '@noble/ed25519';
-// Set SHA-512 hash function for ed25519 (required in @noble/ed25519 v3+)
-ed25519.hashes.sha512Async = async (message) => {
-    return new Uint8Array(await crypto.subtle.digest('SHA-512', message));
-};
+import { WebCryptoAdapter } from './web-crypto-adapter.js';
+import { RpcBatcher } from './rpc-batcher.js';
 /**
- * Helper: Convert Uint8Array to base64 string
- */
-function bytesToBase64(bytes) {
-    const binString = Array.from(bytes, byte => String.fromCodePoint(byte)).join('');
-    return btoa(binString);
-}
-/**
- * Helper: Convert base64 string to Uint8Array
- */
-function base64ToBytes(base64) {
-    const binString = atob(base64);
-    return Uint8Array.from(binString, char => char.codePointAt(0));
-}
-/**
- * RondevuAPI - Complete API client for Rondevu signaling server
+ * RondevuAPI - RPC-based API client for Rondevu signaling server
  */
 export class RondevuAPI {
-    constructor(baseUrl, credentials) {
+    constructor(baseUrl, username, keypair, cryptoAdapter, batcherOptions) {
         this.baseUrl = baseUrl;
-        this.credentials = credentials;
-    }
-    /**
-     * Set credentials for authentication
-     */
-    setCredentials(credentials) {
-        this.credentials = credentials;
-    }
-    /**
-     * Authentication header
-     */
-    getAuthHeader() {
-        if (!this.credentials) {
-            return {};
+        this.username = username;
+        this.keypair = keypair;
+        this.batcher = null;
+        // Use WebCryptoAdapter by default (browser environment)
+        this.crypto = cryptoAdapter || new WebCryptoAdapter();
+        // Create batcher if not explicitly disabled
+        if (batcherOptions !== false) {
+            this.batcher = new RpcBatcher((requests) => this.rpcBatchDirect(requests), batcherOptions);
         }
-        return {
-            Authorization: `Bearer ${this.credentials.peerId}:${this.credentials.secret}`,
-        };
-    }
-    // ============================================
-    // Ed25519 Cryptography Helpers
-    // ============================================
-    /**
-     * Generate an Ed25519 keypair for username claiming and service publishing
-     */
-    static async generateKeypair() {
-        const privateKey = ed25519.utils.randomSecretKey();
-        const publicKey = await ed25519.getPublicKeyAsync(privateKey);
-        return {
-            publicKey: bytesToBase64(publicKey),
-            privateKey: bytesToBase64(privateKey),
-        };
     }
     /**
-     * Sign a message with an Ed25519 private key
+     * Generate authentication parameters for RPC calls
      */
-    static async signMessage(message, privateKeyBase64) {
-        const privateKey = base64ToBytes(privateKeyBase64);
-        const encoder = new TextEncoder();
-        const messageBytes = encoder.encode(message);
-        const signature = await ed25519.signAsync(messageBytes, privateKey);
-        return bytesToBase64(signature);
+    async generateAuth(method, params = '') {
+        const timestamp = Date.now();
+        const message = params
+            ? `${method}:${this.username}:${params}:${timestamp}`
+            : `${method}:${this.username}:${timestamp}`;
+        const signature = await this.crypto.signMessage(message, this.keypair.privateKey);
+        return { message, signature };
     }
     /**
-     * Verify a signature
+     * Execute RPC call with optional batching
      */
-    static async verifySignature(message, signatureBase64, publicKeyBase64) {
-        const publicKey = base64ToBytes(publicKeyBase64);
-        const signature = base64ToBytes(signatureBase64);
-        const encoder = new TextEncoder();
-        const messageBytes = encoder.encode(message);
-        return await ed25519.verifyAsync(signature, messageBytes, publicKey);
+    async rpc(request) {
+        // Use batcher if enabled
+        if (this.batcher) {
+            return await this.batcher.add(request);
+        }
+        // Direct call without batching
+        return await this.rpcDirect(request);
     }
-    // ============================================
-    // Authentication
-    // ============================================
     /**
-     * Register a new peer and get credentials
+     * Execute single RPC call directly (bypasses batcher)
      */
-    async register() {
-        const response = await fetch(`${this.baseUrl}/register`, {
+    async rpcDirect(request) {
+        const response = await fetch(`${this.baseUrl}/rpc`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(request),
         });
         if (!response.ok) {
-            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-            throw new Error(`Registration failed: ${error.error || response.statusText}`);
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        const result = await response.json();
+        if (!result.success) {
+            throw new Error(result.error || 'RPC call failed');
         }
-        return await response.json();
+        return result.result;
     }
-    // ============================================
-    // Offers
-    // ============================================
     /**
-     * Create one or more offers
+     * Execute batch RPC calls directly (bypasses batcher)
      */
-    async createOffers(offers) {
-        const response = await fetch(`${this.baseUrl}/offers`, {
+    async rpcBatchDirect(requests) {
+        const response = await fetch(`${this.baseUrl}/rpc`, {
             method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                ...this.getAuthHeader(),
-            },
-            body: JSON.stringify({ offers }),
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(requests),
         });
         if (!response.ok) {
-            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-            throw new Error(`Failed to create offers: ${error.error || response.statusText}`);
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
         }
-        return await response.json();
-    }
-    /**
-     * Get offer by ID
-     */
-    async getOffer(offerId) {
-        const response = await fetch(`${this.baseUrl}/offers/${offerId}`, {
-            headers: this.getAuthHeader(),
-        });
-        if (!response.ok) {
-            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-            throw new Error(`Failed to get offer: ${error.error || response.statusText}`);
+        const results = await response.json();
+        // Validate response is an array
+        if (!Array.isArray(results)) {
+            console.error('Invalid RPC batch response:', results);
+            throw new Error('Server returned invalid batch response (not an array)');
         }
-        return await response.json();
+        // Check response length matches request length
+        if (results.length !== requests.length) {
+            console.error(`Response length mismatch: expected ${requests.length}, got ${results.length}`);
+        }
+        return results.map((result, i) => {
+            if (!result || typeof result !== 'object') {
+                throw new Error(`Invalid response at index ${i}`);
+            }
+            if (!result.success) {
+                throw new Error(result.error || `RPC call ${i} failed`);
+            }
+            return result.result;
+        });
     }
+    // ============================================
+    // Ed25519 Cryptography Helpers
+    // ============================================
     /**
-     * Answer a specific offer from a service
+     * Generate an Ed25519 keypair for username claiming and service publishing
+     * @param cryptoAdapter - Optional crypto adapter (defaults to WebCryptoAdapter)
      */
-    async postOfferAnswer(serviceFqn, offerId, sdp) {
-        const response = await fetch(`${this.baseUrl}/services/${encodeURIComponent(serviceFqn)}/offers/${offerId}/answer`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                ...this.getAuthHeader(),
-            },
-            body: JSON.stringify({ sdp }),
-        });
-        if (!response.ok) {
-            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-            throw new Error(`Failed to answer offer: ${error.error || response.statusText}`);
-        }
-        return await response.json();
+    static async generateKeypair(cryptoAdapter) {
+        const adapter = cryptoAdapter || new WebCryptoAdapter();
+        return await adapter.generateKeypair();
     }
     /**
-     * Get answer for a specific offer (offerer polls this)
+     * Sign a message with an Ed25519 private key
+     * @param cryptoAdapter - Optional crypto adapter (defaults to WebCryptoAdapter)
      */
-    async getOfferAnswer(serviceFqn, offerId) {
-        const response = await fetch(`${this.baseUrl}/services/${encodeURIComponent(serviceFqn)}/offers/${offerId}/answer`, {
-            headers: this.getAuthHeader(),
-        });
-        if (!response.ok) {
-            // 404 means not yet answered
-            if (response.status === 404) {
-                return null;
-            }
-            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-            throw new Error(`Failed to get answer: ${error.error || response.statusText}`);
-        }
-        return await response.json();
+    static async signMessage(message, privateKeyBase64, cryptoAdapter) {
+        const adapter = cryptoAdapter || new WebCryptoAdapter();
+        return await adapter.signMessage(message, privateKeyBase64);
     }
     /**
-     * Search offers by topic
+     * Verify an Ed25519 signature
+     * @param cryptoAdapter - Optional crypto adapter (defaults to WebCryptoAdapter)
      */
-    async searchOffers(topic) {
-        const response = await fetch(`${this.baseUrl}/offers?topic=${encodeURIComponent(topic)}`, {
-            headers: this.getAuthHeader(),
-        });
-        if (!response.ok) {
-            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-            throw new Error(`Failed to search offers: ${error.error || response.statusText}`);
-        }
-        return await response.json();
+    static async verifySignature(message, signatureBase64, publicKeyBase64, cryptoAdapter) {
+        const adapter = cryptoAdapter || new WebCryptoAdapter();
+        return await adapter.verifySignature(message, signatureBase64, publicKeyBase64);
     }
     // ============================================
-    // ICE Candidates
+    // Username Management
     // ============================================
     /**
-     * Add ICE candidates to a specific offer
+     * Check if a username is available
      */
-    async addOfferIceCandidates(serviceFqn, offerId, candidates) {
-        const response = await fetch(`${this.baseUrl}/services/${encodeURIComponent(serviceFqn)}/offers/${offerId}/ice-candidates`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                ...this.getAuthHeader(),
-            },
-            body: JSON.stringify({ candidates }),
+    async isUsernameAvailable(username) {
+        const auth = await this.generateAuth('getUser', username);
+        const result = await this.rpc({
+            method: 'getUser',
+            message: auth.message,
+            signature: auth.signature,
+            params: { username },
         });
-        if (!response.ok) {
-            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-            throw new Error(`Failed to add ICE candidates: ${error.error || response.statusText}`);
-        }
-        return await response.json();
+        return result.available;
     }
     /**
-     * Get ICE candidates for a specific offer (with polling support)
+     * Check if current username is claimed
      */
-    async getOfferIceCandidates(serviceFqn, offerId, since = 0) {
-        const url = new URL(`${this.baseUrl}/services/${encodeURIComponent(serviceFqn)}/offers/${offerId}/ice-candidates`);
-        url.searchParams.set('since', since.toString());
-        const response = await fetch(url.toString(), { headers: this.getAuthHeader() });
-        if (!response.ok) {
-            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-            throw new Error(`Failed to get ICE candidates: ${error.error || response.statusText}`);
-        }
-        const data = await response.json();
-        return {
-            candidates: data.candidates || [],
-            offerId: data.offerId
-        };
+    async isUsernameClaimed() {
+        const auth = await this.generateAuth('getUser', this.username);
+        const result = await this.rpc({
+            method: 'getUser',
+            message: auth.message,
+            signature: auth.signature,
+            params: { username: this.username },
+        });
+        return !result.available;
     }
     // ============================================
-    // Services
+    // Service Management
     // ============================================
     /**
      * Publish a service
-     * Service FQN must include username: service:version@username
      */
     async publishService(service) {
-        const response = await fetch(`${this.baseUrl}/services`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                ...this.getAuthHeader(),
+        const auth = await this.generateAuth('publishService', service.serviceFqn);
+        return await this.rpc({
+            method: 'publishService',
+            message: auth.message,
+            signature: auth.signature,
+            publicKey: this.keypair.publicKey,
+            params: {
+                serviceFqn: service.serviceFqn,
+                offers: service.offers,
+                ttl: service.ttl,
             },
-            body: JSON.stringify(service),
         });
-        if (!response.ok) {
-            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-            throw new Error(`Failed to publish service: ${error.error || response.statusText}`);
-        }
-        return await response.json();
     }
     /**
-     * Get service by FQN (with username) - Direct lookup
-     * Example: chat:1.0.0@alice
+     * Get service by FQN (direct lookup, random, or paginated)
      */
-    async getService(serviceFqn) {
-        const response = await fetch(`${this.baseUrl}/services/${encodeURIComponent(serviceFqn)}`, {
-            headers: this.getAuthHeader(),
+    async getService(serviceFqn, options) {
+        const auth = await this.generateAuth('getService', serviceFqn);
+        return await this.rpc({
+            method: 'getService',
+            message: auth.message,
+            signature: auth.signature,
+            publicKey: this.keypair.publicKey,
+            params: {
+                serviceFqn,
+                ...options,
+            },
         });
-        if (!response.ok) {
-            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-            throw new Error(`Failed to get service: ${error.error || response.statusText}`);
-        }
-        return await response.json();
     }
     /**
-     * Discover a random available service without knowing the username
-     * Example: chat:1.0.0 (without @username)
+     * Delete a service
      */
-    async discoverService(serviceVersion) {
-        const response = await fetch(`${this.baseUrl}/services/${encodeURIComponent(serviceVersion)}`, {
-            headers: this.getAuthHeader(),
+    async deleteService(serviceFqn) {
+        const auth = await this.generateAuth('deleteService', serviceFqn);
+        await this.rpc({
+            method: 'deleteService',
+            message: auth.message,
+            signature: auth.signature,
+            publicKey: this.keypair.publicKey,
+            params: { serviceFqn },
         });
-        if (!response.ok) {
-            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-            throw new Error(`Failed to discover service: ${error.error || response.statusText}`);
-        }
-        return await response.json();
     }
+    // ============================================
+    // WebRTC Signaling
+    // ============================================
     /**
-     * Discover multiple available services with pagination
-     * Example: chat:1.0.0 (without @username)
+     * Answer an offer
      */
-    async discoverServices(serviceVersion, limit = 10, offset = 0) {
-        const url = new URL(`${this.baseUrl}/services/${encodeURIComponent(serviceVersion)}`);
-        url.searchParams.set('limit', limit.toString());
-        url.searchParams.set('offset', offset.toString());
-        const response = await fetch(url.toString(), {
-            headers: this.getAuthHeader(),
+    async answerOffer(serviceFqn, offerId, sdp) {
+        const auth = await this.generateAuth('answerOffer', offerId);
+        await this.rpc({
+            method: 'answerOffer',
+            message: auth.message,
+            signature: auth.signature,
+            publicKey: this.keypair.publicKey,
+            params: { serviceFqn, offerId, sdp },
         });
-        if (!response.ok) {
-            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-            throw new Error(`Failed to discover services: ${error.error || response.statusText}`);
-        }
-        return await response.json();
     }
-    // ============================================
-    // Usernames
-    // ============================================
     /**
-     * Check if username is available
+     * Get answer for a specific offer (offerer polls this)
      */
-    async checkUsername(username) {
-        const response = await fetch(`${this.baseUrl}/users/${encodeURIComponent(username)}`);
-        if (!response.ok) {
-            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-            throw new Error(`Failed to check username: ${error.error || response.statusText}`);
+    async getOfferAnswer(serviceFqn, offerId) {
+        try {
+            const auth = await this.generateAuth('getOfferAnswer', offerId);
+            return await this.rpc({
+                method: 'getOfferAnswer',
+                message: auth.message,
+                signature: auth.signature,
+                publicKey: this.keypair.publicKey,
+                params: { serviceFqn, offerId },
+            });
+        }
+        catch (err) {
+            if (err.message.includes('not yet answered')) {
+                return null;
+            }
+            throw err;
         }
-        return await response.json();
     }
     /**
-     * Claim a username (requires Ed25519 signature)
+     * Combined polling for answers and ICE candidates
      */
-    async claimUsername(username, publicKey, signature, message) {
-        const response = await fetch(`${this.baseUrl}/users/${encodeURIComponent(username)}`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                ...this.getAuthHeader(),
-            },
-            body: JSON.stringify({
-                publicKey,
-                signature,
-                message,
-            }),
+    async poll(since) {
+        const auth = await this.generateAuth('poll');
+        return await this.rpc({
+            method: 'poll',
+            message: auth.message,
+            signature: auth.signature,
+            publicKey: this.keypair.publicKey,
+            params: { since },
         });
-        if (!response.ok) {
-            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-            throw new Error(`Failed to claim username: ${error.error || response.statusText}`);
-        }
-        return await response.json();
+    }
+    /**
+     * Add ICE candidates to a specific offer
+     */
+    async addOfferIceCandidates(serviceFqn, offerId, candidates) {
+        const auth = await this.generateAuth('addIceCandidates', offerId);
+        return await this.rpc({
+            method: 'addIceCandidates',
+            message: auth.message,
+            signature: auth.signature,
+            publicKey: this.keypair.publicKey,
+            params: { serviceFqn, offerId, candidates },
+        });
+    }
+    /**
+     * Get ICE candidates for a specific offer
+     */
+    async getOfferIceCandidates(serviceFqn, offerId, since = 0) {
+        const auth = await this.generateAuth('getIceCandidates', `${offerId}:${since}`);
+        const result = await this.rpc({
+            method: 'getIceCandidates',
+            message: auth.message,
+            signature: auth.signature,
+            publicKey: this.keypair.publicKey,
+            params: { serviceFqn, offerId, since },
+        });
+        return {
+            candidates: result.candidates || [],
+            offerId: result.offerId,
+        };
     }
 }

package/dist/crypto-adapter.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Crypto adapter interface for platform-independent cryptographic operations
+ */
+export interface Keypair {
+    publicKey: string;
+    privateKey: string;
+}
+/**
+ * Platform-independent crypto adapter interface
+ * Implementations provide platform-specific crypto operations
+ */
+export interface CryptoAdapter {
+    /**
+     * Generate an Ed25519 keypair
+     */
+    generateKeypair(): Promise<Keypair>;
+    /**
+     * Sign a message with an Ed25519 private key
+     */
+    signMessage(message: string, privateKeyBase64: string): Promise<string>;
+    /**
+     * Verify an Ed25519 signature
+     */
+    verifySignature(message: string, signatureBase64: string, publicKeyBase64: string): Promise<boolean>;
+    /**
+     * Convert Uint8Array to base64 string
+     */
+    bytesToBase64(bytes: Uint8Array): string;
+    /**
+     * Convert base64 string to Uint8Array
+     */
+    base64ToBytes(base64: string): Uint8Array;
+    /**
+     * Generate random bytes
+     */
+    randomBytes(length: number): Uint8Array;
+}

package/dist/crypto-adapter.js

@@ -0,0 +1,4 @@
+/**
+ * Crypto adapter interface for platform-independent cryptographic operations
+ */
+export {};

package/dist/index.d.ts

@@ -4,8 +4,10 @@
  */
 export { Rondevu } from './rondevu.js';
 export { RondevuAPI } from './api.js';
-export { RondevuSignaler } from './rondevu-signaler.js';
+export { RpcBatcher } from './rpc-batcher.js';
+export { WebCryptoAdapter } from './web-crypto-adapter.js';
+export { NodeCryptoAdapter } from './node-crypto-adapter.js';
 export type { Signaler, Binnable, } from './types.js';
-export type { Credentials, Keypair, OfferRequest, Offer, ServiceRequest, Service, IceCandidate, } from './api.js';
-export type { RondevuOptions, PublishServiceOptions } from './rondevu.js';
-export type { PollingConfig } from './rondevu-signaler.js';
+export type { Keypair, OfferRequest, ServiceRequest, Service, ServiceOffer, IceCandidate, } from './api.js';
+export type { RondevuOptions, PublishServiceOptions, ConnectToServiceOptions, ConnectionContext, OfferContext, OfferFactory } from './rondevu.js';
+export type { CryptoAdapter } from './crypto-adapter.js';

package/dist/index.js

@@ -4,4 +4,7 @@
  */
 export { Rondevu } from './rondevu.js';
 export { RondevuAPI } from './api.js';
-export { RondevuSignaler } from './rondevu-signaler.js';
+export { RpcBatcher } from './rpc-batcher.js';
+// Export crypto adapters
+export { WebCryptoAdapter } from './web-crypto-adapter.js';
+export { NodeCryptoAdapter } from './node-crypto-adapter.js';

package/dist/node-crypto-adapter.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Node.js Crypto adapter for Node.js environments
+ * Requires Node.js 19+ or Node.js 18 with --experimental-global-webcrypto flag
+ */
+import { CryptoAdapter, Keypair } from './crypto-adapter.js';
+/**
+ * Node.js Crypto implementation using Node.js built-in APIs
+ * Uses Buffer for base64 encoding and crypto.randomBytes for random generation
+ *
+ * Requirements:
+ * - Node.js 19+ (crypto.subtle available globally)
+ * - OR Node.js 18 with --experimental-global-webcrypto flag
+ *
+ * @example
+ * ```typescript
+ * import { RondevuAPI } from '@xtr-dev/rondevu-client'
+ * import { NodeCryptoAdapter } from '@xtr-dev/rondevu-client/node'
+ *
+ * const api = new RondevuAPI(
+ *   'https://signal.example.com',
+ *   'alice',
+ *   keypair,
+ *   new NodeCryptoAdapter()
+ * )
+ * ```
+ */
+export declare class NodeCryptoAdapter implements CryptoAdapter {
+    constructor();
+    generateKeypair(): Promise<Keypair>;
+    signMessage(message: string, privateKeyBase64: string): Promise<string>;
+    verifySignature(message: string, signatureBase64: string, publicKeyBase64: string): Promise<boolean>;
+    bytesToBase64(bytes: Uint8Array): string;
+    base64ToBytes(base64: string): Uint8Array;
+    randomBytes(length: number): Uint8Array;
+}