{"blocked": null, "port_source": "\"\"\"Python/numba port of RS2 (\"censored_10\" Strategy.sol, sha256 f24b6ca1...eaf2).\nAll WAD integers are float64 fractions (1e18 -> 1.0). wmul(x,y)=x*y, wdiv(x,y)=x/y: the floor\ndivisions of the EVM are dropped (error ~1e-18 per op); _isqrt(x*WAD) is math.sqrt. Branches are\nkept as in the Solidity. Solidity reverts (div by zero / underflow) are not modelled.\"\"\"\nimport math\nimport numpy as np\nfrom numba import njit\n\nTH_NAMES = ['ELAPSED_CAP', 'SIGNAL_THRESHOLD', 'DIR_DECAY', 'ACT_DECAY', 'SIZE_DECAY', 'TOX_DECAY', 'SIGMA_DECAY', 'LAMBDA_DECAY', 'SIZE_BLEND_DECAY', 'TOX_BLEND_DECAY', 'ACT_BLEND_DECAY', 'PHAT_ALPHA', 'PHAT_ALPHA_RETAIL', 'PHAT_ALPHA_SAME', 'REVERT_U', 'DIR_IMPACT_MULT', 'GATE_SIGMA_MULT', 'MIN_GATE', 'TRADE_TOX_BOOST', 'STALE_ATTRACT_FRAC', 'RET_CAP', 'TOX_CAP', 'TRADE_RATIO_CAP', 'LAMBDA_CAP', 'STEP_COUNT_CAP', 'BASE_FEE', 'SIGMA_COEF', 'LAMBDA_COEF', 'FLOW_SIZE_COEF', 'TOX_COEF', 'TOX_QUAD_COEF', 'ACT_COEF', 'DIR_COEF', 'DIR_TOX_COEF', 'STALE_DIR_COEF', 'SIGMA_TOX_COEF', 'TAIL_KNEE', 'TAIL_SLOPE_PROTECT', 'TAIL_SLOPE_ATTRACT', 'INIT_PRICE_DEFAULT', 'INIT_SIGMA', 'INIT_LAMBDA', 'INIT_SIZE', 'INIT_RATE', 'INIT_MEANSIZE', 'INIT_UNCERTAINTY', 'SILENT_MIN', 'SILENCE_G_CAP', 'SILENCE_W_BASE', 'SILENCE_SCALE_COEF', 'UNCERTAINTY_CAP', 'FEE_PIVOT', 'PHAT_INTERIOR_KEEP', 'PHAT_INTERIOR_NEW', 'DIR_PUSH_CAP', 'DIR_STATE_CAP', 'STALE_W_PHAT', 'STALE_W_FAST', 'FLOW_BLEND', 'FLOW_DEFAULT_RATE', 'FLOW_DEFAULT_MEANSIZE', 'FLOW_INST_CAP', 'FLOW_RETENTION_BASE', 'FLOW_RETENTION_CAP', 'FLOW_MODE', 'MISSING_COEF', 'MISSING_CAP', 'FLOW_LEARN_BASE', 'RETAIL_RATE_COEF', 'RETAIL_SIZE_COEF', 'FIRST_FEE_CAP', 'RETAIL_BOOST_CAP', 'FINAL_FEE_CAP', 'POST_V_FLOOR', 'POST_PROCESS_NOISE', 'POST_ELAPSED_CAP', 'POST_OBS_NOISE', 'POST_TOTALV_ADD', 'POST_Z_DIV', 'POST_DENSITY_POW', 'POST_ODDS_COEF', 'POST_BIGSIZE', 'POST_BIGSIZE_MULT', 'POST_SILENT_MULT', 'POST_MASS_MIN', 'POST_SD_MULT', 'POST_VAR_CAP', 'BAND_W_CENTER', 'BAND_W_NEAR', 'BAND_W_MID', 'BAND_W_FAR', 'BAND_LIK_COEF', 'BAND_VAR_FLOOR', 'BAND_MIN_PRICE', 'WAD', 'MAX_FEE', 'BPS']\nTH_VALUES = [8.0, 0.0015384615384615385, 0.75, 0.53, 0.53, 0.91, 0.69, 0.99, 0.828, 0.051, 0.985, 0.27, 0.06, 0.12, 0.0, 4.0, 7.2, 0.03, 0.35, 1.05, 0.02857142857142857, 0.2, 0.2, 1.82, 64.0, 0.0004, 0.2, 0.0012, 0.4842, 0.03, 1.5, 9.1843, 0.002, 0.01, 0.685, 0.05, 0.06, 0.93, 0.85, 100.0, 0.00095, 0.8, 0.002, 0.4, 0.002, 9.025e-07, 1.0, 1.0, 0.8, 0.3, 0.0001, 0.003, 0.9, 0.1, 0.25, 2.0, 0.7, 0.3, 0.3424067991934183, 0.4, 0.002, 3.0, 0.999, 64.0, 2.0, 196.03088039613942, 0.33333333333333337, 0.999, 0.36638342491340714, 1.8832961581192984, 0.003, 0.0016, 0.0036, 1e-08, 9.025e-07, 8.0, 9e-06, 2.25e-08, 8.0, 4.0, 0.004, 0.003, 0.4, 0.8, 0.01, 2.0, 0.0001, 72.0, 45.0, 10.0, 1.0, 4.0, 1e-08, 1e-18, 1.0, 0.1, 0.0001]\nTH = np.array(TH_VALUES, dtype=np.float64)\nK_ELAPSED_CAP = 0\nK_SIGNAL_THRESHOLD = 1\nK_DIR_DECAY = 2\nK_ACT_DECAY = 3\nK_SIZE_DECAY = 4\nK_TOX_DECAY = 5\nK_SIGMA_DECAY = 6\nK_LAMBDA_DECAY = 7\nK_SIZE_BLEND_DECAY = 8\nK_TOX_BLEND_DECAY = 9\nK_ACT_BLEND_DECAY = 10\nK_PHAT_ALPHA = 11\nK_PHAT_ALPHA_RETAIL = 12\nK_PHAT_ALPHA_SAME = 13\nK_REVERT_U = 14\nK_DIR_IMPACT_MULT = 15\nK_GATE_SIGMA_MULT = 16\nK_MIN_GATE = 17\nK_TRADE_TOX_BOOST = 18\nK_STALE_ATTRACT_FRAC = 19\nK_RET_CAP = 20\nK_TOX_CAP = 21\nK_TRADE_RATIO_CAP = 22\nK_LAMBDA_CAP = 23\nK_STEP_COUNT_CAP = 24\nK_BASE_FEE = 25\nK_SIGMA_COEF = 26\nK_LAMBDA_COEF = 27\nK_FLOW_SIZE_COEF = 28\nK_TOX_COEF = 29\nK_TOX_QUAD_COEF = 30\nK_ACT_COEF = 31\nK_DIR_COEF = 32\nK_DIR_TOX_COEF = 33\nK_STALE_DIR_COEF = 34\nK_SIGMA_TOX_COEF = 35\nK_TAIL_KNEE = 36\nK_TAIL_SLOPE_PROTECT = 37\nK_TAIL_SLOPE_ATTRACT = 38\nK_INIT_PRICE_DEFAULT = 39\nK_INIT_SIGMA = 40\nK_INIT_LAMBDA = 41\nK_INIT_SIZE = 42\nK_INIT_RATE = 43\nK_INIT_MEANSIZE = 44\nK_INIT_UNCERTAINTY = 45\nK_SILENT_MIN = 46\nK_SILENCE_G_CAP = 47\nK_SILENCE_W_BASE = 48\nK_SILENCE_SCALE_COEF = 49\nK_UNCERTAINTY_CAP = 50\nK_FEE_PIVOT = 51\nK_PHAT_INTERIOR_KEEP = 52\nK_PHAT_INTERIOR_NEW = 53\nK_DIR_PUSH_CAP = 54\nK_DIR_STATE_CAP = 55\nK_STALE_W_PHAT = 56\nK_STALE_W_FAST = 57\nK_FLOW_BLEND = 58\nK_FLOW_DEFAULT_RATE = 59\nK_FLOW_DEFAULT_MEANSIZE = 60\nK_FLOW_INST_CAP = 61\nK_FLOW_RETENTION_BASE = 62\nK_FLOW_RETENTION_CAP = 63\nK_FLOW_MODE = 64\nK_MISSING_COEF = 65\nK_MISSING_CAP = 66\nK_FLOW_LEARN_BASE = 67\nK_RETAIL_RATE_COEF = 68\nK_RETAIL_SIZE_COEF = 69\nK_FIRST_FEE_CAP = 70\nK_RETAIL_BOOST_CAP = 71\nK_FINAL_FEE_CAP = 72\nK_POST_V_FLOOR = 73\nK_POST_PROCESS_NOISE = 74\nK_POST_ELAPSED_CAP = 75\nK_POST_OBS_NOISE = 76\nK_POST_TOTALV_ADD = 77\nK_POST_Z_DIV = 78\nK_POST_DENSITY_POW = 79\nK_POST_ODDS_COEF = 80\nK_POST_BIGSIZE = 81\nK_POST_BIGSIZE_MULT = 82\nK_POST_SILENT_MULT = 83\nK_POST_MASS_MIN = 84\nK_POST_SD_MULT = 85\nK_POST_VAR_CAP = 86\nK_BAND_W_CENTER = 87\nK_BAND_W_NEAR = 88\nK_BAND_W_MID = 89\nK_BAND_W_FAR = 90\nK_BAND_LIK_COEF = 91\nK_BAND_VAR_FLOOR = 92\nK_BAND_MIN_PRICE = 93\nK_WAD = 94\nK_MAX_FEE = 95\nK_BPS = 96\n\n# ---- state layout S (float64[40]); slot index = Solidity slots[] index ----\nS_BID, S_ASK, S_LASTTS, S_DIR, S_ACT, S_PHAT, S_SIGMA, S_LAMBDA, S_SIZE, S_TOX, S_COUNT_STEP = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10\nS_PRE, S_D1, S_UNC, S_FAST = 11, 12, 13, 14\nS_RATE, S_FLOWCOUNT, S_MEANSIZE = 15, 16, 17      # slots[15] packed: rate | count<<80 | meanSize<<160\nS_LASTSPOT = 18                                    # slots[2] >> 64\nSLOTS = [\n    (0, \"prevBidFee\"), (1, \"prevAskFee\"), (2, \"lastTs (low 64 bits of slots[2])\"), (3, \"dirState\"), (4, \"actEma\"),\n    (5, \"pHat\"), (6, \"sigmaHat\"), (7, \"lambdaHat\"), (8, \"sizeHat\"), (9, \"toxEma\"), (10, \"stepTradeCount\"),\n    (11, \"pre (unused: only read when REVERT_U>0)\"), (12, \"d1 first-trade direction of step (0/1/2)\"),\n    (13, \"uncertainty (posterior variance)\"), (14, \"fastHat (posterior mean)\"),\n    (15, \"flow rate (slots[15] bits 0..79)\"), (16, \"flow count (slots[15] bits 80..159)\"),\n    (17, \"flow meanSize (slots[15] bits 160..239)\"), (18, \"lastSpot (slots[2] >> 64)\"),\n]\n\n\n@njit(cache=False)\ndef _pow(factor, e):\n    # _powWad: exponentiation by squaring, e integer\n    result = 1.0\n    n = int(e)\n    while n > 0:\n        if n & 1 == 1:\n            result = result * factor\n        factor = factor * factor\n        n >>= 1\n    return result\n\n\n@njit(cache=False)\ndef _blend(a, b, w):\n    if b >= a:\n        return a + (b - a) * w\n    return a - (a - b) * w\n\n\n@njit(cache=False)\ndef _absd(a, b):\n    return a - b if a > b else b - a\n\n\n@njit(cache=False)\ndef _sqrt(x):\n    # Solidity _isqrt(x*WAD) on WAD values == floor(sqrt) in WAD; float sqrt (rounding ~1e-18 ignored)\n    if x <= 0.0:\n        return 0.0\n    return math.sqrt(x)\n\n\n@njit(cache=False)\ndef _band(T, mu, v, lo, hi):\n    sd = mu * _sqrt(v)\n    a0 = 0.0\n    a1 = 0.0\n    a2 = 0.0\n    for j in range(7):\n        if j < 3:\n            k = 3 - j\n            p = mu - k * sd if mu > k * sd else T[K_BAND_MIN_PRICE]\n        else:\n            p = mu + (j - 3) * sd\n        if j == 3:\n            w = T[K_BAND_W_CENTER]\n        elif j == 2 or j == 4:\n            w = T[K_BAND_W_NEAR]\n        elif j == 1 or j == 5:\n            w = T[K_BAND_W_MID]\n        else:\n            w = T[K_BAND_W_FAR]\n        if p < lo:\n            distance = lo - p\n        elif p > hi:\n            distance = p - hi\n        else:\n            distance = 0.0\n        z = distance / sd if sd > 0.0 else 0.0\n        lik = 1.0 / (1.0 + T[K_BAND_LIK_COEF] * z * z)\n        w = w * lik\n        a0 += w\n        a1 += w * p\n        d = _absd(p, mu) / mu\n        a2 += w * (d * d)\n    m = a1 / a0\n    d = _absd(m, mu) / mu\n    second = a2 / a0\n    if second > d * d:\n        return m, second - d * d\n    return m, T[K_BAND_VAR_FLOOR]\n\n\n@njit(cache=False)\ndef _posterior(T, mu, v, obs, spot, preSpot, bid, ask, first, silent, buy, size):\n    if mu == 0.0:\n        mu = spot\n    if v < T[K_POST_V_FLOOR]:\n        v = T[K_POST_V_FLOOR]\n    lo = preSpot * (1.0 - bid)\n    hi = preSpot / (1.0 - ask)\n    if first:\n        if silent > T[K_SILENT_MIN] and preSpot > 0.0:\n            elapsed = T[K_POST_ELAPSED_CAP] if silent > T[K_POST_ELAPSED_CAP] else silent\n            v += T[K_POST_PROCESS_NOISE] * (elapsed - 1.0)\n            mu, v = _band(T, mu, v, lo, hi)\n        v += T[K_POST_PROCESS_NOISE]\n    mRetail = mu\n    vRetail = v\n    if first and preSpot > 0.0:\n        mRetail, vRetail = _band(T, mu, v, lo, hi)\n    if not first:\n        fee = bid if buy else ask\n        if fee > T[K_FEE_PIVOT]:\n            if buy:\n                normal = spot * (1.0 - fee) / (1.0 - T[K_FEE_PIVOT])\n            else:\n                normal = spot * (1.0 - T[K_FEE_PIVOT]) / (1.0 - fee)\n            residual = _absd(normal, mu) / mu\n            noise = T[K_POST_OBS_NOISE] + residual * residual\n            k = v / (v + noise)\n            return _blend(mu, normal, k), v * (1.0 - k), 0.0\n        return mu, v, 0.0\n    e = _absd(obs, mu) / mu\n    totalV = v + T[K_POST_TOTALV_ADD]\n    z = (e * e) / totalV\n    density = _pow(1.0 / (1.0 + z / T[K_POST_Z_DIV]), T[K_POST_DENSITY_POW])\n    odds = density * (T[K_POST_ODDS_COEF] / _sqrt(totalV))\n    if size > T[K_POST_BIGSIZE]:\n        odds = odds * T[K_POST_BIGSIZE_MULT]\n    if silent > T[K_SILENT_MIN]:\n        odds = odds * T[K_POST_SILENT_MULT]\n    sd = _sqrt(v)\n    width = (hi - lo) / mu\n    if mu < lo:\n        distance = lo - mu\n    elif mu > hi:\n        distance = mu - hi\n    else:\n        distance = 0.0\n    zBand = (distance / mu) / sd\n    mass = (width / (width + T[K_POST_SD_MULT] * sd)) * (1.0 / (1.0 + zBand * zBand))\n    if mass < T[K_POST_MASS_MIN]:\n        mass = T[K_POST_MASS_MIN]\n    odds = odds / mass\n    prob = odds / (1.0 + odds)\n    kArb = v / totalV\n    mArb = _blend(mu, obs, kArb)\n    mean = _blend(mRetail, mArb, prob)\n    between = _absd(mArb, mRetail) / mu\n    variance = prob * (v * (1.0 - kArb)) + (1.0 - prob) * vRetail + (prob * (1.0 - prob)) * (between * between)\n    if variance > T[K_POST_VAR_CAP]:\n        variance = T[K_POST_VAR_CAP]\n    return mean, variance, prob\n\n\n@njit(cache=False)\ndef _compress(T, fee, slope):\n    if fee <= T[K_TAIL_KNEE]:\n        return fee\n    return T[K_TAIL_KNEE] + (fee - T[K_TAIL_KNEE]) * slope\n\n\n@njit(cache=False)\ndef _clampfee(T, f):\n    if f < 0.0:\n        return 0.0\n    if f > T[K_MAX_FEE]:\n        return T[K_MAX_FEE]\n    return f\n\n\n@njit(cache=False)\ndef strat_init(S, TH, x0, y0):\n    for i in range(S.shape[0]):\n        S[i] = 0.0\n    T = TH\n    S[S_BID] = T[K_BASE_FEE]\n    S[S_ASK] = T[K_BASE_FEE]\n    S[S_DIR] = 1.0\n    S[S_PHAT] = y0 / x0 if x0 > 0.0 else T[K_INIT_PRICE_DEFAULT]\n    S[S_SIGMA] = T[K_INIT_SIGMA]\n    S[S_LAMBDA] = T[K_INIT_LAMBDA]\n    S[S_SIZE] = T[K_INIT_SIZE]\n    S[S_RATE] = T[K_INIT_RATE]\n    S[S_FLOWCOUNT] = 0.0\n    S[S_MEANSIZE] = T[K_INIT_MEANSIZE]\n    S[S_UNC] = T[K_INIT_UNCERTAINTY]\n    S[S_FAST] = S[S_PHAT]\n    return T[K_BASE_FEE], T[K_BASE_FEE]\n\n\n@njit(cache=False)\ndef strat_after(S, TH, is_buy, amount_x, amount_y, timestamp, reserve_x, reserve_y):\n    T = TH\n    BPSV = T[K_BPS]\n    prevBidFee = S[S_BID]\n    prevAskFee = S[S_ASK]\n    lastTs = S[S_LASTTS]\n    dirState = S[S_DIR]\n    actEma = S[S_ACT]\n    pHat = S[S_PHAT]\n    sigmaHat = S[S_SIGMA]\n    lambdaHat = S[S_LAMBDA]\n    sizeHat = S[S_SIZE]\n    toxEma = S[S_TOX]\n    stepTradeCount = S[S_COUNT_STEP]\n    isBuy = is_buy > 0.5\n\n    fastHat = S[S_FAST]\n    uncertainty = S[S_UNC]\n    silent = timestamp - lastTs if timestamp > lastTs else 0.0\n    isNewStep = timestamp > lastTs\n    if isNewStep:\n        elapsedRaw = timestamp - lastTs\n        elapsed = T[K_ELAPSED_CAP] if elapsedRaw > T[K_ELAPSED_CAP] else elapsedRaw\n        # _decayCentered\n        mul = _pow(T[K_DIR_DECAY], elapsed)\n        if dirState >= 1.0:\n            dirState = 1.0 + (dirState - 1.0) * mul\n        else:\n            below = (1.0 - dirState) * mul\n            dirState = 1.0 - below if below < 1.0 else 0.0\n        actEma = actEma * _pow(T[K_ACT_DECAY], elapsed)\n        sizeHat = sizeHat * _pow(T[K_SIZE_DECAY], elapsed)\n        toxEma = toxEma * _pow(T[K_TOX_DECAY], elapsed)\n        if stepTradeCount > 0.0 and elapsedRaw > 0.0:\n            lambdaInst = stepTradeCount / elapsedRaw\n            if lambdaInst > T[K_LAMBDA_CAP]:\n                lambdaInst = T[K_LAMBDA_CAP]\n            lambdaHat = lambdaHat * T[K_LAMBDA_DECAY] + lambdaInst * (1.0 - T[K_LAMBDA_DECAY])\n        if uncertainty > T[K_UNCERTAINTY_CAP]:\n            uncertainty = T[K_UNCERTAINTY_CAP]\n        stepTradeCount = 0.0\n\n    firstInStep = stepTradeCount == 0.0\n    spot = reserve_y / reserve_x if reserve_x > 0.0 else pHat\n    if pHat == 0.0:\n        pHat = spot\n\n    feeUsed = prevBidFee if isBuy else prevAskFee\n    gamma = 1.0 - feeUsed if feeUsed < 1.0 else 0.0\n    if gamma == 0.0:\n        pImplied = spot\n    else:\n        pImplied = spot * gamma if isBuy else spot / gamma\n\n    silenceScale = 1.0\n    if firstInStep and silent > T[K_SILENT_MIN]:\n        g = silent - 1.0\n        if g > T[K_SILENCE_G_CAP]:\n            g = T[K_SILENCE_G_CAP]\n        w = 1.0 - _pow(T[K_SILENCE_W_BASE], g)\n        s = S[S_LASTSPOT]\n        if s == 0.0:\n            s = pHat\n        c = (s * (1.0 - prevBidFee) + s / (1.0 - prevAskFee)) / 2.0\n        if c >= pHat:\n            pHat += w * (c - pHat)\n        else:\n            pHat -= w * (pHat - c)\n        silenceScale = 1.0 - T[K_SILENCE_SCALE_COEF] * w\n\n    ret = _absd(pImplied, pHat) / pHat if pHat > 0.0 else 0.0\n    alpha = T[K_PHAT_ALPHA] if firstInStep else T[K_PHAT_ALPHA_RETAIL]\n    secondPrint = (not firstInStep) and stepTradeCount == 1.0\n    sameDir = False\n    oppDir = False\n    if secondPrint:\n        up2 = pImplied >= pHat\n        d1 = S[S_D1]\n        if d1 != 0.0:\n            sameDir = (d1 == 1.0) == up2\n            oppDir = not sameDir\n        if sameDir:\n            alpha = T[K_PHAT_ALPHA_SAME]\n    if firstInStep:\n        S[S_D1] = 1.0 if pImplied >= pHat else 2.0\n    adaptiveGate = sigmaHat * T[K_GATE_SIGMA_MULT]\n    if adaptiveGate < T[K_MIN_GATE]:\n        adaptiveGate = T[K_MIN_GATE]\n    alpha = alpha * silenceScale\n    adaptiveGate = adaptiveGate * silenceScale\n    if ret <= adaptiveGate:\n        pHat = pHat * (1.0 - alpha) + pImplied * alpha\n    if oppDir and T[K_REVERT_U] > 0.0:\n        pre = S[S_PRE]\n        if pre > pHat:\n            pHat = pHat + (pre - pHat) * T[K_REVERT_U]\n        else:\n            pHat = pHat - (pHat - pre) * T[K_REVERT_U]\n    if firstInStep:\n        if ret > T[K_RET_CAP]:\n            ret = T[K_RET_CAP]\n        sigmaHat = sigmaHat * T[K_SIGMA_DECAY] + ret * (1.0 - T[K_SIGMA_DECAY])\n\n    if (not firstInStep) and feeUsed > T[K_FEE_PIVOT] and gamma > 0.0:\n        if isBuy:\n            normalSpot = (spot * gamma) / (1.0 - T[K_FEE_PIVOT])\n        else:\n            normalSpot = (spot * (1.0 - T[K_FEE_PIVOT])) / gamma\n        pHat = pHat * T[K_PHAT_INTERIOR_KEEP] + normalSpot * T[K_PHAT_INTERIOR_NEW]\n\n    tr0 = amount_y / reserve_y if reserve_y > 0.0 else 0.0\n    fastHat, uncertainty, arbProbability = _posterior(\n        T, fastHat, uncertainty, pImplied, spot, S[S_LASTSPOT],\n        prevBidFee, prevAskFee, firstInStep, silent, isBuy, tr0)\n    S[S_UNC] = uncertainty\n    S[S_FAST] = fastHat\n    tradeRatio = tr0\n    if tradeRatio > T[K_TRADE_RATIO_CAP]:\n        tradeRatio = T[K_TRADE_RATIO_CAP]\n\n    if tradeRatio > T[K_SIGNAL_THRESHOLD]:\n        push = tradeRatio * T[K_DIR_IMPACT_MULT]\n        if push > T[K_DIR_PUSH_CAP]:\n            push = T[K_DIR_PUSH_CAP]\n        if isBuy:\n            dirState = dirState + push\n            if dirState > T[K_DIR_STATE_CAP]:\n                dirState = T[K_DIR_STATE_CAP]\n        else:\n            dirState = dirState - push if dirState > push else 0.0\n        actEma = actEma * T[K_ACT_BLEND_DECAY] + tradeRatio * (1.0 - T[K_ACT_BLEND_DECAY])\n        sizeHat = sizeHat * T[K_SIZE_BLEND_DECAY] + tradeRatio * (1.0 - T[K_SIZE_BLEND_DECAY])\n        if sizeHat > 1.0:\n            sizeHat = 1.0\n\n    tox = _absd(spot, pHat) / pHat if pHat > 0.0 else 0.0\n    if tox > T[K_TOX_CAP]:\n        tox = T[K_TOX_CAP]\n    toxEma = toxEma * T[K_TOX_BLEND_DECAY] + tox * (1.0 - T[K_TOX_BLEND_DECAY])\n    toxSignal = toxEma\n\n    stepTradeCount = stepTradeCount + 1.0\n    if stepTradeCount > T[K_STEP_COUNT_CAP]:\n        stepTradeCount = T[K_STEP_COUNT_CAP]\n\n    originalLambda = lambdaHat\n    originalSize = sizeHat\n\n    if T[K_FLOW_BLEND] > 0.0:\n        rate = S[S_RATE]\n        count = S[S_FLOWCOUNT]\n        meanSize = S[S_MEANSIZE]\n        if rate == 0.0:\n            rate = T[K_FLOW_DEFAULT_RATE]\n        if meanSize == 0.0:\n            meanSize = T[K_FLOW_DEFAULT_MEANSIZE]\n        if isNewStep:\n            inst = count / silent\n            if inst > T[K_FLOW_INST_CAP]:\n                inst = T[K_FLOW_INST_CAP]\n            retention = _pow(T[K_FLOW_RETENTION_BASE], T[K_FLOW_RETENTION_CAP] if silent > T[K_FLOW_RETENTION_CAP] else silent)\n            rate = rate * retention + inst * (1.0 - retention)\n            count = 0.0\n        weight = (1.0 - arbProbability) if firstInStep else 1.0\n        correctedWeight = weight\n        if T[K_FLOW_MODE] == 2.0:\n            missing = feeUsed * T[K_MISSING_COEF]\n            if missing > T[K_MISSING_CAP]:\n                missing = T[K_MISSING_CAP]\n            correctedWeight = weight / (1.0 - missing)\n        count += correctedWeight\n        learning = (1.0 - T[K_FLOW_LEARN_BASE]) * weight\n        meanSize = _blend(meanSize, tradeRatio, learning)\n        S[S_RATE] = rate\n        S[S_FLOWCOUNT] = count\n        S[S_MEANSIZE] = meanSize\n        retailRate = rate * T[K_RETAIL_RATE_COEF]\n        retailSize = sizeHat if T[K_FLOW_MODE] == 0.0 else meanSize * T[K_RETAIL_SIZE_COEF]\n        lambdaHat = _blend(lambdaHat, retailRate, T[K_FLOW_BLEND])\n        sizeHat = _blend(sizeHat, retailSize, T[K_FLOW_BLEND])\n    flowSize = lambdaHat * sizeHat\n    fBase = T[K_BASE_FEE] + T[K_SIGMA_COEF] * sigmaHat + T[K_LAMBDA_COEF] * lambdaHat + T[K_FLOW_SIZE_COEF] * flowSize\n    fMid = fBase + T[K_TOX_COEF] * toxSignal + T[K_TOX_QUAD_COEF] * (toxSignal * toxSignal) + T[K_ACT_COEF] * actEma\n    fMid = fMid + T[K_SIGMA_TOX_COEF] * (sigmaHat * toxSignal)\n\n    lambdaHat = originalLambda\n    sizeHat = originalSize\n    if dirState >= 1.0:\n        dirDev = dirState - 1.0\n        sellPressure = True\n    else:\n        dirDev = 1.0 - dirState\n        sellPressure = False\n\n    skew = T[K_DIR_COEF] * dirDev + T[K_DIR_TOX_COEF] * (dirDev * toxSignal)\n    if sellPressure:\n        bidFee = fMid + skew\n        askFee = fMid - skew if fMid > skew else 0.0\n    else:\n        askFee = fMid + skew\n        bidFee = fMid - skew if fMid > skew else 0.0\n\n    staleHat = pHat * T[K_STALE_W_PHAT] + fastHat * T[K_STALE_W_FAST]\n    staleTox = _absd(spot, staleHat) / staleHat\n    if staleTox > T[K_TOX_CAP]:\n        staleTox = T[K_TOX_CAP]\n    staleShift = T[K_STALE_DIR_COEF] * staleTox\n    attractShift = staleShift * T[K_STALE_ATTRACT_FRAC]\n    if spot >= staleHat:\n        bidFee = bidFee + staleShift\n        askFee = askFee - attractShift if askFee > attractShift else 0.0\n    else:\n        askFee = askFee + staleShift\n        bidFee = bidFee - attractShift if bidFee > attractShift else 0.0\n\n    tradeAligned = (isBuy and spot >= pHat) or ((not isBuy) and spot < pHat)\n    if tradeAligned:\n        tradeBoost = T[K_TRADE_TOX_BOOST] * tradeRatio\n        if (not firstInStep) and tradeBoost > T[K_RETAIL_BOOST_CAP]:\n            tradeBoost = T[K_RETAIL_BOOST_CAP]\n        if isBuy:\n            bidFee = bidFee + tradeBoost\n        else:\n            askFee = askFee + tradeBoost\n\n    if sellPressure:\n        bidFee = _clampfee(T, _compress(T, bidFee, T[K_TAIL_SLOPE_PROTECT]))\n        askFee = _clampfee(T, _compress(T, askFee, T[K_TAIL_SLOPE_ATTRACT]))\n    else:\n        askFee = _clampfee(T, _compress(T, askFee, T[K_TAIL_SLOPE_PROTECT]))\n        bidFee = _clampfee(T, _compress(T, bidFee, T[K_TAIL_SLOPE_ATTRACT]))\n\n    if firstInStep:\n        if askFee > bidFee and bidFee > T[K_FIRST_FEE_CAP]:\n            bidFee = T[K_FIRST_FEE_CAP]\n        elif bidFee > askFee and askFee > T[K_FIRST_FEE_CAP]:\n            askFee = T[K_FIRST_FEE_CAP]\n\n    if bidFee > askFee and askFee > T[K_FINAL_FEE_CAP]:\n        askFee = T[K_FINAL_FEE_CAP]\n    elif askFee > bidFee and bidFee > T[K_FINAL_FEE_CAP]:\n        bidFee = T[K_FINAL_FEE_CAP]\n\n    S[S_BID] = bidFee\n    S[S_ASK] = askFee\n    S[S_LASTTS] = timestamp\n    S[S_LASTSPOT] = spot\n    S[S_DIR] = dirState\n    S[S_ACT] = actEma\n    S[S_PHAT] = pHat\n    S[S_SIGMA] = sigmaHat\n    S[S_LAMBDA] = lambdaHat\n    S[S_SIZE] = sizeHat\n    S[S_TOX] = toxEma\n    S[S_COUNT_STEP] = stepTradeCount\n    return bidFee, askFee\n", "th_names": ["ELAPSED_CAP", "SIGNAL_THRESHOLD", "DIR_DECAY", "ACT_DECAY", "SIZE_DECAY", "TOX_DECAY", "SIGMA_DECAY", "LAMBDA_DECAY", "SIZE_BLEND_DECAY", "TOX_BLEND_DECAY", "ACT_BLEND_DECAY", "PHAT_ALPHA", "PHAT_ALPHA_RETAIL", "PHAT_ALPHA_SAME", "REVERT_U", "DIR_IMPACT_MULT", "GATE_SIGMA_MULT", "MIN_GATE", "TRADE_TOX_BOOST", "STALE_ATTRACT_FRAC", "RET_CAP", "TOX_CAP", "TRADE_RATIO_CAP", "LAMBDA_CAP", "STEP_COUNT_CAP", "BASE_FEE", "SIGMA_COEF", "LAMBDA_COEF", "FLOW_SIZE_COEF", "TOX_COEF", "TOX_QUAD_COEF", "ACT_COEF", "DIR_COEF", "DIR_TOX_COEF", "STALE_DIR_COEF", "SIGMA_TOX_COEF", "TAIL_KNEE", "TAIL_SLOPE_PROTECT", "TAIL_SLOPE_ATTRACT", "INIT_PRICE_DEFAULT", "INIT_SIGMA", "INIT_LAMBDA", "INIT_SIZE", "INIT_RATE", "INIT_MEANSIZE", "INIT_UNCERTAINTY", "SILENT_MIN", "SILENCE_G_CAP", "SILENCE_W_BASE", "SILENCE_SCALE_COEF", "UNCERTAINTY_CAP", "FEE_PIVOT", "PHAT_INTERIOR_KEEP", "PHAT_INTERIOR_NEW", "DIR_PUSH_CAP", "DIR_STATE_CAP", "STALE_W_PHAT", "STALE_W_FAST", "FLOW_BLEND", "FLOW_DEFAULT_RATE", "FLOW_DEFAULT_MEANSIZE", "FLOW_INST_CAP", "FLOW_RETENTION_BASE", "FLOW_RETENTION_CAP", "FLOW_MODE", "MISSING_COEF", "MISSING_CAP", "FLOW_LEARN_BASE", "RETAIL_RATE_COEF", "RETAIL_SIZE_COEF", "FIRST_FEE_CAP", "RETAIL_BOOST_CAP", "FINAL_FEE_CAP", "POST_V_FLOOR", "POST_PROCESS_NOISE", "POST_ELAPSED_CAP", "POST_OBS_NOISE", "POST_TOTALV_ADD", "POST_Z_DIV", "POST_DENSITY_POW", "POST_ODDS_COEF", "POST_BIGSIZE", "POST_BIGSIZE_MULT", "POST_SILENT_MULT", "POST_MASS_MIN", "POST_SD_MULT", "POST_VAR_CAP", "BAND_W_CENTER", "BAND_W_NEAR", "BAND_W_MID", "BAND_W_FAR", "BAND_LIK_COEF", "BAND_VAR_FLOOR", "BAND_MIN_PRICE", "WAD", "MAX_FEE", "BPS"], "th_values": [8.0, 0.0015384615384615385, 0.75, 0.53, 0.53, 0.91, 0.69, 0.99, 0.828, 0.051, 0.985, 0.27, 0.06, 0.12, 0.0, 4.0, 7.2, 0.03, 0.35, 1.05, 0.02857142857142857, 0.2, 0.2, 1.82, 64.0, 0.0004, 0.2, 0.0012, 0.4842, 0.03, 1.5, 9.1843, 0.002, 0.01, 0.685, 0.05, 0.06, 0.93, 0.85, 100.0, 0.00095, 0.8, 0.002, 0.4, 0.002, 9.025e-07, 1.0, 1.0, 0.8, 0.3, 0.0001, 0.003, 0.9, 0.1, 0.25, 2.0, 0.7, 0.3, 0.3424067991934183, 0.4, 0.002, 3.0, 0.999, 64.0, 2.0, 196.03088039613942, 0.33333333333333337, 0.999, 0.36638342491340714, 1.8832961581192984, 0.003, 0.0016, 0.0036, 1e-08, 9.025e-07, 8.0, 9e-06, 2.25e-08, 8.0, 4.0, 0.004, 0.003, 0.4, 0.8, 0.01, 2.0, 0.0001, 72.0, 45.0, 10.0, 1.0, 4.0, 1e-08, 1e-18, 1.0, 0.1, 0.0001], "slots": [{"index": 0, "meaning": "prevBidFee"}, {"index": 1, "meaning": "prevAskFee"}, {"index": 2, "meaning": "lastTs (low 64 bits of slots[2])"}, {"index": 3, "meaning": "dirState"}, {"index": 4, "meaning": "actEma"}, {"index": 5, "meaning": "pHat"}, {"index": 6, "meaning": "sigmaHat"}, {"index": 7, "meaning": "lambdaHat"}, {"index": 8, "meaning": "sizeHat"}, {"index": 9, "meaning": "toxEma"}, {"index": 10, "meaning": "stepTradeCount"}, {"index": 11, "meaning": "pre (unused: only read when REVERT_U>0)"}, {"index": 12, "meaning": "d1 first-trade direction of step (0/1/2)"}, {"index": 13, "meaning": "uncertainty (posterior variance)"}, {"index": 14, "meaning": "fastHat (posterior mean)"}, {"index": 15, "meaning": "flow rate (slots[15] bits 0..79)"}, {"index": 16, "meaning": "flow count (slots[15] bits 80..159)"}, {"index": 17, "meaning": "flow meanSize (slots[15] bits 160..239)"}, {"index": 18, "meaning": "lastSpot (slots[2] >> 64)"}, {"index": "S[19..39]", "meaning": "unused"}], "slot_note": "S index == Solidity slots[] index for 0..15; packed slots[2] -> S[2]=lastTs, S[18]=lastSpot; packed slots[15] -> S[15]=rate, S[16]=count, S[17]=meanSize. Constants are named K_<NAME> indices into TH.", "diff_test": {"sequences": 200, "callbacks": 400000, "max_abs_diff_bps": 2.966168977103223e-09, "mean_abs_diff_bps": 6.86e-12, "share_above_0p01bps": 0.0, "first_divergence": null, "detail": "EVM = repo EVMStrategyAdapter(pyrevm) on solc 0.8.24 compile of RS2 (sha256 f24b6ca1...). 200 seqs x 2000 callbacks, steps with 0-4 retail fills plus arb to fee band, gaps of 2-11 steps (30% of steps), calm (even seeds) and volatile (odd seeds, 3% 6x shocks) regimes; EVM returned fees fed back to the market; port state evolved independently (never resynced), fees compared after every callback; p99.9 diff 1.8e-10 bps. Fee coverage: median ~55-60 bps, ~8-10% of callbacks below 30 bps, ~83% above 36 bps, max 887-1000 bps (10% cap hit in some runs); so the synthetic market is on the high-fee side and rarely sits in the 4-30 bps low-fee regime; both sides of the 30 and 36 bps branches run.", "script": "in test/scratch only (not delivered)"}, "njit_compiles": true, "speed": "~0.13 us per strat_after call inside an njit loop (1e6 calls); ~9 us per call when called from a Python loop (dispatch overhead).", "deviations": ["WAD integer floor division in wmul/wdiv dropped (float64 products); error ~1e-18 relative per op, observed max fee diff 3e-9 bps.", "_isqrt(x*WAD) replaced by math.sqrt (EVM version is floor sqrt via 7 Newton steps; difference <=1 wei).", "uint80/uint64/uint256 packing, casts and truncation not modelled (values far below limits); slots[2] spot<<64|ts unpacked.", "Solidity reverts (division by zero, unsigned underflow e.g. hi-lo) are not modelled; the EVM never reverted in the test.", "Calldata quantisation: the test feeds the port amounts/reserves rounded to 1e-18 like the adapter (int(Decimal*1e18)); the port itself does not round.", "Quadrature node count 7, loop bounds and the 3-j node symmetry are hard-coded; compile-time branch flags `342406799193418304 > 0`, `2 == 2`, `2 == 0` are TH entries FLOW_BLEND and FLOW_MODE (=2).", "TH order: header constants in source order, then afterInitialize literals, afterSwap literals, _posterior literals, _band literals, then WAD, MAX_FEE, BPS from the base contract. TH_VALUES are fractions (bps constants already x1e-4)."], "notes": "Contract unchanged. REVERT_U=0 so slot 11 is never read. clampFee to [0,0.1] reproduced. Only verified against the EVM on the synthetic market, not against the real simulator batch."}