eth-compress 0.2.1 → 0.3.0

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 << 128n) - 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 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 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 dec = <K>(m: Map<K, number>, k: K) => ctr(m, k, -1);\n  const pushOp = (op: number) => {\n    ops.push(op);\n    inc(opFreq, op);\n  };\n  const pushD = (d: number[] | null) => {\n    data.push(d || null);\n    inc(dataFreq, d || null);\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 === 0x1b) {\n      let [shift, val] = pop2();\n      if (ops[ops.length - 1] == 144) {\n        ops.pop();\n        data.pop();\n        [shift, val] = [val, shift];\n      }\n      pushS((val << BigInt(shift)) & MASK32);\n    } else if (op === 0x17) {\n      // OR\n      const [a, b] = pop2();\n      if (ops[ops.length - 1] == 144) {\n        ops.pop();\n        data.pop();\n      }\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      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        pushS(v);\n        pushOp(0x30); // ADDRESS\n        pushD(null);\n        return;\n      }\n      const idx = getStackIdx(v);\n      if (idx !== -1 && op != 0x5f) {\n        const last = stackFreq.get(v) == 0;\n        if (idx == 0 && last) {\n          dec(stackFreq, v);\n          return;\n        }\n        if (idx == 1 && last) {\n          pushOp(144);\n          const [a, b] = pop2();\n          stack.push(b);\n          stack.push(a);\n          pushD(null);\n          dec(stackFreq, v);\n          return;\n        }\n        pushS(v, -1);\n        pushOp(128 + idx);\n        pushD(null);\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 & 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  const isInStack = (w) => stack.includes(w) || w == 0xe0 || w == 32n;\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  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    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    // Convert literal bytes to bigint for stack comparison\n\n    const byte8s = seg.every(({ s, e }) => s === e);\n    if (isInStack(literal)) {\n      emitPushB(literal);\n    } else if (byte8s) {\n      for (const { s } of seg) {\n        emitPushN(word[s]);\n        emitPushN(base + s);\n        emitOp(0x53); // MSTORE8\n      }\n      continue;\n    } else 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  // 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_160_BIT;\n    })\n    .slice(0, 13)\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 MIN_SIZE_FOR_COMPRESSION = 1150;\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  // Extract data and target address from params[0] if available, otherwise top-level\n  const txObj = payload.params?.[0] || payload;\n  const blockParam = payload.params?.[1] || 'latest';\n  const existingStateOverride = payload.params?.[2] || {};\n\n  // If there are any existing state overrides for the decompressor address, do not compress\n  const hex = _normHex(txObj.data || '0x');\n  const originalSize = (txObj.data || '0x').length;\n  if (originalSize < MIN_SIZE_FOR_COMPRESSION || (existingStateOverride[DECOMPRESSOR_ADDRESS])) return payload;\n\n  const targetAddress = txObj.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  let selectedMethod = alg;\n  if (!selectedMethod) {\n    selectedMethod =\n      originalSize >= 1150 && (originalSize < 3000 || originalSize >= 8000)\n        ? _jit\n        : originalSize >= 3000 && originalSize < 8000\n          ? flz!.length < cd!.length\n            ? _flz\n            : _cd\n          : _cd;\n  }\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    params: [\n      {\n        ...txObj,\n        to: DECOMPRESSOR_ADDRESS,\n        data: calldata,\n      },\n      blockParam,\n      {\n        ...existingStateOverride,\n        [DECOMPRESSOR_ADDRESS]: { code: bytecode },\n      },\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", "trackedMemSize", "mem", "getStackIdx", "val", "idx", "opFreq", "dataFreq", "stackFreq", "wordCache", "wordCacheCost", "roundUp32", "x", "pushCounter", "stackCnt", "pop2", "MASK32", "ctr", "m", "k", "delta", "inc", "dec", "pushOp", "op", "pushD", "d", "pushS", "v", "freq", "trackMem", "offset", "size", "addOp", "imm", "shift", "a", "b", "last", "value", "_", "isInStack", "w", "opcode", "pushN", "pushB", "cntWords", "wordHex", "estShlCost", "seg", "cost", "first", "s", "e", "plan", "emitPushN", "emitPushB", "emitOp", "o", "base", "word", "literal", "literalCost", "literalVal", "baseBytes", "reuseCost", "byte8s", "suffix0s", "step", "out", "MIN_SIZE_FOR_COMPRESSION", "DECOMPRESSOR_ADDRESS", "_jit", "_flz", "_cd", "compress_call", "payload", "alg", "rpcMethod", "txObj", "blockParam", "existingStateOverride", "originalSize", "targetAddress", "autoSelect", "flz", "cd", "selectedMethod", "bytecode", "isFlz"]
+  "sources": ["../../src/jit-compressor.ts", "../../src/compiler/constants.ts", "../../src/compiler/opcodes.ts", "../../src/compiler/utils.ts", "../../src/compiler/jit.ts", "../../src/contracts.ts"],
+  "sourcesContent": ["import { LibZip } from 'solady';\nimport { _jitDecompressor } from './compiler';\nimport { _normHex } from './compiler/utils';\nimport { flzFwdBytecode, rleFwdBytecode } from './contracts';\nimport { MIN_BODY_SIZE } from './index';\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 * - 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    (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  const from = txObj.from;\n\n  let bytecode: string;\n  let calldata: string;\n  let decompressorAddress: string;\n  let fromAddr: string | undefined;\n  let balanceHex: string;\n\n  if (alg === 'jit' || (!alg && (originalSize < 3000 || originalSize >= 8000))) {\n    const result = _jitDecompressor(inputData, to, from);\n    bytecode = result.bytecode;\n    calldata = result.calldata;\n    decompressorAddress = result.to;\n    fromAddr = result.from;\n    balanceHex = result.balance;\n  } else {\n    const jit = !alg ? _jitDecompressor(inputData, to, from) : null;\n    const flzData = alg === 'flz' || !alg ? LibZip.flzCompress(inputData) : null;\n    const cdData = alg === 'cd' || (!alg && flzData) ? LibZip.cdCompress(inputData) : null;\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    decompressorAddress = '0x' + 224n.toString(16).padStart(40, '0');\n    fromAddr = from ? _normHex(from).padStart(16, '0') : undefined;\n    balanceHex = '0';\n    if (\n      !alg &&\n      jit &&\n      jit.bytecode.length + jit.calldata.length < bytecode.length + calldata.length\n    ) {\n      bytecode = jit.bytecode;\n      calldata = jit.calldata;\n      decompressorAddress = jit.to;\n      fromAddr = jit.from;\n      balanceHex = jit.balance;\n    }\n  }\n\n  // Skip if not beneficial\n  if (bytecode.length + calldata.length >= originalSize) return payload;\n\n  const stateOverride: any = {\n    code: bytecode,\n    balance: '0x' + balanceHex,\n  };\n  const compressedTxObj: any = { to: decompressorAddress, data: calldata };\n  if (fromAddr) {\n    compressedTxObj.from = '0x' + fromAddr;\n  }\n\n  return {\n    ...payload,\n    params: [compressedTxObj, blockParam, { ...overrides, [decompressorAddress]: stateOverride }],\n  };\n};\n", "export const MAX_128_BIT = (1n << 128n) - 1n;\nexport const MAX_256_BIT = (1n << 256n) - 1n;\n", "import { MAX_256_BIT } from './constants';\n\nexport const not = (a: bigint): bigint => ~a & MAX_256_BIT;\nexport const eq = (a: bigint, b: bigint): bigint => (a === b ? 1n : 0n);\nexport const and = (a: bigint, b: bigint): bigint => a & b & MAX_256_BIT;\nexport const or = (a: bigint, b: bigint): bigint => (a | b) & MAX_256_BIT;\nexport const xor = (a: bigint, b: bigint): bigint => (a ^ b) & MAX_256_BIT;\n\nexport const add = (a: bigint, b: bigint): bigint => (a + b) & MAX_256_BIT;\nexport const sub = (a: bigint, b: bigint): bigint => (a - b) & MAX_256_BIT;\n\nexport const shl = (shift: bigint, value: bigint): bigint => (value << shift) & MAX_256_BIT;\nexport const shr = (shift: bigint, value: bigint): bigint => (value >> shift) & MAX_256_BIT;\n\nexport const 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) !== 0n ? maskedVal | (~mask & MAX_256_BIT) : maskedVal;\n  return extended & MAX_256_BIT;\n};\n\nexport const clz = (value: bigint): bigint => {\n  if (value === 0n) return 256n;\n  let count = 0n;\n  let mask = 1n << 255n;\n  while ((value & mask) === 0n && count < 256n) {\n    count++;\n    mask >>= 1n;\n  }\n  return count;\n};\n\nexport const ctz = (value: bigint): bigint => {\n  if (value === 0n) return 256n;\n  let count = 0n;\n  while (count < 256n && (value & (1n << count)) === 0n) {\n    count++;\n  }\n  return count;\n};\n", "export const _normHex = (hex: string): string => hex.replace(/^0x/, '').toLowerCase();\n\nexport const _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\nexport const _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\nexport type MemorySegment = { s: number; e: number };\n\nexport interface WordStats {\n  /** Total number of times this 32-byte word appears in the view. */\n  freq: number;\n  normFreq: number;\n  /** First 32-byte word index at which this word appears. */\n  firstWordIndex: number;\n  /** Last 32-byte word index at which this word appears. */\n  lastWordIndex: number;\n  /** Starting byte offset in memory of the first occurrence (same as MLOAD offset). */\n  firstOffset: number;\n  /** Starting byte offset in memory of the last occurrence (same as MLOAD offset). */\n  lastOffset: number;\n  reuseCost: number;\n}\n\nexport interface MemoryView {\n  /** Normalized hex string (without 0x) of the original payload. */\n  readonly hex: string;\n  /** Backing buffer containing `padding` zero bytes followed by the payload. */\n  readonly buffer: Uint8Array;\n  /** Total length of the backing buffer (padding + payload length), rounded up to full words. */\n  readonly roundedLength: number;\n  /** Number of zero bytes prefixed before the payload. */\n  readonly padding: number;\n  /** Length of the original (unpadded) payload in bytes. */\n  readonly dataLength: number;\n  /** Number of 32-byte words in this view. */\n  readonly wordCount: number;\n  /** Frequency of each 32-byte word (by hex representation) across the memory view. */\n  readonly wordFreq: ReadonlyMap<string, number>;\n  readonly wordStats: ReadonlyMap<string, WordStats>;\n  /** Return the nth 32-byte word (zero-padded on the right if incomplete). */\n  getWord(wordIndex: number): Uint8Array;\n  /**\n   * Return all non-zero byte segments within the nth 32-byte word.\n   * Each segment is an inclusive [s, e] range in the word.\n   */\n  getSegments(wordIndex: number): MemorySegment[];\n  mload(offset: number): Uint8Array;\n  /**\n   * Read an arbitrary slice starting at `offset` for `size` bytes,\n   * padding with zeros when reading past `length`.\n   */\n  slice(offset: number, size: number): Uint8Array;\n}\n\nexport const initMemoryView = (calldata: string, padding: number): MemoryView => {\n  const hex = _normHex(calldata);\n  const originalBuf = _hexToUint8Array(hex);\n  const buffer = new Uint8Array(padding + originalBuf.length);\n  buffer.set(originalBuf, padding);\n  const rawLength = buffer.length;\n  const wordCount = Math.ceil(rawLength / 32);\n  const roundedLength = wordCount * 32;\n\n  const words: Uint8Array[] = new Array(wordCount);\n  const segments: MemorySegment[][] = new Array(wordCount);\n  const wordFreq = new Map<string, number>();\n  const wordStats = new Map<string, WordStats>();\n\n  let prevWordHex: string | null = null;\n\n  for (let wordIndex = 0; wordIndex < wordCount; wordIndex++) {\n    const base = wordIndex * 32;\n    const word = new Uint8Array(32);\n    if (base < rawLength) {\n      const end = Math.min(base + 32, rawLength);\n      word.set(buffer.subarray(base, end), 0);\n    }\n    words[wordIndex] = word;\n\n    const wordHex = _uint8ArrayToHex(word);\n    const existing = wordStats.get(wordHex);\n    const isRunContinuation = prevWordHex === wordHex;\n    if (!existing) {\n      const stats: WordStats = {\n        freq: 1,\n        normFreq: 1,\n        firstWordIndex: wordIndex,\n        lastWordIndex: wordIndex,\n        firstOffset: base,\n        lastOffset: base,\n        reuseCost: -1,\n      };\n      wordStats.set(wordHex, stats);\n      wordFreq.set(wordHex, 1);\n    } else {\n      existing.freq += 1;\n      if (!isRunContinuation) {\n        existing.normFreq += 1;\n      }\n      existing.lastWordIndex = wordIndex;\n      existing.lastOffset = base;\n      wordFreq.set(wordHex, existing.freq);\n    }\n    prevWordHex = wordHex;\n\n    const seg: MemorySegment[] = [];\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    segments[wordIndex] = seg;\n  }\n\n  for (const stats of wordStats.values()) {\n    const baseBytes = stats.firstOffset === 0 ? 0 : Math.ceil(Math.log2(stats.firstOffset + 1) / 8);\n    const reuseCost = baseBytes + 3;\n    const totalLiteralBytes = stats.normFreq * 32;\n    const totalReuseBytes = stats.normFreq * reuseCost;\n    stats.reuseCost = totalLiteralBytes > totalReuseBytes ? reuseCost : -1;\n  }\n\n  const zeroWord = new Uint8Array(32);\n\n  const getWord = (wordIndex: number): Uint8Array => {\n    if (wordIndex < 0 || wordIndex >= wordCount) return zeroWord;\n    return words[wordIndex];\n  };\n\n  const getSegments = (wordIndex: number): MemorySegment[] => {\n    if (wordIndex < 0 || wordIndex >= wordCount) return [];\n    return segments[wordIndex];\n  };\n\n  const mload = (offset: number): Uint8Array => {\n    const out = new Uint8Array(32);\n    if (offset < 0 || offset >= rawLength) return out;\n    const end = Math.min(offset + 32, rawLength);\n    out.set(buffer.slice(offset, end), 0);\n    return out;\n  };\n\n  const slice = (offset: number, size: number): Uint8Array => {\n    if (size <= 0) return new Uint8Array(0);\n    const out = new Uint8Array(size);\n    if (offset < 0 || offset >= rawLength) return out;\n    const end = Math.min(offset + size, rawLength);\n    out.set(buffer.slice(offset, end), 0);\n    return out;\n  };\n\n  return {\n    hex,\n    buffer,\n    roundedLength,\n    padding,\n    dataLength: originalBuf.length,\n    wordCount,\n    wordFreq,\n    wordStats,\n    getWord,\n    getSegments,\n    mload,\n    slice,\n  };\n};\n", "import { MAX_128_BIT, MAX_256_BIT } from './constants';\nimport { add, and, not, or, shl, shr, sigext, sub, xor } from './opcodes';\nimport { _normHex, _uint8ArrayToHex, initMemoryView, MemorySegment } from './utils';\n\nexport const _jitDecompressor = function (\n  calldata: string,\n  to: string,\n  from?: string,\n): { bytecode: string; calldata: string; to: string; from?: string; balance: string } {\n  let padding = 28;\n  const view = initMemoryView(calldata, padding);\n  let decAddr = 224n;\n  let originalTo = _normHex(to).padStart(16, '0');\n  let fromAddr = from ? BigInt('0x' + _normHex(from)) : 96n;\n  const excluded = new Set([0n, 32n, decAddr, fromAddr, BigInt('0x' + originalTo)]);\n  let selfbalance = 2n;\n  const filtered = Array.from(view.wordFreq.entries())\n    .map(([word, freq]) => [BigInt('0x' + word), freq] as [bigint, number])\n    .filter(([val]) => !excluded.has(val));\n  if (filtered.length > 0) {\n    selfbalance = filtered.reduce((max, curr) => (curr[1] > max[1] ? curr : max))[0];\n  }\n  const { wordCount } = view;\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\n  const roundUp32 = (x: number) => (x + 31) & ~31;\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  const stackFreq = new Map<bigint, number>();\n  const stackLastUse = new Map<bigint, number>();\n  let pushCounter = 0;\n  const ctr = <K>(m: Map<K, number>, k: K, delta: number) => m.set(k, (m.get(k) || 0) + delta);\n  const pushOp = (op: number, d?: number[] | null) => {\n    ops.push(op);\n    data.push(d ?? null);\n  };\n  const pushS = (v: bigint, freqDelta: number = 1) => {\n    stack.push(v);\n    if (freqDelta !== 0) ctr(stackFreq, v, freqDelta);\n    ++pushCounter;\n    stackLastUse.set(v, pushCounter);\n  };\n  const pop2 = (): [bigint, bigint] => [stack.pop()!, stack.pop()!];\n  const trackMem = (offset: number, size: number) => {\n    trackedMemSize = roundUp32(offset + size);\n  };\n\n  const addOp = (op: number, imm?: number[]) => {\n    if (op == 0x80) {\n      // DUP1\n      const val = stack[stack.length - 1]!;\n      pushS(val, firstPass ? 0 : 1);\n    }\n    if (op == 0x50) stack.pop();\n    if (op == 0x47) pushS(selfbalance, 0);\n    if (op == 0x30) pushS(decAddr, 0);\n    if (op == 0x33) pushS(fromAddr, 0);\n    if (op == 0x36) pushS(32n, 0);\n    if (op == 0x59) pushS(BigInt(trackedMemSize), 0);\n    if (op === 0x0b) {\n      // SIGNEXTEND\n      const [byteSize, val] = pop2();\n      pushS(sigext(byteSize, val), 1);\n    }\n    if (op == 0x19) {\n      // NOT\n      const val = stack.pop()!;\n      pushS(not(val), 0);\n    }\n    if (op === 0x18) {\n      // XOR\n      const [a, b] = pop2();\n      pushS(xor(a, b), 1);\n    }\n    if (op == 0x16) {\n      // AND\n      const [a, b] = pop2();\n      pushS(and(a, b), 1);\n    }\n    if (op == 0x17) {\n      // OR\n      const [a, b] = pop2();\n      pushS(or(a, b), 1);\n    }\n    if (op == 0x01) {\n      // ADD\n      const [a, b] = pop2();\n      pushS(add(a, b), 1);\n    }\n    if (op === 0x03) {\n      // SUB\n      const [a, b] = pop2();\n      pushS(sub(b, a), 1);\n    }\n    if (op == 0x1b) {\n      // SHL\n      const [shift, val] = pop2();\n      pushS(shl(shift, val), 1);\n    }\n    if (op == 0x1c) {\n      // SHR\n      const [shift, val] = pop2();\n      pushS(shr(shift, val), 1);\n    }\n    if ((op >= 0x60 && op <= 0x7f) || op === 0x5f) {\n      let v = 0n; // PUSH* and PUSH0\n      for (const b of imm || []) v = (v << 8n) | BigInt(b);\n      if (v == selfbalance) {\n        pushS(v, 0);\n        pushOp(0x47);\n        return;\n      }\n      if (v == decAddr) {\n        pushS(v, 0);\n        pushOp(0x30);\n        return;\n      }\n      if (v == fromAddr) {\n        pushS(v, 0);\n        pushOp(0x33); // FROM ADDRESS\n        return;\n      }\n      if (v == 32n) {\n        pushS(v, 0);\n        pushOp(0x36); // CALLDATASIZE\n        return;\n      }\n      if (v === BigInt(trackedMemSize) && v !== 0n) {\n        pushS(v, 0);\n        pushOp(0x59);\n        return;\n      }\n      const idx = getStackIdx(v);\n      if (idx !== -1 && op !== 0x5f) {\n        const freqDelta = firstPass ? 1 : 0;\n        pushS(v, freqDelta);\n        pushOp(0x80 + idx);\n        return;\n      }\n      if (v === MAX_256_BIT) {\n        pushS(v, 0);\n        pushOp(0x5f); // PUSH0\n        pushOp(0x19); // NOT\n        return;\n      }\n      pushS(v, 1);\n      pushOp(op, imm || null);\n      return;\n    }\n    if (op === 0x51) {\n      // MLOAD\n      const k = Number(stack.pop()!);\n      pushS(mem.has(k) ? mem.get(k)! : 0n, 0);\n    }\n    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    }\n    if (op === 0x53) {\n      // MSTORE8\n      const [offset, _] = pop2();\n      trackMem(Number(offset), 1);\n    }\n    pushOp(op, imm || null);\n  };\n\n  const op = (opcode: number) => addOp(opcode);\n\n  const bytesLen = (v: bigint): number => {\n    if (v === 0n) return 0;\n    let n = 0;\n    let t = v < 0n ? -v : v;\n    while (t > 0n) {\n      ++n;\n      t >>= 8n;\n    }\n    return n;\n  };\n\n  const pushCost = (v: bigint): number => (v === 0n ? 1 : 1 + bytesLen(v));\n\n  const pushN = (value: number | bigint) => {\n    const v = typeof value === 'bigint' ? value : BigInt(value);\n    if (v > 0n && v === BigInt(trackedMemSize)) return addOp(0x59);\n    if (v === 32n) return addOp(0x36);\n    if (v === 0n) return addOp(0x5f);\n\n    let tmp = v;\n    const bytes: number[] = [];\n    while (tmp !== 0n) {\n      bytes.unshift(Number(tmp & 0xffn));\n      tmp >>= 8n;\n    }\n    return addOp(0x5f + bytes.length, bytes);\n  };\n\n  const pushB = (buf: Uint8Array) => addOp(0x5f + buf.length, Array.from(buf));\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\n  const emitPushN = (v: number | bigint) => {\n    plan.push({ t: 'num', v });\n    pushN(v);\n  };\n  const emitPushB = (b: Uint8Array) => {\n    plan.push({ t: 'bytes', b });\n    pushB(b);\n  };\n  const emitOp = (o: number) => {\n    plan.push({ t: 'op', o });\n    op(o);\n  };\n\n  const estShlCost = (seg: MemorySegment[]) => {\n    let cost = 0;\n    let first = true;\n    for (const { s, e } of seg) {\n      cost += 1 + (e - s + 1); // PUSH<n> immediate bytes\n      if (31 - e > 0) cost += 1 + 1 + 1; // PUSH1 shift + SHL\n      if (!first) cost += 1; // OR\n      first = false;\n    }\n    return cost;\n  };\n\n  const emitBestValueForWord = (word: Uint8Array, seg: MemorySegment[]) => {\n    const literal = word.slice(seg[0].s);\n    let literalVal = 0n;\n    for (const b of literal) literalVal = (literalVal << 8n) | BigInt(b);\n    const literalCost = 1 + literal.length;\n    const shlCost = estShlCost(seg);\n    let bestCost = literalCost;\n    let bestEmit: () => void = () => emitPushB(literal);\n    // Try NOT: PUSH(~x) NOT\n    const notVal = not(literalVal);\n    const notCost = pushCost(notVal) + 1;\n    if (notCost < bestCost) {\n      bestCost = notCost;\n      bestEmit = () => {\n        emitPushN(notVal);\n        emitOp(0x19);\n      };\n    }\n    // Try SUB: PUSH0, PUSH(x), SUB\n    const subVal = sub(0n, literalVal);\n    const subCost = 1 + pushCost(subVal) + 1;\n    if (subCost < bestCost) {\n      bestCost = subCost;\n      bestEmit = () => {\n        emitPushN(0);\n        emitPushN(subVal);\n        emitOp(0x03);\n      };\n    }\n    // Try 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 (\n        extended === literalVal &&\n        (truncated & (1n << BigInt(numBytes * 8 - 1))) !== 0n // must be negative in that width\n      ) {\n        const signCost = pushCost(truncated) + 2 + 1; // PUSH + 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    // Try SHIFT+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      if (reconstructed === literalVal) {\n        const shiftNotCost = pushCost(notShifted) + pushCost(BigInt(shiftBits)) + 2; // PUSH + PUSH + SHL + NOT\n        if (shiftNotCost < bestCost) {\n          bestCost = shiftNotCost;\n          bestEmit = () => {\n            emitPushN(notShifted);\n            emitPushN(shiftBits);\n            emitOp(0x1b);\n            emitOp(0x19);\n          };\n        }\n      }\n    }\n    // Try SHL/OR\n    if (shlCost < bestCost) {\n      bestCost = shlCost;\n      bestEmit = () => {\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    }\n    return { literal, literalVal, bestCost, bestEmit, literalCost, shlCost };\n  };\n\n  let wordIndex = 0;\n  while (wordIndex < wordCount) {\n    const base = wordIndex * 32;\n    const word = view.getWord(wordIndex);\n    const seg = view.getSegments(wordIndex);\n    if (!seg.length) {\n      ++wordIndex;\n      continue;\n    }\n\n    const wordHex = _uint8ArrayToHex(word);\n    // Encode Run?\n    let runLen = 1;\n    while (wordIndex + runLen < wordCount) {\n      const w2 = view.getWord(wordIndex + runLen);\n      const s2 = view.getSegments(wordIndex + runLen);\n      if (!s2.length) break;\n      if (_uint8ArrayToHex(w2) !== wordHex) break;\n      ++runLen;\n    }\n\n    if (runLen >= 2) {\n      const { bestEmit } = emitBestValueForWord(word, seg);\n      // First store: keep word value on stack.\n      bestEmit(); // push value\n      emitOp(0x80); // DUP1 (keep value)\n      emitPushN(base); // offset (MSIZE if aligned)\n      emitOp(0x52); // MSTORE\n\n      for (let j = 1; j < runLen; j++) {\n        emitOp(0x80); // DUP1\n        emitOp(0x59); // MSIZE\n        emitOp(0x52); // MSTORE\n      }\n      const stats = view.wordStats.get(wordHex);\n      if (stats && stats.lastWordIndex <= wordIndex + runLen - 1) {\n        emitOp(0x50); // POP\n      }\n      wordIndex += runLen;\n      continue;\n    }\n\n    const { literalCost, shlCost, bestCost, bestEmit } = emitBestValueForWord(word, seg);\n    // Try MLOAD/MSTORE reuse\n    if (literalCost > 8) {\n      const stats = view.wordStats.get(wordHex);\n      if (stats && stats.reuseCost !== -1 && wordIndex > stats.firstWordIndex) {\n        const baseBytes =\n          stats.firstOffset === 0 ? 0 : Math.ceil(Math.log2(stats.firstOffset + 1) / 8);\n        if (literalCost > stats.reuseCost + baseBytes) {\n          emitPushN(stats.firstOffset);\n          emitOp(0x51); // MLOAD\n          emitPushN(base);\n          emitOp(0x52); // MSTORE\n          ++wordIndex;\n          continue;\n        }\n      }\n    }\n    const byte8s = seg.every(({ s, e }) => s === e);\n    const byte8sCost = seg.length * 3; // PUSH1(value), PUSH1(offset), MSTORE8\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      ++wordIndex;\n      continue;\n    }\n    // Default\n    bestEmit();\n    emitPushN(base);\n    emitOp(0x52); // MSTORE\n    ++wordIndex;\n  }\n\n  //2nd pass: preseed dictionary + emit final ops\n  const planOut = plan.slice();\n  ops = [];\n  data = [];\n  stack = [];\n  trackedMemSize = 0;\n  mem = new Map();\n  firstPass = false;\n\n  const reserved = new Set<bigint>([0n, 32n, selfbalance, decAddr, fromAddr]);\n  Array.from(stackFreq.entries())\n    .filter(([val, uses]) => uses > 1 && !reserved.has(val))\n    .map(([val, uses]) => {\n      const p = pushCost(val);\n      const net = uses * (p - 1) - p;\n      return { val, uses, net, p };\n    })\n    .sort((a, b) => {\n      if (b.net !== a.net) return b.net - a.net;\n      if (b.uses !== a.uses) return b.uses - a.uses;\n      return a.p - b.p;\n    })\n    .filter((x) => x.net > 0 && x.val <= MAX_128_BIT)\n    .slice(0, 15)\n    .forEach(({ val }) => {\n      pushN(val);\n    });\n\n  for (const step of planOut) {\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  // - 0x5f5f: PUSH0 PUSH0 (retSize=0, retOffset=0)\n  // - pushN(view.dataLength): argsSize\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(view.dataLength); // 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  const bytecode = '0x' + _uint8ArrayToHex(new Uint8Array(out)) + '345f355af13d5f5f3e3d5ff3';\n  const calldataOut = '0x' + _normHex(originalTo).padStart(64, '0');\n\n  return {\n    bytecode,\n    calldata: calldataOut,\n    to: '0x' + decAddr.toString(16).padStart(40, '0'),\n    from: _normHex(fromAddr.toString(16)).padStart(40, '0'),\n    balance: selfbalance.toString(16),\n  };\n};\n", "import { _normHex } from './compiler/utils';\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"],
+  "mappings": "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",
+  "names": ["LibZip", "MAX_128_BIT", "MAX_256_BIT", "not", "a", "MAX_256_BIT", "and", "a", "b", "MAX_256_BIT", "or", "xor", "add", "sub", "shl", "shift", "value", "shr", "sigext", "byteSize", "numBytes", "mask", "signBit", "maskedVal", "_normHex", "hex", "_hexToUint8Array", "normalized", "len", "bytes", "i", "_uint8ArrayToHex", "initMemoryView", "calldata", "padding", "originalBuf", "buffer", "rawLength", "wordCount", "roundedLength", "words", "segments", "wordFreq", "wordStats", "prevWordHex", "wordIndex", "base", "word", "end", "wordHex", "existing", "isRunContinuation", "stats", "seg", "s", "reuseCost", "totalLiteralBytes", "totalReuseBytes", "zeroWord", "getWord", "getSegments", "mload", "offset", "out", "slice", "size", "_jitDecompressor", "calldata", "to", "from", "padding", "view", "initMemoryView", "decAddr", "originalTo", "_normHex", "fromAddr", "excluded", "selfbalance", "filtered", "word", "freq", "val", "max", "curr", "wordCount", "ops", "data", "stack", "trackedMemSize", "mem", "firstPass", "roundUp32", "x", "getStackIdx", "idx", "stackFreq", "stackLastUse", "pushCounter", "ctr", "m", "k", "delta", "pushOp", "op", "d", "pushS", "v", "freqDelta", "pop2", "trackMem", "offset", "size", "addOp", "imm", "byteSize", "sigext", "not", "a", "b", "xor", "and", "or", "add", "sub", "shift", "shl", "shr", "MAX_256_BIT", "value", "_", "opcode", "bytesLen", "n", "t", "pushCost", "pushN", "tmp", "bytes", "pushB", "buf", "plan", "emitPushN", "emitPushB", "emitOp", "o", "estShlCost", "seg", "cost", "first", "e", "emitBestValueForWord", "literal", "literalVal", "literalCost", "shlCost", "bestCost", "bestEmit", "notVal", "notCost", "subVal", "subCost", "numBytes", "mask", "truncated", "signCost", "shiftBits", "shifted", "notShifted", "shiftNotCost", "s", "suffix0s", "wordIndex", "base", "wordHex", "_uint8ArrayToHex", "runLen", "w2", "j", "stats", "baseBytes", "byte8s", "byte8sCost", "planOut", "reserved", "uses", "p", "net", "MAX_128_BIT", "step", "out", "i", "bytecode", "calldataOut", "flzFwdBytecode", "address", "_normHex", "rleFwdBytecode", "compress_call", "payload", "alg", "method", "params", "txObj", "blockParam", "overrides", "k", "originalSize", "inputData", "_normHex", "to", "from", "bytecode", "calldata", "decompressorAddress", "fromAddr", "balanceHex", "result", "_jitDecompressor", "jit", "flzData", "LibZip", "cdData", "flzFwdBytecode", "rleFwdBytecode", "stateOverride", "compressedTxObj"]
 }

