@ember-finance/sdk 2.11.0-pre.4 → 2.11.0-pre.5

package/dist/src/placements/evm.d.ts

@@ -11,5 +11,17 @@ export interface JsonRpcEvmReaderOptions {
     sleep?: (ms: number) => Promise<void>;
     fetch?: typeof globalThis.fetch;
     onRequest?: (request: TransportRequest) => void;
+    multicall?: boolean;
 }
+interface EvmCall {
+    to: string;
+    data: string;
+}
+export declare const MULTICALL3_ADDRESS = "0xcA11bde05977b3631167028862bE2a173976CA11";
+export declare function encodeAggregate3(calls: EvmCall[]): string;
+export declare function decodeAggregate3(data: string, count: number): {
+    success: boolean;
+    data: string;
+}[];
 export declare function jsonRpcEvmReader(endpoints?: Record<number, string>, options?: JsonRpcEvmReaderOptions): EvmReader;
+export {};

package/dist/src/placements/evm.js

@@ -16,13 +16,76 @@ export function decodeUint256(hex) {
         return 0n;
     return BigInt(hex);
 }
-function jsonRpcRequest(call, id) {
-    return {
-        jsonrpc: "2.0",
-        id,
-        method: "eth_call",
-        params: [{ to: call.to, data: call.data }, "latest"]
+export const MULTICALL3_ADDRESS = "0xcA11bde05977b3631167028862bE2a173976CA11";
+const AGGREGATE3_SELECTOR = "0x82ad56cb";
+const RATE_LIMITED = /too many requests|rate ?limit/i;
+function stripHex(value) {
+    return value.trim().replace(/^0x/i, "");
+}
+function word(value) {
+    return BigInt(value).toString(16).padStart(64, "0");
+}
+function addressWord(address) {
+    return stripHex(address).toLowerCase().padStart(64, "0");
+}
+function bytesWords(data) {
+    const raw = stripHex(data);
+    const length = raw.length / 2;
+    const padded = raw.padEnd(Math.ceil(length / 32) * 64, "0");
+    return word(length) + padded;
+}
+export function encodeAggregate3(calls) {
+    const tuples = calls.map(call => addressWord(call.to) + word(1) + word(0x60) + bytesWords(call.data));
+    let offset = calls.length * 32;
+    const offsets = tuples.map(tuple => {
+        const current = offset;
+        offset += tuple.length / 2;
+        return word(current);
+    });
+    return (AGGREGATE3_SELECTOR +
+        word(0x20) +
+        word(calls.length) +
+        offsets.join("") +
+        tuples.join(""));
+}
+export function decodeAggregate3(data, count) {
+    const raw = stripHex(data);
+    const read = (byteOffset) => {
+        const slice = raw.slice(byteOffset * 2, byteOffset * 2 + 64);
+        if (slice.length !== 64)
+            throw new Error("multicall: truncated response");
+        return Number(BigInt(`0x${slice}`));
     };
+    const arrayOffset = read(0);
+    const length = read(arrayOffset);
+    if (length !== count)
+        throw new Error("multicall: result count mismatch");
+    const base = arrayOffset + 32;
+    const results = [];
+    for (let index = 0; index < length; index += 1) {
+        const tupleOffset = base + read(base + index * 32);
+        const success = read(tupleOffset) === 1;
+        const bytesOffset = tupleOffset + read(tupleOffset + 32);
+        const bytesLength = read(bytesOffset);
+        const start = (bytesOffset + 32) * 2;
+        const body = raw.slice(start, start + bytesLength * 2);
+        if (body.length !== bytesLength * 2)
+            throw new Error("multicall: truncated response");
+        results.push({ success, data: `0x${body}` });
+    }
+    return results;
+}
+function jsonRpcRequest(method, params, id) {
+    return { jsonrpc: "2.0", id, method, params };
+}
+function callRequest(call, id) {
+    return jsonRpcRequest("eth_call", [{ to: call.to, data: call.data }, "latest"], id);
+}
+function isRateLimited(entry) {
+    const error = entry?.error;
+    if (!error)
+        return false;
+    return error.code === -32005 || RATE_LIMITED.test(error.message ?? "");
 }
 function toResult(entry) {
     if (!entry)
@@ -35,53 +98,111 @@ export function jsonRpcEvmReader(endpoints = {}, options = {}) {
     const fetchImpl = options.fetch ??
         ((input, init) => globalThis.fetch(input, init));
     const onRequest = options.onRequest;
+    const useMulticall = options.multicall ?? true;
     const batchers = new Map();
-    const singleOnly = new Set();
+    const modes = new Map();
     const post = async (endpoint, body, items, attempt) => {
+        let response;
         try {
-            const response = await fetchImpl(endpoint, {
+            response = await fetchImpl(endpoint, {
                 method: "POST",
                 headers: { "Content-Type": "application/json" },
                 body: JSON.stringify(body)
             });
-            onRequest?.({ items, attempt, status: response.status });
-            return response;
         }
         catch (error) {
             onRequest?.({ items, attempt, status: "network-error" });
             throw new TransientError(`evm rpc: ${error instanceof Error ? error.message : String(error)}`);
         }
-    };
-    const send = async (endpoint, calls, attempt) => {
-        const batched = calls.length > 1;
-        if (batched && singleOnly.has(endpoint)) {
-            throw new ChunkTooLargeError("evm rpc: batch unsupported");
-        }
-        const body = batched
-            ? calls.map((call, id) => jsonRpcRequest(call, id))
-            : jsonRpcRequest(calls[0], 1);
-        const response = await post(endpoint, body, calls.length, attempt);
+        onRequest?.({ items, attempt, status: response.status });
         if (isTransientStatus(response.status)) {
             throw new TransientError(`evm rpc ${response.status}`, retryAfterMs(response.headers?.get("retry-after")));
         }
-        if (!response.ok) {
-            if (batched) {
-                singleOnly.add(endpoint);
-                throw new ChunkTooLargeError(`evm rpc ${response.status}`);
-            }
+        return response;
+    };
+    const rpc = async (endpoint, method, params, items, attempt) => {
+        const response = await post(endpoint, jsonRpcRequest(method, params, 1), items, attempt);
+        if (!response.ok)
             throw new Error(`evm rpc ${response.status}`);
-        }
         const parsed = (await response.json());
-        if (!batched) {
-            return [toResult(Array.isArray(parsed) ? parsed[0] : parsed)];
+        const entry = Array.isArray(parsed) ? parsed[0] : parsed;
+        if (isRateLimited(entry))
+            throw new TransientError(`evm rpc: ${entry?.error?.message}`);
+        return entry ?? {};
+    };
+    const detectMode = async (endpoint, attempt) => {
+        const known = modes.get(endpoint);
+        if (known)
+            return known;
+        let mode = "batch";
+        if (useMulticall) {
+            try {
+                const code = await rpc(endpoint, "eth_getCode", [MULTICALL3_ADDRESS, "latest"], 1, attempt);
+                if (!code.error && stripHex(code.result ?? "").length > 2)
+                    mode = "multicall";
+            }
+            catch (error) {
+                if (error instanceof TransientError)
+                    throw error;
+            }
+        }
+        modes.set(endpoint, mode);
+        return mode;
+    };
+    const sendMulticall = async (endpoint, calls, attempt) => {
+        const entry = await rpc(endpoint, "eth_call", [{ to: MULTICALL3_ADDRESS, data: encodeAggregate3(calls) }, "latest"], calls.length, attempt);
+        if (entry.error || !entry.result)
+            return undefined;
+        let decoded;
+        try {
+            decoded = decodeAggregate3(entry.result, calls.length);
+        }
+        catch {
+            return undefined;
+        }
+        return decoded.map(result => result.success
+            ? { ok: true, value: result.data === "" ? "0x" : result.data }
+            : { ok: false, error: new Error("evm rpc: execution reverted") });
+    };
+    const sendBatch = async (endpoint, calls, attempt) => {
+        const response = await post(endpoint, calls.map((call, id) => callRequest(call, id)), calls.length, attempt);
+        if (!response.ok) {
+            modes.set(endpoint, "single");
+            throw new ChunkTooLargeError(`evm rpc ${response.status}`);
         }
+        const parsed = (await response.json());
         if (!Array.isArray(parsed)) {
-            singleOnly.add(endpoint);
+            modes.set(endpoint, "single");
             throw new ChunkTooLargeError("evm rpc: batch unsupported");
         }
+        const limited = parsed.find(isRateLimited);
+        if (limited)
+            throw new TransientError(`evm rpc: ${limited.error?.message}`);
         const byId = new Map(parsed.map(entry => [Number(entry.id), entry]));
         return calls.map((_, id) => toResult(byId.get(id)));
     };
+    const send = async (endpoint, calls, attempt) => {
+        if (calls.length === 1) {
+            const response = await post(endpoint, callRequest(calls[0], 1), 1, attempt);
+            if (!response.ok)
+                throw new Error(`evm rpc ${response.status}`);
+            const parsed = (await response.json());
+            const entry = Array.isArray(parsed) ? parsed[0] : parsed;
+            if (isRateLimited(entry))
+                throw new TransientError(`evm rpc: ${entry?.error?.message}`);
+            return [toResult(entry)];
+        }
+        const mode = await detectMode(endpoint, attempt);
+        if (mode === "single")
+            throw new ChunkTooLargeError("evm rpc: batch unsupported");
+        if (mode === "multicall") {
+            const aggregated = await sendMulticall(endpoint, calls, attempt);
+            if (aggregated)
+                return aggregated;
+            modes.set(endpoint, "batch");
+        }
+        return sendBatch(endpoint, calls, attempt);
+    };
     const batcherFor = (endpoint) => {
         const existing = batchers.get(endpoint);
         if (existing)

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@ember-finance/sdk",
     "description": "Ember Protocol SDK",
-    "version": "2.11.0-pre.4",
+    "version": "2.11.0-pre.5",
     "type": "module",
     "module": "./dist/index.js",
     "main": "./dist/index.js",