types

package
v1.16.67 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 1, 2026 License: GPL-3.0, BSD-3-Clause Imports: 29 Imported by: 134

Documentation

Overview

Package types contains data types related to Ethereum consensus.

Index

Constants

View Source 
const (
	// BloomByteLength represents the number of bytes used in a header log bloom.
	BloomByteLength = 256

	// BloomBitLength represents the number of bits used in a header log bloom.
	BloomBitLength = 8 * BloomByteLength
)
View Source 
const (
	// ReceiptStatusFailed is the status code of a transaction if execution failed.
	ReceiptStatusFailed = uint64(0)

	// ReceiptStatusSuccessful is the status code of a transaction if execution succeeded.
	ReceiptStatusSuccessful = uint64(1)
)
View Source 
const (
	LegacyTxType     = 0x00
	AccessListTxType = 0x01
	DynamicFeeTxType = 0x02
	BlobTxType       = 0x03
	SetCodeTxType    = 0x04
)

Transaction types.

View Source 
const (
	// BlobSidecarVersion0 includes a single proof for verifying the entire blob
	// against its commitment. Used when the full blob is available and needs to
	// be checked as a whole.
	BlobSidecarVersion0 = byte(0)

	// BlobSidecarVersion1 includes multiple cell proofs for verifying specific
	// blob elements (cells). Used in scenarios like data availability sampling,
	// where only portions of the blob are verified individually.
	BlobSidecarVersion1 = byte(1)
)

Variables

View Source 
var (
	// EmptyRootHash is the known root hash of an empty merkle trie.
	EmptyRootHash = common.HexToHash("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421")

	// EmptyUncleHash is the known hash of the empty uncle set.
	EmptyUncleHash = rlpHash([]*Header(nil)) // 1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347

	// EmptyCodeHash is the known hash of the empty EVM bytecode.
	EmptyCodeHash = common.Keccak256Hash(nil) // c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470

	// EmptyTxsHash is the known hash of the empty transaction set.
	EmptyTxsHash = common.HexToHash("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421")

	// EmptyReceiptsHash is the known hash of the empty receipt set.
	EmptyReceiptsHash = common.HexToHash("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421")

	// EmptyWithdrawalsHash is the known hash of the empty withdrawal set.
	EmptyWithdrawalsHash = common.HexToHash("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421")

	// EmptyRequestsHash is the known hash of an empty request set, sha256("").
	EmptyRequestsHash = common.HexToHash("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855")

	// EmptyVerkleHash is the known hash of an empty verkle trie.
	EmptyVerkleHash = common.Hash{}

	// EmptyBinaryHash is the known hash of an empty binary trie.
	EmptyBinaryHash = common.Hash{}
)
View Source 
var (
	ErrInvalidSig           = errors.New("invalid transaction v, r, s values")
	ErrUnexpectedProtection = errors.New("transaction type does not supported EIP-155 protected signatures")
	ErrTxTypeNotSupported   = errors.New("transaction type not supported")
	ErrGasFeeCapTooLow      = errors.New("fee cap less than base fee")
	ErrUint256Overflow      = errors.New("bigint overflow, too large for uint256")
)
View Source 
var DelegationPrefix = []byte{0xef, 0x01, 0x00}

DelegationPrefix is used by code to denote the account is delegating to another account.

View Source 
var ErrInvalidChainId = errors.New("invalid chain id for signer")

Functions

func AddressToDelegation 

func AddressToDelegation(addr common.Address) []byte

AddressToDelegation adds the delegation prefix to the specified address.

func Bloom9 

func Bloom9(data []byte) []byte

Bloom9 returns the bloom filter for the given data

func BloomLookup 

func BloomLookup(bin Bloom, topic bytesBacked) bool

BloomLookup is a convenience-method to check presence in the bloom filter

func CalcRequestsHash 

func CalcRequestsHash(requests [][]byte) common.Hash

CalcRequestsHash creates the block requestsHash value for a list of requests.

func CalcUncleHash 

func CalcUncleHash(uncles []*Header) common.Hash

func DepositLogToRequest 

func DepositLogToRequest(data []byte) ([]byte, error)

DepositLogToRequest unpacks a serialized DepositEvent.

func DeriveSha 

func DeriveSha(list DerivableList, hasher ListHasher) common.Hash

DeriveSha creates the tree hashes of transactions, receipts, and withdrawals in a block header.

func EncodeBlockReceiptLists 

func EncodeBlockReceiptLists(receipts []Receipts) []rlp.RawValue

EncodeBlockReceiptLists encodes a list of block receipt lists into RLP.

func FullAccountRLP 

func FullAccountRLP(data []byte) ([]byte, error)

FullAccountRLP converts data on the 'slim RLP' format into the full RLP-format.

func HashDifference 

func HashDifference(a, b []common.Hash) []common.Hash

HashDifference returns a new set of hashes that are present in a but not in b.

func HeaderParentHashFromRLP 

func HeaderParentHashFromRLP(header []byte) common.Hash

HeaderParentHashFromRLP returns the parentHash of an RLP-encoded header. If 'header' is invalid, the zero hash is returned.

func ParseDelegation 

func ParseDelegation(b []byte) (common.Address, bool)

ParseDelegation tries to parse the address from a delegation slice.

func Sender 

func Sender(signer Signer, tx *Transaction) (common.Address, error)

Sender returns the address derived from the signature (V, R, S) using secp256k1 elliptic curve and an error if it failed deriving or upon an incorrect signature.

Sender may cache the address, allowing it to be used regardless of signing method. The cache is invalidated if the cached signer does not match the signer used in the current call.

func SlimAccountRLP 

func SlimAccountRLP(account StateAccount) []byte

SlimAccountRLP encodes the state account in 'slim RLP' format.

Types

type AccessList 

type AccessList []AccessTuple

AccessList is an EIP-2930 access list.

func (AccessList) StorageKeys 

func (al AccessList) StorageKeys() int

StorageKeys returns the total number of storage keys in the access list.

type AccessListTx 

type AccessListTx struct {
	ChainID    *big.Int        // destination chain ID
	Nonce      uint64          // nonce of sender account
	GasPrice   *big.Int        // wei per gas
	Gas        uint64          // gas limit
	To         *common.Address `rlp:"nil"` // nil means contract creation
	Value      *big.Int        // wei amount
	Data       []byte          // contract invocation input data
	AccessList AccessList      // EIP-2930 access list
	V, R, S    *big.Int        // signature values
}

AccessListTx is the data of EIP-2930 access list transactions.

type AccessTuple 

type AccessTuple struct {
	Address     common.Address `json:"address"     gencodec:"required"`
	StorageKeys []common.Hash  `json:"storageKeys" gencodec:"required"`
}

AccessTuple is the element type of an access list.

func (AccessTuple) MarshalJSON 

func (a AccessTuple) MarshalJSON() ([]byte, error)

MarshalJSON marshals as JSON.

func (*AccessTuple) UnmarshalJSON 

func (a *AccessTuple) UnmarshalJSON(input []byte) error

UnmarshalJSON unmarshals from JSON.

type Account 

type Account struct {
	Code    []byte                      `json:"code,omitempty"`
	Storage map[common.Hash]common.Hash `json:"storage,omitempty"`
	Balance *big.Int                    `json:"balance" gencodec:"required"`
	Nonce   uint64                      `json:"nonce,omitempty"`
}

Account represents an Ethereum account and its attached data. This type is used to specify accounts in the genesis block state, and is also useful for JSON encoding/decoding of accounts.

func (Account) MarshalJSON 

func (a Account) MarshalJSON() ([]byte, error)

MarshalJSON marshals as JSON.

