Solidity Gas Optimization — Agent Saved 40% on Contract Deployment

The Problem

Gas costs on Ethereum are a tax on bad code. Every wasted storage slot, every unnecessary memory copy, every unoptimized loop — you're paying for it. And your users are paying for it on every transaction.

We had a token vesting contract for an Artificial-Lab project. It worked. Tests passed. But deployment cost 3.2M gas, and key functions like claimVested() were running at 85K gas per call. For a contract that thousands of users would interact with, that's real money burned on inefficiency.

A senior Solidity developer could optimize it. In a day or two. We needed it in 15 minutes.

The Solution

Upload the contract to our Web3 sub-agent. It analyzes gas usage at the function level, identifies optimization opportunities by category, rewrites the contract, and generates a before/after Hardhat gas report.

The Process

Step 1: Gas Profiling

The agent first profiles every function using Hardhat's gas reporter:

// hardhat.config.js
module.exports = {
  gasReporter: {
    enabled: true,
    currency: 'USD',
    gasPrice: 30,
    showMethodSig: true,
    showTimeSpent: true,
  }
};

Step 2: Storage Packing

The original contract had three separate storage slots for related data:

// BEFORE: 3 storage slots = 3 × SSTORE operations
struct VestingSchedule {
    uint256 totalAmount;      // slot 0 (256 bits)
    uint256 startTime;        // slot 1 (256 bits)
    uint256 claimedAmount;    // slot 2 (256 bits)
    bool isRevocable;         // slot 3 (8 bits, wastes 248 bits)
    address beneficiary;      // slot 4 (160 bits, wastes 96 bits)
}

Agent rewrote it:

// AFTER: 2 storage slots — packed tightly
struct VestingSchedule {
    uint128 totalAmount;      // slot 0, bits 0-127
    uint128 claimedAmount;    // slot 0, bits 128-255
    uint64 startTime;         // slot 1, bits 0-63 (good until year 2554)
    address beneficiary;      // slot 1, bits 64-223 (160 bits)
    bool isRevocable;         // slot 1, bit 224
}

Three slots became two. Every write saves 20,000 gas (cold SSTORE cost).

Step 3: Calldata vs Memory

// BEFORE: copying array to memory unnecessarily
function batchClaim(uint256[] memory scheduleIds) external {

// AFTER: read directly from calldata — cheaper
function batchClaim(uint256[] calldata scheduleIds) external {

calldata is read-only and cheaper than memory for external function parameters. The agent flagged every instance.

Step 4: Loop Optimization

// BEFORE: reading array length on every iteration
for (uint256 i = 0; i < schedules.length; i++) {

// AFTER: cache length, use unchecked increment (Solidity ≥0.8.0, no overflow risk)
uint256 len = schedules.length;
for (uint256 i = 0; i < len; ) {
    // ... loop body
    unchecked { ++i; }
}

Step 5: Verification

The agent ran the full test suite against the optimized contract — all 34 tests passing — then generated the comparative gas report.

The Results

At 30 gwei and ETH at $3,500, the deployment savings alone were ~$146. Over 10,000 claimVested() calls, that's $3,800 saved for users.

Try It Yourself

Start with Hardhat's gas reporter plugin — you can't optimize what you can't measure. Focus on storage packing first (biggest wins), then calldata, then loop optimizations. The Solidity compiler doesn't pack structs for you — that's on you, or on your agent.

Gas optimization isn't premature optimization. It's respecting your users' wallets.