{"item":"cont-b","blocked":null,"design_url":"https://api.imdnotdead.fun/artifacts/e3f159b9b1b2458001869784af1b18ea2ed13f1e46ee08249a5d3055c766a811","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\n    bool constant OVERLAY_ENABLED = true;\n    uint256 constant RADIUS = 1 * BPS;\n    int256 constant ERROR_MARGIN = 131072;\n    int256 constant MAX_SCORE = 1099511627;\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[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        (fastHat, uncertainty) = _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 flowSize = wmul(lambdaHat, sizeHat);\n        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\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        if (trade.reserveX>0) (bidFee,askFee)=_cont(bidFee,askFee,spot,fastHat,uncertainty,stepTradeCount,trade.reserveY,firstInStep);\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\n    // Public-observable, bounded two-head local rollout approximation.\n    // Coefficients: signed integer / 2**40. Features: signed integer / 1e6.\n    function _cont(uint256 bid, uint256 ask, uint256 spot, uint256 mu,\n        uint256 variance, uint256 count, uint256 reserveY, bool first)\n        internal pure returns (uint256, uint256) {\n        if (!OVERLAY_ENABLED || mu == 0 || reserveY == 0) return (bid,ask);\n        int256[11] memory p;\n        p[0]=1000000;\n        p[1]=(int256(spot*WAD/mu)-int256(WAD))/10000000000;\n        p[2]=int256(variance/10000000);\n        p[3]=int256(5000*1e24/reserveY);\n        p[4]=int256((count<4?count:4)*250000);\n        p[5]=int256(bid/10000000000);p[6]=int256(ask/10000000000);\n        if (p[1] < -2000000 || p[1]>2000000 || p[2]>2000000 || p[3]>2000000\n            || p[5]>2000000 || p[6]>2000000) return (bid,ask);\n        unchecked {\n            p[7]=p[1]*p[1]/1000000;p[8]=p[1]*p[2]/1000000;\n            p[9]=p[1]*p[3]/1000000;p[10]=p[1]*p[4]/1000000;\n        }\n        int256[5] memory h;\n        // Fixed-size MACs; support bounds above keep all products below int256.\n        unchecked {\nh[0]=((int256(231269)*p[0])+(int256(827266)*p[1])+(int256(-2962)*p[2])+(int256(-437053)*p[3])+(int256(31704)*p[4])+(int256(-89401)*p[5])+(int256(34324)*p[6])+(int256(42946)*p[7])+(int256(6041)*p[8])+(int256(-1427983)*p[9])+(int256(-2574)*p[10]))/1000000;\nh[1]=((int256(-219268)*p[0])+(int256(-622196)*p[1])+(int256(20945)*p[2])+(int256(447800)*p[3])+(int256(34426)*p[4])+(int256(3480)*p[5])+(int256(-58726)*p[6])+(int256(46866)*p[7])+(int256(18636)*p[8])+(int256(1087678)*p[9])+(int256(-44667)*p[10]))/1000000;\nh[2]=((int256(-28553)*p[0])+(int256(280582)*p[1])+(int256(4583)*p[2])+(int256(3356)*p[3])+(int256(-12289)*p[4])+(int256(38798)*p[5])+(int256(51631)*p[6])+(int256(-28638)*p[7])+(int256(17835)*p[8])+(int256(-570573)*p[9])+(int256(33983)*p[10]))/1000000;\nh[3]=((int256(76503)*p[0])+(int256(-158497)*p[1])+(int256(-2878)*p[2])+(int256(-151612)*p[3])+(int256(-1632)*p[4])+(int256(-11980)*p[5])+(int256(15631)*p[6])+(int256(505)*p[7])+(int256(16729)*p[8])+(int256(340280)*p[9])+(int256(-1915)*p[10]))/1000000;\nh[4]=((int256(18804)*p[0])+(int256(411012)*p[1])+(int256(3548)*p[2])+(int256(-84427)*p[3])+(int256(5627)*p[4])+(int256(61782)*p[5])+(int256(4347)*p[6])+(int256(-18475)*p[7])+(int256(4324)*p[8])+(int256(-860550)*p[9])+(int256(-10300)*p[10]))/1000000;\n        }\n        int256 best=ERROR_MARGIN; uint256 bb=bid;uint256 aa=ask;\n        for (uint256 i=1;i<9;++i) {\n            int256 db;int256 da;\n            if(i==1) db=1;\n            else if(i==2) db=-1;\n            else if(i==3) da=1;\n            else if(i==4) da=-1;\n            else if(i==5) {db=1;da=-1;}\n            else if(i==6) {db=-1;da=1;}\n            else if(i==7) {db=1;da=1;}\n            else {db=-1;da=-1;}\n            int256 tb=int256(bid)+db*int256(RADIUS);\n            int256 ta=int256(ask)+da*int256(RADIUS);\n            uint256 b=tb<0?0:(tb>int256(MAX_FEE)?MAX_FEE:uint256(tb));\n            uint256 a=ta<0?0:(ta>int256(MAX_FEE)?MAX_FEE:uint256(ta));\n            if(first) {\n                if(a>b && b>30*BPS)b=30*BPS;\n                else if(b>a && a>30*BPS)a=30*BPS;\n            }\n            if(b>a && a>36*BPS)a=36*BPS;\n            else if(a>b && b>36*BPS)b=36*BPS;\n            // Cap projection can flip the cheaper side. Reject large projected moves.\n            if(absDiff(b,bid)>4*BPS || absDiff(a,ask)>4*BPS)continue;\n            db=(int256(b)-int256(bid))*1000000/int256(2*BPS);\n            da=(int256(a)-int256(ask))*1000000/int256(2*BPS);\n            int256 q;\n            unchecked {\n                q=(h[0]*db+h[1]*da)/1000000\n                    +(h[2]*db*db+2*h[3]*db*da+h[4]*da*da)/2000000000000;\n            }\n            if(q>best && q<MAX_SCORE) {best=q;bb=b;aa=a;}\n        }\n        return (bb,aa);\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) {\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));\n            }\n            return (x.mu,x.v);\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.mu<lo?lo-x.mu:(x.mu>hi?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);\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=p<lo?lo-p:(p>hi?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":"3618c7886b7c24f867421f1dfa3055319d3994b796f944b32ea0f8aab5fa22e6","family":"A2 finite-band two-step continuation; two-head bounded fee-action polynomial over unchanged V10","params":{"name":"A2safe","sha256":"3618c7886b7c24f867421f1dfa3055319d3994b796f944b32ea0f8aab5fa22e6","beta":1,"shadow":false,"radius_bp":1,"enabled":true,"margin":131072,"baseline_sha256":"cd9bdb45ab0537ad25c4fd90ca8618898cef6386de3df65f192eaef65fbca245","coefficient_scale":1099511627776,"feature_scale":1000000,"head_order":["retail","finite_band_arb","linear_shadow_arb"],"derivative_order":["g_b","g_a","h_bb","h_ba","h_aa"],"features":["1","u","v","d","c","b","a","u*u","u*v","u*d","u*c"],"quantized_coefficients":[[[166989,1074149,-16548,-319698,4551,-4820,1426,-608,-29049,-2047977,-47293],[-144494,-645258,3556,285049,7181,-34007,33490,5040,18778,1268183,30979],[16908,193623,-146,-78741,-15086,51274,31231,-13453,27857,-444306,43207],[113311,-29427,-4188,-233326,-5976,3218,23487,-5330,4277,74366,33],[2202,290668,10307,-43789,-6736,46964,15307,-8195,14600,-592166,-23097]],[[64280,-246883,13586,-117355,27153,-84581,32898,43554,35090,619994,44719],[-74774,23062,17389,162751,27245,37487,-92216,41826,-142,-180505,-75646],[-45461,86959,4729,82097,2797,-12476,20400,-15185,-10022,-126267,-9224],[-36808,-129070,1310,81714,4344,-15198,-7856,5835,12452,265914,-1948],[16602,120344,-6759,-40638,12363,14818,-10960,-10280,-10276,-268384,12797]],[[-57124,-180504,217,112168,857,6985,-3792,-1450,7066,330204,8129],[-2601,34955,2062,6960,4254,-7292,-5119,1485,-2762,-50396,-3992],[26255,-72194,3665,-45334,6668,-7409,-21187,6872,-3767,137324,-9682],[3515,-19377,182,-8547,543,1631,171,-141,491,36658,897],[-19708,-89074,165,45526,-1151,-1753,-7667,656,-769,173131,-2193]]],"action_unit_bp":2,"max_fee_deviation_bp":4,"score_cap_normalized_Y":0.001,"score_margin_normalized_Y":1.1920928955078125e-07,"identity_wins_ties":true,"training":{"seed_range":[770000,773999],"rng":"numpy default_rng;synthetic screen histories, not Rust RNG parity","steps_per_seed":256,"states":4085,"ridge":0.01,"validation_rmse":[1.2247292948715667e-07,4.4737879992135353e-08,1.3625342021672745e-08],"validation_target_rms":[1.2463826463696646e-07,6.127970110332374e-08,1.3898191284518515e-08],"training_rows":26464,"validation_rows":6216,"elapsed":199.50010132789612},"compiler":{"solc":"0.8.24","viaIR":true,"optimizer_runs":200,"evmVersion":"paris"}},"parity":{"n":32,"max_abs_diff":0,"disabled_sha256":"f323e3ab48396a8f3676bb319588a6a37eba02244f1b4171d6d967a130b997d7","fields":["total_edge","reconstructed_arb","retail_residual"],"synthetic_slot_parity_callbacks":400},"screen":[{"name":"A2","sha256":"aea19b7a0bc77e9f2735e2ccd2d52876b09e0f453ebabe92380683fb8bb43071","n":256,"mean_diff":-0.23143033789835732,"se":0.02595417477847312,"worst":[{"seed":770251,"d":-1.4336489431691462},{"seed":770189,"d":-1.2250363140697118},{"seed":770011,"d":-1.2063581349128754},{"seed":770170,"d":-1.2045372542366977},{"seed":770150,"d":-1.1872940603052484}],"retail_edge_delta":-0.9760805415050426,"arb_edge_delta":0.744650203606685,"gas":{"max_ok":211016,"init_max_ok":220987,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0}},{"name":"Beta0","sha256":"9e499205bde13902c57d56d4c436c652e6752242ea77e2c2c10855ff16e41dd9","n":256,"mean_diff":-0.34252285816901473,"se":0.028577329388607645,"worst":[{"seed":770251,"d":-1.7942227014516448},{"seed":770184,"d":-1.5723666683477404},{"seed":770041,"d":-1.4154884018432767},{"seed":770090,"d":-1.3861143360003325},{"seed":770245,"d":-1.3772904125682999}],"retail_edge_delta":-0.8465299314034551,"arb_edge_delta":0.5040070732344398,"gas":{"max_ok":211022,"init_max_ok":220987,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0}},{"name":"A1","sha256":"f5db8cfbe6c73fb1b415a92472174b64c64196b3bc507cd26cf32c88d2cfa14f","n":256,"mean_diff":-0.33979291024751346,"se":0.028483043884152723,"worst":[{"seed":770251,"d":-1.6543040969554568},{"seed":770184,"d":-1.4984909800406285},{"seed":770041,"d":-1.3659682313520989},{"seed":770245,"d":-1.359917051030834},{"seed":770090,"d":-1.359770998286649}],"retail_edge_delta":-0.810166560311645,"arb_edge_delta":0.4703736500641282,"gas":{"max_ok":211019,"init_max_ok":220987,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0}},{"name":"A2r2","sha256":"6209bf80c491dfefeb9375fd71b4cba6b15075d5fa2f57fbe69334ff8b744dfa","n":256,"mean_diff":-0.6305461121553333,"se":0.0391128182981359,"worst":[{"seed":770038,"d":-2.7337262084527083},{"seed":770215,"d":-2.2501503225416855},{"seed":770251,"d":-2.2145216780108967},{"seed":770150,"d":-2.0408261076328245},{"seed":770241,"d":-1.880793845989615}],"retail_edge_delta":-2.0888393165256036,"arb_edge_delta":1.458293204370268,"gas":{"max_ok":212335,"init_max_ok":220987,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0}},{"name":"A2r4","sha256":"b6325d5c13d4d511ccb3f1cc7701018bf2686cf7d24d22ffbf958db080b90864","n":256,"mean_diff":-1.7402385632695234,"se":0.059414543323467114,"worst":[{"seed":770188,"d":-4.025469064904314},{"seed":770086,"d":-4.00585335898279},{"seed":770038,"d":-3.991079407129064},{"seed":770069,"d":-3.866957723388623},{"seed":770044,"d":-3.743762734737061}],"retail_edge_delta":-4.454068912635072,"arb_edge_delta":2.713830349365547,"gas":{"max_ok":210955,"init_max_ok":220987,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0}},{"name":"A2safe","sha256":"3618c7886b7c24f867421f1dfa3055319d3994b796f944b32ea0f8aab5fa22e6","n":256,"mean_diff":-0.006258957488572081,"se":0.003917569048994184,"worst":[{"seed":770153,"d":-0.3150045425348367},{"seed":770219,"d":-0.2990637585799618},{"seed":770017,"d":-0.24233789404752315},{"seed":770195,"d":-0.24023807000855868},{"seed":770089,"d":-0.16374537722066407}],"retail_edge_delta":-0.035768940006582595,"arb_edge_delta":0.02950998251800746,"gas":{"max_ok":210833,"init_max_ok":220987,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0}},{"name":"Beta0safe","sha256":"d565c2edf670d10ea89ea0f4d185f95f43664b7da706670bc3e630ac0fc3957f","n":256,"mean_diff":-0.00028167902857245686,"se":0.00022923904399122617,"worst":[{"seed":770252,"d":-0.028464618627594973},{"seed":770207,"d":-0.021085591086603017},{"seed":770111,"d":-0.020947888063233222},{"seed":770017,"d":-0.017424742635739676},{"seed":770209,"d":-0.012269268069417194}],"retail_edge_delta":-0.0002317609734143744,"arb_edge_delta":-4.9918055157568975e-05,"gas":{"max_ok":210839,"init_max_ok":220987,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0}}],"recheck":{"seeds":[774000,774255],"arms":[{"name":"A2safe","sha256":"3618c7886b7c24f867421f1dfa3055319d3994b796f944b32ea0f8aab5fa22e6","n":256,"mean_diff":0.0045123305290555304,"se":0.003710714282191342,"worst":[{"seed":774009,"d":-0.2389415800965935},{"seed":774203,"d":-0.22525769121870098},{"seed":774196,"d":-0.21757905145614131},{"seed":774162,"d":-0.18896498008939488},{"seed":774171,"d":-0.17596647453854075}],"retail_edge_delta":-0.02462918108403711,"arb_edge_delta":0.029141511613094,"gas":{"max_ok":210833,"init_max_ok":220987,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0}},{"name":"A2","sha256":"aea19b7a0bc77e9f2735e2ccd2d52876b09e0f453ebabe92380683fb8bb43071","n":256,"mean_diff":-0.2942523802211514,"se":0.03036161129855518,"worst":[{"seed":774174,"d":-1.7395965130342574},{"seed":774062,"d":-1.6431971827761913},{"seed":774223,"d":-1.4871327544450423},{"seed":774070,"d":-1.4258819281926662},{"seed":774078,"d":-1.1581498903738066}],"retail_edge_delta":-1.0460988321981533,"arb_edge_delta":0.7518464519770036,"gas":{"max_ok":211016,"init_max_ok":220987,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0}}]},"freeze":{"name":"A2safe","sha256":"3618c7886b7c24f867421f1dfa3055319d3994b796f944b32ea0f8aab5fa22e6","ablation":"Beta0safe","ablation_sha256":"d565c2edf670d10ea89ea0f4d185f95f43664b7da706670bc3e630ac0fc3957f","recheck_names":["A2safe","A2"],"screen_selection":"Highest paired screen mean among valid A2 arms; diagnostic controls ineligible.","recheck_selection":"Highest paired recheck mean of the top two eligible screen arms.","held_out_not_yet_used":true},"held_out":{"seeds":[775000,775511],"frozen":{"name":"A2safe","sha256":"3618c7886b7c24f867421f1dfa3055319d3994b796f944b32ea0f8aab5fa22e6","n":512,"mean_diff":-0.002863054135920473,"se":0.0031686271910556702,"worst":[{"seed":775219,"d":-0.9138974477900774},{"seed":775119,"d":-0.2919228833809484},{"seed":775014,"d":-0.24765571562323885},{"seed":775098,"d":-0.2439790141075946},{"seed":775478,"d":-0.22471462437636092}],"retail_edge_delta":-0.02747415093549499,"arb_edge_delta":0.02461109679957524,"gas":{"max_ok":212731,"init_max_ok":220987,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0}},"ablation":{"name":"Beta0safe","sha256":"d565c2edf670d10ea89ea0f4d185f95f43664b7da706670bc3e630ac0fc3957f","n":512,"mean_diff":-0.00688885822720553,"se":0.005719024027497811,"worst":[{"seed":775441,"d":-2.80267815842069},{"seed":775219,"d":-0.8447491141457704},{"seed":775472,"d":-0.018838985619311188},{"seed":775040,"d":-0.012817177658689616},{"seed":775005,"d":-0.010798332890090023}],"retail_edge_delta":-0.0012356910618926964,"arb_edge_delta":-0.0056531671653138535,"gas":{"max_ok":212737,"init_max_ok":220987,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0}},"baseline":{"name":"V10","sha256":"cd9bdb45ab0537ad25c4fd90ca8618898cef6386de3df65f192eaef65fbca245","n":512,"mean_diff":0.0,"se":0.0,"worst":[{"seed":775000,"d":0.0},{"seed":775001,"d":0.0},{"seed":775002,"d":0.0},{"seed":775003,"d":0.0},{"seed":775004,"d":0.0}],"retail_edge_delta":0.0,"arb_edge_delta":0.0,"gas":{"max_ok":194771,"init_max_ok":220981,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0}},"frozen_minus_ablation":{"n":512,"mean_diff":0.004025804091285057,"se":0.006098842180275574,"worst":[{"seed":775119,"d":-0.2919228833809484},{"seed":775014,"d":-0.24765571562323885},{"seed":775098,"d":-0.2439790141075946},{"seed":775478,"d":-0.22471462437636092},{"seed":775395,"d":-0.1712653170239946}]}},"gas":{"max_ok":212731,"init_max_ok":220987,"oog":0},"falsifiers_run":{"CH_calibration":{"n":1000,"mean":525.5258821780834,"expected":525.5258821780834,"absolute_error":0.0,"sha256":"6dd68f77a70900319460215374143dbd5d924198450a46d9f5f91f6b1e3d35c3","oog":0},"static_design_assertions":true,"static_validation":[{"name":"Disabled","valid":true,"errors":[]},{"name":"A2","valid":true,"errors":[]},{"name":"Beta0","valid":true,"errors":[]},{"name":"A1","valid":true,"errors":[]},{"name":"A2r2","valid":true,"errors":[]},{"name":"A2r4","valid":true,"errors":[]},{"name":"A2safe","valid":true,"errors":[]},{"name":"Beta0r2","valid":true,"errors":[]},{"name":"Beta0r4","valid":true,"errors":[]},{"name":"Beta0safe","valid":true,"errors":[]}],"integer_runtime_and_slot_checks":[{"name":"Disabled","callbacks":400,"synthetic_pyrevm_max_gas":142351,"changed":0,"nonfee_slots_equal":true,"integer_prediction_equal":true,"disabled_max_abs_slot_diff":0},{"name":"A2","callbacks":400,"synthetic_pyrevm_max_gas":160504,"changed":284,"nonfee_slots_equal":true,"integer_prediction_equal":true,"disabled_max_abs_slot_diff":0},{"name":"Beta0","callbacks":400,"synthetic_pyrevm_max_gas":160510,"changed":283,"nonfee_slots_equal":true,"integer_prediction_equal":true,"disabled_max_abs_slot_diff":0},{"name":"A1","callbacks":400,"synthetic_pyrevm_max_gas":160507,"changed":283,"nonfee_slots_equal":true,"integer_prediction_equal":true,"disabled_max_abs_slot_diff":0},{"name":"A2r2","callbacks":400,"synthetic_pyrevm_max_gas":160504,"changed":283,"nonfee_slots_equal":true,"integer_prediction_equal":true,"disabled_max_abs_slot_diff":0},{"name":"A2r4","callbacks":400,"synthetic_pyrevm_max_gas":160443,"changed":283,"nonfee_slots_equal":true,"integer_prediction_equal":true,"disabled_max_abs_slot_diff":0},{"name":"A2safe","callbacks":400,"synthetic_pyrevm_max_gas":160321,"changed":20,"nonfee_slots_equal":true,"integer_prediction_equal":true,"disabled_max_abs_slot_diff":0},{"name":"Beta0r2","callbacks":400,"synthetic_pyrevm_max_gas":160510,"changed":284,"nonfee_slots_equal":true,"integer_prediction_equal":true,"disabled_max_abs_slot_diff":0},{"name":"Beta0r4","callbacks":400,"synthetic_pyrevm_max_gas":160510,"changed":284,"nonfee_slots_equal":true,"integer_prediction_equal":true,"disabled_max_abs_slot_diff":0},{"name":"Beta0safe","callbacks":400,"synthetic_pyrevm_max_gas":160327,"changed":0,"nonfee_slots_equal":true,"integer_prediction_equal":true,"disabled_max_abs_slot_diff":0}],"zero_retail_reconstruction":{"n":14,"max_abs_residual":8.705536291842009e-12},"quadrature_and_mediation":{"n_public_states":32,"domain":"screen seeds only, first 32 eligible synthetic callbacks after burn-in","radii_bp":2,"quadrature_9_vs_33_max_abs_action_delta":1.958579558169679e-05,"quadrature_rmse":7.058437125859434e-06,"selected_mean":{"retail":2.989722656407054e-05,"arb":0.00047121443101646814,"mediation":-3.196558360913406e-05,"carry":0.0005031800146256022,"predicted":0.0005273247005460878,"actual_total":0.0005011116575805387},"selected_positive_fraction":0.875,"retail_branches":10,"mediation_reconciles":true,"limitations":"No certified normal-tail error bound, model sensitivity or conditional-mean confidence interval; Monte Carlo latent-state diagnostic only."},"screen_only_fit_validation":{"validation_states":777,"validation_seed_clusters":522,"selected_mean_delta_Y":0.000558929887754057,"selected_retail_mean_delta_Y":0.00022578123290359432,"selected_arb_mean_delta_Y":0.00033314865485046266,"selected_positive_fraction":0.7966537966537967,"selected_nonidentity_fraction":1.0,"oracle_mean_upper_bound_delta_Y":0.0007695702804397446,"predicted_mean_delta_Y":0.0005081864460058114,"equal_weight_seed_cluster_mean_delta_Y":0.0005420158788013399,"equal_weight_seed_cluster_se":3.8249127462989754e-05,"coefficient_quantization_max_abs_delta_normalized_Y":3.531934568293946e-12,"scope":"Screen-only model validation, radius2bp; one-step latent rollout targets, not market performance. Correlated callbacks are clustered by seed; oracle sees latent offline future and is unavailable in deployed code."},"screen_A2_minus_beta0":{"name":"A2","sha256":"aea19b7a0bc77e9f2735e2ccd2d52876b09e0f453ebabe92380683fb8bb43071","n":256,"mean_diff":0.11109252027065741,"se":0.023214402924755594,"worst":[{"seed":770118,"d":-1.2403278193529559},{"seed":770172,"d":-1.2392594902380552},{"seed":770240,"d":-1.2024750499458605},{"seed":770028,"d":-1.0007762252762404},{"seed":770056,"d":-0.7877195586285097}],"retail_edge_delta":-0.12955061010158753,"arb_edge_delta":0.24064313037224516,"gas":{"max_ok":211016,"init_max_ok":220987,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0}},"screen_A2_minus_A1":{"name":"A2","sha256":"aea19b7a0bc77e9f2735e2ccd2d52876b09e0f453ebabe92380683fb8bb43071","n":256,"mean_diff":0.10836257234915614,"se":0.023558099526222547,"worst":[{"seed":770240,"d":-1.274263703311476},{"seed":770118,"d":-1.248583048538535},{"seed":770056,"d":-0.9845624033331433},{"seed":770038,"d":-0.8068299904992955},{"seed":770172,"d":-0.7686075256863205}],"retail_edge_delta":-0.16591398119339762,"arb_edge_delta":0.27427655354255687,"gas":{"max_ok":211016,"init_max_ok":220987,"oog":0,"revert":0,"other_halt":0,"tx_error":0,"bad_return":0}},"controls":["beta=0 on identical projected action set and radius/margin","A1 linear-shadow screen diagnostic","disabled exact V10 parity"],"not_run":["formal conditional-belief sensitivity bounds","certified shock/size-tail bounds","full-sequence versus aggregate signed-notional ablation","frequency-matched random-action control"]},"offline_source":{"language":"Python 3.12","source":"\"\"\"Screen-only empirical latent rollouts, exact V10 EVM callbacks.\nSynthetic RNG uses assigned screen seeds; not a claim of Rust RNG parity.\nConditional expectation is distilled by regression on public features only.\n\"\"\"\nimport json,math,time,hashlib\nfrom pathlib import Path\nimport numpy as np\nfrom amm_competition.evm.compiler import SolidityCompiler\nfrom amm_competition.evm.executor import EVMStrategyExecutor\nW=10**18\nOFF=np.array([[0,0],[1,0],[-1,0],[0,1],[0,-1],[1,-1],[-1,1],[1,1],[-1,-1]],float)\n\ndef project(b,a,first):\n b=max(0,min(.1,b));a=max(0,min(.1,a))\n if first:\n  if a>b and b>.003:b=.003\n  elif b>a and a>.003:a=.003\n if b>a and a>.0036:a=.0036\n elif a>b and b>.0036:b=.0036\n return b,a\n\ndef features(pool,slots):\n x,y,b,a=pool;mu=slots[14]/W;var=slots[13]/W\n if x<=0 or y<=0 or mu<=0:return None\n u=(y/x/mu-1)/.01;v=var/1e-5;d=(20/y)/.004;c=min(slots[10],4)/4\n b=b/.01;a=a/.01\n z=np.array([1,u,v,d,c,b,a,u*u,u*v,u*d,u*c])\n if abs(u)>2 or not 0<=v<=2 or d>2 or max(b,a)>2 or np.max(np.abs(z))>4:return None\n return z\n\nclass Adapter:\n def __init__(self,bytecode):\n  self.e=EVMStrategyExecutor(bytecode);self.addr=self.e.deployed_address\n def load(self,slots):\n  for i,v in enumerate(slots): self.e.evm.insert_account_storage(self.addr,i,int(v))\n def slots(self):return [self.e.evm.storage(self.addr,i) for i in range(15)]\n def init(self):\n  self.load([0]*15)\n  data=bytes.fromhex('837aef47')+(100*W).to_bytes(32,'big')+(10000*W).to_bytes(32,'big')\n  self.e.evm.message_call(caller=self.e.CALLER_ADDRESS,to=self.addr,calldata=data,gas=250000)\n def call(self,info,ts):\n  buy,ax,ay,x,y=info\n  vals=[int(buy),int(ax*W),int(ay*W),int(ts),int(x*W),int(y*W)]\n  data=bytes.fromhex('c2babb57')+b''.join(z.to_bytes(32,'big') for z in vals)\n  r=self.e.evm.message_call(caller=self.e.CALLER_ADDRESS,to=self.addr,calldata=data,gas=250000)\n  assert len(r)==64\n  return int.from_bytes(r[:32],'big')/W,int.from_bytes(r[32:],'big')/W\n\ndef fill(a,t,buy,p):\n x,y,fb,fa=a;k=x*y\n if buy:\n  yy=y+(1-fa)*t;xx=k/yy;q=x-xx;e=t-p*q;info=(False,q,t,xx,yy)\n else:\n  xx=x+(1-fb)*t;yy=k/xx;q=y-yy;e=p*t-q;info=(True,t,q,xx,yy)\n return (xx,yy,fb,fa),e,info\n\ndef split(a,b,T,buy):\n g=1-a[3 if buy else 2];h=1-b[3 if buy else 2];r=math.sqrt(a[0]*a[1]*g/(b[0]*b[1]*h))\n A,C=(a[1],b[1]) if buy else (a[0],b[0])\n return max(0,min(T,(r*(C+h*T)-A)/(g+r*h)))\n\ndef arb(a,p):\n x,y,b,f=a;k=x*y;s=y/x\n if s<p:\n  g=1-f;q=min(.99*x,max(0,x-math.sqrt(k/(g*p))));t=(k/(x-q)-y)/g\n  if q>0 and p*q>t:return fill(a,t,True,p)\n else:\n  g=1-b;q=max(0,(math.sqrt(k*g/p)-x)/g);v=y-k/(x+g*q)\n  if q>0 and v>p*q:return fill(a,q,False,p)\n return a,0,None\n\ndef retail(a,b,p,S,buy,adapter,ts):\n T=S if buy else S/p;t=split(a,b,T,buy);e=0;info=None\n if t>1e-4:\n  a,e,info=fill(a,t,buy,p);fees=adapter.call(info,ts);a=(*a[:2],*fees)\n if T-t>1e-4:b,_,_=fill(b,T-t,buy,p)\n return a,b,e,info\n\ndef terminal(a,p,sigma):\n # Gaussian quadrature integrates banded next-arb value; fixed current p per rollout.\n return sum(w*arb(a,p*math.exp(-sigma*sigma/2+sigma*z))[1] for z,w in SHOCK)\n\nZH,WH=np.polynomial.hermite.hermgauss(9);SHOCK=list(zip(ZH*math.sqrt(2),WH/math.sqrt(math.pi)))\n\ndef rollout(a,b,p,orders,ts,slots,adapter,sigma,pending=False):\n adapter.load(slots);adapter.e.evm.insert_account_storage(adapter.addr,0,int(a[2]*W));adapter.e.evm.insert_account_storage(adapter.addr,1,int(a[3]*W))\n if pending:b,_,_=arb(b,p)\n R=0\n for S,buy in orders:\n  a,b,e,_=retail(a,b,p,S,buy,adapter,ts);R+=e\n A=terminal(a,p,sigma);u=math.log(a[1]/a[0]/p)\n return np.array([R,A,u])\n\ndef targets(a,b,p,orders,ts,slots,adapter,sigma,pending,first):\n # Candidate carried until next actual own execution; all later callbacks are exact V10.\n rad=.0002;baseline=rollout(a,b,p,orders,ts,slots,adapter,sigma,pending)\n vals=[];acts=[]\n for db,da in OFF[1:]:\n  f=project(a[2]+rad*db,a[3]+rad*da,first);an=(*a[:2],*f)\n  vals.append(rollout(an,b,p,orders,ts,slots,adapter,sigma,pending)-baseline)\n  acts.append((np.array(f)-a[2:])/rad)\n vals=np.array(vals);acts=np.array(acts)\n B=np.column_stack([acts[:,0],acts[:,1],.5*acts[:,0]**2,acts[:,0]*acts[:,1],.5*acts[:,1]**2])\n # A1 fixes terminal carried fees and linearizes current spot. G_u is a fixed-fee derivative.\n h=1e-5;x,y,fb,fa=a\n ap=(x*math.exp(-h/2),y*math.exp(h/2),fb,fa);am=(x*math.exp(h/2),y*math.exp(-h/2),fb,fa)\n gu=(terminal(ap,p,sigma)-terminal(am,p,sigma))/(2*h)\n Y=np.column_stack([vals[:,0]/y,vals[:,1]/y,gu*vals[:,2]/y])\n return B,Y\n\ndef main():\n compiler=SolidityCompiler();c=compiler.compile(Path('scratch/V10.sol').read_text());assert c.success,c.errors\n live=Adapter(c.bytecode);branch=Adapter(c.bytecode)\n X=[];Y=[];meta=[];t0=time.time()\n # Entire allowed 4000-seed screen domain; 256 steps, sample all callbacks at one independently selected step per seed.\n for seed in range(770000,774000):\n  rng=np.random.default_rng(seed);M=rng.uniform(19,21);lam=rng.uniform(.6,1);sigma=rng.uniform(.000882,.001008)\n  rr=np.random.default_rng(seed+1);pp=np.random.default_rng(seed)\n  sample_step=int(rng.integers(128,256));unused=0\n  live.init();a=(100.,10000.,.0004,.0004);b=(100.,10000.,.003,.003);p=100.;count=0\n  for ts in range(256):\n   p*=math.exp(-sigma*sigma/2+sigma*pp.normal());N=rr.poisson(lam)\n   orders=[(float(rr.lognormal(math.log(M)-1.2**2/2,1.2)),bool(rr.random()<.5)) for _ in range(N)]\n   pre=live.slots();first=(pre[2]&((1<<64)-1))<ts or pre[10]==0\n   aa,_,info=arb(a,p)\n   if info:\n    fees=live.call(info,ts);a=(*aa[:2],*fees)\n    if ts==sample_step:\n     slots=live.slots();z=features(a,slots)\n     if z is not None:\n      B,T=targets(a,b,p,orders,ts,slots,branch,sigma,True,first)\n      for act,y in zip(B,T):X.append(np.outer(act,z).ravel());Y.append(y)\n      meta.append([seed,ts,0]);count+=1\n   b,_,_=arb(b,p)\n   for j,(S,buy) in enumerate(orders):\n    pre=live.slots();first=(pre[2]&((1<<64)-1))<ts or pre[10]==0\n    a,b,_,info=retail(a,b,p,S,buy,live,ts)\n    if info and ts==sample_step:\n     slots=live.slots();z=features(a,slots)\n     if z is not None:\n      B,T=targets(a,b,p,orders[j+1:],ts,slots,branch,sigma,False,first)\n      for act,y in zip(B,T):X.append(np.outer(act,z).ravel());Y.append(y)\n      meta.append([seed,ts,j+1]);count+=1\n  if (seed+1)%100==0: print(seed+1,len(meta),time.time()-t0,flush=True)\n X=np.array(X);Y=np.array(Y)\n np.savez_compressed('scratch/targets.npz',X=X,Y=Y,meta=meta)\n # Fit all 3 heads with common ridge; disjoint seed validation below.\n train=np.array([m[0]%5!=0 for m in meta]).repeat(8)\n ridge=.01;C=np.linalg.solve(X[train].T@X[train]+ridge*np.eye(55),X[train].T@Y[train])\n pred=X[~train]@C;err=pred-Y[~train]\n out={'seed_range':[770000,773999],'rng':'numpy default_rng;synthetic screen histories, not Rust RNG parity','steps_per_seed':256,'states':len(meta),'ridge':ridge,'coefficient_scale':2**40,'coefficients':C.T.reshape(3,5,11).tolist(),'validation_rmse':np.sqrt(np.mean(err**2,axis=0)).tolist(),'validation_target_rms':np.sqrt(np.mean(Y[~train]**2,axis=0)).tolist(),'training_rows':int(train.sum()),'validation_rows':int((~train).sum()),'elapsed':time.time()-t0}\n Path('scratch/fit.json').write_text(json.dumps(out));print(json.dumps(out),flush=True)\nif __name__=='__main__':main()\n","generator_source":"import json,hashlib\nfrom pathlib import Path\nimport numpy as np\nsrc=Path('scratch/V10.sol').read_text()\nfit=json.loads(Path('scratch/fit.json').read_text())\nC=np.rint(np.array(fit['coefficients'])*2**40).astype(np.int64)\nassert abs(C).max()<2**31\nbody='''\n    // Public-observable, bounded two-head local rollout approximation.\n    // Coefficients: signed integer / 2**40. Features: signed integer / 1e6.\n    function _cont(uint256 bid, uint256 ask, uint256 spot, uint256 mu,\n        uint256 variance, uint256 count, uint256 reserveY, bool first)\n        internal pure returns (uint256, uint256) {\n        if (!OVERLAY_ENABLED || mu == 0 || reserveY == 0) return (bid,ask);\n        int256[11] memory p;\n        p[0]=1000000;\n        p[1]=(int256(spot*WAD/mu)-int256(WAD))/10000000000;\n        p[2]=int256(variance/10000000);\n        p[3]=int256(5000*1e24/reserveY);\n        p[4]=int256((count<4?count:4)*250000);\n        p[5]=int256(bid/10000000000);p[6]=int256(ask/10000000000);\n        if (p[1] < -2000000 || p[1]>2000000 || p[2]>2000000 || p[3]>2000000\n            || p[5]>2000000 || p[6]>2000000) return (bid,ask);\n        unchecked {\n            p[7]=p[1]*p[1]/1000000;p[8]=p[1]*p[2]/1000000;\n            p[9]=p[1]*p[3]/1000000;p[10]=p[1]*p[4]/1000000;\n        }\n        int256[5] memory h;\n        // Fixed-size MACs; support bounds above keep all products below int256.\n        unchecked {\nASSEMBLY\n        }\n        int256 best=ERROR_MARGIN; uint256 bb=bid;uint256 aa=ask;\n        for (uint256 i=1;i<9;++i) {\n            int256 db;int256 da;\n            if(i==1) db=1;\n            else if(i==2) db=-1;\n            else if(i==3) da=1;\n            else if(i==4) da=-1;\n            else if(i==5) {db=1;da=-1;}\n            else if(i==6) {db=-1;da=1;}\n            else if(i==7) {db=1;da=1;}\n            else {db=-1;da=-1;}\n            int256 tb=int256(bid)+db*int256(RADIUS);\n            int256 ta=int256(ask)+da*int256(RADIUS);\n            uint256 b=tb<0?0:(tb>int256(MAX_FEE)?MAX_FEE:uint256(tb));\n            uint256 a=ta<0?0:(ta>int256(MAX_FEE)?MAX_FEE:uint256(ta));\n            if(first) {\n                if(a>b && b>30*BPS)b=30*BPS;\n                else if(b>a && a>30*BPS)a=30*BPS;\n            }\n            if(b>a && a>36*BPS)a=36*BPS;\n            else if(a>b && b>36*BPS)b=36*BPS;\n            // Cap projection can flip the cheaper side. Reject large projected moves.\n            if(absDiff(b,bid)>4*BPS || absDiff(a,ask)>4*BPS)continue;\n            db=(int256(b)-int256(bid))*1000000/int256(2*BPS);\n            da=(int256(a)-int256(ask))*1000000/int256(2*BPS);\n            int256 q;\n            unchecked {\n                q=(h[0]*db+h[1]*da)/1000000\n                    +(h[2]*db*db+2*h[3]*db*da+h[4]*da*da)/2000000000000;\n            }\n            if(q>best && q<MAX_SCORE) {best=q;bb=b;aa=a;}\n        }\n        return (bb,aa);\n    }\n'''\n# h = retail + beta continuation; fixed integer arithmetic makes deployed predictions reproducible.\ndef gen(name,beta=1,shadow=False,radius=1,enabled=True,margin=0):\n D=C[0]+(C[2] if shadow else C[1])*beta\n lines=[]\n for j,row in enumerate(D):\n  terms=[f'(int256({int(c)})*p[{i}])' for i,c in enumerate(row) if c]\n  lines.append(f'h[{j}]=('+ '+'.join(terms)+')/1000000;')\n constants=f'\\n    bool constant OVERLAY_ENABLED = {str(enabled).lower()};\\n    uint256 constant RADIUS = {radius} * BPS;\\n    int256 constant ERROR_MARGIN = {margin};\\n    int256 constant MAX_SCORE = 1099511627;\\n'\n out=src.replace('    uint256 constant ELAPSED_CAP',constants+'    uint256 constant ELAPSED_CAP')\n out=out.replace('        slots[0] = bidFee; slots[1] = askFee; slots[2]', '        if (trade.reserveX>0) (bidFee,askFee)=_cont(bidFee,askFee,spot,fastHat,uncertainty,stepTradeCount,trade.reserveY,firstInStep);\\n        slots[0] = bidFee; slots[1] = askFee; slots[2]')\n out=out.replace('    struct PosteriorInput',body.replace('ASSEMBLY','\\n'.join(lines))+'\\n    struct PosteriorInput')\n Path('scratch/'+name+'.sol').write_text(out)\n return {'name':name,'sha256':hashlib.sha256(out.encode()).hexdigest(),'beta':beta,'shadow':shadow,'radius_bp':radius,'enabled':enabled,'margin':margin}\nvariants=[gen('Disabled',enabled=False),gen('A2'),gen('Beta0',beta=0),gen('A1',shadow=True),gen('A2r2',radius=2),gen('A2r4',radius=4),gen('A2safe',margin=131072),gen('Beta0r2',beta=0,radius=2),gen('Beta0r4',beta=0,radius=4),gen('Beta0safe',beta=0,margin=131072)]\nPath('scratch/variants.json').write_text(json.dumps(variants));print(json.dumps(variants))\n","evaluation_source":"import json,time,sys,hashlib\nfrom pathlib import Path\nimport numpy as np\nfrom harness import configs,decomposition,aggregate,compare\nimport amm_sim_rs as sim\nfrom amm_competition.evm.compiler import SolidityCompiler\n\ndef compile_cached(name):\n source=Path('scratch/'+name+'.sol').read_text();h=hashlib.sha256(source.encode()).hexdigest();p=Path('scratch/compiled-'+h+'.json')\n if p.exists():return bytes.fromhex(json.loads(p.read_text())['bytecode'])\n c=SolidityCompiler().compile(source);assert c.success,c.errors\n p.write_text(json.dumps({'bytecode':c.bytecode.hex(),'runtime_bytes':len(c.deployed_bytecode)}))\n return c.bytecode\n\ndef gas(out):\n rows=out['raw_counters'];own=[r for r in rows if r['role']=='Submission']\n return {'max_ok':max((r['max_ok_gas'] for r in own if r['callback']=='afterSwap'),default=0),'init_max_ok':max((r['max_ok_gas'] for r in own if r['callback']=='afterInitialize'),default=0),**{k:sum(r.get(k,0) for r in rows) for k in ['oog','revert','other_halt','tx_error','bad_return']}}\n\ndef run(name,start,n):\n source=Path('scratch/'+name+'.sol').read_text();h=hashlib.sha256(source.encode()).hexdigest();path=Path(f'scratch/run-{name}-{start}-{n}.json')\n if path.exists():\n  old=json.loads(path.read_text())\n  if old['sha256']==h:return old\n a=compile_cached(name);b=SolidityCompiler().compile(Path('contracts/src/VanillaStrategy.sol').read_text(),'VanillaStrategy');assert b.success\n rows=[];chunks=[];t=time.time()\n for first in range(start,start+n,16):\n  count=min(16,start+n-first);sim.gas_stats_reset()\n  result=sim.run_batch(list(a),list(b.bytecode),configs(first,count),8)\n  assert sorted(r.seed for r in result.results)==list(range(first,first+count))\n  for r in result.results:\n   arb,retail=decomposition(r);rows.append({'seed':r.seed,'edge':r.edges['submission'],'arb':arb,'retail':retail})\n  chunks.append({'start':first,'raw':sim.gas_stats()});del result\n  print(name,first+count-start,'/',n,'seconds',time.time()-t,flush=True)\n out={'name':name,'sha256':h,'rows':rows,'raw_counters':aggregate(chunks),'seconds':time.time()-t}\n out['gas']=gas(out);path.write_text(json.dumps(out));print(name,out['gas'],flush=True)\n return out\nif __name__=='__main__':\n start,n=map(int,sys.argv[1:3])\n for name in sys.argv[3:]:run(name,start,n)\n","numeric_validation_source_sha256":"46d98cea9001f15015d82e3cdba13d1f937f59ec0586d196ec8906b65c1c90b7","source_sha256":"2403b8027c9ddb34a6c8378103fe90b3755e7d7850bb22bbb07afbe603cd84f9","dependencies":"Pinned checkout 6b6921f8d463314aa7c96234e1be25a25245f704; brief setup wheel checksum verified; numpy 2.5.4, py-solc-x 2.1.0, pyrevm 0.3.7, solc 0.8.24. Save V10 artifact.code to scratch/V10.sol and artifact.harness_source to scratch/harness.py. Runtime Solidity imports only the challenge base and TradeInfo interface. No runtime fitting, external calls, new storage, quadrature, recursion or dynamic inference.","V10_source_url":"https://api.imdnotdead.fun/artifacts/33f54e81f3372088e9eced52c0174f310ac348af98ef5727b73785c088679194","harness_source_url":"https://api.imdnotdead.fun/artifacts/33f54e81f3372088e9eced52c0174f310ac348af98ef5727b73785c088679194"},"notes":["Local simulations only; no board claim. No seeds >=5000000 were used. No STACK confirmation was authorized for this item.","Every measured arm ran alone against VanillaStrategy in a separate market, run_batch(...,8), 10000 steps, all seeds retained. Config draws: size, rate, sigma, in that order from default_rng(seed); Rust engine seeds price=seed, retail=seed+1. SE uses sample standard deviation divided by sqrt(n).","Screen is 770000..770255, a 256-seed subset of the allowed 770000..773999 screen domain. Offline fitting uses only 770000..773999. Re-check and held-out seeds were excluded from fitting.","Training is a synthetic forward model with exact compiled V10 callbacks and NumPy RNGs, not a replay of Rust random streams. All callbacks at one independently selected timestamp 128..255 per screen seed are sampled with their natural phase/count weights, including later own prints; zero-own-route censoring and pending normalizer opening are simulated. Hidden current price, phase, opponent reserves and actual residual orders enter targets only.","Regression on 11 bounded public features estimates conditional target means; it is not an identified full-history joint belief. Short training histories have less depth/price dispersion than full 10000-step markets. Fit error is large relative to target variation; quadrature tails are not certified. The score margin is a heuristic, not a proved confidence bound.","Candidate acts only after the triggering fill. It is held until the next own execution, then exact V10 resumes on perturbed history. No terminal inventory mark, fee double-counting or triggering-trade repricing is included. All original V10 estimators, fee formulas, tail compression, initialization and caps are retained.","Runtime embeds retail + beta*continuation coefficient sums (linearity), avoiding duplicate MACs. The two heads are fitted and quantized separately. A1 substitutes the fixed-carry-fee current-state linear shadow gradient times terminal log-spot displacement; it drops finite-band/curvature and direct carry-fee terms, but routed-volume response can remain nonlinear in fee actions.","Only A2 arms are eligible for freezing; beta-zero and A1 are diagnostic controls. Rank eligible valid A2 arms by paired screen mean, re-check top two, freeze highest paired re-check mean, without held-out tuning. Held-out execution starts only after the freeze manifest is saved.","Arbitrage is reconstructed from each step opening reserves/previous final fees and fair price; retail is total edge minus reconstructed arbitrage. The zero-retail control validates this reconstruction. Raw gas_stats counters were collected separately for every market arm/chunk; all halt categories are checked.","The offline mediation diagnostic suggests fee carry/protection rather than positive displacement alpha in its 32 sampled states; it is not a benchmark gain or causal attribution for the full held-out market.","Frozen overlay has no positive held-out gain."]}