package/_types/compiler/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const MAX_128_BIT: bigint;
+export declare const MAX_256_BIT: bigint;
+//# sourceMappingURL=constants.d.ts.map

package/_types/compiler/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/compiler/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,QAAoB,CAAC;AAC7C,eAAO,MAAM,WAAW,QAAoB,CAAC"}

package/_types/compiler/index.d.ts

@@ -0,0 +1,4 @@
+export * from './constants';
+export * from './jit';
+export * from './opcodes';
+//# sourceMappingURL=index.d.ts.map

package/_types/compiler/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/compiler/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,OAAO,CAAC;AACtB,cAAc,WAAW,CAAC"}

package/_types/compiler/jit.d.ts

@@ -0,0 +1,8 @@
+export declare const _jitDecompressor: (calldata: string, to: string, from?: string) => {
+    bytecode: string;
+    calldata: string;
+    to: string;
+    from?: string;
+    balance: string;
+};
+//# sourceMappingURL=jit.d.ts.map

package/_types/compiler/jit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jit.d.ts","sourceRoot":"","sources":["../../../src/compiler/jit.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,gBAAgB,GAC3B,UAAU,MAAM,EAChB,IAAI,MAAM,EACV,OAAO,MAAM,KACZ;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CA0dlF,CAAC"}

