redis_exchange 0.3.0

data/redis_scripts/migrate_orders_batch.lua

@@ -0,0 +1,204 @@
+--[[
+migrate_orders_batch.lua
+Process a batch of price levels for precision update.
+Reads orders from old queues, converts them, and appends to TMP queues/books.
+
+KEYS:
+  1. market:{symbol}
+  2. book:{symbol}:{side}:TMP
+  3. volume:{symbol}:{side}:TMP
+  4. orders:{symbol} (for events)
+
+ARGV:
+  1. symbol
+  2. side (BUY/SELL)
+  3. new_price_scale
+  4. new_quantity_scale
+  5. timestamp
+  6...N. price_members (strings) to process
+
+Returns:
+  JSON object { processed_orders: N, processed_levels: M }
+]]
+
+local cjson = cjson
+
+local market_key = KEYS[1]
+local book_tmp_key = KEYS[2]
+local volume_tmp_key = KEYS[3]
+local orders_key = KEYS[4]
+
+local symbol = ARGV[1]
+local side = ARGV[2]
+local new_price_scale = tonumber(ARGV[3])
+local new_quantity_scale = tonumber(ARGV[4])
+local timestamp = tonumber(ARGV[5])
+
+-- Helper: Convert HGETALL to map
+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)
+  return tonumber(value) or 0
+end
+
+local function append_ledger(user_id, asset, bucket, delta, reason, ts)
+  if delta == 0 then return end
+  local seq = redis.call('INCR', 'ledger_seq:' .. user_id .. ':' .. asset)
+  local ledger_biz_id = 'PRECISION:' .. symbol .. ':' .. ts .. ':' .. seq
+  redis.call('XADD', 'account_ledger', 'MAXLEN', '~', 1000000, '*',
+    'user_id', user_id,
+    'asset', asset,
+    'bucket', bucket,
+    'amount', tostring(delta),
+    'reason', reason,
+    'ts', tostring(ts),
+    'sequence', tostring(seq),
+    'biz_id', ledger_biz_id
+  )
+end
+
+-- Load Market Config (for old scales)
+local market = to_map(redis.call('HGETALL', market_key))
+if next(market) == nil then
+  return cjson.encode({ error = 'UNKNOWN_MARKET' })
+end
+
+local base_asset = market['base_asset']
+local quote_asset = market['quote_asset']
+local old_price_scale = tonumber(market['price_scale'])
+local old_quantity_scale = tonumber(market['quantity_scale'])
+local maker_fee_bps = tonumber(market['maker_fee_bps'] or '0')
+
+-- Load Asset Factors
+local base_asset_map = to_map(redis.call('HGETALL', 'asset:' .. base_asset))
+local quote_asset_map = to_map(redis.call('HGETALL', 'asset:' .. quote_asset))
+local base_balance_scale = tonumber(base_asset_map['balance_scale'] or '0')
+local quote_balance_scale = tonumber(quote_asset_map['balance_scale'] or '0')
+
+local function compute_factor(balance_scale, market_scale)
+  if market_scale <= 0 then return 0 end
+  local div = math.floor(balance_scale / market_scale)
+  if (div * market_scale) ~= balance_scale then return 0 end
+  return div
+end
+
+local new_base_factor = compute_factor(base_balance_scale, new_quantity_scale)
+local new_quote_factor = compute_factor(quote_balance_scale, new_price_scale)
+
+if new_base_factor == 0 or new_quote_factor == 0 then
+  return cjson.encode({ error = 'ASSET_SCALE_MISMATCH' })
+end
+
+local processed_orders_count = 0
+local processed_levels_count = 0
+local is_buy = (side == 'BUY')
+
+-- Iterate over provided price members
+for i = 6, #ARGV do
+  local old_price_member = ARGV[i]
+  local old_price = as_number(old_price_member)
+  local old_queue_key = 'queue:' .. symbol .. ':' .. side .. ':' .. old_price_member
+
+  -- Calculate New Price
+  local new_price = math.floor(old_price * new_price_scale / old_price_scale)
+  local new_price_member = tostring(new_price)
+  local new_queue_key_tmp = 'queue:' .. symbol .. ':' .. side .. ':' .. new_price_member .. ':TMP'
+
+  local orders = redis.call('LRANGE', old_queue_key, 0, -1)
+  -- Note: We do NOT delete the old queue here.
+  -- We leave old data intact until finalize step to be safe,
+  -- OR we can delete it now to save space?
+  -- Safety first: If script fails midway, we want to be able to retry.
+  -- But if we don't delete, re-running this batch will duplicate data in TMP.
+  -- Assumption: The caller handles idempotency or we clear TMP before starting.
+  -- Actually, let's delete the old queue key as we process it.
+  -- If we crash, we are in a halfway state anyway (Maintenance Mode).
+  redis.call('DEL', old_queue_key)
+
+  for _, order_id in ipairs(orders) do
+    local order_key = 'order:' .. order_id
+    local order = to_map(redis.call('HGETALL', order_key))
+
+    if next(order) then
+      processed_orders_count = processed_orders_count + 1
+      local old_qty = as_number(order['quantity'])
+      local old_rem = as_number(order['remaining'])
+      local old_reserved_base = as_number(order['reserved_base'])
+      local old_reserved_quote = as_number(order['reserved_quote'])
+      local user_id = order['user_id']
+
+      local new_qty = math.floor(old_qty * new_quantity_scale / old_quantity_scale)
+      local new_rem = math.floor(old_rem * new_quantity_scale / old_quantity_scale)
+
+      local new_reserved_base = 0
+      local new_reserved_quote = 0
+
+      if side == 'SELL' then
+        new_reserved_base = new_rem * new_base_factor
+      else
+        local quote_val = math.floor((new_price * new_rem) / new_quantity_scale)
+        local fee = math.floor((quote_val * maker_fee_bps) / 10000)
+        local total_quote = quote_val + fee
+        new_reserved_quote = total_quote * new_quote_factor
+      end
+
+      local refund_base = old_reserved_base - new_reserved_base
+      local refund_quote = old_reserved_quote - new_reserved_quote
+
+      if refund_base > 0 then
+        local bal_key = 'balance:' .. user_id
+        redis.call('HINCRBY', bal_key, base_asset .. ':reserved', -refund_base)
+        redis.call('HINCRBY', bal_key, base_asset .. ':available', refund_base)
+        append_ledger(user_id, base_asset, 'available', refund_base, 'DUST_REFUND', timestamp)
+        append_ledger(user_id, base_asset, 'reserved', -refund_base, 'DUST_RELEASE', timestamp)
+      end
+
+      if refund_quote > 0 then
+        local bal_key = 'balance:' .. user_id
+        redis.call('HINCRBY', bal_key, quote_asset .. ':reserved', -refund_quote)
+        redis.call('HINCRBY', bal_key, quote_asset .. ':available', refund_quote)
+        append_ledger(user_id, quote_asset, 'available', refund_quote, 'DUST_REFUND', timestamp)
+        append_ledger(user_id, quote_asset, 'reserved', -refund_quote, 'DUST_RELEASE', timestamp)
+      end
+
+      if new_rem > 0 then
+        redis.call('HMSET', order_key,
+          'price', new_price_member,
+          'quantity', tostring(new_qty),
+          'remaining', tostring(new_rem),
+          'reserved_base', tostring(new_reserved_base),
+          'reserved_quote', tostring(new_reserved_quote)
+        )
+        redis.call('RPUSH', new_queue_key_tmp, order_id)
+
+        -- Accumulate Volume in TMP
+        redis.call('HINCRBY', volume_tmp_key, new_price_member, new_rem)
+
+        -- Add to TMP Book
+        local score = is_buy and -new_price or new_price
+        redis.call('ZADD', book_tmp_key, score, new_price_member)
+      else
+        redis.call('HMSET', order_key,
+          'price', new_price_member,
+          'quantity', tostring(new_qty),
+          'remaining', '0',
+          'reserved_base', '0',
+          'reserved_quote', '0',
+          'status', 'FILLED'
+        )
+        redis.call('ZREM', 'user_orders:' .. user_id .. ':' .. symbol, order_id)
+        redis.call('SET', 'order_tombstone:' .. order_id, 'FILLED', 'EX', 86400)
+        redis.call('DEL', order_key)
+      end
+    end
+  end
+  processed_levels_count = processed_levels_count + 1
+end
+
+return cjson.encode({ processed_orders = processed_orders_count, processed_levels = processed_levels_count })

