eth-compress 0.2.0 → 0.2.2

package/_esm/jit-compressor.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/jit-compressor.ts"],
-  "sourcesContent": ["import { LibZip } from 'solady';\n\nconst MAX_160_BIT = (1n << 160n) - 1n;\n\nconst _normHex = (hex: string): string => hex.replace(/^0x/, '').toLowerCase();\n\nconst _hexToUint8Array = (hex: string): Uint8Array => {\n  const normalized = _normHex(hex);\n  const len = normalized.length;\n  const bytes = new Uint8Array(len / 2);\n  for (let i = 0; i < len; i += 2) {\n    bytes[i / 2] = Number.parseInt(normalized.slice(i, i + 2), 16);\n  }\n  return bytes;\n};\n\nconst _uint8ArrayToHex = (bytes: Uint8Array): string => {\n  let hex = '';\n  for (let i = 0; i < bytes.length; i++) {\n    hex += bytes[i].toString(16).padStart(2, '0');\n  }\n  return hex;\n};\n\n/**\n * Generates FastLZ (LZ77) decompressor bytecode. The generated code decompresses incoming calldata and forwards it to the target address.\n * @param address - Target contract address\n * @see {@link https://github.com/Vectorized/solady/blob/main/src/utils/LibZip.sol}\n * @pure\n */\n//! @__PURE__\nexport const flzFwdBytecode = (address: string): string =>\n  `0x365f73${_normHex(address)}815b838110602f575f80848134865af1503d5f803e3d5ff35b803590815f1a8060051c908115609857600190600783149285831a6007018118840218600201948383011a90601f1660081b0101808603906020811860208211021890815f5b80830151818a015201858110609257505050600201019201916018565b82906075565b6001929350829150019101925f5b82811060b3575001916018565b85851060c1575b60010160a6565b936001818192355f1a878501530194905060ba56`;\n\n/**\n * Generates RLE (run-length encoded) decompressor bytecode. The generated code decompresses incoming calldata and forwards it to the target address.\n * @param address - Target contract address\n * @see {@link https://github.com/Vectorized/solady/blob/main/src/utils/LibZip.sol}\n * @pure\n */\n//! @__PURE__\nexport const rleFwdBytecode = (address: string): string =>\n  `0x5f5f5b368110602d575f8083813473${_normHex(address)}5af1503d5f803e3d5ff35b600180820192909160031981019035185f1a8015604c57815301906002565b505f19815282820192607f9060031981019035185f1a818111156072575b160101906002565b838101368437606a56`;\n\n/**\n * JIT Compiles decompressor bytecode\n * @param calldata - Calldata to compress\n * @pure\n */\n//! @__PURE__\nexport const jitBytecode = function (calldata: string): string {\n  return _jitDecompressor('0x' + _normHex(calldata));\n};\n\nconst _jitDecompressor = function (calldata: string): string {\n  const hex = _normHex(calldata);\n  const originalBuf = _hexToUint8Array(hex);\n\n  // Right\u2011align the 4\u2011byte selector in the first 32\u2011byte slot (offset 28),\n  // so that everything after the selector is reconstructed on mostly\n  // word\u2011aligned boundaries. This keeps the ABI words (and therefore most\n  // calldata reconstruction) 32\u2011byte aligned in memory.\n  // That way we avoid encoding offsets for writes (most of the time),\n  const padding = 28;\n  const buf = new Uint8Array(padding + originalBuf.length);\n  buf.set(originalBuf, padding);\n\n  const n = buf.length;\n\n  let ops: number[] = [];\n  let data: (number[] | null)[] = [];\n  let stack: bigint[] = [];\n  let stackFreq2 = new Map<bigint, number>();\n  let trackedMemSize = 0;\n  let mem = new Map<number, bigint>();\n  const getStackIdx = (val: bigint): number => {\n    const idx = stack.lastIndexOf(val);\n    return idx === -1 ? -1 : stack.length - 1 - idx;\n  };\n\n  const opFreq = new Map<number, number>();\n  const dataFreq = new Map<number[] | null, number>();\n  const stackFreq = new Map<bigint, number>();\n  const wordCache = new Map<string, number>();\n  const wordCacheCost = new Map<string, number>();\n  const roundUp32 = (x: number) => (x + 31) & ~31;\n\n  let pushCounter = 0;\n  const stackCnt = new Map<bigint, number>();\n\n  const pop2 = (): [bigint, bigint] => [stack.pop()!, stack.pop()!];\n  const MASK32 = (1n << 256n) - 1n;\n\n  const bump = <K>(m: Map<K, number>, k: K) => m.set(k, (m.get(k) || 0) + 1);\n  const pushOp = (op: number) => {\n    ops.push(op);\n    bump(opFreq, op);\n  };\n  const pushD = (d: number[] | null) => {\n    data.push(d || null);\n    bump(dataFreq, d || null);\n  };\n  const pushS = (v: bigint) => {\n    stack.push(v);\n    bump(stackFreq, v);\n    bump(stackFreq2, v);\n    ++pushCounter;\n    stackCnt.set(v, pushCounter);\n  };\n\n  const trackMem = (offset: number, size: number) => {\n    trackedMemSize = roundUp32(offset + size);\n  };\n\n  const addOp = (op: number, imm?: number[]) => {\n    if (op === 0x59) {\n      pushS(BigInt(trackedMemSize));\n    } else if (op === 0x1b) {\n      // SHL\n      const [shift, val] = pop2();\n      pushS((val << shift) & MASK32);\n    } else if (op === 0x17) {\n      // OR\n      const [a, b] = pop2();\n      pushS((a | b) & MASK32);\n    } else if ((op >= 0x60 && op <= 0x7f) || op === 0x5f) {\n      // PUSH\n      let v = 0n;\n      for (const b of imm || []) v = (v << 8n) | BigInt(b);\n      const idx = getStackIdx(v);\n      pushS(v);\n      if (idx !== -1 && op != 0x5f) {\n        if (stackFreq2.get(v)! * 2 < stackFreq.get(v)!) {\n          pushOp(128 + idx);\n          pushD(null);\n        }\n        return;\n      }\n      if (v == 224n) {\n        // Special\u2011case the literal 0xe0 (224):\n        // the decompressor is always deployed at 0x...00e0, so the final\n        // byte of ADDRESS is exactly 0xe0. Since we must send our own\n        // address with the eth_call anyway, we can synthesize this value \n        // with a single opcode instead of encoding a literal, effectively\n        // giving us one more hot constant slot on the stack.\n        pushOp(0x30); // ADDRESS\n        pushD(null);\n        return;\n      }\n    } else if (op === 0x51) {\n      // MLOAD\n      const k = Number(stack.pop()!);\n      pushS(mem.has(k) ? mem.get(k)! : 0n);\n    } else if (op === 0x52) {\n      // MSTORE\n      const [offset, value] = pop2();\n      const k = Number(offset);\n      mem.set(k, value & MASK32);\n      trackMem(k, 32);\n    } else if (op === 0x53) {\n      // MSTORE8\n      const [offset, _] = pop2();\n      trackMem(Number(offset), 1);\n    } else if (op === 0xf3) {\n      // RETURN\n      pop2();\n    }\n    pushOp(op);\n    pushD(imm || null);\n  };\n\n  const op = (opcode: number) => addOp(opcode);\n  const pushN = (value: number | bigint) => {\n    if (value > 0 && value === trackedMemSize) return addOp(0x59);\n    if (!value) return addOp(0x5f, undefined); // PUSH0\n    let v = BigInt(value);\n    let bytes: number[] = [];\n    while (v) {\n      bytes.unshift(Number(v & 0xffn));\n      v >>= 8n;\n    }\n    return addOp(0x5f + bytes.length, bytes);\n  };\n  const pushB = (buf: Uint8Array) => addOp(0x5f + buf.length, Array.from(buf));\n  const cntWords = (hex: string, wordHex: string) =>\n    (hex.match(new RegExp(wordHex, 'g')) || []).length;\n\n  // Rough cost model\n  const estShlCost = (seg: Array<{ s: number; e: number }>) => {\n    let cost = 0;\n    let first = true;\n    for (const { s, e } of seg) {\n      cost += 1 + e - s + 1; // PUSH segLen bytes\n      if (31 - e > 0) cost += 1 /* PUSH1 */ + 1 /* shift byte */ + 1 /* SHL */;\n      if (!first) cost += 1; // OR\n      first = false;\n    }\n    return cost;\n  };\n\n  type PlanStep =\n    | { t: 'num'; v: number | bigint }\n    | { t: 'bytes'; b: Uint8Array }\n    | { t: 'op'; o: number };\n\n  const plan: PlanStep[] = [];\n  const emitPushN = (v: number | bigint) => (plan.push({ t: 'num', v }), pushN(v));\n  const emitPushB = (b: Uint8Array) => (plan.push({ t: 'bytes', b }), pushB(b));\n  const emitOp = (o: number) => (plan.push({ t: 'op', o }), op(o));\n\n  // First pass: decide how to build each 32-byte word without emitting bytecode\n  for (let base = 0; base < n; base += 32) {\n    const word = new Uint8Array(32);\n    word.set(buf.slice(base, Math.min(base + 32, n)), 0);\n\n    const seg: Array<{ s: number; e: number }> = [];\n    for (let i = 0; i < 32; ) {\n      while (i < 32 && word[i] === 0) ++i;\n      if (i >= 32) break;\n      const s = i;\n      while (i < 32 && word[i] !== 0) ++i;\n      seg.push({ s, e: i - 1 });\n    }\n\n    if (!seg.length) continue;\n\n    const byte8s = seg.every(({ s, e }) => s === e);\n    if (byte8s) {\n      for (const { s } of seg) {\n        emitPushN(word[s]);\n        emitPushN(base + s);\n        emitOp(0x53); // MSTORE8\n      }\n      continue;\n    }\n\n    // Decide whether to build this word via SHL/OR or as a single literal word\n    const literal = word.slice(seg[0].s);\n    const literalCost = 1 + literal.length;\n\n    const baseBytes = Math.ceil(Math.log2(base + 1) / 8);\n    const wordHex = _uint8ArrayToHex(word);\n    if (literalCost > 8) {\n      if (wordCache.has(wordHex)) {\n        if (literalCost > wordCacheCost.get(wordHex)! + baseBytes) {\n          emitPushN(wordCache.get(wordHex)!);\n          emitOp(0x51);\n          emitPushN(base);\n          emitOp(0x52); // MSTORE\n          continue;\n        }\n      } else if (wordCacheCost.get(wordHex) != -1) {\n        const reuseCost = baseBytes + 3;\n        const freq = cntWords(hex, wordHex);\n        wordCacheCost.set(wordHex, freq * 32 > freq * reuseCost ? reuseCost : -1);\n        wordCache.set(wordHex, base);\n      }\n    }\n\n    if (literalCost <= estShlCost(seg)) {\n      emitPushB(literal);\n    } else {\n      let first = true;\n      for (const { s, e } of seg) {\n        const suffix0s = 31 - e;\n        emitPushB(word.slice(s, e + 1));\n        if (suffix0s > 0) {\n          emitPushN(suffix0s * 8);\n          emitOp(0x1b); // SHL\n        }\n        if (!first) emitOp(0x17); // OR\n        first = false;\n      }\n    }\n    emitPushN(base);\n    emitOp(0x52); // MSTORE\n  }\n\n  ops = [];\n  data = [];\n  stack = [];\n  trackedMemSize = 0;\n  mem = new Map();\n\n  // Pre 2nd pass. Push most frequent literals into stack.\n  Array.from(stackFreq.entries())\n    .filter(([val, freq]) => freq > 1 && val !== 0n && val !== 224n)\n    .filter(([val, _]) => {\n      return typeof val === 'number' ? val : Number(val) <= MAX_160_BIT;\n    })\n    .sort((a, b) => stackCnt.get(b[0])! - stackCnt.get(a[0])!)\n    .slice(0, 14)\n    .forEach(([val, _]) => {\n      pushN(val);\n    });\n\n  stackFreq2 = new Map();\n  // Second pass: emit ops and track mem/stack\n  for (const step of plan) {\n    if (step.t === 'num') pushN(step.v);\n    else if (step.t === 'bytes') pushB(step.b);\n    else if (step.t === 'op') op(step.o);\n  }\n\n  // CALL stack layout (top to bottom): gas, address, value, argsOffset, argsSize, retOffset, retSize\n  //\n  // Opcodes breakdown:\n  // - 0x5f5f: PUSH0 PUSH0 (retSize=0, retOffset=0)\n  // - pushN(originalBuf.length): argsSize = actual data length\n  // - pushN(padding): argsOffset (skip leading alignment bytes)\n  // - 0x34: CALLVALUE (value)\n  // - 0x5f35: PUSH0 CALLDATALOAD (address from calldata[0])\n  // - 0x5a: GAS (remaining gas)\n  // - 0xf1: CALL\n  // - 0x50: POP (discard success value)\n  //\n  // RETURNDATACOPY(destOffset=0, offset=0, length=RETURNDATASIZE):\n  // - 0x3d5f5f3e: RETURNDATASIZE PUSH0 PUSH0 RETURNDATACOPY\n  //\n  // RETURN(offset=0, size=RETURNDATASIZE):\n  // - 0x3d5ff3: RETURNDATASIZE PUSH0 RETURN\n\n  op(0x5f); // PUSH0 (retSize)\n  op(0x5f); // PUSH0 (retOffset)\n  pushN(originalBuf.length); // argsSize = actual data length\n  pushN(padding); // argsOffset = padding\n\n  const out: number[] = [];\n  for (let i = 0; i < ops.length; ++i) {\n    out.push(ops[i]);\n    if (ops[i] >= 0x60 && ops[i] <= 0x7f && data[i]) out.push(...data[i]!);\n  }\n\n  // - CALLVALUE, load target address from calldata[0], GAS, CALL\n  // - RETURNDATACOPY(0, 0, RETURNDATASIZE)\n  // - RETURN(0, RETURNDATASIZE)\n  return '0x' + _uint8ArrayToHex(new Uint8Array(out)) + '345f355af1503d5f5f3e3d5ff3';\n};\n\nconst MIN_SIZE_FOR_COMPRESSION = 800;\nconst DECOMPRESSOR_ADDRESS = '0x00000000000000000000000000000000000000e0';\n\nconst _jit = 'jit';\nconst _flz = 'flz';\nconst _cd = 'cd';\n\n/**\n * Compresses eth_call payload using JIT, FastLZ (FLZ), or calldata RLE (CD) compression.\n * Auto-selects best algorithm if not specified. Only compresses if >800 bytes and beneficial.\n * @param payload - eth_call RPC payload\n * @param alg - 'jit' | 'flz' | 'cd' | undefined (auto)\n * @returns (un)compressed eth_call payload\n * @pure\n */\n//! @__PURE__\nexport const compress_call = function (payload: any, alg?: string): any {\n  const rpcMethod = payload.params?.[0]?.method || payload.method;\n  if (rpcMethod && rpcMethod !== 'eth_call') return payload;\n\n  const hex = _normHex(payload.data || '0x');\n  const originalSize = (payload.data || '0x').length;\n  if (originalSize < MIN_SIZE_FOR_COMPRESSION) return payload;\n\n  const targetAddress = payload.to || '';\n  const data = '0x' + hex;\n\n  const autoSelect = !alg && originalSize < 1150;\n  const flz = alg === _flz || autoSelect ? LibZip.flzCompress(data) : null;\n  const cd = alg === _cd || autoSelect ? LibZip.cdCompress(data) : null;\n\n  const selectedMethod =\n    alg || (originalSize >= 1150 ? _jit : flz!.length < cd!.length ? _flz : _cd);\n\n  let bytecode: string;\n  let calldata: string;\n\n  if (selectedMethod === _jit) {\n    bytecode = _jitDecompressor(data);\n    calldata = '0x' + _normHex(targetAddress).padStart(64, '0');\n  } else {\n    const isFlz = selectedMethod === _flz;\n    calldata = isFlz ? flz! : cd!;\n    bytecode = isFlz ? flzFwdBytecode(targetAddress) : rleFwdBytecode(targetAddress);\n  }\n\n  const compressedSize = bytecode.length + calldata.length;\n  if (compressedSize >= originalSize) return payload;\n\n  return {\n    ...payload,\n    to: DECOMPRESSOR_ADDRESS,\n    data: calldata,\n    stateDiff: {\n      ...(payload.stateDiff || {}),\n      [DECOMPRESSOR_ADDRESS]: { code: bytecode },\n    },\n  };\n};\n"],
-  "mappings": "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",
-  "names": ["LibZip", "MAX_160_BIT", "_normHex", "hex", "_hexToUint8Array", "normalized", "len", "bytes", "i", "_uint8ArrayToHex", "flzFwdBytecode", "address", "rleFwdBytecode", "jitBytecode", "calldata", "_jitDecompressor", "originalBuf", "padding", "buf", "n", "ops", "data", "stack", "stackFreq2", "trackedMemSize", "mem", "getStackIdx", "val", "idx", "opFreq", "dataFreq", "stackFreq", "wordCache", "wordCacheCost", "roundUp32", "x", "pushCounter", "stackCnt", "pop2", "MASK32", "bump", "m", "k", "pushOp", "op", "pushD", "d", "pushS", "v", "trackMem", "offset", "size", "addOp", "imm", "shift", "a", "b", "value", "_", "opcode", "pushN", "pushB", "cntWords", "wordHex", "estShlCost", "seg", "cost", "first", "s", "e", "plan", "emitPushN", "emitPushB", "emitOp", "o", "base", "word", "literal", "literalCost", "baseBytes", "reuseCost", "freq", "suffix0s", "step", "out", "MIN_SIZE_FOR_COMPRESSION", "DECOMPRESSOR_ADDRESS", "_jit", "_flz", "_cd", "compress_call", "payload", "alg", "rpcMethod", "originalSize", "targetAddress", "autoSelect", "flz", "cd", "selectedMethod", "bytecode", "isFlz"]
+  "sourcesContent": ["import { LibZip } from 'solady';\nimport { MIN_BODY_SIZE } from './index';\n\nconst MAX_128_BIT = (1n << 128n) - 1n;\nconst MAX_256_BIT = (1n << 256n) - 1n;\n\nconst _normHex = (hex: string): string => hex.replace(/^0x/, '').toLowerCase();\n\nconst _hexToUint8Array = (hex: string): Uint8Array => {\n  const normalized = _normHex(hex);\n  const len = normalized.length;\n  const bytes = new Uint8Array(len / 2);\n  for (let i = 0; i < len; i += 2) {\n    bytes[i / 2] = Number.parseInt(normalized.slice(i, i + 2), 16);\n  }\n  return bytes;\n};\n\nconst _uint8ArrayToHex = (bytes: Uint8Array): string => {\n  let hex = '';\n  for (let i = 0; i < bytes.length; i++) {\n    hex += bytes[i].toString(16).padStart(2, '0');\n  }\n  return hex;\n};\n\nconst not = (a: bigint): bigint => ~a & MAX_256_BIT;\nconst and = (a: bigint, b: bigint): bigint => a & b & MAX_256_BIT;\nconst or = (a: bigint, b: bigint): bigint => (a | b) & MAX_256_BIT;\nconst xor = (a: bigint, b: bigint): bigint => (a ^ b) & MAX_256_BIT;\nconst shl = (shift: bigint, value: bigint): bigint => (value << shift) & MAX_256_BIT;\nconst shr = (shift: bigint, value: bigint): bigint => (value >> shift) & MAX_256_BIT;\nconst sub = (a: bigint, b: bigint): bigint => (a - b) & MAX_256_BIT;\nconst sigext = (byteSize: bigint, value: bigint): bigint => {\n  const numBytes = Number(byteSize) + 1;\n  const mask = (1n << BigInt(numBytes * 8)) - 1n;\n  const signBit = 1n << BigInt(numBytes * 8 - 1);\n  const maskedVal = value & mask;\n  const extended = maskedVal & signBit ? maskedVal | (~mask & MAX_256_BIT) : maskedVal;\n  return extended & MAX_256_BIT;\n};\n\n/**\n * Generates FastLZ (LZ77) decompressor bytecode. The generated code decompresses incoming calldata and forwards it to the target address.\n * @param address - Target contract address\n * @see {@link https://github.com/Vectorized/solady/blob/main/src/utils/LibZip.sol}\n * @pure\n */\n//! @__PURE__\nconst flzFwdBytecode = (address: string): string =>\n  `0x365f73${_normHex(address)}815b838110602f575f80848134865af1503d5f803e3d5ff35b803590815f1a8060051c908115609857600190600783149285831a6007018118840218600201948383011a90601f1660081b0101808603906020811860208211021890815f5b80830151818a015201858110609257505050600201019201916018565b82906075565b6001929350829150019101925f5b82811060b3575001916018565b85851060c1575b60010160a6565b936001818192355f1a878501530194905060ba56`;\n\n/**\n * Generates RLE (run-length encoded) decompressor bytecode. The generated code decompresses incoming calldata and forwards it to the target address.\n * @param address - Target contract address\n * @see {@link https://github.com/Vectorized/solady/blob/main/src/utils/LibZip.sol}\n * @pure\n */\n//! @__PURE__\nconst rleFwdBytecode = (address: string): string =>\n  `0x5f5f5b368110602d575f8083813473${_normHex(address)}5af1503d5f803e3d5ff35b600180820192909160031981019035185f1a8015604c57815301906002565b505f19815282820192607f9060031981019035185f1a818111156072575b160101906002565b838101368437606a56`;\n\nconst _jitDecompressor = function (calldata: string): string {\n  const hex = _normHex(calldata);\n  const originalBuf = _hexToUint8Array(hex);\n\n  // Right\u2011align the 4\u2011byte selector in the first 32\u2011byte slot (offset 28),\n  // so that everything after the selector is reconstructed on mostly\n  // word\u2011aligned boundaries. This keeps the ABI words (and therefore most\n  // calldata reconstruction) 32\u2011byte aligned in memory.\n  // That way we avoid encoding offsets for writes (most of the time),\n  const padding = 28;\n  const buf = new Uint8Array(padding + originalBuf.length);\n  buf.set(originalBuf, padding);\n\n  const n = buf.length;\n\n  let ops: number[] = [];\n  let data: (number[] | null)[] = [];\n  let stack: bigint[] = [];\n  let trackedMemSize = 0;\n  let mem = new Map<number, bigint>();\n  let firstPass = true;\n  const getStackIdx = (val: bigint): number => {\n    let idx = stack.lastIndexOf(val);\n    idx = idx === -1 ? -1 : stack.length - 1 - idx;\n    return idx > 15 ? -1 : idx;\n  };\n\n  const opFreq = new Map<number, number>();\n  const dataFreq = new Map<number[] | null, number>();\n  const stackFreq = new Map<bigint, number>();\n  const wordCache = new Map<string, number>();\n  const wordCacheCost = new Map<string, number>();\n  const roundUp32 = (x: number) => (x + 31) & ~31;\n\n  let pushCounter = 0;\n  const stackCnt = new Map<bigint, number>();\n  const pop2 = (): [bigint, bigint] => [stack.pop()!, stack.pop()!];\n  const ctr = <K>(m: Map<K, number>, k: K, delta: number) => m.set(k, (m.get(k) || 0) + delta);\n  const inc = <K>(m: Map<K, number>, k: K) => ctr(m, k, 1);\n  const pushOp = (op: number, d?: number[] | null) => {\n    ops.push(op);\n    inc(opFreq, op);\n    const imm = d ?? null;\n    data.push(imm);\n    inc(dataFreq, imm);\n  };\n  const pushS = (v: bigint, freq: number = 1) => {\n    stack.push(v);\n    ctr(stackFreq, v, freq);\n    ++pushCounter;\n    stackCnt.set(v, pushCounter);\n  };\n\n  const trackMem = (offset: number, size: number) => {\n    trackedMemSize = roundUp32(offset + size);\n  };\n\n  const addOp = (op: number, imm?: number[]) => {\n    if (op === 0x36) {\n      pushS(32n, 0);\n    } else if (op === 0x59) {\n      pushS(BigInt(trackedMemSize), 0);\n    } else if (op === 0x0b) {\n      // SIGNEXTEND\n      const [byteSize, val] = pop2();\n      pushS(sigext(byteSize, val), 1);\n    } else if (op === 0x19) {\n      // NOT\n      const val = stack.pop()!;\n      pushS(not(val), 0);\n    } else if (op === 0x18) {\n      // XOR\n      const [a, b] = pop2();\n      pushS(xor(a, b), 1);\n    } else if (op === 0x16) {\n      // AND\n      const [a, b] = pop2();\n      pushS(and(a, b), 1);\n    } else if (op === 0x03) {\n      // SUB\n      const [a, b] = pop2();\n      pushS(sub(a, b), 1);\n    } else if (op === 0x1b) {\n      // SHL\n      let [shift, val] = pop2();\n      pushS(shl(shift, val), 1);\n    } else if (op === 0x1c) {\n      // SHR\n      let [shift, val] = pop2();\n      pushS(shr(shift, val), 1);\n    } else if (op === 0x17) {\n      // OR\n      let [a, b] = pop2();\n      pushS(or(a, b), 1);\n    } else if ((op >= 0x60 && op <= 0x7f) || op === 0x5f) {\n      // PUSH\n      let v = 0n;\n      for (const b of imm || []) v = (v << 8n) | BigInt(b);\n      if (v == 224n) {\n        pushS(v, 0);\n        pushOp(0x30); // ADDRESS\n        return;\n      }\n      if (v == 32n) {\n        pushS(v, 0);\n        pushOp(0x36); // ADDRESS\n        return;\n      }\n      if (v === BigInt(trackedMemSize)) {\n        pushS(v, 0);\n        pushOp(0x59); // MemSize\n        return;\n      }\n      const idx = getStackIdx(v);\n      if (idx !== -1 && op != 0x5f) {\n        let pushCtr = firstPass ? 1 : -1;\n        pushS(v, pushCtr);\n        pushOp(128 + idx);\n        return;\n      }\n      if (v == MAX_256_BIT) {\n        pushS(v);\n        pushOp(0x5f); // 0\n        pushOp(0x19); // NOT\n        return;\n      }\n      pushS(v);\n    } else if (op === 0x51) {\n      // MLOAD\n      const k = Number(stack.pop()!);\n      pushS(mem.has(k) ? mem.get(k)! : 0n);\n    } else if (op === 0x52) {\n      // MSTORE\n      const [offset, value] = pop2();\n      const k = Number(offset);\n      mem.set(k, value & MAX_256_BIT);\n      trackMem(k, 32);\n    } else if (op === 0x53) {\n      // MSTORE8\n      const [offset, _] = pop2();\n      trackMem(Number(offset), 1);\n    } else if (op === 0xf3) {\n      // RETURN\n      pop2();\n    }\n    pushOp(op, imm || null);\n  };\n  const op = (opcode: number) => addOp(opcode);\n  const pushN = (value: number | bigint) => {\n    if (value > 0 && value === trackedMemSize) return addOp(0x59);\n    if (value == 32n) return addOp(0x36);\n    if (!value) return addOp(0x5f, undefined); // PUSH0\n    let v = BigInt(value);\n    let bytes: number[] = [];\n    while (v) {\n      bytes.unshift(Number(v & 0xffn));\n      v >>= 8n;\n    }\n    return addOp(0x5f + bytes.length, bytes);\n  };\n  const pushB = (buf: Uint8Array) => addOp(0x5f + buf.length, Array.from(buf));\n  const cntWords = (hex: string, wordHex: string) =>\n    (hex.match(new RegExp(wordHex, 'g')) || []).length;\n\n  // Rough cost model\n  const estShlCost = (seg: Array<{ s: number; e: number }>) => {\n    let cost = 0;\n    let first = true;\n    for (const { s, e } of seg) {\n      cost += 1 + e - s + 1; // PUSH segLen bytes\n      if (31 - e > 0) cost += 1 /* PUSH1 */ + 1 /* shift byte */ + 1 /* SHL */;\n      if (!first) cost += 1; // OR\n      first = false;\n    }\n    return cost;\n  };\n\n  type PlanStep =\n    | { t: 'num'; v: number | bigint }\n    | { t: 'bytes'; b: Uint8Array }\n    | { t: 'op'; o: number };\n\n  const plan: PlanStep[] = [];\n  const emitPushN = (v: number | bigint) => (plan.push({ t: 'num', v }), pushN(v));\n  const emitPushB = (b: Uint8Array) => (plan.push({ t: 'bytes', b }), pushB(b));\n  const emitOp = (o: number) => (plan.push({ t: 'op', o }), op(o));\n  pushN(1n);\n  // First pass: decide how to build each 32-byte word without emitting bytecode\n  const _stack = [1n, 32n, 224n];\n  for (let base = 0; base < n; base += 32) {\n    const word = new Uint8Array(32);\n    word.set(buf.slice(base, Math.min(base + 32, n)), 0);\n\n    const seg: Array<{ s: number; e: number }> = [];\n    for (let i = 0; i < 32; ) {\n      while (i < 32 && word[i] === 0) ++i;\n      if (i >= 32) break;\n      const s = i;\n      while (i < 32 && word[i] !== 0) ++i;\n      seg.push({ s, e: i - 1 });\n    }\n\n    if (!seg.length) continue;\n\n    // Decide whether to build this word via SHL/OR or as a single literal word\n    const literal = word.slice(seg[0].s);\n    const literalCost = 1 + literal.length;\n    let literalVal = 0n;\n    for (const b of literal) literalVal = (literalVal << 8n) | BigInt(b);\n    const baseBytes = Math.ceil(Math.log2(base + 1) / 8);\n    const wordHex = _uint8ArrayToHex(word);\n    const shlCost = estShlCost(seg);\n\n    const inStack = _stack.includes(literalVal);\n    if (inStack) {\n      emitPushB(literal);\n      emitPushN(base);\n      emitOp(0x52); // MSTORE\n      continue;\n    }\n    if (literalCost > 8) {\n      if (wordCache.has(wordHex)) {\n        if (literalCost > wordCacheCost.get(wordHex)! + baseBytes) {\n          emitPushN(wordCache.get(wordHex)!);\n          emitOp(0x51);\n          emitPushN(base);\n          emitOp(0x52); // MSTORE\n          continue;\n        }\n      } else if (wordCacheCost.get(wordHex) != -1) {\n        const reuseCost = baseBytes + 3;\n        const freq = cntWords(hex, wordHex);\n        wordCacheCost.set(wordHex, freq * 32 > freq * reuseCost ? reuseCost : -1);\n        wordCache.set(wordHex, base);\n      }\n    }\n\n    const byte8s = seg.every(({ s, e }) => s === e);\n    const byte8sCost = seg.length * 3; // each: PUSH1 (value), PUSH1 (offset), MSTORE8\n    if (inStack) {\n      emitPushB(literal);\n    } else {\n      // Aggregate all costs\n      let bestCost = literalCost;\n      let bestEmit: (() => void) | null = () => {\n        emitPushB(literal);\n      };\n      if (literalVal == MAX_256_BIT) {\n        bestCost = 2;\n        bestEmit = () => {\n          emitPushN(notVal);\n          emitOp(0x19);\n        };\n      }\n      // Try NOT: PUSH<n> ~val, NOT\n      const notVal = not(literalVal);\n      let notBytes = 0;\n      let tmp = notVal;\n      while (tmp > 0n) {\n        ++notBytes;\n        tmp >>= 8n;\n      }\n      notBytes = 1 + notBytes;\n      if (notBytes === 0) notBytes;\n      const notCost = notBytes + 1; // PUSH<n> + NOT\n      if (notCost < bestCost) {\n        bestCost = notCost;\n        bestEmit = () => {\n          emitPushN(notVal);\n          emitOp(0x19);\n        };\n      }\n\n      // Try SUB: PUSH1 0, PUSH<n> val, SUB\n      const subVal = sub(0n, literalVal);\n      let subBytes = 0;\n      tmp = subVal;\n      while (tmp > 0n) {\n        ++subBytes;\n        tmp >>= 8n;\n      }\n      if (subBytes === 0) subBytes = 1;\n      if (_stack.includes(subVal)) subBytes = 1;\n      const subCost = 1 + (1 + subBytes) + 1; // PUSH0 + PUSH<n> + SUB\n      if (subCost < bestCost) {\n        bestCost = subCost;\n        bestEmit = () => {\n          emitPushN(0);\n          emitPushN(subVal);\n          emitOp(0x03);\n        };\n      }\n\n      // Try SIGNEXTEND: PUSH<n> truncated, PUSH1 byteSize, SIGNEXTEND\n      for (let numBytes = 1; numBytes < literal.length; numBytes++) {\n        const mask = (1n << BigInt(numBytes * 8)) - 1n;\n        const truncated = literalVal & mask;\n        const extended = sigext(BigInt(numBytes - 1), truncated);\n        if (extended === literalVal && (truncated & (1n << BigInt(numBytes * 8 - 1))) !== 0n) {\n          let trueByteCost = 1 + numBytes;\n          if (_stack.includes(BigInt(extended))) trueByteCost = 1;\n          let signCost = trueByteCost + (1 + 1) + 1; // PUSH<n> + PUSH1 + SIGNEXTEND\n          if (signCost < bestCost) {\n            bestCost = signCost;\n            bestEmit = () => {\n              emitPushN(truncated);\n              emitPushN(numBytes - 1);\n              emitOp(0x0b);\n            };\n          }\n          break;\n        }\n      }\n\n      // Try SHIFT+NOT: PUSH<n> val, PUSH1 shift, SHL, NOT\n      for (let shiftBits = 8; shiftBits <= 248; shiftBits += 8) {\n        const shifted = shr(BigInt(shiftBits), literalVal);\n        if (shifted === 0n) break;\n\n        const notShifted = not(shifted);\n        const reconstructed = shl(BigInt(shiftBits), notShifted);\n\n        if (reconstructed === literalVal) {\n          let shiftedBytes = 0;\n          let tmpShifted = notShifted;\n          while (tmpShifted > 0n) {\n            ++shiftedBytes;\n            tmpShifted >>= 8n;\n          }\n          if (shiftedBytes === 0) shiftedBytes = 1;\n          const shiftNotCost = 1 + shiftedBytes + 2 + 1 + 1; // PUSH<n> + PUSH1 + SHL + NOT\n          if (shiftNotCost < bestCost) {\n            bestCost = shiftNotCost;\n            bestEmit = () => {\n              emitPushN(notShifted);\n              emitPushN(shiftBits);\n              emitOp(0x1b); // SHL\n              emitOp(0x19); // NOT\n            };\n          }\n        }\n      }\n\n      if (byte8s && byte8sCost < bestCost && byte8sCost <= shlCost) {\n        for (const { s } of seg) {\n          emitPushN(word[s]);\n          emitPushN(base + s);\n          emitOp(0x53); // MSTORE8\n        }\n        continue; // Skip the single MSTORE at the end\n      } else if (shlCost < bestCost) {\n        // Use SHL/OR\n        let first = true;\n        for (const { s, e } of seg) {\n          const suffix0s = 31 - e;\n          emitPushB(word.slice(s, e + 1));\n          if (suffix0s > 0) {\n            emitPushN(suffix0s * 8);\n            emitOp(0x1b); // SHL\n          }\n          if (!first) emitOp(0x17); // OR\n          first = false;\n        }\n      } else {\n        bestEmit!();\n      }\n    }\n    emitPushN(base);\n    emitOp(0x52); // MSTORE\n  }\n\n  ops = [];\n  data = [];\n  stack = [];\n  trackedMemSize = 0;\n  mem = new Map();\n  // Pre 2nd pass. Push most frequent literals into stack.\n  Array.from(stackFreq.entries())\n    .filter(([val, freq]) => freq > 1 && val > 1n && val !== 32n && val !== 224n)\n    .sort((a, b) => stackCnt.get(b[0])! - stackCnt.get(a[0])!)\n    .filter(([val, _]) => {\n      return typeof val === 'number' ? BigInt(val) : val <= MAX_128_BIT;\n    })\n    .slice(0, 15)\n    .forEach(([val, _]) => {\n      pushN(val);\n    });\n  pushN(1n);\n  // Second pass: emit ops and track mem/stack\n  for (const step of plan) {\n    if (step.t === 'num') pushN(step.v);\n    else if (step.t === 'bytes') pushB(step.b);\n    else if (step.t === 'op') op(step.o);\n  }\n\n  // CALL stack layout (top to bottom): gas, address, value, argsOffset, argsSize, retOffset, retSize\n  //\n  // Opcodes breakdown:\n  // - 0x5f5f: PUSH0 PUSH0 (retSize=0, retOffset=0)\n  // - pushN(originalBuf.length): argsSize = actual data length\n  // - pushN(padding): argsOffset (skip leading alignment bytes)\n  // - 0x34: CALLVALUE (value)\n  // - 0x5f35: PUSH0 CALLDATALOAD (address from calldata[0])\n  // - 0x5a: GAS (remaining gas)\n  // - 0xf1: CALL\n  //\n  // RETURNDATACOPY(destOffset=0, offset=0, length=RETURNDATASIZE):\n  // - 0x3d5f5f3e: RETURNDATASIZE PUSH0 PUSH0 RETURNDATACOPY\n  //\n  // RETURN(offset=0, size=RETURNDATASIZE):\n  // - 0x3d5ff3: RETURNDATASIZE PUSH0 RETURN\n\n  op(0x5f); // PUSH0 (retSize)\n  op(0x5f); // PUSH0 (retOffset)\n  pushN(originalBuf.length); // argsSize = actual data length\n  pushN(padding); // argsOffset = padding\n\n  const out: number[] = [];\n  for (let i = 0; i < ops.length; ++i) {\n    out.push(ops[i]);\n    if (ops[i] >= 0x60 && ops[i] <= 0x7f && data[i]) out.push(...data[i]!);\n  }\n\n  // - CALLVALUE, load target address from calldata[0], GAS, CALL\n  // - RETURNDATACOPY(0, 0, RETURNDATASIZE)\n  // - RETURN(0, RETURNDATASIZE)\n  return '0x' + _uint8ArrayToHex(new Uint8Array(out)) + '345f355af13d5f5f3e3d5ff3';\n};\n\nconst DECOMPRESSOR_ADDRESS = '0x00000000000000000000000000000000000000e0';\n\n/**\n * Compresses eth_call payload using JIT, FastLZ (FLZ), or calldata RLE (CD) compression.\n * Auto-selects best algorithm if not specified. Only compresses if >800 bytes and beneficial.\n *\n * Only applies compression to calls that:\n * - target the latest block ID\n * - have no state overrides\n * - have a target address and calldata\n * - have no other properties (nonce, gas, etc.)\n *\n * @param payload - eth_call RPC payload\n * @param alg - 'jit' | 'flz' | 'cd' | undefined (auto)\n * @returns (un)compressed eth_call payload\n * @pure\n */\n//! @__PURE__\nexport const compress_call = function (payload: any, alg?: string): any {\n  const { method, params } = payload;\n  if (method && method !== 'eth_call') return payload;\n  const txObj = params?.[0] || payload;\n  const blockParam = params?.[1];\n  const overrides = params?.[2];\n\n  // Validation\n  if (\n    (blockParam && blockParam !== 'latest') ||\n    (overrides && Object.keys(overrides).length > 0) ||\n    !txObj?.to ||\n    !txObj?.data ||\n    Object.keys(txObj).some((k) => !['to', 'data', 'from'].includes(k))\n  ) {\n    return payload;\n  }\n\n  const originalSize = txObj.data.length;\n  if (originalSize < MIN_BODY_SIZE) return payload;\n\n  const inputData = '0x' + _normHex(txObj.data);\n  const to = txObj.to;\n\n  // Determine compression method and generate bytecode/calldata\n  let bytecode: string;\n  let calldata: string;\n\n  if (alg === 'jit' || (!alg && (originalSize < 3000 || originalSize >= 8000))) {\n    bytecode = _jitDecompressor(inputData);\n    calldata = '0x' + _normHex(to).padStart(64, '0');\n  } else {\n    // Need FLZ and/or CD compression\n    const flzData = alg === 'flz' || !alg ? LibZip.flzCompress(inputData) : null;\n    const cdData = alg === 'cd' || (!alg && flzData) ? LibZip.cdCompress(inputData) : null;\n\n    // Pick the best or requested one\n    const useFlz =\n      alg === 'flz' || (!alg && flzData && (!cdData || flzData.length < cdData.length));\n\n    if (useFlz) {\n      calldata = flzData!;\n      bytecode = flzFwdBytecode(to);\n    } else {\n      calldata = cdData!;\n      bytecode = rleFwdBytecode(to);\n    }\n  }\n\n  // Skip if not beneficial\n  if (bytecode.length + calldata.length >= originalSize) return payload;\n\n  return {\n    ...payload,\n    params: [\n      { ...txObj, to: DECOMPRESSOR_ADDRESS, data: calldata },\n      blockParam || 'latest',\n      { ...overrides, [DECOMPRESSOR_ADDRESS]: { code: bytecode } },\n    ],\n  };\n};\n"],
+  "mappings": "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",
+  "names": ["LibZip", "MIN_BODY_SIZE", "MAX_128_BIT", "MAX_256_BIT", "_normHex", "hex", "_hexToUint8Array", "normalized", "len", "bytes", "i", "_uint8ArrayToHex", "not", "a", "and", "b", "or", "xor", "shl", "shift", "value", "shr", "sub", "sigext", "byteSize", "numBytes", "mask", "signBit", "maskedVal", "flzFwdBytecode", "address", "rleFwdBytecode", "_jitDecompressor", "calldata", "originalBuf", "padding", "buf", "n", "ops", "data", "stack", "trackedMemSize", "mem", "firstPass", "getStackIdx", "val", "idx", "opFreq", "dataFreq", "stackFreq", "wordCache", "wordCacheCost", "roundUp32", "x", "pushCounter", "stackCnt", "pop2", "ctr", "m", "k", "delta", "inc", "pushOp", "op", "d", "imm", "pushS", "v", "freq", "trackMem", "offset", "size", "addOp", "_", "opcode", "pushN", "pushB", "cntWords", "wordHex", "estShlCost", "seg", "cost", "first", "s", "e", "plan", "emitPushN", "emitPushB", "emitOp", "o", "_stack", "base", "word", "literal", "literalCost", "literalVal", "baseBytes", "shlCost", "inStack", "reuseCost", "byte8s", "byte8sCost", "bestCost", "bestEmit", "notVal", "notBytes", "tmp", "notCost", "subVal", "subBytes", "subCost", "truncated", "extended", "trueByteCost", "signCost", "shiftBits", "shifted", "notShifted", "shiftedBytes", "tmpShifted", "shiftNotCost", "suffix0s", "step", "out", "DECOMPRESSOR_ADDRESS", "compress_call", "payload", "alg", "method", "params", "txObj", "blockParam", "overrides", "originalSize", "inputData", "to", "bytecode", "flzData", "cdData"]
 }