package/_types/compiler/opcodes.d.ts

@@ -0,0 +1,13 @@
+export declare const not: (a: bigint) => bigint;
+export declare const eq: (a: bigint, b: bigint) => bigint;
+export declare const and: (a: bigint, b: bigint) => bigint;
+export declare const or: (a: bigint, b: bigint) => bigint;
+export declare const xor: (a: bigint, b: bigint) => bigint;
+export declare const add: (a: bigint, b: bigint) => bigint;
+export declare const sub: (a: bigint, b: bigint) => bigint;
+export declare const shl: (shift: bigint, value: bigint) => bigint;
+export declare const shr: (shift: bigint, value: bigint) => bigint;
+export declare const sigext: (byteSize: bigint, value: bigint) => bigint;
+export declare const clz: (value: bigint) => bigint;
+export declare const ctz: (value: bigint) => bigint;
+//# sourceMappingURL=opcodes.d.ts.map

package/_types/compiler/opcodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opcodes.d.ts","sourceRoot":"","sources":["../../../src/compiler/opcodes.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,GAAG,GAAI,GAAG,MAAM,KAAG,MAA0B,CAAC;AAC3D,eAAO,MAAM,EAAE,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,KAAG,MAA6B,CAAC;AACxE,eAAO,MAAM,GAAG,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,KAAG,MAA6B,CAAC;AACzE,eAAO,MAAM,EAAE,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,KAAG,MAA+B,CAAC;AAC1E,eAAO,MAAM,GAAG,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,KAAG,MAA+B,CAAC;AAE3E,eAAO,MAAM,GAAG,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,KAAG,MAA+B,CAAC;AAC3E,eAAO,MAAM,GAAG,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,KAAG,MAA+B,CAAC;AAE3E,eAAO,MAAM,GAAG,GAAI,OAAO,MAAM,EAAE,OAAO,MAAM,KAAG,MAAwC,CAAC;AAC5F,eAAO,MAAM,GAAG,GAAI,OAAO,MAAM,EAAE,OAAO,MAAM,KAAG,MAAwC,CAAC;AAE5F,eAAO,MAAM,MAAM,GAAI,UAAU,MAAM,EAAE,OAAO,MAAM,KAAG,MAOxD,CAAC;AAEF,eAAO,MAAM,GAAG,GAAI,OAAO,MAAM,KAAG,MASnC,CAAC;AAEF,eAAO,MAAM,GAAG,GAAI,OAAO,MAAM,KAAG,MAOnC,CAAC"}

