state

package
v0.4.6-t3 Latest Latest
Warning

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

Go to latest
Published: Jan 5, 2024 License: AGPL-3.0, AGPL-3.0-or-later Imports: 45 Imported by: 15

Documentation

Index

Constants

View Source
const (
	// StreamTypeSequencer represents a Sequencer stream
	StreamTypeSequencer datastreamer.StreamType = 1
	// EntryTypeBookMark represents a bookmark entry
	EntryTypeBookMark datastreamer.EntryType = datastreamer.EtBookmark
	// EntryTypeL2BlockStart represents a L2 block start
	EntryTypeL2BlockStart datastreamer.EntryType = 1
	// EntryTypeL2Tx represents a L2 transaction
	EntryTypeL2Tx datastreamer.EntryType = 2
	// EntryTypeL2BlockEnd represents a L2 block end
	EntryTypeL2BlockEnd datastreamer.EntryType = 3
	// EntryTypeUpdateGER represents a GER update
	EntryTypeUpdateGER datastreamer.EntryType = 4
	// BookMarkTypeL2Block represents a L2 block bookmark
	BookMarkTypeL2Block byte = 0
	// SystemSC is the system smart contract address
	SystemSC = "0x000000000000000000000000000000005ca1ab1e"
)
View Source
const (

	// MaxEffectivePercentage is the maximum value that can be used as effective percentage
	MaxEffectivePercentage = uint8(255)

	// EfficiencyPercentageByteLength is the length of the effective percentage in bytes
	EfficiencyPercentageByteLength uint64 = 1
)

Variables

View Source
var (
	// ErrInvalidBatchHeader indicates the batch header is invalid
	ErrInvalidBatchHeader = errors.New("invalid batch header")
	// ErrUnexpectedBatch indicates that the batch is unexpected
	ErrUnexpectedBatch = errors.New("unexpected batch")
	// ErrStateNotSynchronized indicates the state database may be empty
	ErrStateNotSynchronized = errors.New("state not synchronized")
	// ErrNotFound indicates an object has not been found for the search criteria used
	ErrNotFound = errors.New("object not found")
	// ErrNilDBTransaction indicates the db transaction has not been properly initialized
	ErrNilDBTransaction = errors.New("database transaction not properly initialized")
	// ErrAlreadyInitializedDBTransaction indicates the db transaction was already initialized
	ErrAlreadyInitializedDBTransaction = errors.New("database transaction already initialized")
	// ErrNotEnoughIntrinsicGas indicates the gas is not enough to cover the intrinsic gas cost
	ErrNotEnoughIntrinsicGas = fmt.Errorf("not enough gas supplied for intrinsic gas costs")
	// ErrParsingExecutorTrace indicates an error occurred while parsing the executor trace
	ErrParsingExecutorTrace = fmt.Errorf("error while parsing executor trace")
	// ErrInvalidBatchNumber indicates the provided batch number is not the latest in db
	ErrInvalidBatchNumber = errors.New("provided batch number is not latest")
	// ErrLastBatchShouldBeClosed indicates that last batch needs to be closed before adding a new one
	ErrLastBatchShouldBeClosed = errors.New("last batch needs to be closed before adding a new one")
	// ErrBatchAlreadyClosed indicates that batch is already closed
	ErrBatchAlreadyClosed = errors.New("batch is already closed")
	// ErrClosingBatchWithoutTxs indicates that the batch attempted to close does not have txs.
	ErrClosingBatchWithoutTxs = errors.New("can not close a batch without transactions")
	// ErrTimestampGE indicates that timestamp needs to be greater or equal
	ErrTimestampGE = errors.New("timestamp needs to be greater or equal")
	// ErrDBTxNil indicates that the method requires a dbTx that is not nil
	ErrDBTxNil = errors.New("the method requires a dbTx that is not nil")
	// ErrExistingTxGreaterThanProcessedTx indicates that we have more txs stored
	// in db than the txs we want to process.
	ErrExistingTxGreaterThanProcessedTx = errors.New("there are more transactions in the database than in the processed transaction set")
	// ErrOutOfOrderProcessedTx indicates the the processed transactions of an
	// ongoing batch are not in the same order as the transactions stored in the
	// database for the same batch.
	ErrOutOfOrderProcessedTx = errors.New("the processed transactions are not in the same order as the stored transactions")
	// ErrInsufficientFundsForTransfer is returned if the transaction sender doesn't
	// have enough funds for transfer(topmost call only).
	ErrInsufficientFundsForTransfer = errors.New("insufficient funds for transfer")
	// ErrExecutorNil indicates that the method requires an executor that is not nil
	ErrExecutorNil = errors.New("the method requires an executor that is not nil")
	// ErrStateTreeNil indicates that the method requires a state tree that is not nil
	ErrStateTreeNil = errors.New("the method requires a state tree that is not nil")
	// ErrUnsupportedDuration is returned if the provided unit for a time
	// interval is not supported by our conversion mechanism.
	ErrUnsupportedDuration = errors.New("unsupported time duration")
	// ErrInvalidData is the error when the raw txs is unexpected
	ErrInvalidData = errors.New("invalid data")
	// ErrBatchResourceBytesUnderflow happens when the batch runs out of Bytes
	ErrBatchResourceBytesUnderflow = NewBatchRemainingResourcesUnderflowError(nil, "Bytes")
	// ErrInvalidBlockRange returned when the selected block range is invalid, generally
	// because the toBlock is bigger than the fromBlock
	ErrInvalidBlockRange = errors.New("invalid block range")
	// ErrMaxLogsCountLimitExceeded returned when the number of logs is bigger than the
	// configured limit
	ErrMaxLogsCountLimitExceeded = errors.New("query returned more than %v results")
	// ErrMaxLogsBlockRangeLimitExceeded returned when the range between block number range
	// to filter logs is bigger than the configured limit
	ErrMaxLogsBlockRangeLimitExceeded = errors.New("logs are limited to a %v block range")
	// ErrMaxNativeBlockHashBlockRangeLimitExceeded returned when the range between block number range
	// to filter native block hashes is bigger than the configured limit
	ErrMaxNativeBlockHashBlockRangeLimitExceeded = errors.New("native block hashes are limited to a %v block range")
)
View Source
var (
	// DefaultSenderAddress is the address that jRPC will use
	// to communicate with the state for eth_EstimateGas and eth_Call when
	// the From field is not specified because it is optional
	DefaultSenderAddress = "0x1111111111111111111111111111111111111111"
	// ZeroHash is the hash 0x0000000000000000000000000000000000000000000000000000000000000000
	ZeroHash = common.Hash{}
	// ZeroAddress is the address 0x0000000000000000000000000000000000000000
	ZeroAddress = common.Address{}
)
View Source
var (
	// ErrInvalidSig indicates the signature of the transaction is not valid
	ErrInvalidSig = errors.New("invalid transaction v, r, s values")
)
View Source
var ErrQueueEmpty = fmt.Errorf("queue is empty")

ErrQueueEmpty is returned when a queue operation depends on the queue to not be empty, but it is empty

View Source
var ErrStackEmpty = errors.New("Empty Stack")

ErrStackEmpty returned when Pop is called and the stack is empty

Functions

func AddressPtr

func AddressPtr(i common.Address) *common.Address

AddressPtr returns a pointer to the provided address

func CheckLogOrder added in v0.0.990

func CheckLogOrder(logs []*types.Log) bool

CheckLogOrder checks the order of the logs. The order should be incremental

func CheckSignature

func CheckSignature(tx types.Transaction) error

CheckSignature checks a transaction signature

func CheckSupersetBatchTransactions

func CheckSupersetBatchTransactions(existingTxHashes []common.Hash, processedTxs []*ProcessTransactionResponse) error

CheckSupersetBatchTransactions verifies that processedTransactions is a superset of existingTxs and that the existing txs have the same order, returns a non-nil error if that is not the case.

func DecodeTx

func DecodeTx(encodedTx string) (*types.Transaction, error)

DecodeTx decodes a string rlp tx representation into a types.Transaction instance

func DecodeTxs

func DecodeTxs(txsData []byte, forkID uint64) ([]types.Transaction, []byte, []uint8, error)

DecodeTxs extracts Transactions for its encoded form

func EncodeTransaction

func EncodeTransaction(tx types.Transaction, effectivePercentage uint8, forkID uint64) ([]byte, error)

EncodeTransaction RLP encodes the given transaction

func EncodeTransactionWithoutEffectivePercentage added in v0.0.990

func EncodeTransactionWithoutEffectivePercentage(tx types.Transaction) ([]byte, error)

EncodeTransactionWithoutEffectivePercentage RLP encodes the given transaction without the effective percentage

func EncodeTransactions

func EncodeTransactions(txs []types.Transaction, effectivePercentages []uint8, forkID uint64) ([]byte, error)

EncodeTransactions RLP encodes the given transactions

func EncodeTransactionsWithoutEffectivePercentage added in v0.0.990

func EncodeTransactionsWithoutEffectivePercentage(txs []types.Transaction) ([]byte, error)

EncodeTransactionsWithoutEffectivePercentage RLP encodes the given transactions without the effective percentage

func EncodeUnsignedTransaction

func EncodeUnsignedTransaction(tx types.Transaction, chainID uint64, forcedNonce *uint64, forkID uint64) ([]byte, error)

EncodeUnsignedTransaction RLP encodes the given unsigned transaction

func GenerateDataStreamerFile added in v0.0.990

func GenerateDataStreamerFile(ctx context.Context, streamServer *datastreamer.StreamServer, stateDB DSState, readWIPBatch bool, imStateRoots *map[uint64][]byte) error

GenerateDataStreamerFile generates or resumes a data stream file

func GetSender

func GetSender(tx types.Transaction) (common.Address, error)

GetSender gets the sender from the transaction's signature

func GetSystemSCPosition added in v0.4.3

func GetSystemSCPosition(blockNumber uint64) []byte

GetSystemSCPosition computes the position of the intermediate state root for the system smart contract

