@leofcoin/endpoint-clients 0.3.16 → 0.3.17

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/index.js

@@ -1,5 +1,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/utils';

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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/endpoint-clients",
-  "version": "0.3.16",
+  "version": "0.3.17",
   "description": "",
   "exports": {
     ".": {
@@ -19,9 +19,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"