Transaction

Complete Ethereum transaction encoding/decoding for all transaction types

Try it Live

Run Transaction examples in the interactive playground

Transaction

New to transactions? Start with Transaction Fundamentals to learn about transaction types, lifecycle, signing, and gas mechanics.

Complete Ethereum transaction implementation supporting all transaction types from Legacy to EIP-7702.

Overview

Transaction module provides type-safe encoding, decoding, signing, and hashing for all Ethereum transaction types. Supports Legacy (Type 0), EIP-2930 (Type 1), EIP-1559 (Type 2), EIP-4844 (Type 3), and EIP-7702 (Type 4) transactions with full RLP serialization.

Quick Start

Basic Usage

import * as Transaction from 'tevm/Transaction'
import * as Address from 'tevm/Address'

// Create a transaction
const tx: Transaction.EIP1559 = {
  type: Transaction.Type.EIP1559,
  chainId: 1n,
  nonce: 0n,
  maxPriorityFeePerGas: 1000000000n,
  maxFeePerGas: 20000000000n,
  gasLimit: 21000n,
  to: addressBytes,
  value: 1000000000000000000n,
  data: new Uint8Array(),
  accessList: [],
  yParity: 0,
  r: signatureR,
  s: signatureS,
}

// Serialize to bytes
const serialized = Transaction.serialize(tx)

// Compute transaction hash
const hash = Transaction.hash(tx)

// Get signing hash
const signingHash = Transaction.getSigningHash(tx)

// Recover sender from signature
const sender = Transaction.getSender(tx)

// Deserialize from bytes
const decoded = Transaction.deserialize(serialized)

// Detect transaction type from bytes
const type = Transaction.detectType(serialized)

Type-Specific Operations

import * as Transaction from 'tevm/Transaction'

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

// Get chain ID from legacy v value
const chainId = Transaction.getChainId(legacy)

// EIP-1559 transaction
const eip1559: Transaction.EIP1559 = { /* ... */ }
const effectiveGasPrice = Transaction.EIP1559.getEffectiveGasPrice(
  eip1559,
  baseFee
)

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

const blobCost = Transaction.EIP4844.getBlobGasCost(eip4844, blobBaseFee)

Utilities

import * as Transaction from 'tevm/Transaction'

// Format for display
const formatted = Transaction.format(tx)
// "EIP-1559 tx to 0x..., value: 1 ETH, nonce: 0"

// Get gas price (handles all types)
const gasPrice = Transaction.getGasPrice(tx, baseFee)

// Check if transaction has access list
if (Transaction.hasAccessList(tx)) {
  const accessList = Transaction.getAccessList(tx)
}

// Get chain ID
const chainId = Transaction.getChainId(tx)

// Check if signed
if (Transaction.isSigned(tx)) {
  const sender = Transaction.getSender(tx)
}

// Assert signed (throws if not)
Transaction.assertSigned(tx)

// Verify signature
const isValid = Transaction.verifySignature(tx)

Effect Schema

import { TransactionSchema } from '@tevm/voltaire/Transaction/effect'

// From RPC (legacy)
const tx = TransactionSchema.fromRpc({ type: '0x0', nonce: '0x0', gas: '0x5208', to: '0x' + '11'.repeat(20), value: '0x0', data: '0x' })
const hash = tx.hash()
const serialized = tx.serialize()

Quick Reference

Core Operations

Method	Description
serialize(tx)	RLP encode to bytes
deserialize(data)	RLP decode from bytes
detectType(data)	Detect type from serialized bytes
hash(tx)	Compute transaction hash
getSigningHash(tx)	Get hash to sign

Signature Operations

Method	Description
getSender(tx)	Recover sender address
verifySignature(tx)	Validate signature
isSigned(tx)	Check if signed
assertSigned(tx)	Assert signed (throws)

RPC Conversion

Method	Description
toRpc(tx)	Convert to JSON-RPC format
fromRpc(rpc)	Parse from JSON-RPC format

Utilities

Method	Description
getChainId(tx)	Extract chain ID
getGasPrice(tx, baseFee?)	Get effective gas price
hasAccessList(tx)	Check for access list
getAccessList(tx)	Get access list
format(tx)	Format for display

Transaction Types