func GetZKCounterError

func GetZKCounterError(name string) error

GetZKCounterError returns the error associated with the zkCounter

func HashPtr

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

HashPtr returns a pointer to the provided hash

func HexToAddressPtr

func HexToAddressPtr(hex string) *common.Address

HexToAddressPtr create an address from a hex and returns its pointer

func HexToHashPtr

func HexToHashPtr(hex string) *common.Hash

HexToHashPtr create a hash from a hex and returns its pointer

func InfiniteSafeRun added in v0.4.0

func InfiniteSafeRun(fn func(), errorMessage string, restartInterval time.Duration)

InfiniteSafeRun executes a function and in case it fails, runs the function again infinitely

func IsPreEIP155Tx added in v0.0.990

func IsPreEIP155Tx(tx types.Transaction) bool

IsPreEIP155Tx checks if the tx is a tx that has a chainID as zero and V field is either 27 or 28

func IsStateRootChanged added in v0.0.990

func IsStateRootChanged(err executor.RomError) bool

IsStateRootChanged returns true if the transaction changes the state root

func NewBatchRemainingResourcesUnderflowError added in v0.0.990

func NewBatchRemainingResourcesUnderflowError(err error, resourceName string) error

NewBatchRemainingResourcesUnderflowError creates a new BatchRemainingResourcesUnderflowError

func RlpFieldsToLegacyTx

func RlpFieldsToLegacyTx(fields [][]byte, v, r, s []byte) (tx *types.LegacyTx, err error)

RlpFieldsToLegacyTx parses the rlp fields slice into a type.LegacyTx in this specific order:

required fields: [0] Nonce uint64 [1] GasPrice *big.Int [2] Gas uint64 [3] To *common.Address [4] Value *big.Int [5] Data []byte

optional fields: [6] V *big.Int [7] R *big.Int [8] S *big.Int

func SafeRun added in v0.4.0

func SafeRun(fn func(), errorMessage string)

SafeRun executes a function with a deferred recover to avoid to panic.

Types

type Batch

type Batch struct {
	BatchNumber    uint64
	Coinbase       common.Address
	BatchL2Data    []byte
	StateRoot      common.Hash
	LocalExitRoot  common.Hash
	AccInputHash   common.Hash
	Timestamp      time.Time
	Transactions   []types.Transaction
	GlobalExitRoot common.Hash
	ForcedBatchNum *uint64
}

Batch struct

type BatchConfig added in v0.0.990

type BatchConfig struct {
	Constraints BatchConstraintsCfg `mapstructure:"Constraints"`
}

BatchConfig represents the configuration of the batch constraints

type BatchConstraintsCfg added in v0.0.990

type BatchConstraintsCfg struct {
	MaxTxsPerBatch       uint64 `mapstructure:"MaxTxsPerBatch"`
	MaxBatchBytesSize    uint64 `mapstructure:"MaxBatchBytesSize"`
	MaxCumulativeGasUsed uint64 `mapstructure:"MaxCumulativeGasUsed"`
	MaxKeccakHashes      uint32 `mapstructure:"MaxKeccakHashes"`
	MaxPoseidonHashes    uint32 `mapstructure:"MaxPoseidonHashes"`
	MaxPoseidonPaddings  uint32 `mapstructure:"MaxPoseidonPaddings"`
	MaxMemAligns         uint32 `mapstructure:"MaxMemAligns"`
	MaxArithmetics       uint32 `mapstructure:"MaxArithmetics"`
	MaxBinaries          uint32 `mapstructure:"MaxBinaries"`
	MaxSteps             uint32 `mapstructure:"MaxSteps"`
}

BatchConstraintsCfg represents the configuration of the batch constraints

func (BatchConstraintsCfg) IsWithinConstraints added in v0.0.990

func (c BatchConstraintsCfg) IsWithinConstraints(counters ZKCounters) bool

IsWithinConstraints checks if the counters are within the batch constraints

type BatchRemainingResourcesUnderflowError added in v0.0.990

type BatchRemainingResourcesUnderflowError struct {
	Message      string
	Code         int
	Err          error
	ResourceName string
}

BatchRemainingResourcesUnderflowError happens when the execution of a batch runs out of counters

func (BatchRemainingResourcesUnderflowError) Error added in v0.0.990

Error returns the error message

type BatchResources added in v0.0.990

type BatchResources struct {
	ZKCounters ZKCounters
	Bytes      uint64
}

BatchResources is a struct that contains the ZKEVM resources used by a batch/tx

func (*BatchResources) Sub added in v0.0.990

func (r *BatchResources) Sub(other BatchResources) error

Sub subtracts the batch resources from other

type Block

type Block struct {
	BlockNumber uint64
	BlockHash   common.Hash
	ParentHash  common.Hash
	ReceivedAt  time.Time
}

Block struct

func NewBlock

func NewBlock(blockNumber uint64) *Block

NewBlock creates a block with the given data.

type ClosingReason added in v0.0.990

type ClosingReason string

ClosingReason represents the reason why a batch is closed.

const (
	// EmptyClosingReason is the closing reason used when a batch is not closed
	EmptyClosingReason ClosingReason = ""
	// BatchFullClosingReason  is the closing reason used when a batch is closed when it is full
	BatchFullClosingReason ClosingReason = "Batch is full"
	// ForcedBatchClosingReason  is the closing reason used when a batch is closed because it is forced
	ForcedBatchClosingReason ClosingReason = "Forced Batch"
	// BatchAlmostFullClosingReason is the closing reason used when the batch it is almost full
	BatchAlmostFullClosingReason ClosingReason = "Batch is almost full"
	// ForcedBatchDeadlineClosingReason is the closing reason used when forced batch deadline is reached
	ForcedBatchDeadlineClosingReason ClosingReason = "Forced Batch deadline"
	// TimeoutResolutionDeadlineClosingReason is the closing reason used when timeout resolution deadline is reached
	TimeoutResolutionDeadlineClosingReason ClosingReason = "timeout resolution deadline"
	// GlobalExitRootDeadlineClosingReason is the closing reason used when Global Exit Root deadline is reached
	GlobalExitRootDeadlineClosingReason ClosingReason = "Global Exit Root deadline"
)

type Config

type Config struct {
	// MaxCumulativeGasUsed is the max gas allowed per batch
	MaxCumulativeGasUsed uint64

	// ChainID is the L2 ChainID provided by the Network Config
	ChainID uint64

	// ForkIdIntervals is the list of fork id intervals
	ForkIDIntervals []ForkIDInterval

	// MaxResourceExhaustedAttempts is the max number of attempts to make a transaction succeed because of resource exhaustion
	MaxResourceExhaustedAttempts int

	// WaitOnResourceExhaustion is the time to wait before retrying a transaction because of resource exhaustion
	WaitOnResourceExhaustion types.Duration

	// Batch number from which there is a forkid change (fork upgrade)
	ForkUpgradeBatchNumber uint64

	// New fork id to be used for batches greaters than ForkUpgradeBatchNumber (fork upgrade)
	ForkUpgradeNewForkId uint64

	// DB is the database configuration
	DB db.Config `mapstructure:"DB"`

	// Configuration for the batch constraints
	Batch BatchConfig `mapstructure:"Batch"`

	// MaxLogsCount is a configuration to set the max number of logs that can be returned
	// in a single call to the state, if zero it means no limit
	MaxLogsCount uint64

	// MaxLogsBlockRange is a configuration to set the max range for block number when querying TXs
	// logs in a single call to the state, if zero it means no limit
	MaxLogsBlockRange uint64

	// MaxNativeBlockHashBlockRange is a configuration to set the max range for block number when querying
	// native block hashes in a single call to the state, if zero it means no limit
	MaxNativeBlockHashBlockRange uint64
}

Config is state config

type DSBatch added in v0.0.990

type DSBatch struct {
	Batch
	ForkID uint16
}

DSBatch represents a data stream batch

type DSBookMark added in v0.0.990

type DSBookMark struct {
	Type          byte
	L2BlockNumber uint64
}

DSBookMark represents a data stream bookmark

func (DSBookMark) Decode added in v0.0.990

func (b DSBookMark) Decode(data []byte) DSBookMark

Decode decodes the DSBookMark from a byte slice

func (DSBookMark) Encode added in v0.0.990

func (b DSBookMark) Encode() []byte

Encode returns the encoded DSBookMark as a byte slice

type DSFullBatch added in v0.4.0

type DSFullBatch struct {
	DSBatch
	L2Blocks []DSL2FullBlock
}

DSFullBatch represents a data stream batch ant its L2 blocks

type DSL2Block added in v0.0.990

type DSL2Block struct {
	BatchNumber    uint64         // 8 bytes
	L2BlockNumber  uint64         // 8 bytes
	Timestamp      int64          // 8 bytes
	GlobalExitRoot common.Hash    // 32 bytes
	Coinbase       common.Address // 20 bytes
	ForkID         uint16         // 2 bytes
	BlockHash      common.Hash    // 32 bytes
	StateRoot      common.Hash    // 32 bytes
}

DSL2Block is a full l2 block

type DSL2BlockEnd added in v0.0.990

type DSL2BlockEnd struct {
	L2BlockNumber uint64      // 8 bytes
	BlockHash     common.Hash // 32 bytes
	StateRoot     common.Hash // 32 bytes
}

DSL2BlockEnd represents a L2 block end

func (DSL2BlockEnd) Decode added in v0.0.990

func (b DSL2BlockEnd) Decode(data []byte) DSL2BlockEnd

Decode decodes the DSL2BlockEnd from a byte slice

func (DSL2BlockEnd) Encode added in v0.0.990

func (b DSL2BlockEnd) Encode() []byte

Encode returns the encoded DSL2BlockEnd as a byte slice

type DSL2BlockStart added in v0.0.990

type DSL2BlockStart struct {
	BatchNumber    uint64         // 8 bytes
	L2BlockNumber  uint64         // 8 bytes
	Timestamp      int64          // 8 bytes
	GlobalExitRoot common.Hash    // 32 bytes
	Coinbase       common.Address // 20 bytes
	ForkID         uint16         // 2 bytes
}

