Price Calculation

// All arithmetic in BigInt — floor division matches Vyper's //
function calculatePrice(supplyLots, deltaLots, isBuy, chain) {
    const { P_START, PRICE_SLOPE } = chain;
    const INITIAL_SUPPLY_LOTS = 60_000n;
    const ADDITIONAL_CAP = 740_000_000n;
    const TWO_TIMES_CAP  = 1_480_000_000n;
    const T_START_BP = 1200n, T_END_BP = 120n, TAX_DECREASE_BP = 1080n;

    const n = deltaLots * 1000n;
    const x = (supplyLots - INITIAL_SUPPLY_LOTS) * 1000n;

    if (!isBuy && supplyLots <= INITIAL_SUPPLY_LOTS) {
        throw new Error("Cannot sell at floor");
    }
    if (!isBuy && n > x) {
        // On-chain `x - n` is uint256 and underflows here, reverting the tx.
        // BigInt would silently go negative, so guard explicitly.
        throw new Error("Cannot sell more than the supply above the floor");
    }

    const xStart = isBuy ? x : x - n;
    const xEnd   = isBuy ? x + n : x;

    // Square first, then divide — do not factor this
    const quad   = (PRICE_SLOPE * (xEnd * xEnd - xStart * xStart)) / TWO_TIMES_CAP;
    const linear = P_START * n;
    const base   = quad + linear;

    let avg = (xStart + xEnd) / 2n;
    if (avg > ADDITIONAL_CAP) avg = ADDITIONAL_CAP;

    let rate = T_START_BP - (TAX_DECREASE_BP * avg) / ADDITIONAL_CAP;
    if (rate < T_END_BP) rate = T_END_BP;

    const tax = (base * rate) / 10000n;

    return isBuy
        ? { base, tax, total: base + tax }
        : { base, tax, proceeds: base - tax };
}

# Python ints are arbitrary precision; // is floor division, matching Vyper.
# Every value here is non-negative, so floor and truncation agree.
def calculate_price(supply_lots, delta_lots, is_buy, chain):
    P_START, PRICE_SLOPE = chain["P_START"], chain["PRICE_SLOPE"]
    INITIAL_SUPPLY_LOTS = 60_000
    ADDITIONAL_CAP = 740_000_000
    TWO_TIMES_CAP = 1_480_000_000
    T_START_BP, T_END_BP, TAX_DECREASE_BP = 1200, 120, 1080

    n = delta_lots * 1000
    x = (supply_lots - INITIAL_SUPPLY_LOTS) * 1000

    if not is_buy and supply_lots <= INITIAL_SUPPLY_LOTS:
        raise ValueError("Cannot sell at floor")
    if not is_buy and n > x:
        # On-chain `x - n` is uint256 and underflows here, reverting the tx.
        # Python ints would silently go negative, so guard explicitly.
        raise ValueError("Cannot sell more than the supply above the floor")

    x_start = x if is_buy else x - n
    x_end = x + n if is_buy else x

    # Square first, then divide — do not factor this
    quad = (PRICE_SLOPE * (x_end * x_end - x_start * x_start)) // TWO_TIMES_CAP
    linear = P_START * n
    base = quad + linear

    avg = (x_start + x_end) // 2
    avg = min(avg, ADDITIONAL_CAP)

    rate = T_START_BP - (TAX_DECREASE_BP * avg) // ADDITIONAL_CAP
    rate = max(rate, T_END_BP)

    tax = (base * rate) // 10000

    if is_buy:
        return {"base": base, "tax": tax, "total": base + tax}
    return {"base": base, "tax": tax, "proceeds": base - tax}