@xtr-dev/rondevu-client 0.13.0 → 0.17.0

package/dist/rpc-batcher.d.ts

@@ -0,0 +1,61 @@
+/**
+ * RPC Batcher - Throttles and batches RPC requests to reduce HTTP overhead
+ */
+export interface BatcherOptions {
+    /**
+     * Maximum number of requests to batch together
+     * Default: 10
+     */
+    maxBatchSize?: number;
+    /**
+     * Maximum time to wait before sending a batch (ms)
+     * Default: 50ms
+     */
+    maxWaitTime?: number;
+    /**
+     * Minimum time between batches (ms)
+     * Default: 10ms
+     */
+    throttleInterval?: number;
+}
+/**
+ * Batches and throttles RPC requests to optimize network usage
+ *
+ * @example
+ * ```typescript
+ * const batcher = new RpcBatcher(
+ *   (requests) => api.rpcBatch(requests),
+ *   { maxBatchSize: 10, maxWaitTime: 50 }
+ * )
+ *
+ * // These will be batched together if called within maxWaitTime
+ * const result1 = await batcher.add(request1)
+ * const result2 = await batcher.add(request2)
+ * const result3 = await batcher.add(request3)
+ * ```
+ */
+export declare class RpcBatcher {
+    private queue;
+    private batchTimeout;
+    private lastBatchTime;
+    private options;
+    private sendBatch;
+    constructor(sendBatch: (requests: any[]) => Promise<any[]>, options?: BatcherOptions);
+    /**
+     * Add an RPC request to the batch queue
+     * Returns a promise that resolves when the request completes
+     */
+    add(request: any): Promise<any>;
+    /**
+     * Flush the queue immediately
+     */
+    flush(): Promise<void>;
+    /**
+     * Get current queue size
+     */
+    getQueueSize(): number;
+    /**
+     * Clear the queue without sending
+     */
+    clear(): void;
+}

package/dist/rpc-batcher.js

@@ -0,0 +1,111 @@
+/**
+ * RPC Batcher - Throttles and batches RPC requests to reduce HTTP overhead
+ */
+/**
+ * Batches and throttles RPC requests to optimize network usage
+ *
+ * @example
+ * ```typescript
+ * const batcher = new RpcBatcher(
+ *   (requests) => api.rpcBatch(requests),
+ *   { maxBatchSize: 10, maxWaitTime: 50 }
+ * )
+ *
+ * // These will be batched together if called within maxWaitTime
+ * const result1 = await batcher.add(request1)
+ * const result2 = await batcher.add(request2)
+ * const result3 = await batcher.add(request3)
+ * ```
+ */
+export class RpcBatcher {
+    constructor(sendBatch, options) {
+        this.queue = [];
+        this.batchTimeout = null;
+        this.lastBatchTime = 0;
+        this.sendBatch = sendBatch;
+        this.options = {
+            maxBatchSize: options?.maxBatchSize ?? 10,
+            maxWaitTime: options?.maxWaitTime ?? 50,
+            throttleInterval: options?.throttleInterval ?? 10,
+        };
+    }
+    /**
+     * Add an RPC request to the batch queue
+     * Returns a promise that resolves when the request completes
+     */
+    async add(request) {
+        return new Promise((resolve, reject) => {
+            this.queue.push({ request, resolve, reject });
+            // Send immediately if batch is full
+            if (this.queue.length >= this.options.maxBatchSize) {
+                this.flush();
+                return;
+            }
+            // Schedule batch if not already scheduled
+            if (!this.batchTimeout) {
+                this.batchTimeout = setTimeout(() => {
+                    this.flush();
+                }, this.options.maxWaitTime);
+            }
+        });
+    }
+    /**
+     * Flush the queue immediately
+     */
+    async flush() {
+        // Clear timeout if set
+        if (this.batchTimeout) {
+            clearTimeout(this.batchTimeout);
+            this.batchTimeout = null;
+        }
+        // Nothing to flush
+        if (this.queue.length === 0) {
+            return;
+        }
+        // Throttle: wait if we sent a batch too recently
+        const now = Date.now();
+        const timeSinceLastBatch = now - this.lastBatchTime;
+        if (timeSinceLastBatch < this.options.throttleInterval) {
+            const waitTime = this.options.throttleInterval - timeSinceLastBatch;
+            await new Promise(resolve => setTimeout(resolve, waitTime));
+        }
+        // Extract requests from queue
+        const batch = this.queue.splice(0, this.options.maxBatchSize);
+        const requests = batch.map(item => item.request);
+        this.lastBatchTime = Date.now();
+        try {
+            // Send batch request
+            const results = await this.sendBatch(requests);
+            // Resolve individual promises
+            for (let i = 0; i < batch.length; i++) {
+                batch[i].resolve(results[i]);
+            }
+        }
+        catch (error) {
+            // Reject all promises in batch
+            for (const item of batch) {
+                item.reject(error);
+            }
+        }
+    }
+    /**
+     * Get current queue size
+     */
+    getQueueSize() {
+        return this.queue.length;
+    }
+    /**
+     * Clear the queue without sending
+     */
+    clear() {
+        if (this.batchTimeout) {
+            clearTimeout(this.batchTimeout);
+            this.batchTimeout = null;
+        }
+        // Reject all pending requests
+        for (const item of this.queue) {
+            item.reject(new Error('Batch queue cleared'));
+        }
+        this.queue = [];
+    }
+}

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

