{ "approach": "Test the supplied post-arbitrage fee-pair hypothesis as one delta on verified CH. Detect first-in-step ret > 2*pre-update sigmaHat using CH pImplied and pHat; retain timestamp/direction in slots 11-12; impose scaled protect-floor/attract-cap after CH fees with linear interpolation. Compare each strategy separately against the fixed-30-bps normalizer with matched exogenous seeds. The fee table is a requester-supplied hypothesis, not a proven optimum.", "tried": [ { "n": 2000, "mean_diff": -189.62702361821735, "se": 0.9617646891220847, "worst": [ { "seed": 10696, "diff": -481.841746459761, "candidate_edge": 428.3546721808282, "reference_edge": 910.1964186405892 }, { "seed": 11816, "diff": -400.1281499643594, "candidate_edge": 396.28576687421446, "reference_edge": 796.4139168385739 }, { "seed": 11144, "diff": -399.1665041174026, "candidate_edge": 410.67910168340586, "reference_edge": 809.8456058008085 }, { "seed": 10879, "diff": -385.57799348239, "candidate_edge": 434.5962937653223, "reference_edge": 820.1742872477123 }, { "seed": 10241, "diff": -369.2726315824129, "candidate_edge": 355.3274085994904, "reference_edge": 724.6000401819033 } ], "variant": "s=0.6", "seeds": "10000..11999", "code_sha256": "2ab962b79cdd67ffcfa13996c9e72ec4b95906812d6a0ed15f7daf682b104f71", "mean_edge": 333.5945392111675 }, { "n": 2000, "mean_diff": -175.6687987019238, "se": 0.9378108820911414, "worst": [ { "seed": 10696, "diff": -462.64948459022133, "candidate_edge": 447.54693405036784, "reference_edge": 910.1964186405892 }, { "seed": 11816, "diff": -387.9090196300642, "candidate_edge": 408.50489720850965, "reference_edge": 796.4139168385739 }, { "seed": 11144, "diff": -384.43938675488954, "candidate_edge": 425.40621904591893, "reference_edge": 809.8456058008085 }, { "seed": 10241, "diff": -356.12959339079987, "candidate_edge": 368.4704467911034, "reference_edge": 724.6000401819033 }, { "seed": 10879, "diff": -344.16434121653896, "candidate_edge": 476.00994603117334, "reference_edge": 820.1742872477123 } ], "variant": "s=0.8", "seeds": "10000..11999", "code_sha256": "cb952eb6c7a8ef722ff944c7969adfba3c5f4ee8d8150adcad9024c9408e7612", "mean_edge": 347.552764127461 }, { "n": 2000, "mean_diff": -163.84175208620286, "se": 0.9088440714836545, "worst": [ { "seed": 11816, "diff": -389.51725041604294, "candidate_edge": 406.8966664225309, "reference_edge": 796.4139168385739 }, { "seed": 11144, "diff": -373.2158088842894, "candidate_edge": 436.62979691651907, "reference_edge": 809.8456058008085 }, { "seed": 10879, "diff": -356.2668396102018, "candidate_edge": 463.9074476375105, "reference_edge": 820.1742872477123 }, { "seed": 10241, "diff": -340.3872667625379, "candidate_edge": 384.2127734193654, "reference_edge": 724.6000401819033 }, { "seed": 10794, "diff": -328.7347387832051, "candidate_edge": 393.69578961120226, "reference_edge": 722.4305283944074 } ], "variant": "s=1.0", "seeds": "10000..11999", "code_sha256": "c45d49cee55339e468fc24d18c520bed567934faa1b2d1fe324afa4ba1110523", "mean_edge": 359.379810743182 }, { "n": 2000, "mean_diff": -157.74550010084698, "se": 0.8919534441809212, "worst": [ { "seed": 11816, "diff": -375.94888885317795, "candidate_edge": 420.4650279853959, "reference_edge": 796.4139168385739 }, { "seed": 11144, "diff": -362.1268197705428, "candidate_edge": 447.7187860302657, "reference_edge": 809.8456058008085 }, { "seed": 10879, "diff": -351.2971645507911, "candidate_edge": 468.8771226969212, "reference_edge": 820.1742872477123 }, { "seed": 10241, "diff": -332.6082822607943, "candidate_edge": 391.991757921109, "reference_edge": 724.6000401819033 }, { "seed": 11898, "diff": -320.0356401142148, "candidate_edge": 426.3208639162155, "reference_edge": 746.3565040304303 } ], "variant": "s=1.2", "seeds": "10000..11999", "code_sha256": "ad62d47cb9263120842799b9267faf3a92067e6efe26a1d6532e63d52d3d2fff", "mean_edge": 365.4760627285379 } ], "next": "Do not promote: the frozen candidate does not clear +2 SE on fresh seeds. Keep CH as previous best. This is the best tested scale of the requested mechanism, delivered as a valid losing result. Consider testing expiry after a subsequent same-step print, rather than a persistent absolute cap, in a separately assigned experiment.", "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 POST_ARB_SCALE = 12;\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 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[2] = 0; slots[3] = WAD; slots[4] = 0;\n slots[5] = initialX > 0 ? wdiv(initialY, initialX) : 100 * WAD;\n slots[6] = 950000000000000; slots[7] = 800000000000000000; slots[8] = 2000000000000000;\n slots[9] = 0; slots[10] = 0; slots[11] = 0; slots[12] = 0;\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 = 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 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 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 {\n uint256 ret = pHat > 0 ? wdiv(absDiff(pImplied, pHat), pHat) : 0;\n if (firstInStep && ret > 2 * sigmaHat) {\n slots[11] = trade.timestamp;\n slots[12] = trade.isBuy ? 1 : 2;\n }\n uint256 alpha = firstInStep ? PHAT_ALPHA : PHAT_ALPHA_RETAIL;\n uint256 adaptiveGate = wmul(sigmaHat, GATE_SIGMA_MULT);\n if (adaptiveGate < MIN_GATE) adaptiveGate = MIN_GATE;\n if (ret <= adaptiveGate) { pHat = wmul(pHat, WAD - alpha) + wmul(pImplied, alpha); }\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 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 staleShift = wmul(STALE_DIR_COEF, toxSignal);\n uint256 attractShift = wmul(staleShift, STALE_ATTRACT_FRAC);\n if (spot >= pHat) {\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 (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 (slots[12] != 0) {\n (uint256 protect, uint256 attract) = _postArbPair(trade.timestamp - slots[11]);\n if (slots[12] == 1) {\n if (bidFee < protect) bidFee = protect;\n if (askFee > attract) askFee = attract;\n } else {\n if (askFee < protect) askFee = protect;\n if (bidFee > attract) bidFee = attract;\n }\n }\n\n slots[0] = bidFee; slots[1] = askFee; slots[2] = 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 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 // elapsed is capped at eight: four bits suffice, without a loop.\n if (exp & 1 != 0) result = wmul(result, factor);\n factor = wmul(factor, factor);\n if (exp & 2 != 0) result = wmul(result, factor);\n factor = wmul(factor, factor);\n if (exp & 4 != 0) result = wmul(result, factor);\n factor = wmul(factor, factor);\n if (exp & 8 != 0) result = wmul(result, factor);\n }\n\n function _postArbPair(uint256 n) internal pure returns (uint256 protect, uint256 attract) {\n // Tenths of a basis point, piecewise linear in silent steps.\n uint256 p; uint256 a;\n if (n == 0) { p = 586 * BPS; a = 162 * BPS; }\n else if (n == 1) { p = 480 * BPS; a = 180 * BPS; }\n else if (n < 4) { p = 420 * BPS - 40 * BPS * (n - 2); a = 200 * BPS + 10 * BPS * (n - 2); }\n else if (n < 8) { p = 340 * BPS - 15 * BPS * (n - 4); a = 220 * BPS + 30 * BPS * (n - 4) / 4; }\n else if (n < 16) { p = 280 * BPS - 10 * BPS * (n - 8) / 8; a = 250 * BPS + 10 * BPS * (n - 8) / 8; }\n else if (n < 32) { p = 270 * BPS - 10 * BPS * (n - 16) / 16; a = 260 * BPS; }\n else { p = 260 * BPS; a = 260 * BPS; }\n protect = p * POST_ARB_SCALE / 100;\n attract = a * POST_ARB_SCALE / 100;\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 function getName() external pure override returns (string memory) { return \"post_arb_pair_12\"; }\n}\n", "code_sha256": "ad62d47cb9263120842799b9267faf3a92067e6efe26a1d6532e63d52d3d2fff", "delta": "Add POST_ARB_SCALE=12 (scale in tenths). Initialize slots[11]=slots[12]=0. Before CH updates pHat/sigmaHat, if firstInStep && ret>2*sigmaHat, record timestamp in slot 11 and direction in slot 12 (1=trade.isBuy/bid protection; 2=ask protection). After CH tail compression, when slot 12!=0, n=trade.timestamp-slots[11]; floor protected fee and cap opposite fee with scaled, piecewise-linear table P/A in bps: 0:58.6/16.2, 1:48/18, 2:42/20, 4:34/22, 8:28/25, 16:27/26, >=32:26/26. Keep last signal until replaced; elapsed steps include gaps with no AMM call. Add _postArbPair helper. Unroll _powWad into four bit tests, exactly preserving CH arithmetic for elapsed<=8; no loops remain. Rename getName. Other CH constants and calculations unchanged.", "score": { "seed_start": 0, "n": 1000, "mean_edge": 367.3744620637392, "se": 1.952356925971179 }, "paired": { "reference": "CH 6dd68f77", "seed_start": 600000, "n": 2000, "mean_diff": -156.93499763531617, "se": 0.8855906333726495, "worst": [ { "seed": 601703, "diff": -362.3773570944751, "candidate_edge": 540.7538364759419, "reference_edge": 903.1311935704169 }, { "seed": 601154, "diff": -356.19905364366514, "candidate_edge": 471.84537297542397, "reference_edge": 828.0444266190891 }, { "seed": 601861, "diff": -322.80245218879656, "candidate_edge": 463.6021959534638, "reference_edge": 786.4046481422604 }, { "seed": 601191, "diff": -310.639993400546, "candidate_edge": 430.33561123743505, "reference_edge": 740.9756046379811 }, { "seed": 600107, "diff": -310.07283521953696, "candidate_edge": 435.230266975876, "reference_edge": 745.303102195413 } ] }, "seconds_per_simulation": 0.2651481519655402, "validate_ok": true, "blocked": null, "citations": [ "https://raw.githubusercontent.com/ChengHua926/amm-challenge/d34a5199c59a4c44d5336a25f1436b4ae1f21104/contracts/src/Strategy.sol", "https://raw.githubusercontent.com/benedictbrady/amm-challenge/6b6921f8d463314aa7c96234e1be25a25245f704/README.md", "https://raw.githubusercontent.com/benedictbrady/amm-challenge/6b6921f8d463314aa7c96234e1be25a25245f704/amm_competition/competition/match.py", "https://raw.githubusercontent.com/benedictbrady/amm-challenge/6b6921f8d463314aa7c96234e1be25a25245f704/amm_competition/competition/config.py", "https://raw.githubusercontent.com/benedictbrady/amm-challenge/6b6921f8d463314aa7c96234e1be25a25245f704/amm_sim_rs/src/lib.rs", "https://raw.githubusercontent.com/benedictbrady/amm-challenge/6b6921f8d463314aa7c96234e1be25a25245f704/amm_sim_rs/src/evm/strategy.rs", "https://raw.githubusercontent.com/benedictbrady/amm-challenge/6b6921f8d463314aa7c96234e1be25a25245f704/amm_sim_rs/src/simulation/engine.rs", "https://raw.githubusercontent.com/dipankar/amm-challenge/main/ANALYSIS.md" ], "measurement_protocol": { "engine_commit": "6b6921f8d463314aa7c96234e1be25a25245f704", "tuning_seeds": "10000..11999", "heldout_seeds": "600000..601999", "score_seeds": "0..999", "forbidden_seeds_used": false, "n_steps": 10000, "workers": 8, "chunk_size": 50, "configs": "numpy.default_rng(seed): draw mean size U[19,21], arrival rate U[0.6,1], sigma U[0.000882,0.001008], in that order. Standard initial reserves 100 X/10000 Y, GBM mu=0, dt=1, retail size sigma=1.2, buy probability=0.5. Pass seed to pinned Rust engine (price seed; retail seed+1).", "paired_definition": "Candidate edge minus CH edge on identical configs. Each runs against VanillaStrategy fixed 30 bps. SE=sample sd(ddof=1)/sqrt(n). Worst sorted by most negative paired difference.", "selection": "Freeze largest tuning mean_diff among four scales before any heldout evaluation; evaluate that candidate once on heldout set, no revision after looking.", "timing_definition": "Wall time summed over heldout and score batches for CH and candidate, divided by 6000 simulations; excludes compilation, tuning and checks.", "candidate_seconds_per_simulation": 0.263436119659959 }, "scoreboard": { "previous_best": { "file": "CH.sol", "sha256": "6dd68f77a70900319460215374143dbd5d924198450a46d9f5f91f6b1e3d35c3", "score": { "seed_start": 0, "n": 1000, "mean_edge": 525.5258821780834, "se": 2.7894264590251843 }, "requester_reference_score": 525.525882178 }, "selected_candidate": { "file": "Strategy.sol", "sha256": "ad62d47cb9263120842799b9267faf3a92067e6efe26a1d6532e63d52d3d2fff", "scale": 1.2, "promoted": false }, "promotions": [], "starter_comparison": "Not measured: this bounded round-3 assignment specifies CH as reference; no paired starter gain is claimed." }, "checks": [ "Starter, CH and all four candidates passed amm-match validate.", "Storage indices limited to 0..12; no for/while loops in candidate.", "Tested pair table endpoints and monotonic interpolation for n=0..99.", "Verified unrolled power equals original WAD rounding for all elapsed values 0..8 and three CH decay factors.", "Both arb directions, same-step persistence and elapsed calls executed under 250000 gas.", "Config builder exactly matches MatchRunner for seeds 0..9.", "Full paired runs completed with the pinned engine gas limit of 250000." ], "public_writeup": "Read dipankar ANALYSIS.md as qualitative background on hidden-state estimation versus per-print classification. Its reported scores and ablation results were not independently replicated here and were not used to tune this candidate." }