@leofcoin/endpoint-clients 0.3.16 → 0.4.0

package/exports/dex.js

@@ -0,0 +1,137 @@
+const BASIS_POINTS = 10000n;
+const address = (value, label) => {
+    if (typeof value !== 'string' || value.length === 0)
+        throw new Error(`${label} address required`);
+    return value;
+};
+const amount = (value, label, allowZero = false) => {
+    const result = BigInt(value);
+    if (allowZero ? result < 0n : result <= 0n)
+        throw new Error(`${label} must be ${allowZero ? 'non-negative' : 'positive'}`);
+    return result;
+};
+const safeInteger = (value, label) => {
+    if (!Number.isSafeInteger(value) || value < 0)
+        throw new Error(`${label} must be a non-negative safe integer`);
+    return value;
+};
+class DexClient {
+    transport;
+    factory;
+    constructor(transport, factory) {
+        if (!transport || typeof transport.staticCall !== 'function')
+            throw new Error('DEX transport with staticCall required');
+        this.transport = transport;
+        this.factory = address(factory, 'factory');
+    }
+    async poolFor(tokenA, tokenB) {
+        tokenA = address(tokenA, 'token A');
+        tokenB = address(tokenB, 'token B');
+        if (tokenA === tokenB)
+            throw new Error('pool tokens must differ');
+        const pool = await this.transport.staticCall(this.factory, 'poolFor', [tokenA, tokenB]);
+        return pool === undefined || pool === null || pool === '' ? undefined : String(pool);
+    }
+    async pools() {
+        const pools = await this.transport.staticCall(this.factory, 'pools', []);
+        if (!Array.isArray(pools))
+            throw new Error('factory returned an invalid pool list');
+        return pools.map(String);
+    }
+    async poolState(pool) {
+        pool = address(pool, 'pool');
+        const [token0, token1, feeBasisPoints, reserve0, reserve1, totalLiquidity] = await Promise.all([
+            this.transport.staticCall(pool, 'token0', []),
+            this.transport.staticCall(pool, 'token1', []),
+            this.transport.staticCall(pool, 'feeBasisPoints', []),
+            this.transport.staticCall(pool, 'reserve0', []),
+            this.transport.staticCall(pool, 'reserve1', []),
+            this.transport.staticCall(pool, 'totalLiquidity', [])
+        ]);
+        return {
+            address: pool,
+            token0: address(String(token0 ?? ''), 'token 0'),
+            token1: address(String(token1 ?? ''), 'token 1'),
+            feeBasisPoints: BigInt(feeBasisPoints),
+            reserve0: BigInt(reserve0),
+            reserve1: BigInt(reserve1),
+            totalLiquidity: BigInt(totalLiquidity)
+        };
+    }
+    async liquidityOf(pool, provider) {
+        pool = address(pool, 'pool');
+        provider = address(provider, 'provider');
+        return BigInt((await this.transport.staticCall(pool, 'liquidityOf', [provider])));
+    }
+    async quoteExactInput(pool, tokenIn, amountIn) {
+        pool = address(pool, 'pool');
+        tokenIn = address(tokenIn, 'input token');
+        const input = amount(amountIn, 'input amount');
+        return BigInt((await this.transport.staticCall(pool, 'getAmountOut', [tokenIn, input])));
+    }
+    minimumAmountOut(quote, slippageBasisPoints) {
+        const output = amount(quote, 'quote');
+        const slippage = amount(slippageBasisPoints, 'slippage', true);
+        if (slippage >= BASIS_POINTS)
+            throw new Error('slippage must be below 10000 basis points');
+        return (output * (BASIS_POINTS - slippage)) / BASIS_POINTS;
+    }
+    approve(from, token, pool, value, options = {}) {
+        return this.#transaction(from, token, 'approve', [address(pool, 'pool'), amount(value, 'approval amount')], options);
+    }
+    addLiquidity(from, pool, amount0Desired, amount1Desired, minimumLiquidity = 0n, options = {}) {
+        return this.#transaction(from, pool, 'addLiquidity', [
+            amount(amount0Desired, 'token 0 amount'),
+            amount(amount1Desired, 'token 1 amount'),
+            amount(minimumLiquidity, 'minimum liquidity', true)
+        ], options);
+    }
+    removeLiquidity(from, pool, liquidity, minimumAmount0 = 0n, minimumAmount1 = 0n, receiver = from, options = {}) {
+        return this.#transaction(from, pool, 'removeLiquidity', [
+            amount(liquidity, 'liquidity'),
+            amount(minimumAmount0, 'minimum token 0 amount', true),
+            amount(minimumAmount1, 'minimum token 1 amount', true),
+            address(receiver, 'receiver')
+        ], options);
+    }
+    swapExactInput(from, pool, tokenIn, amountIn, minimumAmountOut, receiver = from, deadline = Date.now() + 20 * 60 * 1000, options = {}) {
+        return this.#transaction(from, pool, 'swapExactTokensForTokens', [
+            address(tokenIn, 'input token'),
+            amount(amountIn, 'input amount'),
+            amount(minimumAmountOut, 'minimum output amount', true),
+            address(receiver, 'receiver'),
+            safeInteger(deadline, 'deadline')
+        ], options);
+    }
+    registerPool(from, pool, options = {}) {
+        return this.#transaction(from, this.factory, 'registerPool', [address(pool, 'pool')], options);
+    }
+    async signAndSend(transaction, signer) {
+        if (typeof signer !== 'function')
+            throw new Error('transaction signer required');
+        if (typeof this.transport.sendTransaction !== 'function')
+            throw new Error('DEX transport does not support sendTransaction');
+        const signed = await signer(transaction);
+        return this.transport.sendTransaction(signed);
+    }
+    async #transaction(from, to, method, params, options) {
+        from = address(from, 'sender');
+        to = address(to, 'target');
+        let nonce = options.nonce;
+        if (nonce === undefined) {
+            if (typeof this.transport.getNonce !== 'function')
+                throw new Error('nonce required when transport has no getNonce');
+            nonce = Number(await this.transport.getNonce(from)) + 1;
+        }
+        return {
+            from,
+            to,
+            method,
+            params,
+            nonce: safeInteger(nonce, 'nonce'),
+            timestamp: safeInteger(options.timestamp ?? Date.now(), 'timestamp')
+        };
+    }
+}
+
+export { DexClient as default };

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

