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
  }
}

Documentation Index

Try it Live

​Transaction Types

​Transaction Type Enum

​Type Definitions

​Legacy Transaction (Type 0)

​EIP-2930 Transaction (Type 1)

​EIP-1559 Transaction (Type 2)

​EIP-4844 Transaction (Type 3)

​EIP-7702 Transaction (Type 4)

​Supporting Types

​AccessList

​Authorization

​VersionedHash

​Any Transaction

​Type Guards

​Type Comparison

​Usage Examples

​Creating Transactions

​Type Narrowing

Transaction Types

Transaction Type Enum

Type Definitions

Legacy Transaction (Type 0)

EIP-2930 Transaction (Type 1)

EIP-1559 Transaction (Type 2)

EIP-4844 Transaction (Type 3)

EIP-7702 Transaction (Type 4)

Supporting Types

AccessList

Authorization

VersionedHash

Any Transaction

Type Guards

Type Comparison

Usage Examples

Creating Transactions

Type Narrowing