DSL2BlockStart represents a data stream L2 block start

func (DSL2BlockStart) Decode added in v0.0.990

func (b DSL2BlockStart) Decode(data []byte) DSL2BlockStart

Decode decodes the DSL2BlockStart from a byte slice

func (DSL2BlockStart) Encode added in v0.0.990

func (b DSL2BlockStart) Encode() []byte

Encode returns the encoded DSL2BlockStart as a byte slice

type DSL2FullBlock added in v0.0.990

type DSL2FullBlock struct {
	DSL2Block
	Txs []DSL2Transaction
}

DSL2FullBlock represents a data stream L2 full block and its transactions

type DSL2Transaction added in v0.0.990

type DSL2Transaction struct {
	L2BlockNumber               uint64      // Not included in the encoded data
	EffectiveGasPricePercentage uint8       // 1 byte
	IsValid                     uint8       // 1 byte
	StateRoot                   common.Hash // 32 bytes
	EncodedLength               uint32      // 4 bytes
	Encoded                     []byte
}

DSL2Transaction represents a data stream L2 transaction

func (DSL2Transaction) Decode added in v0.0.990

func (l DSL2Transaction) Decode(data []byte) DSL2Transaction

Decode decodes the DSL2Transaction from a byte slice

func (DSL2Transaction) Encode added in v0.0.990

func (l DSL2Transaction) Encode() []byte

Encode returns the encoded DSL2Transaction as a byte slice

type DSState added in v0.0.990

type DSState interface {
	GetDSGenesisBlock(ctx context.Context, dbTx pgx.Tx) (*DSL2Block, error)
	GetDSBatches(ctx context.Context, firstBatchNumber, lastBatchNumber uint64, readWIPBatch bool, dbTx pgx.Tx) ([]*DSBatch, error)
	GetDSL2Blocks(ctx context.Context, firstBatchNumber, lastBatchNumber uint64, dbTx pgx.Tx) ([]*DSL2Block, error)
	GetDSL2Transactions(ctx context.Context, firstL2Block, lastL2Block uint64, dbTx pgx.Tx) ([]*DSL2Transaction, error)
	GetStorageAt(ctx context.Context, address common.Address, position *big.Int, root common.Hash) (*big.Int, error)
	GetLastL2BlockHeader(ctx context.Context, dbTx pgx.Tx) (*types.Header, error)
}

DSState gathers the methods required to interact with the data stream state.

type DSUpdateGER added in v0.0.990

type DSUpdateGER struct {
	BatchNumber    uint64         // 8 bytes
	Timestamp      int64          // 8 bytes
	GlobalExitRoot common.Hash    // 32 bytes
	Coinbase       common.Address // 20 bytes
	ForkID         uint16         // 2 bytes
	StateRoot      common.Hash    // 32 bytes
}

DSUpdateGER represents a data stream GER update

func (DSUpdateGER) Decode added in v0.0.990

func (g DSUpdateGER) Decode(data []byte) DSUpdateGER

Decode decodes the DSUpdateGER from a byte slice

func (DSUpdateGER) Encode added in v0.0.990

func (g DSUpdateGER) Encode() []byte

Encode returns the encoded DSUpdateGER as a byte slice

type EffectiveGasPriceLog added in v0.4.0

type EffectiveGasPriceLog struct {
	Enabled        bool
	ValueFinal     *big.Int
	ValueFirst     *big.Int
	ValueSecond    *big.Int
	FinalDeviation *big.Int
	MaxDeviation   *big.Int
	GasUsedFirst   uint64
	GasUsedSecond  uint64
	GasPrice       *big.Int
	Percentage     uint8
	Reprocess      bool
	GasPriceOC     bool
	BalanceOC      bool
	L1GasPrice     uint64
	L2GasPrice     uint64
	Error          string
}

EffectiveGasPriceLog contains all the data needed to calculate the effective gas price for logging purposes

type FakeDB

type FakeDB struct {
	State *State
	// contains filtered or unexported fields
}

FakeDB is the implementation of the fakeevm.FakeDB interface

func (*FakeDB) AddAddressToAccessList

func (f *FakeDB) AddAddressToAccessList(addr common.Address)

AddAddressToAccessList not implemented// even if the feature/fork is not active yet

func (*FakeDB) AddBalance

func (f *FakeDB) AddBalance(common.Address, *big.Int)

AddBalance not implemented

func (*FakeDB) AddLog

func (f *FakeDB) AddLog(*types.Log)

AddLog not implemented

func (*FakeDB) AddPreimage

func (f *FakeDB) AddPreimage(common.Hash, []byte)

AddPreimage not implemented

func (*FakeDB) AddRefund

func (f *FakeDB) AddRefund(uint64)

AddRefund not implemented

func (*FakeDB) AddSlotToAccessList

func (f *FakeDB) AddSlotToAccessList(addr common.Address, slot common.Hash)

AddSlotToAccessList not implemented// even if the feature/fork is not active yet

func (*FakeDB) AddressInAccessList

func (f *FakeDB) AddressInAccessList(addr common.Address) bool

AddressInAccessList not implemented

func (*FakeDB) CreateAccount

func (f *FakeDB) CreateAccount(common.Address)

CreateAccount not implemented

func (*FakeDB) Empty

func (f *FakeDB) Empty(address common.Address) bool

Empty returns whether the given account is empty. Empty is defined according to EIP161 (balance = nonce = code = 0).

func (*FakeDB) Exist

func (f *FakeDB) Exist(address common.Address) bool

Exist reports whether the given account exists in state. Notably this should also return true for suicided accounts.

func (*FakeDB) GetBalance

func (f *FakeDB) GetBalance(address common.Address) *big.Int

GetBalance returns the balance of the given address.

func (*FakeDB) GetCode

func (f *FakeDB) GetCode(address common.Address) []byte

GetCode returns the SC code of the given address.

func (*FakeDB) GetCodeHash

func (f *FakeDB) GetCodeHash(address common.Address) common.Hash

GetCodeHash gets the hash for the code at a given address

func (*FakeDB) GetCodeSize

func (f *FakeDB) GetCodeSize(address common.Address) int

GetCodeSize get address code size

func (*FakeDB) GetCommittedState

func (f *FakeDB) GetCommittedState(common.Address, common.Hash) common.Hash

GetCommittedState not implemented

func (*FakeDB) GetNonce

func (f *FakeDB) GetNonce(address common.Address) uint64

GetNonce returns the nonce of the given address.

func (*FakeDB) GetRefund

func (f *FakeDB) GetRefund() uint64

GetRefund not implemented

func (*FakeDB) GetState

func (f *FakeDB) GetState(address common.Address, hash common.Hash) common.Hash

GetState retrieves a value from the given account's storage trie.

func (*FakeDB) GetTransientState

func (f *FakeDB) GetTransientState(addr common.Address, key common.Hash) common.Hash

GetTransientState not implemented

func (*FakeDB) HasSuicided

func (f *FakeDB) HasSuicided(common.Address) bool

HasSuicided not implemented

func (*FakeDB) Prepare

func (f *FakeDB) Prepare(rules params.Rules, sender, coinbase common.Address, dest *common.Address, precompiles []common.Address, txAccesses types.AccessList)

Prepare not implemented

func (*FakeDB) RevertToSnapshot

func (f *FakeDB) RevertToSnapshot(int)

RevertToSnapshot not implemented

func (*FakeDB) SetCode

func (f *FakeDB) SetCode(common.Address, []byte)

SetCode not implemented

func (*FakeDB) SetNonce

func (f *FakeDB) SetNonce(common.Address, uint64)

SetNonce not implemented

func (*FakeDB) SetState

func (f *FakeDB) SetState(common.Address, common.Hash, common.Hash)

SetState not implemented

func (*FakeDB) SetStateRoot

func (f *FakeDB) SetStateRoot(stateRoot []byte)

SetStateRoot is the stateRoot setter.

func (*FakeDB) SetTransientState

func (f *FakeDB) SetTransientState(addr common.Address, key, value common.Hash)

SetTransientState not implemented

func (*FakeDB) SlotInAccessList

func (f *FakeDB) SlotInAccessList(addr common.Address, slot common.Hash) (addressOk bool, slotOk bool)

SlotInAccessList not implemented

func (*FakeDB) Snapshot

func (f *FakeDB) Snapshot() int

Snapshot not implemented

func (*FakeDB) SubBalance

func (f *FakeDB) SubBalance(common.Address, *big.Int)

SubBalance not implemented

func (*FakeDB) SubRefund

func (f *FakeDB) SubRefund(uint64)

SubRefund not implemented

func (*FakeDB) Suicide

func (f *FakeDB) Suicide(common.Address) bool

Suicide not implemented

type ForcedBatch

type ForcedBatch struct {
	BlockNumber       uint64
	ForcedBatchNumber uint64
	Sequencer         common.Address
	GlobalExitRoot    common.Hash
	RawTxsData        []byte
	ForcedAt          time.Time
}

ForcedBatch represents a ForcedBatch

type ForkIDInterval

type ForkIDInterval struct {
	FromBatchNumber uint64
	ToBatchNumber   uint64
	ForkId          uint64
	Version         string
	BlockNumber     uint64
}

ForkIDInterval is a fork id interval

type Genesis

type Genesis struct {
	// GenesisBlockNum is the block number where the polygonZKEVM smc was deployed on L1
	GenesisBlockNum uint64
	// Root hash of the genesis block
	Root common.Hash
	// Contracts to be deployed to L2
	GenesisActions []*GenesisAction
}

Genesis contains the information to populate state on creation

type GenesisAction

type GenesisAction struct {
	Address         string `json:"address"`
	Type            int    `json:"type"`
	StoragePosition string `json:"storagePosition"`
	Bytecode        string `json:"bytecode"`
	Key             string `json:"key"`
	Value           string `json:"value"`
	Root            string `json:"root"`
}

