Try it Live

Run Authorization examples in the interactive playground

Gas Calculations

Calculate gas costs for EIP-7702 authorizations.

Overview

EIP-7702 authorization processing has two gas cost components:

Base cost per authorization: 12,500 gas
Empty account cost: 25,000 gas (if delegated address is empty)

Total cost: (authCount * 12500) + (emptyCount * 25000)

Constants

Authorization.PER_AUTH_BASE_COST = 12500n;      // Base gas per authorization
Authorization.PER_EMPTY_ACCOUNT_COST = 25000n;  // Gas for empty account

calculateGasCost

Calculate total gas cost for authorization list.

Authorization.calculateGasCost.call(
  authList: Authorization.Item[],
  emptyAccounts: number
): bigint

Parameters:

authList: Array of authorizations
emptyAccounts: Number of empty accounts being delegated to

Returns: Total gas cost as bigint Formula: (authList.length * 12500) + (emptyAccounts * 25000)

Usage

import { Authorization } from 'tevm';

const authList: Authorization.Item[] = [auth1, auth2, auth3];
const emptyAccountCount = 2;

const gas = Authorization.calculateGasCost.call(authList, emptyAccountCount);
console.log(`Total gas: ${gas}`);
// gas = (3 * 12500) + (2 * 25000) = 87500

Examples

All empty accounts:

const gas = Authorization.calculateGasCost.call([auth1, auth2], 2);
// (2 * 12500) + (2 * 25000) = 75000

No empty accounts:

const gas = Authorization.calculateGasCost.call([auth1, auth2], 0);
// (2 * 12500) + (0 * 25000) = 25000

Empty list:

const gas = Authorization.calculateGasCost.call([], 0);
// (0 * 12500) + (0 * 25000) = 0

Mixed:

const gas = Authorization.calculateGasCost.call([auth1, auth2, auth3, auth4], 1);
// (4 * 12500) + (1 * 25000) = 75000

getGasCost

Calculate gas cost for single authorization.

Authorization.getGasCost.call(
  auth: Authorization.Item,
  isEmpty: boolean
): bigint

Parameters:

auth: Authorization to calculate cost for
isEmpty: Whether delegated address is empty

Returns: Gas cost as bigint Formula:

If empty: 12500 + 25000 = 37500
If not empty: 12500

Usage

import { Authorization } from 'tevm';

const auth: Authorization.Item = {...};

// Empty account
const gasIfEmpty = Authorization.getGasCost.call(auth, true);
console.log(`Gas (empty): ${gasIfEmpty}`);
// 37500

// Non-empty account
const gasIfNotEmpty = Authorization.getGasCost.call(auth, false);
console.log(`Gas (not empty): ${gasIfNotEmpty}`);
// 12500

Empty Account Detection

What is an Empty Account?

An account is considered empty if:

Balance = 0
Nonce = 0
Code length = 0
Storage is empty

Checking if Account is Empty

import { Authorization } from 'tevm';

async function isAccountEmpty(address: Address): Promise<boolean> {
  const balance = await getBalance(address);
  const nonce = await getNonce(address);
  const code = await getCode(address);

  return balance === 0n && nonce === 0n && code.length === 0;
}

// Use in gas calculation
const isEmpty = await isAccountEmpty(auth.address);
const gas = Authorization.getGasCost.call(auth, isEmpty);

Counting Empty Accounts

import { Authorization } from 'tevm';

async function countEmptyAccounts(
  authList: Authorization.Item[]
): Promise<number> {
  let count = 0;

  for (const auth of authList) {
    const isEmpty = await isAccountEmpty(auth.address);
    if (isEmpty) count++;
  }

  return count;
}

// Use in gas calculation
const emptyCount = await countEmptyAccounts(authList);
const gas = Authorization.calculateGasCost.call(authList, emptyCount);

Gas Estimation Patterns

Pre-transaction Estimation

Estimate gas before sending transaction:

import { Authorization } from 'tevm';

async function estimateAuthGas(
  authList: Authorization.Item[]
): Promise<bigint> {
  // Count empty accounts
  const emptyCount = await countEmptyAccounts(authList);

  // Calculate authorization gas
  const authGas = Authorization.calculateGasCost.call(authList, emptyCount);

  // Add execution gas (estimated separately)
  const executionGas = 21000n; // Base transaction cost
  const totalGas = authGas + executionGas;

  return totalGas;
}

const gasEstimate = await estimateAuthGas(authList);
console.log(`Estimated gas: ${gasEstimate}`);