@@ -0,0 +1,16 @@
+/**
+ * Web Crypto adapter for browser environments
+ */
+import { CryptoAdapter, Keypair } from './crypto-adapter.js';
+/**
+ * Web Crypto implementation using browser APIs
+ * Uses btoa/atob for base64 encoding and crypto.getRandomValues for random bytes
+ */
+export declare class WebCryptoAdapter implements CryptoAdapter {
+    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;
+}

package/dist/web-crypto-adapter.js

@@ -0,0 +1,52 @@
+/**
+ * Web Crypto adapter for browser environments
+ */
+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));
+};
+/**
+ * Web Crypto implementation using browser APIs
+ * Uses btoa/atob for base64 encoding and crypto.getRandomValues for random bytes
+ */
+export class WebCryptoAdapter {
+    async generateKeypair() {
+        const privateKey = ed25519.utils.randomSecretKey();
+        const publicKey = await ed25519.getPublicKeyAsync(privateKey);
+        return {
+            publicKey: this.bytesToBase64(publicKey),
+            privateKey: this.bytesToBase64(privateKey),
+        };
+    }
+    async signMessage(message, privateKeyBase64) {
+        const privateKey = this.base64ToBytes(privateKeyBase64);
+        const encoder = new TextEncoder();
+        const messageBytes = encoder.encode(message);
+        const signature = await ed25519.signAsync(messageBytes, privateKey);
+        return this.bytesToBase64(signature);
+    }
+    async verifySignature(message, signatureBase64, publicKeyBase64) {
+        try {
+            const signature = this.base64ToBytes(signatureBase64);
+            const publicKey = this.base64ToBytes(publicKeyBase64);
+            const encoder = new TextEncoder();
+            const messageBytes = encoder.encode(message);
+            return await ed25519.verifyAsync(signature, messageBytes, publicKey);
+        }
+        catch {
+            return false;
+        }
+    }
+    bytesToBase64(bytes) {
+        const binString = Array.from(bytes, byte => String.fromCodePoint(byte)).join('');
+        return btoa(binString);
+    }
+    base64ToBytes(base64) {
+        const binString = atob(base64);
+        return Uint8Array.from(binString, char => char.codePointAt(0));
+    }
+    randomBytes(length) {
+        return crypto.getRandomValues(new Uint8Array(length));
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xtr-dev/rondevu-client",
-  "version": "0.13.0",
+  "version": "0.17.0",
   "description": "TypeScript client for Rondevu with durable WebRTC connections, automatic reconnection, and message queuing",
   "type": "module",
   "main": "dist/index.js",