eth-compress 0.3.0 → 0.3.1

package/_esm/jit-compressor.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "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"]
+  "sourcesContent": ["import { LibZip } from 'solady';\nimport { _jitDecompressor, DEC_ADDR } 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    !txObj?.to ||\n    !txObj?.data ||\n    (() => {\n      if (overrides) for (const _ in overrides) return true;\n      for (const k in txObj) if (k !== 'to' && k !== 'data' && k !== 'from') return true;\n      return false;\n    })()\n  ) {\n    return payload;\n  }\n\n  const originalSize = txObj.data.length;\n  if (originalSize < MIN_BODY_SIZE) return payload;\n\n  const inputData = 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 = DEC_ADDR;\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\n  const compressedTxObj: any = { to: decompressorAddress, data: calldata };\n\n  if (fromAddr) compressedTxObj.from = '0x' + fromAddr;\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  if (byteSize >= 31n) return value & MAX_256_BIT;\n  const bits = Number((byteSize + 1n) * 8n);\n  return BigInt.asUintN(256, BigInt.asIntN(bits, value));\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", "export const _normHex = (hex: string): string =>\n  (hex.charCodeAt(0) === 48 && (hex.charCodeAt(1) | 32) === 120 ? hex.slice(2) : hex).toLowerCase();\n\nconst _hexes = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0')),\n  _nibbles = (() => {\n    const t = new Int8Array(103).fill(-1);\n    for (let i = 0; i < 10; i++) t[48 + i] = i;\n    for (let i = 0; i < 6; i++) t[97 + i] = 10 + i;\n    return t;\n  })();\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, j = 0; i < len; i += 2) {\n    bytes[j++] = (_nibbles[normalized.charCodeAt(i)] << 4) | _nibbles[normalized.charCodeAt(i + 1)];\n  }\n  return bytes;\n};\n\nexport const _uint8ArrayToHex = (bytes: Uint8Array): string => {\n  let hex = '';\n  for (let i = 0; i < bytes.length; i++) hex += _hexes[bytes[i]]!;\n  return hex;\n};\n\nexport type MemorySegment = number; // (s << 8) | e, both in [0..31]\nconst _zeroWord = new Uint8Array(32);\nconst _emptySegments: MemorySegment[] = [];\n\nexport type WordStats = [\n  freq: number,\n  normFreq: number,\n  firstWordIndex: number,\n  lastWordIndex: number,\n  firstOffset: number,\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  /** Hex string (without 0x) for each 32-byte word in the view. */\n  readonly wordHexes: readonly string[];\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  /** Return all non-zero byte segments (packed as (s<<8)|e) within the nth 32-byte word. */\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  let 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  if (rawLength !== roundedLength) {\n    const rounded = new Uint8Array(roundedLength);\n    rounded.set(buffer, 0);\n    buffer = rounded;\n  }\n\n  const segments: MemorySegment[][] = new Array(wordCount);\n  const wordHexes: string[] = new Array(wordCount);\n  const wordStats = new Map<string, WordStats>();\n\n  let prevWordHex: string | null = null;\n  const wordAt = (wordIndex: number) => {\n    const base = wordIndex << 5;\n    return buffer.subarray(base, base + 32);\n  };\n\n  for (let wordIndex = 0; wordIndex < wordCount; wordIndex++) {\n    const base = wordIndex << 5;\n    const word = wordAt(wordIndex);\n\n    const wordHex = _uint8ArrayToHex(word);\n    wordHexes[wordIndex] = wordHex;\n    const existing = wordStats.get(wordHex);\n    const isRunContinuation = prevWordHex === wordHex;\n    if (!existing) {\n      const stats: WordStats = [1, 1, wordIndex, wordIndex, base, base, -1];\n      wordStats.set(wordHex, stats);\n    } else {\n      existing[0] += 1;\n      if (!isRunContinuation) existing[1] += 1;\n      existing[3] = wordIndex;\n      existing[5] = base;\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 << 8) | (i - 1));\n    }\n    segments[wordIndex] = seg;\n  }\n\n  for (const stats of wordStats.values()) {\n    const baseBytes = stats[4] === 0 ? 0 : (32 - Math.clz32(stats[4]) + 7) >> 3;\n    const reuseCost = baseBytes + 3;\n    stats[6] = 32 > reuseCost ? reuseCost : -1;\n  }\n\n  const getWord = (wordIndex: number): Uint8Array => {\n    return wordIndex < 0 || wordIndex >= wordCount ? _zeroWord : wordAt(wordIndex);\n  };\n\n  const getSegments = (wordIndex: number): MemorySegment[] => {\n    return wordIndex < 0 || wordIndex >= wordCount ? _emptySegments : segments[wordIndex];\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.subarray(offset, end), 0);\n    return out;\n  };\n\n  const mload = (offset: number): Uint8Array => slice(offset, 32);\n\n  return {\n    hex,\n    buffer,\n    roundedLength,\n    padding,\n    dataLength: originalBuf.length,\n    wordCount,\n    wordHexes,\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';\nexport const DEC_ADDR = '0x00000000000000000000000000000000000000e0';\n\nconst _pad64 = (s: string) => s.padStart(64, '0'),\n  _zeroW = _pad64('0'),\n  _cdsizeW = _pad64('20'),\n  _decW = _pad64('e0'),\n  _retSuffix = '345f355af13d5f5f3e3d5ff3';\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  const fromHex = from ? _normHex(from) : null;\n\n  let padding = 28,\n    bestW: string | null = null,\n    bestF = 0,\n    originalTo = _normHex(to).padStart(16, '0'),\n    fromAddr = fromHex ? BigInt('0x' + fromHex) : 96n,\n    selfbalance = 2n,\n    ops: number[] = [],\n    data: (Uint8Array | null)[] = [],\n    stack: bigint[] = [],\n    trackedMemSize = 0,\n    mem: bigint[] = [],\n    firstPass = true;\n\n  const view = initMemoryView(calldata, padding);\n  const { wordCount } = view;\n\n  const decAddr = 224n,\n    stackFreq = new Map<bigint, number>(),\n    decW = _decW,\n    fromW = _pad64(fromHex ?? fromAddr.toString(16)),\n    toW = _pad64(originalTo);\n\n  for (const [w, st] of view.wordStats) {\n    const f = st[0];\n    if (w === _zeroW || w === _cdsizeW || w === decW || w === fromW || w === toW) continue;\n    if (f > bestF) (bestF = f), (bestW = w);\n  }\n  if (bestW) selfbalance = BigInt('0x' + bestW);\n\n  const roundUp32 = (x: number) => (x + 31) & ~31;\n\n  const getStackIdx = (val: bigint): number => {\n    for (let i = stack.length - 1, d = 0; d < 16 && i >= 0; --i, ++d) {\n      if (stack[i] === val) return d;\n    }\n    return -1;\n  };\n\n  const ctr = <K>(m: Map<K, number>, k: K, delta: number) => m.set(k, (m.get(k) || 0) + delta);\n\n  const pushOp = (op: number, d?: Uint8Array | null) => {\n    ops.push(op);\n    data.push(d ?? null);\n  };\n\n  const pushS = (v: bigint, freqDelta: number = 1) => {\n    stack.push(v);\n    if (freqDelta !== 0) ctr(stackFreq, v, freqDelta);\n  };\n\n  const pop2 = (): [bigint, bigint] => [stack.pop()!, stack.pop()!];\n\n  const trackMem = (offset: number, size: number) => {\n    trackedMemSize = roundUp32(offset + size);\n  };\n\n  const addOp = (op: number, imm?: Uint8Array) => {\n    if (op === 0x80) {\n      // DUP1\n      pushS(stack[stack.length - 1]!, 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      pushS(not(stack.pop()!), 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      pushS(mem[Number(stack.pop()!) >>> 5] ?? 0n, 0);\n    }\n    if (op === 0x52) {\n      // MSTORE\n      const [offset, value] = pop2();\n      const k = Number(offset);\n      mem[k >>> 5] = 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 len = bytesLen(tmp);\n    const bytes = new Uint8Array(len);\n    for (let i = len - 1; i >= 0; --i) {\n      bytes[i] = Number(tmp & 0xffn);\n      tmp >>= 8n;\n    }\n    return addOp(0x5f + len, bytes);\n  };\n\n  const pushB = (buf: Uint8Array) => addOp(0x5f + buf.length, 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 (let i = 0; i < seg.length; i++) {\n      const se = seg[i]!;\n      const s = se >>> 8,\n        e = se & 0xff;\n      cost += 1 + (e - s + 1); // PUSH<n> immediate bytes\n      if (31 - e > 0) cost += 3; // 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.subarray(seg[0]! >>> 8);\n    let literalVal = 0n;\n    for (let i = 0; i < literal.length; i++) literalVal = (literalVal << 8n) | BigInt(literal[i]!);\n    const literalCost = literal.length + 1;\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\n    // Try SUB: PUSH0, PUSH(x), SUB\n    const subVal = sub(0n, literalVal);\n    const subCost = pushCost(subVal) + 2;\n    if (subCost < bestCost) {\n      bestCost = subCost;\n      bestEmit = () => {\n        emitPushN(0);\n        emitPushN(subVal);\n        emitOp(0x03);\n      };\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) + 3; // 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\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 (let i = 0; i < seg.length; i++) {\n          const se = seg[i]!;\n          const s = se >>> 8,\n            e = se & 0xff;\n          const suffix0s = 31 - e;\n          emitPushB(word.subarray(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 = view.wordHexes[wordIndex]!;\n    // Encode Run?\n    let nextIndex = wordIndex + 1;\n    while (nextIndex < wordCount) {\n      const s2 = view.getSegments(nextIndex);\n      if (!s2.length) break;\n      if (view.wordHexes[nextIndex] !== wordHex) break;\n      ++nextIndex;\n    }\n    const runLen = nextIndex - wordIndex;\n\n    if (runLen >= 2) {\n      const lastIndex = nextIndex - 1;\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[3] <= lastIndex) {\n        emitOp(0x50); // POP\n      }\n      wordIndex = nextIndex;\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[6] !== -1 && wordIndex > stats[2]) {\n        const baseBytes = stats[4] === 0 ? 0 : (32 - Math.clz32(stats[4]) + 7) >> 3;\n        if (literalCost > stats[6] + baseBytes) {\n          emitPushN(stats[4]);\n          emitOp(0x51); // MLOAD\n          emitPushN(base);\n          emitOp(0x52); // MSTORE\n          ++wordIndex;\n          continue;\n        }\n      }\n    }\n    let byte8s = true;\n    for (let i = 0; i < seg.length; i++) {\n      const se = seg[i]!;\n      if (se >>> 8 !== (se & 0xff)) {\n        byte8s = false;\n        break;\n      }\n    }\n    const byte8sCost = seg.length * 3; // PUSH1(value), PUSH1(offset), MSTORE8\n    if (byte8s && byte8sCost < bestCost && byte8sCost <= shlCost) {\n      for (let i = 0; i < seg.length; i++) {\n        const s = seg[i]! >>> 8;\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  ops = [];\n  data = [];\n  stack = [];\n  trackedMemSize = 0;\n  mem = [];\n  firstPass = false;\n\n  const pre: { val: bigint; uses: number; net: number; p: number }[] = [];\n  for (const [val, uses] of stackFreq) {\n    if (\n      uses > 1 &&\n      val !== 0n &&\n      val !== 32n &&\n      val !== selfbalance &&\n      val !== decAddr &&\n      val !== fromAddr &&\n      val <= MAX_128_BIT\n    ) {\n      const p = pushCost(val);\n      const net = uses * (p - 1) - p;\n      if (net > 0) pre.push({ val, uses, net, p });\n    }\n  }\n\n  pre.sort((a, b) => b.net - a.net || b.uses - a.uses || a.p - b.p);\n  for (let i = 0; i < 15 && i < pre.length; ++i) pushN(pre[i]!.val);\n\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  // - 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  // - CALLVALUE, load target address from calldata[0], GAS, CALL\n  // - RETURNDATACOPY(0, 0, RETURNDATASIZE)\n  // - RETURN(0, RETURNDATASIZE)\n  let outLen = ops.length;\n\n  for (let i = 0; i < ops.length; ++i)\n    if (ops[i] >= 0x60 && ops[i] <= 0x7f && data[i]) outLen += data[i]!.length;\n\n  const out = new Uint8Array(outLen);\n\n  for (let i = 0, o = 0; i < ops.length; ++i) {\n    out[o++] = ops[i]!;\n    if (ops[i] >= 0x60 && ops[i] <= 0x7f && data[i]) out.set(data[i]!, o), (o += data[i]!.length);\n  }\n\n  const bytecode = '0x' + _uint8ArrayToHex(out) + _retSuffix;\n  const calldataOut = '0x' + _pad64(originalTo);\n\n  return {\n    bytecode,\n    calldata: calldataOut,\n    to: DEC_ADDR,\n    from: 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", "bits", "_normHex", "hex", "_hexes", "_", "i", "_nibbles", "t", "_hexToUint8Array", "normalized", "len", "bytes", "j", "_uint8ArrayToHex", "_zeroWord", "_emptySegments", "initMemoryView", "calldata", "padding", "originalBuf", "buffer", "rawLength", "wordCount", "roundedLength", "rounded", "segments", "wordHexes", "wordStats", "prevWordHex", "wordAt", "wordIndex", "base", "word", "wordHex", "existing", "isRunContinuation", "stats", "seg", "s", "reuseCost", "getWord", "getSegments", "slice", "offset", "size", "out", "end", "mload", "DEC_ADDR", "_pad64", "s", "_zeroW", "_cdsizeW", "_decW", "_retSuffix", "_jitDecompressor", "calldata", "to", "from", "fromHex", "_normHex", "padding", "bestW", "bestF", "originalTo", "fromAddr", "selfbalance", "ops", "data", "stack", "trackedMemSize", "mem", "firstPass", "view", "initMemoryView", "wordCount", "decAddr", "stackFreq", "decW", "fromW", "toW", "w", "st", "f", "roundUp32", "x", "getStackIdx", "val", "i", "d", "ctr", "m", "k", "delta", "pushOp", "op", "pushS", "v", "freqDelta", "pop2", "trackMem", "offset", "size", "addOp", "imm", "byteSize", "sigext", "not", "a", "b", "xor", "and", "or", "add", "sub", "shift", "shl", "shr", "idx", "MAX_256_BIT", "value", "_", "opcode", "bytesLen", "n", "t", "pushCost", "pushN", "tmp", "len", "bytes", "pushB", "buf", "plan", "emitPushN", "emitPushB", "emitOp", "o", "estShlCost", "seg", "cost", "first", "se", "e", "emitBestValueForWord", "word", "literal", "literalVal", "literalCost", "shlCost", "bestCost", "bestEmit", "notVal", "notCost", "subVal", "subCost", "numBytes", "mask", "truncated", "signCost", "shiftBits", "shifted", "notShifted", "shiftNotCost", "suffix0s", "wordIndex", "base", "wordHex", "nextIndex", "runLen", "lastIndex", "j", "stats", "baseBytes", "byte8s", "byte8sCost", "pre", "uses", "MAX_128_BIT", "p", "net", "step", "outLen", "out", "bytecode", "_uint8ArrayToHex", "calldataOut", "flzFwdBytecode", "address", "_normHex", "rleFwdBytecode", "compress_call", "payload", "alg", "method", "params", "txObj", "blockParam", "overrides", "_", "k", "originalSize", "inputData", "to", "from", "bytecode", "calldata", "decompressorAddress", "fromAddr", "balanceHex", "result", "_jitDecompressor", "jit", "flzData", "LibZip", "cdData", "flzFwdBytecode", "rleFwdBytecode", "DEC_ADDR", "_normHex", "stateOverride", "compressedTxObj"]
 }

