Gas Optimization Techniques for DeFi Smart Contracts

How we reduced gas costs by 67% in our AMM protocol

⛽ The Gas Problem: Real Numbers

Our Uniswap V3-style AMM was bleeding money. Every swap cost users 150,000+ gas. At 50 gwei, that's $15+ per transaction. Users were furious.

Here's how we cut gas costs from 150,000 to 49,000 per swap - a 67% reduction.

🧠 Understanding the EVM Gas Model

Gas Cost Breakdown (Pre-Optimization)

SWAP TRANSACTION (150,342 gas total):
├── SSTORE operations: 72,000 gas (48%)
├── SLOAD operations: 18,000 gas (12%)  
├── Contract calls: 24,000 gas (16%)
├── Arithmetic ops: 15,000 gas (10%)
├── Memory expansion: 9,000 gas (6%)
└── Other: 12,342 gas (8%)

The villain: Storage operations eating 60% of our gas!

🔬 Optimization #1: Storage Layout Optimization

Problem: Inefficient Storage Packing

Before (expensive):

contract SwapPoolBad {
    // Each variable takes a full 32-byte slot
    uint128 reserve0;          // Slot 0
    uint128 reserve1;          // Slot 1  
    uint32 blockTimestampLast; // Slot 2
    bool paused;               // Slot 3
    address token0;            // Slot 4
    address token1;            // Slot 5
    
    // Cost: 6 SSTORE operations = 120,000 gas
}

After (optimized):

contract SwapPoolOptimized {
    // Pack multiple variables into single slots
    struct PoolState {
        uint128 reserve0;          // Slot 0 (bytes 0-15)
        uint128 reserve1;          // Slot 0 (bytes 16-31)
        uint32 blockTimestampLast; // Slot 1 (bytes 0-3)
        bool paused;               // Slot 1 (byte 4)
        // 27 bytes unused in Slot 1
    }
    
    PoolState public poolState;
    
    address public immutable token0; // Embedded in bytecode
    address public immutable token1; // Embedded in bytecode
    
    // Cost: 2 SSTORE operations = 40,000 gas
    // Savings: 80,000 gas (67% reduction)
}

Advanced Packing with Bitwise Operations

contract UltraOptimized {
    // Pack everything into one 256-bit slot
    uint256 private _packedState;
    
    // Bit layout:
    // Bits 0-127:   reserve0 (128 bits)
    // Bits 128-255: reserve1 (128 bits)
    // Bits 256-287: timestamp (32 bits) - uses next slot
    // Bit 288:      paused flag (1 bit)
    
    function getReserves() public view returns (uint128 reserve0, uint128 reserve1) {
        uint256 packed = _packedState;
        reserve0 = uint128(packed);
        reserve1 = uint128(packed >> 128);
    }
    
    function updateReserves(uint128 newReserve0, uint128 newReserve1) internal {
        _packedState = uint256(newReserve0) | (uint256(newReserve1) << 128);
        // Single SSTORE: 20,000 gas vs 40,000 gas for two operations
    }
}

⚡ Optimization #2: Assembly for Critical Paths

Custom Math Libraries in Assembly

Standard Solidity (expensive):

function mulDiv(uint256 a, uint256 b, uint256 denominator) 
    public pure returns (uint256 result) {
    // Built-in overflow protection adds gas overhead
    return (a * b) / denominator;
    // Gas cost: ~800 gas with overflow checks
}

Assembly Version (blazing fast):

function mulDivAssembly(uint256 a, uint256 b, uint256 denominator) 
    public pure returns (uint256 result) {
    assembly {
        // Check for overflow manually (cheaper than Solidity's checks)
        if iszero(denominator) { revert(0, 0) }
        
        // Compute a * b
        let prod := mul(a, b)
        
        // Check for overflow in multiplication
        if iszero(or(iszero(a), eq(div(prod, a), b))) { revert(0, 0) }
        
        // Perform division
        result := div(prod, denominator)
    }
    // Gas cost: ~200 gas (75% savings!)
}

Optimized Square Root for Price Calculations

// Critical for AMM price calculations
function sqrtAssembly(uint256 x) internal pure returns (uint256 result) {
    assembly {
        // Babylonian method in assembly
        result := x
        let xAux := x
        if gt(xAux, 3) {
            result := xAux
            xAux := div(add(div(xAux, result), result), 2)
            result := xAux
            xAux := div(add(div(xAux, result), result), 2)
            result := xAux
            xAux := div(add(div(xAux, result), result), 2)
            result := xAux
            xAux := div(add(div(xAux, result), result), 2)
            result := xAux
            xAux := div(add(div(xAux, result), result), 2)
            result := xAux
            xAux := div(add(div(xAux, result), result), 2)
            result := xAux
            xAux := div(add(div(xAux, result), result), 2)
            if lt(xAux, result) { result := xAux }
        }
        if eq(x, 0) { result := 0 }
    }
    // 4x faster than library implementations
}

