redis_exchange 0.3.0

data/redis_scripts/audit_user_balance.lua

@@ -0,0 +1,150 @@
+-- audit_user_balance.lua
+-- Calculates required reserved balances from active orders and reconciles with actual user balance.
+--
+-- KEYS:
+--   1. balance hash (balance:{user_id})
+-- ARGV:
+--   1. user_id
+--   2. fix_mode ('1' for true, '0' for false)
+--   3. timestamp (for ledger)
+--   4..N. symbols (list of all market symbols to scan)
+--
+-- Returns JSON object:
+-- {
+--   "deficits": [ { "asset": "BTC", "amount": 100 } ],
+--   "fixes": [ { "asset": "USDT", "action": "LOCK", "amount": 50 } ]
+-- }
+
+local cjson = cjson
+local balance_key = KEYS[1]
+local user_id = ARGV[1]
+local fix_mode = (ARGV[2] == '1')
+local ts = ARGV[3]
+local symbols = {}
+for i = 4, #ARGV do
+  table.insert(symbols, ARGV[i])
+end
+
+-- Helpers
+local function as_number(value)
+  return tonumber(value) or 0
+end
+
+local function append_ledger(uid, asset, action, amount, new_available, new_reserved, reason, timestamp)
+  if amount == 0 then return end
+  local now_ts = timestamp
+  if not now_ts or tonumber(now_ts) <= 0 then
+    local now = redis.call('TIME')
+    now_ts = (tonumber(now[1]) or 0) * 1000 + math.floor((tonumber(now[2]) or 0) / 1000)
+  end
+  local seq = redis.call('INCR', 'ledger_seq:' .. uid .. ':' .. asset)
+  local ledger_biz_id = 'AUDIT:' .. uid .. ':' .. asset .. ':' .. action .. ':' .. tostring(seq)
+  redis.call('XADD', 'account_ledger', 'MAXLEN', '~', 1000000, '*',
+    'user_id', uid,
+    'asset', asset,
+    'action', action,
+    'amount', tostring(amount),
+    'new_available', tostring(new_available),
+    'new_reserved', tostring(new_reserved),
+    'reason', reason,
+    'ts', tostring(now_ts),
+    'sequence', tostring(seq),
+    'biz_id', ledger_biz_id
+  )
+end
+
+-- 1. Calculate Required Reserved
+local required = {} -- asset -> amount
+
+for _, symbol in ipairs(symbols) do
+  local index_key = 'user_orders:' .. user_id .. ':' .. symbol
+  -- Use ZRANGE to get all order IDs
+  local order_ids = redis.call('ZRANGE', index_key, 0, -1)
+
+  if #order_ids > 0 then
+    -- Optimize: We need base/quote asset for this symbol.
+    -- We can fetch it once per symbol.
+    local market_key = 'market:' .. symbol
+    local m = redis.call('HMGET', market_key, 'base_asset', 'quote_asset')
+    local base_asset = m[1]
+    local quote_asset = m[2]
+
+    if base_asset and quote_asset then
+      for _, oid in ipairs(order_ids) do
+        local order_key = 'order:' .. oid
+        local reserved = redis.call('HMGET', order_key, 'reserved_base', 'reserved_quote')
+        local r_base = as_number(reserved[1])
+        local r_quote = as_number(reserved[2])
+
+        if r_base > 0 then
+          required[base_asset] = (required[base_asset] or 0) + r_base
+        end
+        if r_quote > 0 then
+          required[quote_asset] = (required[quote_asset] or 0) + r_quote
+        end
+      end
+    end
+  end
+end
+
+-- 2. Compare with Actual Balance & Fix
+local deficits = {}
+local fixes = {}
+
+-- We iterate over all assets that have requirements OR exist in balance?
+-- Ideally we should also check if we have reserved balance for assets with NO orders.
+-- But iterating all fields in balance hash is expensive if it's huge?
+-- Usually user balance hash has limited fields. Let's iterate all reserved fields in balance too.
+
+local all_assets = {}
+for a, _ in pairs(required) do all_assets[a] = true end
+
+-- Also scan balance hash for any 'reserved' fields
+local balance_fields = redis.call('HGETALL', balance_key)
+for i = 1, #balance_fields, 2 do
+  local field = balance_fields[i]
+  if string.find(field, ':reserved$') then
+    local asset = string.sub(field, 1, -10) -- remove ':reserved'
+    all_assets[asset] = true
+  end
+end
+
+for asset, _ in pairs(all_assets) do
+  local req_amount = required[asset] or 0
+  local actual_reserved = as_number(redis.call('HGET', balance_key, asset .. ':reserved'))
+  local diff = req_amount - actual_reserved
+
+  if diff > 0 then
+    -- Deficit: Need to lock more
+    local actual_available = as_number(redis.call('HGET', balance_key, asset .. ':available'))
+    local to_lock = diff
+    if actual_available < to_lock then
+      to_lock = actual_available
+    end
+
+    if fix_mode and to_lock > 0 then
+      local new_available = redis.call('HINCRBY', balance_key, asset .. ':available', -to_lock)
+      local new_reserved = redis.call('HINCRBY', balance_key, asset .. ':reserved', to_lock)
+      append_ledger(user_id, asset, 'LOCK', to_lock, new_available, new_reserved, 'AUDIT_FIX_LOCK', ts)
+
+      table.insert(fixes, { asset = asset, action = 'LOCK', amount = to_lock })
+    end
+
+    local remaining_deficit = diff - to_lock
+    if remaining_deficit > 0 then
+      table.insert(deficits, { asset = asset, amount = remaining_deficit })
+    end
+  elseif diff < 0 then
+    -- Surplus: Locked too much. Release to available.
+    local to_release = -diff
+    if fix_mode then
+      local new_reserved = redis.call('HINCRBY', balance_key, asset .. ':reserved', -to_release)
+      local new_available = redis.call('HINCRBY', balance_key, asset .. ':available', to_release)
+      append_ledger(user_id, asset, 'UNLOCK', to_release, new_available, new_reserved, 'AUDIT_FIX_RELEASE', ts)
+
+      table.insert(fixes, { asset = asset, action = 'RELEASE', amount = to_release })
+    end
+  end
+end
+
+return cjson.encode({ deficits = deficits, fixes = fixes })

