eth-compress 0.2.2 → 0.3.1

package/_esm/jit-compressor.js

@@ -1,5 +1,3 @@
-import{LibZip as at}from"solady";import{MIN_BODY_SIZE as It}from"./index";const Mt=(1n<<128n)-1n,d=(1n<<256n)-1n,P=s=>s.replace(/^0x/,"").toLowerCase(),St=s=>{const i=P(s),b=i.length,a=new Uint8Array(b/2);for(let c=0;c<b;c+=2)a[c/2]=Number.parseInt(i.slice(c,c+2),16);return a},gt=s=>{let i="";for(let b=0;b<s.length;b++)i+=s[b].toString(16).padStart(2,"0");return i},G=s=>~s&d,kt=(s,i)=>s&i&d,At=(s,i)=>(s|i)&d,_t=(s,i)=>(s^i)&d,mt=(s,i)=>i<<s&d,xt=(s,i)=>i>>s&d,ht=(s,i)=>s-i&d,dt=(s,i)=>{const b=Number(s)+1,a=(1n<<BigInt(b*8))-1n,c=1n<<BigInt(b*8-1),y=i&a;return(y&c?y|~a&d:y)&d};//! @__PURE__
-const zt=s=>`0x365f73${P(s)}815b838110602f575f80848134865af1503d5f803e3d5ff35b803590815f1a8060051c908115609857600190600783149285831a6007018118840218600201948383011a90601f1660081b0101808603906020811860208211021890815f5b80830151818a015201858110609257505050600201019201916018565b82906075565b6001929350829150019101925f5b82811060b3575001916018565b85851060c1575b60010160a6565b936001818192355f1a878501530194905060ba56`;//! @__PURE__
-const Ut=s=>`0x5f5f5b368110602d575f8083813473${P(s)}5af1503d5f803e3d5ff35b600180820192909160031981019035185f1a8015604c57815301906002565b505f19815282820192607f9060031981019035185f1a818111156072575b160101906002565b838101368437606a56`,Nt=function(s){const i=P(s),b=St(i),a=28,c=new Uint8Array(a+b.length);c.set(b,a);const y=c.length;let p=[],M=[],x=[],S=0,B=new Map,A=!0;const k=t=>{let e=x.lastIndexOf(t);return e=e===-1?-1:x.length-1-e,e>15?-1:e},K=new Map,J=new Map,Q=new Map,L=new Map,X=new Map,yt=t=>t+31&-32;let tt=0;const Z=new Map,w=()=>[x.pop(),x.pop()],nt=(t,e,n)=>t.set(e,(t.get(e)||0)+n),et=(t,e)=>nt(t,e,1),_=(t,e)=>{p.push(t),et(K,t);const n=e??null;M.push(n),et(J,n)},l=(t,e=1)=>{x.push(t),nt(Q,t,e),++tt,Z.set(t,tt)},st=(t,e)=>{S=yt(t+e)},O=(t,e)=>{if(t===54)l(32n,0);else if(t===89)l(BigInt(S),0);else if(t===11){const[n,o]=w();l(dt(n,o),1)}else if(t===25){const n=x.pop();l(G(n),0)}else if(t===24){const[n,o]=w();l(_t(n,o),1)}else if(t===22){const[n,o]=w();l(kt(n,o),1)}else if(t===3){const[n,o]=w();l(ht(n,o),1)}else if(t===27){let[n,o]=w();l(mt(n,o),1)}else if(t===28){let[n,o]=w();l(xt(n,o),1)}else if(t===23){let[n,o]=w();l(At(n,o),1)}else if(t>=96&&t<=127||t===95){let n=0n;for(const h of e||[])n=n<<8n|BigInt(h);if(n==224n){l(n,0),_(48);return}if(n==32n){l(n,0),_(54);return}if(n===BigInt(S)){l(n,0),_(89);return}const o=k(n);if(o!==-1&&t!=95){l(n,A?1:-1),_(128+o);return}if(n==d){l(n),_(95),_(25);return}l(n)}else if(t===81){const n=Number(x.pop());l(B.has(n)?B.get(n):0n)}else if(t===82){const[n,o]=w(),h=Number(n);B.set(h,o&d),st(h,32)}else if(t===83){const[n,o]=w();st(Number(n),1)}else t===243&&w();_(t,e||null)},T=t=>O(t),z=t=>{if(t>0&&t===S)return O(89);if(t==32n)return O(54);if(!t)return O(95,void 0);let e=BigInt(t),n=[];for(;e;)n.unshift(Number(e&0xffn)),e>>=8n;return O(95+n.length,n)},it=t=>O(95+t.length,Array.from(t)),Bt=(t,e)=>(t.match(new RegExp(e,"g"))||[]).length,wt=t=>{let e=0,n=!0;for(const{s:o,e:h}of t)e+=1+h-o+1,31-h>0&&(e+=3),n||(e+=1),n=!1;return e},V=[],u=t=>(V.push({t:"num",v:t}),z(t)),H=t=>(V.push({t:"bytes",b:t}),it(t)),g=t=>(V.push({t:"op",o:t}),T(t));z(1n);const $=[1n,32n,224n];for(let t=0;t<y;t+=32){const e=new Uint8Array(32);e.set(c.slice(t,Math.min(t+32,y)),0);const n=[];for(let r=0;r<32;){for(;r<32&&e[r]===0;)++r;if(r>=32)break;const m=r;for(;r<32&&e[r]!==0;)++r;n.push({s:m,e:r-1})}if(!n.length)continue;const o=e.slice(n[0].s),h=1+o.length;let C=0n;for(const r of o)C=C<<8n|BigInt(r);const rt=Math.ceil(Math.log2(t+1)/8),U=gt(e),ot=wt(n),ct=$.includes(C);if(ct){H(o),u(t),g(82);continue}if(h>8){if(L.has(U)){if(h>X.get(U)+rt){u(L.get(U)),g(81),u(t),g(82);continue}}else if(X.get(U)!=-1){const r=rt+3,m=Bt(i,U);X.set(U,m*32>m*r?r:-1),L.set(U,t)}}const Ct=n.every(({s:r,e:m})=>r===m),ft=n.length*3;if(ct)H(o);else{let r=h,m=()=>{H(o)};C==d&&(r=2,m=()=>{u(W),g(25)});const W=G(C);let D=0,j=W;for(;j>0n;)++D,j>>=8n;D=1+D;const lt=D+1;lt<r&&(r=lt,m=()=>{u(W),g(25)});const Y=ht(0n,C);let q=0;for(j=Y;j>0n;)++q,j>>=8n;q===0&&(q=1),$.includes(Y)&&(q=1);const bt=1+(1+q)+1;bt<r&&(r=bt,m=()=>{u(0),u(Y),g(3)});for(let f=1;f<o.length;f++){const E=(1n<<BigInt(f*8))-1n,I=C&E,F=dt(BigInt(f-1),I);if(F===C&&(I&1n<<BigInt(f*8-1))!==0n){let N=1+f;$.includes(BigInt(F))&&(N=1);let R=N+2+1;R<r&&(r=R,m=()=>{u(I),u(f-1),g(11)});break}}for(let f=8;f<=248;f+=8){const E=xt(BigInt(f),C);if(E===0n)break;const I=G(E);if(mt(BigInt(f),I)===C){let N=0,R=I;for(;R>0n;)++N,R>>=8n;N===0&&(N=1);const ut=1+N+2+1+1;ut<r&&(r=ut,m=()=>{u(I),u(f),g(27),g(25)})}}if(Ct&&ft<r&&ft<=ot){for(const{s:f}of n)u(e[f]),u(t+f),g(83);continue}else if(ot<r){let f=!0;for(const{s:E,e:I}of n){const F=31-I;H(e.slice(E,I+1)),F>0&&(u(F*8),g(27)),f||g(23),f=!1}}else m()}u(t),g(82)}p=[],M=[],x=[],S=0,B=new Map,Array.from(Q.entries()).filter(([t,e])=>e>1&&t>1n&&t!==32n&&t!==224n).sort((t,e)=>Z.get(e[0])-Z.get(t[0])).filter(([t,e])=>typeof t=="number"?BigInt(t):t<=Mt).slice(0,15).forEach(([t,e])=>{z(t)}),z(1n);for(const t of V)t.t==="num"?z(t.v):t.t==="bytes"?it(t.b):t.t==="op"&&T(t.o);T(95),T(95),z(b.length),z(a);const v=[];for(let t=0;t<p.length;++t)v.push(p[t]),p[t]>=96&&p[t]<=127&&M[t]&&v.push(...M[t]);return"0x"+gt(new Uint8Array(v))+"345f355af13d5f5f3e3d5ff3"},pt="0x00000000000000000000000000000000000000e0";//! @__PURE__
-const Et=function(s,i){const{method:b,params:a}=s;if(b&&b!=="eth_call")return s;const c=a?.[0]||s,y=a?.[1],p=a?.[2];if(y&&y!=="latest"||p&&Object.keys(p).length>0||!c?.to||!c?.data||Object.keys(c).some(k=>!["to","data","from"].includes(k)))return s;const M=c.data.length;if(M<It)return s;const x="0x"+P(c.data),S=c.to;let B,A;if(i==="jit"||!i&&(M<3e3||M>=8e3))B=Nt(x),A="0x"+P(S).padStart(64,"0");else{const k=i==="flz"||!i?at.flzCompress(x):null,K=i==="cd"||!i&&k?at.cdCompress(x):null;i==="flz"||!i&&k&&(!K||k.length<K.length)?(A=k,B=zt(S)):(A=K,B=Ut(S))}return B.length+A.length>=M?s:{...s,params:[{...c,to:pt,data:A},y||"latest",{...p,[pt]:{code:B}}]}};export{Et as compress_call};
+import{LibZip as Wt}from"solady";var wt=(1n<<128n)-1n,k=(1n<<256n)-1n;var et=o=>~o&k;var At=(o,r)=>o&r&k,St=(o,r)=>(o|r)&k,_t=(o,r)=>(o^r)&k,Bt=(o,r)=>o+r&k,it=(o,r)=>o-r&k,ct=(o,r)=>r<<o&k,ft=(o,r)=>r>>o&k,at=(o,r)=>{if(o>=31n)return r&k;let h=Number((o+1n)*8n);return BigInt.asUintN(256,BigInt.asIntN(h,r))};var j=o=>(o.charCodeAt(0)===48&&(o.charCodeAt(1)|32)===120?o.slice(2):o).toLowerCase(),Dt=Array.from({length:256},(o,r)=>r.toString(16).padStart(2,"0")),It=(()=>{let o=new Int8Array(103).fill(-1);for(let r=0;r<10;r++)o[48+r]=r;for(let r=0;r<6;r++)o[97+r]=10+r;return o})(),Lt=o=>{let r=j(o),h=r.length,w=new Uint8Array(h/2);for(let l=0,H=0;l<h;l+=2)w[H++]=It[r.charCodeAt(l)]<<4|It[r.charCodeAt(l+1)];return w},lt=o=>{let r="";for(let h=0;h<o.length;h++)r+=Dt[o[h]];return r},Nt=new Uint8Array(32),Ft=[],Mt=(o,r)=>{let h=j(o),w=Lt(h),l=new Uint8Array(r+w.length);l.set(w,r);let H=l.length,A=Math.ceil(H/32),L=A*32;if(H!==L){let i=new Uint8Array(L);i.set(l,0),l=i}let M=new Array(A),C=new Array(A),g=new Map,m=null,u=i=>{let f=i<<5;return l.subarray(f,f+32)};for(let i=0;i<A;i++){let f=i<<5,d=u(i),W=lt(d);C[i]=W;let V=g.get(W),rt=m===W;if(V)V[0]+=1,rt||(V[1]+=1),V[3]=i,V[5]=f;else{let _=[1,1,i,i,f,f,-1];g.set(W,_)}m=W;let Y=[];for(let _=0;_<32;){for(;_<32&&d[_]===0;)++_;if(_>=32)break;let ot=_;for(;_<32&&d[_]!==0;)++_;Y.push(ot<<8|_-1)}M[i]=Y}for(let i of g.values()){let d=(i[4]===0?0:32-Math.clz32(i[4])+7>>3)+3;i[6]=32>d?d:-1}let U=i=>i<0||i>=A?Nt:u(i),N=i=>i<0||i>=A?Ft:M[i],F=(i,f)=>{if(f<=0)return new Uint8Array(0);let d=new Uint8Array(f);if(i<0||i>=H)return d;let W=Math.min(i+f,H);return d.set(l.subarray(i,W),0),d},S=i=>F(i,32);return{hex:h,buffer:l,roundedLength:L,padding:r,dataLength:w.length,wordCount:A,wordHexes:C,wordStats:g,getWord:U,getSegments:N,mload:S,slice:F}};var ut="0x00000000000000000000000000000000000000e0",R=o=>o.padStart(64,"0"),Ot=R("0"),Tt=R("20"),jt=R("e0"),Vt="345f355af13d5f5f3e3d5ff3",bt=function(o,r,h){let w=h?j(h):null,l=28,H=null,A=0,L=j(r).padStart(16,"0"),M=w?BigInt("0x"+w):96n,C=2n,g=[],m=[],u=[],U=0,N=[],F=!0,S=Mt(o,l),{wordCount:i}=S,f=224n,d=new Map,W=jt,V=R(w??M.toString(16)),rt=R(L);for(let[t,e]of S.wordStats){let n=e[0];t===Ot||t===Tt||t===W||t===V||t===rt||n>A&&(A=n,H=t)}H&&(C=BigInt("0x"+H));let Y=t=>t+31&-32,_=t=>{for(let e=u.length-1,n=0;n<16&&e>=0;--e,++n)if(u[e]===t)return n;return-1},ot=(t,e,n)=>t.set(e,(t.get(e)||0)+n),O=(t,e)=>{g.push(t),m.push(e??null)},a=(t,e=1)=>{u.push(t),e!==0&&ot(d,t,e)},T=()=>[u.pop(),u.pop()],gt=(t,e)=>{U=Y(t+e)},P=(t,e)=>{if(t===128&&a(u[u.length-1],F?0:1),t===80&&u.pop(),t===71&&a(C,0),t===48&&a(f,0),t===51&&a(M,0),t===54&&a(32n,0),t===89&&a(BigInt(U),0),t===11){let[n,s]=T();a(at(n,s),1)}if(t===25&&a(et(u.pop()),0),t===24){let[n,s]=T();a(_t(n,s),1)}if(t===22){let[n,s]=T();a(At(n,s),1)}if(t===23){let[n,s]=T();a(St(n,s),1)}if(t===1){let[n,s]=T();a(Bt(n,s),1)}if(t===3){let[n,s]=T();a(it(s,n),1)}if(t===27){let[n,s]=T();a(ct(n,s),1)}if(t===28){let[n,s]=T();a(ft(n,s),1)}if(t>=96&&t<=127||t===95){let n=0n;for(let b of e||[])n=n<<8n|BigInt(b);if(n===C){a(n,0),O(71);return}if(n===f){a(n,0),O(48);return}if(n===M){a(n,0),O(51);return}if(n===32n){a(n,0),O(54);return}if(n===BigInt(U)&&n!=0n){a(n,0),O(89);return}let s=_(n);if(s!=-1&&t!=95){a(n,F?1:0),O(128+s);return}if(n===k){a(n,0),O(95),O(25);return}a(n,1),O(t,e||null);return}if(t===81&&a(N[Number(u.pop())>>>5]??0n,0),t===82){let[n,s]=T(),b=Number(n);N[b>>>5]=s&k,gt(b,32)}if(t===83){let[n,s]=T();gt(Number(n),1)}O(t,e||null)},G=t=>P(t),mt=t=>{if(t===0n)return 0;let e=0,n=t<0n?-t:t;for(;n>0n;)++e,n>>=8n;return e},q=t=>t===0n?1:1+mt(t),K=t=>{let e=typeof t=="bigint"?t:BigInt(t);if(e>0n&&e===BigInt(U))return P(89);if(e===32n)return P(54);if(e===0n)return P(95);let n=e,s=mt(n),b=new Uint8Array(s);for(let D=s-1;D>=0;--D)b[D]=Number(n&0xffn),n>>=8n;return P(95+s,b)},dt=t=>P(95+t.length,t),J=[],B=t=>{J.push({t:"num",v:t}),K(t)},xt=t=>{J.push({t:"bytes",b:t}),dt(t)},y=t=>{J.push({t:"op",o:t}),G(t)},zt=t=>{let e=0,n=!0;for(let s=0;s<t.length;s++){let b=t[s],D=b>>>8,p=b&255;e+=1+(p-D+1),31-p>0&&(e+=3),n||(e+=1),n=!1}return e},ht=(t,e)=>{let n=t.subarray(e[0]>>>8),s=0n;for(let c=0;c<n.length;c++)s=s<<8n|BigInt(n[c]);let b=n.length+1,D=zt(e),p=b,v=()=>xt(n),tt=et(s),nt=q(tt)+1;nt<p&&(p=nt,v=()=>{B(tt),y(25)});let Z=it(0n,s),$=q(Z)+2;$<p&&(p=$,v=()=>{B(0),B(Z),y(3)});for(let c=1;c<n.length;c++){let x=(1n<<BigInt(c*8))-1n,I=s&x;if(at(BigInt(c-1),I)===s&&(I&1n<<BigInt(c*8-1))!==0n){let E=q(I)+3;E<p&&(p=E,v=()=>{B(I),B(c-1),y(11)});break}}for(let c=8;c<=248;c+=8){let x=ft(BigInt(c),s);if(x===0n)break;let I=et(x);if(ct(BigInt(c),I)===s){let E=q(I)+q(BigInt(c))+2;E<p&&(p=E,v=()=>{B(I),B(c),y(27),y(25)})}}return D<p&&(p=D,v=()=>{let c=!0;for(let x=0;x<e.length;x++){let I=e[x],X=I>>>8,E=I&255,pt=31-E;xt(t.subarray(X,E+1)),pt>0&&(B(pt*8),y(27)),c||y(23),c=!1}}),{literal:n,literalVal:s,bestCost:p,bestEmit:v,literalCost:b,shlCost:D}},z=0;for(;z<i;){let t=z*32,e=S.getWord(z),n=S.getSegments(z);if(!n.length){++z;continue}let s=S.wordHexes[z],b=z+1;for(;b<i&&!(!S.getSegments(b).length||S.wordHexes[b]!==s);)++b;let D=b-z;if(D>=2){let c=b-1,{bestEmit:x}=ht(e,n);x(),y(128),B(t),y(82);for(let X=1;X<D;X++)y(128),y(89),y(82);let I=S.wordStats.get(s);I&&I[3]<=c&&y(80),z=b;continue}let{literalCost:p,shlCost:v,bestCost:tt,bestEmit:nt}=ht(e,n);if(p>8){let c=S.wordStats.get(s);if(c&&c[6]!==-1&&z>c[2]){let x=c[4]===0?0:32-Math.clz32(c[4])+7>>3;if(p>c[6]+x){B(c[4]),y(81),B(t),y(82),++z;continue}}}let Z=!0;for(let c=0;c<n.length;c++){let x=n[c];if(x>>>8!==(x&255)){Z=!1;break}}let $=n.length*3;if(Z&&$<tt&&$<=v){for(let c=0;c<n.length;c++){let x=n[c]>>>8;B(e[x]),B(t+x),y(83)}++z;continue}nt(),B(t),y(82),++z}g=[],m=[],u=[],U=0,N=[],F=!1;let Q=[];for(let[t,e]of d)if(e>1&&t!==0n&&t!==32n&&t!==C&&t!==f&&t!==M&&t<=wt){let n=q(t),s=e*(n-1)-n;s>0&&Q.push({val:t,uses:e,net:s,p:n})}Q.sort((t,e)=>e.net-t.net||e.uses-t.uses||t.p-e.p);for(let t=0;t<15&&t<Q.length;++t)K(Q[t].val);for(let t of J)t.t==="num"?K(t.v):t.t==="bytes"?dt(t.b):t.t==="op"&&G(t.o);G(95),G(95),K(S.dataLength),K(l);let yt=g.length;for(let t=0;t<g.length;++t)g[t]>=96&&g[t]<=127&&m[t]&&(yt+=m[t].length);let st=new Uint8Array(yt);for(let t=0,e=0;t<g.length;++t)st[e++]=g[t],g[t]>=96&&g[t]<=127&&m[t]&&(st.set(m[t],e),e+=m[t].length);let kt="0x"+lt(st)+Vt,Ht="0x"+R(L);return{bytecode:kt,calldata:Ht,to:ut,from:M.toString(16).padStart(40,"0"),balance:C.toString(16)}};var Ct=o=>`0x365f73${j(o)}815b838110602f575f80848134865af1503d5f803e3d5ff35b803590815f1a8060051c908115609857600190600783149285831a6007018118840218600201948383011a90601f1660081b0101808603906020811860208211021890815f5b80830151818a015201858110609257505050600201019201916018565b82906075565b6001929350829150019101925f5b82811060b3575001916018565b85851060c1575b60010160a6565b936001818192355f1a878501530194905060ba56`;var Ut=o=>`0x5f5f5b368110602d575f8083813473${j(o)}5af1503d5f803e3d5ff35b600180820192909160031981019035185f1a8015604c57815301906002565b505f19815282820192607f9060031981019035185f1a818111156072575b160101906002565b838101368437606a56`;var rn=function(o,r){let{method:h,params:w}=o;if(h&&h!=="eth_call")return o;let l=w?.[0]||o,H=w?.[1],A=w?.[2];if(!l?.to||!l?.data||(()=>{if(A)for(let f in A)return!0;for(let f in l)if(f!=="to"&&f!=="data"&&f!=="from")return!0;return!1})())return o;let L=l.data.length;if(L<1150)return o;let M=l.data,C=l.to,g=l.from,m,u,U,N,F;if(r==="jit"||!r&&(L<3e3||L>=8e3)){let f=bt(M,C,g);m=f.bytecode,u=f.calldata,U=f.to,N=f.from,F=f.balance}else{let f=r?null:bt(M,C,g),d=r==="flz"||!r?Wt.flzCompress(M):null,W=r==="cd"||!r&&d?Wt.cdCompress(M):null;r==="flz"||!r&&d&&(!W||d.length<W.length)?(u=d,m=Ct(C)):(u=W,m=Ut(C)),U=ut,N=g?j(g).padStart(16,"0"):void 0,F="0",!r&&f&&f.bytecode.length+f.calldata.length<m.length+u.length&&(m=f.bytecode,u=f.calldata,U=f.to,N=f.from,F=f.balance)}if(m.length+u.length>=L)return o;let S={code:m,balance:"0x"+F},i={to:U,data:u};return N&&(i.from="0x"+N),{...o,params:[i,H,{...A,[U]:S}]}};export{rn as compress_call};
+//! @__PURE__
 //# sourceMappingURL=jit-compressor.js.map

