Batch Deposit

import express from 'express';
import { verifySignature } from './security';

app.post('/deposit/batch', async (req, res) => {
  // Verify signature
  if (!verifySignature(req.body, req.headers.signature)) {
    return res.status(401).json({ type: 'ERROR', code: 'INVALID_SIGNATURE' });
  }

  const { bets } = req.body;

  try {
    // Process in transaction
    const result = await db.transaction(async (tx) => {
      const playerBalances = new Map();

      for (const bet of bets) {
        // Check idempotency
        const exists = await tx.query(
          'SELECT 1 FROM transactions WHERE tx_id = ?',
          [bet.tx_id]
        );

        if (exists.length > 0) continue;

        // Update balance
        await tx.execute(
          'UPDATE players SET balance = balance + ? WHERE id = ?',
          [bet.amount / 100, bet.player_id]
        );

        // Record transaction
        await tx.execute(
          'INSERT INTO transactions (tx_id, bet_id, player_id, amount) VALUES (?, ?, ?, ?)',
          [bet.tx_id, bet.bet_id, bet.player_id, bet.amount]
        );

        playerBalances.set(bet.player_id, null); // Mark for balance fetch
      }

      // Fetch updated balances
      const playerIds = Array.from(playerBalances.keys());
      const balances = await tx.query(
        'SELECT id, balance FROM players WHERE id IN (?)',
        [playerIds]
      );

      return balances.map(p => ({
        player_id: p.id,
        balance: p.balance
      }));
    });

    res.json({
      type: 'SUCCESS',
      balances: result,
      timestamp: Date.now()
    });
  } catch (error) {
    console.error('Batch deposit error:', error);
    res.status(500).json({
      type: 'ERROR',
      code: 'BATCH_PROCESSING_FAILED'
    });
  }
});

from flask import Flask, request, jsonify
from sqlalchemy import create_engine
from contextlib import contextmanager

@app.route('/deposit/batch', methods=['POST'])
def batch_deposit():
    # Verify signature
    if not verify_signature(request.get_json(), request.headers.get('signature')):
        return jsonify({'type': 'ERROR', 'code': 'INVALID_SIGNATURE'}), 401

    data = request.get_json()
    bets = data['bets']

    try:
        with transaction() as tx:
            player_ids = set()

            for bet in bets:
                # Check idempotency
                if tx.execute(
                    "SELECT 1 FROM transactions WHERE tx_id = %s",
                    (bet['tx_id'],)
                ).fetchone():
                    continue

                # Update balance
                tx.execute(
                    "UPDATE players SET balance = balance + %s WHERE id = %s",
                    (bet['amount'] / 100, bet['player_id'])
                )

                # Record transaction
                tx.execute(
                    "INSERT INTO transactions (tx_id, bet_id, player_id, amount) VALUES (%s, %s, %s, %s)",
                    (bet['tx_id'], bet['bet_id'], bet['player_id'], bet['amount'])
                )

                player_ids.add(bet['player_id'])

            # Fetch updated balances
            balances = tx.execute(
                "SELECT id, balance FROM players WHERE id = ANY(%s)",
                (list(player_ids),)
            ).fetchall()

            return jsonify({
                'type': 'SUCCESS',
                'balances': [
                    {'player_id': row[0], 'balance': float(row[1])}
                    for row in balances
                ],
                'timestamp': int(time.time() * 1000)
            })

    except Exception as e:
        print(f"Batch deposit error: {e}")
        return jsonify({
            'type': 'ERROR',
            'code': 'BATCH_PROCESSING_FAILED'
        }), 500

<?php
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;

Route::post('/deposit/batch', function (Request $request) {
    // Verify signature
    if (!verifySignature($request->all(), $request->header('signature'))) {
        return response()->json([
            'type' => 'ERROR',
            'code' => 'INVALID_SIGNATURE'
        ], 401);
    }

    $bets = $request->input('bets');

    try {
        $balances = DB::transaction(function () use ($bets) {
            $playerIds = [];

            foreach ($bets as $bet) {
                // Check idempotency
                $exists = DB::table('transactions')
                    ->where('tx_id', $bet['tx_id'])
                    ->exists();

                if ($exists) continue;

                // Update balance
                DB::table('players')
                    ->where('id', $bet['player_id'])
                    ->increment('balance', $bet['amount'] / 100);

                // Record transaction
                DB::table('transactions')->insert([
                    'tx_id' => $bet['tx_id'],
                    'bet_id' => $bet['bet_id'],
                    'player_id' => $bet['player_id'],
                    'amount' => $bet['amount']
                ]);

                $playerIds[] = $bet['player_id'];
            }

            // Fetch updated balances
            $playerIds = array_unique($playerIds);
            return DB::table('players')
                ->whereIn('id', $playerIds)
                ->get(['id', 'balance'])
                ->map(function ($player) {
                    return [
                        'player_id' => $player->id,
                        'balance' => (float) $player->balance
                    ];
                })->toArray();
        });

        return response()->json([
            'type' => 'SUCCESS',
            'balances' => $balances,
            'timestamp' => now()->timestamp * 1000
        ]);

    } catch (\Exception $e) {
        Log::error('Batch deposit error: ' . $e->getMessage());
        return response()->json([
            'type' => 'ERROR',
            'code' => 'BATCH_PROCESSING_FAILED'
        ], 500);
    }
});
?>