data/redis_scripts/balance_op.lua

@@ -0,0 +1,148 @@
+-- balance_op.lua
+-- Atomically adjusts user balance based on specific actions and records ledger entries.
+--
+-- KEYS:
+--   1. balance hash (balance:{user_id})
+-- ARGV:
+--   1. user_id
+--   2. asset
+--   3. amount (positive integer/string)
+--   4. action (LOCK, UNLOCK, ADD, SUB, SUB_LOCKED, ADD_LOCKED)
+--   5. reason
+--   6. timestamp (optional)
+--   7. biz_id (optional, for idempotency)
+--
+-- Returns JSON with new balances or error.
+
+local cjson = cjson
+
+if redis.call('GET', 'system:maintenance_mode') == '1' then
+  return cjson.encode({ error = 'SYSTEM_MAINTENANCE' })
+end
+
+local function as_number(value)
+  return tonumber(value) or 0
+end
+
+local balance_key = KEYS[1]
+local user_id = ARGV[1]
+local asset = ARGV[2]
+local amount = as_number(ARGV[3])
+local action = ARGV[4]
+local reason = ARGV[5] or 'MANUAL'
+local ts_arg = ARGV[6]
+local biz_id = ARGV[7]
+
+if not (balance_key and user_id and asset and action) then
+  return cjson.encode({ error = 'INVALID_ARGUMENTS' })
+end
+
+if amount <= 0 then
+  return cjson.encode({ error = 'INVALID_AMOUNT' })
+end
+
+-- Idempotency check
+local resp_key = nil
+if biz_id and biz_id ~= '' then
+  resp_key = 'op_biz:' .. user_id .. ':' .. asset .. ':' .. action .. ':' .. biz_id
+  local cached = redis.call('GET', resp_key)
+  if cached then
+    return cached
+  end
+end
+
+local avail_field = asset .. ':available'
+local reserved_field = asset .. ':reserved'
+
+local avail_bal = as_number(redis.call('HGET', balance_key, avail_field))
+local reserved_bal = as_number(redis.call('HGET', balance_key, reserved_field))
+
+local new_avail = avail_bal
+local new_reserved = reserved_bal
+
+if action == 'LOCK' then
+  if avail_bal < amount then
+    return cjson.encode({ error = 'INSUFFICIENT_FUNDS', asset = asset, bucket = 'available' })
+  end
+  new_avail = avail_bal - amount
+  new_reserved = reserved_bal + amount
+  redis.call('HINCRBY', balance_key, avail_field, -amount)
+  redis.call('HINCRBY', balance_key, reserved_field, amount)
+elseif action == 'UNLOCK' then
+  if reserved_bal < amount then
+    return cjson.encode({ error = 'INSUFFICIENT_FUNDS', asset = asset, bucket = 'reserved' })
+  end
+  new_reserved = reserved_bal - amount
+  new_avail = avail_bal + amount
+  redis.call('HINCRBY', balance_key, reserved_field, -amount)
+  redis.call('HINCRBY', balance_key, avail_field, amount)
+elseif action == 'ADD' then
+  new_avail = avail_bal + amount
+  redis.call('HINCRBY', balance_key, avail_field, amount)
+elseif action == 'SUB' then
+  if avail_bal < amount then
+    return cjson.encode({ error = 'INSUFFICIENT_FUNDS', asset = asset, bucket = 'available' })
+  end
+  new_avail = avail_bal - amount
+  redis.call('HINCRBY', balance_key, avail_field, -amount)
+elseif action == 'SUB_LOCKED' then
+  if reserved_bal < amount then
+    return cjson.encode({ error = 'INSUFFICIENT_FUNDS', asset = asset, bucket = 'reserved' })
+  end
+  new_reserved = reserved_bal - amount
+  redis.call('HINCRBY', balance_key, reserved_field, -amount)
+elseif action == 'ADD_LOCKED' then
+  new_reserved = reserved_bal + amount
+  redis.call('HINCRBY', balance_key, reserved_field, amount)
+else
+  return cjson.encode({ error = 'INVALID_ACTION' })
+end
+
+-- Ledger Recording
+local ts
+if ts_arg and ts_arg ~= '' then
+  ts = tonumber(ts_arg) or 0
+else
+  local now = redis.call('TIME')
+  ts = (tonumber(now[1]) or 0) * 1000 + math.floor((tonumber(now[2]) or 0) / 1000)
+end
+
+local seq = redis.call('INCR', 'ledger_seq:' .. user_id .. ':' .. asset)
+local ledger_biz_id = biz_id
+if not ledger_biz_id or ledger_biz_id == '' then
+  ledger_biz_id = 'AUTO:' .. user_id .. ':' .. asset .. ':' .. action .. ':' .. tostring(seq)
+end
+
+redis.call('XADD', 'account_ledger', 'MAXLEN', '~', 10000000, '*',
+  'user_id', user_id,
+  'asset', asset,
+  'action', action,
+  'amount', tostring(amount),
+  'new_available', tostring(new_avail),
+  'new_reserved', tostring(new_reserved),
+  'reason', reason,
+  'ts', tostring(ts),
+  'sequence', tostring(seq),
+  'biz_id', ledger_biz_id
+)
+
+local result = {
+  ok = true,
+  user_id = user_id,
+  asset = asset,
+  action = action,
+  amount = amount,
+  available = new_avail,
+  reserved = new_reserved,
+  ts = ts,
+  sequence = seq,
+  biz_id = ledger_biz_id
+}
+
+local result_json = cjson.encode(result)
+
+if resp_key then
+  redis.call('SET', resp_key, result_json, 'EX', 86400)
+end
+
+return result_json