@@ -1,5 +1,7 @@
 export { default as ws } from './ws.js';
 export { default as http } from './http.js';
 export { default as direct } from './direct.js';
-import 'socket-request-client';
+export { default as DexClient } from './dex.js';
+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/dex.d.ts

@@ -0,0 +1,45 @@
+export type DexTransaction = {
+    from: string;
+    to: string;
+    method: string;
+    params: unknown[];
+    nonce: number;
+    timestamp: number;
+};
+export type DexTransport = {
+    staticCall: (contract: string, method: string, params?: unknown[]) => Promise<unknown>;
+    getNonce?: (address: string) => Promise<number | string | bigint>;
+    sendTransaction?: (transaction: unknown) => Promise<unknown>;
+};
+export type DexSigner = (transaction: DexTransaction) => Promise<unknown> | unknown;
+export type TransactionOptions = {
+    nonce?: number;
+    timestamp?: number;
+};
+export type PoolState = {
+    address: string;
+    token0: string;
+    token1: string;
+    feeBasisPoints: bigint;
+    reserve0: bigint;
+    reserve1: bigint;
+    totalLiquidity: bigint;
+};
+export default class DexClient {
+    #private;
+    readonly transport: DexTransport;
+    readonly factory: string;
+    constructor(transport: DexTransport, factory: string);
+    poolFor(tokenA: string, tokenB: string): Promise<string | undefined>;
+    pools(): Promise<string[]>;
+    poolState(pool: string): Promise<PoolState>;
+    liquidityOf(pool: string, provider: string): Promise<bigint>;
+    quoteExactInput(pool: string, tokenIn: string, amountIn: bigint | number | string): Promise<bigint>;
+    minimumAmountOut(quote: bigint | number | string, slippageBasisPoints: bigint | number | string): bigint;
+    approve(from: string, token: string, pool: string, value: bigint | number | string, options?: TransactionOptions): Promise<DexTransaction>;
+    addLiquidity(from: string, pool: string, amount0Desired: bigint | number | string, amount1Desired: bigint | number | string, minimumLiquidity?: bigint | number | string, options?: TransactionOptions): Promise<DexTransaction>;
+    removeLiquidity(from: string, pool: string, liquidity: bigint | number | string, minimumAmount0?: bigint | number | string, minimumAmount1?: bigint | number | string, receiver?: string, options?: TransactionOptions): Promise<DexTransaction>;
+    swapExactInput(from: string, pool: string, tokenIn: string, amountIn: bigint | number | string, minimumAmountOut: bigint | number | string, receiver?: string, deadline?: number, options?: TransactionOptions): Promise<DexTransaction>;
+    registerPool(from: string, pool: string, options?: TransactionOptions): Promise<DexTransaction>;
+    signAndSend(transaction: DexTransaction, signer: DexSigner): Promise<unknown>;
+}

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/index.d.ts

@@ -1,3 +1,5 @@
 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';
+export type { DexSigner, DexTransaction, DexTransport, PoolState, TransactionOptions } from './dex.js';

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.16",
+  "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"
@@ -19,9 +20,14 @@
       "import": "./exports/direct.js",
       "types": "./exports/types/direct.d.ts"
     },
+    "./dex": {
+      "import": "./exports/dex.js",
+      "types": "./exports/types/dex.d.ts"
+    },
     "./ws.js": "./exports/ws.js",
     "./http.js": "./exports/http.js",
-    "./direct.js": "./exports/direct.js"
+    "./direct.js": "./exports/direct.js",
+    "./dex.js": "./exports/dex.js"
   },
   "files": [
     "exports"
@@ -51,6 +57,6 @@
   },
   "dependencies": {
     "@leofcoin/utils": "^1.1.45",
-    "socket-request-client": "^2.0.9"
+    "@leofcoin/binary": "^1.1.0"
   }
 }