Gas Optimization

Reduce transaction costs by 35% with dynamic fee strategies, priority bidding, and MEV protection.

Overview

Molt402's gas optimizer analyzes network conditions in real-time to calculate optimal fee parameters. Instead of overpaying for guaranteed inclusion or underpaying and waiting indefinitely, the optimizer finds the efficiency frontier for each urgency level.

How it works

The optimizer implements three core strategies:

Base fee prediction: Exponential moving average of recent blocks predicts next-block base fee with 95% confidence Priority fee bidding: Historical analysis determines competitive priority fees for each urgency tier Dynamic adjustment: Automatic gas price bumping when transactions don't confirm within expected timeframe

Urgency tiers

Instant

Target next-block inclusion (12-15 seconds).

const result = await client.execute({
  instruction: "Transfer 50 USDC to 0xabcd...ef01",
  urgency: "instant"
})

Fee strategy:

• Base fee: 98th percentile prediction (near-certain inclusion)

• Priority fee: 95th percentile (compete with high-priority transactions)

• Use case: Time-sensitive arbitrage, liquidations, critical operations

Cost premium: +40% vs standard tier Confirmation probability: >95% next block

Fast

Target inclusion within 3 blocks (~45 seconds).

const result = await client.execute({
  instruction: "Transfer 50 USDC to 0xabcd...ef01",
  urgency: "fast"
})

Fee strategy:

• Base fee: 90th percentile prediction

• Priority fee: 75th percentile

• Use case: User-facing operations, moderate time sensitivity

Cost premium: +15% vs standard tier Confirmation probability: >90% within 3 blocks

Standard (default)

Target inclusion within 10 blocks (~2 minutes).

const result = await client.execute({
  instruction: "Transfer 50 USDC to 0xabcd...ef01",
  urgency: "standard"  // or omit (default)
})

Fee strategy:

• Base fee: 75th percentile prediction

• Priority fee: 50th percentile (median)

• Use case: Most operations, balanced cost/speed trade-off

Cost premium: Baseline Confirmation probability: >85% within 10 blocks

Economy

Best-effort inclusion, minimize cost.

const result = await client.execute({
  instruction: "Transfer 50 USDC to 0xabcd...ef01",
  urgency: "economy"
})

Fee strategy:

• Base fee: 50th percentile prediction

• Priority fee: 25th percentile (below median)

• Use case: Non-urgent background operations

Cost saving: -30% vs standard tier Confirmation probability: >70% within 20 blocks (variable timing)

Manual gas configuration

Override automatic optimization for specific requirements:

const result = await client.execute({
  instruction: "Transfer 50 USDC to 0xabcd...ef01",
  maxGasPrice: "50000000000",  // 50 gwei max
  maxPriorityFee: "2000000000"  // 2 gwei priority
})

When to use manual config:

• Strict budget constraints

• Custom timing requirements

• Testing gas strategies

• Compliance with protocol limits

Warning: Manual configuration may result in delayed or failed inclusion if fees are insufficient.

Dynamic adjustment

If transaction doesn't confirm within expected timeframe, Molt402 automatically bumps gas price.

const client = new Molt402Client({
  network: 'x402-mainnet',
  wallet: walletConfig,
  gasOptimization: {
    autoBump: true,
    bumpStrategy: 'exponential',  // or 'linear'
    maxBumps: 3,
    bumpPercentage: 20  // Increase by 20% each bump
  }
})

Exponential strategy:

1. Initial: 50 gwei

2. Bump 1 (+20%): 60 gwei

3. Bump 2 (+20%): 72 gwei

4. Bump 3 (+20%): 86.4 gwei

Linear strategy:

1. Initial: 50 gwei

2. Bump 1 (+10 gwei): 60 gwei

3. Bump 2 (+10 gwei): 70 gwei

4. Bump 3 (+10 gwei): 80 gwei

MEV protection

Prevent frontrunning and sandwich attacks with private transaction relays.

Configuration

const client = new Molt402Client({
  network: 'x402-mainnet',
  wallet: walletConfig,
  mevProtection: {
    enabled: true,
    provider: 'flashbots',  // or 'eden', 'bloXroute'
    minValueUsd: 1000,  // Use private relay for transactions >$1000
    maxRetries: 3
  }
})

Supported providers

Flashbots: Largest private mempool, highest liquidity Eden Network: Priority ordering, MEV redistribution bloXroute: Low latency, global coverage

When to use MEV protection

Enable for:

• DEX swaps >$1000

• NFT purchases

• Liquidation transactions

• Time-sensitive arbitrage

Skip for:

• Simple transfers

• Low-value transactions (<$100)

• Operations not susceptible to MEV

Costs

Private relays charge priority fees or percentage of MEV value. Molt402 automatically selects the most cost-effective relay for each transaction.

Gas estimation

Accurate gas limit estimation prevents wasted funds from out-of-gas failures.

Automatic estimation

Molt402 simulates transactions to estimate exact gas usage:

const result = await client.execute({
  instruction: "Swap 100 USDC for WETH",
  simulate: true  // Enable simulation-based estimation
})

console.log(`Estimated gas: ${result.gasEstimate}`)

Estimation process:

1. Simulate transaction against current state

2. Measure actual gas consumption

3. Add 10% buffer for state changes

4. Cap at block gas limit

Manual gas limits

Override estimation for special cases:

const result = await client.execute({
  instruction: "Complex contract interaction",
  gasLimit: "500000"  // Explicit gas limit
})

When to set manual limits:

• Complex contracts with variable gas usage

• Multi-step operations

• Testing worst-case scenarios

Cost analysis

Example comparison

Transfer 50 USDC on x402 mainnet:

