@gas-killer/analyzer-wasm 0.3.1 → 0.4.0

package/README.md

@@ -11,7 +11,7 @@ npm install @gas-killer/analyzer-wasm
 The package is built for the web target. Initialize it once before calling anything:
 
 ```js
-import init, { analyze_trace, analyze_prestate } from "@gas-killer/analyzer-wasm"
+import init, { analyze_trace_bytes, analyze_prestate } from "@gas-killer/analyzer-wasm"
 
 await init() // in Node: initSync({ module: fs.readFileSync(".../gas_killer_wasm_bg.wasm") })
 ```
@@ -30,6 +30,23 @@ const result = analyze_trace(JSON.stringify(trace), estimator, receipt.from, Big
 // { gas_estimate, is_heuristic, encoded_updates, state_update_count, skipped_opcodes, reentered }
 ```
 
+### `analyze_trace_bytes(response, estimator, caller, block?, origin?)`
+
+Takes the same arguments as `analyze_trace`, except that it accepts the whole JSON-RPC response body as a `Uint8Array`. Use it for large traces:
+
+- The trace is never decoded into a JavaScript string, so it isn't held twice and isn't subject to the string length limit.
+- Memory snapshots are skipped for steps that don't need them, so the analysis uses about 1.4× the response's size in wasm memory.
+
+```js
+const response = new Uint8Array(await (await fetch(rpcUrl, { method: "POST", body })).arrayBuffer())
+try {
+  const result = analyze_trace_bytes(response, estimator, receipt.from, BigInt(receipt.blockNumber), receipt.to)
+} catch (e) {
+  // e.name is "RpcError" when the node returned an error, or "TraceTooLargeError" when the error
+  // was the provider's response size limit
+}
+```
+
 ### `analyze_prestate(diff, callFrame, consumer, estimator, caller, block?)`
 
 Analyzes the same transaction from two much smaller traces:

package/gas_killer_wasm.d.ts

@@ -68,6 +68,16 @@ export function analyze_prestate(diff_json: string, call_frame_json: string, con
  */
 export function analyze_trace(trace_json: string, estimator_address: string, caller_address: string, estimate_state_changes_block_number?: bigint | null, origin_address?: string | null): any;
 
+/**
+ * [`analyze_trace`] on the raw bytes of a whole `debug_traceTransaction` JSON-RPC response, so a
+ * large trace never has to be decoded into a JS string or unwrapped from its envelope in JS.
+ *
+ * When the node answered with an error, throws an `Error` named `RpcError` with the node's
+ * message, or `TraceTooLargeError` when the message is the provider's response size limit.
+ * Other failures throw a plain `Error`, as [`analyze_trace`] does.
+ */
+export function analyze_trace_bytes(response: Uint8Array, estimator_address: string, caller_address: string, estimate_state_changes_block_number?: bigint | null, origin_address?: string | null): any;
+
 /**
  * Encode state updates only (no gas estimation).
  */
@@ -91,6 +101,7 @@ export interface InitOutput {
   readonly memory: WebAssembly.Memory;
   readonly analyze_prestate: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: bigint) => [number, number, number];
   readonly analyze_trace: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: bigint, i: number, j: number) => [number, number, number];
+  readonly analyze_trace_bytes: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: bigint, i: number, j: number) => [number, number, number];
   readonly encode_trace: (a: number, b: number) => [number, number, number];
   readonly estimate_gas_heuristic: (a: number, b: number, c: number, d: number) => [number, number, number];
   readonly init: () => void;

package/gas_killer_wasm.js

@@ -25,6 +25,13 @@ function isLikeNone(x) {
     return x === undefined || x === null;
 }
 
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);
@@ -176,6 +183,36 @@ export function analyze_trace(trace_json, estimator_address, caller_address, est
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * [`analyze_trace`] on the raw bytes of a whole `debug_traceTransaction` JSON-RPC response, so a
+ * large trace never has to be decoded into a JS string or unwrapped from its envelope in JS.
+ *
+ * When the node answered with an error, throws an `Error` named `RpcError` with the node's
+ * message, or `TraceTooLargeError` when the message is the provider's response size limit.
+ * Other failures throw a plain `Error`, as [`analyze_trace`] does.
+ * @param {Uint8Array} response
+ * @param {string} estimator_address
+ * @param {string} caller_address
+ * @param {bigint | null} [estimate_state_changes_block_number]
+ * @param {string | null} [origin_address]
+ * @returns {any}
+ */
+export function analyze_trace_bytes(response, estimator_address, caller_address, estimate_state_changes_block_number, origin_address) {
+    const ptr0 = passArray8ToWasm0(response, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(estimator_address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passStringToWasm0(caller_address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len2 = WASM_VECTOR_LEN;
+    var ptr3 = isLikeNone(origin_address) ? 0 : passStringToWasm0(origin_address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len3 = WASM_VECTOR_LEN;
+    const ret = wasm.analyze_trace_bytes(ptr0, len0, ptr1, len1, ptr2, len2, !isLikeNone(estimate_state_changes_block_number), isLikeNone(estimate_state_changes_block_number) ? BigInt(0) : estimate_state_changes_block_number, ptr3, len3);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Encode state updates only (no gas estimation).
  * @param {string} trace_json
@@ -290,12 +327,19 @@ function __wbg_get_imports() {
         const ret = new Error();
         return ret;
     };
+    imports.wbg.__wbg_new_df1173567d5ff028 = function(arg0, arg1) {
+        const ret = new Error(getStringFromWasm0(arg0, arg1));
+        return ret;
+    };
     imports.wbg.__wbg_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) {
         arg0[arg1] = arg2;
     };
     imports.wbg.__wbg_set_7df433eea03a5c14 = function(arg0, arg1, arg2) {
         arg0[arg1 >>> 0] = arg2;
     };
+    imports.wbg.__wbg_set_name_df69b75cb0b4de8a = function(arg0, arg1, arg2) {
+        arg0.name = getStringFromWasm0(arg1, arg2);
+    };
     imports.wbg.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {
         const ret = arg1.stack;
         const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);

package/package.json

@@ -2,7 +2,7 @@
   "name": "@gas-killer/analyzer-wasm",
   "type": "module",
   "description": "Gas Killer's WebAssembly gas analyzer: estimates a transaction's gas savings from its Geth trace in the browser",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "license": "SEE LICENSE IN LICENSE",
   "files": [
     "gas_killer_wasm_bg.wasm",