func (*Account) UnmarshalJSON 

func (a *Account) UnmarshalJSON(input []byte) error

UnmarshalJSON unmarshals from JSON.

type BlobTx 

type BlobTx struct {
	ChainID    *uint256.Int
	Nonce      uint64
	GasTipCap  *uint256.Int // a.k.a. maxPriorityFeePerGas
	GasFeeCap  *uint256.Int // a.k.a. maxFeePerGas
	Gas        uint64
	To         common.Address
	Value      *uint256.Int
	Data       []byte
	AccessList AccessList
	BlobFeeCap *uint256.Int // a.k.a. maxFeePerBlobGas
	BlobHashes []common.Hash

	// A blob transaction can optionally contain blobs. This field must be set when BlobTx
	// is used to create a transaction for signing.
	Sidecar *BlobTxSidecar `rlp:"-"`

	// Signature values
	V *uint256.Int
	R *uint256.Int
	S *uint256.Int
}

BlobTx represents an EIP-4844 transaction.

type BlobTxSidecar 

type BlobTxSidecar struct {
	Version     byte                 // Version
	Blobs       []kzg4844.Blob       // Blobs needed by the blob pool
	Commitments []kzg4844.Commitment // Commitments needed by the blob pool
	Proofs      []kzg4844.Proof      // Proofs needed by the blob pool
}

BlobTxSidecar contains the blobs of a blob transaction.

func NewBlobTxSidecar 

func NewBlobTxSidecar(version byte, blobs []kzg4844.Blob, commitments []kzg4844.Commitment, proofs []kzg4844.Proof) *BlobTxSidecar

NewBlobTxSidecar initialises the BlobTxSidecar object with the provided parameters.

func (*BlobTxSidecar) BlobHashes 

func (sc *BlobTxSidecar) BlobHashes() []common.Hash

BlobHashes computes the blob hashes of the given blobs.

func (*BlobTxSidecar) CellProofsAt 

func (sc *BlobTxSidecar) CellProofsAt(idx int) ([]kzg4844.Proof, error)

CellProofsAt returns the cell proofs for blob with index idx. This method is only valid for sidecars with version 1.

func (*BlobTxSidecar) Copy 

func (sc *BlobTxSidecar) Copy() *BlobTxSidecar

Copy returns a deep-copied BlobTxSidecar object.

func (*BlobTxSidecar) ToV1 

func (sc *BlobTxSidecar) ToV1() error

ToV1 converts the BlobSidecar to version 1, attaching the cell proofs.

func (*BlobTxSidecar) ValidateBlobCommitmentHashes 

func (sc *BlobTxSidecar) ValidateBlobCommitmentHashes(hashes []common.Hash) error

ValidateBlobCommitmentHashes checks whether the given hashes correspond to the commitments in the sidecar

type Block 

type Block struct {

	// These fields are used by package eth to track
	// inter-peer block relay.
	ReceivedAt   time.Time
	ReceivedFrom interface{}
	// contains filtered or unexported fields
}

Block represents an Ethereum block.

Note the Block type tries to be 'immutable', and contains certain caches that rely on that. The rules around block immutability are as follows:

  • We copy all data when the block is constructed. This makes references held inside the block independent of whatever value was passed in.

  • We copy all header data on access. This is because any change to the header would mess up the cached hash and size values in the block. Calling code is expected to take advantage of this to avoid over-allocating!

  • When new body data is attached to the block, a shallow copy of the block is returned. This ensures block modifications are race-free.

  • We do not copy body data on access because it does not affect the caches, and also because it would be too expensive.

func DecodeBlock added in v1.16.55 

func DecodeBlock(data []byte) (*Block, error)

DecodeBlock decodes a block from RLP bytes.

func DecodeBlockRLPWithLegacySupport added in v1.16.55 

func DecodeBlockRLPWithLegacySupport(data []byte) (*Block, error)

DecodeBlockRLPWithLegacySupport decodes a block from RLP with support for legacy headers. This is used for importing blocks from older chains that use pre-Shanghai header format.

func NewBlock 

func NewBlock(header *Header, body *Body, receipts []*Receipt, hasher ListHasher) *Block

NewBlock creates a new block. The input data is copied, changes to header and to the field values will not affect the block.

The body elements and the receipts are used to recompute and overwrite the relevant portions of the header.

The receipt's bloom must already calculated for the block's bloom to be correctly calculated.

func NewBlockWithHeader 

func NewBlockWithHeader(header *Header) *Block

NewBlockWithHeader creates a block with the given header data. The header data is copied, changes to header and to the field values will not affect the block.

func (*Block) BaseFee 

func (b *Block) BaseFee() *big.Int

func (*Block) BeaconRoot 

func (b *Block) BeaconRoot() *common.Hash

func (*Block) BlobGasUsed 

func (b *Block) BlobGasUsed() *uint64

func (*Block) Bloom 

func (b *Block) Bloom() Bloom

func (*Block) Body 

func (b *Block) Body() *Body

Body returns the non-header content of the block. Note the returned data is not an independent copy.

func (*Block) Coinbase 

func (b *Block) Coinbase() common.Address

func (*Block) DecodeRLP 

func (b *Block) DecodeRLP(s *rlp.Stream) error

DecodeRLP decodes a block from RLP with format detection.

func (*Block) Difficulty 

func (b *Block) Difficulty() *big.Int

func (*Block) EncodeRLP 

func (b *Block) EncodeRLP(w io.Writer) error

EncodeRLP serializes a block as RLP.

func (*Block) ExcessBlobGas 

func (b *Block) ExcessBlobGas() *uint64

func (*Block) ExecutionWitness 

func (b *Block) ExecutionWitness() *ExecutionWitness

ExecutionWitness returns the verkle execution witneess + proof for a block

func (*Block) Extra 

func (b *Block) Extra() []byte

func (*Block) GasLimit 

func (b *Block) GasLimit() uint64

func (*Block) GasUsed 

func (b *Block) GasUsed() uint64

func (*Block) Hash 

func (b *Block) Hash() common.Hash

Hash returns the keccak256 hash of b's header. The hash is computed on the first call and cached thereafter.

func (*Block) Header 

func (b *Block) Header() *Header

Header returns the block header (as a copy).

func (*Block) MixDigest 

func (b *Block) MixDigest() common.Hash

func (*Block) Nonce 

func (b *Block) Nonce() uint64

func (*Block) Number 

func (b *Block) Number() *big.Int

func (*Block) NumberU64 

func (b *Block) NumberU64() uint64

func (*Block) ParentHash 

func (b *Block) ParentHash() common.Hash

func (*Block) ReceiptHash 

func (b *Block) ReceiptHash() common.Hash

func (*Block) RequestsHash 

func (b *Block) RequestsHash() *common.Hash

func (*Block) Root 

func (b *Block) Root() common.Hash

func (*Block) SanityCheck 

func (b *Block) SanityCheck() error

SanityCheck can be used to prevent that unbounded fields are stuffed with junk data to add processing overhead

func (*Block) Size 

func (b *Block) Size() uint64

Size returns the true RLP encoded storage size of the block, either by encoding and returning it, or returning a previously cached value.

func (*Block) Time 

func (b *Block) Time() uint64

func (*Block) Transaction 

func (b *Block) Transaction(hash common.Hash) *Transaction

func (*Block) Transactions 

func (b *Block) Transactions() Transactions

func (*Block) TxHash 

func (b *Block) TxHash() common.Hash

func (*Block) UncleHash 

func (b *Block) UncleHash() common.Hash

func (*Block) Uncles 

func (b *Block) Uncles() []*Header

func (*Block) WithBody 

func (b *Block) WithBody(body Body) *Block