package/_types/index.d.ts

@@ -1,3 +1,4 @@
+export declare const MIN_BODY_SIZE = 1150;
 export type PayloadTransform = (payload: unknown) => unknown;
 /**
  * Fetch-compatible function that applies HTTP compression (gzip/deflate) to requests.

package/_types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC;AAE7D;;;;;;;;GAQG;AAEH,wBAAsB,cAAc,CAClC,KAAK,EAAE,MAAM,GAAG,GAAG,GAAG,OAAO,EAC7B,IAAI,CAAC,EAAE,WAAW,GACjB,OAAO,CAAC,QAAQ,CAAC,CAAC;AAGrB,wBAAsB,cAAc,CAClC,KAAK,EAAE,MAAM,GAAG,GAAG,GAAG,OAAO,EAC7B,IAAI,EAAE,WAAW,GAAG,SAAS,EAC7B,gBAAgB,CAAC,EAAE,gBAAgB,GAClC,OAAO,CAAC,QAAQ,CAAC,CAAC;AA0DrB;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,eAAO,MAAM,qBAAqB,GAChC,OAAO,WAAW,GAAG,GAAG,EACxB,OAAO,WAAW,KACjB,OAAO,CAAC,QAAQ,CAIlB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,OAAO,CAAC;AAMlC,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC;AAE7D;;;;;;;;GAQG;AAEH,wBAAsB,cAAc,CAClC,KAAK,EAAE,MAAM,GAAG,GAAG,GAAG,OAAO,EAC7B,IAAI,CAAC,EAAE,WAAW,GACjB,OAAO,CAAC,QAAQ,CAAC,CAAC;AAGrB,wBAAsB,cAAc,CAClC,KAAK,EAAE,MAAM,GAAG,GAAG,GAAG,OAAO,EAC7B,IAAI,EAAE,WAAW,GAAG,SAAS,EAC7B,gBAAgB,CAAC,EAAE,gBAAgB,GAClC,OAAO,CAAC,QAAQ,CAAC,CAAC;AA4DrB;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,eAAO,MAAM,qBAAqB,GAChC,OAAO,WAAW,GAAG,GAAG,EACxB,OAAO,WAAW,KACjB,OAAO,CAAC,QAAQ,CAIlB,CAAC"}

package/_types/jit-compressor.d.ts

@@ -1,26 +1,13 @@
-/**
- * Generates FastLZ (LZ77) decompressor bytecode. The generated code decompresses incoming calldata and forwards it to the target address.
- * @param address - Target contract address
- * @see {@link https://github.com/Vectorized/solady/blob/main/src/utils/LibZip.sol}
- * @pure
- */
-export declare const flzFwdBytecode: (address: string) => string;
-/**
- * Generates RLE (run-length encoded) decompressor bytecode. The generated code decompresses incoming calldata and forwards it to the target address.
- * @param address - Target contract address
- * @see {@link https://github.com/Vectorized/solady/blob/main/src/utils/LibZip.sol}
- * @pure
- */
-export declare const rleFwdBytecode: (address: string) => string;
-/**
- * JIT Compiles decompressor bytecode
- * @param calldata - Calldata to compress
- * @pure
- */
-export declare const jitBytecode: (calldata: string) => string;
 /**
  * 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

package/_types/jit-compressor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"jit-compressor.d.ts","sourceRoot":"","sources":["../../src/jit-compressor.ts"],"names":[],"mappings":"AAwBA;;;;;GAKG;AAEH,eAAO,MAAM,cAAc,GAAI,SAAS,MAAM,KAAG,MAC6W,CAAC;AAE/Z;;;;;GAKG;AAEH,eAAO,MAAM,cAAc,GAAI,SAAS,MAAM,KAAG,MACyL,CAAC;AAE3O;;;;GAIG;AAEH,eAAO,MAAM,WAAW,GAAa,UAAU,MAAM,KAAG,MAEvD,CAAC;AAsSF;;;;;;;GAOG;AAEH,eAAO,MAAM,aAAa,GAAa,SAAS,GAAG,EAAE,MAAM,MAAM,KAAG,GA0CnE,CAAC"}
+{"version":3,"file":"jit-compressor.d.ts","sourceRoot":"","sources":["../../src/jit-compressor.ts"],"names":[],"mappings":"AA6eA;;;;;;;;;;;;;;GAcG;AAEH,eAAO,MAAM,aAAa,GAAa,SAAS,GAAG,EAAE,MAAM,MAAM,KAAG,GA4DnE,CAAC"}

package/index.node.ts

@@ -1,6 +1,6 @@
 import zlib from 'node:zlib';
 
-// Polyfill for CompressionStream/DecompressionStream in Node.js
+// Polyfill for CompressionStream/DecompressionStream in older versions of Node.js & Bun
 const make = (ctx: any, handle: any) =>
   Object.assign(ctx, {
     writable: new WritableStream({

package/index.ts

@@ -1,3 +1,5 @@
+export const MIN_BODY_SIZE = 1150;
+
 const _sup_enc = new Map<string, string[] | -1>();
 const _enc = ['deflate-raw', 'deflate', 'gzip'];
 let supported: string | -1 | null = typeof CompressionStream === 'undefined' ? -1 : null;
@@ -57,9 +59,11 @@ export async function compressModule(
     }
   }
 
-  if (supported && supported !== -1 && init?.body) {
+  const bodyStr = typeof init?.body === 'string' ? (init.body as string) : null;
+
+  if (supported && supported !== -1 && bodyStr && bodyStr.length >= MIN_BODY_SIZE) {
     const compressed = await new Response(
-      new Blob([init.body as string])
+      new Blob([bodyStr])
         .stream()
         .pipeThrough(new CompressionStream(supported as CompressionFormat)),
     ).blob();