@xtr-dev/rondevu-client 0.12.4 → 0.17.0

package/dist/api.d.ts

@@ -1,40 +1,17 @@
 /**
- * Rondevu API Client - Single class for all API endpoints
+ * Rondevu API Client - RPC interface
  */
-export interface Credentials {
-    peerId: string;
-    secret: string;
-}
-export interface Keypair {
-    publicKey: string;
-    privateKey: string;
-}
-export interface OfferRequest {
-    sdp: string;
-    topics?: string[];
-    ttl?: number;
-    secret?: string;
-}
-export interface Offer {
-    id: string;
-    peerId: string;
-    sdp: string;
-    topics: string[];
-    ttl: number;
-    createdAt: number;
-    expiresAt: number;
-    answererPeerId?: string;
-}
+import { CryptoAdapter, Keypair } from './crypto-adapter.js';
+import { BatcherOptions } from './rpc-batcher.js';
+export type { Keypair } from './crypto-adapter.js';
+export type { BatcherOptions } from './rpc-batcher.js';
 export interface OfferRequest {
     sdp: string;
 }
 export interface ServiceRequest {
-    username: string;
     serviceFqn: string;
     offers: OfferRequest[];
     ttl?: number;
-    isPublic?: boolean;
-    metadata?: Record<string, any>;
     signature: string;
     message: string;
 }