data/redis_scripts/update_market_precision.lua

@@ -0,0 +1,260 @@
+--[[
+update_market_precision.lua
+Revises all orders for a market to match new precision settings.
+Refunds any "dust" amounts to user balances.
+
+KEYS:
+  1. market:{symbol}
+  2. book:{symbol}:BUY
+  3. book:{symbol}:SELL
+  4. volume:{symbol}:BUY
+  5. volume:{symbol}:SELL
+  6. orders:{symbol} (for events)
+
+ARGV:
+  1. symbol
+  2. new_price_scale
+  3. new_quantity_scale
+  4. timestamp
+
+Returns:
+  JSON object { updated_orders: N, refunds: M }
+]]
+
+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 orders_key = KEYS[6]
+
+local symbol = ARGV[1]
+local new_price_scale = tonumber(ARGV[2])
+local new_quantity_scale = tonumber(ARGV[3])
+local timestamp = tonumber(ARGV[4])
+
+if not (symbol and new_price_scale and new_quantity_scale and timestamp) then
+  return cjson.encode({ error = 'INVALID_ARGUMENTS' })
+end
+
+if new_price_scale <= 0 or new_quantity_scale <= 0 then
+  return cjson.encode({ error = 'INVALID_SCALE' })
+end
+
+-- Helper: Convert HGETALL to map
+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)
+  return tonumber(value) or 0
+end
+
+-- Helper: Append Ledger (Copied from match_order.lua - shortened)
+local function append_ledger(user_id, asset, bucket, delta, reason, ts)
+  if delta == 0 then return end
+  local seq = redis.call('INCR', 'ledger_seq:' .. user_id .. ':' .. asset)
+  local ledger_biz_id = 'PRECISION:' .. symbol .. ':' .. ts .. ':' .. seq
+  redis.call('XADD', 'account_ledger', 'MAXLEN', '~', 1000000, '*',
+    'user_id', user_id,
+    'asset', asset,
+    'bucket', bucket,
+    'amount', tostring(delta),
+    'reason', reason,
+    'ts', tostring(ts),
+    'sequence', tostring(seq),
+    'biz_id', ledger_biz_id
+  )
+end
+
+-- Load Market
+local market = to_map(redis.call('HGETALL', market_key))
+if next(market) == nil then
+  return cjson.encode({ error = 'UNKNOWN_MARKET' })
+end
+
+local base_asset = market['base_asset']
+local quote_asset = market['quote_asset']
+local old_price_scale = tonumber(market['price_scale'])
+local old_quantity_scale = tonumber(market['quantity_scale'])
+local maker_fee_bps = tonumber(market['maker_fee_bps'] or '0')
+
+-- Load Asset Configs for Factors
+local base_asset_map = to_map(redis.call('HGETALL', 'asset:' .. base_asset))
+local quote_asset_map = to_map(redis.call('HGETALL', 'asset:' .. quote_asset))
+local base_balance_scale = tonumber(base_asset_map['balance_scale'] or '0')
+local quote_balance_scale = tonumber(quote_asset_map['balance_scale'] or '0')
+
+-- Validate Asset Scales
+local function compute_factor(balance_scale, market_scale)
+  if market_scale <= 0 then return 0 end
+  local div = math.floor(balance_scale / market_scale)
+  if (div * market_scale) ~= balance_scale then return 0 end
+  return div
+end
+
+local new_base_factor = compute_factor(base_balance_scale, new_quantity_scale)
+local new_quote_factor = compute_factor(quote_balance_scale, new_price_scale)
+
+if new_base_factor == 0 or new_quote_factor == 0 then
+  return cjson.encode({ error = 'ASSET_SCALE_MISMATCH_WITH_NEW_CONFIG' })
+end
+
+-- Update Market Config
+redis.call('HSET', market_key, 'price_scale', new_price_scale, 'quantity_scale', new_quantity_scale)
+
+local updated_count = 0
+local sides = { 'BUY', 'SELL' }
+local queues_to_rename = {} -- { {old_key, new_key, is_tmp} }
+-- Actually we use TMP keys for new queues
+
+local function process_side(side)
+  local is_buy = (side == 'BUY')
+  local book_key = is_buy and book_buy_key or book_sell_key
+  local volume_key = is_buy and volume_buy_key or volume_sell_key
+
+  -- Read all levels
+  local levels = redis.call('ZRANGE', book_key, 0, -1, 'WITHSCORES')
+
+  -- Clear old book and volume
+  redis.call('DEL', book_key)
+  redis.call('DEL', volume_key)
+
+  -- We will rebuild book/volume in memory then write
+  local new_book = {}   -- price -> score
+  local new_volume = {} -- price -> volume
+
+  for i = 1, #levels, 2 do
+    local old_price_member = levels[i]
+    local old_price = as_number(old_price_member) -- This is the price string/member
+    -- Note: Score is also available but we use member as source of truth for price value
+
+    local old_queue_key = 'queue:' .. symbol .. ':' .. side .. ':' .. old_price_member
+
+    -- Calculate New Price
+    -- Logic: new_p = floor(old_p * new_scale / old_scale)
+    local new_price = math.floor(old_price * new_price_scale / old_price_scale)
+    local new_price_member = tostring(new_price)
+
+    -- Iterate Orders
+    local orders = redis.call('LRANGE', old_queue_key, 0, -1)
+    redis.call('DEL', old_queue_key) -- Delete old queue
+
+    local new_queue_key_tmp = 'queue:' .. symbol .. ':' .. side .. ':' .. new_price_member .. ':TMP'
+
+    for _, order_id in ipairs(orders) do
+      local order_key = 'order:' .. order_id
+      local order = to_map(redis.call('HGETALL', order_key))
+
+      if next(order) then
+        updated_count = updated_count + 1
+        local old_qty = as_number(order['quantity'])
+        local old_rem = as_number(order['remaining'])
+        local old_reserved_base = as_number(order['reserved_base'])
+        local old_reserved_quote = as_number(order['reserved_quote'])
+        local user_id = order['user_id']
+
+        -- Calculate New Qty/Rem
+        local new_qty = math.floor(old_qty * new_quantity_scale / old_quantity_scale)
+        local new_rem = math.floor(old_rem * new_quantity_scale / old_quantity_scale)
+
+        -- Calculate New Reserved
+        local new_reserved_base = 0
+        local new_reserved_quote = 0
+
+        if side == 'SELL' then
+          -- SELL: Reserve Base = rem * base_factor
+          new_reserved_base = new_rem * new_base_factor
+        else
+          -- BUY: Reserve Quote = floor(price * rem / qty_scale) + fee
+          -- fee = floor(quote * bps / 10000)
+          local quote_val = math.floor((new_price * new_rem) / new_quantity_scale)
+          local fee = math.floor((quote_val * maker_fee_bps) / 10000)
+          local total_quote = quote_val + fee
+          new_reserved_quote = total_quote * new_quote_factor
+        end
+
+        -- Refunds
+        local refund_base = old_reserved_base - new_reserved_base
+        local refund_quote = old_reserved_quote - new_reserved_quote
+
+        if refund_base > 0 then
+          local bal_key = 'balance:' .. user_id
+          redis.call('HINCRBY', bal_key, base_asset .. ':reserved', -refund_base)
+          redis.call('HINCRBY', bal_key, base_asset .. ':available', refund_base)
+          append_ledger(user_id, base_asset, 'available', refund_base, 'DUST_REFUND', timestamp)
+          append_ledger(user_id, base_asset, 'reserved', -refund_base, 'DUST_RELEASE', timestamp)
+        end
+
+        if refund_quote > 0 then
+          local bal_key = 'balance:' .. user_id
+          redis.call('HINCRBY', bal_key, quote_asset .. ':reserved', -refund_quote)
+          redis.call('HINCRBY', bal_key, quote_asset .. ':available', refund_quote)
+          append_ledger(user_id, quote_asset, 'available', refund_quote, 'DUST_REFUND', timestamp)
+          append_ledger(user_id, quote_asset, 'reserved', -refund_quote, 'DUST_RELEASE', timestamp)
+        end
+
+        -- Update Order
+        if new_rem > 0 then
+          redis.call('HMSET', order_key,
+            'price', new_price_member,
+            'quantity', tostring(new_qty),
+            'remaining', tostring(new_rem),
+            'reserved_base', tostring(new_reserved_base),
+            'reserved_quote', tostring(new_reserved_quote)
+          )
+          -- Push to new queue (TMP)
+          redis.call('RPUSH', new_queue_key_tmp, order_id)
+
+          -- Accumulate Volume
+          new_volume[new_price_member] = (new_volume[new_price_member] or 0) + new_rem
+
+          -- Mark this TMP key for renaming later (deduplicate)
+          queues_to_rename[new_queue_key_tmp] = 'queue:' .. symbol .. ':' .. side .. ':' .. new_price_member
+        else
+          -- Filled (Dust eliminated remaining)
+          redis.call('HMSET', order_key,
+            'price', new_price_member,
+            'quantity', tostring(new_qty),
+            'remaining', '0',
+            'reserved_base', '0',
+            'reserved_quote', '0',
+            'status', 'FILLED'
+          )
+          -- Remove from User Index
+          local user_idx = 'user_orders:' .. user_id .. ':' .. symbol
+          redis.call('ZREM', user_idx, order_id)
+          -- Tombstone
+          redis.call('SET', 'order_tombstone:' .. order_id, 'FILLED', 'EX', 86400)
+          redis.call('DEL', order_key)
+        end
+      end
+    end
+  end
+
+  -- Write Book and Volume
+  for price_str, vol in pairs(new_volume) do
+    if vol > 0 then
+      local price_val = tonumber(price_str)
+      local score = is_buy and -price_val or price_val
+      redis.call('ZADD', book_key, score, price_str)
+      redis.call('HSET', volume_key, price_str, vol)
+    end
+  end
+end
+
+process_side('BUY')
+process_side('SELL')
+
+-- Rename TMP queues to Real queues
+for tmp_key, real_key in pairs(queues_to_rename) do
+  redis.call('RENAME', tmp_key, real_key)
+end
+
+return cjson.encode({ updated_orders = updated_count })

