eth-compress 0.2.1 → 0.2.2

package/jit-compressor.ts

@@ -1,6 +1,8 @@
 import { LibZip } from 'solady';
+import { MIN_BODY_SIZE } from './index';
 
-const MAX_160_BIT = (1n << 128n) - 1n;
+const MAX_128_BIT = (1n << 128n) - 1n;
+const MAX_256_BIT = (1n << 256n) - 1n;
 
 const _normHex = (hex: string): string => hex.replace(/^0x/, '').toLowerCase();
 
@@ -22,6 +24,22 @@ const _uint8ArrayToHex = (bytes: Uint8Array): string => {
   return hex;
 };
 
+const not = (a: bigint): bigint => ~a & MAX_256_BIT;
+const and = (a: bigint, b: bigint): bigint => a & b & MAX_256_BIT;
+const or = (a: bigint, b: bigint): bigint => (a | b) & MAX_256_BIT;
+const xor = (a: bigint, b: bigint): bigint => (a ^ b) & MAX_256_BIT;
+const shl = (shift: bigint, value: bigint): bigint => (value << shift) & MAX_256_BIT;
+const shr = (shift: bigint, value: bigint): bigint => (value >> shift) & MAX_256_BIT;
+const sub = (a: bigint, b: bigint): bigint => (a - b) & MAX_256_BIT;
+const sigext = (byteSize: bigint, value: bigint): bigint => {
+  const numBytes = Number(byteSize) + 1;
+  const mask = (1n << BigInt(numBytes * 8)) - 1n;
+  const signBit = 1n << BigInt(numBytes * 8 - 1);
+  const maskedVal = value & mask;
+  const extended = maskedVal & signBit ? maskedVal | (~mask & MAX_256_BIT) : maskedVal;
+  return extended & MAX_256_BIT;
+};
+
 /**
  * Generates FastLZ (LZ77) decompressor bytecode. The generated code decompresses incoming calldata and forwards it to the target address.
  * @param address - Target contract address
@@ -29,7 +47,7 @@ const _uint8ArrayToHex = (bytes: Uint8Array): string => {
  * @pure
  */
 //! @__PURE__
-export const flzFwdBytecode = (address: string): string =>
+const flzFwdBytecode = (address: string): string =>
   `0x365f73${_normHex(address)}815b838110602f575f80848134865af1503d5f803e3d5ff35b803590815f1a8060051c908115609857600190600783149285831a6007018118840218600201948383011a90601f1660081b0101808603906020811860208211021890815f5b80830151818a015201858110609257505050600201019201916018565b82906075565b6001929350829150019101925f5b82811060b3575001916018565b85851060c1575b60010160a6565b936001818192355f1a878501530194905060ba56`;
 
 /**
@@ -39,19 +57,9 @@ export const flzFwdBytecode = (address: string): string =>
  * @pure
  */
 //! @__PURE__
-export const rleFwdBytecode = (address: string): string =>
+const rleFwdBytecode = (address: string): string =>
   `0x5f5f5b368110602d575f8083813473${_normHex(address)}5af1503d5f803e3d5ff35b600180820192909160031981019035185f1a8015604c57815301906002565b505f19815282820192607f9060031981019035185f1a818111156072575b160101906002565b838101368437606a56`;
 