package/_types/compiler/utils.d.ts

@@ -0,0 +1,53 @@
+export declare const _normHex: (hex: string) => string;
+export declare const _hexToUint8Array: (hex: string) => Uint8Array;
+export declare const _uint8ArrayToHex: (bytes: Uint8Array) => string;
+export type MemorySegment = {
+    s: number;
+    e: number;
+};
+export interface WordStats {
+    /** Total number of times this 32-byte word appears in the view. */
+    freq: number;
+    normFreq: number;
+    /** First 32-byte word index at which this word appears. */
+    firstWordIndex: number;
+    /** Last 32-byte word index at which this word appears. */
+    lastWordIndex: number;
+    /** Starting byte offset in memory of the first occurrence (same as MLOAD offset). */
+    firstOffset: number;
+    /** Starting byte offset in memory of the last occurrence (same as MLOAD offset). */
+    lastOffset: number;
+    reuseCost: number;
+}
+export interface MemoryView {
+    /** Normalized hex string (without 0x) of the original payload. */
+    readonly hex: string;
+    /** Backing buffer containing `padding` zero bytes followed by the payload. */
+    readonly buffer: Uint8Array;
+    /** Total length of the backing buffer (padding + payload length), rounded up to full words. */
+    readonly roundedLength: number;
+    /** Number of zero bytes prefixed before the payload. */
+    readonly padding: number;
+    /** Length of the original (unpadded) payload in bytes. */
+    readonly dataLength: number;
+    /** Number of 32-byte words in this view. */
+    readonly wordCount: number;
+    /** Frequency of each 32-byte word (by hex representation) across the memory view. */
+    readonly wordFreq: ReadonlyMap<string, number>;
+    readonly wordStats: ReadonlyMap<string, WordStats>;
+    /** Return the nth 32-byte word (zero-padded on the right if incomplete). */
+    getWord(wordIndex: number): Uint8Array;
+    /**
+     * Return all non-zero byte segments within the nth 32-byte word.
+     * Each segment is an inclusive [s, e] range in the word.
+     */
+    getSegments(wordIndex: number): MemorySegment[];
+    mload(offset: number): Uint8Array;
+    /**
+     * Read an arbitrary slice starting at `offset` for `size` bytes,
+     * padding with zeros when reading past `length`.
+     */
+    slice(offset: number, size: number): Uint8Array;
+}
+export declare const initMemoryView: (calldata: string, padding: number) => MemoryView;
+//# sourceMappingURL=utils.d.ts.map