data/script/export_rdb_data.sh

@@ -0,0 +1,234 @@
+#!/bin/bash
+# Export balances and ledger sequences from a Redis RDB file to CSV.
+#
+# Outputs:
+#   - balances_{SNAPSHOT_ID}_{TIMESTAMP}.csv: User balances (available, reserved).
+#   - ledger_sequences_{SNAPSHOT_ID}_{TIMESTAMP}.csv: Ledger sequence numbers.
+#
+# Dependencies:
+#   - rdb-cli (included in bin/)
+#   - jq (brew install jq / apt install jq)
+#
+# Usage:
+#   ./script/export_rdb_data.sh [options] [path/to/dump.rdb]
+#
+# Options:
+#   -h, --host <host>     Redis host (default: 127.0.0.1)
+#   -p, --port <port>     Redis port (default: 6379)
+#   -a, --password <pwd>  Redis password
+#   -u, --url <url>       Redis URL (e.g. redis://[:password@]host:port[/db])
+#
+
+set -e
+
+REDIS_HOST="127.0.0.1"
+REDIS_PORT="6379"
+REDIS_PASS=""
+REDIS_URL=""
+USE_REMOTE=false
+POSITIONAL_ARGS=()
+
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    -h|--host)
+      REDIS_HOST="$2"
+      USE_REMOTE=true
+      shift 2
+      ;;
+    -p|--port)
+      REDIS_PORT="$2"
+      USE_REMOTE=true
+      shift 2
+      ;;
+    -a|--password)
+      REDIS_PASS="$2"
+      USE_REMOTE=true
+      shift 2
+      ;;
+    -u|--url)
+      REDIS_URL="$2"
+      USE_REMOTE=true
+      shift 2
+      ;;
+    *)
+      POSITIONAL_ARGS+=("$1")
+      shift
+      ;;
+  esac
+done
+
+set -- "${POSITIONAL_ARGS[@]}"
+
+if [ ${#POSITIONAL_ARGS[@]} -gt 0 ]; then
+  RDB_FILE="${POSITIONAL_ARGS[0]}"
+  if [ ! -f "$RDB_FILE" ]; then
+    echo "Error: RDB file '$RDB_FILE' not found."
+    exit 1
+  fi
+  CLEANUP_RDB=false
+elif [ "$USE_REMOTE" = true ]; then
+  if ! command -v redis-cli &> /dev/null; then
+    echo "Error: redis-cli not found. Cannot dump from remote Redis."
+    exit 1
+  fi
+
+  # Create tmp directory if it doesn't exist
+  mkdir -p tmp
+
+  RDB_FILE="tmp/dump_$(date +%s).rdb"
+
+  if [ -n "$REDIS_URL" ]; then
+    echo "Dumping data from Redis URL to ${RDB_FILE}..."
+    
+    # Check if URL contains password but empty username (e.g. redis://:password@host...)
+    # This causes redis-cli to fail with "invalid uri scheme" or similar errors depending on version
+    # If detected, inject 'default' as username
+    if [[ "$REDIS_URL" =~ redis://:[^@]+@ ]]; then
+      echo "  Detected empty username with password in REDIS_URL. Injecting 'default' username..."
+      REDIS_URL="${REDIS_URL/redis:\/\/:/redis:\/\/default:}"
+    fi
+
+    CMD="redis-cli -u $REDIS_URL --rdb $RDB_FILE"
+  else
+    echo "Dumping data from ${REDIS_HOST}:${REDIS_PORT} to ${RDB_FILE}..."
+
+    CMD="redis-cli -h $REDIS_HOST -p $REDIS_PORT"
+    if [ -n "$REDIS_PASS" ]; then
+      CMD="$CMD -a $REDIS_PASS"
+    fi
+    CMD="$CMD --rdb $RDB_FILE"
+  fi
+
+  $CMD
+
+  if [ ! -f "$RDB_FILE" ]; then
+    echo "Error: Failed to dump RDB file from remote."
+    exit 1
+  fi
+  CLEANUP_RDB=true
+else
+  # Default fallback
+  RDB_FILE="dump.rdb"
+  if [ ! -f "$RDB_FILE" ]; then
+    echo "Error: RDB file '$RDB_FILE' not found."
+    echo "Usage: $0 [options] [path/to/dump.rdb]"
+    exit 1
+  fi
+  CLEANUP_RDB=false
+fi
+
+# Check for rdb-cli (librdb)
+if [ -n "$RDB_CLI_CMD" ]; then
+  RDB_CMD="$RDB_CLI_CMD"
+elif [ -f "./bin/rdb-cli" ]; then
+  RDB_CMD="./bin/rdb-cli"
+elif command -v rdb-cli &> /dev/null; then
+  RDB_CMD="rdb-cli"
+else
+  echo "Error: 'rdb-cli' command not found. Please ensure bin/rdb-cli exists."
+  exit 1
+fi
+
+if ! command -v jq &> /dev/null; then
+  echo "Error: 'jq' command not found. Please install jq."
+  exit 1
+fi
+
+echo "Processing $RDB_FILE..."
+
+# Create tmp directory if it doesn't exist
+mkdir -p tmp
+
+echo "Exporting balances to tmp/balances.csv..."
+echo "user_id,asset,available,reserved" > tmp/balances.csv
+
+# rdb-cli json outputs: [{"key": value, "key2": value2}] (Array of objects, usually one per DB)
+# We filter for keys starting with "balance:" using -k
+$RDB_CMD "$RDB_FILE" -k "balance:*" json > tmp/balances_raw.json
+# echo "Raw JSON:"
+# cat tmp/balances_raw.json
+
+cat tmp/balances_raw.json | jq -r '
+  .[] | to_entries[] |
+  .key as $k |
+  .value | to_entries |
+  map(
+    (.key | split(":")) as $p |
+    {asset: $p[0], bucket: $p[1], val: .value}
+  ) |
+  group_by(.asset)[] |
+  {
+    user: ($k | split(":")[1]),
+    asset: .[0].asset,
+    avail: (map(select(.bucket=="available"))[0].val // "0"),
+    reserved: (map(select(.bucket=="reserved"))[0].val // "0")
+  } |
+  "\(.user),\(.asset),\(.avail),\(.reserved)"
+' >> tmp/balances.csv
+
+echo "  -> Wrote $(wc -l < tmp/balances.csv) lines (including header)"
+
+echo "Exporting ledger sequences to tmp/ledger_sequences.csv..."
+echo "user_id,asset,sequence" > tmp/ledger_sequences.csv
+
+# Filter for keys starting with "ledger_seq:"
+$RDB_CMD "$RDB_FILE" -k "ledger_seq:*" json > tmp/ledger_seq_raw.json
+
+cat tmp/ledger_seq_raw.json | jq -r '
+  .[] | to_entries[] |
+  (.key | split(":")) as $p |
+  "\( $p[1] ),\( $p[2] ),\( .value )"
+' >> tmp/ledger_sequences.csv
+
+echo "  -> Wrote $(wc -l < tmp/ledger_sequences.csv) lines (including header)"
+
+# 3. Export Snapshot ID (Last Entry ID from account_ledger)
+echo "Exporting snapshot ID from account_ledger..."
+
+# rdb-cli output for stream varies based on Redis stream structure
+# Try to get the last entry from account_ledger stream
+# Note: rdb-cli outputs invalid JSON ("account_ledger":) for empty streams, so we need to fix that
+$RDB_CMD "$RDB_FILE" -k "account_ledger" json | sed 's/"account_ledger":$/&null/' > tmp/stream_raw.json
+
+# Debug: show the raw JSON structure (commented out)
+# cat stream_raw.json
+
+# Actual JSON structure from rdb-cli for Redis streams:
+# [{"account_ledger": {"entries": [{"id": "...", "items": {"ts": "...", ...}}, ...]}}]
+# Note: Some databases may have empty account_ledger, so we need to filter them out
+SNAPSHOT_DATA=$(cat tmp/stream_raw.json | jq -r '
+  try (
+    .[] |
+    select(has("account_ledger") and .account_ledger != null and (.account_ledger.entries // null) != null) |
+    .account_ledger.entries |
+    select(length > 0) |
+    last | "\(.id) \(.items.ts // 0)"
+  ) catch "0-0 0"
+')
+
+# Take the last non-empty line (from the database with actual data)
+SNAPSHOT_LINE=$(echo "$SNAPSHOT_DATA" | grep -v '^0-0 0$' | tail -n 1)
+if [ -z "$SNAPSHOT_LINE" ]; then
+  SNAPSHOT_LINE="0-0 0"
+fi
+
+SNAPSHOT_ID=$(echo "$SNAPSHOT_LINE" | awk '{print $1}')
+SNAPSHOT_TS=$(echo "$SNAPSHOT_LINE" | awk '{print $2}')
+
+if [ -z "$SNAPSHOT_ID" ] || [ "$SNAPSHOT_ID" == "null" ]; then
+  SNAPSHOT_ID="0-0"
+fi
+
+mv tmp/balances.csv tmp/balances_${SNAPSHOT_ID}_${SNAPSHOT_TS}.csv
+mv tmp/ledger_sequences.csv tmp/ledger_sequences_${SNAPSHOT_ID}_${SNAPSHOT_TS}.csv
+echo "Snapshot ID: $SNAPSHOT_ID, Timestamp: $SNAPSHOT_TS"
+echo "Renamed balances.csv to tmp/balances_${SNAPSHOT_ID}_${SNAPSHOT_TS}.csv"
+echo "Renamed ledger_sequences.csv to tmp/ledger_sequences_${SNAPSHOT_ID}_${SNAPSHOT_TS}.csv"
+
+# Cleanup
+if [ "$CLEANUP_RDB" = true ]; then
+  echo "Cleaning up temporary RDB file $RDB_FILE..."
+  rm "$RDB_FILE"
+fi
+
+rm -f tmp/balances_raw.json tmp/ledger_seq_raw.json tmp/stream_raw.json