package/_esm/jit-compressor.js.map

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

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

package/_types/compiler/utils.d.ts

@@ -0,0 +1,42 @@
+export declare const _normHex: (hex: string) => string;
+export declare const _hexToUint8Array: (hex: string) => Uint8Array;
+export declare const _uint8ArrayToHex: (bytes: Uint8Array) => string;
+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;
+    /** 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;
+    /** 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 (packed as (s<<8)|e) within the nth 32-byte 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,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/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,36 +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":"AAAA,eAAO,MAAM,aAAa,OAAO,CAAC;AAMlC,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC;AAE7D;;;;;;;;GAQG;AAEH,wBAAsB,cAAc,CAClC,KAAK,EAAE,MAAM,GAAG,GAAG,GAAG,OAAO,EAC7B,IAAI,CAAC,EAAE,WAAW,GACjB,OAAO,CAAC,QAAQ,CAAC,CAAC;AAGrB,wBAAsB,cAAc,CAClC,KAAK,EAAE,MAAM,GAAG,GAAG,GAAG,OAAO,EAC7B,IAAI,EAAE,WAAW,GAAG,SAAS,EAC7B,gBAAgB,CAAC,EAAE,gBAAgB,GAClC,OAAO,CAAC,QAAQ,CAAC,CAAC;AA4DrB;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,eAAO,MAAM,qBAAqB,GAChC,OAAO,WAAW,GAAG,GAAG,EACxB,OAAO,WAAW,KACjB,OAAO,CAAC,QAAQ,CAIlB,CAAC"}
+{"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

@@ -3,7 +3,6 @@
  * Auto-selects best algorithm if not specified. Only compresses if >800 bytes and beneficial.
  *
  * Only applies compression to calls that:
- * - target the latest block ID
  * - have no state overrides
  * - have a target address and calldata
  * - have no other properties (nonce, gas, etc.)

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

@@ -1 +1 @@
-{"version":3,"file":"jit-compressor.d.ts","sourceRoot":"","sources":["../../src/jit-compressor.ts"],"names":[],"mappings":"AA6eA;;;;;;;;;;;;;;GAcG;AAEH,eAAO,MAAM,aAAa,GAAa,SAAS,GAAG,EAAE,MAAM,MAAM,KAAG,GA4DnE,CAAC"}
+{"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"}