package/_types/compiler/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/compiler/utils.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,QAAQ,GAAI,KAAK,MAAM,KAAG,MAA8C,CAAC;AAEtF,eAAO,MAAM,gBAAgB,GAAI,KAAK,MAAM,KAAG,UAQ9C,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,OAAO,UAAU,KAAG,MAMpD,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAErD,MAAM,WAAW,SAAS;IACxB,mEAAmE;IACnE,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,2DAA2D;IAC3D,cAAc,EAAE,MAAM,CAAC;IACvB,0DAA0D;IAC1D,aAAa,EAAE,MAAM,CAAC;IACtB,qFAAqF;IACrF,WAAW,EAAE,MAAM,CAAC;IACpB,oFAAoF;IACpF,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,UAAU;IACzB,kEAAkE;IAClE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,8EAA8E;IAC9E,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAC5B,+FAA+F;IAC/F,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,wDAAwD;IACxD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,0DAA0D;IAC1D,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,4CAA4C;IAC5C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,qFAAqF;IACrF,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/C,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IACnD,4EAA4E;IAC5E,OAAO,CAAC,SAAS,EAAE,MAAM,GAAG,UAAU,CAAC;IACvC;;;OAGG;IACH,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,aAAa,EAAE,CAAC;IAChD,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAAC;IAClC;;;OAGG;IACH,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC;CACjD;AAED,eAAO,MAAM,cAAc,GAAI,UAAU,MAAM,EAAE,SAAS,MAAM,KAAG,UAiHlE,CAAC"}