package/_types/compiler/jit.d.ts

@@ -1,3 +1,4 @@
+export declare const DEC_ADDR = "0x00000000000000000000000000000000000000e0";
 export declare const _jitDecompressor: (calldata: string, to: string, from?: string) => {
     bytecode: string;
     calldata: string;

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

@@ -1 +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"}
+{"version":3,"file":"jit.d.ts","sourceRoot":"","sources":["../../../src/compiler/jit.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,QAAQ,+CAA+C,CAAC;AAQrE,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;CA2flF,CAAC"}

package/_types/compiler/opcodes.d.ts

@@ -9,5 +9,4 @@ 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

@@ -1 +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"}
+{"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,MAIxD,CAAC;AAEF,eAAO,MAAM,GAAG,GAAI,OAAO,MAAM,KAAG,MASnC,CAAC"}

package/_types/compiler/utils.d.ts

@@ -1,24 +1,16 @@
 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 type MemorySegment = number;
+export type WordStats = [
+    freq: number,
+    normFreq: number,
+    firstWordIndex: number,
+    lastWordIndex: number,
+    firstOffset: number,
+    lastOffset: number,
+    reuseCost: number
+];
 export interface MemoryView {
     /** Normalized hex string (without 0x) of the original payload. */
     readonly hex: string;
@@ -32,15 +24,12 @@ export interface MemoryView {
     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>;
+    /** Hex string (without 0x) for each 32-byte word in the view. */
+    readonly wordHexes: readonly string[];
     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.
-     */
+    /** Return all non-zero byte segments (packed as (s<<8)|e) within the nth 32-byte word. */
     getSegments(wordIndex: number): MemorySegment[];
     mload(offset: number): Uint8Array;
     /**

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

@@ -1 +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"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/compiler/utils.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,QAAQ,GAAI,KAAK,MAAM,KAAG,MAC4D,CAAC;AAUpG,eAAO,MAAM,gBAAgB,GAAI,KAAK,MAAM,KAAG,UAQ9C,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,OAAO,UAAU,KAAG,MAIpD,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC;AAInC,MAAM,MAAM,SAAS,GAAG;IACtB,IAAI,EAAE,MAAM;IACZ,QAAQ,EAAE,MAAM;IAChB,cAAc,EAAE,MAAM;IACtB,aAAa,EAAE,MAAM;IACrB,WAAW,EAAE,MAAM;IACnB,UAAU,EAAE,MAAM;IAClB,SAAS,EAAE,MAAM;CAClB,CAAC;AAEF,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,iEAAiE;IACjE,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IACnD,4EAA4E;IAC5E,OAAO,CAAC,SAAS,EAAE,MAAM,GAAG,UAAU,CAAC;IACvC,0FAA0F;IAC1F,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,UA6FlE,CAAC"}

package/_types/index.d.ts.map

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,OAAO,CAAC;AAOlC,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,CA8DnB"}

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

@@ -1 +1 @@
-{"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"}
+{"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,GAuFnE,CAAC"}

package/index.ts

@@ -1,5 +1,6 @@
 export const MIN_BODY_SIZE = 1150;
 
+const _hasCS = typeof CompressionStream !== 'undefined';
 const _cache = new Map<string, string | -1>();
 const _enc = ['gzip', 'deflate'] as const;
 type SupportedEncoding = (typeof _enc)[number];
@@ -39,9 +40,8 @@ export async function compressModule(
   }
 
   const cached = _cache.get(url);
-  const hasCS = typeof CompressionStream !== 'undefined';
   const known = mode === 'gzip' || mode === 'deflate';
-  const encoding = !hasCS
+  const encoding = !_hasCS
     ? null
     : known
       ? (mode as SupportedEncoding)

package/jit-compressor.ts

@@ -1,5 +1,5 @@
 import { LibZip } from 'solady';
-import { _jitDecompressor } from './compiler';
+import { _jitDecompressor, DEC_ADDR } from './compiler';
 import { _normHex } from './compiler/utils';
 import { flzFwdBytecode, rleFwdBytecode } from './contracts';
 import { MIN_BODY_SIZE } from './index';
@@ -27,10 +27,13 @@ export const compress_call = function (payload: any, alg?: string): any {
 
   // Validation
   if (
-    (overrides && Object.keys(overrides).length > 0) ||
     !txObj?.to ||
     !txObj?.data ||
-    Object.keys(txObj).some((k) => !['to', 'data', 'from'].includes(k))
+    (() => {
+      if (overrides) for (const _ in overrides) return true;
+      for (const k in txObj) if (k !== 'to' && k !== 'data' && k !== 'from') return true;
+      return false;
+    })()
   ) {
     return payload;
   }
@@ -38,7 +41,7 @@ export const compress_call = function (payload: any, alg?: string): any {
   const originalSize = txObj.data.length;
   if (originalSize < MIN_BODY_SIZE) return payload;
 
-  const inputData = '0x' + _normHex(txObj.data);
+  const inputData = txObj.data;
   const to = txObj.to;
   const from = txObj.from;
 
@@ -70,7 +73,7 @@ export const compress_call = function (payload: any, alg?: string): any {
       bytecode = rleFwdBytecode(to);
     }
 
-    decompressorAddress = '0x' + 224n.toString(16).padStart(40, '0');
+    decompressorAddress = DEC_ADDR;
     fromAddr = from ? _normHex(from).padStart(16, '0') : undefined;
     balanceHex = '0';
     if (
@@ -93,10 +96,10 @@ export const compress_call = function (payload: any, alg?: string): any {
     code: bytecode,
     balance: '0x' + balanceHex,
   };
+
   const compressedTxObj: any = { to: decompressorAddress, data: calldata };
-  if (fromAddr) {
-    compressedTxObj.from = '0x' + fromAddr;
-  }
+
+  if (fromAddr) compressedTxObj.from = '0x' + fromAddr;
 
   return {
     ...payload,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eth-compress",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "private": false,
   "type": "module",
   "description": "Client-to-server compression (viem-compatible) module for compressed, gas-efficient, low-latency eth_call requests.",
@@ -99,7 +99,7 @@
     "node": ">=22",
     "pnpm": ">=10"
   },
-  "packageManager": "pnpm@10.25.0",
+  "packageManager": "pnpm@10.26.1",
   "pnpm": {
     "peerDependencyRules": {
       "ignoreMissing": [
@@ -111,16 +111,16 @@
     "solady": "0.1.26"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.3.8",
+    "@biomejs/biome": "2.3.10",
     "@ethereumjs/common": "10.1.0",
     "@ethereumjs/util": "10.1.0",
     "@ethereumjs/vm": "10.1.0",
-    "@types/bun": "1.3.4",
-    "@types/node": "25.0.1",
-    "esbuild": "0.27.1",
+    "@types/bun": "1.3.5",
+    "@types/node": "25.0.3",
+    "esbuild": "0.27.2",
     "typescript": "5.9.3",
-    "viem": "2.41.2",
-    "vitest": "4.0.15"
+    "viem": "2.43.3",
+    "vitest": "4.0.16"
   },
   "browserslist": [
     ">0.3%",