Transaction Types

All Ethereum transaction type definitions and type guards

Try it Live

Run Transaction examples in the interactive playground

Transaction Types

Complete type definitions for all Ethereum transaction types.

Transaction Type Enum

enum Type {
  Legacy = 0x00,
  EIP2930 = 0x01,
  EIP1559 = 0x02,
  EIP4844 = 0x03,
  EIP7702 = 0x04,
}

Source: types.ts:7-13

Type Definitions

Legacy Transaction (Type 0)

Original Ethereum transaction format with fixed gas price.

type Legacy = {
  type: Type.Legacy       // 0x00
  nonce: bigint
  gasPrice: bigint
  gasLimit: bigint
  to: AddressType | null  // null for contract creation
  value: bigint
  data: Uint8Array
  v: bigint               // EIP-155: chainId or 27/28
  r: Uint8Array           // 32 bytes
  s: Uint8Array           // 32 bytes
}

Key characteristics:

• Uses v signature component (bigint) instead of yParity
• Chain ID encoded in v for EIP-155 (v = chainId * 2 + 35 + yParity)
• Pre-EIP-155 transactions use v = 27 or v = 28
• No access list support

Source: types.ts:59-72

EIP-2930 Transaction (Type 1)

Access list transactions introduced in Berlin hard fork.

type EIP2930 = {
  type: Type.EIP2930      // 0x01
  chainId: bigint
  nonce: bigint
  gasPrice: bigint
  gasLimit: bigint
  to: AddressType | null
  value: bigint
  data: Uint8Array
  accessList: AccessList
  yParity: number         // 0 or 1
  r: Uint8Array           // 32 bytes
  s: Uint8Array           // 32 bytes
}

Key characteristics:

• Explicit chainId field
• Uses yParity (0 or 1) instead of v
• Includes accessList for pre-declaring account/storage access
• Still uses fixed gasPrice

Source: types.ts:74-90

EIP-1559 Transaction (Type 2)

Dynamic fee market transactions introduced in London hard fork.

type EIP1559 = {
  type: Type.EIP1559      // 0x02
  chainId: bigint
  nonce: bigint
  maxPriorityFeePerGas: bigint  // Tip for miner
  maxFeePerGas: bigint          // Max total fee willing to pay
  gasLimit: bigint
  to: AddressType | null
  value: bigint
  data: Uint8Array
  accessList: AccessList
  yParity: number         // 0 or 1
  r: Uint8Array           // 32 bytes
  s: Uint8Array           // 32 bytes
}

Key characteristics:

• Uses maxFeePerGas and maxPriorityFeePerGas instead of fixed gasPrice
• Effective gas price = min(baseFee + maxPriorityFeePerGas, maxFeePerGas)
• Includes access list support
• Most common transaction type on modern Ethereum

Source: types.ts:92-109

EIP-4844 Transaction (Type 3)

Blob transactions for L2 data availability introduced in Dencun hard fork.

type EIP4844 = {
  type: Type.EIP4844      // 0x03
  chainId: bigint
  nonce: bigint
  maxPriorityFeePerGas: bigint
  maxFeePerGas: bigint
  gasLimit: bigint
  to: AddressType      // Cannot be null for blob transactions
  value: bigint
  data: Uint8Array
  accessList: AccessList
  maxFeePerBlobGas: bigint       // Max fee per blob gas
  blobVersionedHashes: readonly VersionedHash[]  // Blob commitments
  yParity: number         // 0 or 1
  r: Uint8Array           // 32 bytes
  s: Uint8Array           // 32 bytes
}

Key characteristics:

• to cannot be null (no contract creation with blobs)
• Includes maxFeePerBlobGas for blob gas pricing
• blobVersionedHashes contains KZG commitments to blob data
• Each blob is 128 KB (131072 bytes)
• Maximum 6 blobs per transaction
• Blob data stored separately from transaction

Source: types.ts:111-130

EIP-7702 Transaction (Type 4)

EOA delegation transactions allowing externally-owned accounts to temporarily act as smart contracts.

type EIP7702 = {
  type: Type.EIP7702      // 0x04
  chainId: bigint
  nonce: bigint
  maxPriorityFeePerGas: bigint
  maxFeePerGas: bigint
  gasLimit: bigint
  to: AddressType | null
  value: bigint
  data: Uint8Array
  accessList: AccessList
  authorizationList: AuthorizationList  // List of delegations
  yParity: number         // 0 or 1
  r: Uint8Array           // 32 bytes
  s: Uint8Array           // 32 bytes
}

Key characteristics:

• Includes authorizationList for EOA-to-contract delegations
• Each authorization must be signed by the delegating EOA
• Allows EOAs to execute contract logic temporarily
• Delegation is valid only for the transaction duration

Source: types.ts:132-150

Supporting Types

AccessList

Pre-declared account and storage slot access for gas optimization.

type AccessListItem = {
  address: AddressType
  storageKeys: readonly HashType[]
}

type AccessList = readonly AccessListItem[]

Example:

