@leofcoin/endpoint-clients 0.3.17 → 0.4.0

package/exports/http.js

@@ -1,3 +1,6 @@
+import { readBinaryResponse } from './transport.js';
+import { BINARY_CONTENT_TYPE, encodeWire } from '@leofcoin/binary';
+
 class Client {
     url;
     networkVersion;
@@ -9,9 +12,15 @@ class Client {
         this.networkVersion = networkVersion;
     }
     async _fetch(method, params, type = 'json') {
-        params = new URLSearchParams(params).toString();
-        const response = await fetch(`${this.url}/${method}?${params}`);
-        return response[type]();
+        const response = await fetch(`${this.url}/${method}`, {
+            method: 'POST', headers: { 'Content-Type': BINARY_CONTENT_TYPE },
+            body: encodeWire('rpc', params ?? {}, { maxBytes: 1048576 }),
+            signal: AbortSignal.timeout(10000)
+        });
+        const value = await readBinaryResponse(response);
+        if (!response.ok)
+            throw new Error(value?.error || `${method} failed with HTTP ${response.status}`);
+        return value;
     }
     async _fetchString(method, params) {
         return String(await this._fetch(method, params, 'text'));
@@ -61,7 +70,9 @@ class Client {
     lookup(name) {
         return this._fetch('lookup', { name });
     }
-    staticCall(contract, method, params) {
+    async staticCall(contract, method, params = []) {
+        if (!Array.isArray(params))
+            throw new Error('staticCall params must be an array');
         return this._fetch('staticCall', { contract, method, params });
     }
     contracts() {
@@ -143,7 +154,7 @@ class Client {
         return this._fetch('blockHashMap');
     }
     bootstrap() {
-        return this._fetch('blockHashMap');
+        return this._fetch('bootstrap');
     }
 }
 

package/exports/index.js

@@ -2,5 +2,6 @@ export { default as ws } from './ws.js';
 export { default as http } from './http.js';
 export { default as direct } from './direct.js';
 export { default as DexClient } from './dex.js';
-import 'socket-request-client';
+import '@leofcoin/binary';
+import './transport.js';
 import '@leofcoin/utils';

package/exports/transport.js

@@ -0,0 +1,37 @@
+import { BINARY_CONTENT_TYPE, decodeWire } from '@leofcoin/binary';
+
+/** Bound allocation while receiving, not only after arrayBuffer() has buffered an untrusted body. */
+async function readBinaryResponse(response, maxBytes = 4 * 1024 * 1024) {
+    if (response.headers.get('content-type')?.split(';')[0] !== BINARY_CONTENT_TYPE)
+        throw new Error('Node does not support binary RPC');
+    const reader = response.body?.getReader();
+    if (!reader)
+        throw new Error('Binary response has no body');
+    const chunks = [];
+    let size = 0;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            size += value.byteLength;
+            if (size > maxBytes) {
+                await reader.cancel();
+                throw new RangeError('Binary response exceeds byte limit');
+            }
+            chunks.push(value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    const bytes = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return decodeWire('rpc', bytes, { maxBytes });
+}
+
+export { readBinaryResponse };

package/exports/types/binary-socket.d.ts

@@ -0,0 +1,21 @@
+export default class BinarySocketClient {
+    socket: WebSocket;
+    pending: Map<string, {
+        resolve: Function;
+        reject: Function;
+        timer: ReturnType<typeof setTimeout>;
+    }>;
+    listeners: Map<string, Set<Function>>;
+    pubsub: {
+        publish: (topic: any, value: any) => void;
+        subscribe: (topic: any, handler: any) => () => boolean | undefined;
+    };
+    constructor(url: string, protocol: string);
+    init(): Promise<this>;
+    fail(error: any): void;
+    request({ url, params }: {
+        url: any;
+        params: any;
+    }): Promise<any>;
+    close(): void;
+}

package/exports/types/direct.d.ts

@@ -4,8 +4,8 @@ export default class Client {
     client: any;
     constructor(url?: string, networkVersion?: string);
     get pubsub(): {
-        publish: <T = any>(event: string, value: T, verbose?: boolean) => void;
-        subscribe: <T = any>(event: string, handler: import("@vandeurenglenn/little-pubsub").Handler<T>, options?: import("@vandeurenglenn/little-pubsub").SubscribeOptions) => () => void;
+        publish: any;
+        subscribe: any;
     };
     balances(): any;
     balanceOf(address: string, format: boolean): Promise<any>;

package/exports/types/http.d.ts

@@ -22,7 +22,7 @@ export default class Client {
     peers(): Promise<any>;
     validators(): Promise<any>;
     lookup(name: any): Promise<any>;
-    staticCall(contract: any, method: any, params: any): Promise<any>;
+    staticCall(contract: any, method: any, params?: never[]): Promise<any>;
     contracts(): Promise<any>;
     totalContracts(): Promise<number>;
     nativeToken(): Promise<string>;

package/exports/types/transport.d.ts

@@ -0,0 +1,2 @@
+/** Bound allocation while receiving, not only after arrayBuffer() has buffered an untrusted body. */
+export declare function readBinaryResponse(response: Response, maxBytes?: number): Promise<any>;

package/exports/types/ws.d.ts

@@ -1,13 +1,13 @@
-import ClientConnection from 'socket-request-client/connection';
+import BinarySocketClient from './binary-socket.js';
 export default class Client {
     url: string;
     networkVersion: string;
-    client: ClientConnection;
+    client: BinarySocketClient;
     constructor(url?: string, networkVersion?: string);
     init(): Promise<void>;
     get pubsub(): {
-        publish: (topic: string, value: any) => Promise<any>;
-        subscribe: (topic: string, cb: any) => Promise<any>;
+        publish: (topic: any, value: any) => void;
+        subscribe: (topic: any, handler: any) => () => boolean | undefined;
     };
     request(url: string, params?: {}): Promise<any>;
     balances(): Promise<any>;
@@ -23,7 +23,7 @@ export default class Client {
     peers(): Promise<any>;
     validators(): Promise<any>;
     lookup(name: string): Promise<any>;
-    staticCall(contract: string, method: string, params: {}): Promise<any>;
+    staticCall(contract: string, method: string, params?: any[]): Promise<any>;
     contracts(): Promise<number>;
     totalContracts(): Promise<number>;
     nativeToken(): Promise<string>;

package/exports/ws.js

@@ -1,4 +1,81 @@
-import { SocketRequestClient } from 'socket-request-client';
+import { decodeWire, encodeWire } from '@leofcoin/binary';
+
+class BinarySocketClient {
+    socket;
+    pending = new Map();
+    listeners = new Map();
+    pubsub = {
+        publish: (topic, value) => { for (const handler of this.listeners.get(topic) || [])
+            handler(value); },
+        subscribe: (topic, handler) => {
+            if (!this.listeners.has(topic))
+                this.listeners.set(topic, new Set());
+            this.listeners.get(topic).add(handler);
+            return () => this.listeners.get(topic)?.delete(handler);
+        }
+    };
+    constructor(url, protocol) {
+        this.socket = new WebSocket(url, `${protocol}.lfc-binary-v1`);
+        this.socket.binaryType = 'arraybuffer';
+    }
+    async init() {
+        await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => { this.socket.close(); reject(new Error('Binary RPC connection timed out')); }, 10000);
+            this.socket.addEventListener('open', () => { clearTimeout(timer); resolve(); }, { once: true });
+            this.socket.addEventListener('error', () => { clearTimeout(timer); reject(new Error('Binary RPC connection failed')); }, { once: true });
+        });
+        this.socket.addEventListener('message', event => {
+            try {
+                if (!(event.data instanceof ArrayBuffer))
+                    throw new Error('Binary RPC frames required');
+                const message = decodeWire('rpc-response', new Uint8Array(event.data), { maxBytes: 4 * 1024 * 1024 });
+                if (!message || typeof message.id !== 'string' || !Number.isInteger(message.status))
+                    throw new Error('Invalid RPC response');
+                const pending = this.pending.get(message.id);
+                if (!pending)
+                    return;
+                clearTimeout(pending.timer);
+                this.pending.delete(message.id);
+                if (message.status >= 400)
+                    pending.reject(new Error(message.value?.error || `RPC failed (${message.status})`));
+                else
+                    pending.resolve(message.value);
+            }
+            catch (error) {
+                this.fail(error);
+                this.socket.close(1002, 'Invalid binary RPC');
+            }
+        });
+        this.socket.addEventListener('close', () => this.fail(new Error('Binary RPC connection closed')));
+        this.socket.addEventListener('error', () => this.fail(new Error('Binary RPC connection failed')));
+        return this;
+    }
+    fail(error) { for (const { reject, timer } of this.pending.values()) {
+        clearTimeout(timer);
+        reject(error);
+    } this.pending.clear(); }
+    request({ url, params }) {
+        if (this.socket.readyState !== WebSocket.OPEN)
+            return Promise.reject(new Error('Binary RPC is not connected'));
+        if (this.pending.size >= 32)
+            return Promise.reject(new Error('Too many pending RPC requests'));
+        const id = crypto.randomUUID();
+        const bytes = encodeWire('rpc-request', { id, url, params }, { maxBytes: 1048576 });
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => { this.pending.delete(id); reject(new Error('Binary RPC request timed out')); }, 10000);
+            this.pending.set(id, { resolve, reject, timer });
+            try {
+                this.socket.send(bytes);
+            }
+            catch (error) {
+                clearTimeout(timer);
+                this.pending.delete(id);
+                reject(error);
+            }
+        });
+    }
+    close() { this.fail(new Error('Binary RPC client closed')); this.socket.close(); }
+}
 
 class Client {
     url;
@@ -9,8 +86,7 @@ class Client {
         this.networkVersion = networkVersion;
     }
     async init() {
-        const client = new SocketRequestClient(this.url, this.networkVersion);
-        this.client = (await client.init());
+        this.client = await new BinarySocketClient(this.url, this.networkVersion).init();
     }
     get pubsub() {
         return {
@@ -60,8 +136,23 @@ class Client {
     lookup(name) {
         return this.request('lookup', { name });
     }
-    staticCall(contract, method, params) {
-        return this.request('staticCall', { contract, method, params });
+    async staticCall(contract, method, params = []) {
+        if (!Array.isArray(params))
+            throw new Error('staticCall params must be an array');
+        try {
+            const value = await this.request('staticCall', {
+                contract, method, params
+            });
+            if (value?.error)
+                throw new Error(value.error);
+            return value ?? null;
+        }
+        catch (error) {
+            if (error instanceof Error)
+                throw error;
+            const message = error && typeof error === 'object' && 'error' in error ? error.error : undefined;
+            throw new Error(typeof error === 'string' ? error : typeof message === 'string' ? message : 'Read-only RPC query failed');
+        }
     }
     contracts() {
         return this.request('contracts');

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@leofcoin/endpoint-clients",
-  "version": "0.3.17",
+  "version": "0.4.0",
   "description": "",
   "exports": {
+    "./transport": { "import": "./exports/transport.js", "types": "./exports/types/transport.d.ts" },
     ".": {
       "import": "./exports/index.js",
       "types": "./exports/types/index.d.ts"
@@ -56,6 +57,6 @@
   },
   "dependencies": {
     "@leofcoin/utils": "^1.1.45",
-    "socket-request-client": "^2.0.9"
+    "@leofcoin/binary": "^1.1.0"
   }
 }