GenesisAction represents one of the values set on the SMT during genesis.

type GlobalExitRoot

type GlobalExitRoot struct {
	BlockNumber     uint64
	Timestamp       time.Time
	MainnetExitRoot common.Hash
	RollupExitRoot  common.Hash
	GlobalExitRoot  common.Hash
}

GlobalExitRoot struct

type InfoReadWrite

type InfoReadWrite struct {
	Address common.Address
	Nonce   *uint64
	Balance *big.Int
}

InfoReadWrite has information about modified addresses during the execution

type NewL2BlockEvent

type NewL2BlockEvent struct {
	Block types.Block
	Logs  []*types.Log
}

NewL2BlockEvent is a struct provided from the state to the NewL2BlockEventHandler when a new l2 block is detected with data related to this new l2 block.

type NewL2BlockEventHandler

type NewL2BlockEventHandler func(e NewL2BlockEvent)

NewL2BlockEventHandler represent a func that will be called by the state when a NewL2BlockEvent is triggered

type PostgresStorage

type PostgresStorage struct {
	*pgxpool.Pool
	// contains filtered or unexported fields
}

PostgresStorage implements the Storage interface

func NewPostgresStorage

func NewPostgresStorage(cfg Config, db *pgxpool.Pool) *PostgresStorage

NewPostgresStorage creates a new StateDB

func (*PostgresStorage) AddAccumulatedInputHash

func (p *PostgresStorage) AddAccumulatedInputHash(ctx context.Context, batchNum uint64, accInputHash common.Hash, dbTx pgx.Tx) error

AddAccumulatedInputHash adds the accumulated input hash

func (*PostgresStorage) AddBlock

func (p *PostgresStorage) AddBlock(ctx context.Context, block *Block, dbTx pgx.Tx) error

AddBlock adds a new block to the State Store

func (*PostgresStorage) AddForcedBatch

func (p *PostgresStorage) AddForcedBatch(ctx context.Context, forcedBatch *ForcedBatch, tx pgx.Tx) error

AddForcedBatch adds a new ForcedBatch to the db

func (*PostgresStorage) AddForkID added in v0.0.990

func (p *PostgresStorage) AddForkID(ctx context.Context, forkID ForkIDInterval, dbTx pgx.Tx) error

AddForkID adds a new forkID to the storage

func (*PostgresStorage) AddGeneratedProof

func (p *PostgresStorage) AddGeneratedProof(ctx context.Context, proof *Proof, dbTx pgx.Tx) error

AddGeneratedProof adds a generated proof to the storage

func (*PostgresStorage) AddGlobalExitRoot

func (p *PostgresStorage) AddGlobalExitRoot(ctx context.Context, exitRoot *GlobalExitRoot, dbTx pgx.Tx) error

AddGlobalExitRoot adds a new ExitRoot to the db

func (*PostgresStorage) AddL2Block

func (p *PostgresStorage) AddL2Block(ctx context.Context, batchNumber uint64, l2Block *types.Block, receipts []*types.Receipt, txsEGPData []StoreTxEGPData, dbTx pgx.Tx) error

AddL2Block adds a new L2 block to the State Store

func (*PostgresStorage) AddLog

func (p *PostgresStorage) AddLog(ctx context.Context, l *types.Log, dbTx pgx.Tx) error

AddLog adds a new log to the State Store

func (*PostgresStorage) AddReceipt

func (p *PostgresStorage) AddReceipt(ctx context.Context, receipt *types.Receipt, dbTx pgx.Tx) error

AddReceipt adds a new receipt to the State Store

func (*PostgresStorage) AddSequence

func (p *PostgresStorage) AddSequence(ctx context.Context, sequence Sequence, dbTx pgx.Tx) error

AddSequence stores the sequence information to allow the aggregator verify sequences.

func (*PostgresStorage) AddTrustedReorg

func (p *PostgresStorage) AddTrustedReorg(ctx context.Context, reorg *TrustedReorg, dbTx pgx.Tx) error

AddTrustedReorg is used to store trusted reorgs

func (*PostgresStorage) AddVerifiedBatch

func (p *PostgresStorage) AddVerifiedBatch(ctx context.Context, verifiedBatch *VerifiedBatch, dbTx pgx.Tx) error

AddVerifiedBatch adds a new VerifiedBatch to the db

func (*PostgresStorage) AddVirtualBatch

func (p *PostgresStorage) AddVirtualBatch(ctx context.Context, virtualBatch *VirtualBatch, dbTx pgx.Tx) error

AddVirtualBatch adds a new virtual batch to the storage.

func (*PostgresStorage) BatchNumberByL2BlockNumber

func (p *PostgresStorage) BatchNumberByL2BlockNumber(ctx context.Context, blockNumber uint64, dbTx pgx.Tx) (uint64, error)

BatchNumberByL2BlockNumber gets a batch number by a l2 block number

func (*PostgresStorage) CheckProofContainsCompleteSequences

func (p *PostgresStorage) CheckProofContainsCompleteSequences(ctx context.Context, proof *Proof, dbTx pgx.Tx) (bool, error)

CheckProofContainsCompleteSequences checks if a recursive proof contains complete sequences

func (*PostgresStorage) CleanupGeneratedProofs

func (p *PostgresStorage) CleanupGeneratedProofs(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) error

CleanupGeneratedProofs deletes from the storage the generated proofs up to the specified batch number included.

func (*PostgresStorage) CleanupLockedProofs

func (p *PostgresStorage) CleanupLockedProofs(ctx context.Context, duration string, dbTx pgx.Tx) (int64, error)

CleanupLockedProofs deletes from the storage the proofs locked in generating state for more than the provided threshold.

func (*PostgresStorage) CountReorgs

func (p *PostgresStorage) CountReorgs(ctx context.Context, dbTx pgx.Tx) (uint64, error)

CountReorgs returns the number of reorgs

func (*PostgresStorage) DeleteGeneratedProofs

func (p *PostgresStorage) DeleteGeneratedProofs(ctx context.Context, batchNumber uint64, batchNumberFinal uint64, dbTx pgx.Tx) error

DeleteGeneratedProofs deletes from the storage the generated proofs falling inside the batch numbers range.

func (*PostgresStorage) DeleteUngeneratedProofs

func (p *PostgresStorage) DeleteUngeneratedProofs(ctx context.Context, dbTx pgx.Tx) error

DeleteUngeneratedProofs deletes ungenerated proofs. This method is meant to be use during aggregator boot-up sequence

func (*PostgresStorage) GetBatchByForcedBatchNum

func (p *PostgresStorage) GetBatchByForcedBatchNum(ctx context.Context, forcedBatchNumber uint64, dbTx pgx.Tx) (*Batch, error)

GetBatchByForcedBatchNum returns the batch with the given forced batch number.

func (*PostgresStorage) GetBatchByL2BlockNumber

func (p *PostgresStorage) GetBatchByL2BlockNumber(ctx context.Context, l2BlockNumber uint64, dbTx pgx.Tx) (*Batch, error)

GetBatchByL2BlockNumber returns the batch related to the l2 block accordingly to the provided l2 block number.

func (*PostgresStorage) GetBatchByNumber

func (p *PostgresStorage) GetBatchByNumber(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) (*Batch, error)

GetBatchByNumber returns the batch with the given number.

func (*PostgresStorage) GetBatchByTxHash

func (p *PostgresStorage) GetBatchByTxHash(ctx context.Context, transactionHash common.Hash, dbTx pgx.Tx) (*Batch, error)

GetBatchByTxHash returns the batch including the given tx

func (*PostgresStorage) GetBatchNumberOfL2Block

func (p *PostgresStorage) GetBatchNumberOfL2Block(ctx context.Context, blockNumber uint64, dbTx pgx.Tx) (uint64, error)

GetBatchNumberOfL2Block gets a batch number for l2 block by its number

func (*PostgresStorage) GetBlockNumAndMainnetExitRootByGER

func (p *PostgresStorage) GetBlockNumAndMainnetExitRootByGER(ctx context.Context, ger common.Hash, dbTx pgx.Tx) (uint64, common.Hash, error)

GetBlockNumAndMainnetExitRootByGER gets block number and mainnet exit root by the global exit root

func (*PostgresStorage) GetBlockNumVirtualBatchByBatchNum

func (p *PostgresStorage) GetBlockNumVirtualBatchByBatchNum(ctx context.Context, batchNum uint64, dbTx pgx.Tx) (uint64, error)

GetBlockNumVirtualBatchByBatchNum get block num of virtual batch by block num

func (*PostgresStorage) GetDSBatches added in v0.4.0

func (p *PostgresStorage) GetDSBatches(ctx context.Context, firstBatchNumber, lastBatchNumber uint64, readWIPBatch bool, dbTx pgx.Tx) ([]*DSBatch, error)

GetDSBatches returns the DS batches

func (*PostgresStorage) GetDSGenesisBlock added in v0.0.990

func (p *PostgresStorage) GetDSGenesisBlock(ctx context.Context, dbTx pgx.Tx) (*DSL2Block, error)

GetDSGenesisBlock returns the genesis block

func (*PostgresStorage) GetDSL2Blocks added in v0.0.990

func (p *PostgresStorage) GetDSL2Blocks(ctx context.Context, firstBatchNumber, lastBatchNumber uint64, dbTx pgx.Tx) ([]*DSL2Block, error)

GetDSL2Blocks returns the L2 blocks

func (*PostgresStorage) GetDSL2Transactions added in v0.0.990

func (p *PostgresStorage) GetDSL2Transactions(ctx context.Context, firstL2Block, lastL2Block uint64, dbTx pgx.Tx) ([]*DSL2Transaction, error)

GetDSL2Transactions returns the L2 transactions

func (*PostgresStorage) GetEncodedTransactionsByBatchNumber

func (p *PostgresStorage) GetEncodedTransactionsByBatchNumber(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) (encodedTxs []string, effectivePercentages []uint8, err error)