Urgency	Base Fee	Priority Fee	Total Fee	USD Cost	Time
Instant	48 gwei	4 gwei	52 gwei	$3.64	~15s
Fast	45 gwei	2.5 gwei	47.5 gwei	$3.33	~45s
Standard	43 gwei	1.5 gwei	44.5 gwei	$3.12	~2min
Economy	40 gwei	0.5 gwei	40.5 gwei	$2.84	~4min

Savings: Economy tier saves $0.80 (22%) vs instant, acceptable for non-urgent operations.

Cost optimization strategies

Batch transactions: Amortize fixed costs across multiple operations

const batch = await client.executeBatch([
  { instruction: "Transfer 10 USDC to 0xaaaa..." },
  { instruction: "Transfer 15 USDC to 0xbbbb..." },
  { instruction: "Transfer 20 USDC to 0xcccc..." }
])

// Single transaction costs ~$3, batch costs ~$5 for 3 transfers
// Saves $4 (57%) vs individual transactions

Off-peak execution: Schedule non-urgent operations during low-congestion periods

const client = new Molt402Client({
  gasOptimization: {
    scheduling: {
      enabled: true,
      preferredHours: [0, 1, 2, 3, 4, 5],  // UTC midnight-6am
      maxDelay: 14400  // Execute within 4 hours
    }
  }
})

Monitor historical patterns: Identify low-cost time windows

const gasPriceHistory = await client.getGasPriceHistory({
  period: '7d',
  granularity: 'hourly'
})

// Find cheapest hour of day
const cheapestHour = gasPriceHistory.reduce((min, hour) =>
  hour.averageGasPrice < min.averageGasPrice ? hour : min
)

console.log(`Cheapest hour: ${cheapestHour.hour} UTC`)

Monitoring gas spend

Track cumulative gas costs to identify optimization opportunities.

Real-time tracking

const client = new Molt402Client({
  gasOptimization: {
    tracking: {
      enabled: true,
      alerts: [
        {
          type: 'daily_spend',
          threshold: 0.1,  // 0.1 ETH
          action: 'notify'
        },
        {
          type: 'per_transaction',
          threshold: 0.01,  // 0.01 ETH
          action: 'notify'
        }
      ]
    }
  }
})

Historical analysis

const gasReport = await client.getGasReport({
  startDate: '2026-03-01',
  endDate: '2026-03-17',
  groupBy: 'day'
})

console.log(`Total gas spent: ${gasReport.totalEth} ETH`)
console.log(`Average per transaction: ${gasReport.averagePerTx} ETH`)
console.log(`Most expensive transaction: ${gasReport.maxTx.hash}`)

Advanced optimization

EIP-1559 prediction models

Molt402 uses machine learning to predict base fee trends:

const client = new Molt402Client({
  gasOptimization: {
    predictionModel: 'ml',  // or 'statistical'
    historicalWindow: 100,  // Analyze last 100 blocks
    confidenceLevel: 0.95  // 95% confidence interval
  }
})

ML model: LSTM neural network trained on historical base fee patterns Statistical model: Exponential weighted moving average (faster, less accurate)

Flash loan optimization

Reduce gas costs for flash loan operations:

const result = await client.execute({
  action: 'flashloan',
  protocol: 'aave',
  asset: 'USDC',
  amount: '1000000',
  operations: [
    { action: 'swap', from: 'USDC', to: 'WETH' },
    { action: 'swap', from: 'WETH', to: 'USDC' }
  ],
  gasOptimization: {
    // Optimize calldata encoding
    compressCalldata: true,
    // Use gas token refunds
    gasTokenRefund: true
  }
})

Optimization techniques:

• Calldata compression (save ~2000 gas per transaction)

• Gas token refunds (CHI, GST2)

• Optimal operation ordering

• Redundant approval elimination

Troubleshooting

Transaction stuck in pending

Problem: Transaction not confirming despite adequate gas price.

Solution: Increase urgency tier or manually bump gas

// Check current gas price
const currentGas = await client.getGasPrice('standard')
console.log(`Current: ${currentGas.maxFeePerGas}`)

// Bump stuck transaction
await client.bumpGasPrice(txHash, {
  increasePercent: 50  // Increase by 50%
})

Out-of-gas errors

Problem: Transaction reverts due to insufficient gas limit.

Solution: Enable simulation or increase manual gas limit

const result = await client.execute({
  instruction: "Complex operation",
  simulate: true,  // Estimate accurate gas requirement
  gasLimit: "800000"  // Or set explicit limit
})

High gas costs

Problem: Gas costs exceeding budget.

Solution: Use economy tier, batch operations, or schedule off-peak

// Switch to economy tier
const result = await client.execute({
  instruction: "Non-urgent transfer",
  urgency: "economy"
})

// Or schedule for off-peak
const result = await client.execute({
  instruction: "Background task",
  schedule: {
    executeAfter: "2026-03-18T02:00:00Z",  // 2am UTC
    expireAfter: "2026-03-18T06:00:00Z"   // Cancel if not executed by 6am
  }
})

Best practices

Use appropriate urgency: Don't pay for instant when standard suffices Enable simulation: Accurate gas estimation prevents waste Batch operations: Amortize fixed costs across multiple transactions Monitor gas spend: Set alerts for unusual consumption Schedule off-peak: Execute non-urgent operations during low congestion Test on testnet: Validate gas optimization before mainnet deployment

Next steps

• Transaction simulation: Pre-flight validation

• MEV protection: Detailed MEV defense strategies

• Batch transactions: Efficient multi-operation workflows

• Monitoring and alerts: Track gas consumption

Support

Questions about gas optimization? We're here to help:

• Discord: discord.gg/molt402 (#gas-optimization channel)

• Documentation: docs.molt402.dev

• Email: [email protected]