{"blocked":null,"item":"d","port_source":"\"\"\"RS2 float64 port. Fees/reserves/prices use real units, not raw TH[WAD].\nS is float64[40]; use a fresh zero array for each deployment.\nTH is float64 len(TH_NAMES), initialized from TH_VALUES. No fastmath.\nInteger TH[WAD] floors are deliberately not emulated; see differential results.\n\"\"\"\nimport math\nimport numpy as np\nfrom numba import njit\n\n\n# Base constants precede RS2 entries. Named entries are evaluated real-unit\n# constants ordered by their source occurrence. L<line>_N<ordinal> entries\n# inventory EVERY numeric literal (including slots, packing and isqrt) in\n# the hashed RS2 text, in lexical order; these inventory entries are raw\n# literal magnitudes, not additional tunable parameters. Structural indices\n# and integer-algorithm literals are retained for audit, not read by floats.\n# Named parameters shared across occurrences are tied, as their names imply.\n\nTH_NAMES = ('WAD', 'MAX_FEE', 'MIN_FEE', 'BPS', 'ELAPSED_CAP', 'L8_N0', 'SIGNAL_THRESHOLD', 'L9_N0', 'DIR_DECAY', 'L10_N0', 'ACT_DECAY', 'L11_N0', 'SIZE_DECAY', 'L12_N0', 'TOX_DECAY', 'L13_N0', 'SIGMA_DECAY', 'L14_N0', 'LAMBDA_DECAY', 'L15_N0', 'SIZE_BLEND_DECAY', 'L16_N0', 'TOX_BLEND_DECAY', 'L17_N0', 'ACT_BLEND_DECAY', 'L18_N0', 'PHAT_ALPHA', 'L19_N0', 'PHAT_ALPHA_RETAIL', 'L20_N0', 'PHAT_ALPHA_SAME', 'L21_N0', 'REVERT_U', 'L22_N0', 'DIR_IMPACT_MULT', 'L23_N0', 'GATE_SIGMA_MULT', 'L24_N0', 'MIN_GATE', 'L25_N0', 'TRADE_TOX_BOOST', 'L26_N0', 'STALE_ATTRACT_FRAC', 'L27_N0', 'RET_CAP', 'L28_N0', 'TOX_CAP', 'L29_N0', 'TRADE_RATIO_CAP', 'L30_N0', 'LAMBDA_CAP', 'L31_N0', 'STEP_COUNT_CAP', 'L32_N0', 'BASE_FEE', 'L33_N0', 'SIGMA_COEF', 'L34_N0', 'LAMBDA_COEF', 'L35_N0', 'FLOW_SIZE_COEF', 'L36_N0', 'TOX_COEF', 'L37_N0', 'TOX_QUAD_COEF', 'L38_N0', 'ACT_COEF', 'L39_N0', 'DIR_COEF', 'L40_N0', 'DIR_TOX_COEF', 'L41_N0', 'STALE_DIR_COEF', 'L42_N0', 'SIGMA_TOX_COEF', 'L43_N0', 'TAIL_KNEE', 'L44_N0', 'TAIL_SLOPE_PROTECT', 'L45_N0', 'TAIL_SLOPE_ATTRACT', 'L46_N0', 'ZERO', 'L49_N0', 'L49_N1', 'ONE', 'L49_N2', 'L50_N0', 'L50_N1', 'FALLBACK_PRICE', 'L50_N2', 'L51_N0', 'INITIAL_SIGMA', 'L51_N1', 'L51_N2', 'INITIAL_LAMBDA', 'L51_N3', 'L51_N4', 'INITIAL_SIZE', 'L51_N5', 'L52_N0', 'INITIAL_RATE', 'L52_N1', 'L52_N2', 'L52_N3', 'L52_N4', 'PROCESS_VAR', 'L52_N5', 'L52_N6', 'L52_N7', 'L57_N0', 'L57_N1', 'L57_N2', 'L58_N0', 'L58_N1', 'L58_N2', 'L59_N0', 'L59_N1', 'L59_N2', 'L60_N0', 'L60_N1', 'L63_N0', 'L64_N0', 'L65_N0', 'L74_N0', 'L74_N1', 'VAR_CAP', 'L80_N0', 'L80_N1', 'L81_N0', 'L84_N0', 'L85_N0', 'L86_N0', 'L89_N0', 'L91_N0', 'L96_N0', 'L97_N0', 'SILENCE_G_CAP', 'L98_N0', 'L98_N1', 'SILENCE_DECAY', 'L99_N0', 'L100_N0', 'L100_N1', 'L101_N0', 'TWO', 'L102_N0', 'SILENCE_ATTENUATION', 'L105_N0', 'L109_N0', 'L109_N1', 'L112_N0', 'L116_N0', 'L117_N0', 'L117_N1', 'L120_N0', 'L120_N1', 'L120_N2', 'L126_N0', 'L127_N0', 'ROUTE_FEE', 'L139_N0', 'L139_N1', 'L141_N0', 'L142_N0', 'ROUTE_OLD', 'L143_N0', 'L143_N1', 'ROUTE_NEW', 'L143_N2', 'L143_N3', 'L149_N0', 'L149_N1', 'L151_N0', 'L151_N1', 'L153_N0', 'L154_N0', 'L155_N0', 'L155_N1', 'PUSH_CAP', 'L160_N0', 'L160_N1', 'DIR_CAP', 'L163_N0', 'L163_N1', 'L165_N0', 'L172_N0', 'L172_N1', 'L177_N0', 'FLOW_BLEND', 'L182_N0', 'L182_N1', 'L183_N0', 'L185_N0', 'L186_N0', 'L187_N0', 'L187_N1', 'L188_N0', 'L188_N1', 'FLOW_RATE_CAP', 'L191_N0', 'L191_N1', 'FLOW_RETENTION', 'L192_N0', 'FLOW_ELAPSED_CAP', 'L192_N1', 'L192_N2', 'L194_N0', 'FLOW_CORRECTION_MODE', 'FLOW_CORRECTION_ACTIVE', 'L198_N0', 'L198_N1', 'MISSING_COEF', 'L199_N0', 'MISSING_CAP', 'L200_N0', 'L200_N1', 'L204_N0', 'L206_N0', 'L206_N1', 'L206_N2', 'RETAIL_RATE_COEF', 'L207_N0', 'FLOW_SIZE_MODE', 'L208_N0', 'L208_N1', 'RETAIL_SIZE_COEF', 'L208_N2', 'L209_N0', 'L210_N0', 'L226_N0', 'L229_N0', 'STALE_SLOW_WEIGHT', 'L233_N0', 'STALE_FAST_WEIGHT', 'L233_N1', 'L240_N0', 'L243_N0', 'RETAIL_BOOST_CAP', 'L251_N0', 'L251_N1', 'L266_N0', 'L266_N1', 'L267_N0', 'L267_N1', 'ATTRACT_CAP', 'L270_N0', 'L270_N1', 'L271_N0', 'L271_N1', 'L273_N0', 'L273_N1', 'L273_N2', 'L273_N3', 'L274_N0', 'L274_N1', 'L274_N2', 'L275_N0', 'L275_N1', 'L275_N2', 'L276_N0', 'L276_N1', 'L287_N0', 'VAR_FLOOR', 'L288_N0', 'L288_N1', 'L292_N0', 'L292_N1', 'POST_ELAPSED_CAP', 'L293_N0', 'L293_N1', 'L294_N0', 'L294_N1', 'L297_N0', 'L302_N0', 'L309_N0', 'L310_N0', 'L311_N0', 'RETAIL_NOISE', 'L313_N0', 'L315_N0', 'L317_N0', 'OBS_VAR', 'L320_N0', 'DENSITY_SCALE', 'DENSITY_POWER', 'L322_N0', 'L322_N1', 'ODDS_SCALE', 'L323_N0', 'LARGE_SIZE', 'L324_N0', 'LARGE_ODDS_MULT', 'L324_N1', 'L324_N2', 'L325_N0', 'SILENT_ODDS_MULT', 'L325_N1', 'L325_N2', 'L328_N0', 'L330_N0', 'MASS_FLOOR', 'L331_N0', 'L331_N1', 'L340_N0', 'L340_N1', 'L349_N0', 'L350_N0', 'L350_N1', 'THREE', 'L351_N0', 'L351_N1', 'L351_N2', 'ONE_WEI', 'L351_N3', 'L351_N4', 'Q_CENTER', 'L352_N0', 'L352_N1', 'L352_N2', 'Q_NEAR', 'L352_N3', 'L352_N4', 'L352_N5', 'Q_MID', 'L352_N6', 'L352_N7', 'L352_N8', 'L353_N0', 'L354_N0', 'L354_N1', 'FOUR', 'L355_N0', 'L357_N0', 'L357_N1', 'L359_N0', 'L361_N0', 'L361_N1', 'L363_N0', 'L363_N1', 'L364_N0', 'L374_N0', 'L375_N0', 'L375_N1', 'L377_N0', 'L385_N0', 'L390_N0', 'L390_N1', 'L393_N0', 'L394_N0', 'L394_N1', 'L394_N2', 'L394_N3', 'L395_N0', 'L395_N1', 'L395_N2', 'L395_N3', 'L396_N0', 'L396_N1', 'L396_N2', 'L396_N3', 'L397_N0', 'L397_N1', 'L397_N2', 'L397_N3', 'L398_N0', 'L398_N1', 'L398_N2', 'L398_N3', 'L399_N0', 'L399_N1', 'L399_N2', 'L399_N3', 'L400_N0', 'L400_N1', 'L400_N2', 'L401_N0', 'L402_N0', 'L403_N0', 'L404_N0', 'L405_N0', 'L406_N0', 'L407_N0')\nTH_VALUES = np.array([1.0, 0.1, 0.0, 0.0001, 8.0, 8.0, 0.001538461538461538, 650.0, 0.75, 7.5e+17, 0.53, 5.3e+17, 0.53, 5.3e+17, 0.91, 9.1e+17, 0.69, 6.9e+17, 0.99, 9.9e+17, 0.828, 8.28e+17, 0.051, 5.1e+16, 0.985, 9.85e+17, 0.27, 2.7e+17, 0.06, 6e+16, 0.12, 1.2e+17, 0.0, 0.0, 4.0, 4.0, 7.2, 7.2e+18, 0.03, 3e+16, 0.35, 3500.0, 1.05, 1.05e+18, 0.02857142857142857, 35.0, 0.2, 5.0, 0.2, 5.0, 1.82, 1.82e+18, 64.0, 64.0, 0.0004, 4.0, 0.2, 2e+17, 0.0012, 12.0, 0.4842, 4842.0, 0.03, 300.0, 1.5, 15000.0, 9.1843, 91843.0, 0.002, 20.0, 0.01, 100.0, 0.685, 6850.0, 0.05, 500.0, 0.06, 600.0, 0.93, 9.3e+17, 0.85, 8.5e+17, 0.0, 0.0, 1.0, 1.0, 3.0, 5.0, 0.0, 100.0, 100.0, 6.0, 0.00095, 950000000000000.0, 7.0, 0.8, 8e+17, 8.0, 0.002, 2000000000000000.0, 15.0, 0.4, 4e+17, 2000000000000000.0, 160.0, 13.0, 9.025e-07, 902500000000.0, 14.0, 5.0, 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 14.0, 13.0, 0.0, 0.0, 0.0, 0.0001, 100000000000000.0, 100000000000000.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.8, 8e+17, 2.0, 64.0, 0.0, 2.0, 2.0, 0.3, 3e+17, 0.0, 0.0, 1.0, 12.0, 0.0, 1.0, 12.0, 1.0, 2.0, 0.0, 11.0, 0.003, 30.0, 0.0, 30.0, 30.0, 0.9, 90.0, 100.0, 0.1, 10.0, 100.0, 2.0, 64.0, 0.0, 0.0, 13.0, 14.0, 0.0, 0.0, 0.25, 4.0, 4.0, 2.0, 2.0, 2.0, 0.0, 0.0, 0.0, 1.0, 0.3424067991934183, 3.424067991934183e+17, 0.0, 15.0, 80.0, 160.0, 0.0, 4e+17, 0.0, 2000000000000000.0, 3.0, 3.0, 3.0, 0.999, 9.99e+17, 64.0, 64.0, 64.0, 0.0, 2.0, 2.0, 2.0, 2.0, 196.03088039613942, 1.9603088039613943e+20, 0.33333333333333337, 3.333333333333334e+17, 3.333333333333334e+17, 9.99e+17, 15.0, 80.0, 160.0, 0.36638342491340714, 3.6638342491340717e+17, 2.0, 2.0, 0.0, 1.8832961581192984, 1.8832961581192983e+18, 3.424067991934183e+17, 3.424067991934183e+17, 0.0, 0.0, 0.7, 7e+17, 0.3, 3e+17, 0.0, 0.0, 0.0016, 16.0, 16.0, 30.0, 30.0, 30.0, 30.0, 0.0036, 36.0, 36.0, 36.0, 36.0, 0.0, 1.0, 2.0, 64.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 0.0, 1e-08, 10000000000.0, 10000000000.0, 1.0, 0.0, 8.0, 8.0, 8.0, 902500000000.0, 1.0, 902500000000.0, 0.0, 30.0, 30.0, 30.0, 9e-06, 9000000000000.0, 0.0, 0.0, 2.25e-08, 22500000000.0, 8.0, 4.0, 8.0, 4.0, 0.004, 4000000000000000.0, 0.003, 3000000000000000.0, 0.4, 4.0, 10.0, 1.0, 0.8, 8.0, 10.0, 0.0, 2.0, 0.01, 100.0, 100.0, 100000000000000.0, 100000000000000.0, 3.0, 0.0, 7.0, 3.0, 3.0, 3.0, 3.0, 1e-18, 1.0, 3.0, 72.0, 3.0, 72.0, 2.0, 45.0, 4.0, 45.0, 1.0, 10.0, 5.0, 10.0, 1.0, 0.0, 0.0, 0.0, 4.0, 4.0, 0.0, 1.0, 2.0, 1.0, 0.0, 2.0, 0.0, 10000000000.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 128.0, 0.0, 128.0, 64.0, 64.0, 0.0, 64.0, 32.0, 32.0, 0.0, 32.0, 16.0, 16.0, 0.0, 16.0, 8.0, 8.0, 0.0, 8.0, 4.0, 4.0, 0.0, 4.0, 2.0, 2.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0], dtype=np.float64)\n\n# Immutable indices; parameter values themselves always come from TH.\nWAD = 0\nMAX_FEE = 1\nMIN_FEE = 2\nELAPSED_CAP = 4\nSIGNAL_THRESHOLD = 6\nDIR_DECAY = 8\nACT_DECAY = 10\nSIZE_DECAY = 12\nTOX_DECAY = 14\nSIGMA_DECAY = 16\nLAMBDA_DECAY = 18\nSIZE_BLEND_DECAY = 20\nTOX_BLEND_DECAY = 22\nACT_BLEND_DECAY = 24\nPHAT_ALPHA = 26\nPHAT_ALPHA_RETAIL = 28\nPHAT_ALPHA_SAME = 30\nREVERT_U = 32\nDIR_IMPACT_MULT = 34\nGATE_SIGMA_MULT = 36\nMIN_GATE = 38\nTRADE_TOX_BOOST = 40\nSTALE_ATTRACT_FRAC = 42\nRET_CAP = 44\nTOX_CAP = 46\nTRADE_RATIO_CAP = 48\nLAMBDA_CAP = 50\nSTEP_COUNT_CAP = 52\nBASE_FEE = 54\nSIGMA_COEF = 56\nLAMBDA_COEF = 58\nFLOW_SIZE_COEF = 60\nTOX_COEF = 62\nTOX_QUAD_COEF = 64\nACT_COEF = 66\nDIR_COEF = 68\nDIR_TOX_COEF = 70\nSTALE_DIR_COEF = 72\nSIGMA_TOX_COEF = 74\nTAIL_KNEE = 76\nTAIL_SLOPE_PROTECT = 78\nTAIL_SLOPE_ATTRACT = 80\nZERO = 82\nONE = 85\nFALLBACK_PRICE = 89\nINITIAL_SIGMA = 92\nINITIAL_LAMBDA = 95\nINITIAL_SIZE = 98\nINITIAL_RATE = 101\nPROCESS_VAR = 106\nVAR_CAP = 126\nSILENCE_G_CAP = 137\nSILENCE_DECAY = 140\nTWO = 145\nSILENCE_ATTENUATION = 147\nROUTE_FEE = 160\nROUTE_OLD = 165\nROUTE_NEW = 168\nPUSH_CAP = 179\nDIR_CAP = 182\nFLOW_BLEND = 189\nFLOW_RATE_CAP = 199\nFLOW_RETENTION = 202\nFLOW_ELAPSED_CAP = 204\nFLOW_CORRECTION_MODE = 208\nFLOW_CORRECTION_ACTIVE = 209\nMISSING_COEF = 212\nMISSING_CAP = 214\nRETAIL_RATE_COEF = 221\nFLOW_SIZE_MODE = 223\nRETAIL_SIZE_COEF = 226\nSTALE_SLOW_WEIGHT = 232\nSTALE_FAST_WEIGHT = 234\nRETAIL_BOOST_CAP = 238\nATTRACT_CAP = 245\nVAR_FLOOR = 263\nPOST_ELAPSED_CAP = 268\nRETAIL_NOISE = 278\nOBS_VAR = 282\nDENSITY_SCALE = 284\nDENSITY_POWER = 285\nODDS_SCALE = 288\nLARGE_SIZE = 290\nLARGE_ODDS_MULT = 292\nSILENT_ODDS_MULT = 296\nMASS_FLOOR = 301\nTHREE = 309\nONE_WEI = 313\nQ_CENTER = 316\nQ_NEAR = 320\nQ_MID = 324\nFOUR = 331\n\n@njit\ndef _pow(TH, factor, exp):\n    result = TH[ONE]\n    while exp > TH[ZERO]:\n        if int(exp) & 1:\n            result *= factor\n        factor *= factor\n        exp = math.floor(exp / TH[TWO])\n    return result\n\n@njit\ndef _blend(TH, a, b, w):\n    if b >= a:\n        return a + (b-a)*w\n    return a - (a-b)*w\n\n@njit\ndef _band(TH, mu, v, lo, hi):\n    # Solidity floors sqrt(v * 1e36) to an integer, then rescales by 1e18.\n    sd = mu * math.sqrt(v)\n    a0 = TH[ZERO]\n    a1 = TH[ZERO]\n    a2 = TH[ZERO]\n    for j in range(7):\n        if j < 3:\n            p = mu-(TH[THREE]-j)*sd if mu > (TH[THREE]-j)*sd else TH[ONE_WEI]\n        else:\n            p = mu+(j-TH[THREE])*sd\n        w = TH[Q_CENTER] if j == 3 else (TH[Q_NEAR] if j == 2 or j == 4 else (TH[Q_MID] if j == 1 or j == 5 else TH[ONE]))\n        distance = lo-p if p < lo else (p-hi if p > hi else TH[ZERO])\n        z = distance/sd if sd > TH[ZERO] else TH[ZERO]\n        likelihood = TH[ONE]/(TH[ONE]+TH[FOUR]*z*z)\n        w *= likelihood\n        a0 += w\n        a1 += w*p\n        d = abs(p-mu)/mu\n        a2 += w*d*d\n    m = a1/a0\n    d = abs(m-mu)/mu\n    second = a2/a0\n    return m, second-d*d if second > d*d else TH[VAR_FLOOR]\n\n@njit\ndef _posterior(TH, mu, v, obs, spot, pre_spot, bid, ask, first, silent, buy, size):\n    if mu == TH[ZERO]:\n        mu = spot\n    if v < TH[VAR_FLOOR]:\n        v = TH[VAR_FLOOR]\n    lo = pre_spot*(TH[ONE]-bid)\n    hi = pre_spot/(TH[ONE]-ask)\n    if first:\n        if silent > TH[ONE] and pre_spot > TH[ZERO]:\n            elapsed = min(silent, TH[POST_ELAPSED_CAP])\n            v += TH[PROCESS_VAR]*(elapsed-TH[ONE])\n            mu, v = _band(TH, mu, v, lo, hi)\n        v += TH[PROCESS_VAR]\n    m_retail = mu\n    v_retail = v\n    if first and pre_spot > TH[ZERO]:\n        m_retail, v_retail = _band(TH, mu, v, lo, hi)\n    if not first:\n        fee = bid if buy else ask\n        if fee > TH[ROUTE_FEE]:\n            normal = spot*(TH[ONE]-fee)/(TH[ONE]-TH[ROUTE_FEE]) if buy else spot*(TH[ONE]-TH[ROUTE_FEE])/(TH[ONE]-fee)\n            residual = abs(normal-mu)/mu\n            noise = TH[RETAIL_NOISE]+residual*residual\n            k = v/(v+noise)\n            return _blend(TH, mu, normal, k), v*(TH[ONE]-k), TH[ZERO]\n        return mu, v, TH[ZERO]\n    e = abs(obs-mu)/mu\n    total_v = v+TH[OBS_VAR]\n    z = e*e/total_v\n    density = _pow(TH, TH[ONE]/(TH[ONE]+z/TH[DENSITY_SCALE]), TH[DENSITY_POWER])\n    odds = density*TH[ODDS_SCALE]/math.sqrt(total_v)\n    if size > TH[LARGE_SIZE]:\n        odds *= TH[LARGE_ODDS_MULT]\n    if silent > TH[ONE]:\n        odds *= TH[SILENT_ODDS_MULT]\n    sd = math.sqrt(v)\n    width = (hi-lo)/mu\n    distance = lo-mu if mu < lo else (mu-hi if mu > hi else TH[ZERO])\n    z_band = (distance/mu)/sd\n    mass = width/(width+TH[TWO]*sd)/(TH[ONE]+z_band*z_band)\n    if mass < TH[MASS_FLOOR]:\n        mass = TH[MASS_FLOOR]\n    odds /= mass\n    prob = odds/(TH[ONE]+odds)\n    k_arb = v/total_v\n    m_arb = _blend(TH, mu, obs, k_arb)\n    mean = _blend(TH, m_retail, m_arb, prob)\n    between = abs(m_arb-m_retail)/mu\n    variance = prob*v*(TH[ONE]-k_arb)+(TH[ONE]-prob)*v_retail+prob*(TH[ONE]-prob)*between*between\n    if variance > TH[VAR_CAP]:\n        variance = TH[VAR_CAP]\n    return mean, variance, prob\n\n@njit\ndef strat_init(S, TH, x0, y0):\n    # As in Solidity, only initialized slots are assigned; callers zero S.\n    S[0] = TH[BASE_FEE]\n    S[1] = TH[BASE_FEE]\n    S[3] = TH[ONE]\n    S[5] = y0/x0 if x0 > TH[ZERO] else TH[FALLBACK_PRICE]\n    S[6] = TH[INITIAL_SIGMA]\n    S[7] = TH[INITIAL_LAMBDA]\n    S[8] = TH[INITIAL_SIZE]\n    S[15] = TH[INITIAL_RATE]\n    S[33] = TH[INITIAL_SIZE]\n    S[13] = TH[PROCESS_VAR]\n    S[14] = S[5]\n    return TH[BASE_FEE], TH[BASE_FEE]\n\n@njit\ndef strat_after(S, TH, is_buy, amount_x, amount_y, timestamp, reserve_x, reserve_y):\n    prev_bid = S[0]\n    prev_ask = S[1]\n    last_ts = S[2]\n    direction = S[3]\n    act = S[4]\n    phat = S[5]\n    sigma = S[6]\n    lam = S[7]\n    size = S[8]\n    tox_ema = S[9]\n    count = S[10]\n    fast = S[14]\n    uncertainty = S[13]\n    silent = timestamp-last_ts if timestamp > last_ts else TH[ZERO]\n    new_step = timestamp > last_ts\n    if new_step:\n        elapsed_raw = timestamp-last_ts\n        elapsed = min(elapsed_raw, TH[ELAPSED_CAP])\n        mul = _pow(TH, TH[DIR_DECAY], elapsed)\n        if direction >= TH[ONE]:\n            direction = TH[ONE]+(direction-TH[ONE])*mul\n        else:\n            below = (TH[ONE]-direction)*mul\n            direction = TH[ONE]-below if below < TH[ONE] else TH[ZERO]\n        act *= _pow(TH, TH[ACT_DECAY], elapsed)\n        size *= _pow(TH, TH[SIZE_DECAY], elapsed)\n        tox_ema *= _pow(TH, TH[TOX_DECAY], elapsed)\n        if count > TH[ZERO] and elapsed_raw > TH[ZERO]:\n            inst = min(count/elapsed_raw, TH[LAMBDA_CAP])\n            lam = lam*TH[LAMBDA_DECAY]+inst*(TH[ONE]-TH[LAMBDA_DECAY])\n        uncertainty = min(uncertainty, TH[VAR_CAP])\n        count = TH[ZERO]\n    first = count == TH[ZERO]\n    spot = reserve_y/reserve_x if reserve_x > TH[ZERO] else phat\n    if phat == TH[ZERO]:\n        phat = spot\n    fee = prev_bid if is_buy else prev_ask\n    gamma = TH[ONE]-fee if fee < TH[ONE] else TH[ZERO]\n    if gamma == TH[ZERO]:\n        implied = spot\n    else:\n        implied = spot*gamma if is_buy else spot/gamma\n    silence_scale = TH[ONE]\n    if first and silent > TH[ONE]:\n        g = min(silent-TH[ONE], TH[SILENCE_G_CAP])\n        w = TH[ONE]-_pow(TH, TH[SILENCE_DECAY], g)\n        s = S[32]\n        if s == TH[ZERO]:\n            s = phat\n        c = (s*(TH[ONE]-prev_bid)+s/(TH[ONE]-prev_ask))/TH[TWO]\n        phat = _blend(TH, phat, c, w)\n        silence_scale = TH[ONE]-TH[SILENCE_ATTENUATION]*w\n    ret = abs(implied-phat)/phat if phat > TH[ZERO] else TH[ZERO]\n    alpha = TH[PHAT_ALPHA] if first else TH[PHAT_ALPHA_RETAIL]\n    second = not first and count == TH[ONE]\n    same = False\n    opposite = False\n    if second:\n        up = implied >= phat\n        d1 = S[12]\n        if d1 != TH[ZERO]:\n            same = (d1 == TH[ONE]) == up\n            opposite = not same\n        if same:\n            alpha = TH[PHAT_ALPHA_SAME]\n    if first:\n        S[12] = TH[ONE] if implied >= phat else TH[TWO]\n    gate = max(sigma*TH[GATE_SIGMA_MULT], TH[MIN_GATE])\n    alpha *= silence_scale\n    gate *= silence_scale\n    if ret <= gate:\n        phat = phat*(TH[ONE]-alpha)+implied*alpha\n    if opposite and TH[REVERT_U] > TH[ZERO]:\n        phat = _blend(TH, phat, S[11], TH[REVERT_U])\n    if first:\n        ret = min(ret, TH[RET_CAP])\n        sigma = sigma*TH[SIGMA_DECAY]+ret*(TH[ONE]-TH[SIGMA_DECAY])\n    if not first and fee > TH[ROUTE_FEE] and gamma > TH[ZERO]:\n        normal = spot*gamma/(TH[ONE]-TH[ROUTE_FEE]) if is_buy else spot*(TH[ONE]-TH[ROUTE_FEE])/gamma\n        phat = phat*TH[ROUTE_OLD]+normal*TH[ROUTE_NEW]\n    raw_ratio = amount_y/reserve_y if reserve_y > TH[ZERO] else TH[ZERO]\n    fast, uncertainty, arb_prob = _posterior(TH, fast, uncertainty, implied, spot, S[32], prev_bid, prev_ask, first, silent, is_buy, raw_ratio)\n    S[13] = uncertainty\n    S[14] = fast\n    ratio = min(raw_ratio, TH[TRADE_RATIO_CAP])\n    if ratio > TH[SIGNAL_THRESHOLD]:\n        push = min(ratio*TH[DIR_IMPACT_MULT], TH[PUSH_CAP])\n        if is_buy:\n            direction = min(direction+push, TH[DIR_CAP])\n        else:\n            direction = direction-push if direction > push else TH[ZERO]\n        act = act*TH[ACT_BLEND_DECAY]+ratio*(TH[ONE]-TH[ACT_BLEND_DECAY])\n        size = size*TH[SIZE_BLEND_DECAY]+ratio*(TH[ONE]-TH[SIZE_BLEND_DECAY])\n        size = min(size, TH[ONE])\n    tox = abs(spot-phat)/phat if phat > TH[ZERO] else TH[ZERO]\n    tox = min(tox, TH[TOX_CAP])\n    tox_ema = tox_ema*TH[TOX_BLEND_DECAY]+tox*(TH[ONE]-TH[TOX_BLEND_DECAY])\n    count = min(count+TH[ONE], TH[STEP_COUNT_CAP])\n    original_lam = lam\n    original_size = size\n    if TH[FLOW_BLEND] > TH[ZERO]:\n        rate = S[15]\n        flow_count = S[34]\n        mean_size = S[33]\n        if rate == TH[ZERO]:\n            rate = TH[INITIAL_RATE]\n        if mean_size == TH[ZERO]:\n            mean_size = TH[INITIAL_SIZE]\n        if new_step:\n            inst = min(flow_count/silent, TH[FLOW_RATE_CAP])\n            retention = _pow(TH, TH[FLOW_RETENTION], min(silent, TH[FLOW_ELAPSED_CAP]))\n            rate = rate*retention+inst*(TH[ONE]-retention)\n            flow_count = TH[ZERO]\n        weight = TH[ONE]-arb_prob if first else TH[ONE]\n        corrected_weight = weight\n        if TH[FLOW_CORRECTION_MODE] == TH[FLOW_CORRECTION_ACTIVE]:\n            missing = min(fee*TH[MISSING_COEF], TH[MISSING_CAP])\n            corrected_weight = weight/(TH[ONE]-missing)\n        flow_count += corrected_weight\n        learning = (TH[ONE]-TH[FLOW_RETENTION])*weight\n        mean_size = _blend(TH, mean_size, ratio, learning)\n        S[15] = rate\n        S[34] = flow_count\n        S[33] = mean_size\n        retail_rate = rate*TH[RETAIL_RATE_COEF]\n        retail_size = size if TH[FLOW_SIZE_MODE] == TH[ZERO] else mean_size*TH[RETAIL_SIZE_COEF]\n        lam = _blend(TH, lam, retail_rate, TH[FLOW_BLEND])\n        size = _blend(TH, size, retail_size, TH[FLOW_BLEND])\n    flow_size = lam*size\n    fbase = TH[BASE_FEE]+TH[SIGMA_COEF]*sigma+TH[LAMBDA_COEF]*lam+TH[FLOW_SIZE_COEF]*flow_size\n    fmid = fbase+TH[TOX_COEF]*tox_ema+TH[TOX_QUAD_COEF]*tox_ema*tox_ema+TH[ACT_COEF]*act\n    fmid += TH[SIGMA_TOX_COEF]*sigma*tox_ema\n    lam = original_lam\n    size = original_size\n    pressure = direction >= TH[ONE]\n    dev = direction-TH[ONE] if pressure else TH[ONE]-direction\n    skew = TH[DIR_COEF]*dev+TH[DIR_TOX_COEF]*dev*tox_ema\n    if pressure:\n        bid = fmid+skew\n        ask = fmid-skew if fmid > skew else TH[ZERO]\n    else:\n        ask = fmid+skew\n        bid = fmid-skew if fmid > skew else TH[ZERO]\n    stale_hat = phat*TH[STALE_SLOW_WEIGHT]+fast*TH[STALE_FAST_WEIGHT]\n    stale_tox = min(abs(spot-stale_hat)/stale_hat, TH[TOX_CAP])\n    shift = TH[STALE_DIR_COEF]*stale_tox\n    attract = shift*TH[STALE_ATTRACT_FRAC]\n    if spot >= stale_hat:\n        bid += shift\n        ask = ask-attract if ask > attract else TH[ZERO]\n    else:\n        ask += shift\n        bid = bid-attract if bid > attract else TH[ZERO]\n    aligned = (is_buy and spot >= phat) or (not is_buy and spot < phat)\n    if aligned:\n        boost = TH[TRADE_TOX_BOOST]*ratio\n        if not first and boost > TH[RETAIL_BOOST_CAP]:\n            boost = TH[RETAIL_BOOST_CAP]\n        if is_buy:\n            bid += boost\n        else:\n            ask += boost\n    bid_slope = TH[TAIL_SLOPE_PROTECT] if pressure else TH[TAIL_SLOPE_ATTRACT]\n    ask_slope = TH[TAIL_SLOPE_ATTRACT] if pressure else TH[TAIL_SLOPE_PROTECT]\n    if bid > TH[TAIL_KNEE]:\n        bid = TH[TAIL_KNEE]+(bid-TH[TAIL_KNEE])*bid_slope\n    if ask > TH[TAIL_KNEE]:\n        ask = TH[TAIL_KNEE]+(ask-TH[TAIL_KNEE])*ask_slope\n    bid = min(max(bid, TH[MIN_FEE]), TH[MAX_FEE])\n    ask = min(max(ask, TH[MIN_FEE]), TH[MAX_FEE])\n    if first:\n        if ask > bid and bid > TH[ROUTE_FEE]:\n            bid = TH[ROUTE_FEE]\n        elif bid > ask and ask > TH[ROUTE_FEE]:\n            ask = TH[ROUTE_FEE]\n    if bid > ask and ask > TH[ATTRACT_CAP]:\n        ask = TH[ATTRACT_CAP]\n    elif ask > bid and bid > TH[ATTRACT_CAP]:\n        bid = TH[ATTRACT_CAP]\n    S[0] = bid\n    S[1] = ask\n    S[2] = timestamp\n    S[32] = spot\n    S[3] = direction\n    S[4] = act\n    S[5] = phat\n    S[6] = sigma\n    S[7] = lam\n    S[8] = size\n    S[9] = tox_ema\n    S[10] = count\n    return bid, ask\n","port_sha256":"9eac3553357528b06eeae3ed8d18283d83401e1968145ceba16be356a147e271","rs2_source_url":"https://api.imdnotdead.fun/artifacts/19f2ec857df536e8ab62ab1da89ec6623332521ce46849f15bccff402c63e1e5","rs2_source_sha256":"f24b6ca198b744c380842c3a17964a6dc21f311bb04984b26733afa3fee8eaf2","repository_commit":"6b6921f8d463314aa7c96234e1be25a25245f704","setup":{"passed":true,"starter_validation":"Strategy StarterStrategy validated successfully","working_area":"test/scratch/ (not delivered)"},"th_names":["WAD","MAX_FEE","MIN_FEE","BPS","ELAPSED_CAP","L8_N0","SIGNAL_THRESHOLD","L9_N0","DIR_DECAY","L10_N0","ACT_DECAY","L11_N0","SIZE_DECAY","L12_N0","TOX_DECAY","L13_N0","SIGMA_DECAY","L14_N0","LAMBDA_DECAY","L15_N0","SIZE_BLEND_DECAY","L16_N0","TOX_BLEND_DECAY","L17_N0","ACT_BLEND_DECAY","L18_N0","PHAT_ALPHA","L19_N0","PHAT_ALPHA_RETAIL","L20_N0","PHAT_ALPHA_SAME","L21_N0","REVERT_U","L22_N0","DIR_IMPACT_MULT","L23_N0","GATE_SIGMA_MULT","L24_N0","MIN_GATE","L25_N0","TRADE_TOX_BOOST","L26_N0","STALE_ATTRACT_FRAC","L27_N0","RET_CAP","L28_N0","TOX_CAP","L29_N0","TRADE_RATIO_CAP","L30_N0","LAMBDA_CAP","L31_N0","STEP_COUNT_CAP","L32_N0","BASE_FEE","L33_N0","SIGMA_COEF","L34_N0","LAMBDA_COEF","L35_N0","FLOW_SIZE_COEF","L36_N0","TOX_COEF","L37_N0","TOX_QUAD_COEF","L38_N0","ACT_COEF","L39_N0","DIR_COEF","L40_N0","DIR_TOX_COEF","L41_N0","STALE_DIR_COEF","L42_N0","SIGMA_TOX_COEF","L43_N0","TAIL_KNEE","L44_N0","TAIL_SLOPE_PROTECT","L45_N0","TAIL_SLOPE_ATTRACT","L46_N0","ZERO","L49_N0","L49_N1","ONE","L49_N2","L50_N0","L50_N1","FALLBACK_PRICE","L50_N2","L51_N0","INITIAL_SIGMA","L51_N1","L51_N2","INITIAL_LAMBDA","L51_N3","L51_N4","INITIAL_SIZE","L51_N5","L52_N0","INITIAL_RATE","L52_N1","L52_N2","L52_N3","L52_N4","PROCESS_VAR","L52_N5","L52_N6","L52_N7","L57_N0","L57_N1","L57_N2","L58_N0","L58_N1","L58_N2","L59_N0","L59_N1","L59_N2","L60_N0","L60_N1","L63_N0","L64_N0","L65_N0","L74_N0","L74_N1","VAR_CAP","L80_N0","L80_N1","L81_N0","L84_N0","L85_N0","L86_N0","L89_N0","L91_N0","L96_N0","L97_N0","SILENCE_G_CAP","L98_N0","L98_N1","SILENCE_DECAY","L99_N0","L100_N0","L100_N1","L101_N0","TWO","L102_N0","SILENCE_ATTENUATION","L105_N0","L109_N0","L109_N1","L112_N0","L116_N0","L117_N0","L117_N1","L120_N0","L120_N1","L120_N2","L126_N0","L127_N0","ROUTE_FEE","L139_N0","L139_N1","L141_N0","L142_N0","ROUTE_OLD","L143_N0","L143_N1","ROUTE_NEW","L143_N2","L143_N3","L149_N0","L149_N1","L151_N0","L151_N1","L153_N0","L154_N0","L155_N0","L155_N1","PUSH_CAP","L160_N0","L160_N1","DIR_CAP","L163_N0","L163_N1","L165_N0","L172_N0","L172_N1","L177_N0","FLOW_BLEND","L182_N0","L182_N1","L183_N0","L185_N0","L186_N0","L187_N0","L187_N1","L188_N0","L188_N1","FLOW_RATE_CAP","L191_N0","L191_N1","FLOW_RETENTION","L192_N0","FLOW_ELAPSED_CAP","L192_N1","L192_N2","L194_N0","FLOW_CORRECTION_MODE","FLOW_CORRECTION_ACTIVE","L198_N0","L198_N1","MISSING_COEF","L199_N0","MISSING_CAP","L200_N0","L200_N1","L204_N0","L206_N0","L206_N1","L206_N2","RETAIL_RATE_COEF","L207_N0","FLOW_SIZE_MODE","L208_N0","L208_N1","RETAIL_SIZE_COEF","L208_N2","L209_N0","L210_N0","L226_N0","L229_N0","STALE_SLOW_WEIGHT","L233_N0","STALE_FAST_WEIGHT","L233_N1","L240_N0","L243_N0","RETAIL_BOOST_CAP","L251_N0","L251_N1","L266_N0","L266_N1","L267_N0","L267_N1","ATTRACT_CAP","L270_N0","L270_N1","L271_N0","L271_N1","L273_N0","L273_N1","L273_N2","L273_N3","L274_N0","L274_N1","L274_N2","L275_N0","L275_N1","L275_N2","L276_N0","L276_N1","L287_N0","VAR_FLOOR","L288_N0","L288_N1","L292_N0","L292_N1","POST_ELAPSED_CAP","L293_N0","L293_N1","L294_N0","L294_N1","L297_N0","L302_N0","L309_N0","L310_N0","L311_N0","RETAIL_NOISE","L313_N0","L315_N0","L317_N0","OBS_VAR","L320_N0","DENSITY_SCALE","DENSITY_POWER","L322_N0","L322_N1","ODDS_SCALE","L323_N0","LARGE_SIZE","L324_N0","LARGE_ODDS_MULT","L324_N1","L324_N2","L325_N0","SILENT_ODDS_MULT","L325_N1","L325_N2","L328_N0","L330_N0","MASS_FLOOR","L331_N0","L331_N1","L340_N0","L340_N1","L349_N0","L350_N0","L350_N1","THREE","L351_N0","L351_N1","L351_N2","ONE_WEI","L351_N3","L351_N4","Q_CENTER","L352_N0","L352_N1","L352_N2","Q_NEAR","L352_N3","L352_N4","L352_N5","Q_MID","L352_N6","L352_N7","L352_N8","L353_N0","L354_N0","L354_N1","FOUR","L355_N0","L357_N0","L357_N1","L359_N0","L361_N0","L361_N1","L363_N0","L363_N1","L364_N0","L374_N0","L375_N0","L375_N1","L377_N0","L385_N0","L390_N0","L390_N1","L393_N0","L394_N0","L394_N1","L394_N2","L394_N3","L395_N0","L395_N1","L395_N2","L395_N3","L396_N0","L396_N1","L396_N2","L396_N3","L397_N0","L397_N1","L397_N2","L397_N3","L398_N0","L398_N1","L398_N2","L398_N3","L399_N0","L399_N1","L399_N2","L399_N3","L400_N0","L400_N1","L400_N2","L401_N0","L402_N0","L403_N0","L404_N0","L405_N0","L406_N0","L407_N0"],"th_values":[1.0,0.1,0.0,0.0001,8.0,8.0,0.001538461538461538,650.0,0.75,7.5e+17,0.53,5.3e+17,0.53,5.3e+17,0.91,9.1e+17,0.69,6.9e+17,0.99,9.9e+17,0.828,8.28e+17,0.051,5.1e+16,0.985,9.85e+17,0.27,2.7e+17,0.06,6e+16,0.12,1.2e+17,0.0,0.0,4.0,4.0,7.2,7.2e+18,0.03,3e+16,0.35,3500.0,1.05,1.05e+18,0.02857142857142857,35.0,0.2,5.0,0.2,5.0,1.82,1.82e+18,64.0,64.0,0.0004,4.0,0.2,2e+17,0.0012,12.0,0.4842,4842.0,0.03,300.0,1.5,15000.0,9.1843,91843.0,0.002,20.0,0.01,100.0,0.685,6850.0,0.05,500.0,0.06,600.0,0.93,9.3e+17,0.85,8.5e+17,0.0,0.0,1.0,1.0,3.0,5.0,0.0,100.0,100.0,6.0,0.00095,950000000000000.0,7.0,0.8,8e+17,8.0,0.002,2000000000000000.0,15.0,0.4,4e+17,2000000000000000.0,160.0,13.0,9.025e-07,902500000000.0,14.0,5.0,0.0,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0,14.0,13.0,0.0,0.0,0.0,0.0001,100000000000000.0,100000000000000.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,1.0,0.8,8e+17,2.0,64.0,0.0,2.0,2.0,0.3,3e+17,0.0,0.0,1.0,12.0,0.0,1.0,12.0,1.0,2.0,0.0,11.0,0.003,30.0,0.0,30.0,30.0,0.9,90.0,100.0,0.1,10.0,100.0,2.0,64.0,0.0,0.0,13.0,14.0,0.0,0.0,0.25,4.0,4.0,2.0,2.0,2.0,0.0,0.0,0.0,1.0,0.3424067991934183,3.424067991934183e+17,0.0,15.0,80.0,160.0,0.0,4e+17,0.0,2000000000000000.0,3.0,3.0,3.0,0.999,9.99e+17,64.0,64.0,64.0,0.0,2.0,2.0,2.0,2.0,196.03088039613942,1.9603088039613943e+20,0.33333333333333337,3.333333333333334e+17,3.333333333333334e+17,9.99e+17,15.0,80.0,160.0,0.36638342491340714,3.6638342491340717e+17,2.0,2.0,0.0,1.8832961581192984,1.8832961581192983e+18,3.424067991934183e+17,3.424067991934183e+17,0.0,0.0,0.7,7e+17,0.3,3e+17,0.0,0.0,0.0016,16.0,16.0,30.0,30.0,30.0,30.0,0.0036,36.0,36.0,36.0,36.0,0.0,1.0,2.0,64.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0,0.0,1e-08,10000000000.0,10000000000.0,1.0,0.0,8.0,8.0,8.0,902500000000.0,1.0,902500000000.0,0.0,30.0,30.0,30.0,9e-06,9000000000000.0,0.0,0.0,2.25e-08,22500000000.0,8.0,4.0,8.0,4.0,0.004,4000000000000000.0,0.003,3000000000000000.0,0.4,4.0,10.0,1.0,0.8,8.0,10.0,0.0,2.0,0.01,100.0,100.0,100000000000000.0,100000000000000.0,3.0,0.0,7.0,3.0,3.0,3.0,3.0,1e-18,1.0,3.0,72.0,3.0,72.0,2.0,45.0,4.0,45.0,1.0,10.0,5.0,10.0,1.0,0.0,0.0,0.0,4.0,4.0,0.0,1.0,2.0,1.0,0.0,2.0,0.0,10000000000.0,0.0,1.0,1.0,1.0,0.0,0.0,0.0,1.0,128.0,0.0,128.0,64.0,64.0,0.0,64.0,32.0,32.0,0.0,32.0,16.0,16.0,0.0,16.0,8.0,8.0,0.0,8.0,4.0,4.0,0.0,4.0,2.0,2.0,0.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0],"slots":[{"index":0,"meaning":"previous bid fee (fraction)"},{"index":1,"meaning":"previous ask fee (fraction)"},{"index":2,"meaning":"last timestamp, low uint64 of Solidity slots[2], raw steps"},{"index":3,"meaning":"centered direction; 1 neutral, range [0,2]"},{"index":4,"meaning":"activity EMA"},{"index":5,"meaning":"slow inferred fair price pHat (Y/X)"},{"index":6,"meaning":"sigmaHat absolute-return EMA"},{"index":7,"meaning":"lambdaHat original trade-count rate estimate"},{"index":8,"meaning":"sizeHat original trade-ratio EMA"},{"index":9,"meaning":"toxicity EMA"},{"index":10,"meaning":"step trade count, capped at 64"},{"index":11,"meaning":"unused pre-price slot; read only if REVERT_U enabled (RS2 never writes)"},{"index":12,"meaning":"first-print sign: 1 up, 2 down"},{"index":13,"meaning":"posterior relative-price variance"},{"index":14,"meaning":"fast posterior mean (Y/X)"},{"index":15,"meaning":"retail-flow rate, low uint80 of Solidity slots[15]"},{"index":16,"meaning":"unused; zero on a fresh deployment"},{"index":17,"meaning":"unused; zero on a fresh deployment"},{"index":18,"meaning":"unused; zero on a fresh deployment"},{"index":19,"meaning":"unused; zero on a fresh deployment"},{"index":20,"meaning":"unused; zero on a fresh deployment"},{"index":21,"meaning":"unused; zero on a fresh deployment"},{"index":22,"meaning":"unused; zero on a fresh deployment"},{"index":23,"meaning":"unused; zero on a fresh deployment"},{"index":24,"meaning":"unused; zero on a fresh deployment"},{"index":25,"meaning":"unused; zero on a fresh deployment"},{"index":26,"meaning":"unused; zero on a fresh deployment"},{"index":27,"meaning":"unused; zero on a fresh deployment"},{"index":28,"meaning":"unused; zero on a fresh deployment"},{"index":29,"meaning":"unused; zero on a fresh deployment"},{"index":30,"meaning":"unused; zero on a fresh deployment"},{"index":31,"meaning":"unused; zero on a fresh deployment"},{"index":32,"meaning":"last post-trade spot, high bits (>>64) of Solidity slots[2]"},{"index":33,"meaning":"mean retail size, uint80(slots[15] >>160)"},{"index":34,"meaning":"weighted retail-flow count, uint80(slots[15] >>80)"},{"index":35,"meaning":"unused; zero on a fresh deployment"},{"index":36,"meaning":"unused; zero on a fresh deployment"},{"index":37,"meaning":"unused; zero on a fresh deployment"},{"index":38,"meaning":"unused; zero on a fresh deployment"},{"index":39,"meaning":"unused; zero on a fresh deployment"}],"th_convention":"Base named constants first (WAD=1, MAX_FEE=0.1, MIN_FEE=0, BPS=0.0001); then RS2 entries in source order. Named constants are evaluated in real units, except counts/multipliers which are unscaled. Interleaved L<source line>_N<zero-based literal ordinal> entries inventory every numeric literal, including indices, packing and square-root algorithm literals, in raw literal units. These audit entries are not independent tuning knobs. Named repeated constants are tied. Only named semantic entries are consumed by float calculations; index constants in Python address TH, not numeric strategy parameters.","diff_test":{"sequences":200,"swap_callbacks":400000,"initialization_callbacks":200,"callbacks":400200,"fee_comparisons":800400,"max_abs_fee_difference_bps":3.7855135692765884e-09,"mean_abs_fee_difference_bps":5.515070219688841e-12,"share_above_0_01_bps":0.0,"callback_share_above_0_01_bps":0.0,"first_divergence":null,"cause":null,"coverage":{"arb":95181,"retail":304819,"zero_trade_steps":39744,"same_step_callbacks":239968,"gap_gt_1":95751,"gap_gt_8":25741,"buy":200432,"sell":199568,"max_gap":43,"max_trades_per_step":4},"seed_start":310000,"seed_end":310199,"wall_seconds":59.454680470284075},"njit_compiles":true,"speed":{"python_to_njit_seconds":1.3218357362784445,"evm_adapter_seconds":37.33883620100096,"python_to_njit_callbacks_per_second":302760.76596835017,"evm_adapter_callbacks_per_second":10718.063033503751,"native_replay_callbacks":2000000,"native_replay_seconds":0.33566848188638687,"native_replay_callbacks_per_second":5958259.7352018785,"native_checksum":29247.22741782459,"warm_compile_excluded":true},"deviations":["Floored uint256 wmul/wdiv and intermediate integer divisions become float64 multiplication/division. WAD/650 and WAD/35 named defaults use the integer-evaluated constant divided by 1e18. Normal floating arithmetic introduces sub-ulp differences; no fastmath is enabled.","_isqrt(v*WAD) becomes math.sqrt(v) in real units. The Solidity floor can change normalized square roots by less than 1e-18. Quadrature moments, gates, sign checks, mixture likelihoods and tail fees may amplify rounding at branch boundaries; measured agreement is empirical, not a proof over all uint256 inputs.","Packed fields are separate float entries; uint64/uint80 masking, uint256 overflow/revert and packing overlap are not simulated. Raw integer timestamps/counts are exact only through 2**53. Ordinary market ranges were tested; adversarial overflow and singular price inputs are outside the replica domain.","Initializer mirrors only Solidity assignments and does not clear S. Supply a fresh np.zeros(40,dtype=np.float64) per market. amount_x is intentionally unused because RS2 only reads amountY/reserveY."],"notes":["Usage: save port_source verbatim as rs2_port.py; from rs2_port import *; S=np.zeros(40,dtype=np.float64); TH=TH_VALUES.copy(); bid,ask=strat_init(S,TH,x0,y0); bid,ask=strat_after(S,TH,is_buy,amount_x,amount_y,float(timestamp),reserve_x,reserve_y). Reserves, amounts and prices are real units; timestamp is raw simulation steps, NOT divided by 1e18. Buy means the AMM buys X (trader sells X). S updates in place; use returned fractions for the next fill.","Tested with CPython 3.12.16, numpy 2.5.4, numba 0.68.1, pyrevm 0.3.7, solc 0.8.24; repository compiler uses optimizer 200 runs, viaIR, Paris. Dependency packages are not embedded in this source-only JSON artifact; the importing market-replica runtime must provide numpy and numba.","Market stress test uses seeds 310000..310199; initial X log-uniform [100,10000], initial fair price log-uniform [20,500], sigma uniform [0.0003,0.006]. Log fair price is a random walk; step gaps sampled from [1,1,1,1,2,3,5,9]; 0..4 callbacks per step. The first fill arbitrages to the current fee band when profitable, otherwise retail; later fills are random retail with capped lognormal relative size. Constant-product reserves use fee-adjusted input, fees excluded from reserves. Even sequences use prior EVM fees to execute fills; odd sequences use prior port fees. Both receive the SAME WAD-quantized callback each time.","Max and mean errors aggregate both bid/ask fees over all 400200 callbacks (800400 comparisons), including initialization. First divergence means first error greater than 0.01 bps; none occurred. Adapter raises on EVM failure, and this run completed without exceptions; no EVM failure was suppressed. No strategy score or leaderboard gain is claimed.","Speed excludes compilation; Python dispatch timings cover individual calls; native speed times 1000 replays of the first 2000-swap sequence inside a njit loop. EVM adapter time includes callback encoding and pyrevm execution. These are local timings, not a deployment guarantee.","Offline source extraction: import base64,zlib; write zlib.decompress(base64.b64decode(result[\"contract_source_zlib_base64\"])) to RS2.sol. Its SHA-256 must equal rs2_source_sha256. Write port_source to rs2_port.py and differential_test_source to diff_test.py in the same scratch directory. Run the harness from the pinned checkout with its configured Python environment active. Test artifacts are written only beside the harness. Python packages must already be available; no network is used by the test."],"differential_test_source":"\"\"\"Run from checkout: . scratch/env.sh && python ../diff_test.py [sequences].\"\"\"\nimport sys, json, time, math, hashlib\nfrom pathlib import Path\nfrom decimal import Decimal\nimport numpy as np\nfrom numba import njit\nsys.path.insert(0,str(Path(__file__).parent))\nfrom rs2_port import TH_NAMES, TH_VALUES, strat_init, strat_after\nfrom amm_competition.evm.adapter import EVMStrategyAdapter\nfrom amm_competition.evm.compiler import SolidityCompiler\nfrom amm_competition.core.trade import TradeInfo\nP=Path(__file__).parent\nN=int(sys.argv[1]) if len(sys.argv)>1 else 200\nsource=(P/'RS2.sol').read_text()\nassert hashlib.sha256(source.encode()).hexdigest()=='f24b6ca198b744c380842c3a17964a6dc21f311bb04984b26733afa3fee8eaf2'\nt0=time.perf_counter(); c=SolidityCompiler().compile(source)\nassert c.success,c.errors\nprint('Compiled',len(c.bytecode),'bytes',time.perf_counter()-t0,flush=True)\nnp.savez(P/'compiled.npz',bytecode=np.frombuffer(c.bytecode,dtype=np.uint8))\ns=np.zeros(40); th=TH_VALUES.copy()\nstrat_init(s,th,100.,10000.)\nstrat_after(s,th,True,1.,99.,1.,101.,9901.)\nmaxerr=0.; sumerr=0.; over=0; callback_over=0; callbacks=0; first=None\nport_seconds=0.; evm_seconds=0.; events=[]; initial=[]\ncounts={'arb':0,'retail':0,'zero_trade_steps':0,'same_step_callbacks':0,'gap_gt_1':0,'gap_gt_8':0,'buy':0,'sell':0,'max_gap':0,'max_trades_per_step':0}\nstart=time.perf_counter()\nfor seq in range(N):\n    # Tuning-range seeds, not the held-out strategy evaluation block.\n    rng=np.random.default_rng(310000+seq)\n    x=float(np.exp(rng.uniform(np.log(100),np.log(10000))))\n    fair=float(np.exp(rng.uniform(np.log(20),np.log(500))))\n    y=x*fair\n    sigma=float(rng.uniform(.0003,.006))\n    adapter=EVMStrategyAdapter(c.bytecode,c.abi)\n    s=np.zeros(40); initial.append((x,y))\n    a=time.perf_counter();eq=adapter.after_initialize(Decimal(str(x)),Decimal(str(y)));evm_seconds+=time.perf_counter()-a\n    ef=(float(eq.bid_fee),float(eq.ask_fee))\n    a=time.perf_counter();pf=strat_init(s,th,x,y);port_seconds+=time.perf_counter()-a\n    er=np.abs(np.array(ef)-pf)*1e4\n    maxerr=max(maxerr,float(er.max()));sumerr+=float(er.sum());over+=int((er>.01).sum());callback_over+=int(er.max()>.01);callbacks+=1\n    timestamp=0; last_callback_ts=0; n=0\n    while n<2000:\n        delta=int(rng.choice([1,1,1,1,2,3,5,9]))\n        timestamp+=delta\n        fair*=math.exp(float(rng.normal(-.5*sigma*sigma*delta,sigma*math.sqrt(delta))))\n        slots=int(rng.integers(0,5))\n        if slots==0:\n            counts['zero_trade_steps']+=1\n            continue\n        step_trades=0\n        for j in range(slots):\n            if n==2000:break\n            # Alternate which implementation's previous quote drives fills.\n            bid,ask=ef if seq%2==0 else pf\n            old_x,old_y=x,y;k=x*y;spot=y/x\n            arb=False\n            if j==0 and spot*(1-bid)>fair:\n                buy=True;gamma=1-bid\n                x=math.sqrt(k/(fair/gamma));y=k/x\n                ax=(x-old_x)/gamma;ay=old_y-y;arb=True\n            elif j==0 and spot/(1-ask)<fair:\n                buy=False;gamma=1-ask\n                x=math.sqrt(k/(fair*gamma));y=k/x\n                ax=old_x-x;ay=(y-old_y)/gamma;arb=True\n            else:\n                buy=bool(rng.integers(0,2))\n                q=min(float(rng.lognormal(math.log(.0013),.95)),.06)\n                if buy:\n                    ax=old_x*q;x=old_x+ax*(1-bid);y=k/x;ay=old_y-y\n                else:\n                    ay=old_y*q;y=old_y+ay*(1-ask);x=k/y;ax=old_x-x\n            assert x>0 and y>0 and ax>0 and ay>0\n            # One canonical callback: EVM encodes floor(Decimal * WAD).\n            # Normalize those exact encoded integers for the float port.\n            decimals=[Decimal(str(v)) for v in (ax,ay,x,y)]\n            wad_values=[int(v*10**18) for v in decimals]\n            vals=[v/1e18 for v in wad_values]\n            trade=TradeInfo('buy' if buy else 'sell',decimals[0],decimals[1],timestamp,decimals[2],decimals[3])\n            a=time.perf_counter();ev=adapter.after_swap_wad(trade);evm_seconds+=time.perf_counter()-a\n            ef=(ev[0]/1e18,ev[1]/1e18)\n            a=time.perf_counter();pf=strat_after(s,th,buy,vals[0],vals[1],float(timestamp),vals[2],vals[3]);port_seconds+=time.perf_counter()-a\n            er=np.abs(np.array(ef)-pf)*1e4\n            if er.max()>.01 and first is None:\n                first={'sequence':seq,'callback':n,'timestamp':timestamp,'error_bps':er.tolist(),'evm':ef,'port':pf,'input':[buy,*vals[:2],timestamp,*vals[2:]],'state':s.tolist()}\n            maxerr=max(maxerr,float(er.max()));sumerr+=float(er.sum());over+=int((er>.01).sum());callback_over+=int(er.max()>.01);callbacks+=1\n            counts['arb' if arb else 'retail']+=1;counts['buy' if buy else 'sell']+=1\n            gap=timestamp-last_callback_ts;counts['max_gap']=max(counts['max_gap'],gap)\n            counts['same_step_callbacks']+=int(gap==0);counts['gap_gt_1']+=int(gap>1);counts['gap_gt_8']+=int(gap>8)\n            last_callback_ts=timestamp;n+=1;step_trades+=1\n            if seq==0: events.append((float(buy),vals[0],vals[1],float(timestamp),vals[2],vals[3]))\n        counts['max_trades_per_step']=max(counts['max_trades_per_step'],step_trades)\n    if seq%10==9:\n        print(seq+1,'sequences',callbacks,'callbacks','max_bps',maxerr,'above',over,'elapsed',time.perf_counter()-start,flush=True)\n\n@njit\ndef replay(events,th,x,y,repeats):\n    s=np.zeros(40);checksum=0.\n    for rep in range(repeats):\n        s[:]=0.;strat_init(s,th,x,y)\n        for i in range(events.shape[0]):\n            v=events[i]\n            b,a=strat_after(s,th,v[0]!=0.,v[1],v[2],v[3],v[4],v[5])\n            checksum+=b+a\n    return checksum\narr=np.asarray(events);x,y=initial[0]\nreplay(arr,th,x,y,1)\na=time.perf_counter();check=replay(arr,th,x,y,1000);native_time=time.perf_counter()-a\nresult={'sequences':N,'swap_callbacks':N*2000,'initialization_callbacks':N,'callbacks':callbacks,'fee_comparisons':callbacks*2,'max_abs_fee_difference_bps':maxerr,'mean_abs_fee_difference_bps':sumerr/(callbacks*2),'share_above_0_01_bps':over/(callbacks*2),'callback_share_above_0_01_bps':callback_over/callbacks,'first_divergence':first,'cause':None if first is None else 'Investigate before acceptance','coverage':counts,'seed_start':310000,'seed_end':310000+N-1,'njit_compiles':bool(strat_init.nopython_signatures and strat_after.nopython_signatures),'speed':{'python_to_njit_seconds':port_seconds,'evm_adapter_seconds':evm_seconds,'python_to_njit_callbacks_per_second':callbacks/port_seconds,'evm_adapter_callbacks_per_second':callbacks/evm_seconds,'native_replay_callbacks':len(events)*1000,'native_replay_seconds':native_time,'native_replay_callbacks_per_second':len(events)*1000/native_time,'native_checksum':check,'warm_compile_excluded':True},'wall_seconds':time.perf_counter()-start}\n(P/f'diff_{N}.json').write_text(json.dumps(result,indent=2));np.save(P/'events.npy',arr)\nprint(json.dumps(result,indent=2),flush=True)\n","source_refs":{"strategy":"https://api.imdnotdead.fun/artifacts/19f2ec857df536e8ab62ab1da89ec6623332521ce46849f15bccff402c63e1e5","wad_math":"https://raw.githubusercontent.com/benedictbrady/amm-challenge/6b6921f8d463314aa7c96234e1be25a25245f704/contracts/src/AMMStrategyBase.sol","evm_adapter":"https://raw.githubusercontent.com/benedictbrady/amm-challenge/6b6921f8d463314aa7c96234e1be25a25245f704/amm_competition/evm/adapter.py","compiler":"https://raw.githubusercontent.com/benedictbrady/amm-challenge/6b6921f8d463314aa7c96234e1be25a25245f704/amm_competition/evm/compiler.py","callback_execution":"https://raw.githubusercontent.com/benedictbrady/amm-challenge/6b6921f8d463314aa7c96234e1be25a25245f704/amm_competition/evm/executor.py","trade_fields":"https://raw.githubusercontent.com/benedictbrady/amm-challenge/6b6921f8d463314aa7c96234e1be25a25245f704/amm_competition/core/trade.py","constant_product_model":"https://raw.githubusercontent.com/benedictbrady/amm-challenge/6b6921f8d463314aa7c96234e1be25a25245f704/amm_competition/core/amm.py"},"contract_source_zlib_base64":"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"}