package/_types/contracts.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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;
+//# sourceMappingURL=contracts.d.ts.map

package/_types/contracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contracts.d.ts","sourceRoot":"","sources":["../../src/contracts.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AAEH,eAAO,MAAM,cAAc,GAAI,SAAS,MAAM,KAAG,MAC6W,CAAC;AAE/Z;;;;;GAKG;AAEH,eAAO,MAAM,cAAc,GAAI,SAAS,MAAM,KAAG,MACyL,CAAC"}

package/_types/index.d.ts

@@ -1,35 +1,14 @@
+export declare const MIN_BODY_SIZE = 1150;
 export type PayloadTransform = (payload: unknown) => unknown;
+export type CompressionMode = 'passive' | 'proactive' | 'gzip' | 'deflate' | PayloadTransform;
 /**
- * Fetch-compatible function that applies HTTP compression (gzip/deflate) to requests.
- * Optionally transforms request payloads before sending.
- *
- * @param input - The resource URL, Request object, or URL string
- * @param init - Optional request initialization options
- * @param transformPayload - Optional function to transform the request payload
- * @returns A Promise that resolves to the Response
+ * @param input - URL or Request
+ * @param init - Request options
+ * @param mode - Compression mode:
+ *   - 'passive' (default): discover support via Accept-Encoding header first
+ *   - 'proactive': compress with gzip first, adjust if server rejects
+ *   - 'gzip' | 'deflate': use specified encoding directly (known support)
+ *   - PayloadTransform function: transform payload, skip HTTP compression
  */