With Gas Limit

Check if within gas limit:

import { Authorization } from 'tevm';

async function validateGasLimit(
  authList: Authorization.Item[],
  gasLimit: bigint
): Promise<void> {
  const emptyCount = await countEmptyAccounts(authList);
  const authGas = Authorization.calculateGasCost.call(authList, emptyCount);

  if (authGas > gasLimit) {
    throw new Error(
      `Authorization gas (${authGas}) exceeds limit (${gasLimit})`
    );
  }
}

await validateGasLimit(authList, 100000n);

Per-Authorization Cost Breakdown

Calculate cost for each authorization:

import { Authorization } from 'tevm';

interface AuthGasCost {
  auth: Authorization.Item;
  isEmpty: boolean;
  gas: bigint;
}

async function calculateIndividualCosts(
  authList: Authorization.Item[]
): Promise<AuthGasCost[]> {
  const costs: AuthGasCost[] = [];

  for (const auth of authList) {
    const isEmpty = await isAccountEmpty(auth.address);
    const gas = Authorization.getGasCost.call(auth, isEmpty);

    costs.push({ auth, isEmpty, gas });
  }

  return costs;
}

const costs = await calculateIndividualCosts(authList);
costs.forEach((c, i) => {
  console.log(`Auth ${i}: ${c.gas} gas (${c.isEmpty ? 'empty' : 'not empty'})`);
});

Optimization Strategies

Minimize Empty Account Delegations

Empty accounts cost more gas. Prefer delegating to deployed contracts:

// More expensive: delegate to empty address
const expensiveAuth = {
  chainId: 1n,
  address: emptyAddress,  // 37,500 gas
  nonce: 0n
};

// Cheaper: delegate to deployed contract
const cheaperAuth = {
  chainId: 1n,
  address: deployedContract,  // 12,500 gas
  nonce: 0n
};

Batch Size Optimization

Larger batches have better gas efficiency per authorization:

import { Authorization } from 'tevm';

function calculateEfficiency(
  authCount: number,
  emptyCount: number
): number {
  const totalGas = Authorization.calculateGasCost.call(
    new Array(authCount).fill(null),
    emptyCount
  );

  const gasPerAuth = Number(totalGas) / authCount;
  return gasPerAuth;
}

// Examples
calculateEfficiency(1, 0);   // 12,500 gas/auth
calculateEfficiency(10, 0);  // 12,500 gas/auth (same)
calculateEfficiency(1, 1);   // 37,500 gas/auth
calculateEfficiency(10, 5);  // 25,000 gas/auth (better due to batching)

Deduplication

Remove duplicate delegations to save gas:

import { Authorization, Address } from 'tevm';

function deduplicateByAddress(
  authList: Authorization.Item[]
): Authorization.Item[] {
  const seen = new Set<string>();
  const unique: Authorization.Item[] = [];

  for (const auth of authList) {
    const key = Address.toHex(auth.address);

    if (!seen.has(key)) {
      seen.add(key);
      unique.push(auth);
    }
  }

  return unique;
}

const deduplicated = deduplicateByAddress(authList);
const savedAuths = authList.length - deduplicated.length;
const savedGas = BigInt(savedAuths) * Authorization.PER_AUTH_BASE_COST;

console.log(`Saved ${savedGas} gas by removing ${savedAuths} duplicates`);

Gas Cost Tables

Base Costs

Scenario	Authorizations	Empty Accounts	Gas Cost
Single (empty)	1	1	37,500
Single (not empty)	1	0	12,500
Batch of 5 (all empty)	5	5	187,500
Batch of 5 (none empty)	5	0	62,500
Batch of 10 (5 empty)	10	5	250,000

Cost per Authorization

Empty Accounts	Gas per Auth
All empty	37,500
None empty	12,500
50% empty	25,000 (average)
25% empty	18,750 (average)

Advanced Patterns

Dynamic Gas Pricing

Adjust authorization list based on gas price:

import { Authorization } from 'tevm';

async function optimizeAuthList(
  authList: Authorization.Item[],
  maxGas: bigint
): Promise<Authorization.Item[]> {
  // Calculate costs
  const costs = await calculateIndividualCosts(authList);

  // Sort by cost (cheapest first)
  costs.sort((a, b) => Number(a.gas - b.gas));

  // Include as many as possible within budget
  const optimized: Authorization.Item[] = [];
  let totalGas = 0n;

  for (const cost of costs) {
    if (totalGas + cost.gas <= maxGas) {
      optimized.push(cost.auth);
      totalGas += cost.gas;
    }
  }

  return optimized;
}