🏗️ Optimization #3: Efficient Data Structures

Replace Dynamic Arrays with Mappings

Inefficient (for sparse data):

struct Position {
    uint256[] tickCumulatives;
    uint256[] secondsPerLiquidityBucket;
}

// Gas cost for accessing element 1000: 
// ~21,000 gas (cold storage) + iteration costs

Efficient (O(1) access):

struct Position {
    mapping(uint256 => uint256) tickCumulatives;
    mapping(uint256 => uint256) secondsPerLiquidityBucket;
    uint256 lastIndex; // Track highest index
}

// Gas cost for accessing any element: 
// ~2,100 gas (warm) or ~21,000 gas (cold) - no iteration!

Packed Structs for Event Logs

// Expensive: Multiple SSTORE operations
event Swap(
    address indexed sender,
    uint256 amount0In,
    uint256 amount1In,
    uint256 amount0Out,
    uint256 amount1Out,
    address indexed to
);

// Optimized: Single packed value
event SwapPacked(
    address indexed sender,
    uint256 packedAmounts, // amounts packed into single uint256
    address indexed to
);

// Packing function
function packAmounts(
    uint128 amount0In,
    uint128 amount1In,
    uint128 amount0Out,
    uint128 amount1Out
) internal pure returns (uint256 packed) {
    return uint256(amount0In) | 
           (uint256(amount1In) << 128) |
           (uint256(amount0Out) << 256) |
           (uint256(amount1Out) << 384);
}

🎯 Optimization #4: Minimize External Calls

Batch Operations Pattern

Before (multiple external calls):

function swapMultiple(SwapParams[] calldata swaps) external {
    for (uint i = 0; i < swaps.length; i++) {
        IERC20(swaps[i].tokenIn).transferFrom(
            msg.sender, 
            address(this), 
            swaps[i].amountIn
        ); // 25,000 gas per call
        
        _performSwap(swaps[i]);
        
        IERC20(swaps[i].tokenOut).transfer(
            msg.sender, 
            swaps[i].amountOut
        ); // 25,000 gas per call
    }
    // Total: ~50,000 gas per swap
}

After (batched calls):

function swapMultipleOptimized(SwapParams[] calldata swaps) external {
    // Pre-calculate total amounts for each token
    mapping(address => uint256) totalIn;
    mapping(address => uint256) totalOut;
    
    for (uint i = 0; i < swaps.length; i++) {
        totalIn[swaps[i].tokenIn] += swaps[i].amountIn;
        totalOut[swaps[i].tokenOut] += swaps[i].amountOut;
        _performSwap(swaps[i]);
    }
    
    // Single transfer per token type
    for (uint i = 0; i < uniqueTokensIn.length; i++) {
        IERC20(uniqueTokensIn[i]).transferFrom(msg.sender, address(this), totalIn[uniqueTokensIn[i]]);
    }
    
    for (uint i = 0; i < uniqueTokensOut.length; i++) {
        IERC20(uniqueTokensOut[i]).transfer(msg.sender, totalOut[uniqueTokensOut[i]]);
    }
    // Total: ~25,000 gas regardless of swap count!
}

🔧 Optimization #5: Advanced Assembly Patterns

Efficient Memory Management

function efficientMemoryOps() internal pure returns (bytes32[] memory result) {
    assembly {
        // Allocate memory efficiently
        result := mload(0x40) // Get free memory pointer
        mstore(0x40, add(result, 0x80)) // Update free memory pointer
        
        // Set array length
        mstore(result, 0x02) // length = 2
        
        // Set array elements directly
        mstore(add(result, 0x20), 0x1234) // element 0
        mstore(add(result, 0x40), 0x5678) // element 1
        
        // No need for bounds checking or safe math
    }
}

Custom Error Handling

// Expensive: String error messages
require(amount > 0, "Amount must be positive");

// Optimized: Custom errors (Solidity 0.8.4+)
error InvalidAmount();
if (amount <= 0) revert InvalidAmount();

// Even better: Assembly with custom error codes
assembly {
    if iszero(gt(amount, 0)) {
        mstore(0x00, 0x01) // Error code 1
        revert(0x00, 0x20)
    }
}

📊 Real-World Results

Our AMM Protocol Gas Analysis

Operation	Before	After	Savings
Swap	150,342 gas	49,234 gas	67%
Add Liquidity	180,567 gas	72,123 gas	60%
Remove Liquidity	95,432 gas	38,891 gas	59%
Collect Fees	65,234 gas	21,567 gas	67%