WithBody returns a new block with the original header and a deep copy of the provided body.

func (*Block) WithSeal 

func (b *Block) WithSeal(header *Header) *Block

WithSeal returns a new block with the data from b but the header replaced with the sealed one.

func (*Block) WithWitness 

func (b *Block) WithWitness(witness *ExecutionWitness) *Block

func (*Block) Withdrawals 

func (b *Block) Withdrawals() Withdrawals

type BlockNonce 

type BlockNonce [8]byte

A BlockNonce is a 64-bit hash which proves (combined with the mix-hash) that a sufficient amount of computation has been carried out on a block.

func EncodeNonce 

func EncodeNonce(i uint64) BlockNonce

EncodeNonce converts the given integer to a block nonce.

func (BlockNonce) MarshalText 

func (n BlockNonce) MarshalText() ([]byte, error)

MarshalText encodes n as a hex string with 0x prefix.

func (BlockNonce) Uint64 

func (n BlockNonce) Uint64() uint64

Uint64 returns the integer value of a block nonce.

func (*BlockNonce) UnmarshalText 

func (n *BlockNonce) UnmarshalText(input []byte) error

UnmarshalText implements encoding.TextUnmarshaler.

type Blocks 

type Blocks []*Block

type Bloom 

type Bloom [BloomByteLength]byte

Bloom represents a 2048 bit bloom filter.

func BytesToBloom 

func BytesToBloom(b []byte) Bloom

BytesToBloom converts a byte slice to a bloom filter. It panics if b is not of suitable size.

func CreateBloom 

func CreateBloom(receipt *Receipt) Bloom

CreateBloom creates a bloom filter out of the give Receipt (+Logs)

func MergeBloom 

func MergeBloom(receipts Receipts) Bloom

MergeBloom merges the precomputed bloom filters in the Receipts without recalculating them. It assumes that each receipt’s Bloom field is already correctly populated.

func (*Bloom) Add 

func (b *Bloom) Add(d []byte)

Add adds d to the filter. Future calls of Test(d) will return true.

func (*Bloom) AddWithBuffer 

func (b *Bloom) AddWithBuffer(d []byte, buf *[6]byte)

add is internal version of Add, which takes a scratch buffer for reuse (needs to be at least 6 bytes)

func (Bloom) Big 

func (b Bloom) Big() *big.Int

Big converts b to a big integer. Note: Converting a bloom filter to a big.Int and then calling GetBytes does not return the same bytes, since big.Int will trim leading zeroes

func (Bloom) Bytes 

func (b Bloom) Bytes() []byte

Bytes returns the backing byte slice of the bloom

func (Bloom) MarshalText 

func (b Bloom) MarshalText() ([]byte, error)

MarshalText encodes b as a hex string with 0x prefix.

func (*Bloom) SetBytes 

func (b *Bloom) SetBytes(d []byte)

SetBytes sets the content of b to the given bytes. It panics if d is not of suitable size.

func (Bloom) Test 

func (b Bloom) Test(topic []byte) bool

Test checks if the given topic is present in the bloom filter

func (*Bloom) UnmarshalText 

func (b *Bloom) UnmarshalText(input []byte) error

UnmarshalText b as a hex string with 0x prefix.

type Body 

type Body struct {
	Transactions []*Transaction
	Uncles       []*Header
	Withdrawals  []*Withdrawal `rlp:"optional"`
}

Body is a simple (mutable, non-safe) data container for storing and moving a block's data contents (transactions and uncles) together.

type DerivableList 

type DerivableList interface {
	Len() int
	EncodeIndex(int, *bytes.Buffer)
}

DerivableList is the input to DeriveSha. It is implemented by the 'Transactions' and 'Receipts' types. This is internal, do not use these methods.

type DeriveReceiptContext 

type DeriveReceiptContext struct {
	BlockHash    common.Hash
	BlockNumber  uint64
	BlockTime    uint64
	BaseFee      *big.Int
	BlobGasPrice *big.Int
	GasUsed      uint64
	LogIndex     uint // Number of logs in the block until this receipt
	Tx           *Transaction
	TxIndex      uint
}

DeriveReceiptContext holds the contextual information needed to derive a receipt

type DynamicFeeTx 

type DynamicFeeTx struct {
	ChainID    *big.Int
	Nonce      uint64
	GasTipCap  *big.Int // a.k.a. maxPriorityFeePerGas
	GasFeeCap  *big.Int // a.k.a. maxFeePerGas
	Gas        uint64
	To         *common.Address `rlp:"nil"` // nil means contract creation
	Value      *big.Int
	Data       []byte
	AccessList AccessList

	// Signature values
	V *big.Int
	R *big.Int
	S *big.Int
}

DynamicFeeTx represents an EIP-1559 transaction.

type EIP155Signer 

type EIP155Signer struct {
	// contains filtered or unexported fields
}

EIP155Signer implements Signer using the EIP-155 rules. This accepts transactions which are replay-protected as well as unprotected homestead transactions. Deprecated: always use the Signer interface type

func NewEIP155Signer 

func NewEIP155Signer(chainId *big.Int) EIP155Signer

func (EIP155Signer) ChainID 

func (s EIP155Signer) ChainID() *big.Int

func (EIP155Signer) Equal 

func (s EIP155Signer) Equal(s2 Signer) bool

func (EIP155Signer) Hash 

func (s EIP155Signer) Hash(tx *Transaction) common.Hash

Hash returns the hash to be signed by the sender. It does not uniquely identify the transaction.

func (EIP155Signer) Sender 

func (s EIP155Signer) Sender(tx *Transaction) (common.Address, error)

func (EIP155Signer) SignatureValues 

func (s EIP155Signer) SignatureValues(tx *Transaction, sig []byte) (R, S, V *big.Int, err error)

SignatureValues returns signature values. This signature needs to be in the [R || S || V] format where V is 0 or 1.

type ExecutionWitness 

type ExecutionWitness struct {
	StateDiff   verkle.StateDiff    `json:"stateDiff"`
	VerkleProof *verkle.VerkleProof `json:"verkleProof"`
}

ExecutionWitness represents the witness + proof used in a verkle context, to provide the ability to execute a block statelessly.

type FrontierSigner 

type FrontierSigner struct{}

FrontierSigner implements Signer using the frontier rules. Deprecated: always use the Signer interface type

func (FrontierSigner) ChainID 

func (fs FrontierSigner) ChainID() *big.Int

func (FrontierSigner) Equal 

func (fs FrontierSigner) Equal(s2 Signer) bool

func (FrontierSigner) Hash 

func (fs FrontierSigner) Hash(tx *Transaction) common.Hash

Hash returns the hash to be signed by the sender. It does not uniquely identify the transaction.

func (FrontierSigner) Sender 

func (fs FrontierSigner) Sender(tx *Transaction) (common.Address, error)

func (FrontierSigner) SignatureValues 

func (fs FrontierSigner) SignatureValues(tx *Transaction, sig []byte) (r, s, v *big.Int, err error)

SignatureValues returns signature values. This signature needs to be in the [R || S || V] format where V is 0 or 1.

type GenesisAlloc 

type GenesisAlloc map[common.Address]Account

GenesisAlloc specifies the initial state of a genesis block.

func (*GenesisAlloc) UnmarshalJSON 

