{ "blocked": null, "replica_source": "\"\"\"Pinned 6b6921f8 market replica. Fractions, not bps/WAD integers.\nPython 3.12; optional numpy/numba acceleration; no mandatory packages.\nWithout numpy, run_many returns a list of tuples; with numpy, an ndarray.\nrun_many returns N x 4: edge, retail_edge, arb_edge, retail_volume_y.\nRNG distributions match Rust; paths intentionally differ (MT19937 vs Pcg64).\n\"\"\"\nimport math\nimport multiprocessing as mp\n# All acceleration dependencies are optional. This embedded fallback runs offline\n# with Python's standard library; it uses different but distribution-matched paths.\nimport os\ntry:\n if os.environ.get('AMM_REPLICA_STDLIB') == '1':\n raise ImportError('stdlib requested')\n import numpy as np\n HAS_NUMPY = True\nexcept ImportError:\n HAS_NUMPY = False\n import random\n class _Array(list):\n def __getitem__(self,key):\n if isinstance(key,tuple):\n return list.__getitem__(self,key[0])[key[1]]\n return list.__getitem__(self,key)\n def __setitem__(self,key,value):\n if isinstance(key,tuple):\n list.__getitem__(self,key[0])[key[1]]=value\n elif isinstance(key,slice) and isinstance(value,(float,int)):\n for j in range(*key.indices(len(self))):\n list.__setitem__(self,j,float(value))\n else:\n list.__setitem__(self,key,value)\n class _Random:\n def __init__(self): self.rng=random.Random()\n def seed(self,seed): self.rng.seed(int(seed))\n def standard_normal(self,n=None):\n if n is None: return self.rng.gauss(0.,1.)\n return [self.rng.gauss(0.,1.) for _ in range(n)]\n def random(self): return self.rng.random()\n def poisson(self,rate):\n # Canonical rate is 0.6..1.0; Knuth's exact Poisson sampler.\n cutoff=math.exp(-rate)\n prod=1.; n=0\n while prod > cutoff:\n prod *= self.rng.random(); n+=1\n return n-1\n class _NP:\n float64=float\n random=_Random()\n def array(self,values,dtype=None): return _Array(values)\n def zeros(self,n,dtype=None): return _Array([0.]*n)\n def full(self,shape,value,dtype=None):\n if isinstance(shape,tuple):\n return _Array([_Array([value]*shape[1]) for _ in range(shape[0])])\n return _Array([value]*shape)\n np=_NP()\ntry:\n if not HAS_NUMPY: raise ImportError('no numpy')\n from numba import njit\n HAS_NUMBA=True\nexcept ImportError:\n HAS_NUMBA=False\n def njit(**kwargs):\n return lambda f:f\n\n\n\n# SeedSequence/PCG adaptation notice (MIT):\n# Copyright (c) 2014-2015 Melissa E. O'Neill\n# Copyright (c) 2015 Robert Kern\n# Copyright (c) 2019 NumPy Developers\n# Permission is hereby granted, free of charge, to any person obtaining a copy\n# of this software and associated documentation files (the \"Software\"), to deal\n# in the Software without restriction, including without limitation the rights\n# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies\n# of the Software, and to permit persons to whom the Software is furnished to\n# do so, subject to the following conditions:\n# The above copyright notice and this permission notice shall be included in\n# all copies or substantial portions of the Software.\n# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n# THE SOFTWARE.\n\ndef _config_uniforms(seed):\n \"\"\"Three default_rng(seed) uniform draws without numpy.\n SeedSequence(pool_size=4) + PCG64 XSL-RR, little-endian uint64 words.\n Arithmetic derived from numpy v2.2.0 bit_generator.pyx and pcg64.h.\n \"\"\"\n if seed < 0: raise ValueError('seed must be nonnegative')\n mask32=(1<<32)-1; mask64=(1<<64)-1; mask128=(1<<128)-1\n words=[]\n while seed:\n words.append(seed & mask32); seed >>= 32\n if not words: words=[0]\n hc=0x43b0d7e5\n def h(value):\n nonlocal hc\n value ^= hc\n hc=(hc*0x931e8875)&mask32\n value=(value*hc)&mask32\n return value^(value>>16)\n def mix(a,b):\n v=(0xca01f9dd*a-0x4973f715*b)&mask32\n return v^(v>>16)\n pool=[h(words[i] if i>16))\n u=[output[i]+(output[i+1]<<32) for i in range(0,8,2)]\n mult=(2549297995355413924<<64)+4865540595714422341\n inc=(((u[2]<<64)+u[3])*2+1)&mask128\n state=((inc+(u[0]<<64)+u[1])*mult+inc)&mask128\n draws=[]\n for _ in range(3):\n state=(state*mult+inc)&mask128\n v=((state>>64)^state)&mask64\n rot=state>>122\n v=((v>>rot)|(v<<((-rot)&63)))&mask64\n draws.append((v>>11)*(1./9007199254740992.))\n return draws\n\n\nTH_NAMES = ['ELAPSED_CAP','SIGNAL_THRESHOLD','DIR_DECAY','ACT_DECAY','SIZE_DECAY',\n'TOX_DECAY','SIGMA_DECAY','LAMBDA_DECAY','SIZE_BLEND_DECAY','TOX_BLEND_DECAY',\n'ACT_BLEND_DECAY','PHAT_ALPHA','PHAT_ALPHA_RETAIL','DIR_IMPACT_MULT',\n'GATE_SIGMA_MULT','MIN_GATE','TRADE_TOX_BOOST','STALE_ATTRACT_FRAC','RET_CAP',\n'TOX_CAP','TRADE_RATIO_CAP','LAMBDA_CAP','STEP_COUNT_CAP','BASE_FEE',\n'SIGMA_COEF','LAMBDA_COEF','FLOW_SIZE_COEF','TOX_COEF','TOX_QUAD_COEF',\n'ACT_COEF','DIR_COEF','DIR_TOX_COEF','STALE_DIR_COEF','SIGMA_TOX_COEF',\n'TAIL_KNEE','TAIL_SLOPE_PROTECT','TAIL_SLOPE_ATTRACT','FLAT_FEE']\nTH = np.array([8,(10**18//650)/1e18,.75,.53,.53,.91,.69,.99,.828,.051,.985,.27,.06,\n4,7.2,.03,.35,1.05,1/35,1/5,1/5,1.82,64,.0004,.2,.0012,.4842,.03,\n1.5,9.1843,.002,.01,.685,.05,.06,.93,.85,-1], dtype=np.float64)\n\n# STRATEGY BEGIN\n@njit(cache=True)\ndef strat_init(S, TH, x0, y0):\n S[:] = 0.\n base = TH[23] if TH[37] < 0 else TH[37]\n S[0] = base\n S[1] = base\n S[3] = 1.\n S[5] = y0/x0 if x0 > 0 else 100.\n S[6] = .00095\n S[7] = .8\n S[8] = .002\n return base, base\n\n@njit(cache=True)\ndef strat_after(S, TH, is_buy, amount_x, amount_y, timestamp, reserve_x, reserve_y):\n if TH[37] >= 0:\n return TH[37], TH[37]\n prev_bid, prev_ask, last_ts = S[0], S[1], S[2]\n direction, act, phat = S[3], S[4], S[5]\n sigma, lam, size, toxema, count = S[6], S[7], S[8], S[9], S[10]\n if timestamp > last_ts:\n raw = timestamp-last_ts\n elapsed = min(raw, TH[0])\n direction = 1. + (direction-1.) * TH[2]**elapsed\n act *= TH[3]**elapsed\n size *= TH[4]**elapsed\n toxema *= TH[5]**elapsed\n if count > 0 and raw > 0:\n inst = min(count/raw, TH[21])\n lam = lam*TH[7] + inst*(1.-TH[7])\n count = 0.\n first = count == 0\n spot = reserve_y/reserve_x if reserve_x > 0 else phat\n if phat == 0:\n phat = spot\n fee = prev_bid if is_buy else prev_ask\n gamma = max(0., 1.-fee)\n implied = spot if gamma == 0 else (spot*gamma if is_buy else spot/gamma)\n ret = abs(implied-phat)/phat if phat > 0 else 0.\n alpha = TH[11] if first else TH[12]\n gate = max(sigma*TH[14], TH[15])\n if ret <= gate:\n phat = phat*(1.-alpha) + implied*alpha\n if first:\n ret = min(ret, TH[18])\n sigma = sigma*TH[6] + ret*(1.-TH[6])\n # Preserve the WAD division truncation at CH's discontinuous flow gate.\n ratio = min(math.floor((amount_y/reserve_y)*1e18)/1e18, TH[20]) if reserve_y > 0 else 0.\n if ratio > TH[1]:\n push = min(ratio*TH[13], .25)\n direction = min(direction+push, 2.) if is_buy else max(direction-push, 0.)\n act = act*TH[10] + ratio*(1.-TH[10])\n size = min(size*TH[8] + ratio*(1.-TH[8]), 1.)\n tox = min(abs(spot-phat)/phat, TH[19]) if phat > 0 else 0.\n toxema = toxema*TH[9] + tox*(1.-TH[9])\n count = min(count+1., TH[22])\n flow = lam*size\n base = TH[23] + TH[24]*sigma + TH[25]*lam + TH[26]*flow\n mid = base + TH[27]*toxema + TH[28]*toxema*toxema + TH[29]*act\n mid += TH[33]*sigma*toxema\n dev = abs(direction-1.)\n pressure = direction >= 1.\n skew = TH[30]*dev + TH[31]*dev*toxema\n bid = mid+skew if pressure else max(mid-skew, 0.)\n ask = max(mid-skew, 0.) if pressure else mid+skew\n stale = TH[32]*toxema\n attract = stale*TH[17]\n if spot >= phat:\n bid += stale\n ask = max(ask-attract, 0.)\n else:\n ask += stale\n bid = max(bid-attract, 0.)\n aligned = (is_buy and spot >= phat) or ((not is_buy) and spot < phat)\n if aligned:\n if is_buy:\n bid += TH[16]*ratio\n else:\n ask += TH[16]*ratio\n bslope = TH[35] if pressure else TH[36]\n aslope = TH[36] if pressure else TH[35]\n if bid > TH[34]:\n bid = TH[34] + (bid-TH[34])*bslope\n if ask > TH[34]:\n ask = TH[34] + (ask-TH[34])*aslope\n bid, ask = min(max(bid, 0.), .1), min(max(ask, 0.), .1)\n S[0],S[1],S[2] = bid,ask,timestamp\n S[3],S[4],S[5] = direction,act,phat\n S[6],S[7],S[8],S[9],S[10] = sigma,lam,size,toxema,count\n return bid, ask\n# STRATEGY END\n\n@njit(cache=True)\ndef _update(S, TH, x, y, fees, i, is_buy, ax, ay, t):\n if i == 0:\n bid, ask = strat_after(S, TH, is_buy, ax, ay, t, x[i], y[i])\n fees[0,0] = min(max(bid,0.),.1)\n fees[0,1] = min(max(ask,0.),.1)\n\n@njit(cache=True)\ndef _arb(S, TH, x, y, fees, i, p, t):\n rx, ry = x[i], y[i]\n k = rx*ry\n if ry/rx < p:\n gamma = 1.-fees[i,1]\n if gamma <= 0 or p <= 0:\n return 0.\n ax = min(rx-math.sqrt(k/(gamma*p)), rx*.99)\n if ax <= 0:\n return 0.\n net_y = k/(rx-ax)-ry\n ay = net_y/gamma\n profit = ax*p-ay\n if ay <= 0 or profit <= 0:\n return 0.\n x[i] -= ax\n # Rust: total_y - fee_amount, where fee_amount=total_y-net_y.\n y[i] += ay-(ay-net_y)\n _update(S,TH,x,y,fees,i,False,ax,ay,t)\n return -profit\n elif ry/rx > p:\n gamma = 1.-fees[i,0]\n if gamma <= 0 or p <= 0:\n return 0.\n ax = (math.sqrt(k*gamma/p)-rx)/gamma\n if ax <= 0:\n return 0.\n ay = ry-k/(rx+ax*gamma)\n profit = ay-ax*p\n if ay <= 0 or profit <= 0:\n return 0.\n x[i] += ax-ax*fees[i,0]\n y[i] -= ay\n _update(S,TH,x,y,fees,i,True,ax,ay,t)\n return -profit\n return 0.\n\n@njit(cache=True)\ndef _retail(S,TH,x,y,fees,i,is_buy,amount,p,t):\n if amount <= .0001:\n return 0.,0.\n k = x[i]*y[i]\n if is_buy: # AMM buys X; input amount is gross X\n ax = amount\n gamma = 1.-fees[i,0]\n ay = y[i]-k/(x[i]+ax*gamma)\n if ay <= 0 or gamma <= 0:\n return 0.,0.\n x[i] += ax-ax*fees[i,0]\n y[i] -= ay\n edge = ax*p-ay\n else: # Trader spends gross Y\n ay = amount\n gamma = 1.-fees[i,1]\n ax = x[i]-k/(y[i]+ay*gamma)\n if ax <= 0 or gamma <= 0:\n return 0.,0.\n x[i] -= ax\n y[i] += ay-ay*fees[i,1]\n edge = ay-ax*p\n _update(S,TH,x,y,fees,i,is_buy,ax,ay,t)\n return edge,ay\n\n@njit(cache=True)\ndef run_market(TH, seed, mean_size, rate, sigma, n_steps):\n \"\"\"One strategy pool versus fixed 30bps Vanilla, canonical initial reserves.\n Separate price(seed) and retail(seed+1) streams. No strategy RNG calls.\n \"\"\"\n np.random.seed(seed % 4294967296)\n shocks = np.random.standard_normal(n_steps)\n np.random.seed((seed+1) % 4294967296)\n S = np.zeros(40, dtype=np.float64)\n x = np.full(2,100.,dtype=np.float64)\n y = np.full(2,10000.,dtype=np.float64)\n fees = np.full((2,2),.003,dtype=np.float64)\n bid,ask = strat_init(S,TH,x[0],y[0])\n fees[0,0],fees[0,1] = min(max(bid,0.),.1),min(max(ask,0.),.1)\n p = 100.\n arb,ret,volume = 0.,0.,0.\n mu = math.log(max(mean_size,.01))-.5*1.2**2\n for t in range(n_steps):\n p *= math.exp(-.5*sigma*sigma+sigma*shocks[t])\n arb += _arb(S,TH,x,y,fees,0,p,t)\n _arb(S,TH,x,y,fees,1,p,t)\n arrivals = np.random.poisson(max(rate,.01))\n for j in range(arrivals):\n size = math.exp(mu+1.2*np.random.standard_normal())\n trader_buy = np.random.random() < .5\n is_buy = not trader_buy\n side = 0 if is_buy else 1\n g1,g2 = 1.-fees[0,side],1.-fees[1,side]\n a1 = math.sqrt(x[0]*g1*y[0])\n a2 = math.sqrt(x[1]*g2*y[1])\n total = size/p if is_buy else size\n if a2 == 0:\n part = total\n else:\n r = a1/a2\n v1 = x[0] if is_buy else y[0]\n v2 = x[1] if is_buy else y[1]\n denominator = g1+r*g2\n part = total/2. if denominator == 0 else (r*(v2+g2*total)-v1)/denominator\n part = min(max(part,0.),total)\n # Both splits computed before either afterSwap callback.\n edge,vol = _retail(S,TH,x,y,fees,0,is_buy,part,p,t)\n ret += edge\n volume += vol\n _retail(S,TH,x,y,fees,1,is_buy,total-part,p,t)\n return ret+arb,ret,arb,volume\n\ndef config_values(seed):\n \"\"\"MatchRunner._build_configs: draw size, arrival rate, sigma in that order.\"\"\"\n if HAS_NUMPY:\n rng = np.random.default_rng(int(seed))\n return rng.uniform(19.,21.),rng.uniform(.6,1.),rng.uniform(.000882,.001008)\n u,v,w = _config_uniforms(int(seed))\n return 19.+2.*u,.6+.4*v,.000882+.000126*w\n\ndef _worker(task):\n th,seeds,n_steps = task\n out = np.empty((len(seeds),4), dtype=np.float64) if HAS_NUMPY else [None]*len(seeds)\n for i,seed in enumerate(seeds):\n size,rate,sigma = config_values(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 \"\"\"Return ordered N x 4 floats. Use a __main__ guard when spawning processes.\n Compile once in parent; fork workers inherit JIT code on Linux. Cache is on.\n Without numpy, returns ordered list of tuples using the stdlib backend.\n \"\"\"\n if not HAS_NUMPY:\n seeds = list(seeds)\n if procs <= 1 or len(seeds) < 2:\n return _worker((TH,seeds,n_steps))\n chunks=[seeds[j::procs] for j in range(procs)]\n tasks=[(TH,chunk,n_steps) for chunk in chunks]\n with mp.get_context('fork').Pool(procs) as pool:\n parts=pool.map(_worker,tasks)\n out=[None]*len(seeds)\n for j,part in enumerate(parts): out[j::procs]=part\n return out\n seeds = np.asarray(list(seeds),dtype=np.int64)\n if len(seeds) == 0:\n return np.empty((0,4))\n th = np.asarray(TH,dtype=np.float64)\n run_market(th,0,20.,.8,.000945,1)\n if procs <= 1:\n return _worker((th,seeds,n_steps))\n tasks = [(th,chunk,n_steps) for chunk in np.array_split(seeds,min(procs,len(seeds))) if len(chunk)]\n with mp.get_context('fork').Pool(min(procs,len(seeds))) as pool:\n return np.concatenate(pool.map(_worker,tasks),axis=0)\n\nif __name__ == '__main__':\n import argparse,time,json\n parser = argparse.ArgumentParser()\n parser.add_argument('--n',type=int,default=256)\n parser.add_argument('--start',type=int,default=0)\n parser.add_argument('--procs',type=int,default=8)\n args=parser.parse_args()\n run_market(TH,0,20.,.8,.000945,1)\n start=time.perf_counter()\n out=run_many(TH,range(args.start,args.start+args.n),args.procs)\n seconds=time.perf_counter()-start\n import statistics\n rows=[tuple(row) for row in out]\n print(json.dumps({'n':args.n,'mean':[statistics.mean(row[j] for row in rows) for j in range(4)],\n 'edge_se':statistics.stdev(row[0] for row in rows)/math.sqrt(args.n) if args.n>1 else None,\n 'seconds':seconds,'markets_per_second':args.n/seconds,\n 'numpy':HAS_NUMPY,'numba':HAS_NUMBA}))\n", "sha256": "c74286f9b01dd6e8b9e1536959a79097210db3d5e028a347775b540deb91132f", "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", "FLAT_FEE" ], "th": [ 8.0, 0.001538461538461538, 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.35, 1.05, 0.02857142857142857, 0.2, 0.2, 1.82, 64.0, 0.0004, 0.2, 0.0012, 0.4842, 0.03, 1.5, 9.1843, 0.002, 0.01, 0.685, 0.05, 0.06, 0.93, 0.85, -1.0 ], "validation": { "CH": { "seed_start": 0, "seed_end_inclusive": 999, "n_steps": 10000, "real": { "n": 1000, "mean": 525.5258821780834, "se": 2.7894264590251843 }, "replica": { "n": 1000, "mean": 526.3471407960195, "se": 2.8605492809307345 }, "real_mean": 525.5258821780834, "replica_mean": 526.3471407960195, "diff": 0.8212586179361097, "se": 3.9954526851088, "z": 0.20554832772691087, "gas": { "max_ok": 151647, "oog": 0, "after_swap_calls": 10445223, "all_callbacks_max_ok": 185532, "revert": 0, "other_halt": 0, "tx_error": 0, "bad_return": 0 }, "replica_retail_edge_mean": 555.9853544979513, "replica_arb_edge_mean": -29.638213701931832, "replica_retail_volume_mean": 76899.97719223854, "measured_real_seconds": 140.71509459381923, "supplied_reference_mean": 525.5258821780834, "reference_abs_error": 0.0 }, "flat30": { "seed_start": 0, "seed_end_inclusive": 255, "n_steps": 10000, "real": { "n": 256, "mean": 347.9224335871958, "se": 3.1392846735449833 }, "replica": { "n": 256, "mean": 347.2573107018811, "se": 3.1664613569888123 }, "real_mean": 347.9224335871958, "replica_mean": 347.2573107018811, "diff": -0.6651228853147018, "se": 4.458877189030649, "z": -0.14916824507994536, "gas": { "max_ok": 22592, "oog": 0, "after_swap_calls": 2971306, "all_callbacks_max_ok": 22592, "revert": 0, "other_halt": 0, "tx_error": 0, "bad_return": 0 }, "replica_retail_edge_mean": 579.1072408424366, "replica_arb_edge_mean": -231.8499301405554, "replica_retail_volume_mean": 80800.52934931687, "measured_real_seconds": 16.67999760597013 } }, "transfer": { "base_plus_3bps": { "change": "BASE_FEE: 4bps -> 7bps", "th_index": 23, "real": { "n": 128, "delta": -0.9091767092307963, "se": 0.08221275544689513, "worst": -3.0541871348485756, "seed_start": 696100, "seed_end_inclusive": 696227, "retail_edge_delta": null, "arb_edge_delta": null, "gas": { "max_ok": 150887, "oog": 0, "after_swap_calls": 1267432, "all_callbacks_max_ok": 185532, "revert": 0, "other_halt": 0, "tx_error": 0, "bad_return": 0 } }, "replica": { "n": 4096, "delta": -0.9285434384639791, "se": 0.014947682193452553, "worst": -6.1865854173844355, "seed_start": 696100, "seed_end_inclusive": 700195, "retail_edge_delta": -3.9541006815202286, "retail_edge_delta_se": 0.01626874891656924, "arb_edge_delta": 3.02555724305625, "arb_edge_delta_se": 0.005778448281044012, "retail_volume_delta": -4174.785574098411 }, "replica_minus_real_delta": -0.019366729233182833, "comparison_se": 0.08356057898990076, "comparison_z": -0.2317687295527658 }, "stale_x0.8": { "change": "STALE_DIR_COEF: 0.685 -> 0.548; attract multiplier unchanged", "th_index": 32, "real": { "n": 128, "delta": -6.793725127595652, "se": 0.20570002352326555, "worst": -12.51176884043673, "seed_start": 696100, "seed_end_inclusive": 696227, "retail_edge_delta": null, "arb_edge_delta": null, "gas": { "max_ok": 129012, "oog": 0, "after_swap_calls": 1452657, "all_callbacks_max_ok": 185532, "revert": 0, "other_halt": 0, "tx_error": 0, "bad_return": 0 } }, "replica": { "n": 4096, "delta": -6.785175291732687, "se": 0.0351377314267081, "worst": -20.551137192092483, "seed_start": 696100, "seed_end_inclusive": 700195, "retail_edge_delta": 9.434515962079143, "retail_edge_delta_se": 0.03564421568568645, "arb_edge_delta": -16.21969125381183, "arb_edge_delta_se": 0.04428659101387082, "retail_volume_delta": 3821.8225475137224 }, "replica_minus_real_delta": 0.008549835862964983, "comparison_se": 0.20867956260086293, "comparison_z": 0.040971122214387985 }, "lambda_x1.5": { "change": "LAMBDA_COEF: 12bps -> 18bps", "th_index": 25, "real": { "n": 128, "delta": -3.9569044733461776, "se": 0.1650826227703827, "worst": -8.598883210522558, "seed_start": 696100, "seed_end_inclusive": 696227, "retail_edge_delta": null, "arb_edge_delta": null, "gas": { "max_ok": 134308, "oog": 0, "after_swap_calls": 1159666, "all_callbacks_max_ok": 185532, "revert": 0, "other_halt": 0, "tx_error": 0, "bad_return": 0 } }, "replica": { "n": 4096, "delta": -3.9675144112848915, "se": 0.027984493901788646, "worst": -10.610703621965285, "seed_start": 696100, "seed_end_inclusive": 700195, "retail_edge_delta": -9.878456407317628, "retail_edge_delta_se": 0.03240950717237905, "arb_edge_delta": 5.910941996032735, "arb_edge_delta_se": 0.010992389321623088, "retail_volume_delta": -8671.8196930306 }, "replica_minus_real_delta": -0.010609937938713898, "comparison_se": 0.16743776228702925, "comparison_z": -0.06336645804263599 } }, "speed": { "n": 4096, "n_steps": 10000, "processes": 8, "seconds": [ 5.349264762131497, 5.260694271884859, 5.418922368902713 ], "markets_per_second": [ 765.7127067249304, 778.6044556686319, 755.8698429609366 ], "median_markets_per_second": 765.7127067249304, "warm_jit": true, "includes_config_generation_and_process_startup": true }, "deviations": [ { "rule": "random paths", "detail": "Distributions and seed separation match; accelerated backend uses Numba MT19937 rather than Rust rand_pcg::Pcg64/rand_distr. Stdlib backend uses random.Random, Gaussian sampling, and exact Knuth Poisson. Individual seed outcomes are not pathwise replicas. Configs match numpy.default_rng(seed) size/rate/sigma draws exactly; stdlib embeds SeedSequence/PCG64 for those draws." }, { "rule": "WAD arithmetic", "detail": "CH state and trade amounts use float64 rather than Solidity uint256 fixed point. The flow ratio truncates to 1e-18 and the threshold is the Solidity WAD/650 value, but float rounding at exact threshold ties can still select a different branch. Away from those artificial ties, 20000 direct callback comparisons across CH and variants had max fee error below 1e-15. A synthetic exact-threshold sequence first diverged at callback index 594 with maximum fee difference 0.0003153743526118774; exact WAD equivalence is not claimed." }, { "rule": "EVM failure behavior", "detail": "Replica computes fees without an EVM and cannot predict gas or revert/OOG behavior of arbitrary replacement strategies. Real validation used the supplied instrumented wheel and gas_stats; all measured callbacks succeeded with zero OOG." }, { "rule": "supported configuration", "detail": "run_market implements the canonical two-pool market: price=100, x=100, y=10000, mu=0, dt=1, retail log-space sigma=1.2, buy probability=0.5, Vanilla=30bps. The requested scalar inputs vary size, rate, price sigma, seed and steps. PnL, fee buckets and per-step telemetry are not returned; scoring edge and strategy-pool retail volume are returned." } ], "notes": [ "Measured locally, not inferred from leaderboard scores. This item builds a replica; it does not search for or submit a STACK replacement.", "Extract replica_source verbatim to replica.py. python3 replica.py --n 256 --procs 8 works without packages or network. When numpy and numba are available it selects acceleration automatically. AMM_REPLICA_STDLIB=1 forces the bundled fallback. Nothing beyond the Python standard library is required for offline functionality.", "The accelerated measurements used Python 3.12.3, numpy 2.5.4 and numba 0.68.1. No optional binary dependencies are embedded; the fallback is delivered as ordinary source inside replica_source.", "run_many preserves input seed order. S is a 40-element float64 array on the accelerated backend, TH is float64, fees are fractions, timestamps and counts are unscaled, and amount/reserve/price fields are in human units. TH[37]=-1 selects CH; a nonnegative TH[37] selects a flat fee.", "Real runs always evaluated one submission against Vanilla alone with run_batch(submission,Vanilla,configs,8). Seeds are distinct across CH/flat validation and transfer except the explicitly required CH/flat validation overlap at 0..255 and shared paired variant baselines. Runs were chunked into batches of 16 solely to bound telemetry memory.", "Validation se=sqrt(sample_var_real/n_real + sample_var_replica/n_replica). diff=replica_mean-real_mean. It is a two-sample comparison even when config seed numbers coincide because price and retail paths differ.", "Transfer is three independent modifications, each paired against unchanged CH within each engine. se is sample_sd(per-market variant-minus-CH)/sqrt(n). replica-minus-real delta uncertainty combines the independent paired standard errors. All real transfer variants use seeds 696100..696227; all replica transfer variants use 696100..700195.", "Retail and arbitrage component transfer deltas are measured in the replica. The supplied real wheel exposes only total edges and volumes, so real component deltas are unavailable and left null.", "The supplied setup script ran once in the pinned checkout and StarterStrategy validated. The wheel SHA256 check passed: aedb68280aca34c110968f00148387c95885207913fb2cf19a1ab4c5cfd6887a. All setup and validation intermediates were confined to disposable test/scratch.", "Source URLs and exact supporting quotations are in sources.json. Numerical validation and timings are new local experiments; reproduction scripts are included below. For reproduction from the pinned checkout, save replica_source as scratch/replica.py and fetch the pinned CH source to scratch/CH.sol before running the evaluation scripts." ], "checks": { "stdlib_config_exact_draws": 10000, "serial_parallel_identical_markets": 32, "edge_component_identity": true, "analytical_arb_and_fee_exclusion": true, "zero_steps": true }, "strategy_callback_checks": { "CH": { "calls": 5000, "max_abs_fee_error": 8.257283745649602e-16 }, "base_plus_3bps": { "calls": 5000, "max_abs_fee_error": 9.43689570931383e-16 }, "stale_x0.8": { "calls": 5000, "max_abs_fee_error": 5.551115123125783e-16 }, "lambda_x1.5": { "calls": 5000, "max_abs_fee_error": 9.43689570931383e-16 } }, "offline_fallback_check": { "n": 256, "mean": [ 535.4177967793777, 565.3188638774285, -29.901067098050724, 77646.68264360797 ], "edge_se": 5.7845873160884675, "seconds": 23.47466171393171, "markets_per_second": 10.905375469077345, "numpy": false, "numba": false }, "reproduction": { "real_eval_source": "import json,time,gc\nfrom pathlib import Path\nimport numpy as np\nimport amm_sim_rs\nfrom amm_competition.evm.compiler import SolidityCompiler\nfrom replica import config_values\n\ndef compile_source(src, name='Strategy'):\n c=SolidityCompiler().compile(src,name)\n if not c.success: raise RuntimeError(c.errors)\n return list(c.bytecode)\n\ndef configs(seeds):\n out=[]\n for seed in seeds:\n size,rate,sigma=config_values(seed)\n out.append(amm_sim_rs.SimulationConfig(10000,100.,100.,10000.,0.,sigma,1.,rate,size,1.2,.5,int(seed)))\n return out\n\nif __name__=='__main__':\n ch=Path('scratch/CH.sol').read_text()\n vanilla=compile_source(Path('contracts/src/VanillaStrategy.sol').read_text(),'VanillaStrategy')\n source={\n 'CH':ch,\n 'flat30':None,\n 'base_plus_3bps':ch.replace('BASE_FEE = 4 * BPS','BASE_FEE = 7 * BPS'),\n 'stale_x0.8':ch.replace('STALE_DIR_COEF = 6850 * BPS','STALE_DIR_COEF = 5480 * BPS'),\n 'lambda_x1.5':ch.replace('LAMBDA_COEF = 12 * BPS','LAMBDA_COEF = 18 * BPS')}\n cases=[('CH',range(1000),'CH'),('flat30',range(256),'flat30'),('CH',range(696100,696228),'CH_transfer')]+[(v,range(696100,696228),v) for v in list(source)[2:]]\n for name,seeds,label in cases:\n path=Path('scratch/real_'+label+'.json')\n if path.exists(): continue\n bc=vanilla if name=='flat30' else compile_source(source[name])\n rows=[]\n start=time.perf_counter()\n amm_sim_rs.gas_stats_reset()\n for j in range(0,len(seeds),16):\n res=amm_sim_rs.run_batch(bc,vanilla,configs(seeds[j:j+16]),8)\n rows += [{'seed':r.seed,'edge':r.edges['submission']} for r in res.results]\n del res\n gc.collect()\n if j%64==0: print(label,len(rows),'mean',np.mean([r['edge'] for r in rows]),'seconds',time.perf_counter()-start,flush=True)\n gas=amm_sim_rs.gas_stats()\n path.write_text(json.dumps({'rows':rows,'seconds':time.perf_counter()-start,'gas':gas}))\n print('DONE',label,'gas',gas,flush=True)\n", "replica_eval_source": "from replica import *\nimport json,time\nfrom pathlib import Path\n\ndef summary(a):\n return {'n':len(a),'mean':float(np.mean(a)),'se':float(np.std(a,ddof=1)/np.sqrt(len(a)))}\nif __name__=='__main__':\n run_market(TH,0,20.,.8,.000945,1)\n result={}\n for name,seeds,th in [('CH',range(1000),TH),('flat30',range(256),TH.copy())]:\n if name=='flat30': th[37]=.003\n start=time.perf_counter()\n a=run_many(th,seeds,8)\n elapsed=time.perf_counter()-start\n np.save('scratch/replica_'+name+'.npy',a)\n result[name]={**summary(a[:,0]),'means':a.mean(axis=0).tolist(),'seconds':elapsed,'markets_per_second':len(a)/elapsed}\n seeds=range(696100,700196)\n a=run_many(TH,seeds,8)\n np.save('scratch/replica_CH_transfer.npy',a)\n result['transfer']={}\n for name,idx,value in [('base_plus_3bps',23,TH[23]+.0003),('stale_x0.8',32,TH[32]*.8),('lambda_x1.5',25,TH[25]*1.5)]:\n th=TH.copy(); th[idx]=value\n start=time.perf_counter()\n b=run_many(th,seeds,8)\n elapsed=time.perf_counter()-start\n np.save('scratch/replica_'+name+'.npy',b)\n result['transfer'][name]={**summary(b[:,0]-a[:,0]),'component_deltas':(b-a).mean(axis=0).tolist(),'worst':float((b[:,0]-a[:,0]).min()),'seconds':elapsed}\n Path('scratch/replica_eval.json').write_text(json.dumps(result,indent=2))\n print(json.dumps(result,indent=2))\n", "callback_check_source": "from pathlib import Path\nimport json,sys\nimport numpy as np\nfrom amm_competition.evm.compiler import SolidityCompiler\nfrom amm_competition.evm.executor import EVMStrategyExecutor\nfrom replica import TH,strat_init,strat_after\n\ndef check(source,th):\n c=SolidityCompiler().compile(source)\n assert c.success,c.errors\n e=EVMStrategyExecutor(c.bytecode)\n # direct ABI calls preserve Rust's from_f64 rounding at the boundary\n evm=e.evm\n def call(selector,fields):\n data=selector+b''.join(int(v).to_bytes(32,'big') for v in fields)\n result=evm.message_call(caller=e.CALLER_ADDRESS,to=e.deployed_address,calldata=data,value=0,gas=250000)\n assert len(result)==64\n return np.array([int.from_bytes(result[:32],'big')/1e18,int.from_bytes(result[32:],'big')/1e18])\n S=np.zeros(40)\n assert np.array_equal(strat_init(S,th,100.,10000.),call(e.SELECTOR_AFTER_INITIALIZE,[int(100.*1e18),int(10000.*1e18)]))\n rng=np.random.default_rng(880117)\n t=0; worst=0.\n for i in range(5000):\n # Test ties, gaps > ELAPSED_CAP, signal/gate/tail/clamp regions.\n # Jitter ratios so float/WAD threshold ties are tested separately.\n t+=int(rng.choice([0,0,0,1,1,2,9,20]))\n price=100.*np.exp(rng.normal(0,.02))\n rx=100.*np.exp(rng.normal(0,.2)); ry=rx*price\n ratio=float(rng.choice([1e-8,1/650, .0008,.002,.05,.25]))*float(rng.uniform(.999,1.001))\n ay=ratio*ry; ax=ay/price\n buy=bool(rng.integers(0,2))\n info=[int(buy),int(ax*1e18),int(ay*1e18),t,int(rx*1e18),int(ry*1e18)]\n a=np.array(strat_after(S,th,buy,info[1]/1e18,info[2]/1e18,t,info[4]/1e18,info[5]/1e18))\n b=call(e.SELECTOR_AFTER_SWAP,info)\n err=float(np.max(np.abs(a-b)))\n worst=max(worst,err)\n assert err<2e-13,(i,a,b,err)\n return worst\nif __name__=='__main__':\n ch=Path('scratch/CH.sol').read_text()\n result={}\n for name,source,idx,value in [('CH',ch,23,TH[23]),('base_plus_3bps',ch.replace('BASE_FEE = 4 * BPS','BASE_FEE = 7 * BPS'),23,.0007),('stale_x0.8',ch.replace('STALE_DIR_COEF = 6850 * BPS','STALE_DIR_COEF = 5480 * BPS'),32,.548),('lambda_x1.5',ch.replace('LAMBDA_COEF = 12 * BPS','LAMBDA_COEF = 18 * BPS'),25,.0018)]:\n th=TH.copy(); th[idx]=value\n result[name]={'calls':5000,'max_abs_fee_error':check(source,th)}\n Path('scratch/strategy_checks.json').write_text(json.dumps(result,indent=2))\n print(result)\n", "market_check_source": "import json,time,math\nfrom pathlib import Path\nimport numpy as np\nfrom replica import *\nimport replica\n\ndef check():\n checks={}\n for seed in range(10000,20000):\n got=replica._config_uniforms(seed)\n want=np.random.default_rng(seed).random(3)\n assert np.array_equal(got,want),(seed,got,want)\n checks['stdlib_config_exact_draws']=10000\n a=run_many(TH,range(696100,696132),1)\n b=run_many(TH,range(696100,696132),8)\n assert np.array_equal(a,b)\n assert np.allclose(a[:,0],a[:,1]+a[:,2],rtol=0,atol=0)\n assert np.all(a[:,3]>=0) and np.isfinite(a).all()\n checks['serial_parallel_identical_markets']=len(a)\n checks['edge_component_identity']=True\n # Analytic no-order, no-volatility market remains unchanged.\n # rate is floored to .01 in engine, so zero n_steps is used for exact no event.\n assert run_market(TH,1,20,.8,.000945,0)==(0.,0.,0.,0.)\n S=np.zeros(40);th=TH.copy();th[37]=.003\n x=np.array([100.,100.]);y=np.array([10000.,10000.]);f=np.full((2,2),.003)\n strat_init(S,th,100,10000)\n p=110.;rx=x[0];ry=y[0];k=rx*ry\n ax=rx-math.sqrt(k/(.997*p));ay=(k/(rx-ax)-ry)/.997\n edge=replica._arb(S,th,x,y,f,0,p,0)\n assert abs(edge-(ay-ax*p))<1e-11\n assert abs(x[0]*y[0]-k)<1e-8\n e,v=replica._retail(S,th,x,y,f,0,True,1.,p,0)\n assert abs(x[0]*y[0]-k)<1e-8\n assert v>0\n checks['analytical_arb_and_fee_exclusion']=True\n checks['zero_steps']=True\n run_market(TH,0,20.,.8,.000945,1)\n times=[]\n for _ in range(3):\n start=time.perf_counter();o=run_many(TH,range(10000,14096),8)\n times.append(time.perf_counter()-start)\n checks['speed']={'n':4096,'n_steps':10000,'processes':8,'seconds':times,'markets_per_second':[4096/t for t in times],'median_markets_per_second':float(np.median([4096/t for t in times])),'warm_jit':True,'includes_config_generation_and_process_startup':True}\n return checks\nif __name__=='__main__':\n d=check();Path('scratch/market_checks.json').write_text(json.dumps(d,indent=2));print(json.dumps(d,indent=2))\n", "commands": [ ". scratch/env.sh && python scratch/real_eval.py", ". scratch/env.sh && python scratch/replica_eval.py", ". scratch/env.sh && python scratch/check_strategy.py", ". scratch/env.sh && python scratch/check_market.py", "AMM_REPLICA_STDLIB=1 python3 scratch/replica.py --n 256 --procs 8" ] }, "transfer_baseline": { "real": { "n": 128, "mean": 542.7661042021791, "se": 8.22694466241365 }, "replica": { "n": 4096, "mean": 525.0286937477988, "se": 1.415531544113194 }, "gas": { "max_ok": 129012, "oog": 0, "after_swap_calls": 1354536, "all_callbacks_max_ok": 185532, "revert": 0, "other_halt": 0, "tx_error": 0, "bad_return": 0 } }, "measurement_sha256": { "real_CH.json": "7fa77fb4296fd35ed03ab071c7620a70b8e53591576d1aa0dc788540e3946391", "real_CH_transfer.json": "f3ef9e07d59cd47384b7d97c6622c54131c5242793082006ad2cde2ed9f2164a", "real_base_plus_3bps.json": "0648b19a2fa204e843cf7951b0bba1f550171b05536101c22c912324391cdaf4", "real_flat30.json": "4728ee37be7d7b3102e256e6f9e429a0fc269ab79e50b627d6aef08ea975f2cc", "real_lambda_x1.5.json": "7083e87705e9e01ed25c187146853c60f5d6c19b3129414932c5a236cc6d9742", "real_stale_x0.8.json": "fad295d5570f84f9174ed9c4392a97ba5de9483eec68f242853f4b85f60389b0", "replica_CH.npy": "83c67197dae5b9b7b7a599b4469af91a6e9130de510de9aca5a93e2d7d4a4841", "replica_CH_transfer.npy": "013bba50667990d3877b2189d7e58562bce719a96cbb8e72c3c333abe2c0518e", "replica_base_plus_3bps.npy": "5cfb5f7fbd57161e8877e44095d4efc25ed48ae04940f461c4780a16cd18af6f", "replica_flat30.npy": "28f69b099ae6509ffd72690065cd68ffe3cb71996cab58282933294d9bad262b", "replica_lambda_x1.5.npy": "365f4d6b7889cb0c2da7519210f478b0cc3f411d465a8f57d5881df48a577b37", "replica_stale_x0.8.npy": "b693b532f45c3d8c9bdb54b68badb6a0e2f9288f53a5e58e063f6ab9f19b1685" } }