# Gas Optimization Documentation

## Overview

This document describes gas optimization strategies and recommendations for the trustless bridge contracts.

## Current Gas Usage

### Hot Paths

1. **submitClaim()**: ~150k-200k gas
2. **challengeClaim()**: ~200k-300k gas
3. **finalizeClaim()**: ~50k-100k gas
4. **releaseToRecipient()**: ~100k-150k gas

## Optimization Strategies

### 1. Storage Optimization

**Current**: Structs may not be optimally packed

**Recommendation**: Pack structs efficiently
```solidity
// Before
struct Claim {
    uint256 depositId;      // 32 bytes
    address asset;          // 20 bytes
    uint256 amount;         // 32 bytes
    address recipient;      // 20 bytes
    uint256 challengeWindowEnd; // 32 bytes
    bool finalized;         // 1 byte
    bool challenged;        // 1 byte
}
// Total: ~150 bytes

// After (packed)
struct Claim {
    uint256 depositId;       // 32 bytes
    address asset;         // 20 bytes
    address recipient;     // 20 bytes
    uint256 amount;        // 32 bytes
    uint256 challengeWindowEnd; // 32 bytes
    bool finalized;        // 1 byte
    bool challenged;       // 1 byte
}
// Packed: address + bool + bool in same slot
```

### 2. Minimize SLOAD Operations

**Current**: Multiple storage reads

**Recommendation**: Cache storage values
```solidity
// Before
if (claims[depositId].finalized) revert();
if (claims[depositId].challenged) revert();
if (block.timestamp > claims[depositId].challengeWindowEnd) revert();

// After
Claim storage claim = claims[depositId];
if (claim.finalized) revert();
if (claim.challenged) revert();
if (block.timestamp > claim.challengeWindowEnd) revert();
```

### 3. Batch Operations

**Current**: Individual operations

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

### 4. Event Optimization

**Current**: Multiple events

**Recommendation**: Combine events where possible
```solidity
// Before
emit ClaimSubmitted(...);
emit BondPosted(...);

// After
emit ClaimSubmittedWithBond(...);
```

## Gas Benchmarking

### Test Suite

Create `test/bridge/trustless/GasBenchmark.t.sol` to benchmark:
- Claim submission gas costs
- Challenge gas costs
- Finalization gas costs
- Release gas costs

### Target Gas Costs

- **submitClaim()**: < 150k gas
- **challengeClaim()**: < 250k gas
- **finalizeClaim()**: < 80k gas
- **releaseToRecipient()**: < 120k gas

## Implementation Priority

### High Priority
1. Storage packing
2. SLOAD minimization
3. Batch operations

### Medium Priority
4. Event optimization
5. Function inlining
6. Loop optimization

### Low Priority
7. Assembly optimizations
8. Custom errors (already implemented)

## References

- Contracts: `contracts/bridge/trustless/`
- Test Suite: `test/bridge/trustless/`