-/**
- * JIT Compiles decompressor bytecode
- * @param calldata - Calldata to compress
- * @pure
- */
-//! @__PURE__
-export const jitBytecode = function (calldata: string): string {
-  return _jitDecompressor('0x' + _normHex(calldata));
-};
-
 const _jitDecompressor = function (calldata: string): string {
   const hex = _normHex(calldata);
   const originalBuf = _hexToUint8Array(hex);
@@ -72,9 +80,11 @@ const _jitDecompressor = function (calldata: string): string {
   let stack: bigint[] = [];
   let trackedMemSize = 0;
   let mem = new Map<number, bigint>();
+  let firstPass = true;
   const getStackIdx = (val: bigint): number => {
-    const idx = stack.lastIndexOf(val);
-    return idx === -1 ? -1 : stack.length - 1 - idx;
+    let idx = stack.lastIndexOf(val);
+    idx = idx === -1 ? -1 : stack.length - 1 - idx;
+    return idx > 15 ? -1 : idx;
   };
 
   const opFreq = new Map<number, number>();
@@ -86,20 +96,15 @@ const _jitDecompressor = function (calldata: string): string {
 
   let pushCounter = 0;
   const stackCnt = new Map<bigint, number>();
-
   const pop2 = (): [bigint, bigint] => [stack.pop()!, stack.pop()!];
-  const MASK32 = (1n << 256n) - 1n;
-
   const ctr = <K>(m: Map<K, number>, k: K, delta: number) => m.set(k, (m.get(k) || 0) + delta);
   const inc = <K>(m: Map<K, number>, k: K) => ctr(m, k, 1);
-  const dec = <K>(m: Map<K, number>, k: K) => ctr(m, k, -1);
-  const pushOp = (op: number) => {
+  const pushOp = (op: number, d?: number[] | null) => {
     ops.push(op);
     inc(opFreq, op);
-  };
-  const pushD = (d: number[] | null) => {
-    data.push(d || null);
-    inc(dataFreq, d || null);
+    const imm = d ?? null;
+    data.push(imm);
+    inc(dataFreq, imm);
   };
   const pushS = (v: bigint, freq: number = 1) => {
     stack.push(v);
@@ -117,57 +122,68 @@ const _jitDecompressor = function (calldata: string): string {
       pushS(32n, 0);
     } else if (op === 0x59) {
       pushS(BigInt(trackedMemSize), 0);
+    } else if (op === 0x0b) {
+      // SIGNEXTEND
+      const [byteSize, val] = pop2();
+      pushS(sigext(byteSize, val), 1);
+    } else if (op === 0x19) {
+      // NOT
+      const val = stack.pop()!;
+      pushS(not(val), 0);
+    } else if (op === 0x18) {
+      // XOR
+      const [a, b] = pop2();
+      pushS(xor(a, b), 1);
+    } else if (op === 0x16) {
+      // AND
+      const [a, b] = pop2();
+      pushS(and(a, b), 1);
+    } else if (op === 0x03) {
+      // SUB
+      const [a, b] = pop2();
+      pushS(sub(a, b), 1);
     } else if (op === 0x1b) {
+      // SHL
       let [shift, val] = pop2();
-      if (ops[ops.length - 1] == 144) {
-        ops.pop();
-        data.pop();
-        [shift, val] = [val, shift];
-      }
-      pushS((val << BigInt(shift)) & MASK32);
+      pushS(shl(shift, val), 1);
+    } else if (op === 0x1c) {
+      // SHR
+      let [shift, val] = pop2();
+      pushS(shr(shift, val), 1);
     } else if (op === 0x17) {
       // OR
-      const [a, b] = pop2();
-      if (ops[ops.length - 1] == 144) {
-        ops.pop();
-        data.pop();
-      }
-      pushS((a | b) & MASK32);
+      let [a, b] = pop2();
+      pushS(or(a, b), 1);
     } else if ((op >= 0x60 && op <= 0x7f) || op === 0x5f) {
       // PUSH
       let v = 0n;
       for (const b of imm || []) v = (v << 8n) | BigInt(b);
       if (v == 224n) {
-        // Special‑case the literal 0xe0 (224):
-        // the decompressor is always deployed at 0x...00e0, so the final
-        // byte of ADDRESS is exactly 0xe0. Since we must send our own
-        // address with the eth_call anyway, we can synthesize this value
-        // with a single opcode instead of encoding a literal, effectively
-        // giving us one more hot constant slot on the stack.
-        pushS(v);
+        pushS(v, 0);
         pushOp(0x30); // ADDRESS
-        pushD(null);
+        return;
+      }
+      if (v == 32n) {
+        pushS(v, 0);
+        pushOp(0x36); // ADDRESS
+        return;
+      }
+      if (v === BigInt(trackedMemSize)) {
+        pushS(v, 0);
+        pushOp(0x59); // MemSize
         return;
       }
       const idx = getStackIdx(v);
       if (idx !== -1 && op != 0x5f) {
-        const last = stackFreq.get(v) == 0;
-        if (idx == 0 && last) {
-          dec(stackFreq, v);
-          return;
-        }
-        if (idx == 1 && last) {
-          pushOp(144);
-          const [a, b] = pop2();
-          stack.push(b);
-          stack.push(a);
-          pushD(null);
-          dec(stackFreq, v);
-          return;
-        }
-        pushS(v, -1);
+        let pushCtr = firstPass ? 1 : -1;
+        pushS(v, pushCtr);
         pushOp(128 + idx);
-        pushD(null);
+        return;
+      }
+      if (v == MAX_256_BIT) {
+        pushS(v);
+        pushOp(0x5f); // 0
+        pushOp(0x19); // NOT
         return;
       }
       pushS(v);
@@ -179,7 +195,7 @@ const _jitDecompressor = function (calldata: string): string {
       // MSTORE
       const [offset, value] = pop2();
       const k = Number(offset);
-      mem.set(k, value & MASK32);
+      mem.set(k, value & MAX_256_BIT);
       trackMem(k, 32);
     } else if (op === 0x53) {
       // MSTORE8
@@ -189,10 +205,8 @@ const _jitDecompressor = function (calldata: string): string {
       // RETURN
       pop2();
     }
-    pushOp(op);
-    pushD(imm || null);
+    pushOp(op, imm || null);
   };
-  const isInStack = (w) => stack.includes(w) || w == 0xe0 || w == 32n;
   const op = (opcode: number) => addOp(opcode);
   const pushN = (value: number | bigint) => {
     if (value > 0 && value === trackedMemSize) return addOp(0x59);
@@ -234,6 +248,7 @@ const _jitDecompressor = function (calldata: string): string {
   const emitOp = (o: number) => (plan.push({ t: 'op', o }), op(o));
   pushN(1n);
   // First pass: decide how to build each 32-byte word without emitting bytecode
+  const _stack = [1n, 32n, 224n];
   for (let base = 0; base < n; base += 32) {
     const word = new Uint8Array(32);
     word.set(buf.slice(base, Math.min(base + 32, n)), 0);
@@ -256,6 +271,15 @@ const _jitDecompressor = function (calldata: string): string {
     for (const b of literal) literalVal = (literalVal << 8n) | BigInt(b);
     const baseBytes = Math.ceil(Math.log2(base + 1) / 8);
     const wordHex = _uint8ArrayToHex(word);
+    const shlCost = estShlCost(seg);
+
+    const inStack = _stack.includes(literalVal);
+    if (inStack) {
+      emitPushB(literal);
+      emitPushN(base);
+      emitOp(0x52); // MSTORE
+      continue;
+    }
     if (literalCost > 8) {
       if (wordCache.has(wordHex)) {
         if (literalCost > wordCacheCost.get(wordHex)! + baseBytes) {
@@ -273,31 +297,134 @@ const _jitDecompressor = function (calldata: string): string {
       }
     }
 
-    // Convert literal bytes to bigint for stack comparison
-
     const byte8s = seg.every(({ s, e }) => s === e);
-    if (isInStack(literal)) {
-      emitPushB(literal);
-    } else if (byte8s) {
-      for (const { s } of seg) {
-        emitPushN(word[s]);
-        emitPushN(base + s);
-        emitOp(0x53); // MSTORE8
-      }
-      continue;
-    } else if (literalCost <= estShlCost(seg)) {
+    const byte8sCost = seg.length * 3; // each: PUSH1 (value), PUSH1 (offset), MSTORE8
+    if (inStack) {
       emitPushB(literal);
     } else {
-      let first = true;
-      for (const { s, e } of seg) {
-        const suffix0s = 31 - e;
-        emitPushB(word.slice(s, e + 1));
-        if (suffix0s > 0) {
-          emitPushN(suffix0s * 8);
-          emitOp(0x1b); // SHL
+      // Aggregate all costs
+      let bestCost = literalCost;
+      let bestEmit: (() => void) | null = () => {
+        emitPushB(literal);
+      };
+      if (literalVal == MAX_256_BIT) {
+        bestCost = 2;
+        bestEmit = () => {
+          emitPushN(notVal);
+          emitOp(0x19);
+        };
+      }
+      // Try NOT: PUSH<n> ~val, NOT
+      const notVal = not(literalVal);
+      let notBytes = 0;
+      let tmp = notVal;
+      while (tmp > 0n) {
+        ++notBytes;
+        tmp >>= 8n;
+      }
+      notBytes = 1 + notBytes;
+      if (notBytes === 0) notBytes;
+      const notCost = notBytes + 1; // PUSH<n> + NOT
+      if (notCost < bestCost) {
+        bestCost = notCost;
+        bestEmit = () => {
+          emitPushN(notVal);
+          emitOp(0x19);
+        };
+      }
+
+      // Try SUB: PUSH1 0, PUSH<n> val, SUB
+      const subVal = sub(0n, literalVal);
+      let subBytes = 0;
+      tmp = subVal;
+      while (tmp > 0n) {
+        ++subBytes;
+        tmp >>= 8n;
+      }
+      if (subBytes === 0) subBytes = 1;
+      if (_stack.includes(subVal)) subBytes = 1;
+      const subCost = 1 + (1 + subBytes) + 1; // PUSH0 + PUSH<n> + SUB
+      if (subCost < bestCost) {
+        bestCost = subCost;
+        bestEmit = () => {
+          emitPushN(0);
+          emitPushN(subVal);
+          emitOp(0x03);
+        };
+      }
+
+      // Try SIGNEXTEND: PUSH<n> truncated, PUSH1 byteSize, SIGNEXTEND
+      for (let numBytes = 1; numBytes < literal.length; numBytes++) {
+        const mask = (1n << BigInt(numBytes * 8)) - 1n;
+        const truncated = literalVal & mask;
+        const extended = sigext(BigInt(numBytes - 1), truncated);
+        if (extended === literalVal && (truncated & (1n << BigInt(numBytes * 8 - 1))) !== 0n) {
+          let trueByteCost = 1 + numBytes;
+          if (_stack.includes(BigInt(extended))) trueByteCost = 1;
+          let signCost = trueByteCost + (1 + 1) + 1; // PUSH<n> + PUSH1 + SIGNEXTEND
+          if (signCost < bestCost) {
+            bestCost = signCost;
+            bestEmit = () => {
+              emitPushN(truncated);
+              emitPushN(numBytes - 1);
+              emitOp(0x0b);
+            };
+          }
+          break;
         }
-        if (!first) emitOp(0x17); // OR
-        first = false;
+      }
+
+      // Try SHIFT+NOT: PUSH<n> val, PUSH1 shift, SHL, NOT
+      for (let shiftBits = 8; shiftBits <= 248; shiftBits += 8) {
+        const shifted = shr(BigInt(shiftBits), literalVal);
+        if (shifted === 0n) break;
+
+        const notShifted = not(shifted);
+        const reconstructed = shl(BigInt(shiftBits), notShifted);
+
+        if (reconstructed === literalVal) {
+          let shiftedBytes = 0;
+          let tmpShifted = notShifted;
+          while (tmpShifted > 0n) {
+            ++shiftedBytes;
+            tmpShifted >>= 8n;
+          }
+          if (shiftedBytes === 0) shiftedBytes = 1;
+          const shiftNotCost = 1 + shiftedBytes + 2 + 1 + 1; // PUSH<n> + PUSH1 + SHL + NOT
+          if (shiftNotCost < bestCost) {
+            bestCost = shiftNotCost;
+            bestEmit = () => {
+              emitPushN(notShifted);
+              emitPushN(shiftBits);
+              emitOp(0x1b); // SHL
+              emitOp(0x19); // NOT
+            };
+          }
+        }
+      }
+
+      if (byte8s && byte8sCost < bestCost && byte8sCost <= shlCost) {
+        for (const { s } of seg) {
+          emitPushN(word[s]);
+          emitPushN(base + s);
+          emitOp(0x53); // MSTORE8
+        }
+        continue; // Skip the single MSTORE at the end
+      } else if (shlCost < bestCost) {
+        // Use SHL/OR
+        let first = true;
+        for (const { s, e } of seg) {
+          const suffix0s = 31 - e;
+          emitPushB(word.slice(s, e + 1));
+          if (suffix0s > 0) {
+            emitPushN(suffix0s * 8);
+            emitOp(0x1b); // SHL
+          }
+          if (!first) emitOp(0x17); // OR
+          first = false;
+        }
+      } else {
+        bestEmit!();
       }
     }
     emitPushN(base);
@@ -314,9 +441,9 @@ const _jitDecompressor = function (calldata: string): string {
     .filter(([val, freq]) => freq > 1 && val > 1n && val !== 32n && val !== 224n)
     .sort((a, b) => stackCnt.get(b[0])! - stackCnt.get(a[0])!)
     .filter(([val, _]) => {
-      return typeof val === 'number' ? BigInt(val) : val <= MAX_160_BIT;
+      return typeof val === 'number' ? BigInt(val) : val <= MAX_128_BIT;
     })
-    .slice(0, 13)
+    .slice(0, 15)
     .forEach(([val, _]) => {
       pushN(val);
     });
@@ -362,16 +489,18 @@ const _jitDecompressor = function (calldata: string): string {
   return '0x' + _uint8ArrayToHex(new Uint8Array(out)) + '345f355af13d5f5f3e3d5ff3';
 };
 
-const MIN_SIZE_FOR_COMPRESSION = 1150;
 const DECOMPRESSOR_ADDRESS = '0x00000000000000000000000000000000000000e0';
 
-const _jit = 'jit';
-const _flz = 'flz';
-const _cd = 'cd';
-
 /**
  * Compresses eth_call payload using JIT, FastLZ (FLZ), or calldata RLE (CD) compression.
  * Auto-selects best algorithm if not specified. Only compresses if >800 bytes and beneficial.
+ *
+ * Only applies compression to calls that:
+ * - target the latest block ID
+ * - have no state overrides
+ * - have a target address and calldata
+ * - have no other properties (nonce, gas, etc.)
+ *
  * @param payload - eth_call RPC payload
  * @param alg - 'jit' | 'flz' | 'cd' | undefined (auto)
  * @returns (un)compressed eth_call payload
@@ -379,65 +508,63 @@ const _cd = 'cd';
  */
 //! @__PURE__
 export const compress_call = function (payload: any, alg?: string): any {
-  const rpcMethod = payload.params?.[0]?.method || payload.method;
-  if (rpcMethod && rpcMethod !== 'eth_call') return payload;
-
-  // Extract data and target address from params[0] if available, otherwise top-level
-  const txObj = payload.params?.[0] || payload;
-  const blockParam = payload.params?.[1] || 'latest';
-  const existingStateOverride = payload.params?.[2] || {};
-
-  // If there are any existing state overrides for the decompressor address, do not compress
-  const hex = _normHex(txObj.data || '0x');
-  const originalSize = (txObj.data || '0x').length;
-  if (originalSize < MIN_SIZE_FOR_COMPRESSION || (existingStateOverride[DECOMPRESSOR_ADDRESS])) return payload;
-
-  const targetAddress = txObj.to || '';
-  const data = '0x' + hex;
-
-  const autoSelect = !alg && originalSize < 1150;
-  const flz = alg === _flz || autoSelect ? LibZip.flzCompress(data) : null;
-  const cd = alg === _cd || autoSelect ? LibZip.cdCompress(data) : null;
-  let selectedMethod = alg;
-  if (!selectedMethod) {
-    selectedMethod =
-      originalSize >= 1150 && (originalSize < 3000 || originalSize >= 8000)
-        ? _jit
-        : originalSize >= 3000 && originalSize < 8000
-          ? flz!.length < cd!.length
-            ? _flz
-            : _cd
-          : _cd;
+  const { method, params } = payload;
+  if (method && method !== 'eth_call') return payload;
+  const txObj = params?.[0] || payload;
+  const blockParam = params?.[1];
+  const overrides = params?.[2];
+
+  // Validation
+  if (
+    (blockParam && blockParam !== 'latest') ||
+    (overrides && Object.keys(overrides).length > 0) ||
+    !txObj?.to ||
+    !txObj?.data ||
+    Object.keys(txObj).some((k) => !['to', 'data', 'from'].includes(k))
+  ) {
+    return payload;
   }
 
+  const originalSize = txObj.data.length;
+  if (originalSize < MIN_BODY_SIZE) return payload;
+
+  const inputData = '0x' + _normHex(txObj.data);
+  const to = txObj.to;
+
+  // Determine compression method and generate bytecode/calldata
   let bytecode: string;
   let calldata: string;
 
-  if (selectedMethod === _jit) {
-    bytecode = _jitDecompressor(data);
-    calldata = '0x' + _normHex(targetAddress).padStart(64, '0');
+  if (alg === 'jit' || (!alg && (originalSize < 3000 || originalSize >= 8000))) {
+    bytecode = _jitDecompressor(inputData);
+    calldata = '0x' + _normHex(to).padStart(64, '0');
   } else {
-    const isFlz = selectedMethod === _flz;
-    calldata = isFlz ? flz! : cd!;
-    bytecode = isFlz ? flzFwdBytecode(targetAddress) : rleFwdBytecode(targetAddress);
+    // Need FLZ and/or CD compression
+    const flzData = alg === 'flz' || !alg ? LibZip.flzCompress(inputData) : null;
+    const cdData = alg === 'cd' || (!alg && flzData) ? LibZip.cdCompress(inputData) : null;
+
+    // Pick the best or requested one
+    const useFlz =
+      alg === 'flz' || (!alg && flzData && (!cdData || flzData.length < cdData.length));
+
+    if (useFlz) {
+      calldata = flzData!;
+      bytecode = flzFwdBytecode(to);
+    } else {
+      calldata = cdData!;
+      bytecode = rleFwdBytecode(to);
+    }
   }
 
-  const compressedSize = bytecode.length + calldata.length;
-  if (compressedSize >= originalSize) return payload;
+  // Skip if not beneficial
+  if (bytecode.length + calldata.length >= originalSize) return payload;
 
   return {
     ...payload,
     params: [
-      {
-        ...txObj,
-        to: DECOMPRESSOR_ADDRESS,
-        data: calldata,
-      },
-      blockParam,
-      {
-        ...existingStateOverride,
-        [DECOMPRESSOR_ADDRESS]: { code: bytecode },
-      },
+      { ...txObj, to: DECOMPRESSOR_ADDRESS, data: calldata },
+      blockParam || 'latest',
+      { ...overrides, [DECOMPRESSOR_ADDRESS]: { code: bytecode } },
     ],
   };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eth-compress",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "private": false,
   "type": "module",
   "description": "Client-to-server compression (viem-compatible) module for compressed, gas-efficient, low-latency eth_call requests.",
@@ -99,7 +99,7 @@
     "node": ">=22",
     "pnpm": ">=10"
   },
-  "packageManager": "pnpm@10.22.0",
+  "packageManager": "pnpm@10.23.0",
   "pnpm": {
     "peerDependencyRules": {
       "ignoreMissing": [
@@ -111,16 +111,16 @@
     "solady": "0.1.26"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.3.6",
+    "@biomejs/biome": "2.3.7",
     "@ethereumjs/common": "10.1.0",
     "@ethereumjs/util": "10.1.0",
     "@ethereumjs/vm": "10.1.0",
-    "@types/bun": "1.3.2",
+    "@types/bun": "1.3.3",
     "@types/node": "24.10.1",
     "esbuild": "0.27.0",
     "typescript": "5.9.3",
-    "viem": "2.39.3",
-    "vitest": "4.0.10"
+    "viem": "2.40.2",
+    "vitest": "4.0.14"
   },
   "browserslist": [
     ">0.3%",