func (ga *GenesisAlloc) UnmarshalJSON(data []byte) error
type Header struct {
	// Positions 0-14: Core Ethereum fields (unchanged since frontier)
	ParentHash  common.Hash    `json:"parentHash"       gencodec:"required"` // Pos 0
	UncleHash   common.Hash    `json:"sha3Uncles"       gencodec:"required"` // Pos 1
	Coinbase    common.Address `json:"miner"`                                // Pos 2
	Root        common.Hash    `json:"stateRoot"        gencodec:"required"` // Pos 3
	TxHash      common.Hash    `json:"transactionsRoot" gencodec:"required"` // Pos 4
	ReceiptHash common.Hash    `json:"receiptsRoot"     gencodec:"required"` // Pos 5
	Bloom       Bloom          `json:"logsBloom"        gencodec:"required"` // Pos 6 (256 bytes)
	Difficulty  *big.Int       `json:"difficulty"       gencodec:"required"` // Pos 7
	Number      *big.Int       `json:"number"           gencodec:"required"` // Pos 8
	GasLimit    uint64         `json:"gasLimit"         gencodec:"required"` // Pos 9
	GasUsed     uint64         `json:"gasUsed"          gencodec:"required"` // Pos 10
	Time        uint64         `json:"timestamp"        gencodec:"required"` // Pos 11
	Extra       []byte         `json:"extraData"        gencodec:"required"` // Pos 12
	MixDigest   common.Hash    `json:"mixHash"`                              // Pos 13
	Nonce       BlockNonce     `json:"nonce"`                                // Pos 14 (8 bytes)

	// Position 15: EIP-1559 (London fork)
	// Present in 16-field genesis AND all post-genesis blocks.
	BaseFee *big.Int `json:"baseFeePerGas" rlp:"optional"` // Pos 15

	// Positions 16-18: Lux/coreth-specific fields
	// NOT present in genesis (16-field format), present in post-genesis (19+ fields).
	// These MUST come before Ethereum 2.0 fields to maintain hash compatibility.
	//
	// IMPORTANT: ExtDataHash uses *common.Hash (pointer), NOT common.Hash (value).
	// Original coreth used value type, but Lux geth uses pointer for proper nil encoding.
	ExtDataHash    *common.Hash `json:"extDataHash" rlp:"optional"`    // Pos 16 (when present)
	ExtDataGasUsed *big.Int     `json:"extDataGasUsed" rlp:"optional"` // Pos 17 (when present)
	BlockGasCost   *big.Int     `json:"blockGasCost" rlp:"optional"`   // Pos 18 (when present)

	// Positions 19+: Ethereum 2.0 fields (Shanghai/Cancun/Prague)
	// Only present when chain upgrades to support these features.
	// Note: These come AFTER Lux fields, unlike standard Ethereum order.
	BlobGasUsed      *uint64      `json:"blobGasUsed" rlp:"optional"`           // Pos 19 (when present)
	ExcessBlobGas    *uint64      `json:"excessBlobGas" rlp:"optional"`         // Pos 20 (when present)
	ParentBeaconRoot *common.Hash `json:"parentBeaconBlockRoot" rlp:"optional"` // Pos 21 (when present)
	WithdrawalsHash  *common.Hash `json:"withdrawalsRoot" rlp:"optional"`       // Pos 22 (when present)
	RequestsHash     *common.Hash `json:"requestsHash" rlp:"optional"`          // Pos 23 (when present)
	// contains filtered or unexported fields
}

Header represents a block header in the Lux C-chain (EVM-compatible).

IMPORTANT: Lux C-Chain Header Format Requirements

The Lux C-chain uses different header formats depending on the block:

  • Genesis (Block 0): 16 fields (post-London, pre-ExtDataHash)
  • Post-Genesis: 19 fields (with ExtDataHash, ExtDataGasUsed, BlockGasCost)
  • Future: 20-24 fields (adding Ethereum 2.0 fields)

Critical Network Parameters: 

Chain ID:     96369
Genesis Hash: 0x3f4fa2a0b0ce089f52bf0ae9199c75ffdd76ecafc987794050cb0d286f1ec61e
State Root:   0x2d1cedac263020c5c56ef962f6abe0da1f5217bdc6468f8c9258a0ea23699e80

RLP Field Order (for hash computation): 

Pos 0-14:  Core Ethereum fields (ParentHash through Nonce)
Pos 15:    BaseFee (EIP-1559, added in London)
Pos 16-18: Lux-specific fields (ExtDataHash, ExtDataGasUsed, BlockGasCost)
Pos 19+:   Ethereum 2.0 fields (BlobGasUsed, ExcessBlobGas, etc.)

CRITICAL: ExtDataHash Type Difference from Original Coreth

The original coreth implementation used common.Hash (value type) for ExtDataHash: 

ExtDataHash common.Hash `rlp:"optional"`  // WRONG - original coreth

Lux geth uses *common.Hash (pointer type) to allow proper nil encoding: 

ExtDataHash *common.Hash `rlp:"optional"` // CORRECT - Lux geth

This is intentional: pointer types encode as absent when nil, while value types encode as zero hash. The genesis block must NOT include ExtDataHash to produce the correct 16-field hash.

Hash Methods:

  • Hash(): Uses rawRLP if set, otherwise re-encodes (for decoded blocks)
  • Hash16(): Computes 16-field hash for genesis verification

See LLM.md for comprehensive documentation on header formats.

func CopyHeader 

func CopyHeader(h *Header) *Header

CopyHeader creates a deep copy of a block header.

func DecodeHeader added in v1.16.55 

func DecodeHeader(data []byte) (*Header, error)

DecodeHeader decodes a header from RLP bytes. Detects format by field count: 15 (pre-London), 16 (post-London), 17+ (extended). The raw RLP bytes are stored for hash computation compatibility.

func (*Header) ClearInternalFields added in v1.16.55 

func (h *Header) ClearInternalFields()

ClearInternalFields clears internal fields used for decode/encode operations. This is useful for testing when comparing headers after roundtrip encoding.

func (*Header) DecodeRLP added in v1.16.55 

func (h *Header) DecodeRLP(s *rlp.Stream) error

DecodeRLP decodes a header from RLP with format detection. Supports 15-21 field formats for legacy, London, Shanghai, and Lux chains. Stores the original RLP bytes for hash computation to ensure cryptographic continuity regardless of format differences during re-encoding.

func (*Header) EmptyBody 

func (h *Header) EmptyBody() bool

EmptyBody returns true if there is no additional 'body' to complete the header that is: no transactions, no uncles and no withdrawals.

func (*Header) EmptyReceipts 

func (h *Header) EmptyReceipts() bool

EmptyReceipts returns true if there are no receipts for this header/block.

func (*Header) EncodeRLP 

func (h *Header) EncodeRLP(w io.Writer) error

EncodeRLP encodes the header to RLP using the appropriate format. The format is determined by rlpFormat (set during decode) or detected from fields.

Format handling (in priority order):

  1. Genesis blocks (Number == 0): ALWAYS uses 16-field format to match original Lux mainnet genesis. This ensures cryptographic compatibility regardless of what fork fields are set in the header struct.
  2. rlpFormat set (from decode): Uses the format detected during decode
  3. Lux 19-field format: If ExtDataGasUsed or BlockGasCost set (but no Eth2 fields)
  4. Default: Standard encoding with all non-nil fields

func (*Header) EncodeRLP19Lux added in v1.16.55 

func (h *Header) EncodeRLP19Lux() ([]byte, error)

EncodeRLP19Lux encodes the header using Lux 19-field format. This format uses ExtDataHash as a VALUE type (common.Hash), not pointer. Returns the RLP-encoded bytes.

func (*Header) GetRLPFormat added in v1.16.55 

func (h *Header) GetRLPFormat() RLPFormat

GetRLPFormat returns the RLP encoding format used when this header was decoded. Returns RLPFormatUnknown if the header was not decoded from RLP.

func (*Header) Hash 

func (h *Header) Hash() common.Hash