Cost Savings at Different Gas Prices

Gas Price	Before (per swap)	After (per swap)	Monthly Savings*
20 gwei	$6.02	$1.97	$121,500
50 gwei	$15.05	$4.92	$303,900
100 gwei	$30.10	$9.85	$607,500

*Based on 30,000 swaps per month

🧪 Testing Gas Optimizations

Forge Gas Reporting

// test/GasOptimization.t.sol
contract GasOptimizationTest is Test {
    SwapPoolOptimized pool;
    
    function setUp() public {
        pool = new SwapPoolOptimized();
    }
    
    function testSwapGasUsage() public {
        uint256 gasBefore = gasleft();
        
        pool.swap(
            1000e18,  // amountIn
            0,        // amountOutMin  
            address(this)
        );
        
        uint256 gasUsed = gasBefore - gasleft();
        
        // Assert gas usage is under target
        assertLt(gasUsed, 50000, "Swap should use less than 50k gas");
        
        console.log("Gas used for swap:", gasUsed);
    }
}

Gas Snapshot Testing

# Generate gas snapshots
forge snapshot

# Compare changes
forge snapshot --diff .gas-snapshot

⚠️ Optimization Pitfalls to Avoid

1. Over-Packing Variables

// BAD: Too much packing hurts readability
struct OverPacked {
    uint8 a;    // Could be bool
    uint16 b;   // Rarely needs 16 bits
    uint64 c;   // Timestamp (32 bits sufficient)
    uint168 d;  // Weird size, hard to work with
}

// GOOD: Sensible packing
struct WellPacked {
    uint128 reserve0;
    uint128 reserve1;
    uint32 timestamp;
    bool paused;
}

2. Premature Assembly Optimization

// BAD: Assembly for simple operations
function addAssembly(uint256 a, uint256 b) pure returns (uint256 result) {
    assembly {
        result := add(a, b)
        // No overflow protection!
    }
}

// GOOD: Use assembly only for complex operations
function complexMath() pure returns (uint256) {
    assembly {
        // Multi-step calculation that benefits from assembly
    }
}

3. Ignoring Security for Gas Savings

// DANGEROUS: Removing necessary checks
function unsafeTransfer(address to, uint256 amount) external {
    // Removed balance check to save gas
    balances[msg.sender] -= amount;
    balances[to] += amount;
    // Can underflow!
}

// SAFE: Necessary checks remain
function safeTransfer(address to, uint256 amount) external {
    require(balances[msg.sender] >= amount, "Insufficient balance");
    balances[msg.sender] -= amount;
    balances[to] += amount;
}

🚀 Advanced Patterns

CREATE2 for Predictable Addresses

// Save gas on address calculations
function deployPool(address tokenA, address tokenB) external returns (address pool) {
    bytes32 salt = keccak256(abi.encodePacked(tokenA, tokenB));
    
    pool = Clones.cloneDeterministic(poolImplementation, salt);
    
    // No need to store mapping - address is deterministic!
}

function getPoolAddress(address tokenA, address tokenB) external view returns (address) {
    bytes32 salt = keccak256(abi.encodePacked(tokenA, tokenB));
    return Clones.predictDeterministicAddress(poolImplementation, salt);
}

Proxy Pattern for Upgradeable Logic

// Minimize deployment costs with minimal proxy
contract PoolFactory {
    address public immutable implementation;
    
    function createPool() external returns (address pool) {
        // Deploy minimal proxy (only ~200 gas)
        pool = Clones.clone(implementation);
        IPool(pool).initialize(msg.sender);
    }
}

🎯 Key Takeaways

Storage is expensive - Pack variables efficiently
Assembly helps - But only for hot paths
Batch operations - Minimize external calls
Measure everything - Use gas snapshots
Don't sacrifice security - Gas optimization != removing checks

🔮 Future Optimizations

EIP-4844 (Blob Transactions)

// Future: Store large data in blobs
function submitBatchWithBlob(bytes calldata blobData) external {
    // Process blob data (much cheaper than calldata)
    // Will reduce costs for large batch operations by 90%+
}

Account Abstraction Benefits

// Batched operations via account abstraction
// Users can batch multiple DeFi operations in one transaction
// Estimated 40-60% gas savings for complex workflows

The bottom line: We took our AMM from expensive ($15/swap) to competitive ($5/swap) through systematic gas optimization. Every DeFi protocol can benefit from these techniques.

The gas savings aren't just numbers - they directly translate to better user experience and higher adoption.

Building a DeFi protocol? I can help optimize your gas usage. DM me your biggest gas pain points!

GitHub: Full optimized AMM implementation available at github.com/example/gas-optimized-amm