GetEncodedTransactionsByBatchNumber returns the encoded field of all transactions in the given batch.

func (*PostgresStorage) GetExitRootByGlobalExitRoot

func (p *PostgresStorage) GetExitRootByGlobalExitRoot(ctx context.Context, ger common.Hash, dbTx pgx.Tx) (*GlobalExitRoot, error)

GetExitRootByGlobalExitRoot returns the mainnet and rollup exit root given a global exit root number.

func (*PostgresStorage) GetForcedBatch

func (p *PostgresStorage) GetForcedBatch(ctx context.Context, forcedBatchNumber uint64, dbTx pgx.Tx) (*ForcedBatch, error)

GetForcedBatch get an L1 forcedBatch.

func (*PostgresStorage) GetForcedBatchesSince

func (p *PostgresStorage) GetForcedBatchesSince(ctx context.Context, forcedBatchNumber, maxBlockNumber uint64, dbTx pgx.Tx) ([]*ForcedBatch, error)

GetForcedBatchesSince gets L1 forced batches since forcedBatchNumber

func (*PostgresStorage) GetForkIDs added in v0.0.990

func (p *PostgresStorage) GetForkIDs(ctx context.Context, dbTx pgx.Tx) ([]ForkIDInterval, error)

GetForkIDs get all the forkIDs stored

func (*PostgresStorage) GetL2BlockByHash

func (p *PostgresStorage) GetL2BlockByHash(ctx context.Context, hash common.Hash, dbTx pgx.Tx) (*types.Block, error)

GetL2BlockByHash gets a l2 block from its hash

func (*PostgresStorage) GetL2BlockByNumber

func (p *PostgresStorage) GetL2BlockByNumber(ctx context.Context, blockNumber uint64, dbTx pgx.Tx) (*types.Block, error)

GetL2BlockByNumber gets a l2 block by its number

func (*PostgresStorage) GetL2BlockHashesSince

func (p *PostgresStorage) GetL2BlockHashesSince(ctx context.Context, since time.Time, dbTx pgx.Tx) ([]common.Hash, error)

GetL2BlockHashesSince gets the block hashes added since the provided date

func (*PostgresStorage) GetL2BlockHeaderByHash

func (p *PostgresStorage) GetL2BlockHeaderByHash(ctx context.Context, hash common.Hash, dbTx pgx.Tx) (*types.Header, error)

GetL2BlockHeaderByHash gets the block header by block number

func (*PostgresStorage) GetL2BlockHeaderByNumber

func (p *PostgresStorage) GetL2BlockHeaderByNumber(ctx context.Context, blockNumber uint64, dbTx pgx.Tx) (*types.Header, error)

GetL2BlockHeaderByNumber gets the block header by block number

func (*PostgresStorage) GetL2BlockTransactionCountByHash

func (p *PostgresStorage) GetL2BlockTransactionCountByHash(ctx context.Context, blockHash common.Hash, dbTx pgx.Tx) (uint64, error)

GetL2BlockTransactionCountByHash returns the number of transactions related to the provided block hash

func (*PostgresStorage) GetL2BlockTransactionCountByNumber

func (p *PostgresStorage) GetL2BlockTransactionCountByNumber(ctx context.Context, blockNumber uint64, dbTx pgx.Tx) (uint64, error)

GetL2BlockTransactionCountByNumber returns the number of transactions related to the provided block number

func (*PostgresStorage) GetL2BlocksByBatchNumber added in v0.0.990

func (p *PostgresStorage) GetL2BlocksByBatchNumber(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) ([]types.Block, error)

GetL2BlocksByBatchNumber get all blocks associated to a batch accordingly to the provided batch number

func (*PostgresStorage) GetLastBatchNumber

func (p *PostgresStorage) GetLastBatchNumber(ctx context.Context, dbTx pgx.Tx) (uint64, error)

GetLastBatchNumber get last trusted batch number

func (*PostgresStorage) GetLastBatchTime

func (p *PostgresStorage) GetLastBatchTime(ctx context.Context, dbTx pgx.Tx) (time.Time, error)

GetLastBatchTime gets last trusted batch time

func (*PostgresStorage) GetLastBlock

func (p *PostgresStorage) GetLastBlock(ctx context.Context, dbTx pgx.Tx) (*Block, error)

GetLastBlock returns the last L1 block.

func (*PostgresStorage) GetLastClosedBatch

func (p *PostgresStorage) GetLastClosedBatch(ctx context.Context, dbTx pgx.Tx) (*Batch, error)

GetLastClosedBatch returns the latest closed batch

func (*PostgresStorage) GetLastClosedBatchNumber added in v0.4.0

func (p *PostgresStorage) GetLastClosedBatchNumber(ctx context.Context, dbTx pgx.Tx) (uint64, error)

GetLastClosedBatchNumber returns the latest closed batch

func (*PostgresStorage) GetLastConsolidatedL2BlockNumber

func (p *PostgresStorage) GetLastConsolidatedL2BlockNumber(ctx context.Context, dbTx pgx.Tx) (uint64, error)

GetLastConsolidatedL2BlockNumber gets the last l2 block verified

func (*PostgresStorage) GetLastL2Block

func (p *PostgresStorage) GetLastL2Block(ctx context.Context, dbTx pgx.Tx) (*types.Block, error)

GetLastL2Block retrieves the latest L2 Block from the State data base

func (*PostgresStorage) GetLastL2BlockCreatedAt

func (p *PostgresStorage) GetLastL2BlockCreatedAt(ctx context.Context, dbTx pgx.Tx) (*time.Time, error)

GetLastL2BlockCreatedAt gets the timestamp of the last l2 block

func (*PostgresStorage) GetLastL2BlockHeader

func (p *PostgresStorage) GetLastL2BlockHeader(ctx context.Context, dbTx pgx.Tx) (*types.Header, error)

GetLastL2BlockHeader gets the last l2 block number

func (*PostgresStorage) GetLastL2BlockNumber

func (p *PostgresStorage) GetLastL2BlockNumber(ctx context.Context, dbTx pgx.Tx) (uint64, error)

GetLastL2BlockNumber gets the last l2 block number

func (*PostgresStorage) GetLastNBatches

func (p *PostgresStorage) GetLastNBatches(ctx context.Context, numBatches uint, dbTx pgx.Tx) ([]*Batch, error)

GetLastNBatches returns the last numBatches batches.

func (*PostgresStorage) GetLastNBatchesByL2BlockNumber

func (p *PostgresStorage) GetLastNBatchesByL2BlockNumber(ctx context.Context, l2BlockNumber *uint64, numBatches uint, dbTx pgx.Tx) ([]*Batch, common.Hash, error)

GetLastNBatchesByL2BlockNumber returns the last numBatches batches along with the l2 block state root by l2BlockNumber if the l2BlockNumber parameter is nil, it means we want to get the most recent last N batches

func (*PostgresStorage) GetLastTrustedForcedBatchNumber

func (p *PostgresStorage) GetLastTrustedForcedBatchNumber(ctx context.Context, dbTx pgx.Tx) (uint64, error)

GetLastTrustedForcedBatchNumber get last trusted forced batch number

func (*PostgresStorage) GetLastVerifiedBatch

func (p *PostgresStorage) GetLastVerifiedBatch(ctx context.Context, dbTx pgx.Tx) (*VerifiedBatch, error)

GetLastVerifiedBatch gets last verified batch

func (*PostgresStorage) GetLastVerifiedBatchNumberUntilL1Block added in v0.4.0

func (p *PostgresStorage) GetLastVerifiedBatchNumberUntilL1Block(ctx context.Context, l1BlockNumber uint64, dbTx pgx.Tx) (uint64, error)

GetLastVerifiedBatchNumberUntilL1Block gets the last batch number that was verified in or before the provided l1 block number. This is used to identify if a batch is safe or finalized.

func (*PostgresStorage) GetLastVerifiedL2BlockNumberUntilL1Block added in v0.4.0

func (p *PostgresStorage) GetLastVerifiedL2BlockNumberUntilL1Block(ctx context.Context, l1FinalizedBlockNumber uint64, dbTx pgx.Tx) (uint64, error)

GetLastVerifiedL2BlockNumberUntilL1Block gets the last block number that was verified in or before the provided l1 block number. This is used to identify if a l2 block is safe or finalized.

func (*PostgresStorage) GetLastVirtualBatchNum

func (p *PostgresStorage) GetLastVirtualBatchNum(ctx context.Context, dbTx pgx.Tx) (uint64, error)

GetLastVirtualBatchNum gets last virtual batch num

func (*PostgresStorage) GetLastVirtualizedL2BlockNumber added in v0.0.990

func (p *PostgresStorage) GetLastVirtualizedL2BlockNumber(ctx context.Context, dbTx pgx.Tx) (uint64, error)

GetLastVirtualizedL2BlockNumber gets the last l2 block virtualized

func (*PostgresStorage) GetLatestGer

func (p *PostgresStorage) GetLatestGer(ctx context.Context, maxBlockNumber uint64) (GlobalExitRoot, time.Time, error)

GetLatestGer is used to get the latest ger

func (*PostgresStorage) GetLatestGlobalExitRoot

func (p *PostgresStorage) GetLatestGlobalExitRoot(ctx context.Context, maxBlockNumber uint64, dbTx pgx.Tx) (GlobalExitRoot, time.Time, error)

GetLatestGlobalExitRoot get the latest global ExitRoot synced.

func (*PostgresStorage) GetLatestVirtualBatchTimestamp

func (p *PostgresStorage) GetLatestVirtualBatchTimestamp(ctx context.Context, dbTx pgx.Tx) (time.Time, error)

GetLatestVirtualBatchTimestamp gets last virtual batch timestamp

func (*PostgresStorage) GetLocalExitRootByBatchNumber

func (p *PostgresStorage) GetLocalExitRootByBatchNumber(ctx context.Context, batchNum uint64, dbTx pgx.Tx) (common.Hash, error)