const accessList: AccessList = [
  {
    address: contractAddress,
    storageKeys: [slot1Hash, slot2Hash]
  },
  {
    address: anotherAddress,
    storageKeys: []
  }
]

Source: types.ts:18-26

Authorization

Delegation authorization for EIP-7702 transactions.

type Authorization = {
  chainId: bigint
  address: AddressType      // Contract address to delegate to
  nonce: bigint                // EOA nonce at time of authorization
  yParity: number              // 0 or 1
  r: Uint8Array                // 32 bytes
  s: Uint8Array                // 32 bytes
}

type AuthorizationList = readonly Authorization[]

Example:

const authorization: Authorization = {
  chainId: 1n,
  address: contractAddress,
  nonce: 5n,
  yParity: 0,
  r: signatureR,
  s: signatureS,
}

Source: types.ts:29-43

VersionedHash

KZG commitment hash for EIP-4844 blob transactions.

type VersionedHash = HashType  // 32-byte hash

First byte indicates version (currently 0x01 for SHA-256).

Source: types.ts:48

Any Transaction

Union type for all transaction types.

type Any = Legacy | EIP2930 | EIP1559 | EIP4844 | EIP7702

Used in functions that accept any transaction type.

Source: types.ts:155

Type Guards

Type guards for runtime type checking.

import {
  isLegacy,
  isEIP2930,
  isEIP1559,
  isEIP4844,
  isEIP7702
} from 'tevm/Transaction'

const tx: Transaction.Any = /* ... */

if (isLegacy(tx)) {
  // tx is Transaction.Legacy
  const v = tx.v
}

if (isEIP1559(tx)) {
  // tx is Transaction.EIP1559
  const maxFee = tx.maxFeePerGas
}

if (isEIP4844(tx)) {
  // tx is Transaction.EIP4844
  const blobs = tx.blobVersionedHashes
}

Type guard implementations:

function isLegacy(tx: Any): tx is Legacy {
  return tx.type === Type.Legacy
}

function isEIP2930(tx: Any): tx is EIP2930 {
  return tx.type === Type.EIP2930
}

function isEIP1559(tx: Any): tx is EIP1559 {
  return tx.type === Type.EIP1559
}

function isEIP4844(tx: Any): tx is EIP4844 {
  return tx.type === Type.EIP4844
}

function isEIP7702(tx: Any): tx is EIP7702 {
  return tx.type === Type.EIP7702
}

Source: typeGuards.ts

Type Comparison

Feature	Legacy	EIP-2930	EIP-1559	EIP-4844	EIP-7702
Type byte	0x00	0x01	0x02	0x03	0x04
Chain ID	In v	Explicit	Explicit	Explicit	Explicit
Gas pricing	gasPrice	gasPrice	maxFee + priority	maxFee + priority	maxFee + priority
Access list	No	Yes	Yes	Yes	Yes
Blob data	No	No	No	Yes	No
Authorization	No	No	No	No	Yes
Contract creation	Yes	Yes	Yes	No	Yes
Signature	v/r/s	yParity/r/s	yParity/r/s	yParity/r/s	yParity/r/s

Usage Examples

Creating Transactions

import * as Transaction from 'tevm/Transaction'

// Legacy
const legacy: Transaction.Legacy = {
  type: Transaction.Type.Legacy,
  nonce: 0n,
  gasPrice: 20000000000n,
  gasLimit: 21000n,
  to: recipientAddress,
  value: 1000000000000000000n,
  data: new Uint8Array(),
  v: 27n,
  r: signatureR,
  s: signatureS,
}

// EIP-1559
const eip1559: Transaction.EIP1559 = {
  type: Transaction.Type.EIP1559,
  chainId: 1n,
  nonce: 0n,
  maxPriorityFeePerGas: 1000000000n,
  maxFeePerGas: 20000000000n,
  gasLimit: 21000n,
  to: recipientAddress,
  value: 1000000000000000000n,
  data: new Uint8Array(),
  accessList: [],
  yParity: 0,
  r: signatureR,
  s: signatureS,
}

// EIP-4844
const eip4844: Transaction.EIP4844 = {
  type: Transaction.Type.EIP4844,
  chainId: 1n,
  nonce: 0n,
  maxPriorityFeePerGas: 1000000000n,
  maxFeePerGas: 20000000000n,
  gasLimit: 100000n,
  to: recipientAddress,
  value: 0n,
  data: new Uint8Array(),
  accessList: [],
  maxFeePerBlobGas: 1000000000n,
  blobVersionedHashes: [hash1, hash2],
  yParity: 0,
  r: signatureR,
  s: signatureS,
}

Type Narrowing

function processTx(tx: Transaction.Any) {
  switch (tx.type) {
    case Transaction.Type.Legacy:
      // tx is Transaction.Legacy
      console.log('Legacy v:', tx.v)
      break
    case Transaction.Type.EIP1559:
      // tx is Transaction.EIP1559
      console.log('Max fee:', tx.maxFeePerGas)
      break
    case Transaction.Type.EIP4844:
      // tx is Transaction.EIP4844
      console.log('Blobs:', tx.blobVersionedHashes.length)
      break
  }
}