Initial commit: add .gitignore and README

docs/PERFORMANCE_TUNING_GUIDE.md

@@ -0,0 +1,182 @@
+# Performance Tuning Guide
+
+## Overview
+
+This guide covers optimization strategies for improving gas efficiency and execution speed.
+
+## Gas Optimization
+
+### 1. Batch Size Optimization
+
+**Problem**: Large batches consume more gas
+
+**Solution**:
+- Optimize batch sizes (typically 5-10 calls)
+- Split very large strategies into multiple transactions
+- Use flash loans to reduce intermediate steps
+
+### 2. Call Optimization
+
+**Problem**: Redundant or inefficient calls
+
+**Solution**:
+- Combine similar operations
+- Remove unnecessary calls
+- Use protocol-specific batch functions (e.g., Balancer batchSwap)
+
+### 3. Storage Optimization
+
+**Problem**: Excessive storage operations
+
+**Solution**:
+- Minimize state changes
+- Use events instead of storage where possible
+- Cache values when appropriate
+
+## RPC Optimization
+
+### 1. Connection Pooling
+
+**Problem**: Slow RPC responses
+
+**Solution**:
+- Use multiple RPC providers
+- Implement connection pooling
+- Cache non-critical data
+
+### 2. Batch RPC Calls
+
+**Problem**: Multiple sequential RPC calls
+
+**Solution**:
+- Use `eth_call` batch requests
+- Parallelize independent calls
+- Cache results with TTL
+
+### 3. Provider Selection
+
+**Problem**: Single point of failure
+
+**Solution**:
+- Use multiple providers
+- Implement failover logic
+- Monitor provider health
+
+## Caching Strategy
+
+### 1. Price Data Caching
+
+```typescript
+// Cache prices with 60s TTL
+const priceCache = new Map<string, { price: bigint; timestamp: number }>();
+
+async function getCachedPrice(token: string): Promise<bigint> {
+  const cached = priceCache.get(token);
+  if (cached && Date.now() - cached.timestamp < 60000) {
+    return cached.price;
+  }
+  const price = await fetchPrice(token);
+  priceCache.set(token, { price, timestamp: Date.now() });
+  return price;
+}
+```
+
+### 2. Address Caching
+
+```typescript
+// Cache protocol addresses (rarely change)
+const addressCache = new Map<string, string>();
+```
+
+### 3. Gas Estimate Caching
+
+```typescript
+// Cache gas estimates with short TTL (10s)
+const gasCache = new Map<string, { estimate: bigint; timestamp: number }>();
+```
+
+## Strategy Optimization
+
+### 1. Reduce Steps
+
+**Problem**: Too many steps increase gas
+
+**Solution**:
+- Combine operations where possible
+- Use protocol batch functions
+- Eliminate unnecessary steps
+
+### 2. Optimize Flash Loans
+
+**Problem**: Flash loan overhead
+
+**Solution**:
+- Only use flash loans when necessary
+- Minimize operations in callback
+- Optimize repayment logic
+
+### 3. Guard Optimization
+
+**Problem**: Expensive guard evaluations
+
+**Solution**:
+- Cache guard results when possible
+- Use cheaper guards first
+- Skip guards for trusted strategies
+
+## Monitoring Performance
+
+### Metrics to Track
+
+1. **Gas Usage**: Average gas per execution
+2. **Execution Time**: Time to complete strategy
+3. **RPC Latency**: Response times
+4. **Cache Hit Rate**: Caching effectiveness
+5. **Success Rate**: Execution success percentage
+
+### Tools
+
+- Gas tracker dashboard
+- RPC latency monitoring
+- Cache hit rate tracking
+- Performance profiling
+
+## Best Practices
+
+1. **Profile First**: Measure before optimizing
+2. **Optimize Hot Paths**: Focus on frequently used code
+3. **Test Changes**: Verify optimizations don't break functionality
+4. **Monitor Impact**: Track improvements
+5. **Document Changes**: Keep optimization notes
+
+## Common Optimizations
+
+### Before
+```typescript
+// Multiple sequential calls
+const price1 = await oracle.getPrice(token1);
+const price2 = await oracle.getPrice(token2);
+const price3 = await oracle.getPrice(token3);
+```
+
+### After
+```typescript
+// Parallel calls
+const [price1, price2, price3] = await Promise.all([
+  oracle.getPrice(token1),
+  oracle.getPrice(token2),
+  oracle.getPrice(token3),
+]);
+```
+
+## Performance Checklist
+
+- [ ] Optimize batch sizes
+- [ ] Implement caching
+- [ ] Use connection pooling
+- [ ] Parallelize independent calls
+- [ ] Monitor gas usage
+- [ ] Profile execution time
+- [ ] Optimize hot paths
+- [ ] Document optimizations
+