{ "blocked": null, "replica_source": "# SPDX-License-Identifier: MIT\n\"\"\"CH market replica. Requires numpy and numba; run_many returns N x 4 floats.\nColumns: edge, retail_edge, arb_edge, retail_volume (Y units).\nRandom paths use NumPy/Numba MT19937 instead of Rust Pcg64; distributions match.\nTH values are fractions, except count caps and DIR_IMPACT_MULT.\nTH[-1] selects flat fee mode when >=0 (otherwise CH).\n\"\"\"\nimport math\nimport multiprocessing as mp\nimport numpy as np\nfrom numba import njit\nTH_NAMES = ['ELAPSED_CAP', 'SIGNAL_THRESHOLD', 'DIR_DECAY', 'ACT_DECAY', 'SIZE_DECAY', 'TOX_DECAY', 'SIGMA_DECAY', 'LAMBDA_DECAY', 'SIZE_BLEND_DECAY', 'TOX_BLEND_DECAY', 'ACT_BLEND_DECAY', 'PHAT_ALPHA', 'PHAT_ALPHA_RETAIL', 'DIR_IMPACT_MULT', 'GATE_SIGMA_MULT', 'MIN_GATE', 'TRADE_TOX_BOOST', 'STALE_ATTRACT_FRAC', 'RET_CAP', 'TOX_CAP', 'TRADE_RATIO_CAP', 'LAMBDA_CAP', 'STEP_COUNT_CAP', 'BASE_FEE', 'SIGMA_COEF', 'LAMBDA_COEF', 'FLOW_SIZE_COEF', 'TOX_COEF', 'TOX_QUAD_COEF', 'ACT_COEF', 'DIR_COEF', 'DIR_TOX_COEF', 'STALE_DIR_COEF', 'SIGMA_TOX_COEF', 'TAIL_KNEE', 'TAIL_SLOPE_PROTECT', 'TAIL_SLOPE_ATTRACT', 'INIT_SIGMA', 'INIT_LAMBDA', 'INIT_SIZE', 'FLAT_FEE']\nTH = np.array([8.0, 0.0015384615384615385, 0.75, 0.53, 0.53, 0.91, 0.69, 0.99, 0.828, 0.051, 0.985, 0.27, 0.06, 4.0, 7.2, 0.03, 0.35000000000000003, 1.05, 0.02857142857142857, 0.2, 0.2, 1.82, 64.0, 0.0004, 0.2, 0.0012000000000000001, 0.4842, 0.030000000000000002, 1.5, 9.1843, 0.002, 0.01, 0.685, 0.05, 0.060000000000000005, 0.93, 0.85, 0.00095, 0.8, 0.002, -1.0], dtype=np.float64)\n# STRATEGY BEGIN\n@njit(cache=True)\ndef strat_init(S, TH, x0, y0):\n S[:] = 0.0\n S[0] = TH[23]; S[1] = TH[23]; S[3] = 1.\n S[5] = y0/x0 if x0>0 else 100.\n S[6] = TH[-4]; S[7] = TH[-3]; S[8] = TH[-2]\n if TH[-1]>=0: return TH[-1],TH[-1]\n return S[0],S[1]\n\n@njit(cache=True)\ndef strat_after(S, TH, is_buy, amount_x, amount_y, timestamp, reserve_x, reserve_y):\n if TH[-1]>=0: return TH[-1],TH[-1]\n ELAPSED_CAP = TH[0]\n SIGNAL_THRESHOLD = TH[1]\n DIR_DECAY = TH[2]\n ACT_DECAY = TH[3]\n SIZE_DECAY = TH[4]\n TOX_DECAY = TH[5]\n SIGMA_DECAY = TH[6]\n LAMBDA_DECAY = TH[7]\n SIZE_BLEND_DECAY = TH[8]\n TOX_BLEND_DECAY = TH[9]\n ACT_BLEND_DECAY = TH[10]\n PHAT_ALPHA = TH[11]\n PHAT_ALPHA_RETAIL = TH[12]\n DIR_IMPACT_MULT = TH[13]\n GATE_SIGMA_MULT = TH[14]\n MIN_GATE = TH[15]\n TRADE_TOX_BOOST = TH[16]\n STALE_ATTRACT_FRAC = TH[17]\n RET_CAP = TH[18]\n TOX_CAP = TH[19]\n TRADE_RATIO_CAP = TH[20]\n LAMBDA_CAP = TH[21]\n STEP_COUNT_CAP = TH[22]\n BASE_FEE = TH[23]\n SIGMA_COEF = TH[24]\n LAMBDA_COEF = TH[25]\n FLOW_SIZE_COEF = TH[26]\n TOX_COEF = TH[27]\n TOX_QUAD_COEF = TH[28]\n ACT_COEF = TH[29]\n DIR_COEF = TH[30]\n DIR_TOX_COEF = TH[31]\n STALE_DIR_COEF = TH[32]\n SIGMA_TOX_COEF = TH[33]\n TAIL_KNEE = TH[34]\n TAIL_SLOPE_PROTECT = TH[35]\n TAIL_SLOPE_ATTRACT = TH[36]\n d,a,ph,sig,lam,sz,tox,cnt = S[3],S[4],S[5],S[6],S[7],S[8],S[9],S[10]\n if timestamp>S[2]:\n raw=timestamp-S[2]; dt=min(raw,ELAPSED_CAP)\n d=1.+(d-1.)*DIR_DECAY**dt\n a*=ACT_DECAY**dt; sz*=SIZE_DECAY**dt; tox*=TOX_DECAY**dt\n if cnt>0: lam=lam*LAMBDA_DECAY+min(cnt/raw,LAMBDA_CAP)*(1-LAMBDA_DECAY)\n cnt=0.\n first=cnt==0\n spot=reserve_y/reserve_x if reserve_x>0 else ph\n if ph==0: ph=spot\n gamma=1.-(S[0] if is_buy else S[1])\n implied=spot if gamma<=0 else (spot*gamma if is_buy else spot/gamma)\n ret=abs(implied-ph)/ph if ph>0 else 0.\n alpha=PHAT_ALPHA if first else PHAT_ALPHA_RETAIL\n if ret<=max(sig*GATE_SIGMA_MULT,MIN_GATE): ph=ph*(1-alpha)+implied*alpha\n if first: sig=sig*SIGMA_DECAY+min(ret,RET_CAP)*(1-SIGMA_DECAY)\n ratio=min(amount_y/reserve_y if reserve_y>0 else 0.,TRADE_RATIO_CAP)\n if ratio>SIGNAL_THRESHOLD:\n push=min(ratio*DIR_IMPACT_MULT,.25)\n d=min(d+push,2.) if is_buy else max(d-push,0.)\n a=a*ACT_BLEND_DECAY+ratio*(1-ACT_BLEND_DECAY)\n sz=min(sz*SIZE_BLEND_DECAY+ratio*(1-SIZE_BLEND_DECAY),1.)\n tox=tox*TOX_BLEND_DECAY+min(abs(spot-ph)/ph if ph>0 else 0.,TOX_CAP)*(1-TOX_BLEND_DECAY)\n cnt=min(cnt+1,STEP_COUNT_CAP)\n mid=BASE_FEE+SIGMA_COEF*sig+LAMBDA_COEF*lam+FLOW_SIZE_COEF*lam*sz\n mid+=TOX_COEF*tox+TOX_QUAD_COEF*tox*tox+ACT_COEF*a+SIGMA_TOX_COEF*sig*tox\n dev=abs(d-1.); pressure=d>=1.\n skew=DIR_COEF*dev+DIR_TOX_COEF*dev*tox\n bid=mid+skew if pressure else max(mid-skew,0.)\n ask=max(mid-skew,0.) if pressure else mid+skew\n shift=STALE_DIR_COEF*tox; attract=shift*STALE_ATTRACT_FRAC\n if spot>=ph: bid+=shift; ask=max(ask-attract,0.)\n else: ask+=shift; bid=max(bid-attract,0.)\n if (is_buy and spot>=ph) or ((not is_buy) and spotTAIL_KNEE: bid=TAIL_KNEE+(bid-TAIL_KNEE)*bs\n if ask>TAIL_KNEE: ask=TAIL_KNEE+(ask-TAIL_KNEE)*ass\n bid=min(max(bid,0.),.1); ask=min(max(ask,0.),.1)\n S[0]=bid; S[1]=ask; S[2]=timestamp; S[3]=d; S[4]=a; S[5]=ph\n S[6]=sig; S[7]=lam; S[8]=sz; S[9]=tox; S[10]=cnt\n return bid,ask\n# STRATEGY END\n\n@njit(cache=True)\ndef execute(x,y,bid,ask,mode,amount):\n # mode 0: gross X input; 1: X output; 2: gross Y input.\n k=x*y\n if mode==0:\n ax=amount; nx=x+ax*(1-bid); ny=k/nx; ay=y-ny\n return nx,ny,ax,ay\n if mode==1:\n ax=amount; nx=x-ax; ny=k/nx; ay=(ny-y)/(1-ask)\n return nx,ny,ax,ay\n ay=amount; ny=y+ay*(1-ask); nx=k/ny; ax=x-nx\n return nx,ny,ax,ay\n\n@njit(cache=True)\ndef run_market(TH, seed, mean_size, rate, sigma, n_steps):\n # Independent price and retail streams, seeded seed and seed+1.\n np.random.seed(seed)\n shocks=np.random.normal(0.,1.,n_steps)\n np.random.seed(seed+1)\n S=np.zeros(40,np.float64)\n x=np.full(2,100.); y=np.full(2,10000.)\n bid=np.full(2,.003); ask=np.full(2,.003)\n bid[0],ask[0]=strat_init(S,TH,x[0],y[0])\n price=100.; re=0.; ae=0.; vol=0.\n mu=math.log(max(mean_size,.01))-.5*1.2**2\n for t in range(n_steps):\n price*=math.exp(-.5*sigma*sigma+sigma*shocks[t])\n for i in range(2):\n k=x[i]*y[i]; mode=0; amt=0.\n if y[i]/x[i]price:\n amt=(math.sqrt(k*(1-bid[i])/price)-x[i])/(1-bid[i])\n if amt>0:\n nx,ny,ax,ay=execute(x[i],y[i],bid[i],ask[i],mode,amt)\n profit=ax*price-ay if mode==1 else ay-ax*price\n if profit>0 and ay>0:\n x[i]=nx; y[i]=ny\n if i==0:\n ae-=profit\n bid[0],ask[0]=strat_after(S,TH,mode==0,ax,ay,t,nx,ny)\n n=np.random.poisson(max(rate,.01))\n for j in range(n):\n size=math.exp(mu+1.2*np.random.normal())\n buy=np.random.random()<.5\n total=size if buy else size/price\n g0=1-(ask[0] if buy else bid[0]); g1=1-.003\n r=math.sqrt(x[0]*y[0]*g0)/math.sqrt(x[1]*y[1]*g1)\n u0=y[0] if buy else x[0]; u1=y[1] if buy else x[1]\n split=min(max((r*(u1+g1*total)-u0)/(g0+r*g1),0.),total)\n for i in range(2):\n amt=split if i==0 else total-split\n if amt>.0001:\n mode=2 if buy else 0\n nx,ny,ax,ay=execute(x[i],y[i],bid[i],ask[i],mode,amt)\n if ax>0 and ay>0:\n x[i]=nx; y[i]=ny\n if i==0:\n re+=ay-ax*price if buy else ax*price-ay\n vol+=ay\n bid[0],ask[0]=strat_after(S,TH,not buy,ax,ay,t,nx,ny)\n return ae+re,re,ae,vol\n\ndef market_config(seed):\n rng=np.random.default_rng(int(seed))\n return rng.uniform(19.,21.),rng.uniform(.6,1.),rng.uniform(.000882,.001008)\n\ndef _worker(args):\n th,seeds,n_steps=args\n out=np.empty((len(seeds),4))\n for i,seed in enumerate(seeds):\n size,rate,sigma=market_config(seed)\n out[i]=run_market(th,int(seed),size,rate,sigma,n_steps)\n return out\n\ndef run_many(TH,seeds,procs=8,n_steps=10000):\n seeds=np.asarray(list(seeds),dtype=np.int64)\n if not len(seeds): return np.empty((0,4))\n if procs<=1: return _worker((TH,seeds,n_steps))\n chunks=[c for c in np.array_split(seeds,min(procs,len(seeds))) if len(c)]\n # fork shares already compiled code; compile once before pool creation.\n run_market(TH,0,20.,.8,.001,1)\n with mp.get_context('fork').Pool(procs) as pool:\n return np.concatenate(pool.map(_worker,[(TH,c,n_steps) for c in chunks]))\n", "sha256": "b2904402ddda43e4740d950c7bfe277f7262640b5506608e288e7e2a885a4b91", "th_names": [ "ELAPSED_CAP", "SIGNAL_THRESHOLD", "DIR_DECAY", "ACT_DECAY", "SIZE_DECAY", "TOX_DECAY", "SIGMA_DECAY", "LAMBDA_DECAY", "SIZE_BLEND_DECAY", "TOX_BLEND_DECAY", "ACT_BLEND_DECAY", "PHAT_ALPHA", "PHAT_ALPHA_RETAIL", "DIR_IMPACT_MULT", "GATE_SIGMA_MULT", "MIN_GATE", "TRADE_TOX_BOOST", "STALE_ATTRACT_FRAC", "RET_CAP", "TOX_CAP", "TRADE_RATIO_CAP", "LAMBDA_CAP", "STEP_COUNT_CAP", "BASE_FEE", "SIGMA_COEF", "LAMBDA_COEF", "FLOW_SIZE_COEF", "TOX_COEF", "TOX_QUAD_COEF", "ACT_COEF", "DIR_COEF", "DIR_TOX_COEF", "STALE_DIR_COEF", "SIGMA_TOX_COEF", "TAIL_KNEE", "TAIL_SLOPE_PROTECT", "TAIL_SLOPE_ATTRACT", "INIT_SIGMA", "INIT_LAMBDA", "INIT_SIZE", "FLAT_FEE" ], "th_values": [ 8.0, 0.0015384615384615385, 0.75, 0.53, 0.53, 0.91, 0.69, 0.99, 0.828, 0.051, 0.985, 0.27, 0.06, 4.0, 7.2, 0.03, 0.35000000000000003, 1.05, 0.02857142857142857, 0.2, 0.2, 1.82, 64.0, 0.0004, 0.2, 0.0012000000000000001, 0.4842, 0.030000000000000002, 1.5, 9.1843, 0.002, 0.01, 0.685, 0.05, 0.060000000000000005, 0.93, 0.85, 0.00095, 0.8, 0.002, -1.0 ], "validation": { "CH": { "real": { "n": 1000, "mean": 525.5258821780834, "se": 2.7894264590251843 }, "replica": { "n": 1000, "mean": 526.3471654389, "se": 2.8605481844769773 }, "real_mean": 525.5258821780834, "replica_mean": 526.3471654389, "diff": 0.8212832608165854, "se": 3.9954519001014526, "se_method": "two-sample standard error; diff = replica minus real", "seed_start": 0, "seed_end": 999, "reference_mean_from_brief": 525.5258821780834, "reference_error": 0.0 }, "flat_30bps": { "real": { "n": 256, "mean": 347.9224335871958, "se": 3.1392846735449833 }, "replica": { "n": 256, "mean": 347.25731070116933, "se": 3.1664613570763045 }, "real_mean": 347.9224335871958, "replica_mean": 347.25731070116933, "diff": -0.665122886026495, "se": 4.458877189092782, "se_method": "two-sample standard error; diff = replica minus real", "seed_start": 0, "seed_end": 255 } }, "transfer": { "base_fee_plus_3bps": { "real_delta": -0.9058536543617239, "real_se": 0.08199528053565687, "real_n": 128, "replica_delta": -0.9011643071935824, "replica_se": 0.014761166454869619, "replica_n": 4096, "diff": 0.004689347168141511, "two_sample_se": 0.08331337266747421, "real_paired_worst": -3.2623817872974996, "replica_paired_worst": -4.705832434470949, "replica_retail_edge_delta": -3.917312878454588, "replica_arb_edge_delta": 3.016148571261006, "replica_retail_volume_delta": -4157.018332706342 }, "stale_shift_x0.8": { "real_delta": -6.897337567611605, "real_se": 0.19503060979126158, "real_n": 128, "replica_delta": -6.799350669820447, "replica_se": 0.03590243698523202, "replica_n": 4096, "diff": 0.09798689779115843, "two_sample_se": 0.19830764921462282, "real_paired_worst": -12.233689487227252, "replica_paired_worst": -29.157508229109226, "replica_retail_edge_delta": 9.367730796568674, "replica_arb_edge_delta": -16.16708146638912, "replica_retail_volume_delta": 3816.6796963239467 }, "lambda_coefficient_x1.5": { "real_delta": -3.854866626656657, "real_se": 0.1646415375101408, "real_n": 128, "replica_delta": -3.9271277472953194, "replica_se": 0.028623301058450474, "replica_n": 4096, "diff": -0.0722611206386623, "two_sample_se": 0.16711112840617703, "real_paired_worst": -8.94909610642469, "replica_paired_worst": -18.43559842049308, "replica_retail_edge_delta": -9.80710898421332, "replica_arb_edge_delta": 5.879981236918001, "replica_retail_volume_delta": -8632.786620748195 } }, "speed": { "processes": 8, "n": 4096, "seconds": 2.905606481999939, "markets_per_second": 1409.6884851319262, "n_steps": 10000, "seed_start": 800000, "seed_end": 804095, "includes": "config generation, pool startup, dispatch and aggregation; excludes JIT warmup" }, "gas": { "max_ok": 151647, "oog": 0, "details": [ { "role": "Baseline", "callback": "afterInitialize", "calls": 1768, "ok": 1768, "max_ok_gas": 21796, "sum_ok_gas": 38535328, "oog": 0, "revert": 0, "other_halt": 0, "tx_error": 0, "bad_return": 0 }, { "role": "Baseline", "callback": "afterSwap", "calls": 19255787, "ok": 19255787, "max_ok_gas": 22592, "sum_ok_gas": 434465414656, "oog": 0, "revert": 0, "other_halt": 0, "tx_error": 0, "bad_return": 0 }, { "role": "Baseline", "callback": "getName", "calls": 1768, "ok": 1768, "max_ok_gas": 21526, "sum_ok_gas": 38057968, "oog": 0, "revert": 0, "other_halt": 0, "tx_error": 0, "bad_return": 0 }, { "role": "Submission", "callback": "afterInitialize", "calls": 1768, "ok": 1768, "max_ok_gas": 185532, "sum_ok_gas": 286104160, "oog": 0, "revert": 0, "other_halt": 0, "tx_error": 0, "bad_return": 0 }, { "role": "Submission", "callback": "afterSwap", "calls": 18550571, "ok": 18550571, "max_ok_gas": 151647, "sum_ok_gas": 1279456135942, "oog": 0, "revert": 0, "other_halt": 0, "tx_error": 0, "bad_return": 0 }, { "role": "Submission", "callback": "getName", "calls": 1768, "ok": 1768, "max_ok_gas": 21530, "sum_ok_gas": 38064016, "oog": 0, "revert": 0, "other_halt": 0, "tx_error": 0, "bad_return": 0 } ] }, "deviations": [ "Random generator: independent MT19937 streams seeded seed and seed+1, with NumPy/Numba normal, Poisson and lognormal sampling, replace Rust Pcg64 and rand_distr. Same distributions, different paths; cross-engine mean comparisons use two-sample SE. Replica variants share random numbers with replica CH, and real variants share real CH paths.", "Strategy calculations use float64 fractions rather than Solidity uint256 WAD arithmetic and truncation. WAD conversion of trade amounts/reserves is omitted. Synthetic fee replay quantifies error; not bit-exact.", "No EVM gas or revert emulator in replica. Real engine gas counters are reported separately; compiled CH and its tested variants must remain within limits.", "Replica implements the requested default two-pool market only: Vanilla fixed 30bps, initial X=100,Y=10000,price=100,mu=0,dt=1,retail log-sigma=1.2,buy probability=0.5. n_steps is parameterized." ], "notes": [ "Per item e, this is a market replica and CH transfer study, not a candidate Solidity strategy or a STACK paired confirmation.", "Baseline configs: default_rng(seed) draws size uniform[19,21), rate uniform[0.6,1), sigma uniform[0.000882,0.001008), in that order. All full markets have 10000 steps. Each real strategy ran alone against Vanilla via run_batch(...,8).", "Real CH and replica CH validation use seeds 0..999; flat validation uses 0..255. Real transfer block: 716100..716227 (128); replica transfer block: 716100..720195 (4096). Each variant is changed separately; stale shift means STALE_DIR_COEF only, including its effect on attractShift.", "run_many returns an N by 4 float64 array in input seed order; columns edge, retail_edge, arb_edge, retail_volume. All amounts and edges are in Y units except X trade/reserve fields.", "Extract replica_source verbatim into replica.py. Import TH, TH_NAMES, run_market, run_many. Call run_many(TH, range(1000), 8). Change TH using TH_NAMES indexes. FLAT_FEE=-1 selects CH; set FLAT_FEE=0.003 for flat 30bps.", "Requires NumPy and Numba to be supplied by the execution environment; dependency binaries are not bundled in this size-bounded JSON. No network access is used by replica.py.", "Source evidence for rules and constants is in sources.json. Empirical validation and speed values are calculated by the included scripts; they are observations, not claims made by those public sources.", "Pinned reference checkout: benedictbrady/amm-challenge at 6b6921f8d463314aa7c96234e1be25a25245f704. CH source: ChengHua926/amm-challenge at d34a5199c59a4c44d5336a25f1436b4ae1f21104." ], "checks": { "kernel": "passed: all three swap entry points preserve xy; positive trades; edge decomposition; process-count determinism", "strategy_fee_replay": { "calls": 2000, "max_absolute_error": 7.389922007661198e-16 } }, "validation_source": "from pathlib import Path\nimport json,time,sys,math\nimport numpy as np\nimport replica as r\nimport amm_sim_rs as rs\nfrom amm_competition.evm.compiler import SolidityCompiler\nC=SolidityCompiler()\nch=Path('scratch/CH.sol').read_text()\nvan=Path('contracts/src/VanillaStrategy.sol').read_text()\ndef compile(s,name='Strategy'):\n v=C.compile(s,name)\n assert v.success,v.errors\n return list(v.bytecode)\nv=compile(van,'VanillaStrategy')\ndef configs(seeds):\n return [rs.SimulationConfig(10000,100.,100.,10000.,0.,sigma,1.,rate,size,1.2,.5,int(seed)) for seed in seeds for size,rate,sigma in [r.market_config(seed)]]\ndef real(code,seeds):\n out=[]\n for start in range(0,len(seeds),32):\n a=rs.run_batch(code,v,configs(seeds[start:start+32]),8)\n out += [x.edges['submission'] for x in a.results]\n if start%256==0: print('real',start,len(seeds),flush=True)\n return np.array(out)\ndef save(name,a): np.save('scratch/'+name+'.npy',a)\nif __name__=='__main__':\n code=compile(ch)\n t=time.perf_counter(); a=real(code,list(range(1000)));save('real_ch',a)\n print('CH real',a.mean(),'seconds',time.perf_counter()-t,flush=True)\n save('real_flat',real(v,list(range(256))))\n seeds=list(range(716100,716228))\n save('real_base_transfer',real(code,seeds))\n variants={\n 'base_fee_plus_3bps':ch.replace('BASE_FEE = 4 * BPS','BASE_FEE = 7 * BPS'),\n 'stale_shift_x0.8':ch.replace('STALE_DIR_COEF = 6850 * BPS','STALE_DIR_COEF = 5480 * BPS'),\n 'lambda_coefficient_x1.5':ch.replace('LAMBDA_COEF = 12 * BPS','LAMBDA_COEF = 18 * BPS')}\n for name,s in variants.items():\n save('real_'+name,real(compile(s),seeds))\n print(name,'done',flush=True)\n print('gas',rs.gas_stats(),flush=True)\n", "replica_validation_source": "import time,numpy as np\nimport replica as r\n\ndef save(name,a): np.save('scratch/'+name+'.npy',a)\nif __name__=='__main__':\n r.run_many(r.TH,[0],1,1)\n t=time.perf_counter(); a=r.run_many(r.TH,range(1000),8);dt=time.perf_counter()-t\n save('rep_ch',a); print('CH',a.mean(axis=0),'seconds',dt,flush=True)\n flat=r.TH.copy();flat[-1]=.003\n save('rep_flat',r.run_many(flat,range(256),8))\n seeds=range(716100,720196)\n t=time.perf_counter();b=r.run_many(r.TH,seeds,8); dt=time.perf_counter()-t\n save('rep_base_transfer',b)\n np.save('scratch/speed.npy',np.array([4096,dt,4096/dt]))\n for name,key,op in [('base_fee_plus_3bps','BASE_FEE',.0003),('stale_shift_x0.8','STALE_DIR_COEF',.8),('lambda_coefficient_x1.5','LAMBDA_COEF',1.5)]:\n th=r.TH.copy();ix=r.TH_NAMES.index(key)\n th[ix]=th[ix]+op if key=='BASE_FEE' else th[ix]*op\n a=r.run_many(th,seeds,8);save('rep_'+name,a)\n d=a[:,0]-b[:,0];print(name,d.mean(),d.std(ddof=1)/len(d)**.5,flush=True)\n", "kernel_checks_source": "import numpy as np\nimport replica as r\n\ndef check():\n # Fee bucket invariant, all three execution entry points.\n for mode in range(3):\n nx,ny,ax,ay=r.execute(100.,10000.,.003,.003,mode,1.)\n assert abs(nx*ny-1000000.)<1e-8\n assert nx>0 and ny>0 and ax>0 and ay>0\n flat=r.TH.copy();flat[-1]=.003\n a=r.run_many(flat,range(16),1,1000)\n b=r.run_many(flat,range(16),8,1000)\n assert np.array_equal(a,b)\n assert np.allclose(a[:,0],a[:,1]+a[:,2])\n assert np.all(a[:,1]>=0) and np.all(a[:,2]<=0) and np.all(a[:,3]>0)\n s=np.zeros(40)\n assert r.strat_init(s,r.TH,100.,10000.)==(.0004,.0004)\n print('kernel checks passed')\nif __name__=='__main__':check()\n", "strategy_fee_check_source": "from pathlib import Path\nfrom decimal import Decimal as D\nimport numpy as np\nimport replica as r\nfrom amm_competition.evm.compiler import SolidityCompiler\nfrom amm_competition.evm.adapter import EVMStrategyAdapter\nfrom amm_competition.core.trade import TradeInfo\ncode=SolidityCompiler().compile(Path('scratch/CH.sol').read_text());assert code.success\nad=EVMStrategyAdapter(code.bytecode)\na=ad.after_initialize(D(100),D(10000))\ns=np.zeros(40);b=r.strat_init(s,r.TH,100.,10000.)\nrng=np.random.default_rng(19831);ts=0;mx=0.\nx=100.;y=10000.\nfor i in range(2000):\n ts+=int(rng.choice([0,0,1,1,2,10]))\n buy=bool(rng.integers(2));amt=float(rng.lognormal(-1,1))\n nx,ny,ax,ay=r.execute(x,y,b[0],b[1],0 if buy else 1,min(amt,x*.1))\n tr=TradeInfo(side='buy' if buy else 'sell',amount_x=D(str(ax)),amount_y=D(str(ay)),timestamp=ts,reserve_x=D(str(nx)),reserve_y=D(str(ny)))\n a=ad.after_swap(tr)\n b=r.strat_after(s,r.TH,buy,ax,ay,ts,nx,ny)\n err=max(abs(float(a.bid_fee)-b[0]),abs(float(a.ask_fee)-b[1]))\n mx=max(mx,err)\n assert err<1e-11,(i,a,b,err)\n x,y=nx,ny\nprint('fee_test',2000,'max_absolute_error',mx)\nPath('scratch/fee_check.json').write_text(__import__('json').dumps({'calls':2000,'max_absolute_error':mx}))\n" }