Batch Processing Implementation Design

2. Issues Identified

4. Implementation Recommendations

Priority 1: Transaction Queue with Status Tracking

Add a queue system to track pending transactions and enable retry logic.

// New Prisma model
model TransactionQueue {
  id           String   @id @default(uuid())
  type         String   // 'order' | 'trade' | 'cancel'
  signedData   Json     // The signed order/trade data
  status       String   @default("pending") // pending | submitted | confirmed | failed
  txHash       String?
  retryCount   Int      @default(0)
  errorMessage String?
  userId       String
  createdAt    DateTime @default(now())
  updatedAt    DateTime @updatedAt
}

// Transaction states
// pending    -> waiting to be submitted
// submitted  -> TX sent, waiting for confirmation
// confirmed  -> TX confirmed on-chain
// failed     -> TX failed after max retries

Priority 2: Batch Order Matching with Multicall

Use the same pattern as handleBatchCancel() for order matching.

// Server-side batch matching (api/src/routes/trade.ts)
router.post('/execute-batch', async (req, res) => {
  const { orderPairs } = req.body; // Array of {takerOrder, makerOrder}

  // Encode all matchOrders calls
  const calls = orderPairs.map(({ taker, maker }) =>
    ctfExchange.interface.encodeFunctionData(
      "matchOrders",
      [taker, [maker], taker.takerAmount, maker.makerAmount, 0]
    )
  );

  // Single atomic transaction
  const tx = await ctfExchange.multicall(calls);
  const receipt = await tx.wait();

  // Save all trades to DB after confirmation
  await prisma.trade.createMany({
    data: orderPairs.map(pair => ({
      // ... trade details
      txHash: receipt.transactionHash,
      status: 'confirmed'
    }))
  });

  return res.json({ success: true, txHash: receipt.transactionHash });
});

Priority 3: Single Signature for Sweep Operations

User signs once for entire trade amount, server splits as needed.

// Frontend: useTrade.ts
const executeSweep = async (side: 'BUY' | 'SELL', totalAmount: bigint) => {
  // Sign a single "intent" order for total amount
  const sweepIntent = {
    maker: userAddress,
    side: side,
    tokenId: outcomeTokenId,
    makerAmount: side === 'BUY' ? totalUSDCNeeded : totalTokensToSell,
    takerAmount: side === 'BUY' ? totalTokensExpected : totalUSDCExpected,
    nonce: Date.now(),
    expiration: Math.floor(Date.now() / 1000) + 3600,
  };

  // Single signature
  const signature = await signer.signTypedData(domain, ORDER_TYPES, sweepIntent);

  // Server handles splitting into sub-orders for matching
  const response = await fetch(`${API_URL}/api/trade/sweep`, {
    method: 'POST',
    body: JSON.stringify({
      intent: sweepIntent,
      signature,
      maxSlippage: 0.01 // 1% slippage tolerance
    })
  });

  return response.json();
};

Priority 4: Background Transaction Processor

A worker that processes the transaction queue with retry logic.

// api/src/workers/transactionProcessor.ts
class TransactionProcessor {
  private readonly MAX_RETRIES = 3;
  private readonly RETRY_DELAY_MS = 5000;

  async processQueue() {
    // Get pending transactions
    const pending = await prisma.transactionQueue.findMany({
      where: { status: 'pending' },
      orderBy: { createdAt: 'asc' },
      take: 10
    });

    for (const tx of pending) {
      try {
        // Update to submitted
        await prisma.transactionQueue.update({
          where: { id: tx.id },
          data: { status: 'submitted' }
        });

        // Execute based on type
        const result = await this.executeTransaction(tx);

        // Update to confirmed
        await prisma.transactionQueue.update({
          where: { id: tx.id },
          data: {
            status: 'confirmed',
            txHash: result.transactionHash
          }
        });

      } catch (error) {
        await this.handleError(tx, error);
      }
    }
  }

  private async handleError(tx: TransactionQueue, error: Error) {
    const newRetryCount = tx.retryCount + 1;

    if (newRetryCount >= this.MAX_RETRIES) {
      await prisma.transactionQueue.update({
        where: { id: tx.id },
        data: {
          status: 'failed',
          errorMessage: error.message,
          retryCount: newRetryCount
        }
      });
      // Notify user of failure
      await this.notifyUser(tx.userId, 'Transaction failed after retries');
    } else {
      // Reset to pending for retry
      await prisma.transactionQueue.update({
        where: { id: tx.id },
        data: {
          status: 'pending',
          retryCount: newRetryCount,
          errorMessage: error.message
        }
      });
    }
  }
}