-export declare function compressModule(input: string | URL | Request, init?: RequestInit): Promise<Response>;
-export declare function compressModule(input: string | URL | Request, init: RequestInit | undefined, transformPayload?: PayloadTransform): Promise<Response>;
-/**
- * Combines HTTP compression with EVM JIT compression.
- * Just pass this as `fetchFn` to viem's http transport.
- *
- * @param input - The resource URL or Request object
- * @param init - Optional request initialization options
- * @returns A Promise that resolves to the Response
- *
- * @example
- * ```ts
- * const client = createPublicClient({
- *   transport: http(rpcUrl, { fetchFn: compressModuleWithJIT })
- * })
- * ```
- *
- * If the target RPC endpoint and runtime support native HTTP compression,
- * this helper prefers that path and will not apply JIT calldata compression;
- * the JIT-based transform is used as a legacy/fallback path when HTTP
- * content-encoding is unavailable.
- * @pure
- */
-export declare const compressModuleWithJIT: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export declare function compressModule(input: string | URL | Request, init?: RequestInit, mode?: CompressionMode): Promise<Response>;
 //# sourceMappingURL=index.d.ts.map

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;AAC7D,MAAM,MAAM,eAAe,GAAG,SAAS,GAAG,WAAW,GAAG,MAAM,GAAG,SAAS,GAAG,gBAAgB,CAAC;AAE9F;;;;;;;;GAQG;AACH,wBAAsB,cAAc,CAClC,KAAK,EAAE,MAAM,GAAG,GAAG,GAAG,OAAO,EAC7B,IAAI,CAAC,EAAE,WAAW,EAClB,IAAI,CAAC,EAAE,eAAe,GACrB,OAAO,CAAC,QAAQ,CAAC,CA+DnB"}

package/_types/jit-compressor.d.ts