Hash returns the block hash of the header, which is simply the keccak256 hash of its RLP encoding.

Special handling (in order of priority):

  1. Genesis blocks (Number == 0): ALWAYS uses 16-field format to match original Lux mainnet genesis hash. This takes priority over rawRLP because genesis blocks may be stored with extra fork fields (WithdrawalsHash, etc.) but must hash correctly.
  2. rawRLP set (from decoding): Uses stored bytes to preserve hash compatibility with the original chain format for imported/historic blocks.
  3. Lux blocks (ExtDataGasUsed or BlockGasCost set): Uses 19-field format with ExtDataHash as value type to match original coreth encoding.
  4. Default: Uses standard RLP encoding.

func (*Header) Hash16 added in v1.16.55 

func (h *Header) Hash16() common.Hash

Hash16 returns the hash using 16-field format (post-London, pre-ExtDataHash). Used for Lux mainnet genesis compatibility.

func (*Header) Hash19 added in v1.16.55 

func (h *Header) Hash19() common.Hash

Hash19 returns the hash using 19-field Lux format with ExtDataHash as value type. This matches original coreth encoding where ExtDataHash was common.Hash (not pointer). When h.ExtDataHash is nil, encodes as zero hash (32 zero bytes).

func (*Header) Hash19Lux added in v1.16.55 

func (h *Header) Hash19Lux() common.Hash

Hash19Lux returns the hash using Lux 19-field format. This is used for Lux post-genesis blocks where ExtDataHash is a VALUE type.

func (Header) MarshalJSON 

func (h Header) MarshalJSON() ([]byte, error)

MarshalJSON marshals as JSON.

func (*Header) RawRLP added in v1.16.55 

func (h *Header) RawRLP() []byte

RawRLP returns the raw RLP bytes if set.

func (*Header) SanityCheck 

func (h *Header) SanityCheck() error

SanityCheck checks a few basic things -- these checks are way beyond what any 'sane' production values should hold, and can mainly be used to prevent that the unbounded fields are stuffed with junk data to add processing overhead

func (*Header) SetRLPFormat added in v1.16.55 

func (h *Header) SetRLPFormat(f RLPFormat)

SetRLPFormat sets the RLP encoding format for this header. This affects how the header is re-encoded.

func (*Header) SetRawRLP added in v1.16.55 

func (h *Header) SetRawRLP(raw []byte)

SetRawRLP sets the raw RLP bytes for hash computation. This is used when decoding blocks to preserve the original hash.

func (*Header) Size 

func (h *Header) Size() common.StorageSize

Size returns the approximate memory used by all internal contents. It is used to approximate and limit the memory consumption of various caches.

func (*Header) UnmarshalJSON 

func (h *Header) UnmarshalJSON(input []byte) error

UnmarshalJSON unmarshals from JSON.

type HomesteadSigner 

type HomesteadSigner struct{ FrontierSigner }

HomesteadSigner implements Signer using the homestead rules. The only valid reason to use this type is creating legacy transactions which are intentionally not replay-protected.

func (HomesteadSigner) ChainID 

func (hs HomesteadSigner) ChainID() *big.Int

func (HomesteadSigner) Equal 

func (hs HomesteadSigner) Equal(s2 Signer) bool

func (HomesteadSigner) Sender 

func (hs HomesteadSigner) Sender(tx *Transaction) (common.Address, error)

func (HomesteadSigner) SignatureValues 

func (hs HomesteadSigner) SignatureValues(tx *Transaction, sig []byte) (r, s, v *big.Int, err error)

SignatureValues returns signature values. This signature needs to be in the [R || S || V] format where V is 0 or 1.

type LegacyTx 

type LegacyTx struct {
	Nonce    uint64          // nonce of sender account
	GasPrice *big.Int        // wei per gas
	Gas      uint64          // gas limit
	To       *common.Address `rlp:"nil"` // nil means contract creation
	Value    *big.Int        // wei amount
	Data     []byte          // contract invocation input data
	V, R, S  *big.Int        // signature values
}

LegacyTx is the transaction data of the original Ethereum transactions.

type ListHasher added in v1.16.39 

type ListHasher interface {
	// Reset clears the internal state of the hasher, preparing it for reuse.
	Reset()

	// Update inserts the given key-value pair into the hasher.
	// The implementation must copy the provided slices, allowing the caller
	// to safely modify them after the call returns.
	Update(key []byte, value []byte) error

	// Hash computes and returns the final hash of all inserted key-value pairs.
	Hash() common.Hash
}

ListHasher defines the interface for computing the hash of a derivable list.

type Log 

type Log struct {
	// Consensus fields:
	// address of the contract that generated the event
	Address common.Address `json:"address" gencodec:"required"`
	// list of topics provided by the contract.
	Topics []common.Hash `json:"topics" gencodec:"required"`
	// supplied by the contract, usually ABI-encoded
	Data []byte `json:"data" gencodec:"required"`

	// Derived fields. These fields are filled in by the node
	// but not secured by consensus.
	// block in which the transaction was included
	BlockNumber uint64 `json:"blockNumber" rlp:"-"`
	// hash of the transaction
	TxHash common.Hash `json:"transactionHash" gencodec:"required" rlp:"-"`
	// index of the transaction in the block
	TxIndex uint `json:"transactionIndex" rlp:"-"`
	// hash of the block in which the transaction was included
	BlockHash common.Hash `json:"blockHash" rlp:"-"`
	// timestamp of the block in which the transaction was included
	BlockTimestamp uint64 `json:"blockTimestamp" rlp:"-"`
	// index of the log in the block
	Index uint `json:"logIndex" rlp:"-"`

	// The Removed field is true if this log was reverted due to a chain reorganisation.
	// You must pay attention to this field if you receive logs through a filter query.
	Removed bool `json:"removed" rlp:"-"`
}

Log represents a contract log event. These events are generated by the LOG opcode and stored/indexed by the node.

func (*Log) EncodeRLP 

func (obj *Log) EncodeRLP(_w io.Writer) error

func (Log) MarshalJSON 

func (l Log) MarshalJSON() ([]byte, error)

MarshalJSON marshals as JSON.

func (*Log) UnmarshalJSON 

func (l *Log) UnmarshalJSON(input []byte) error

UnmarshalJSON unmarshals from JSON.

type RLPFormat added in v1.16.55 

type RLPFormat uint8

RLPFormat represents the RLP encoding format for headers. This is tracked to ensure hash consistency when re-encoding. 

const (
	RLPFormatUnknown RLPFormat = 0
	RLPFormat15      RLPFormat = 15 // Pre-London
	RLPFormat16      RLPFormat = 16 // Post-London (genesis)
	RLPFormat17      RLPFormat = 17 // With ExtDataHash (pointer)
	RLPFormat18      RLPFormat = 18 // With ExtDataGasUsed
	RLPFormat19Lux   RLPFormat = 19 // Lux 19-field (ExtDataHash as VALUE)
	RLPFormat19Ptr   RLPFormat = 29 // 19-field with ExtDataHash as pointer (internal)
	RLPFormat20      RLPFormat = 20 // Lux extended
	RLPFormat20Eth   RLPFormat = 30 // Ethereum Cancun
	RLPFormat21      RLPFormat = 21 // Lux extended
	RLPFormat21Eth   RLPFormat = 31 // Ethereum with RequestsHash
	RLPFormat22      RLPFormat = 22 // Lux extended
	RLPFormat23      RLPFormat = 23 // Lux extended
	RLPFormat24      RLPFormat = 24 // Lux extended
)

type Receipt 