GetLocalExitRootByBatchNumber get local exit root by batch number

func (*PostgresStorage) GetLogs

func (p *PostgresStorage) GetLogs(ctx context.Context, fromBlock uint64, toBlock uint64, addresses []common.Address, topics [][]common.Hash, blockHash *common.Hash, since *time.Time, dbTx pgx.Tx) ([]*types.Log, error)

GetLogs returns the logs that match the filter

func (*PostgresStorage) GetLogsByBlockNumber added in v0.4.0

func (p *PostgresStorage) GetLogsByBlockNumber(ctx context.Context, blockNumber uint64, dbTx pgx.Tx) ([]*types.Log, error)

GetLogsByBlockNumber get all the logs from a specific block ordered by log index

func (*PostgresStorage) GetNativeBlockHashesInRange added in v0.0.990

func (p *PostgresStorage) GetNativeBlockHashesInRange(ctx context.Context, fromBlock, toBlock uint64, dbTx pgx.Tx) ([]common.Hash, error)

GetNativeBlockHashesInRange return the state root for the blocks in range

func (*PostgresStorage) GetNextForcedBatches

func (p *PostgresStorage) GetNextForcedBatches(ctx context.Context, nextForcedBatches int, dbTx pgx.Tx) ([]ForcedBatch, error)

GetNextForcedBatches gets the next forced batches from the queue.

func (*PostgresStorage) GetNumberOfBlocksSinceLastGERUpdate

func (p *PostgresStorage) GetNumberOfBlocksSinceLastGERUpdate(ctx context.Context, dbTx pgx.Tx) (uint64, error)

GetNumberOfBlocksSinceLastGERUpdate gets number of blocks since last global exit root update

func (*PostgresStorage) GetPreviousBlock

func (p *PostgresStorage) GetPreviousBlock(ctx context.Context, offset uint64, dbTx pgx.Tx) (*Block, error)

GetPreviousBlock gets the offset previous L1 block respect to latest.

func (*PostgresStorage) GetProcessingContext

func (p *PostgresStorage) GetProcessingContext(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) (*ProcessingContext, error)

GetProcessingContext returns the processing context for the given batch.

func (*PostgresStorage) GetProofReadyToVerify

func (p *PostgresStorage) GetProofReadyToVerify(ctx context.Context, lastVerfiedBatchNumber uint64, dbTx pgx.Tx) (*Proof, error)

GetProofReadyToVerify return the proof that is ready to verify

func (*PostgresStorage) GetProofsToAggregate

func (p *PostgresStorage) GetProofsToAggregate(ctx context.Context, dbTx pgx.Tx) (*Proof, *Proof, error)

GetProofsToAggregate return the next to proof that it is possible to aggregate

func (*PostgresStorage) GetReorgedTransactions

func (p *PostgresStorage) GetReorgedTransactions(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) ([]*types.Transaction, error)

GetReorgedTransactions returns the transactions that were reorged

func (*PostgresStorage) GetSequences

func (p *PostgresStorage) GetSequences(ctx context.Context, lastVerifiedBatchNumber uint64, dbTx pgx.Tx) ([]Sequence, error)

GetSequences get the next sequences higher than an specify batch number

func (*PostgresStorage) GetStateRootByBatchNumber

func (p *PostgresStorage) GetStateRootByBatchNumber(ctx context.Context, batchNum uint64, dbTx pgx.Tx) (common.Hash, error)

GetStateRootByBatchNumber get state root by batch number

func (*PostgresStorage) GetSyncingInfo

func (p *PostgresStorage) GetSyncingInfo(ctx context.Context, dbTx pgx.Tx) (SyncingInfo, error)

GetSyncingInfo returns information regarding the syncing status of the node

func (*PostgresStorage) GetTimeForLatestBatchVirtualization

func (p *PostgresStorage) GetTimeForLatestBatchVirtualization(ctx context.Context, dbTx pgx.Tx) (time.Time, error)

GetTimeForLatestBatchVirtualization returns the timestamp of the latest virtual batch.

func (*PostgresStorage) GetTransactionByHash

func (p *PostgresStorage) GetTransactionByHash(ctx context.Context, transactionHash common.Hash, dbTx pgx.Tx) (*types.Transaction, error)

GetTransactionByHash gets a transaction accordingly to the provided transaction hash

func (*PostgresStorage) GetTransactionByL2BlockHashAndIndex

func (p *PostgresStorage) GetTransactionByL2BlockHashAndIndex(ctx context.Context, blockHash common.Hash, index uint64, dbTx pgx.Tx) (*types.Transaction, error)

GetTransactionByL2BlockHashAndIndex gets a transaction accordingly to the block hash and transaction index provided. since we only have a single transaction per l2 block, any index different from 0 will return a not found result

func (*PostgresStorage) GetTransactionByL2BlockNumberAndIndex

func (p *PostgresStorage) GetTransactionByL2BlockNumberAndIndex(ctx context.Context, blockNumber uint64, index uint64, dbTx pgx.Tx) (*types.Transaction, error)

GetTransactionByL2BlockNumberAndIndex gets a transaction accordingly to the block number and transaction index provided. since we only have a single transaction per l2 block, any index different from 0 will return a not found result

func (*PostgresStorage) GetTransactionEGPLogByHash added in v0.4.0

func (p *PostgresStorage) GetTransactionEGPLogByHash(ctx context.Context, transactionHash common.Hash, dbTx pgx.Tx) (*EffectiveGasPriceLog, error)

GetTransactionEGPLogByHash gets the EGP log accordingly to the provided transaction hash

func (*PostgresStorage) GetTransactionReceipt

func (p *PostgresStorage) GetTransactionReceipt(ctx context.Context, transactionHash common.Hash, dbTx pgx.Tx) (*types.Receipt, error)

GetTransactionReceipt gets a transaction receipt accordingly to the provided transaction hash

func (*PostgresStorage) GetTransactionsByBatchNumber

func (p *PostgresStorage) GetTransactionsByBatchNumber(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) (txs []types.Transaction, effectivePercentages []uint8, err error)

GetTransactionsByBatchNumber returns the transactions in the given batch.

func (*PostgresStorage) GetTxsByBatchNumber

func (p *PostgresStorage) GetTxsByBatchNumber(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) ([]*types.Transaction, error)

GetTxsByBatchNumber returns all the txs in a given batch

func (*PostgresStorage) GetTxsByBlockNumber

func (p *PostgresStorage) GetTxsByBlockNumber(ctx context.Context, blockNumber uint64, dbTx pgx.Tx) ([]*types.Transaction, error)

GetTxsByBlockNumber returns all the txs in a given block

func (*PostgresStorage) GetTxsHashesByBatchNumber

func (p *PostgresStorage) GetTxsHashesByBatchNumber(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) (encoded []common.Hash, err error)

GetTxsHashesByBatchNumber returns the hashes of the transactions in the given batch.

func (*PostgresStorage) GetTxsOlderThanNL1Blocks

func (p *PostgresStorage) GetTxsOlderThanNL1Blocks(ctx context.Context, nL1Blocks uint64, dbTx pgx.Tx) ([]common.Hash, error)

GetTxsOlderThanNL1Blocks get txs hashes to delete from tx pool

func (*PostgresStorage) GetVerifiedBatch

func (p *PostgresStorage) GetVerifiedBatch(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) (*VerifiedBatch, error)

GetVerifiedBatch get an L1 verifiedBatch.

func (*PostgresStorage) GetVirtualBatch

func (p *PostgresStorage) GetVirtualBatch(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) (*VirtualBatch, error)

GetVirtualBatch get an L1 virtualBatch.

func (*PostgresStorage) GetVirtualBatchByNumber

func (p *PostgresStorage) GetVirtualBatchByNumber(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) (*Batch, error)

GetVirtualBatchByNumber gets batch from batch table that exists on virtual batch

func (*PostgresStorage) GetVirtualBatchToProve

func (p *PostgresStorage) GetVirtualBatchToProve(ctx context.Context, lastVerfiedBatchNumber uint64, dbTx pgx.Tx) (*Batch, error)

GetVirtualBatchToProve return the next batch that is not proved, neither in proved process.

func (*PostgresStorage) IsBatchClosed

func (p *PostgresStorage) IsBatchClosed(ctx context.Context, batchNum uint64, dbTx pgx.Tx) (bool, error)

IsBatchClosed indicates if the batch referenced by batchNum is closed or not

func (*PostgresStorage) IsBatchConsolidated

func (p *PostgresStorage) IsBatchConsolidated(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) (bool, error)

IsBatchConsolidated checks if batch is consolidated/verified.

func (*PostgresStorage) IsBatchVirtualized

func (p *PostgresStorage) IsBatchVirtualized(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) (bool, error)

IsBatchVirtualized checks if batch is virtualized

func (*PostgresStorage) IsL2BlockConsolidated

func (p *PostgresStorage) IsL2BlockConsolidated(ctx context.Context, blockNumber uint64, dbTx pgx.Tx) (bool, error)

IsL2BlockConsolidated checks if the block ID is consolidated

func (*PostgresStorage) IsL2BlockVirtualized

func (p *PostgresStorage) IsL2BlockVirtualized(ctx context.Context, blockNumber uint64, dbTx pgx.Tx) (bool, error)

IsL2BlockVirtualized checks if the block ID is virtualized

func (*PostgresStorage) IsSequencingTXSynced

func (p *PostgresStorage) IsSequencingTXSynced(ctx context.Context, transactionHash common.Hash, dbTx pgx.Tx) (bool, error)

IsSequencingTXSynced checks if sequencing tx has been synced into the state

func (*PostgresStorage) Reset

func (p *PostgresStorage) Reset(ctx context.Context, blockNumber uint64, dbTx pgx.Tx) error

Reset resets the state to a block for the given DB tx

func (*PostgresStorage) ResetForkID

func (p *PostgresStorage) ResetForkID(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) error

ResetForkID resets the state to reprocess the newer batches with the correct forkID

func (*PostgresStorage) ResetTrustedState