@@ -1,26 +1,12 @@
-/**
- * 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:
+ * - 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;AA+TF;;;;;;;GAOG;AAEH,eAAO,MAAM,aAAa,GAAa,SAAS,GAAG,EAAE,MAAM,MAAM,KAAG,GA8DnE,CAAC"}
+{"version":3,"file":"jit-compressor.d.ts","sourceRoot":"","sources":["../../src/jit-compressor.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;GAaG;AAEH,eAAO,MAAM,aAAa,GAAa,SAAS,GAAG,EAAE,MAAM,MAAM,KAAG,GAoFnE,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,114 +1,86 @@
-const _sup_enc = new Map<string, string[] | -1>();
-const _enc = ['deflate-raw', 'deflate', 'gzip'];
-let supported: string | -1 | null = typeof CompressionStream === 'undefined' ? -1 : null;
+export const MIN_BODY_SIZE = 1150;
+
+const _cache = new Map<string, string | -1>();
+const _enc = ['gzip', 'deflate'] as const;
+type SupportedEncoding = (typeof _enc)[number];
 
 export type PayloadTransform = (payload: unknown) => unknown;
+export type CompressionMode = 'passive' | 'proactive' | 'gzip' | 'deflate' | PayloadTransform;
 
 /**
- * Fetch-compatible function that applies HTTP compression (gzip/deflate) to requests.
- * Optionally transforms request payloads before sending.
- *
- * @param input - The resource URL, Request object, or URL string
- * @param init - Optional request initialization options
- * @param transformPayload - Optional function to transform the request payload
- * @returns A Promise that resolves to the Response
+ * @param input - URL or Request
+ * @param init - Request options
+ * @param mode - Compression mode:
+ *   - 'passive' (default): discover support via Accept-Encoding header first
+ *   - 'proactive': compress with gzip first, adjust if server rejects
+ *   - 'gzip' | 'deflate': use specified encoding directly (known support)
+ *   - PayloadTransform function: transform payload, skip HTTP compression
  */
-//! @__PURE__
-export async function compressModule(
-  input: string | URL | Request,
-  init?: RequestInit,
-): Promise<Response>;
-
-//! @__PURE__
-export async function compressModule(
-  input: string | URL | Request,
-  init: RequestInit | undefined,
-  transformPayload?: PayloadTransform,
-): Promise<Response>;
-
-//! @__PURE__
 export async function compressModule(
   input: string | URL | Request,
   init?: RequestInit,
-  transformPayload?: PayloadTransform,
+  mode?: CompressionMode,
 ): Promise<Response> {
+  const req = input instanceof Request ? input : null;
   const url =
-    typeof input === 'string' ? input : input instanceof URL ? input.toString() : input.url;
+    typeof input === 'string' ? input : input instanceof Request ? input.url : input.toString();
+  const bodyStr = typeof init?.body === 'string' ? init.body : null;
 
-  const cached = _sup_enc.get(url);
-  supported = supported === -1 ? -1 : cached === -1 ? -1 : (cached?.[0] ?? null);
-
-  // Only apply the optional payload transform
-  // when native HTTP compression is not available for this URL.
-  if (transformPayload && init?.body && typeof init.body === 'string') {
-    if (supported === -1 || supported === null) {
+  // Custom transform: apply and skip HTTP compression
+  if (typeof mode === 'function') {
+    if (req && !init) return fetch(req);
+    let body = init?.body;
+    if (bodyStr)
       try {
-        const parsed = JSON.parse(init.body as string);
-        const next = transformPayload(parsed);
-        if (next !== undefined) {
-          init = {
-            ...init,
-            body: JSON.stringify(next),
-          };
-        }
-      } catch {
-        // Non-JSON bodies are left untouched.
-      }
-    }
+        const next = mode(JSON.parse(bodyStr));
+        if (next !== undefined) body = JSON.stringify(next);
+      } catch {}
+    return fetch(req ?? url, { ...init, body });
   }
 
-  if (supported && supported !== -1 && init?.body) {
-    const compressed = await new Response(
-      new Blob([init.body as string])
+  const cached = _cache.get(url);
+  const hasCS = typeof CompressionStream !== 'undefined';
+  const known = mode === 'gzip' || mode === 'deflate';
+  const encoding = !hasCS
+    ? null
+    : known
+      ? (mode as SupportedEncoding)
+      : mode === 'proactive'
+        ? cached === -1
+          ? null
+          : (cached ?? 'gzip')
+        : typeof cached === 'string'
+          ? cached
+          : null;
+
+  const shouldCompress = !!encoding && !!bodyStr && bodyStr.length >= MIN_BODY_SIZE;
+  const opts: RequestInit = { ...init, priority: 'high' as RequestPriority };
+  const headers = new Headers(opts.headers);
+  if (shouldCompress) {
+    opts.body = await new Response(
+      new Blob([bodyStr!])
         .stream()
-        .pipeThrough(new CompressionStream(supported as CompressionFormat)),
+        .pipeThrough(new CompressionStream(encoding as CompressionFormat)),
     ).blob();
-    init = {
-      ...init,
-      body: compressed,
-      headers: { ...(init && init.headers), 'Content-Encoding': supported },
-    };
+    headers.set('Content-Encoding', encoding);
   }
-  const response = await fetch(url, init);
+  opts.headers = headers;
 
-  if (supported === null) {
-    const encodings = response.headers
-      .get('Accept-Encoding')
-      ?.split(',')
-      .filter((e) => _enc.includes(e));
-    _sup_enc.set(url, encodings?.length ? encodings : -1);
+  const response = await fetch(req ?? url, opts);
+
+  // Cache discovery for passive/proactive (not known modes)
+  if (!known && cached === undefined) {
+    const header = response.headers.get('Accept-Encoding');
+    const discovered =
+      header
+        ?.split(',')
+        .map((e) => e.trim())
+        .find((e): e is SupportedEncoding => _enc.includes(e as SupportedEncoding)) ?? -1;
+    _cache.set(
+      url,
+      mode === 'proactive' && shouldCompress ? (response.ok ? encoding! : discovered) : discovered,
+    );
   }
 
   return response;
 }
-
-/**
- * Combines HTTP compression with EVM JIT compression.
- * Just pass this as `fetchFn` to viem's http transport.
- *
- * @param input - The resource URL or Request object
- * @param init - Optional request initialization options
- * @returns A Promise that resolves to the Response
- *
- * @example
- * ```ts
- * const client = createPublicClient({
- *   transport: http(rpcUrl, { fetchFn: compressModuleWithJIT })
- * })
- * ```
- *
- * If the target RPC endpoint and runtime support native HTTP compression,
- * this helper prefers that path and will not apply JIT calldata compression;
- * the JIT-based transform is used as a legacy/fallback path when HTTP
- * content-encoding is unavailable.
- * @pure
- */
-//! @__PURE__
-export const compressModuleWithJIT = (
-  input: RequestInfo | URL,
-  init?: RequestInit,
-): Promise<Response> => {
-  return import('./jit-compressor').then(({ compress_call }) =>
-    compressModule(input, init, compress_call),
-  );
-};