type Receipt struct {
	// Consensus fields: These fields are defined by the Yellow Paper
	Type              uint8  `json:"type,omitempty"`
	PostState         []byte `json:"root"`
	Status            uint64 `json:"status"`
	CumulativeGasUsed uint64 `json:"cumulativeGasUsed" gencodec:"required"`
	Bloom             Bloom  `json:"logsBloom"         gencodec:"required"`
	Logs              []*Log `json:"logs"              gencodec:"required"`

	// Implementation fields: These fields are added by geth when processing a transaction.
	TxHash            common.Hash    `json:"transactionHash" gencodec:"required"`
	ContractAddress   common.Address `json:"contractAddress"`
	GasUsed           uint64         `json:"gasUsed" gencodec:"required"`
	EffectiveGasPrice *big.Int       `json:"effectiveGasPrice"` // required, but tag omitted for backwards compatibility
	BlobGasUsed       uint64         `json:"blobGasUsed,omitempty"`
	BlobGasPrice      *big.Int       `json:"blobGasPrice,omitempty"`

	// Inclusion information: These fields provide information about the inclusion of the
	// transaction corresponding to this receipt.
	BlockHash        common.Hash `json:"blockHash,omitempty"`
	BlockNumber      *big.Int    `json:"blockNumber,omitempty"`
	TransactionIndex uint        `json:"transactionIndex"`
}

Receipt represents the results of a transaction.

func NewReceipt 

func NewReceipt(root []byte, failed bool, cumulativeGasUsed uint64) *Receipt

NewReceipt creates a barebone transaction receipt, copying the init fields. Deprecated: create receipts using a struct literal instead.

func (*Receipt) DecodeRLP 

func (r *Receipt) DecodeRLP(s *rlp.Stream) error

DecodeRLP implements rlp.Decoder, and loads the consensus fields of a receipt from an RLP stream.

func (*Receipt) DeriveFields 

func (r *Receipt) DeriveFields(signer Signer, context DeriveReceiptContext)

DeriveFields fills the receipt with computed fields based on consensus data and contextual infos like containing block and transactions.

func (*Receipt) EncodeRLP 

func (r *Receipt) EncodeRLP(w io.Writer) error

EncodeRLP implements rlp.Encoder, and flattens the consensus fields of a receipt into an RLP stream. If no post state is present, byzantium fork is assumed.

func (*Receipt) MarshalBinary 

func (r *Receipt) MarshalBinary() ([]byte, error)

MarshalBinary returns the consensus encoding of the receipt.

func (Receipt) MarshalJSON 

func (r Receipt) MarshalJSON() ([]byte, error)

MarshalJSON marshals as JSON.

func (*Receipt) Size 

func (r *Receipt) Size() common.StorageSize

Size returns the approximate memory used by all internal contents. It is used to approximate and limit the memory consumption of various caches.

func (*Receipt) UnmarshalBinary 

func (r *Receipt) UnmarshalBinary(b []byte) error

UnmarshalBinary decodes the consensus encoding of receipts. It supports legacy RLP receipts and EIP-2718 typed receipts.

func (*Receipt) UnmarshalJSON 

func (r *Receipt) UnmarshalJSON(input []byte) error

UnmarshalJSON unmarshals from JSON.

type ReceiptForStorage 

type ReceiptForStorage Receipt

ReceiptForStorage is a wrapper around a Receipt with RLP serialization that omits the Bloom field. The Bloom field is recomputed by DeriveFields.

func (*ReceiptForStorage) DecodeRLP 

func (r *ReceiptForStorage) DecodeRLP(s *rlp.Stream) error

DecodeRLP implements rlp.Decoder, and loads both consensus and implementation fields of a receipt from an RLP stream.

func (*ReceiptForStorage) EncodeRLP 

func (r *ReceiptForStorage) EncodeRLP(_w io.Writer) error

EncodeRLP implements rlp.Encoder, and flattens all content fields of a receipt into an RLP stream.

type Receipts 

type Receipts []*Receipt

Receipts implements DerivableList for receipts.

func (Receipts) DeriveFields 

func (rs Receipts) DeriveFields(config *params.ChainConfig, blockHash common.Hash, blockNumber uint64, blockTime uint64, baseFee *big.Int, blobGasPrice *big.Int, txs []*Transaction) error

DeriveFields fills the receipts with their computed fields based on consensus data and contextual infos like containing block and transactions.

func (Receipts) EncodeIndex 

func (rs Receipts) EncodeIndex(i int, w *bytes.Buffer)

EncodeIndex encodes the i'th receipt to w.

func (Receipts) Len 

func (rs Receipts) Len() int

Len returns the number of receipts in this list.

type SetCodeAuthorization 

type SetCodeAuthorization struct {
	ChainID uint256.Int    `json:"chainId" gencodec:"required"`
	Address common.Address `json:"address" gencodec:"required"`
	Nonce   uint64         `json:"nonce" gencodec:"required"`
	V       uint8          `json:"yParity" gencodec:"required"`
	R       uint256.Int    `json:"r" gencodec:"required"`
	S       uint256.Int    `json:"s" gencodec:"required"`
}

SetCodeAuthorization is an authorization from an account to deploy code at its address.

func SignSetCode 

func SignSetCode(prv *ecdsa.PrivateKey, auth SetCodeAuthorization) (SetCodeAuthorization, error)

SignSetCode creates a signed the SetCode authorization.

func (*SetCodeAuthorization) Authority 

func (a *SetCodeAuthorization) Authority() (common.Address, error)

Authority recovers the the authorizing account of an authorization.

func (SetCodeAuthorization) MarshalJSON 

func (s SetCodeAuthorization) MarshalJSON() ([]byte, error)

MarshalJSON marshals as JSON.

func (*SetCodeAuthorization) SigHash added in v1.2.6 

func (a *SetCodeAuthorization) SigHash() common.Hash

SigHash returns the hash of SetCodeAuthorization for signing.

func (*SetCodeAuthorization) UnmarshalJSON 

func (s *SetCodeAuthorization) UnmarshalJSON(input []byte) error

UnmarshalJSON unmarshals from JSON.

type SetCodeTx 

type SetCodeTx struct {
	ChainID    *uint256.Int
	Nonce      uint64
	GasTipCap  *uint256.Int // a.k.a. maxPriorityFeePerGas
	GasFeeCap  *uint256.Int // a.k.a. maxFeePerGas
	Gas        uint64
	To         common.Address
	Value      *uint256.Int
	Data       []byte
	AccessList AccessList
	AuthList   []SetCodeAuthorization

	// Signature values
	V *uint256.Int
	R *uint256.Int
	S *uint256.Int
}

SetCodeTx implements the EIP-7702 transaction type which temporarily installs the code at the signer's address.

type Signer 

type Signer interface {
	// Sender returns the sender address of the transaction.
	Sender(tx *Transaction) (common.Address, error)

	// SignatureValues returns the raw R, S, V values corresponding to the
	// given signature.
	SignatureValues(tx *Transaction, sig []byte) (r, s, v *big.Int, err error)
	ChainID() *big.Int

	// Hash returns 'signature hash', i.e. the transaction hash that is signed by the
	// private key. This hash does not uniquely identify the transaction.
	Hash(tx *Transaction) common.Hash

	// Equal returns true if the given signer is the same as the receiver.
	Equal(Signer) bool
}

Signer encapsulates transaction signature handling. The name of this type is slightly misleading because Signers don't actually sign, they're just for validating and processing of signatures.

Note that this interface is not a stable API and may change at any time to accommodate new protocol rules.

func LatestSigner 

func LatestSigner(config *params.ChainConfig) Signer

LatestSigner returns the 'most permissive' Signer available for the given chain configuration. Specifically, this enables support of all types of transactions when their respective forks are scheduled to occur at any block number (or time) in the chain config.