func (p *PostgresStorage) ResetTrustedState(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) error

ResetTrustedState removes the batches with number greater than the given one from the database.

func (*PostgresStorage) SetInitSyncBatch added in v0.0.990

func (p *PostgresStorage) SetInitSyncBatch(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) error

SetInitSyncBatch sets the initial batch number where the synchronization started

func (*PostgresStorage) SetLastBatchInfoSeenOnEthereum added in v0.0.990

func (p *PostgresStorage) SetLastBatchInfoSeenOnEthereum(ctx context.Context, lastBatchNumberSeen, lastBatchNumberVerified uint64, dbTx pgx.Tx) error

SetLastBatchInfoSeenOnEthereum sets the last batch number that affected the roll-up and the last batch number that was consolidated on ethereum in order to allow the components to know if the state is synchronized or not

func (*PostgresStorage) UpdateBatchL2Data

func (p *PostgresStorage) UpdateBatchL2Data(ctx context.Context, batchNumber uint64, batchL2Data []byte, dbTx pgx.Tx) error

UpdateBatchL2Data updates data tx data in a batch

func (*PostgresStorage) UpdateBatchL2DataAndLER added in v0.4.3

func (p *PostgresStorage) UpdateBatchL2DataAndLER(ctx context.Context, batchNumber uint64, batchL2Data []byte, localExitRoot common.Hash, dbTx pgx.Tx) error

UpdateBatchL2DataAndLER updates data tx data in a batch and the local exit root

func (*PostgresStorage) UpdateForkID added in v0.0.990

func (p *PostgresStorage) UpdateForkID(ctx context.Context, forkID ForkIDInterval, dbTx pgx.Tx) error

UpdateForkID updates the forkID stored in db

func (*PostgresStorage) UpdateGERInOpenBatch

func (p *PostgresStorage) UpdateGERInOpenBatch(ctx context.Context, ger common.Hash, dbTx pgx.Tx) error

UpdateGERInOpenBatch update ger in open batch

func (*PostgresStorage) UpdateGeneratedProof

func (p *PostgresStorage) UpdateGeneratedProof(ctx context.Context, proof *Proof, dbTx pgx.Tx) error

UpdateGeneratedProof updates a generated proof in the storage

type ProcessBatchResponse

type ProcessBatchResponse struct {
	NewStateRoot         common.Hash
	NewAccInputHash      common.Hash
	NewLocalExitRoot     common.Hash
	NewBatchNumber       uint64
	UsedZkCounters       ZKCounters
	Responses            []*ProcessTransactionResponse
	ExecutorError        error
	ReadWriteAddresses   map[common.Address]*InfoReadWrite
	IsRomLevelError      bool
	IsExecutorLevelError bool
	IsRomOOCError        bool
	FlushID              uint64
	StoredFlushID        uint64
	ProverID             string
}

ProcessBatchResponse represents the response of a batch process.

type ProcessRequest

type ProcessRequest struct {
	BatchNumber     uint64
	GlobalExitRoot  common.Hash
	OldStateRoot    common.Hash
	OldAccInputHash common.Hash
	Transactions    []byte
	Coinbase        common.Address
	Timestamp       time.Time
	Caller          metrics.CallerLabel
}

ProcessRequest represents the request of a batch process.

type ProcessTransactionResponse

type ProcessTransactionResponse struct {
	// TxHash is the hash of the transaction
	TxHash common.Hash
	// Type indicates legacy transaction
	// It will be always 0 (legacy) in the executor
	Type uint32
	// ReturnValue is the returned data from the runtime (function result or data supplied with revert opcode)
	ReturnValue []byte
	// GasLeft is the total gas left as result of execution
	GasLeft uint64
	// GasUsed is the total gas used as result of execution or gas estimation
	GasUsed uint64
	// GasRefunded is the total gas refunded as result of execution
	GasRefunded uint64
	// RomError represents any error encountered during the execution
	RomError error
	// CreateAddress is the new SC Address in case of SC creation
	CreateAddress common.Address
	// StateRoot is the State Root
	StateRoot common.Hash
	// Logs emitted by LOG opcode
	Logs []*types.Log
	// ChangesStateRoot indicates if this tx affects the state
	ChangesStateRoot bool
	// Tx is the whole transaction object
	Tx types.Transaction
	// ExecutionTrace contains the traces produced in the execution
	ExecutionTrace []instrumentation.StructLog
	// CallTrace contains the call trace.
	CallTrace instrumentation.ExecutorTrace
	// EffectiveGasPrice effective gas price used for the tx
	EffectiveGasPrice string
	//EffectivePercentage effective percentage used for the tx
	EffectivePercentage uint32
	//HasGaspriceOpcode flag to indicate if opcode 'GASPRICE' has been called
	HasGaspriceOpcode bool
	//HasBalanceOpcode flag to indicate if opcode 'BALANCE' has been called
	HasBalanceOpcode bool
}

ProcessTransactionResponse represents the response of a tx process.

type ProcessingContext

type ProcessingContext struct {
	BatchNumber    uint64
	Coinbase       common.Address
	Timestamp      time.Time
	GlobalExitRoot common.Hash
	ForcedBatchNum *uint64
	BatchL2Data    *[]byte
}

ProcessingContext is the necessary data that a batch needs to provide to the runtime, without the historical state data (processing receipt from previous batch)

type ProcessingReceipt

type ProcessingReceipt struct {
	BatchNumber   uint64
	StateRoot     common.Hash
	LocalExitRoot common.Hash
	AccInputHash  common.Hash
	// Txs           []types.Transaction
	BatchL2Data    []byte
	ClosingReason  ClosingReason
	BatchResources BatchResources
}

ProcessingReceipt indicates the outcome (StateRoot, AccInputHash) of processing a batch

type Proof

type Proof struct {
	BatchNumber      uint64
	BatchNumberFinal uint64
	Proof            string
	InputProver      string
	ProofID          *string
	// Prover name, unique identifier across prover reboots.
	Prover *string
	// ProverID prover process identifier.
	ProverID *string
	// GeneratingSince holds the timestamp for the moment in which the
	// proof generation has started by a prover. Nil if the proof is not
	// currently generating.
	GeneratingSince *time.Time
	CreatedAt       time.Time
	UpdatedAt       time.Time
}

Proof struct

type Queue added in v0.3.4

type Queue[T any] struct {
	// contains filtered or unexported fields
}

Queue is a generic queue implementation that implements FIFO

func NewQueue added in v0.3.4

func NewQueue[T any]() *Queue[T]

NewQueue creates a new instance of queue and initializes it

func (*Queue[T]) IsEmpty added in v0.3.4

func (q *Queue[T]) IsEmpty() bool

IsEmpty returns false if the queue has itens, otherwise true

func (*Queue[T]) Len added in v0.3.4

func (q *Queue[T]) Len() int

Len returns the size of the queue

func (*Queue[T]) Pop added in v0.3.4

func (q *Queue[T]) Pop() (T, error)

Pop returns the top level item and unqueues it

func (*Queue[T]) Push added in v0.3.4

func (q *Queue[T]) Push(item T)

Push enqueue an item

func (*Queue[T]) Top added in v0.3.4

func (q *Queue[T]) Top() (T, error)

Top returns the top level item without removing it

type Sequence

type Sequence struct {
	FromBatchNumber uint64
	ToBatchNumber   uint64
}

Sequence represents the sequence interval

type Stack added in v0.0.990

type Stack[T any] struct {
	// contains filtered or unexported fields
}

Stack is a thread safe stack data structure implementation implementing generics

func NewStack added in v0.0.990

func NewStack[T any]() *Stack[T]

NewStack creates a new stack

func (*Stack[T]) Pop added in v0.0.990

func (s *Stack[T]) Pop() (T, error)

Pop removes and returns the last item added to the stack

func (*Stack[T]) Push added in v0.0.990

func (s *Stack[T]) Push(v T)

Push adds an item to the stack

type State

type State struct {
	*PostgresStorage
	// contains filtered or unexported fields
}

State is an implementation of the state

func NewState

func NewState(cfg Config, storage *PostgresStorage, executorClient executor.ExecutorServiceClient, stateTree *merkletree.StateTree, eventLog *event.EventLog) *State

NewState creates a new State

func (*State) AddForkIDInterval added in v0.0.990

func (s *State) AddForkIDInterval(ctx context.Context, newForkID ForkIDInterval, dbTx pgx.Tx) error

AddForkIDInterval updates the forkID intervals

func (*State) BeginStateTransaction

func (s *State) BeginStateTransaction(ctx context.Context) (pgx.Tx, error)

BeginStateTransaction starts a state transaction

func (*State) CloseBatch

func (s *State) CloseBatch(ctx context.Context, receipt ProcessingReceipt, dbTx pgx.Tx) error

CloseBatch is used by sequencer to close the current batch

func (*State) DebugTransaction

func (s *State) DebugTransaction(ctx context.Context, transactionHash common.Hash, traceConfig TraceConfig, dbTx pgx.Tx) (*runtime.ExecutionResult, error)

DebugTransaction re-executes a tx to generate its trace

func (*State) EstimateGas

func (s *State) EstimateGas(transaction *types.Transaction, senderAddress common.Address, l2BlockNumber *uint64, dbTx pgx.Tx) (uint64, []byte, error)

EstimateGas for a transaction

func (*State) ExecuteBatch

func (s *State) ExecuteBatch(ctx context.Context, batch Batch, updateMerkleTree bool, dbTx pgx.Tx) (*executor.ProcessBatchResponse, error)

ExecuteBatch is used by the synchronizer to reprocess batches to compare generated state root vs stored one It is also used by the sequencer in order to calculate used zkCounter of a WIPBatch

func (*State) FlushMerkleTree

func (s *State) FlushMerkleTree(ctx context.Context) error

FlushMerkleTree persists updates in the Merkle tree

func (*State) GetBalance

func (s *State) GetBalance(ctx context.Context, address common.Address, root common.Hash) (*big.Int, error)

