amount_a = shares_to_burn * reserve_a / total_lp_shares
amount_b = shares_to_burn * reserve_b / total_lp_shares

permanent tail       extended bid         active bid wall    organic ask
▁▁▁▁                 ▂▂▃▃▃▄▄▄▄▄          ▅▆▇█              ▁░░                    (time t0)
▁▁▁▁                 ▂▂▃▃▃▄▄▄▄▄▄▄▄▄▄    ▅▆▇█              ░░                     (after grow at t1)
▁▁▁▁                 ▂▂▃▃▃▄▄▄▄▄▄▄▄▄▄▄▄▄ ▅▆▇█              ░                      (after grow at t2)
└ NAV-1% floor       └ old active zones  └ current NAV     └ RWT (user sells)

// Fees calculated on swap amount
fee_total = amount_in * fee_bps / 10,000
fee_lp = fee_total * lp_fee_share_bps / 10,000
fee_protocol = fee_total - fee_lp

// OT Treasury fee (only if ot_treasury_fee_destination is Some)
ot_treasury_fee = amount_in * OT_TREASURY_FEE_BPS / 10,000  // 50 bps on gross amount

// User pays fees ON TOP — total debit from user wallet:
user_total_debit = amount_in + fee_total + ot_treasury_fee
// Full amount_in goes into pool (no fee deduction from reserves)
amount_out = constant_product(amount_in)

amount_out_gross = constant_product(amount_in)

// Fees calculated on gross RWT output
fee_total = amount_out_gross * fee_bps / 10,000
fee_lp = fee_total * lp_fee_share_bps / 10,000
fee_protocol = fee_total - fee_lp

// OT Treasury fee (only if ot_treasury_fee_destination is Some)
ot_treasury_fee = amount_out_gross * OT_TREASURY_FEE_BPS / 10,000  // 50 bps on gross amount

// Fees deducted from gross output — user receives net:
amount_out = amount_out_gross - fee_total - ot_treasury_fee

// Reserves stay intact — fees never touch pool liquidity
reserve_in  += amount_in   // full swap amount enters pool
reserve_out -= amount_out_gross  // gross amount leaves pool (before fee split)
// All fees are external to pool reserves
total_fees_accumulated += fee_total + ot_treasury_fee

amount_out = reserve_out * net_input / (reserve_in + net_input)

remaining = net_input  (or amount_in if fee taken from output)
total_out = 0
current_bin = active_bin_id

while remaining > 0:
  bin = bin_array[current_bin]
  
  if a_to_b (selling RWT for USDC):
    available = bin.liquidity_b  (USDC in this bin)
    price = (1 + bin_step_bps/10000) ^ current_bin
    consumable = min(remaining * price, available)  // cast u128
    total_out += consumable
    remaining -= consumable / price
    bin.liquidity_b -= consumable
    bin.liquidity_a += consumable / price
    if bin.liquidity_b == 0:
      current_bin -= 1  // move to cheaper bin
      if current_bin < lower_bin_id: break  // no more liquidity
  
  else (buying RWT with USDC):
    available = bin.liquidity_a  (RWT in this bin)
    price = (1 + bin_step_bps/10000) ^ current_bin
    consumable = min(remaining / price, available)  // cast u128
    total_out += consumable
    remaining -= consumable * price
    bin.liquidity_a -= consumable
    bin.liquidity_b += consumable * price
    if bin.liquidity_a == 0:
      current_bin += 1  // move to more expensive bin
      if current_bin > upper_bin_id: break

active_bin_id = current_bin
amount_out = total_out

nav = rwt_vault.nav_book_value                                 // read via CPI or account
best_ask_price = price_at_bin(active_bin_id + 1)              // cheapest RWT in the pool
has_organic_ask = exists bin > active_bin_id with liquidity_a > 0

mint_cheaper_threshold = nav * (10_000 + 50) / 10_000          // NAV × 1.005 (DEX becomes non-competitive above this)

if !has_organic_ask OR best_ask_price > mint_cheaper_threshold:
    // Route to mint — no DEX fee charged
    CPI rwt_engine::mint_rwt(amount_in_usdc)
      accounts = {
        user, rwt_vault, rwt_mint, user_deposit (USDC),
        user_rwt, capital_accumulator_ata, dao_fee_account
      }
    // User pays 1% mint fee inside rwt_engine — split 0.5% vault / 0.5% DAO
    // No LP fee, no DEX protocol fee. Pool state untouched.
    emit SwapRoutedToMint { user, usdc_in, rwt_out, nav }
    return

// Otherwise: standard bin walk from active_bin_id upward, consuming organic RWT
// Standard DEX fees apply (LP + protocol) as in base logic above

delta_a = pool_state.cumulative_fees_per_share_a − lp_position.fees_claimed_per_share_a
delta_b = pool_state.cumulative_fees_per_share_b − lp_position.fees_claimed_per_share_b

claimable_a = (delta_a × lp_position.shares) >> 64    // Q64.64 → integer token amount
claimable_b = (delta_b × lp_position.shares) >> 64

if claimable_a == 0 && claimable_b == 0: return

if claimable_a > 0:
    transfer claimable_a token_A: pool_vault_a → recipient_token_a_ata (pool PDA signs)
if claimable_b > 0:
    transfer claimable_b token_B: pool_vault_b → recipient_token_b_ata (pool PDA signs)

lp_position.fees_claimed_per_share_a = pool_state.cumulative_fees_per_share_a
lp_position.fees_claimed_per_share_b = pool_state.cumulative_fees_per_share_b