Type	Name	Description
0x00	Legacy	Original format with fixed gas price
0x01	EIP-2930	Access list transactions for gas optimization
0x02	EIP-1559	Dynamic fee market with base fee and priority fee
0x03	EIP-4844	Blob transactions for L2 data availability
0x04	EIP-7702	EOA delegation to smart contracts

Type Definitions

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

// Legacy transaction (Type 0)
type Legacy = {
  type: Type.Legacy
  nonce: bigint
  gasPrice: bigint
  gasLimit: bigint
  to: AddressType | null
  value: bigint
  data: Uint8Array
  v: bigint
  r: Uint8Array
  s: Uint8Array
}

// EIP-2930 transaction (Type 1)
type EIP2930 = {
  type: Type.EIP2930
  chainId: bigint
  nonce: bigint
  gasPrice: bigint
  gasLimit: bigint
  to: AddressType | null
  value: bigint
  data: Uint8Array
  accessList: AccessList
  yParity: number
  r: Uint8Array
  s: Uint8Array
}

// EIP-1559 transaction (Type 2)
type EIP1559 = {
  type: Type.EIP1559
  chainId: bigint
  nonce: bigint
  maxPriorityFeePerGas: bigint
  maxFeePerGas: bigint
  gasLimit: bigint
  to: AddressType | null
  value: bigint
  data: Uint8Array
  accessList: AccessList
  yParity: number
  r: Uint8Array
  s: Uint8Array
}

// EIP-4844 transaction (Type 3)
type EIP4844 = {
  type: Type.EIP4844
  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
  blobVersionedHashes: readonly VersionedHash[]
  yParity: number
  r: Uint8Array
  s: Uint8Array
}

// EIP-7702 transaction (Type 4)
type EIP7702 = {
  type: Type.EIP7702
  chainId: bigint
  nonce: bigint
  maxPriorityFeePerGas: bigint
  maxFeePerGas: bigint
  gasLimit: bigint
  to: AddressType | null
  value: bigint
  data: Uint8Array
  accessList: AccessList
  authorizationList: AuthorizationList
  yParity: number
  r: Uint8Array
  s: Uint8Array
}

// Union type for all transactions
type Any = Legacy | EIP2930 | EIP1559 | EIP4844 | EIP7702

Source: types.ts

API Methods

Serialization

• serialize - RLP encode transaction to bytes
• deserialize - RLP decode transaction from bytes
• detectType - Detect transaction type from serialized bytes
• toRpc - Convert transaction to JSON-RPC format
• fromRpc - Parse transaction from JSON-RPC format

Hashing

• hash - Compute transaction hash
• getSigningHash - Get hash to sign

Signatures

• getSender - Recover sender address from signature
• verifySignature - Validate transaction signature
• isSigned - Check if transaction is signed
• assertSigned - Assert transaction is signed (throws if not)

Gas Pricing

• getGasPrice - Calculate effective gas price
• getEffectiveGasPrice - Get effective gas price for EIP-1559
• getBlobGasCost - Calculate blob gas cost for EIP-4844

Access Lists

• hasAccessList - Check if transaction has access list
• getAccessList - Retrieve access list data

Utilities

• getChainId - Extract chain ID from transaction
• format - Format transaction for display

Usage Patterns

Common patterns for working with transactions:

View usage patterns →

Tree-Shaking

Import only what you need:

// Namespace import (all methods)
import * as Transaction from 'tevm/Transaction';

// Granular imports (tree-shakeable)
import { serialize } from 'tevm/Transaction/serialize';
import { hash } from 'tevm/Transaction/hash';
import { getSender } from 'tevm/Transaction/getSender';

Related

• Transaction (Effect) - Effect.ts integration with Schema validation
• Address - 20-byte Ethereum addresses
• Keccak256 - 32-byte hash values
• Hex - Hex string utilities
• RLP - Recursive Length Prefix encoding
• AccessList - Pre-declared account/storage access
• Blob - Blob data for EIP-4844
• Authorization - EOA delegation for EIP-7702
• FeeMarket - Base fee and priority fee calculations
• GasConstants - Gas intrinsic costs
• Secp256k1 - ECDSA signature utilities

Specification

• EIP-155 - Replay protection
• EIP-2718 - Typed transaction envelope
• EIP-2930 - Access lists
• EIP-1559 - Fee market
• EIP-4844 - Blob transactions
• EIP-7702 - EOA delegation
• Ethereum Yellow Paper - Transaction spec (Section 4.2)