GetBalance from a given address

func (*State) GetBalanceByStateRoot

func (s *State) GetBalanceByStateRoot(ctx context.Context, address common.Address, root common.Hash) (*big.Int, error)

GetBalanceByStateRoot gets balance from the MT Service using the provided state root

func (*State) GetCode

func (s *State) GetCode(ctx context.Context, address common.Address, root common.Hash) ([]byte, error)

GetCode from a given address

func (*State) GetForkIDByBatchNumber added in v0.0.990

func (s *State) GetForkIDByBatchNumber(batchNumber uint64) uint64

GetForkIDByBatchNumber returns the fork id for a given batch number

func (*State) GetLastBatch

func (s *State) GetLastBatch(ctx context.Context, dbTx pgx.Tx) (*Batch, error)

GetLastBatch gets latest batch (closed or not) on the data base

func (*State) GetLastStateRoot

func (s *State) GetLastStateRoot(ctx context.Context, dbTx pgx.Tx) (common.Hash, error)

GetLastStateRoot returns the latest state root

func (*State) GetNonce

func (s *State) GetNonce(ctx context.Context, address common.Address, root common.Hash) (uint64, error)

GetNonce returns the nonce of the given account at the given block number

func (*State) GetNonceByStateRoot

func (s *State) GetNonceByStateRoot(ctx context.Context, address common.Address, root common.Hash) (*big.Int, error)

GetNonceByStateRoot gets nonce from the MT Service using the provided state root

func (*State) GetStorageAt

func (s *State) GetStorageAt(ctx context.Context, address common.Address, position *big.Int, root common.Hash) (*big.Int, error)

GetStorageAt from a given address

func (*State) GetStoredFlushID added in v0.0.990

func (s *State) GetStoredFlushID(ctx context.Context) (uint64, string, error)

GetStoredFlushID returns the stored flush ID and Prover ID

func (*State) GetTree

func (s *State) GetTree() *merkletree.StateTree

GetTree returns State inner tree

func (*State) OpenBatch

func (s *State) OpenBatch(ctx context.Context, processingContext ProcessingContext, dbTx pgx.Tx) error

OpenBatch adds a new batch into the state, with the necessary data to start processing transactions within it. It's meant to be used by sequencers, since they don't necessarily know what transactions are going to be added in this batch yet. In other words it's the creation of a WIP batch. Note that this will add a batch with batch number N + 1, where N it's the greatest batch number on the state.

func (*State) PreProcessTransaction

func (s *State) PreProcessTransaction(ctx context.Context, tx *types.Transaction, dbTx pgx.Tx) (*ProcessBatchResponse, error)

PreProcessTransaction processes the transaction in order to calculate its zkCounters before adding it to the pool

func (*State) ProcessAndStoreClosedBatch

func (s *State) ProcessAndStoreClosedBatch(ctx context.Context, processingCtx ProcessingContext, encodedTxs []byte, dbTx pgx.Tx, caller metrics.CallerLabel) (common.Hash, uint64, string, error)

ProcessAndStoreClosedBatch is used by the Synchronizer to add a closed batch into the data base. Values returned are the new stateRoot, the flushID (incremental value returned by executor), the ProverID (executor running ID) the result of closing the batch.

func (*State) ProcessBatch

func (s *State) ProcessBatch(ctx context.Context, request ProcessRequest, updateMerkleTree bool) (*ProcessBatchResponse, error)

ProcessBatch processes a batch

func (*State) ProcessSequencerBatch

func (s *State) ProcessSequencerBatch(ctx context.Context, batchNumber uint64, batchL2Data []byte, caller metrics.CallerLabel, dbTx pgx.Tx) (*ProcessBatchResponse, error)

ProcessSequencerBatch is used by the sequencers to process transactions into an open batch

func (*State) ProcessUnsignedTransaction

func (s *State) ProcessUnsignedTransaction(ctx context.Context, tx *types.Transaction, senderAddress common.Address, l2BlockNumber *uint64, noZKEVMCounters bool, dbTx pgx.Tx) (*runtime.ExecutionResult, error)

ProcessUnsignedTransaction processes the given unsigned transaction.

func (*State) RegisterNewL2BlockEventHandler

func (s *State) RegisterNewL2BlockEventHandler(h NewL2BlockEventHandler)

RegisterNewL2BlockEventHandler add the provided handler to the list of handlers that will be triggered when a new l2 block event is triggered

func (*State) SetGenesis

func (s *State) SetGenesis(ctx context.Context, block Block, genesis Genesis, dbTx pgx.Tx) ([]byte, error)

SetGenesis populates state with genesis information

func (*State) StartToMonitorNewL2Blocks added in v0.0.990

func (s *State) StartToMonitorNewL2Blocks()

StartToMonitorNewL2Blocks starts 2 go routines that will monitor new blocks and execute handlers registered to be executed when a new l2 block is detected. This is used by the RPC WebSocket filter subscription but can be used by any other component that needs to react to a new L2 block added to the state.

func (*State) StoreTransaction

func (s *State) StoreTransaction(ctx context.Context, batchNumber uint64, processedTx *ProcessTransactionResponse, coinbase common.Address, timestamp uint64, egpLog *EffectiveGasPriceLog, dbTx pgx.Tx) (*types.Header, error)

StoreTransaction is used by the sequencer and trusted state synchronizer to add process a transaction.

func (*State) StoreTransactions

func (s *State) StoreTransactions(ctx context.Context, batchNumber uint64, processedTxs []*ProcessTransactionResponse, txsEGPLog []*EffectiveGasPriceLog, dbTx pgx.Tx) error

StoreTransactions is used by the sequencer to add processed transactions into an open batch. If the batch already has txs, the processedTxs must be a super set of the existing ones, preserving order.

func (*State) TestConvertToProcessBatchResponse

func (s *State) TestConvertToProcessBatchResponse(response *executor.ProcessBatchResponse) (*ProcessBatchResponse, error)

TestConvertToProcessBatchResponse for test purposes

func (*State) UpdateForkIDIntervalsInMemory added in v0.0.990

func (s *State) UpdateForkIDIntervalsInMemory(intervals []ForkIDInterval)

UpdateForkIDIntervalsInMemory updates the forkID intervals in memory

type StoreTxEGPData added in v0.4.0

type StoreTxEGPData struct {
	EGPLog              *EffectiveGasPriceLog
	EffectivePercentage uint8
}

StoreTxEGPData contains the data related to the effective gas price that needs to be stored when storing a tx

type SyncingInfo

type SyncingInfo struct {
	InitialSyncingBlock         uint64
	LastBlockNumberSeen         uint64
	LastBlockNumberConsolidated uint64
	CurrentBlockNumber          uint64

	InitialSyncingBatch         uint64
	LastBatchNumberSeen         uint64
	LastBatchNumberConsolidated uint64
	CurrentBatchNumber          uint64
}

SyncingInfo stores information regarding the syncing status of the node

type TraceConfig

type TraceConfig struct {
	DisableStorage   bool
	DisableStack     bool
	EnableMemory     bool
	EnableReturnData bool
	Tracer           *string
	TracerConfig     json.RawMessage
}

TraceConfig sets the debug configuration for the executor

func (*TraceConfig) Is4ByteTracer

func (t *TraceConfig) Is4ByteTracer() bool

Is4ByteTracer returns true when should use 4byteTracer

func (*TraceConfig) IsCallTracer

func (t *TraceConfig) IsCallTracer() bool

IsCallTracer returns true when should use callTracer

func (*TraceConfig) IsDefaultTracer

func (t *TraceConfig) IsDefaultTracer() bool

IsDefaultTracer returns true when no custom tracer is set

func (*TraceConfig) IsJSCustomTracer

func (t *TraceConfig) IsJSCustomTracer() bool

IsJSCustomTracer returns true when should use js custom tracer

func (*TraceConfig) IsNoopTracer

func (t *TraceConfig) IsNoopTracer() bool

IsNoopTracer returns true when should use noopTracer

func (*TraceConfig) IsPrestateTracer

func (t *TraceConfig) IsPrestateTracer() bool

IsPrestateTracer returns true when should use prestateTracer

type TrustedReorg

type TrustedReorg struct {
	BatchNumber uint64
	Reason      string
}

TrustedReorg represents a trusted reorg

type VerifiedBatch

type VerifiedBatch struct {
	BlockNumber uint64
	BatchNumber uint64
	Aggregator  common.Address
	TxHash      common.Hash
	StateRoot   common.Hash
	IsTrusted   bool
}

VerifiedBatch represents a VerifiedBatch

type VirtualBatch

type VirtualBatch struct {
	BatchNumber   uint64
	TxHash        common.Hash
	Coinbase      common.Address
	SequencerAddr common.Address
	BlockNumber   uint64
}

VirtualBatch represents a VirtualBatch

type ZKCounters

type ZKCounters struct {
	CumulativeGasUsed    uint64
	UsedKeccakHashes     uint32
	UsedPoseidonHashes   uint32
	UsedPoseidonPaddings uint32
	UsedMemAligns        uint32
	UsedArithmetics      uint32
	UsedBinaries         uint32
	UsedSteps            uint32
}

ZKCounters counters for the tx

func ConvertToCounters

func ConvertToCounters(resp *executor.ProcessBatchResponse) ZKCounters

ConvertToCounters extracts ZKCounters from a ProcessBatchResponse

func (*ZKCounters) Sub

func (z *ZKCounters) Sub(other ZKCounters) error

Sub subtract zk counters with passed zk counters (not safe)

func (*ZKCounters) SumUp

func (z *ZKCounters) SumUp(other ZKCounters)

SumUp sum ups zk counters with passed tx zk counters

Directories

Path Synopsis
instrumentation/js/internal/tracers
Package tracers contains the actual JavaScript tracer assets.
Package tracers contains the actual JavaScript tracer assets.
instrumentation/tracers
Package tracers is a manager for transaction tracing engines.
Package tracers is a manager for transaction tracing engines.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL