@xtr-dev/rondevu-client 0.18.10 → 0.21.1

package/dist/rpc-batcher.d.ts

@@ -1,61 +0,0 @@
-/**
- * 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

@@ -1,111 +0,0 @@
-/**
- * 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

@@ -1,16 +0,0 @@
-/**
- * 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

@@ -1,52 +0,0 @@
-/**
- * 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));
-    }
-}