Use this in transaction-handling code where the current block number is unknown. If you have the current block number available, use MakeSigner instead.

func LatestSignerForChainID 

func LatestSignerForChainID(chainID *big.Int) Signer

LatestSignerForChainID returns the 'most permissive' Signer available. Specifically, this enables support for EIP-155 replay protection and all implemented EIP-2718 transaction types if chainID is non-nil.

Use this in transaction-handling code where the current block number and fork configuration are unknown. If you have a ChainConfig, use LatestSigner instead. If you have a ChainConfig and know the current block number, use MakeSigner instead.

func MakeSigner 

func MakeSigner(config *params.ChainConfig, blockNumber *big.Int, blockTime uint64) Signer

MakeSigner returns a Signer based on the given chain config and block number.

func NewCancunSigner 

func NewCancunSigner(chainId *big.Int) Signer

NewCancunSigner returns a signer that accepts - EIP-4844 blob transactions - EIP-1559 dynamic fee transactions - EIP-2930 access list transactions, - EIP-155 replay protected transactions, and - legacy Homestead transactions.

func NewEIP2930Signer 

func NewEIP2930Signer(chainId *big.Int) Signer

NewEIP2930Signer returns a signer that accepts EIP-2930 access list transactions, EIP-155 replay protected transactions, and legacy Homestead transactions.

func NewLondonSigner 

func NewLondonSigner(chainId *big.Int) Signer

NewLondonSigner returns a signer that accepts - EIP-1559 dynamic fee transactions - EIP-2930 access list transactions, - EIP-155 replay protected transactions, and - legacy Homestead transactions.

func NewPragueSigner 

func NewPragueSigner(chainId *big.Int) Signer

NewPragueSigner returns a signer that accepts - EIP-7702 set code transactions - EIP-4844 blob transactions - EIP-1559 dynamic fee transactions - EIP-2930 access list transactions, - EIP-155 replay protected transactions, and - legacy Homestead transactions.

type SlimAccount 

type SlimAccount struct {
	Nonce    uint64
	Balance  *uint256.Int
	Root     []byte // Nil if root equals to types.EmptyRootHash
	CodeHash []byte // Nil if hash equals to types.EmptyCodeHash
}

SlimAccount is a modified version of an Account, where the root is replaced with a byte slice. This format can be used to represent full-consensus format or slim format which replaces the empty root and code hash as nil byte slice.

type StateAccount 

type StateAccount struct {
	Nonce    uint64
	Balance  *uint256.Int
	Root     common.Hash // merkle root of the storage trie
	CodeHash []byte
}

StateAccount is the Ethereum consensus representation of accounts. These objects are stored in the main account trie.

func FullAccount 

func FullAccount(data []byte) (*StateAccount, error)

FullAccount decodes the data on the 'slim RLP' format and returns the consensus format account.

func NewEmptyStateAccount 

func NewEmptyStateAccount() *StateAccount

NewEmptyStateAccount constructs an empty state account.

func (*StateAccount) Copy 

func (acct *StateAccount) Copy() *StateAccount

Copy returns a deep-copied state account object.

func (*StateAccount) EncodeRLP 

func (obj *StateAccount) EncodeRLP(_w io.Writer) error

type Transaction 

type Transaction struct {
	// contains filtered or unexported fields
}

Transaction is an Ethereum transaction.

func MustSignNewTx 

func MustSignNewTx(prv *ecdsa.PrivateKey, s Signer, txdata TxData) *Transaction

MustSignNewTx creates a transaction and signs it. This panics if the transaction cannot be signed.

func NewContractCreation 

func NewContractCreation(nonce uint64, amount *big.Int, gasLimit uint64, gasPrice *big.Int, data []byte) *Transaction

NewContractCreation creates an unsigned legacy transaction. Deprecated: use NewTx instead.

func NewTransaction 

func NewTransaction(nonce uint64, to common.Address, amount *big.Int, gasLimit uint64, gasPrice *big.Int, data []byte) *Transaction

NewTransaction creates an unsigned legacy transaction. Deprecated: use NewTx instead.

func NewTx 

func NewTx(inner TxData) *Transaction

NewTx creates a new transaction.

func SignNewTx 

func SignNewTx(prv *ecdsa.PrivateKey, s Signer, txdata TxData) (*Transaction, error)

SignNewTx creates a transaction and signs it.

func SignTx 

func SignTx(tx *Transaction, s Signer, prv *ecdsa.PrivateKey) (*Transaction, error)

SignTx signs the transaction using the given signer and private key.

func (*Transaction) AccessList 

func (tx *Transaction) AccessList() AccessList

AccessList returns the access list of the transaction.

func (*Transaction) BlobGas 

func (tx *Transaction) BlobGas() uint64

BlobGas returns the blob gas limit of the transaction for blob transactions, 0 otherwise.

func (*Transaction) BlobGasFeeCap 

func (tx *Transaction) BlobGasFeeCap() *big.Int

BlobGasFeeCap returns the blob gas fee cap per blob gas of the transaction for blob transactions, nil otherwise.

func (*Transaction) BlobGasFeeCapCmp 

func (tx *Transaction) BlobGasFeeCapCmp(other *Transaction) int

BlobGasFeeCapCmp compares the blob fee cap of two transactions.

func (*Transaction) BlobGasFeeCapIntCmp 

func (tx *Transaction) BlobGasFeeCapIntCmp(other *big.Int) int

BlobGasFeeCapIntCmp compares the blob fee cap of the transaction against the given blob fee cap.

func (*Transaction) BlobHashes 

func (tx *Transaction) BlobHashes() []common.Hash

BlobHashes returns the hashes of the blob commitments for blob transactions, nil otherwise.

func (*Transaction) BlobTxSidecar 

func (tx *Transaction) BlobTxSidecar() *BlobTxSidecar

BlobTxSidecar returns the sidecar of a blob transaction, nil otherwise.

func (*Transaction) ChainId 

func (tx *Transaction) ChainId() *big.Int

ChainId returns the EIP155 chain ID of the transaction. The return value will always be non-nil. For legacy transactions which are not replay-protected, the return value is zero.

func (*Transaction) Cost 

func (tx *Transaction) Cost() *big.Int

Cost returns (gas * gasPrice) + (blobGas * blobGasPrice) + value.

func (*Transaction) Data 

func (tx *Transaction) Data() []byte

Data returns the input data of the transaction.

func (*Transaction) DecodeRLP 

func (tx *Transaction) DecodeRLP(s *rlp.Stream) error

DecodeRLP implements rlp.Decoder

func (*Transaction) EffectiveGasTip 

func (tx *Transaction) EffectiveGasTip(baseFee *big.Int) (*big.Int, error)

EffectiveGasTip returns the effective miner gasTipCap for the given base fee. Note: if the effective gasTipCap would be negative, this method returns ErrGasFeeCapTooLow, and value is undefined.

func (*Transaction) EffectiveGasTipCmp 

func (tx *Transaction) EffectiveGasTipCmp(other *Transaction, baseFee *uint256.Int) int

func (*Transaction) EffectiveGasTipIntCmp 

func (tx *Transaction) EffectiveGasTipIntCmp(other *uint256.Int, baseFee *uint256.Int) int

EffectiveGasTipIntCmp compares the effective gasTipCap of a transaction to the given gasTipCap.

func (*Transaction) EncodeRLP 

func (tx *Transaction) EncodeRLP(w io.Writer) error

EncodeRLP implements rlp.Encoder

func (*Transaction) Gas 

func (tx *Transaction) Gas() uint64

Gas returns the gas limit of the transaction.

