# Batch Processing Documentation

## Overview

This document describes batch processing capabilities for the trustless bridge system, allowing multiple operations to be executed in a single transaction.

## Current State

### Individual Operations

Currently, all operations are individual:
- One claim submission per transaction
- One challenge per transaction
- One finalization per transaction

### Gas Costs

- Multiple transactions = multiple base costs (21k gas each)
- Batch operations = single base cost + operation costs

## Proposed Batch Functions

### 1. Batch Claim Submission

**Function**: `InboxETH.submitClaimsBatch()`

**Implementation**:
```solidity
function submitClaimsBatch(
    uint256[] calldata depositIds,
    address[] calldata assets,
    uint256[] calldata amounts,
    address[] calldata recipients,
    bytes[] calldata proofs
) external payable {
    require(depositIds.length == assets.length, "Length mismatch");
    require(depositIds.length == amounts.length, "Length mismatch");
    require(depositIds.length == recipients.length, "Length mismatch");
    
    uint256 totalBond = 0;
    for (uint256 i = 0; i < depositIds.length; i++) {
        totalBond += bondManager.getRequiredBond(amounts[i]);
    }
    require(msg.value >= totalBond, "Insufficient bond");
    
    for (uint256 i = 0; i < depositIds.length; i++) {
        submitClaim(depositIds[i], assets[i], amounts[i], recipients[i], proofs[i]);
    }
}
```

**Gas Savings**: ~20k gas per additional claim (saves base cost)

### 2. Batch Finalization

**Function**: `ChallengeManager.finalizeClaimsBatch()`

**Implementation**:
```solidity
function finalizeClaimsBatch(uint256[] calldata depositIds) external {
    for (uint256 i = 0; i < depositIds.length; i++) {
        finalizeClaim(depositIds[i]);
    }
}
```

**Gas Savings**: ~20k gas per additional finalization

### 3. Batch Bond Release

**Function**: `BondManager.releaseBondsBatch()`

**Implementation**:
```solidity
function releaseBondsBatch(uint256[] calldata depositIds) external {
    for (uint256 i = 0; i < depositIds.length; i++) {
        releaseBond(depositIds[i]);
    }
}
```

**Gas Savings**: ~20k gas per additional release

## Benefits

### 1. Gas Efficiency

- Single base cost (21k gas) vs multiple
- Significant savings for multiple operations
- Example: 10 claims = 210k gas saved

### 2. User Experience

- Faster processing
- Single transaction
- Lower total gas costs

### 3. Network Efficiency

- Fewer transactions
- Reduced network congestion
- Lower overall gas usage

## Considerations

### 1. Transaction Size

- Batch operations increase transaction size
- May hit block gas limit
- Recommend max batch size (e.g., 50 operations)

### 2. Error Handling

- If one operation fails, entire batch fails
- Consider partial success mechanisms
- Or revert all on any failure

### 3. Reentrancy

- Batch operations increase reentrancy risk
- Ensure proper guards
- Use nonReentrant modifier

## Implementation

### Priority

1. **High**: Batch finalization (most common)
2. **Medium**: Batch claim submission
3. **Low**: Batch bond release

### Testing

Create comprehensive tests:
- `test/bridge/trustless/BatchOperations.t.sol`
- Test batch sizes
- Test error handling
- Test gas costs

## References

- Contracts: `contracts/bridge/trustless/`
- Test Suite: `test/bridge/trustless/BatchOperations.t.sol`