data/redis_scripts/cancel_order.lua

@@ -0,0 +1,277 @@
+-- cancel_order.lua performs atomic cancellation of a resting limit order.
+--
+-- KEYS:
+--   1. order hash (order:{order_id})
+--   2. market sequence counter (seq:{symbol})
+-- ARGV:
+--   1. requested order_id (for error responses)
+--
+-- Returns JSON with `status`, `order_id`, and `symbol` when available.
+
+-- Redis Lua environment provides global `cjson`; no `require` is allowed.
+local cjson = cjson
+
+-- Check for system maintenance mode
+if redis.call('GET', 'system:maintenance_mode') == '1' then
+  return cjson.encode({ error = 'SYSTEM_MAINTENANCE' })
+end
+
+-- order_key is KEYS[1]
+local order_key = KEYS[1]
+local seq_key = KEYS[2]
+local requested_id = ARGV[1]
+
+-- To check market maintenance, we need the symbol.
+-- Since we don't pass market key directly, we must look it up from the order.
+-- This works fine on single-instance Redis.
+
+local symbol = redis.call('HGET', order_key, 'symbol')
+if symbol then
+  if redis.call('HGET', 'market:' .. symbol, 'status') == 'MAINTENANCE' then
+    return cjson.encode({ error = 'MARKET_MAINTENANCE' })
+  end
+end
+
+local function to_map(array)
+  local map = {}
+  for i = 1, #array, 2 do
+    map[array[i]] = array[i + 1]
+  end
+  return map
+end
+
+local function as_number(value)
+  if not value then
+    return 0
+  end
+  local num = tonumber(value)
+  if not num then
+    return 0
+  end
+  return num
+end
+
+-- Append an account ledger entry for a balance change.
+-- Uses per-user-asset sequence `ledger_seq:{user_id}:{asset}` and global stream `account_ledger`.
+local function append_ledger(user_id, asset, action, amount, new_available, new_reserved, reason, ts, biz_id)
+  if amount == 0 then return end
+  local now_ts = ts
+  if not now_ts or now_ts <= 0 then
+    local now = redis.call('TIME')
+    now_ts = (tonumber(now[1]) or 0) * 1000 + math.floor((tonumber(now[2]) or 0) / 1000)
+  end
+  local seq = redis.call('INCR', 'ledger_seq:' .. user_id .. ':' .. asset)
+  local ledger_biz_id = biz_id
+  if not ledger_biz_id then
+    ledger_biz_id = 'AUTO:' .. user_id .. ':' .. asset .. ':' .. action .. ':' .. tostring(seq)
+  end
+  redis.call('XADD', 'account_ledger', 'MAXLEN', '~', 1000000, '*',
+    'user_id', user_id,
+    'asset', asset,
+    'action', action,
+    'amount', tostring(amount),
+    'new_available', tostring(new_available),
+    'new_reserved', tostring(new_reserved),
+    'reason', reason or 'CANCEL',
+    'ts', tostring(now_ts),
+    'sequence', tostring(seq),
+    'biz_id', ledger_biz_id
+  )
+end
+
+local function op_unlock(user_id, asset, amount, reason, ts, biz_id)
+  if amount <= 0 then return end
+  local new_reserved = redis.call('HINCRBY', 'balance:' .. user_id, asset .. ':reserved', -amount)
+  local new_available = redis.call('HINCRBY', 'balance:' .. user_id, asset .. ':available', amount)
+  append_ledger(user_id, asset, 'UNLOCK', amount, new_available, new_reserved, reason, ts, biz_id)
+end
+
+local function publish_depth_update(symbol, side, price, delta, final_volume, ts)
+  redis.call('XADD', 'depth:' .. symbol, 'MAXLEN', '~', 1000000, '*',
+    'e', 'u',
+    's', side,
+    'p', tostring(price),
+    'd', tostring(delta),
+    'v', tostring(final_volume),
+    'ts', tostring(ts)
+  )
+end
+
+local function refresh_ticker(symbol)
+  local ticker_key = 'ticker:' .. symbol
+  local best_bid_member = redis.call('ZRANGE', 'book:' .. symbol .. ':BUY', -1, -1)
+  local best_bid_price = best_bid_member[1] or '0'
+  local best_bid_volume = '0'
+  if best_bid_member[1] then
+    best_bid_volume = redis.call('HGET', 'volume:' .. symbol .. ':BUY', best_bid_price) or '0'
+  end
+
+  local best_ask_member = redis.call('ZRANGE', 'book:' .. symbol .. ':SELL', 0, 0)
+  local best_ask_price = best_ask_member[1] or '0'
+  local best_ask_volume = '0'
+  if best_ask_member[1] then
+    best_ask_volume = redis.call('HGET', 'volume:' .. symbol .. ':SELL', best_ask_price) or '0'
+  end
+
+  redis.call('HSET', ticker_key,
+    'best_bid_price', best_bid_price,
+    'best_bid_volume', tostring(best_bid_volume),
+    'best_ask_price', best_ask_price,
+    'best_ask_volume', tostring(best_ask_volume)
+  )
+end
+
+local order = to_map(redis.call('HGETALL', order_key))
+if next(order) == nil then
+  return cjson.encode({ status = 'NOT_FOUND', order_id = requested_id })
+end
+
+local order_id = order['order_id'] or requested_id
+local symbol = order['symbol']
+local side = order['side']
+local price = order['price']
+local remaining = as_number(order['remaining'])
+local status = order['status'] or 'UNKNOWN'
+local user_id = order['user_id']
+
+local now = redis.call('TIME')
+local ts_ms = (tonumber(now[1]) or 0) * 1000 + math.floor((tonumber(now[2]) or 0) / 1000)
+local sequence = redis.call('INCR', seq_key)
+
+if remaining <= 0 then
+  return cjson.encode({ status = status, order_id = order_id, symbol = symbol or '' })
+end
+
+if not (symbol and side and price and user_id) then
+  return cjson.encode({ status = 'INVALID_ORDER', order_id = order_id })
+end
+
+local market = to_map(redis.call('HGETALL', 'market:' .. symbol))
+if next(market) == nil then
+  return cjson.encode({ status = 'UNKNOWN_MARKET', order_id = order_id })
+end
+
+local tombstone_ttl_sec = tonumber(market['order_tombstone_ttl_sec']) or 86400
+local function mark_tombstone(oid, status)
+  if not oid or oid == '' then return end
+  redis.call('SET', 'order_tombstone:' .. oid, status or 'DONE', 'EX', tombstone_ttl_sec)
+end
+
+local base_asset = market['base_asset']
+local quote_asset = market['quote_asset']
+local quantity_scale = as_number(market['quantity_scale'])
+if quantity_scale <= 0 then
+  quantity_scale = 1
+end
+
+local balance_key = 'balance:' .. user_id
+
+-- Check if order was never executed (no trades)
+local quantity = as_number(order['quantity'])
+local trade_count = as_number(order['trade_count'] or '0')
+local is_untouched = (trade_count == 0 and remaining == quantity)
+
+-- Build biz_id with untouched flag if applicable
+local function build_biz_id(base_biz_id)
+  if is_untouched then
+    return base_biz_id .. ':UNT'
+  else
+    return base_biz_id
+  end
+end
+
+if side == 'SELL' then
+  local reserved_base = as_number(order['reserved_base'])
+  local release_amount = reserved_base
+  if release_amount <= 0 then
+    release_amount = remaining
+  end
+  op_unlock(user_id, base_asset, release_amount, 'CANCEL_REFUND', nil, build_biz_id('order_cancel:' .. sequence .. ':' .. order_id))
+
+  -- If we released the full reserved amount for the order, we should zero it out in the hash too,
+  -- although the order is being deleted shortly. But critically, if this was a partial cancel
+  -- (not supported here, but good practice), we'd update.
+  -- For full cancel, the order hash is deleted anyway.
+else
+  local reserved_quote = as_number(order['reserved_quote'])
+  local release_amount = reserved_quote
+  if release_amount <= 0 then
+    -- Fallback for legacy orders without reserved_quote field
+    release_amount = math.floor((as_number(price) * remaining) / quantity_scale)
+
+    -- Add fee reserve fallback logic matching match_order.lua?
+    -- match_order.lua: reserve_total = reserve_quote + reserve_fee
+    -- If we don't have the exact reserved amount stored, we might under-release if fees were reserved!
+    -- However, match_order.lua NOW stores `reserved_quote` correctly.
+    -- So this fallback is only for very old data.
+
+    -- But wait, if we have stored reserved_quote, we trust it.
+  end
+  if release_amount > 0 then
+    op_unlock(user_id, quote_asset, release_amount, 'CANCEL_REFUND', ts_ms,
+      build_biz_id('order_cancel:' .. sequence .. ':' .. order_id))
+  end
+end
+
+local price_member = tostring(price)
+local queue_key = 'queue:' .. symbol .. ':' .. side .. ':' .. price_member
+redis.call('LREM', queue_key, 0, order_id)
+
+local volume_key = 'volume:' .. symbol .. ':' .. side
+local remaining_volume = redis.call('HINCRBY', volume_key, price_member, -remaining)
+publish_depth_update(symbol, side, price_member, -remaining, remaining_volume, ts_ms)
+
+if remaining_volume <= 0 then
+  redis.call('HDEL', volume_key, price_member)
+  redis.call('DEL', queue_key)
+  local book_key = 'book:' .. symbol .. ':' .. side
+  redis.call('ZREM', book_key, price_member)
+end
+
+redis.call('HMSET', order_key,
+  'status', 'CANCELLED',
+  'remaining', '0'
+)
+
+-- Remove from user's active orders index
+if user_id and symbol and order_id then
+  local index_key = 'user_orders:' .. user_id .. ':' .. symbol
+  redis.call('ZREM', index_key, order_id)
+end
+
+-- Publish order cancellation event to orders stream and delete final order hash
+do
+  local now = redis.call('TIME')
+  local ts_ms = (tonumber(now[1]) or 0) * 1000 + math.floor((tonumber(now[2]) or 0) / 1000)
+  local orders_key = 'orders:' .. symbol
+  local order_type = order['type'] or ''
+  local quantity = order['quantity'] or '0'
+
+  local orders_maxlen = tonumber(market['orders_maxlen']) or 1000000
+  redis.call('XADD', orders_key, 'MAXLEN', '~', orders_maxlen, '*',
+    'order_id', order_id,
+    'user_id', user_id,
+    'symbol', symbol,
+    'side', side,
+    'type', order_type,
+    'status', 'CANCELLED',
+    'price', tostring(price),
+    'quantity', tostring(quantity),
+    'remaining', '0',
+    'ts', tostring(ts_ms),
+    'sequence', tostring(sequence)
+  )
+
+  -- Delete terminal order hash to keep storage lean
+  mark_tombstone(order_id, 'CANCELLED')
+  redis.call('DEL', order_key)
+end
+
+refresh_ticker(symbol)
+
+return cjson.encode({
+  status = 'CANCELLED',
+  order_id = order_id,
+  symbol = symbol,
+  remaining_quantity = 0
+})

data/redis_scripts/finalize_precision_update.lua

@@ -0,0 +1,88 @@
+--[[
+finalize_precision_update.lua
+Switches the market to the new precision configuration and enables the new order books.
+
+KEYS:
+  1. market:{symbol}
+  2. book:{symbol}:BUY
+  3. book:{symbol}:SELL
+  4. volume:{symbol}:BUY
+  5. volume:{symbol}:SELL
+  6. book:{symbol}:BUY:TMP
+  7. book:{symbol}:SELL:TMP
+  8. volume:{symbol}:BUY:TMP
+  9. volume:{symbol}:SELL:TMP
+
+ARGV:
+  1. symbol
+  2. new_price_scale
+  3. new_quantity_scale
+
+Returns:
+  JSON object { status: 'OK' }
+]]
+
+local cjson = cjson
+
+local market_key = KEYS[1]
+local book_buy_key = KEYS[2]
+local book_sell_key = KEYS[3]
+local volume_buy_key = KEYS[4]
+local volume_sell_key = KEYS[5]
+local book_buy_tmp = KEYS[6]
+local book_sell_tmp = KEYS[7]
+local volume_buy_tmp = KEYS[8]
+local volume_sell_tmp = KEYS[9]
+
+local symbol = ARGV[1]
+local new_price_scale = ARGV[2]
+local new_quantity_scale = ARGV[3]
+
+-- Update Market Config
+redis.call('HSET', market_key, 'price_scale', new_price_scale, 'quantity_scale', new_quantity_scale)
+
+-- Replace Books
+redis.call('DEL', book_buy_key)
+if redis.call('EXISTS', book_buy_tmp) == 1 then
+  redis.call('RENAME', book_buy_tmp, book_buy_key)
+end
+
+redis.call('DEL', book_sell_key)
+if redis.call('EXISTS', book_sell_tmp) == 1 then
+  redis.call('RENAME', book_sell_tmp, book_sell_key)
+end
+
+-- Replace Volumes
+redis.call('DEL', volume_buy_key)
+if redis.call('EXISTS', volume_buy_tmp) == 1 then
+  redis.call('RENAME', volume_buy_tmp, volume_buy_key)
+end
+
+redis.call('DEL', volume_sell_key)
+if redis.call('EXISTS', volume_sell_tmp) == 1 then
+  redis.call('RENAME', volume_sell_tmp, volume_sell_key)
+end
+
+-- Rename all TMP queues to real queues
+-- We need to scan for them because we don't know exactly which prices exist.
+-- But SCAN in Lua is discouraged for large keyspaces.
+-- However, we can infer the keys from the NEW books we just put in place.
+-- Iterate over the new books to find active prices and rename their queues.
+
+local function rename_queues(book_key, side)
+  local prices = redis.call('ZRANGE', book_key, 0, -1)
+  for _, price_member in ipairs(prices) do
+    local tmp_queue = 'queue:' .. symbol .. ':' .. side .. ':' .. price_member .. ':TMP'
+    local real_queue = 'queue:' .. symbol .. ':' .. side .. ':' .. price_member
+    
+    redis.call('DEL', real_queue) -- Should be empty as we deleted old ones in batch, but safety first
+    if redis.call('EXISTS', tmp_queue) == 1 then
+      redis.call('RENAME', tmp_queue, real_queue)
+    end
+  end
+end
+
+rename_queues(book_buy_key, 'BUY')
+rename_queues(book_sell_key, 'SELL')
+
+return cjson.encode({ status = 'OK' })