const optimized = await optimizeAuthList(authList, 100000n);

Gas Budget Allocation

Allocate gas budget across authorization types:

import { Authorization } from 'tevm';

interface GasBudget {
  empty: bigint;
  nonEmpty: bigint;
}

function allocateBudget(totalGas: bigint): GasBudget {
  // Reserve 60% for base costs, 40% for empty accounts
  const baseGas = (totalGas * 60n) / 100n;
  const emptyGas = (totalGas * 40n) / 100n;

  return { empty: emptyGas, nonEmpty: baseGas };
}

function calculateMaxAuths(budget: GasBudget): {
  maxEmpty: number;
  maxNonEmpty: number;
} {
  const maxEmpty = Number(budget.empty / Authorization.PER_EMPTY_ACCOUNT_COST);
  const maxNonEmpty = Number(budget.nonEmpty / Authorization.PER_AUTH_BASE_COST);

  return { maxEmpty, maxNonEmpty };
}

const budget = allocateBudget(100000n);
const max = calculateMaxAuths(budget);
console.log(`Can include up to ${max.maxNonEmpty} non-empty or ${max.maxEmpty} empty`);

Gas Monitoring

Track gas usage during processing:

import { Authorization } from 'tevm';

class GasMonitor {
  private totalGas = 0n;
  private authCount = 0;
  private emptyCount = 0;

  async addAuth(auth: Authorization.Item): Promise<void> {
    const isEmpty = await isAccountEmpty(auth.address);
    const gas = Authorization.getGasCost.call(auth, isEmpty);

    this.totalGas += gas;
    this.authCount++;
    if (isEmpty) this.emptyCount++;
  }

  getStats(): {
    totalGas: bigint;
    authCount: number;
    emptyCount: number;
    avgGasPerAuth: number;
  } {
    return {
      totalGas: this.totalGas,
      authCount: this.authCount,
      emptyCount: this.emptyCount,
      avgGasPerAuth: Number(this.totalGas) / this.authCount
    };
  }

  reset(): void {
    this.totalGas = 0n;
    this.authCount = 0;
    this.emptyCount = 0;
  }
}

const monitor = new GasMonitor();
for (const auth of authList) {
  await monitor.addAuth(auth);
}
console.log(monitor.getStats());

Testing

Test Gas Calculations

import { Authorization } from 'tevm';

// Empty list
expect(Authorization.calculateGasCost.call([], 0)).toBe(0n);

// Single non-empty
expect(Authorization.getGasCost.call(auth, false)).toBe(12500n);

// Single empty
expect(Authorization.getGasCost.call(auth, true)).toBe(37500n);

// Batch
const gas = Authorization.calculateGasCost.call([auth1, auth2, auth3], 2);
expect(gas).toBe(87500n); // (3 * 12500) + (2 * 25000)

Performance

Gas calculation is O(1):

// Constant time calculation
const gas = Authorization.calculateGasCost.call(authList, emptyCount);
// gas = authList.length * 12500 + emptyCount * 25000

Documentation Index

Try it Live

​Gas Calculations

​Overview

​Constants

​calculateGasCost

​Usage

​Examples

​getGasCost

​Usage

​Empty Account Detection

​What is an Empty Account?

​Checking if Account is Empty

​Counting Empty Accounts

​Gas Estimation Patterns

​Pre-transaction Estimation

​With Gas Limit

​Per-Authorization Cost Breakdown

​Optimization Strategies

​Minimize Empty Account Delegations

​Batch Size Optimization

​Deduplication

​Gas Cost Tables

​Base Costs

​Cost per Authorization

​Advanced Patterns

​Dynamic Gas Pricing

​Gas Budget Allocation

​Gas Monitoring

​Testing

​Test Gas Calculations

​Performance

​See Also

Gas Calculations

Overview

Constants

calculateGasCost

Usage

Examples

getGasCost

Usage

Empty Account Detection

What is an Empty Account?

Checking if Account is Empty

Counting Empty Accounts

Gas Estimation Patterns

Pre-transaction Estimation

With Gas Limit

Per-Authorization Cost Breakdown

Optimization Strategies

Minimize Empty Account Delegations

Batch Size Optimization

Deduplication

Gas Cost Tables

Base Costs

Cost per Authorization

Advanced Patterns

Dynamic Gas Pricing

Gas Budget Allocation

Gas Monitoring

Testing

Test Gas Calculations

Performance

See Also