{"item":"b","batch":"e07-vol-flow","blocked":null,"code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport {AMMStrategyBase} from \"./AMMStrategyBase.sol\";\nimport {TradeInfo} from \"./IAMMStrategy.sol\";\n\ncontract Strategy is AMMStrategyBase {\n uint256 constant ELAPSED_CAP = 8;\n uint256 constant SIGNAL_THRESHOLD = WAD / 650;\n uint256 constant DIR_DECAY = 750000000000000000;\n uint256 constant ACT_DECAY = 530000000000000000;\n uint256 constant SIZE_DECAY = 530000000000000000;\n uint256 constant TOX_DECAY = 910000000000000000;\n uint256 constant SIGMA_DECAY = 690000000000000000;\n uint256 constant LAMBDA_DECAY = 990000000000000000;\n uint256 constant SIZE_BLEND_DECAY = 828000000000000000;\n uint256 constant TOX_BLEND_DECAY = 51000000000000000;\n uint256 constant ACT_BLEND_DECAY = 985000000000000000;\n uint256 constant PHAT_ALPHA = 270000000000000000;\n uint256 constant PHAT_ALPHA_RETAIL = 60000000000000000;\n uint256 constant PHAT_ALPHA_SAME = 120000000000000000;\n uint256 constant REVERT_U = 0;\n uint256 constant DIR_IMPACT_MULT = 4;\n uint256 constant GATE_SIGMA_MULT = 7200000000000000000;\n uint256 constant MIN_GATE = 30000000000000000;\n uint256 constant TRADE_TOX_BOOST = 3500 * BPS;\n uint256 constant STALE_ATTRACT_FRAC = 1050000000000000000;\n uint256 constant RET_CAP = WAD / 35;\n uint256 constant TOX_CAP = WAD / 5;\n uint256 constant TRADE_RATIO_CAP = WAD / 5;\n uint256 constant LAMBDA_CAP = 1820000000000000000;\n uint256 constant STEP_COUNT_CAP = 64;\n uint256 constant BASE_FEE = 4 * BPS;\n uint256 constant SIGMA_COEF = 200000000000000000;\n uint256 constant LAMBDA_COEF = 12 * BPS;\n uint256 constant FLOW_SIZE_COEF = 4842 * BPS;\n uint256 constant TOX_COEF = 300 * BPS;\n uint256 constant TOX_QUAD_COEF = 15000 * BPS;\n uint256 constant ACT_COEF = 91843 * BPS;\n uint256 constant DIR_COEF = 20 * BPS;\n uint256 constant DIR_TOX_COEF = 100 * BPS;\n uint256 constant STALE_DIR_COEF = 6850 * BPS;\n uint256 constant SIGMA_TOX_COEF = 500 * BPS;\n uint256 constant TAIL_KNEE = 600 * BPS;\n uint256 constant TAIL_SLOPE_PROTECT = 930000000000000000;\n uint256 constant TAIL_SLOPE_ATTRACT = 850000000000000000;\n\n function afterInitialize(uint256 initialX, uint256 initialY) external override returns (uint256, uint256) {\n slots[0] = BASE_FEE; slots[1] = BASE_FEE; slots[3] = WAD; \n slots[5] = initialX > 0 ? wdiv(initialY, initialX) : 100 * WAD;\n slots[6] = 950000000000000; slots[7] = 800000000000000000; slots[8] = 2000000000000000;\n slots[15] = 400000000000000000 | (uint256(2000000000000000) << 160); slots[13] = 902500000000; slots[14] = slots[5]; \n return (BASE_FEE, BASE_FEE);\n }\n\n function afterSwap(TradeInfo calldata trade) external override returns (uint256, uint256) {\n uint256 prevBidFee = slots[0]; uint256 prevAskFee = slots[1]; uint256 lastTs = uint64(slots[2]);\n uint256 dirState = slots[3]; uint256 actEma = slots[4]; uint256 pHat = slots[5];\n uint256 sigmaHat = slots[6]; uint256 lambdaHat = slots[7]; uint256 sizeHat = slots[8];\n uint256 toxEma = slots[9]; uint256 stepTradeCount = slots[10];\n\n uint256 sigmaForFast = sigmaHat;\n uint256 fastHat = slots[14];\n uint256 uncertainty = slots[13];\n uint256 silent = trade.timestamp > lastTs ? trade.timestamp - lastTs : 0;\n bool isNewStep = trade.timestamp > lastTs;\n if (isNewStep) {\n uint256 elapsedRaw = trade.timestamp - lastTs;\n uint256 elapsed = elapsedRaw > ELAPSED_CAP ? ELAPSED_CAP : elapsedRaw;\n dirState = _decayCentered(dirState, DIR_DECAY, elapsed);\n actEma = wmul(actEma, _powWad(ACT_DECAY, elapsed));\n sizeHat = wmul(sizeHat, _powWad(SIZE_DECAY, elapsed));\n toxEma = wmul(toxEma, _powWad(TOX_DECAY, elapsed));\n if (stepTradeCount > 0 && elapsedRaw > 0) {\n uint256 lambdaInst = (stepTradeCount * WAD) / elapsedRaw;\n if (lambdaInst > LAMBDA_CAP) lambdaInst = LAMBDA_CAP;\n lambdaHat = wmul(lambdaHat, LAMBDA_DECAY) + wmul(lambdaInst, WAD - LAMBDA_DECAY);\n }\n // Process variance is propagated inside the censored update.\n if (uncertainty > 100000000000000) uncertainty = 100000000000000;\n stepTradeCount = 0;\n }\n\n bool firstInStep = stepTradeCount == 0;\n uint256 spot = trade.reserveX > 0 ? wdiv(trade.reserveY, trade.reserveX) : pHat;\n if (pHat == 0) pHat = spot;\n\n uint256 feeUsed = trade.isBuy ? prevBidFee : prevAskFee;\n uint256 gamma = feeUsed < WAD ? WAD - feeUsed : 0;\n uint256 pImplied;\n if (gamma == 0) { pImplied = spot; }\n else { pImplied = trade.isBuy ? wmul(spot, gamma) : wdiv(spot, gamma); }\n\n // S: infer a no-trade interval center from the last post-trade spot.\n uint256 silenceScale = WAD;\n if (firstInStep && silent > 1) {\n uint256 g = silent - 1;\n if (g > 1) g = 1;\n uint256 w = WAD - _powWad(800000000000000000, g);\n uint256 s = slots[2] >> 64;\n if (s == 0) s = pHat;\n uint256 c = (wmul(s, WAD - prevBidFee) + wdiv(s, WAD - prevAskFee)) / 2;\n if (c >= pHat) pHat += wmul(w, c - pHat);\n else pHat -= wmul(w, pHat - c);\n silenceScale = WAD - wmul(300000000000000000, w);\n }\n\n {\n uint256 ret = pHat > 0 ? wdiv(absDiff(pImplied, pHat), pHat) : 0;\n uint256 alpha = firstInStep ? PHAT_ALPHA : PHAT_ALPHA_RETAIL;\n uint256 prePhat = pHat;\n bool secondPrint = !firstInStep && stepTradeCount == 1;\n bool sameDir = false; bool oppDir = false;\n if (secondPrint) {\n bool up2 = pImplied >= pHat;\n uint256 d1 = slots[12];\n if (d1 != 0) { sameDir = (d1 == 1) == up2; oppDir = !sameDir; }\n if (sameDir) alpha = PHAT_ALPHA_SAME;\n }\n if (firstInStep) { slots[12] = pImplied >= pHat ? 1 : 2; }\n uint256 adaptiveGate = wmul(sigmaHat, GATE_SIGMA_MULT);\n if (adaptiveGate < MIN_GATE) adaptiveGate = MIN_GATE;\n alpha = wmul(alpha, silenceScale);\n adaptiveGate = wmul(adaptiveGate, silenceScale);\n if (ret <= adaptiveGate) { pHat = wmul(pHat, WAD - alpha) + wmul(pImplied, alpha); }\n if (oppDir && REVERT_U > 0) {\n uint256 pre = slots[11];\n if (pre > pHat) pHat = pHat + wmul(pre - pHat, REVERT_U);\n else pHat = pHat - wmul(pHat - pre, REVERT_U);\n }\n if (firstInStep) {\n if (ret > RET_CAP) ret = RET_CAP;\n sigmaHat = wmul(sigmaHat, SIGMA_DECAY) + wmul(ret, WAD - SIGMA_DECAY);\n }\n }\n\n // Interior retail routing equalizes fee-adjusted marginal prices.\n // Subsequent trades in a step cannot be the initial arbitrage trade.\n if (!firstInStep && feeUsed > 30 * BPS && gamma > 0) {\n uint256 normalSpot = trade.isBuy\n ? wdiv(wmul(spot, gamma), WAD - 30 * BPS)\n : wdiv(wmul(spot, WAD - 30 * BPS), gamma);\n pHat = wmul(pHat, 90 * WAD / 100) + wmul(normalSpot, 10 * WAD / 100);\n }\n\n // Censored assumed-density posterior. No external or future inputs.\n uint256 arbProbability;\n (fastHat, uncertainty, arbProbability) = _posterior(PosteriorInput(\n fastHat, uncertainty, pImplied, spot, slots[2] >> 64,\n prevBidFee, prevAskFee, firstInStep, silent, trade.isBuy,\n trade.reserveY > 0 ? wdiv(trade.amountY, trade.reserveY) : 0\n ));\n slots[13] = uncertainty;\n slots[14] = fastHat;\n uint256 tradeRatio = trade.reserveY > 0 ? wdiv(trade.amountY, trade.reserveY) : 0;\n if (tradeRatio > TRADE_RATIO_CAP) tradeRatio = TRADE_RATIO_CAP;\n\n if (tradeRatio > SIGNAL_THRESHOLD) {\n uint256 push = tradeRatio * DIR_IMPACT_MULT;\n if (push > WAD / 4) push = WAD / 4;\n if (trade.isBuy) {\n dirState = dirState + push;\n if (dirState > 2 * WAD) dirState = 2 * WAD;\n } else {\n dirState = dirState > push ? dirState - push : 0;\n }\n actEma = wmul(actEma, ACT_BLEND_DECAY) + wmul(tradeRatio, WAD - ACT_BLEND_DECAY);\n sizeHat = wmul(sizeHat, SIZE_BLEND_DECAY) + wmul(tradeRatio, WAD - SIZE_BLEND_DECAY);\n if (sizeHat > WAD) sizeHat = WAD;\n }\n\n uint256 tox = pHat > 0 ? wdiv(absDiff(spot, pHat), pHat) : 0;\n if (tox > TOX_CAP) tox = TOX_CAP;\n toxEma = wmul(toxEma, TOX_BLEND_DECAY) + wmul(tox, WAD - TOX_BLEND_DECAY);\n uint256 toxSignal = toxEma;\n\n stepTradeCount = stepTradeCount + 1;\n if (stepTradeCount > STEP_COUNT_CAP) stepTradeCount = STEP_COUNT_CAP;\n\n uint256 originalLambda = lambdaHat; uint256 originalSize = sizeHat;\n\n if (342406799193418304 > 0) {\n uint256 packedFlow = slots[15];\n uint256 rate = uint80(packedFlow);\n uint256 count = uint80(packedFlow >> 80);\n uint256 meanSize = uint80(packedFlow >> 160);\n if (rate == 0) rate = 400000000000000000;\n if (meanSize == 0) meanSize = 2000000000000000;\n if (isNewStep) {\n uint256 inst = count / silent;\n if (inst > 3 * WAD) inst = 3 * WAD;\n uint256 retention = _powWad(999000000000000000, silent > 64 ? 64 : silent);\n rate = wmul(rate, retention) + wmul(inst, WAD-retention);\n count = 0;\n }\n uint256 weight = firstInStep ? WAD-arbProbability : WAD;\n uint256 correctedWeight = weight;\n if (2 == 2) {\n uint256 missing = wmul(feeUsed, 196030880396139429888);\n if (missing > 333333333333333376) missing = 333333333333333376;\n correctedWeight = wdiv(weight, WAD-missing);\n }\n count += correctedWeight;\n uint256 learning = wmul(WAD-999000000000000000, weight);\n meanSize = _blend(meanSize, tradeRatio, learning);\n slots[15]=rate | (count << 80) | (meanSize << 160);\n uint256 retailRate = wmul(rate, 366383424913407168);\n uint256 retailSize = 2 == 0 ? sizeHat : wmul(meanSize,1883296158119298304);\n lambdaHat = _blend(lambdaHat,retailRate,342406799193418304);\n sizeHat = _blend(sizeHat,retailSize,342406799193418304);\n }\n uint256 flowSize = wmul(lambdaHat, sizeHat);\n uint256 fBase = BASE_FEE + wmul(2831435971634313728, wmul(SIGMA_COEF, sigmaHat)) + wmul(170131812809230272, wmul(LAMBDA_COEF, lambdaHat)) + wmul(170131812809230272, wmul(FLOW_SIZE_COEF, flowSize));\n uint256 fMid = fBase + wmul(TOX_COEF, toxSignal) + wmul(TOX_QUAD_COEF, wmul(toxSignal, toxSignal)) + wmul(170131812809230272, wmul(ACT_COEF, actEma));\n fMid = fMid + wmul(2831435971634313728, wmul(SIGMA_TOX_COEF, wmul(sigmaHat, toxSignal)));\n fMid = fMid > 70399256375875 ? fMid - 70399256375875 : 0;\n\n lambdaHat = originalLambda; sizeHat = originalSize;\n uint256 dirDev; bool sellPressure;\n if (dirState >= WAD) { dirDev = dirState - WAD; sellPressure = true; }\n else { dirDev = WAD - dirState; sellPressure = false; }\n\n uint256 skew = wmul(DIR_COEF, dirDev) + wmul(DIR_TOX_COEF, wmul(dirDev, toxSignal));\n uint256 bidFee; uint256 askFee;\n if (sellPressure) {\n bidFee = fMid + skew;\n askFee = fMid > skew ? fMid - skew : 0;\n } else {\n askFee = fMid + skew;\n bidFee = fMid > skew ? fMid - skew : 0;\n }\n\n {\n uint256 staleHat = wmul(pHat, 700000000000000000) + wmul(fastHat, 300000000000000000);\n uint256 staleTox = wdiv(absDiff(spot, staleHat), staleHat);\n if (staleTox > TOX_CAP) staleTox = TOX_CAP;\n uint256 staleShift = wmul(STALE_DIR_COEF, staleTox);\n uint256 attractShift = wmul(staleShift, STALE_ATTRACT_FRAC);\n if (spot >= staleHat) {\n bidFee = bidFee + staleShift;\n askFee = askFee > attractShift ? askFee - attractShift : 0;\n } else {\n askFee = askFee + staleShift;\n bidFee = bidFee > attractShift ? bidFee - attractShift : 0;\n }\n }\n\n {\n bool tradeAligned = (trade.isBuy && spot >= pHat) || (!trade.isBuy && spot < pHat);\n if (tradeAligned) {\n uint256 tradeBoost = wmul(TRADE_TOX_BOOST, tradeRatio);\n if (!firstInStep && tradeBoost > 16 * BPS) tradeBoost = 16 * BPS;\n if (trade.isBuy) { bidFee = bidFee + tradeBoost; }\n else { askFee = askFee + tradeBoost; }\n }\n }\n\n if (sellPressure) {\n bidFee = clampFee(_compressTailWithSlope(bidFee, TAIL_SLOPE_PROTECT));\n askFee = clampFee(_compressTailWithSlope(askFee, TAIL_SLOPE_ATTRACT));\n } else {\n askFee = clampFee(_compressTailWithSlope(askFee, TAIL_SLOPE_PROTECT));\n bidFee = clampFee(_compressTailWithSlope(bidFee, TAIL_SLOPE_ATTRACT));\n }\n\n if (firstInStep) {\n if (askFee > bidFee && bidFee > 30 * BPS) bidFee = 30 * BPS;\n else if (bidFee > askFee && askFee > 30 * BPS) askFee = 30 * BPS;\n }\n\n if (bidFee > askFee && askFee > 36 * BPS) askFee = 36 * BPS;\n else if (askFee > bidFee && bidFee > 36 * BPS) bidFee = 36 * BPS;\n\n slots[0] = bidFee; slots[1] = askFee; slots[2] = (spot << 64) | trade.timestamp;\n slots[3] = dirState; slots[4] = actEma; slots[5] = pHat;\n slots[6] = sigmaHat; slots[7] = lambdaHat; slots[8] = sizeHat;\n slots[9] = toxEma; slots[10] = stepTradeCount;\n\n return (bidFee, askFee);\n }\n\n\n struct PosteriorInput {\n uint256 mu; uint256 v; uint256 obs; uint256 spot; uint256 preSpot;\n uint256 bid; uint256 ask; bool first; uint256 silent; bool buy; uint256 size;\n }\n function _posterior(PosteriorInput memory x) internal pure returns (uint256, uint256, uint256) {\n if (x.mu == 0) x.mu = x.spot;\n if (x.v < 10000000000) x.v = 10000000000;\n uint256 lo = wmul(x.preSpot, WAD-x.bid);\n uint256 hi = wdiv(x.preSpot, WAD-x.ask);\n if (x.first) {\n if (x.silent>1 && x.preSpot>0) {\n uint256 elapsed=x.silent>8?8:x.silent;\n x.v += 902500000000*(elapsed-1);\n (x.mu,x.v)=_band(x.mu,x.v,lo,hi);\n }\n x.v+=902500000000;\n }\n uint256 mRetail = x.mu;\n uint256 vRetail = x.v;\n // A missing own-pool trade is a censored price observation.\n if (x.first && x.preSpot > 0) {\n (mRetail, vRetail) = _band(x.mu, x.v, lo, hi);\n }\n if (!x.first) {\n // A later print is retail. Only an interior route is an observation\n // of the other pool, with explicit observation uncertainty.\n uint256 fee = x.buy ? x.bid : x.ask;\n if (fee > 30 * BPS) {\n uint256 normal = x.buy ? wdiv(wmul(x.spot, WAD-fee), WAD-30*BPS)\n : wdiv(wmul(x.spot, WAD-30*BPS), WAD-fee);\n uint256 residual = wdiv(absDiff(normal, x.mu),x.mu);\n uint256 noise = 9000000000000 + wmul(residual,residual);\n uint256 k = wdiv(x.v,x.v+noise);\n return (_blend(x.mu,normal,k),wmul(x.v,WAD-k),0);\n }\n return (x.mu,x.v,0);\n }\n uint256 e = wdiv(absDiff(x.obs,x.mu),x.mu);\n uint256 totalV = x.v + 22500000000;\n uint256 z = wdiv(wmul(e,e),totalV);\n uint256 density = _powWad(wdiv(WAD,WAD+z/8),4);\n uint256 odds = wmul(density,wdiv(4000000000000000,_isqrt(totalV*WAD)));\n if (x.size > 3000000000000000) odds = wmul(odds,4*WAD/10);\n if (x.silent > 1) odds = wmul(odds,8*WAD/10);\n uint256 sd = _isqrt(x.v*WAD);\n uint256 width = wdiv(hi-lo,x.mu);\n uint256 distance = x.muhi?x.mu-hi:0);\n uint256 zBand = wdiv(wdiv(distance,x.mu),sd);\n uint256 mass = wmul(wdiv(width,width+2*sd),wdiv(WAD,WAD+wmul(zBand,zBand)));\n if (mass < WAD/100) mass = WAD/100;\n odds = wdiv(odds,mass);\n uint256 prob = wdiv(odds,WAD+odds);\n uint256 kArb = wdiv(x.v,totalV);\n uint256 mArb = _blend(x.mu,x.obs,kArb);\n uint256 mean = _blend(mRetail,mArb,prob);\n uint256 between = wdiv(absDiff(mArb,mRetail),x.mu);\n uint256 variance = wmul(prob,wmul(x.v,WAD-kArb)) + wmul(WAD-prob,vRetail)\n + wmul(wmul(prob,WAD-prob),wmul(between,between));\n if (variance > 100000000000000) variance = 100000000000000;\n return (mean,variance,prob);\n }\n function _blend(uint256 a,uint256 b,uint256 w) internal pure returns(uint256) {\n return b>=a ? a+wmul(b-a,w) : a-wmul(a-b,w);\n }\n function _band(uint256 mu,uint256 v,uint256 lo,uint256 hi) internal pure returns(uint256,uint256) {\n // Soft interval likelihood avoids discontinuities at quadrature nodes.\n uint256 sd=wmul(mu,_isqrt(v*WAD));\n uint256[3] memory acc;\n for(uint256 j=0;j<7;j++) {\n uint256 p=j<3 ? (mu>(3-j)*sd?mu-(3-j)*sd:1) : mu+(j-3)*sd;\n uint256 w=j==3?72:(j==2||j==4?45:(j==1||j==5?10:1));\n uint256 distance=phi?p-hi:0);\n uint256 z=sd>0?wdiv(distance,sd):0;\n uint256 likelihood=wdiv(WAD,WAD+4*wmul(z,z));\n w=wmul(w*WAD,likelihood);\n acc[0]+=w;acc[1]+=wmul(w,p);\n uint256 d=wdiv(absDiff(p,mu),mu);\n acc[2]+=wmul(w,wmul(d,d));\n }\n uint256 m=wdiv(acc[1],acc[0]);\n uint256 d=wdiv(absDiff(m,mu),mu);\n uint256 second=wdiv(acc[2],acc[0]);\n return(m,second>wmul(d,d)?second-wmul(d,d):10000000000);\n }\n\n function _compressTailWithSlope(uint256 fee, uint256 slope) internal pure returns (uint256) {\n if (fee <= TAIL_KNEE) return fee;\n return TAIL_KNEE + wmul(fee - TAIL_KNEE, slope);\n }\n\n function _powWad(uint256 factor, uint256 exp) internal pure returns (uint256 result) {\n result = WAD;\n while (exp > 0) {\n if (exp & 1 == 1) result = wmul(result, factor);\n factor = wmul(factor, factor);\n exp >>= 1;\n }\n }\n\n function _decayCentered(uint256 centered, uint256 decayFactor, uint256 elapsed) internal pure returns (uint256) {\n uint256 mul = _powWad(decayFactor, elapsed);\n if (centered >= WAD) { return WAD + wmul(centered - WAD, mul); }\n uint256 below = wmul(WAD - centered, mul);\n return below < WAD ? WAD - below : 0;\n }\n\n // Floor square root: bit-length seed and seven Newton steps (all uint256).\n function _isqrt(uint256 x) internal pure returns (uint256 r) {\n if (x == 0) return 0;\n unchecked {\n uint256 y = x;\n r = 1;\n if (y >> 128 != 0) { y >>= 128; r <<= 64; }\n if (y >> 64 != 0) { y >>= 64; r <<= 32; }\n if (y >> 32 != 0) { y >>= 32; r <<= 16; }\n if (y >> 16 != 0) { y >>= 16; r <<= 8; }\n if (y >> 8 != 0) { y >>= 8; r <<= 4; }\n if (y >> 4 != 0) { y >>= 4; r <<= 2; }\n if (y >> 2 != 0) { r <<= 1; }\n r = (r + x / r) >> 1;\n r = (r + x / r) >> 1;\n r = (r + x / r) >> 1;\n r = (r + x / r) >> 1;\n r = (r + x / r) >> 1;\n r = (r + x / r) >> 1;\n r = (r + x / r) >> 1;\n uint256 t = x / r;\n return r < t ? r : t;\n }\n }\n\n function getName() external pure override returns (string memory) { return \"censored_10\"; }\n}\n","sha256":"84fc2d2a024b29b779e1b62a636d7b986bfbd0389b4a0750e3f97c2d8c7e6b60","params":{"a":1.8314359716343138,"b":0.8298681871907697,"c":0.7039925637587545},"log":[{"params":{"a":1.3376592963992056,"b":-0.13437519037745127,"c":1.1562782262149236},"n":64,"start":935064,"mean_diff":-16.059760229561423,"se":0.5352789497181236,"fitness":-16.059760229561423,"gas":{"max_ok":200624,"init_max_ok":243099,"oog":0,"halts":0},"rs2_gas":{"max_ok":200175,"init_max_ok":243099,"oog":0,"halts":0},"valid":true,"seconds":209.38856590003707,"generation":0},{"params":{"a":0.47742766933130965,"b":0.508672049813459,"c":1.2563645354794175},"n":64,"start":935128,"mean_diff":-7.048299054143703,"se":0.15973557562500618,"fitness":-7.048299054143703,"gas":{"max_ok":197714,"init_max_ok":243099,"oog":0,"halts":0},"rs2_gas":{"max_ok":197288,"init_max_ok":243099,"oog":0,"halts":0},"valid":true,"seconds":224.2561643240042,"generation":0},{"params":{"a":1.8314359716343138,"b":0.8298681871907697,"c":0.7039925637587545},"n":64,"start":935256,"mean_diff":-5.353786904061062,"se":0.1680907290253961,"fitness":-5.353786904061062,"gas":{"max_ok":200693,"init_max_ok":243099,"oog":0,"halts":0},"rs2_gas":{"max_ok":200244,"init_max_ok":243099,"oog":0,"halts":0},"valid":true,"seconds":227.34247615700588,"generation":0},{"params":{"a":1.9527628671976367,"b":0.290536637231113,"c":1.9531306080711246},"n":64,"start":935320,"mean_diff":-19.089556435268335,"se":0.4945901521524677,"fitness":-19.089556435268335,"gas":{"max_ok":202866,"init_max_ok":243099,"oog":0,"halts":0},"rs2_gas":{"max_ok":200163,"init_max_ok":243099,"oog":0,"halts":0},"valid":true,"seconds":205.67276394320652,"generation":0},{"params":{"a":1.1642270739494998,"b":0.8553547246115492,"c":0.4099685487184759},"n":64,"start":935384,"mean_diff":-10.317815614260455,"se":0.22814199542413902,"fitness":-10.317815614260455,"gas":{"max_ok":197726,"init_max_ok":243099,"oog":0,"halts":0},"rs2_gas":{"max_ok":199320,"init_max_ok":243099,"oog":0,"halts":0},"valid":true,"seconds":260.79140857816674,"generation":1}],"recheck":{"start":938000,"end_inclusive":938255,"n":256,"candidates":[{"params":{"a":1.8314359716343138,"b":0.8298681871907697,"c":0.7039925637587545},"search_rank":1,"vs_rs2":{"n":256,"mean_diff":-5.443956090147252,"se":0.09242955944247651,"worst":[{"seed":938045,"d":-10.390789061860346},{"seed":938133,"d":-9.006302224477395},{"seed":938140,"d":-8.999515920378713},{"seed":938014,"d":-8.934787995842612},{"seed":938198,"d":-8.727061166581734}]},"retail_edge_delta":{"mean":-4.702066502578839,"se":0.09236489178819045},"arb_edge_delta":{"mean":-0.7418895875684148,"se":0.082800048034273},"gas":{"max_ok":198487,"init_max_ok":243099,"oog":0,"halts":0},"rs2_gas":{"max_ok":199859,"init_max_ok":243099,"oog":0,"halts":0},"valid":true},{"params":{"a":0.47742766933130965,"b":0.508672049813459,"c":1.2563645354794175},"search_rank":2,"vs_rs2":{"n":256,"mean_diff":-7.059508706949509,"se":0.08648192574931299,"worst":[{"seed":938018,"d":-12.206646130804529},{"seed":938042,"d":-10.845794325425572},{"seed":938091,"d":-10.521573026550186},{"seed":938222,"d":-10.05639384583094},{"seed":938151,"d":-10.024353659623898}]},"retail_edge_delta":{"mean":3.147837177271885,"se":0.1249520103492658},"arb_edge_delta":{"mean":-10.207345884221397,"se":0.0963219718426272},"gas":{"max_ok":197738,"init_max_ok":243099,"oog":0,"halts":0},"rs2_gas":{"max_ok":199859,"init_max_ok":243099,"oog":0,"halts":0},"valid":true},{"params":{"a":1.1642270739494998,"b":0.8553547246115492,"c":0.4099685487184759},"search_rank":3,"vs_rs2":{"n":256,"mean_diff":-10.190704458918168,"se":0.11874972662514016,"worst":[{"seed":938018,"d":-18.04627809848489},{"seed":938042,"d":-16.165622602184612},{"seed":938045,"d":-15.708783389517066},{"seed":938027,"d":-15.138091038351149},{"seed":938111,"d":-14.867871685304294}]},"retail_edge_delta":{"mean":2.900957798816871,"se":0.13135585727734672},"arb_edge_delta":{"mean":-13.09166225773504,"se":0.16050639565339328},"gas":{"max_ok":197738,"init_max_ok":243099,"oog":0,"halts":0},"rs2_gas":{"max_ok":199859,"init_max_ok":243099,"oog":0,"halts":0},"valid":true}],"frozen":{"params":{"a":1.8314359716343138,"b":0.8298681871907697,"c":0.7039925637587545},"sha256":"84fc2d2a024b29b779e1b62a636d7b986bfbd0389b4a0750e3f97c2d8c7e6b60","selection":"Highest valid 256-seed recheck paired mean vs RS2, among top three search fitness values.","time_utc":"2026-11-09T04:15:19Z"}},"held_out":{"vs_rs2":{"n":512,"mean_diff":-5.35039590164935,"se":0.06744925771245823,"worst":[{"seed":939349,"d":-9.717350305287937},{"seed":939130,"d":-9.700673396361253},{"seed":939430,"d":-9.658705727879237},{"seed":939312,"d":-9.331928282536182},{"seed":939293,"d":-9.311712979529943}]},"retail_edge_delta":{"mean":-4.437391966873645,"se":0.06488647365890143},"arb_edge_delta":{"mean":-0.913003934775702,"se":0.0559017750921356},"reconciliation_max_abs":2.2737367544323206e-13,"gas":{"max_ok":204316,"init_max_ok":243099,"oog":0,"halts":0},"rs2_gas":{"max_ok":203867,"init_max_ok":243099,"oog":0,"halts":0},"valid":true,"start":939000,"end_inclusive":939511},"gas":{"max_ok":204316,"init_max_ok":243099,"oog":0,"halts":0},"parity":{"n":32,"start":939600,"end_inclusive":939631,"params":{"a":0,"b":0,"c":0},"source_equal":true,"bytecode_equal":true,"all_equal":true,"rows":[{"seed":939600,"equal":true,"edge_diff":0.0},{"seed":939601,"equal":true,"edge_diff":0.0},{"seed":939602,"equal":true,"edge_diff":0.0},{"seed":939603,"equal":true,"edge_diff":0.0},{"seed":939604,"equal":true,"edge_diff":0.0},{"seed":939605,"equal":true,"edge_diff":0.0},{"seed":939606,"equal":true,"edge_diff":0.0},{"seed":939607,"equal":true,"edge_diff":0.0},{"seed":939608,"equal":true,"edge_diff":0.0},{"seed":939609,"equal":true,"edge_diff":0.0},{"seed":939610,"equal":true,"edge_diff":0.0},{"seed":939611,"equal":true,"edge_diff":0.0},{"seed":939612,"equal":true,"edge_diff":0.0},{"seed":939613,"equal":true,"edge_diff":0.0},{"seed":939614,"equal":true,"edge_diff":0.0},{"seed":939615,"equal":true,"edge_diff":0.0},{"seed":939616,"equal":true,"edge_diff":0.0},{"seed":939617,"equal":true,"edge_diff":0.0},{"seed":939618,"equal":true,"edge_diff":0.0},{"seed":939619,"equal":true,"edge_diff":0.0},{"seed":939620,"equal":true,"edge_diff":0.0},{"seed":939621,"equal":true,"edge_diff":0.0},{"seed":939622,"equal":true,"edge_diff":0.0},{"seed":939623,"equal":true,"edge_diff":0.0},{"seed":939624,"equal":true,"edge_diff":0.0},{"seed":939625,"equal":true,"edge_diff":0.0},{"seed":939626,"equal":true,"edge_diff":0.0},{"seed":939627,"equal":true,"edge_diff":0.0},{"seed":939628,"equal":true,"edge_diff":0.0},{"seed":939629,"equal":true,"edge_diff":0.0},{"seed":939630,"equal":true,"edge_diff":0.0},{"seed":939631,"equal":true,"edge_diff":0.0}],"gas":{"max_ok":197195,"init_max_ok":243099,"oog":0,"halts":0},"rs2_gas":{"max_ok":197195,"init_max_ok":243099,"oog":0,"halts":0},"valid":true},"generator_source":"def generate(base, p):\n \"\"\"Scale only the five specified fMid terms; c is in basis points.\n Constant multipliers avoid any additional state or initialization writes.\n Saturating subtraction prevents negative unsigned fees.\n The disabled overlay returns the original source exactly.\n \"\"\"\n a,b,c=map(float,p)\n assert -.5<=a<=3 and -.5<=b<=1 and -2<=c<=3\n if a==b==c==0: return base\n sa=int(round((1+a)*10**18)); sf=int(round((1-b)*10**18))\n old=''' uint256 fBase = BASE_FEE + wmul(SIGMA_COEF, sigmaHat) + wmul(LAMBDA_COEF, lambdaHat) + wmul(FLOW_SIZE_COEF, flowSize);\n uint256 fMid = fBase + wmul(TOX_COEF, toxSignal) + wmul(TOX_QUAD_COEF, wmul(toxSignal, toxSignal)) + wmul(ACT_COEF, actEma);\n fMid = fMid + wmul(SIGMA_TOX_COEF, wmul(sigmaHat, toxSignal));'''\n new=f''' uint256 fBase = BASE_FEE + wmul({sa}, wmul(SIGMA_COEF, sigmaHat)) + wmul({sf}, wmul(LAMBDA_COEF, lambdaHat)) + wmul({sf}, wmul(FLOW_SIZE_COEF, flowSize));\n uint256 fMid = fBase + wmul(TOX_COEF, toxSignal) + wmul(TOX_QUAD_COEF, wmul(toxSignal, toxSignal)) + wmul({sf}, wmul(ACT_COEF, actEma));\n fMid = fMid + wmul({sa}, wmul(SIGMA_TOX_COEF, wmul(sigmaHat, toxSignal)));'''\n offset=int(round(abs(c)*10**14))\n if c>0: new+=f'\\n fMid = fMid > {offset} ? fMid - {offset} : 0;'\n elif c<0: new+=f'\\n fMid += {offset};'\n assert base.count(old)==1\n return base.replace(old,new)\n","calibration":{"n":1000,"mean":525.5258821780834,"expected":525.5258821780834,"raw_counters":[{"role":"Baseline","callback":"afterInitialize","calls":1000,"ok":1000,"max_ok_gas":21796,"sum_ok_gas":21796000,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},{"role":"Baseline","callback":"afterSwap","calls":10741746,"ok":10741746,"max_ok_gas":22592,"sum_ok_gas":242365461576,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},{"role":"Baseline","callback":"getName","calls":1000,"ok":1000,"max_ok_gas":21526,"sum_ok_gas":21526000,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},{"role":"Submission","callback":"afterInitialize","calls":1000,"ok":1000,"max_ok_gas":185532,"sum_ok_gas":185532000,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},{"role":"Submission","callback":"afterSwap","calls":10445223,"ok":10445223,"max_ok_gas":151647,"sum_ok_gas":811927105393,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},{"role":"Submission","callback":"getName","calls":1000,"ok":1000,"max_ok_gas":21530,"sum_ok_gas":21530000,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0}],"passed":true},"interrupted_gas_audit":{"start":935192,"end_inclusive":935255,"n":64,"params":{"a":1.8314359716343138,"b":0.8298681871907697,"c":0.7039925637587545},"sha256":"84fc2d2a024b29b779e1b62a636d7b986bfbd0389b4a0750e3f97c2d8c7e6b60","gas":{"max_ok":199136,"init_max_ok":243099,"oog":0,"halts":0},"raw_counters":[{"role":"Baseline","callback":"afterInitialize","calls":64,"ok":64,"max_ok_gas":21796,"sum_ok_gas":1394944,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},{"role":"Baseline","callback":"afterSwap","calls":676026,"ok":676026,"max_ok_gas":22592,"sum_ok_gas":15253146672,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},{"role":"Baseline","callback":"getName","calls":64,"ok":64,"max_ok_gas":21526,"sum_ok_gas":1377664,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},{"role":"Submission","callback":"afterInitialize","calls":64,"ok":64,"max_ok_gas":243099,"sum_ok_gas":15558336,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},{"role":"Submission","callback":"afterSwap","calls":612068,"ok":612068,"max_ok_gas":199136,"sum_ok_gas":72961117633,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0},{"role":"Submission","callback":"getName","calls":64,"ok":64,"max_ok_gas":21607,"sum_ok_gas":1382848,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0}],"valid":true,"purpose":"Deterministic rerun of the interrupted, unscored search block for gas only. Edges excluded from search, recheck and selection."},"conclusion":"The frozen overlay loses to RS2 on held-out seeds; retain RS2.","protocol":{"repository":"https://github.com/benedictbrady/amm-challenge","commit":"6b6921f8d463314aa7c96234e1be25a25245f704","baseline_sha256":"f24b6ca198b744c380842c3a17964a6dc21f311bb04984b26733afa3fee8eaf2","baseline_source":"https://api.imd.fun/artifacts/19f2ec857df536e8ab62ab1da89ec6623332521ce46849f15bccff402c63e1e5","method_source":"https://api.imd.fun/artifacts/33f54e81f3372088e9eced52c0174f310ac348af98ef5727b73785c088679194","search":{"seconds":1248.3903088904917,"cma_seed":52,"complete_generations":1,"population":4,"resumed_evaluations":2,"original_population":7,"stop":"time budget"},"workers":8,"n_steps":10000,"arms":"Each candidate and RS2 alone against VanillaStrategy in separate run_batch calls.","search_start":935064,"search_reserved_end_inclusive":937999,"bounds":{"a":[-0.5,3],"b":[-0.5,1],"c":[-2,3]},"c_units":"basis points","cma_version":"4.5.0","cma_initial_mean":[1,0.5,1],"cma_initial_sigma":0.65,"cma_population":4},"notes":["Item-specific seed restriction takes precedence over the general goal confirmation instructions: no seeds >= 5000000 were used; no STACK or board gain is claimed.","RS2 hash was checked before any simulation. Initial RS2 benchmark used 935000..935003 and an overlay smoke check used 935004..935007; search begins at 935064 to keep its blocks fresh.","Each proposal used its own disjoint 64-seed search block and paired RS2 arm. After two evaluations, population was reduced from seven to four to fit measured runtime; seed 52 gives identical first four proposals, and retained parameters were checked bit-for-bit against the reconstructed population. The original elapsed time and deadline were preserved. An interrupted, unscored block 935192..935255 was excluded from fitness; resumed proposals used fresh blocks starting at 935256. That block was later rerun for gas only; its edges were not used in selection. Incomplete final CMA population, if any, is retained in the log but not passed to es.tell.","The top three valid search fitness values were rechecked on the same reserved 256-seed block; the highest recheck mean was frozen before held-out data were evaluated.","SIGMA_COEF and SIGMA_TOX_COEF terms are each multiplied by 1+a; LAMBDA_COEF, FLOW_SIZE_COEF and ACT_COEF terms by 1-b, using WAD integer multipliers. c is subtracted with a floor of zero. No storage or initialization writes were added.","gas reports submission callback maxima across all completed frozen-source runs: its search, recheck, held-out, and matching gas audit. Each phase retains its own counters. Per-proposal, RS2 and parity gas and halt counters are separately recorded. Any halt invalidates fitness; the stricter 235000/245000 caps are also enforced.","Retail and arbitrage deltas use the reference harness decomposition from per-step fair prices, previous spots and fees; retail is total edge minus reconstructed arb edge. Standard errors use sample standard deviation / sqrt(n); worst lists the five lowest paired seed differences.","CH calibration is exactly the required 0..999 block and tolerance is 1e-8. Parity compares edges, PnL, initial reserves, average fees, and every step fair price, spot prices, fees and PnL for all 32 reserved seeds.","Only five proposals completed within the search budget; this does not exhaust the parameter box.","Held-out data did not influence selection or parameters. A positive result on these seeds alone is not evidence of a leaderboard rank."],"evaluation_source":"\"\"\"Volatility/flow overlay experiment; run inside the pinned checkout.\"\"\"\nimport json,hashlib,time,sys\nfrom pathlib import Path\nimport numpy as np\nimport amm_sim_rs as sim\nimport harness as h\n\nRS2=Path('../rs2_code.txt').read_text()\nassert hashlib.sha256(RS2.encode()).hexdigest()=='f24b6ca198b744c380842c3a17964a6dc21f311bb04984b26733afa3fee8eaf2'\n\ndef generate(base, p):\n \"\"\"Scale only the five specified fMid terms; c is in basis points.\n Constant multipliers avoid any additional state or initialization writes.\n Saturating subtraction prevents negative unsigned fees.\n The disabled overlay returns the original source exactly.\n \"\"\"\n a,b,c=map(float,p)\n assert -.5<=a<=3 and -.5<=b<=1 and -2<=c<=3\n if a==b==c==0: return base\n sa=int(round((1+a)*10**18)); sf=int(round((1-b)*10**18))\n old=''' uint256 fBase = BASE_FEE + wmul(SIGMA_COEF, sigmaHat) + wmul(LAMBDA_COEF, lambdaHat) + wmul(FLOW_SIZE_COEF, flowSize);\n uint256 fMid = fBase + wmul(TOX_COEF, toxSignal) + wmul(TOX_QUAD_COEF, wmul(toxSignal, toxSignal)) + wmul(ACT_COEF, actEma);\n fMid = fMid + wmul(SIGMA_TOX_COEF, wmul(sigmaHat, toxSignal));'''\n new=f''' uint256 fBase = BASE_FEE + wmul({sa}, wmul(SIGMA_COEF, sigmaHat)) + wmul({sf}, wmul(LAMBDA_COEF, lambdaHat)) + wmul({sf}, wmul(FLOW_SIZE_COEF, flowSize));\n uint256 fMid = fBase + wmul(TOX_COEF, toxSignal) + wmul(TOX_QUAD_COEF, wmul(toxSignal, toxSignal)) + wmul({sf}, wmul(ACT_COEF, actEma));\n fMid = fMid + wmul({sa}, wmul(SIGMA_TOX_COEF, wmul(sigmaHat, toxSignal)));'''\n offset=int(round(abs(c)*10**14))\n if c>0: new+=f'\\n fMid = fMid > {offset} ? fMid - {offset} : 0;'\n elif c<0: new+=f'\\n fMid += {offset};'\n assert base.count(old)==1\n return base.replace(old,new)\n\nERRORS=['oog','revert','other_halt','tx_error','bad_return']\ndef valid(r):\n return all(not any(x.get(k,0) for k in ERRORS) for x in r['raw_counters'])\ndef gas(r):\n rows=r['raw_counters']\n return {'max_ok':max((x['max_ok_gas'] for x in rows if x['role']=='Submission' and x['callback']=='afterSwap'),default=0),\n 'init_max_ok':max((x['max_ok_gas'] for x in rows if x['role']=='Submission' and x['callback']=='afterInitialize'),default=0),\n 'oog':sum(x.get('oog',0) for x in rows),'halts':sum(sum(x.get(k,0) for k in ERRORS) for x in rows)}\nclass Runner:\n def __init__(self):\n self.compiler=h.SolidityCompiler();self.cache={}\n v=self.compiler.compile(Path('contracts/src/VanillaStrategy.sol').read_text(),'VanillaStrategy')\n assert v.success,v.errors\n self.vanilla=v.bytecode\n def compile(self,source):\n digest=hashlib.sha256(source.encode()).hexdigest()\n if digest not in self.cache:\n compiled=self.compiler.compile(source);assert compiled.success,compiled.errors\n self.cache[digest]=compiled.bytecode\n return digest,self.cache[digest]\n def run(self,source,start,n,label,decomp=False):\n digest,code=self.compile(source);rows=[];chunks=[];t=time.monotonic()\n for first in range(start,start+n,16):\n count=min(16,start+n-first);sim.gas_stats_reset()\n batch=sim.run_batch(list(code),list(self.vanilla),h.configs(first,count),8)\n results=batch.results\n assert sorted(r.seed for r in results)==list(range(first,first+count))\n for r in results:\n row={'seed':r.seed,'edge':r.edges['submission']}\n if decomp:\n arb,retail=h.decomposition(r);row.update(arb=arb,retail=retail)\n rows.append(row)\n chunks.append({'raw':sim.gas_stats()});del results,batch\n print(label,first+count-start,'/',n,'elapsed',round(time.monotonic()-t),flush=True)\n return {'sha256':digest,'rows':sorted(rows,key=lambda x:x['seed']),'raw_counters':h.aggregate(chunks)}\n\ndef paired(a,b):\n ar={x['seed']:x for x in a['rows']};br={x['seed']:x for x in b['rows']};assert ar.keys()==br.keys()\n seeds=sorted(ar);d=np.array([ar[s]['edge']-br[s]['edge'] for s in seeds]);s=h.stats(d)\n return {'n':len(d),'mean_diff':s['mean'],'se':s['se'],'worst':[{'seed':seeds[i],'d':float(d[i])} for i in np.argsort(d)[:5]]}\n\ndef save(name,value):Path('scratch/'+name+'.json').write_text(json.dumps(value,allow_nan=False))\n\ndef search():\n import cma\n state_path=Path('scratch/search.json')\n if state_path.exists():\n old=json.loads(state_path.read_text());records=old['records']\n elapsed_before=old['seconds']+max(0.,time.time()-state_path.stat().st_mtime)\n resume_count=len(records)\n else:\n records=[];elapsed_before=0.;resume_count=0\n t=time.monotonic();budget=25*60;run=Runner()\n es=cma.CMAEvolutionStrategy([1.0,0.5,1.0],.65,{'seed':52,'bounds':[[-.5,-.5,-2],[3,1,3]],'popsize':4,'verbose':-9,'maxiter':6})\n index=0;generation=0\n def elapsed():return elapsed_before+time.monotonic()-t\n def checkpoint(stop=None):\n state={'records':records,'seconds':elapsed(),'cma_seed':52,'complete_generations':generation,'population':4,\n 'resumed_evaluations':resume_count,'original_population':7 if resume_count else 4}\n if stop:state['stop']=stop\n save('search',state)\n # Population was reduced from seven to four because of measured simulation\n # cost. Seed 52 generates exactly the same first four proposals either way;\n # any retained evaluations must match the reconstructed proposal bitwise.\n while generation<6 and elapsed()938000:checkpoint('seed budget');return\n if records and elapsed()+max(r['seconds'] for r in records[-4:])*1.1>budget:\n checkpoint('time budget');return\n p=[float(x) for x in proposal];source=generate(RS2,p);tc=time.monotonic()\n a=run.run(source,start,64,'search candidate');b=run.run(RS2,start,64,'search RS2')\n stats=paired(a,b);g=gas(a)\n good=valid(a) and valid(b) and g['max_ok']<235000 and g['init_max_ok']<245000\n score=stats['mean_diff'] if good else -1000.\n record={'params':{'a':p[0],'b':p[1],'c':p[2]},'n':64,'start':start,'mean_diff':stats['mean_diff'],'se':stats['se'],\n 'fitness':score,'gas':g,'rs2_gas':gas(b),'valid':good,'seconds':time.monotonic()-tc,'generation':generation}\n records.append(record);fitness.append(-score);index+=1;checkpoint()\n save('search_raw_'+str(len(records)),{'candidate':a,'rs2':b})\n print('EVALUATION',len(records),json.dumps(record),flush=True)\n es.tell(population,fitness);generation+=1;checkpoint()\n checkpoint('generation or time budget')\n\nif __name__=='__main__':search()\n","validation_source":"\"\"\"Recheck top three, freeze, and evaluate exactly once on reserved seeds.\"\"\"\nimport inspect,json,hashlib,time\nfrom pathlib import Path\nimport numpy as np\nimport experiment as e\nimport harness as h\nimport amm_sim_rs as sim\n\ndef main():\n search=json.loads(Path('scratch/search.json').read_text());records=search['records']\n assert len(records)>=3\n chosen=sorted((r for r in records if r['valid']),key=lambda r:r['fitness'],reverse=True)[:3]\n assert len(chosen)==3\n runner=e.Runner();base=runner.run(e.RS2,938000,256,'recheck RS2',True);e.save('recheck_rs2_raw',base)\n rechecks=[]\n for i,r in enumerate(chosen):\n p=r['params'];source=e.generate(e.RS2,[p['a'],p['b'],p['c']]);a=runner.run(source,938000,256,'recheck '+str(i),True)\n comparison=h.compare(a,base);g=e.gas(a);good=e.valid(a) and e.valid(base) and g['max_ok']<235000 and g['init_max_ok']<245000\n row={'params':p,'search_rank':i+1,'vs_rs2':comparison['paired'],'retail_edge_delta':comparison['retail_edge_delta'],'arb_edge_delta':comparison['arb_edge_delta'],'gas':g,'rs2_gas':e.gas(base),'valid':good}\n rechecks.append(row);e.save('recheck_'+str(i)+'_raw',a);e.save('recheck',rechecks);print('RECHECK',json.dumps(row),flush=True)\n winner=max((r for r in rechecks if r['valid']),key=lambda r:r['vs_rs2']['mean_diff'])\n p=winner['params'];source=e.generate(e.RS2,[p['a'],p['b'],p['c']]);digest=hashlib.sha256(source.encode()).hexdigest()\n freeze={'params':p,'sha256':digest,'selection':'Highest valid 256-seed recheck paired mean vs RS2, among top three search fitness values.','time_utc':time.strftime('%Y-%m-%dT%H:%M:%SZ',time.gmtime())}\n e.save('freeze',freeze);Path('scratch/Frozen.sol').write_text(source);print('FROZEN',json.dumps(freeze),flush=True)\n candidate=runner.run(source,939000,512,'heldout frozen',True);e.save('heldout_candidate_raw',candidate)\n rs2=runner.run(e.RS2,939000,512,'heldout RS2',True);e.save('heldout_rs2_raw',rs2)\n comparison=h.compare(candidate,rs2);e.save('heldout',{'vs_rs2':comparison['paired'],'retail_edge_delta':comparison['retail_edge_delta'],'arb_edge_delta':comparison['arb_edge_delta'],'reconciliation_max_abs':comparison['reconciliation_max_abs'],'gas':e.gas(candidate),'rs2_gas':e.gas(rs2),'valid':e.valid(candidate) and e.valid(rs2) and e.gas(candidate)['max_ok']<235000 and e.gas(candidate)['init_max_ok']<245000})\n parity(runner)\n\ndef parity(runner):\n off=e.generate(e.RS2,[0,0,0]);assert off==e.RS2\n da,ca=runner.compile(off);db,cb=runner.compile(e.RS2)\n chunks_a=[];chunks_b=[];rows=[]\n for start in range(939600,939632,8):\n sim.gas_stats_reset();a=sim.run_batch(list(ca),list(runner.vanilla),h.configs(start,8),8);chunks_a.append({'raw':sim.gas_stats()})\n sim.gas_stats_reset();b=sim.run_batch(list(cb),list(runner.vanilla),h.configs(start,8),8);chunks_b.append({'raw':sim.gas_stats()})\n aa={r.seed:r for r in a.results};bb={r.seed:r for r in b.results};assert aa.keys()==bb.keys()\n for seed in sorted(aa):\n x,y=aa[seed],bb[seed]\n same=(x.edges==y.edges and x.pnl==y.pnl and x.average_fees==y.average_fees and x.initial_reserves==y.initial_reserves)\n xs,ys=x.steps,y.steps;same=same and len(xs)==len(ys)\n same=same and all((v.fair_price,v.spot_prices,v.fees,v.pnls)==(w.fair_price,w.spot_prices,w.fees,w.pnls) for v,w in zip(xs,ys))\n rows.append({'seed':seed,'equal':same,'edge_diff':x.edges['submission']-y.edges['submission']})\n print('PARITY',start+8-939600,'/32',flush=True)\n ra={'raw_counters':h.aggregate(chunks_a)};rb={'raw_counters':h.aggregate(chunks_b)}\n e.save('parity',{'n':32,'start':939600,'end_inclusive':939631,'params':{'a':0,'b':0,'c':0},'source_equal':off==e.RS2,'bytecode_equal':ca==cb,'all_equal':all(r['equal'] for r in rows),'rows':rows,'gas':e.gas(ra),'rs2_gas':e.gas(rb),'valid':e.valid(ra) and e.valid(rb)})\n\nif __name__=='__main__':main()\n","harness_source":"\"\"\"Run from the pinned amm-challenge checkout, with the brief's environment active.\npython harness.py --start 5000000 --n 2000 --out measured.json candidate.sol STACK.sol\nDo not use confirmation seeds to choose or change a strategy.\n\"\"\"\nimport argparse,hashlib,json,math\nfrom pathlib import Path\nimport numpy as np\nimport amm_sim_rs as sim\nfrom amm_competition.evm.compiler import SolidityCompiler\n\n\ndef configs(start,n):\n configs=[]\n for seed in range(start,start+n):\n rng=np.random.default_rng(seed)\n size=rng.uniform(19.,21.)\n rate=rng.uniform(.6,1.)\n sigma=rng.uniform(.000882,.001008)\n configs.append(sim.SimulationConfig(n_steps=10000,initial_price=100.,\n initial_x=100.,initial_y=10000.,gbm_mu=0.,gbm_sigma=sigma,gbm_dt=1.,\n retail_arrival_rate=rate,retail_mean_size=size,retail_size_sigma=1.2,\n retail_buy_prob=.5,seed=seed))\n return configs\n\n\ndef decomposition(r,initial_fee=.0004):\n # Fees are outside reserves, so k stays fixed up to floating-point roundoff.\n # The arb acts before retail, using the preceding step's final spot and fees.\n steps=r.steps\n fair=np.array([s.fair_price for s in steps])\n spots=np.array([r.initial_fair_price]+[s.spot_prices['submission'] for s in steps[:-1]])\n bids=np.array([initial_fee]+[s.fees['submission'][0] for s in steps[:-1]])\n asks=np.array([initial_fee]+[s.fees['submission'][1] for s in steps[:-1]])\n x0,y0=r.initial_reserves['submission'];k=x0*y0\n x=np.sqrt(k/spots);y=np.sqrt(k*spots)\n ga=1-asks;gb=1-bids\n out=np.minimum(np.maximum(x-np.sqrt(k/(ga*fair)),0),.99*x)\n paid=(k/(x-out)-y)/ga\n buyprofit=np.where(out>0,np.maximum(out*fair-paid,0),0)\n gross=np.maximum((np.sqrt(k*gb/fair)-x)/gb,0)\n received=y-k/(x+gb*gross)\n sellprofit=np.where(gross>0,np.maximum(received-gross*fair,0),0)\n arb=-float(np.sum(np.where(spots$R/env.sh;. $R/env.sh\ncommand -v uv >/dev/null||{ curl -LsSf https://github.com/astral-sh/uv/releases/latest/download/uv-x86_64-unknown-linux-gnu.tar.gz|tar --no-same-owner -xz -C $R/tmp;cp $R/tmp/uv-*/uv $R/bin/;}\nW=amm_sim_rs-0.1.0.post1-cp310-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl;curl -LsSf https://github.com/gtmcknight/amm-sim/releases/download/sim-6b6921f8/$W -o $R/$W\necho \"aedb68280aca34c110968f00148387c95885207913fb2cf19a1ab4c5cfd6887a $R/$W\"|sha256sum -c -\nuv venv --python 3.12 .venv;uv pip install $R/$W numpy py-solc-x==2.1.0 pyrevm==0.3.7;uv pip install --no-deps -e .\npython -c \"import solcx;solcx.install_solc('0.8.24')\"\namm-match validate contracts/src/StarterStrategy.sol\n"}