@@ -46,121 +23,123 @@ export interface ServiceOffer {
 }
 export interface Service {
     serviceId: string;
-    uuid: string;
     offers: ServiceOffer[];
     username: string;
     serviceFqn: string;
-    isPublic: boolean;
-    metadata?: Record<string, any>;
     createdAt: number;
     expiresAt: number;
 }
 export interface IceCandidate {
-    candidate: RTCIceCandidateInit;
+    candidate: RTCIceCandidateInit | null;
     createdAt: number;
 }
 /**
- * RondevuAPI - Complete API client for Rondevu signaling server
+ * RondevuAPI - RPC-based API client for Rondevu signaling server
  */
 export declare class RondevuAPI {
     private baseUrl;
-    private credentials?;
-    constructor(baseUrl: string, credentials?: Credentials | undefined);
+    private username;
+    private keypair;
+    private crypto;
+    private batcher;
+    constructor(baseUrl: string, username: string, keypair: Keypair, cryptoAdapter?: CryptoAdapter, batcherOptions?: BatcherOptions | false);
     /**
-     * Set credentials for authentication
+     * Generate authentication parameters for RPC calls
      */
-    setCredentials(credentials: Credentials): void;
+    private generateAuth;
     /**
-     * Authentication header
+     * Execute RPC call with optional batching
      */
-    private getAuthHeader;
+    private rpc;
     /**
-     * Generate an Ed25519 keypair for username claiming and service publishing
+     * Execute single RPC call directly (bypasses batcher)
      */
-    static generateKeypair(): Promise<Keypair>;
+    private rpcDirect;
     /**
-     * Sign a message with an Ed25519 private key
+     * Execute batch RPC calls directly (bypasses batcher)
      */
-    static signMessage(message: string, privateKeyBase64: string): Promise<string>;
+    private rpcBatchDirect;
     /**
-     * Verify a signature
-     */
-    static verifySignature(message: string, signatureBase64: string, publicKeyBase64: string): Promise<boolean>;
-    /**
-     * Register a new peer and get credentials
+     * Generate an Ed25519 keypair for username claiming and service publishing
+     * @param cryptoAdapter - Optional crypto adapter (defaults to WebCryptoAdapter)
      */
-    register(): Promise<Credentials>;
+    static generateKeypair(cryptoAdapter?: CryptoAdapter): Promise<Keypair>;
     /**
-     * Create one or more offers
+     * Sign a message with an Ed25519 private key
+     * @param cryptoAdapter - Optional crypto adapter (defaults to WebCryptoAdapter)
      */
-    createOffers(offers: OfferRequest[]): Promise<Offer[]>;
+    static signMessage(message: string, privateKeyBase64: string, cryptoAdapter?: CryptoAdapter): Promise<string>;
     /**
-     * Get offer by ID
+     * Verify an Ed25519 signature
+     * @param cryptoAdapter - Optional crypto adapter (defaults to WebCryptoAdapter)
      */
-    getOffer(offerId: string): Promise<Offer>;
+    static verifySignature(message: string, signatureBase64: string, publicKeyBase64: string, cryptoAdapter?: CryptoAdapter): Promise<boolean>;
     /**
-     * Answer a service
+     * Check if a username is available
      */
-    answerService(serviceUuid: string, sdp: string): Promise<{
-        offerId: string;
-    }>;
+    isUsernameAvailable(username: string): Promise<boolean>;
     /**
-     * Get answer for a service (offerer polls this)
+     * Check if current username is claimed
      */
-    getServiceAnswer(serviceUuid: string): Promise<{
-        sdp: string;
-        offerId: string;
-    } | null>;
+    isUsernameClaimed(): Promise<boolean>;
     /**
-     * Search offers by topic
+     * Publish a service
      */
-    searchOffers(topic: string): Promise<Offer[]>;
+    publishService(service: ServiceRequest): Promise<Service>;
     /**
-     * Add ICE candidates to a service
+     * Get service by FQN (direct lookup, random, or paginated)
      */
-    addServiceIceCandidates(serviceUuid: string, candidates: RTCIceCandidateInit[], offerId?: string): Promise<{
-        offerId: string;
-    }>;
+    getService(serviceFqn: string, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<any>;
     /**
-     * Get ICE candidates for a service (with polling support)
+     * Delete a service
      */
-    getServiceIceCandidates(serviceUuid: string, since?: number, offerId?: string): Promise<{
-        candidates: IceCandidate[];
-        offerId: string;
-    }>;
+    deleteService(serviceFqn: string): Promise<void>;
     /**
-     * Publish a service
+     * Answer an offer
      */
-    publishService(service: ServiceRequest): Promise<Service>;
+    answerOffer(serviceFqn: string, offerId: string, sdp: string): Promise<void>;
     /**
-     * Get service by UUID
+     * Get answer for a specific offer (offerer polls this)
      */
-    getService(uuid: string): Promise<Service & {
-        offerId: string;
+    getOfferAnswer(serviceFqn: string, offerId: string): Promise<{
         sdp: string;
-    }>;
-    /**
-     * Search services by username - lists all services for a username
-     */
-    searchServicesByUsername(username: string): Promise<Service[]>;
+        offerId: string;
+        answererId: string;
+        answeredAt: number;
+    } | null>;
     /**
-     * Search services by username AND FQN - returns full service details
-     */
-    searchServices(username: string, serviceFqn: string): Promise<Service[]>;
+     * Combined polling for answers and ICE candidates
+     */
+    poll(since?: number): Promise<{
+        answers: Array<{
+            offerId: string;
+            serviceId?: string;
+            answererId: string;
+            sdp: string;
+            answeredAt: number;
+        }>;
+        iceCandidates: Record<string, Array<{
+            candidate: RTCIceCandidateInit | null;
+            role: 'offerer' | 'answerer';
+            peerId: string;
+            createdAt: number;
+        }>>;
+    }>;
     /**
-     * Check if username is available
+     * Add ICE candidates to a specific offer
      */
-    checkUsername(username: string): Promise<{
-        available: boolean;
-        publicKey?: string;
-        claimedAt?: number;
-        expiresAt?: number;
+    addOfferIceCandidates(serviceFqn: string, offerId: string, candidates: RTCIceCandidateInit[]): Promise<{
+        count: number;
+        offerId: string;
     }>;
     /**
-     * Claim a username (requires Ed25519 signature)
+     * Get ICE candidates for a specific offer
      */
-    claimUsername(username: string, publicKey: string, signature: string, message: string): Promise<{
-        success: boolean;
-        username: string;
+    getOfferIceCandidates(serviceFqn: string, offerId: string, since?: number): Promise<{
+        candidates: IceCandidate[];
+        offerId: string;
     }>;
 }