func (*Transaction) GasFeeCap 

func (tx *Transaction) GasFeeCap() *big.Int

GasFeeCap returns the fee cap per gas of the transaction.

func (*Transaction) GasFeeCapCmp 

func (tx *Transaction) GasFeeCapCmp(other *Transaction) int

GasFeeCapCmp compares the fee cap of two transactions.

func (*Transaction) GasFeeCapIntCmp 

func (tx *Transaction) GasFeeCapIntCmp(other *big.Int) int

GasFeeCapIntCmp compares the fee cap of the transaction against the given fee cap.

func (*Transaction) GasPrice 

func (tx *Transaction) GasPrice() *big.Int

GasPrice returns the gas price of the transaction.

func (*Transaction) GasTipCap 

func (tx *Transaction) GasTipCap() *big.Int

GasTipCap returns the gasTipCap per gas of the transaction.

func (*Transaction) GasTipCapCmp 

func (tx *Transaction) GasTipCapCmp(other *Transaction) int

GasTipCapCmp compares the gasTipCap of two transactions.

func (*Transaction) GasTipCapIntCmp 

func (tx *Transaction) GasTipCapIntCmp(other *big.Int) int

GasTipCapIntCmp compares the gasTipCap of the transaction against the given gasTipCap.

func (*Transaction) Hash 

func (tx *Transaction) Hash() common.Hash

Hash returns the transaction hash.

func (*Transaction) MarshalBinary 

func (tx *Transaction) MarshalBinary() ([]byte, error)

MarshalBinary returns the canonical encoding of the transaction. For legacy transactions, it returns the RLP encoding. For EIP-2718 typed transactions, it returns the type and payload.

func (*Transaction) MarshalJSON 

func (tx *Transaction) MarshalJSON() ([]byte, error)

MarshalJSON marshals as JSON with a hash.

func (*Transaction) Nonce 

func (tx *Transaction) Nonce() uint64

Nonce returns the sender account nonce of the transaction.

func (*Transaction) Protected 

func (tx *Transaction) Protected() bool

Protected says whether the transaction is replay-protected.

func (*Transaction) RawSignatureValues 

func (tx *Transaction) RawSignatureValues() (v, r, s *big.Int)

RawSignatureValues returns the V, R, S signature values of the transaction. The return values should not be modified by the caller. The return values may be nil or zero, if the transaction is unsigned.

func (*Transaction) SetCodeAuthorities 

func (tx *Transaction) SetCodeAuthorities() []common.Address

SetCodeAuthorities returns a list of unique authorities from the authorization list.

func (*Transaction) SetCodeAuthorizations 

func (tx *Transaction) SetCodeAuthorizations() []SetCodeAuthorization

SetCodeAuthorizations returns the authorizations list of the transaction.

func (*Transaction) SetTime 

func (tx *Transaction) SetTime(t time.Time)

SetTime sets the decoding time of a transaction. This is used by tests to set arbitrary times and by persistent transaction pools when loading old txs from disk.

func (*Transaction) Size 

func (tx *Transaction) Size() uint64

Size returns the true encoded storage size of the transaction, either by encoding and returning it, or returning a previously cached value.

func (*Transaction) Time 

func (tx *Transaction) Time() time.Time

Time returns the time when the transaction was first seen on the network. It is a heuristic to prefer mining older txs vs new all other things equal.

func (*Transaction) To 

func (tx *Transaction) To() *common.Address

To returns the recipient address of the transaction. For contract-creation transactions, To returns nil.

func (*Transaction) Type 

func (tx *Transaction) Type() uint8

Type returns the transaction type.

func (*Transaction) UnmarshalBinary 

func (tx *Transaction) UnmarshalBinary(b []byte) error

UnmarshalBinary decodes the canonical encoding of transactions. It supports legacy RLP transactions and EIP-2718 typed transactions.

func (*Transaction) UnmarshalJSON 

func (tx *Transaction) UnmarshalJSON(input []byte) error

UnmarshalJSON unmarshals from JSON.

func (*Transaction) Value 

func (tx *Transaction) Value() *big.Int

Value returns the ether amount of the transaction.

func (*Transaction) WithBlobTxSidecar 

func (tx *Transaction) WithBlobTxSidecar(sideCar *BlobTxSidecar) *Transaction

WithBlobTxSidecar returns a copy of tx with the blob sidecar added.

func (*Transaction) WithSignature 

func (tx *Transaction) WithSignature(signer Signer, sig []byte) (*Transaction, error)

WithSignature returns a new transaction with the given signature. This signature needs to be in the [R || S || V] format where V is 0 or 1.

func (*Transaction) WithoutBlobTxSidecar 

func (tx *Transaction) WithoutBlobTxSidecar() *Transaction

WithoutBlobTxSidecar returns a copy of tx with the blob sidecar removed.

type Transactions 

type Transactions []*Transaction

Transactions implements DerivableList for transactions.

func TxDifference 

func TxDifference(a, b Transactions) Transactions

TxDifference returns a new set of transactions that are present in a but not in b.

func (Transactions) EncodeIndex 

func (s Transactions) EncodeIndex(i int, w *bytes.Buffer)

EncodeIndex encodes the i'th transaction to w. Note that this does not check for errors because we assume that *Transaction will only ever contain valid txs that were either constructed by decoding or via public API in this package.

func (Transactions) Len 

func (s Transactions) Len() int

Len returns the length of s.

type TrieRootHash added in v0.15.4 

type TrieRootHash = common.Hash

TrieRootHash represents the hash of a trie root

type TxByNonce 

type TxByNonce Transactions

TxByNonce implements the sort interface to allow sorting a list of transactions by their nonces. This is usually only useful for sorting transactions from a single account, otherwise a nonce comparison doesn't make much sense.

func (TxByNonce) Len 

func (s TxByNonce) Len() int

func (TxByNonce) Less 

func (s TxByNonce) Less(i, j int) bool

func (TxByNonce) Swap 

func (s TxByNonce) Swap(i, j int)

type TxData 

type TxData interface {
	// contains filtered or unexported methods
}

TxData is the underlying data of a transaction.

This is implemented by DynamicFeeTx, LegacyTx and AccessListTx.

type Withdrawal 

type Withdrawal struct {
	Index     uint64         `json:"index"`          // monotonically increasing identifier issued by consensus layer
	Validator uint64         `json:"validatorIndex"` // index of validator associated with withdrawal
	Address   common.Address `json:"address"`        // target address for withdrawn ether
	Amount    uint64         `json:"amount"`         // value of withdrawal in Gwei
}

Withdrawal represents a validator withdrawal from the consensus layer.

func (*Withdrawal) EncodeRLP 

func (obj *Withdrawal) EncodeRLP(_w io.Writer) error

func (Withdrawal) MarshalJSON 

func (w Withdrawal) MarshalJSON() ([]byte, error)

MarshalJSON marshals as JSON.

func (*Withdrawal) UnmarshalJSON 

func (w *Withdrawal) UnmarshalJSON(input []byte) error

UnmarshalJSON unmarshals from JSON.

type Withdrawals 

type Withdrawals []*Withdrawal

Withdrawals implements DerivableList for withdrawals.

func (Withdrawals) EncodeIndex 

func (s Withdrawals) EncodeIndex(i int, w *bytes.Buffer)

EncodeIndex encodes the i'th withdrawal to w. Note that this does not check for errors because we assume that *Withdrawal will only ever contain valid withdrawals that were either constructed by decoding or via public API in this package.

func (Withdrawals) Len 

func (s Withdrawals) Len() int

Len returns the length of s.

func (Withdrawals) Size 

func (s Withdrawals) Size() int

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.