Versions in this module Expand all Collapse all v1 v1.1.3 Jan 20, 2025 v1.1.2 Jan 20, 2025 Changes in this version + const BookMarkTypeBatch + const BookMarkTypeL2Block + const EfficiencyPercentageByteLength + const EntryTypeBookMark + const EntryTypeL2BlockEnd + const EntryTypeL2BlockStart + const EntryTypeL2Tx + const EntryTypeUpdateGER + const FORKID_9 + const FORKID_BLUEBERRY + const FORKID_DRAGONFRUIT + const FORKID_ELDERBERRY + const FORKID_ETROG + const FORKID_INCABERRY + const MaxEffectivePercentage + const MaxL2BlockGasLimit + const MaxTxGasLimit + const MockL1InfoRootHex + const StreamTypeSequencer + const SystemSC + var DefaultSenderAddress = "0x1111111111111111111111111111111111111111" + var ErrAlreadyInitializedDBTransaction = errors.New("database transaction already initialized") + var ErrBatchAlreadyClosed = errors.New("batch is already closed") + var ErrBatchV2DontStartWithChangeL2Block = errors.New(...) + var ErrClosingBatchWithoutTxs = errors.New("can not close a batch without transactions") + var ErrDBTxNil = errors.New("the method requires a dbTx that is not nil") + var ErrEffectiveGasPriceEmpty = errors.New("effectiveGasPrice or gasPrice cannot be nil or zero") + var ErrEffectiveGasPriceIsZero = errors.New("effectiveGasPrice cannot be zero") + var ErrExecutingBatchOOC = errors.New("Batch execution fails because: out of counters") + var ErrExecutorNil = errors.New("the method requires an executor that is not nil") + var ErrExistingTxGreaterThanProcessedTx = errors.New(...) + var ErrInsufficientFundsForTransfer = errors.New("insufficient funds for transfer") + var ErrInvalidBatchHeader = errors.New("invalid batch header") + var ErrInvalidBatchNumber = errors.New("provided batch number is not latest") + var ErrInvalidBatchV2 = errors.New("invalid batch v2") + var ErrInvalidBlockRange = errors.New("invalid block range") + var ErrInvalidData = errors.New("invalid data") + var ErrInvalidRLP = errors.New("invalid rlp codification") + var ErrInvalidSig = errors.New("invalid transaction v, r, s values") + var ErrLastBatchShouldBeClosed = errors.New("last batch needs to be closed before adding a new one") + var ErrMaxLogsBlockRangeLimitExceeded = errors.New("logs are limited to a %v block range") + var ErrMaxLogsCountLimitExceeded = errors.New("query returned more than %v results") + var ErrMaxNativeBlockHashBlockRangeLimitExceeded = errors.New("native block hashes are limited to a %v block range") + var ErrNilDBTransaction = errors.New("database transaction not properly initialized") + var ErrNotEnoughIntrinsicGas = fmt.Errorf("not enough gas supplied for intrinsic gas costs") + var ErrNotFound = errors.New("object not found") + var ErrOutOfOrderProcessedTx = errors.New(...) + var ErrParsingExecutorTrace = fmt.Errorf("error while parsing executor trace") + var ErrQueueEmpty = fmt.Errorf("queue is empty") + var ErrStackEmpty = errors.New("Empty Stack") + var ErrStateNotSynchronized = errors.New("state not synchronized") + var ErrStateTreeNil = errors.New("the method requires a state tree that is not nil") + var ErrTimestampGE = errors.New("timestamp needs to be greater or equal") + var ErrUnexpectedBatch = errors.New("unexpected batch") + var ErrUnsupportedDuration = errors.New("unsupported time duration") + var ZeroAddress = common.Address + var ZeroHash = common.Hash + func CalculateEffectiveGasPricePercentage(gasPrice *big.Int, effectiveGasPrice *big.Int) (uint8, error) + func CheckLogOrder(logs []*types.Log) bool + func CheckSignature(tx types.Transaction) error + func CheckSupersetBatchTransactions(existingTxHashes []common.Hash, processedTxs []*ProcessTransactionResponse) error + func ConstructErrorFromRevert(err error, returnValue []byte) error + func DecodeTx(encodedTx string) (*types.Transaction, error) + func DecodeTxs(txsData []byte, forkID uint64) ([]types.Transaction, []byte, []uint8, error) + func EncodeBatchV2(batch *BatchRawV2) ([]byte, error) + func EncodeBlockHeaderV2(batchData []byte, block L2BlockRaw) ([]byte, error) + func EncodeTransaction(tx types.Transaction, effectivePercentage uint8, forkID uint64) ([]byte, error) + func EncodeTransactionWithoutEffectivePercentage(tx types.Transaction) ([]byte, error) + func EncodeTransactions(txs []types.Transaction, effectivePercentages []uint8, forkID uint64) ([]byte, error) + func EncodeTransactionsWithoutEffectivePercentage(txs []types.Transaction) ([]byte, error) + func EncodeUnsignedTransaction(tx types.Transaction, chainID uint64, forcedNonce *uint64, forkID uint64) ([]byte, error) + func GenerateDataStreamerFile(ctx context.Context, streamServer *datastreamer.StreamServer, stateDB DSState, ...) error + func GenerateReceipt(blockNumber *big.Int, processedTx *ProcessTransactionResponse, txIndex uint, ...) *types.Receipt + func GetMockL1InfoRoot() common.Hash + func GetSender(tx types.Transaction) (common.Address, error) + func GetSystemSCPosition(blockNumber uint64) []byte + func HashByteArray(data []byte) common.Hash + func HexToAddressPtr(hex string) *common.Address + func HexToHashPtr(hex string) *common.Hash + func InfiniteSafeRun(fn func(), errorMessage string, restartInterval time.Duration) + func IsPreEIP155Tx(tx types.Transaction) bool + func IsStateRootChanged(err executor.RomError) bool + func Ptr[T any](v T) *T + func RlpFieldsToLegacyTx(fields [][]byte, v, r, s []byte) (tx *types.LegacyTx, err error) + func SafeRun(fn func(), errorMessage string) + type Batch struct + AccInputHash common.Hash + BatchL2Data []byte + BatchNumber uint64 + Coinbase common.Address + ForcedBatchNum *uint64 + GlobalExitRoot common.Hash + LocalExitRoot common.Hash + Resources BatchResources + StateRoot common.Hash + Timestamp time.Time + Transactions []types.Transaction + WIP bool + type BatchConfig struct + Constraints BatchConstraintsCfg + type BatchConstraintsCfg struct + MaxArithmetics uint32 + MaxBatchBytesSize uint64 + MaxBinaries uint32 + MaxCumulativeGasUsed uint64 + MaxKeccakHashes uint32 + MaxMemAligns uint32 + MaxPoseidonHashes uint32 + MaxPoseidonPaddings uint32 + MaxSHA256Hashes uint32 + MaxSteps uint32 + MaxTxsPerBatch uint64 + func (c BatchConstraintsCfg) IsWithinConstraints(counters ZKCounters) bool + type BatchRawV2 struct + Blocks []L2BlockRaw + func DecodeBatchV2(txsData []byte) (*BatchRawV2, error) + func (b *BatchRawV2) String() string + type BatchRemainingResourcesUnderflowError struct + Code int + Err error + Message string + ResourceName string + func (b BatchRemainingResourcesUnderflowError) Error() string + type BatchResources struct + Bytes uint64 + ZKCounters ZKCounters + func (r *BatchResources) Fits(other BatchResources) (bool, string) + func (r *BatchResources) Sub(other BatchResources) (bool, string) + func (r *BatchResources) SumUp(other BatchResources) + type Block struct + BlockHash common.Hash + BlockNumber uint64 + Checked bool + ParentHash common.Hash + ReceivedAt time.Time + func NewBlock(blockNumber uint64) *Block + type ClosingReason string + const EmptyClosingReason + const ForcedBatchClosingReason + const ForcedBatchDeadlineClosingReason + const MaxDeltaTimestampClosingReason + const MaxTxsClosingReason + const NoTxFitsClosingReason + const ResourceExhaustedClosingReason + const ResourceMarginExhaustedClosingReason + const SyncGenesisBatchClosingReason + const SyncL1EventInitialBatchClosingReason + const SyncL1EventSequencedBatchClosingReason + const SyncL1EventSequencedForcedBatchClosingReason + const SyncL1EventUpdateEtrogSequenceClosingReason + const SyncL2TrustedBatchClosingReason + type Config struct + AvoidForkIDInMemory bool + Batch BatchConfig + ChainID uint64 + DB db.Config + ForkIDIntervals []ForkIDInterval + ForkUpgradeBatchNumber uint64 + ForkUpgradeNewForkId uint64 + MaxCumulativeGasUsed uint64 + MaxLogsBlockRange uint64 + MaxLogsCount uint64 + MaxNativeBlockHashBlockRange uint64 + MaxResourceExhaustedAttempts int + WaitOnResourceExhaustion types.Duration + type DSBatch struct + ForkID uint16 + type DSBookMark struct + Type byte + Value uint64 + func (b DSBookMark) Decode(data []byte) DSBookMark + func (b DSBookMark) Encode() []byte + type DSFullBatch struct + L2Blocks []DSL2FullBlock + type DSL2Block struct + BatchNumber uint64 + BlockHash common.Hash + ChainID uint32 + Coinbase common.Address + ForkID uint16 + GlobalExitRoot common.Hash + L1BlockHash common.Hash + L1InfoTreeIndex uint32 + L2BlockNumber uint64 + StateRoot common.Hash + Timestamp int64 + type DSL2BlockEnd struct + BlockHash common.Hash + L2BlockNumber uint64 + StateRoot common.Hash + func (b DSL2BlockEnd) Decode(data []byte) DSL2BlockEnd + func (b DSL2BlockEnd) Encode() []byte + type DSL2BlockStart struct + BatchNumber uint64 + ChainID uint32 + Coinbase common.Address + DeltaTimestamp uint32 + ForkID uint16 + GlobalExitRoot common.Hash + L1BlockHash common.Hash + L1InfoTreeIndex uint32 + L2BlockNumber uint64 + Timestamp int64 + func (b DSL2BlockStart) Decode(data []byte) DSL2BlockStart + func (b DSL2BlockStart) Encode() []byte + type DSL2FullBlock struct + Txs []DSL2Transaction + type DSL2Transaction struct + EffectiveGasPricePercentage uint8 + Encoded []byte + EncodedLength uint32 + ImStateRoot common.Hash + IsValid uint8 + L2BlockNumber uint64 + StateRoot common.Hash + func (l DSL2Transaction) Decode(data []byte) DSL2Transaction + func (l DSL2Transaction) Encode() []byte + type DSState interface + GetDSBatches func(ctx context.Context, firstBatchNumber, lastBatchNumber uint64, ...) ([]*DSBatch, error) + GetDSGenesisBlock func(ctx context.Context, dbTx pgx.Tx) (*DSL2Block, error) + GetDSL2Blocks func(ctx context.Context, firstBatchNumber, lastBatchNumber uint64, dbTx pgx.Tx) ([]*DSL2Block, error) + GetDSL2Transactions func(ctx context.Context, firstL2Block, lastL2Block uint64, dbTx pgx.Tx) ([]*DSL2Transaction, error) + GetForcedBatchParentHash func(ctx context.Context, forcedBatchNumber uint64, dbTx pgx.Tx) (common.Hash, error) + GetL1InfoRootLeafByIndex func(ctx context.Context, l1InfoTreeIndex uint32, dbTx pgx.Tx) (L1InfoTreeExitRootStorageEntry, error) + GetStorageAt func(ctx context.Context, address common.Address, position *big.Int, ...) (*big.Int, error) + GetVirtualBatchParentHash func(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) (common.Hash, error) + type DSUpdateGER struct + BatchNumber uint64 + ChainID uint32 + Coinbase common.Address + ForkID uint16 + GlobalExitRoot common.Hash + StateRoot common.Hash + Timestamp int64 + func (g DSUpdateGER) Decode(data []byte) DSUpdateGER + func (g DSUpdateGER) Encode() []byte + type EffectiveGasPriceLog struct + BalanceOC bool + Enabled bool + Error string + FinalDeviation *big.Int + GasPrice *big.Int + GasPriceOC bool + GasUsedFirst uint64 + GasUsedSecond uint64 + L1GasPrice uint64 + L2GasPrice uint64 + MaxDeviation *big.Int + Percentage uint8 + Reprocess bool + ValueFinal *big.Int + ValueFirst *big.Int + ValueSecond *big.Int + type FakeDB struct + State *State + func (f *FakeDB) AddAddressToAccessList(addr common.Address) + func (f *FakeDB) AddBalance(common.Address, *big.Int) + func (f *FakeDB) AddLog(*types.Log) + func (f *FakeDB) AddPreimage(common.Hash, []byte) + func (f *FakeDB) AddRefund(gas uint64) + func (f *FakeDB) AddSlotToAccessList(addr common.Address, slot common.Hash) + func (f *FakeDB) AddressInAccessList(addr common.Address) bool + func (f *FakeDB) CreateAccount(common.Address) + func (f *FakeDB) Empty(address common.Address) bool + func (f *FakeDB) Exist(address common.Address) bool + func (f *FakeDB) GetBalance(address common.Address) *big.Int + func (f *FakeDB) GetCode(address common.Address) []byte + func (f *FakeDB) GetCodeHash(address common.Address) common.Hash + func (f *FakeDB) GetCodeSize(address common.Address) int + func (f *FakeDB) GetCommittedState(common.Address, common.Hash) common.Hash + func (f *FakeDB) GetNonce(address common.Address) uint64 + func (f *FakeDB) GetRefund() uint64 + func (f *FakeDB) GetState(address common.Address, hash common.Hash) common.Hash + func (f *FakeDB) GetTransientState(addr common.Address, key common.Hash) common.Hash + func (f *FakeDB) HasSuicided(common.Address) bool + func (f *FakeDB) Prepare(rules params.Rules, sender, coinbase common.Address, dest *common.Address, ...) + func (f *FakeDB) RevertToSnapshot(int) + func (f *FakeDB) SetCode(common.Address, []byte) + func (f *FakeDB) SetNonce(common.Address, uint64) + func (f *FakeDB) SetState(common.Address, common.Hash, common.Hash) + func (f *FakeDB) SetStateRoot(stateRoot []byte) + func (f *FakeDB) SetTransientState(addr common.Address, key, value common.Hash) + func (f *FakeDB) SlotInAccessList(addr common.Address, slot common.Hash) (addressOk bool, slotOk bool) + func (f *FakeDB) Snapshot() int + func (f *FakeDB) SubBalance(common.Address, *big.Int) + func (f *FakeDB) SubRefund(gas uint64) + func (f *FakeDB) Suicide(common.Address) bool + type ForcedBatch struct + BlockNumber uint64 + ForcedAt time.Time + ForcedBatchNumber uint64 + GlobalExitRoot common.Hash + RawTxsData []byte + Sequencer common.Address + type ForcedBatchRawV2 struct + Transactions []L2TxRaw + func DecodeForcedBatchV2(txsData []byte) (*ForcedBatchRawV2, error) + type ForkIDInterval struct + BlockNumber uint64 + ForkId uint64 + FromBatchNumber uint64 + ToBatchNumber uint64 + Version string + type Genesis struct + Actions []*GenesisAction + BlockNumber uint64 + Root common.Hash + type GenesisAction struct + Address string + Bytecode string + Key string + Root string + StoragePosition string + Type int + Value string + type GlobalExitRoot struct + BlockNumber uint64 + GlobalExitRoot common.Hash + MainnetExitRoot common.Hash + RollupExitRoot common.Hash + Timestamp time.Time + type InfoReadWrite struct + Address common.Address + Balance *big.Int + Nonce *uint64 + type L1DataV2 struct + BlockHashL1 common.Hash + GlobalExitRoot common.Hash + MinTimestamp uint64 + SmtProof [][]byte + type L1InfoTreeExitRootStorageEntry struct + L1InfoTreeIndex uint32 + L1InfoTreeRoot common.Hash + type L1InfoTreeLeaf struct + PreviousBlockHash common.Hash + func (l *L1InfoTreeLeaf) Hash() common.Hash + type L2Block struct + ReceivedAt time.Time + ReceivedFrom interface{} + func NewL2Block(h *L2Header, txs []*types.Transaction, uncles []*L2Header, ...) *L2Block + func NewL2BlockWithHeader(h *L2Header) *L2Block + func (b *L2Block) BlockInfoRoot() common.Hash + func (b *L2Block) GlobalExitRoot() common.Hash + func (b *L2Block) Header() *L2Header + func (b *L2Block) Number() *big.Int + func (b *L2Block) WithBody(transactions []*types.Transaction, uncles []*L2Header) *L2Block + type L2BlockRaw struct + DeltaTimestamp uint32 + IndexL1InfoTree uint32 + Transactions []L2TxRaw + type L2Header struct + BlockInfoRoot common.Hash + GlobalExitRoot common.Hash + func CopyHeader(h *L2Header) *L2Header + func NewL2Header(h *types.Header) *L2Header + func (h *L2Header) Hash() common.Hash + func (h *L2Header) MarshalJSON() ([]byte, error) + func (h *L2Header) UnmarshalJSON(input []byte) error + type L2TxRaw struct + EfficiencyPercentage uint8 + Tx types.Transaction + type NewL2BlockEvent struct + Block L2Block + Logs []*types.Log + type NewL2BlockEventHandler func(e NewL2BlockEvent) + type ProcessBatchResponse struct + BlockResponses []*ProcessBlockResponse + ExecutorError error + FlushID uint64 + ForkID uint64 + GasUsed_V2 uint64 + InvalidBatch_V2 bool + IsExecutorLevelError bool + IsRomLevelError bool + IsRomOOCError bool + NewAccInputHash common.Hash + NewBatchNumber uint64 + NewLocalExitRoot common.Hash + NewStateRoot common.Hash + ProgramKeys_V2 []merkletree.Key + ProverID string + ReadWriteAddresses map[common.Address]*InfoReadWrite + ReservedZkCounters ZKCounters + RomError_V2 error + SMTKeys_V2 []merkletree.Key + StoredFlushID uint64 + UsedZkCounters ZKCounters + type ProcessBlockResponse struct + BlockHash common.Hash + BlockHashL1 common.Hash + BlockInfoRoot common.Hash + BlockNumber uint64 + Coinbase common.Address + GasLimit uint64 + GasUsed uint64 + GlobalExitRoot common.Hash + Logs []*types.Log + ParentHash common.Hash + RomError_V2 error + Timestamp uint64 + TransactionResponses []*ProcessTransactionResponse + type ProcessRequest struct + BatchNumber uint64 + Caller metrics.CallerLabel + Coinbase common.Address + ExecutionMode uint64 + ForcedBlockHashL1 common.Hash + ForkID uint64 + GlobalExitRoot_V1 common.Hash + L1InfoRoot_V2 common.Hash + L1InfoTreeData_V2 map[uint32]L1DataV2 + OldAccInputHash common.Hash + OldStateRoot common.Hash + SkipFirstChangeL2Block_V2 bool + SkipVerifyL1InfoRoot_V2 bool + SkipWriteBlockInfoRoot_V2 bool + TimestampLimit_V2 uint64 + Timestamp_V1 time.Time + Transactions []byte + type ProcessTransactionResponse struct + ChangesStateRoot bool + CreateAddress common.Address + CumulativeGasUsed uint64 + EffectiveGasPrice string + EffectivePercentage uint32 + FullTrace instrumentation.FullTrace + GasLeft uint64 + GasRefunded uint64 + GasUsed uint64 + HasBalanceOpcode bool + HasGaspriceOpcode bool + Logs []*types.Log + ReturnValue []byte + RomError error + StateRoot common.Hash + Status uint32 + Tx types.Transaction + TxHash common.Hash + TxHashL2_V2 common.Hash + Type uint32 + type ProcessingContext struct + BatchL2Data *[]byte + BatchNumber uint64 + ClosingReason ClosingReason + Coinbase common.Address + ForcedBatchNum *uint64 + GlobalExitRoot common.Hash + Timestamp time.Time + type ProcessingContextV2 struct + BatchL2Data *[]byte + BatchNumber uint64 + ClosingReason ClosingReason + Coinbase common.Address + ExecutionMode uint64 + ForcedBatchNum *uint64 + ForcedBlockHashL1 *common.Hash + GlobalExitRoot common.Hash + L1InfoRoot common.Hash + L1InfoTreeData map[uint32]L1DataV2 + SkipVerifyL1InfoRoot uint32 + Timestamp *time.Time + type ProcessingReceipt struct + AccInputHash common.Hash + BatchL2Data []byte + BatchNumber uint64 + BatchResources BatchResources + ClosingReason ClosingReason + GlobalExitRoot common.Hash + LocalExitRoot common.Hash + StateRoot common.Hash + type Proof struct + BatchNumber uint64 + BatchNumberFinal uint64 + CreatedAt time.Time + GeneratingSince *time.Time + InputProver string + Proof string + ProofID *string + Prover *string + ProverID *string + UpdatedAt time.Time + type Queue struct + func NewQueue[T any]() *Queue[T] + func (q *Queue[T]) IsEmpty() bool + func (q *Queue[T]) Len() int + func (q *Queue[T]) Pop() (T, error) + func (q *Queue[T]) Push(item T) + func (q *Queue[T]) Top() (T, error) + type Sequence struct + FromBatchNumber uint64 + ToBatchNumber uint64 + type Stack struct + func NewStack[T any]() *Stack[T] + func (s *Stack[T]) Pop() (T, error) + func (s *Stack[T]) Push(v T) + type State struct + func NewState(cfg Config, storage storage, executorClient executor.ExecutorServiceClient, ...) *State + func (p *State) GetSyncingInfo(ctx context.Context, dbTx pgx.Tx) (SyncingInfo, error) + func (s *State) AddForkIDInterval(ctx context.Context, newForkID ForkIDInterval, dbTx pgx.Tx) error + func (s *State) AddL1InfoTreeLeaf(ctx context.Context, l1InfoTreeLeaf *L1InfoTreeLeaf, dbTx pgx.Tx) (*L1InfoTreeExitRootStorageEntry, error) + func (s *State) BeginStateTransaction(ctx context.Context) (pgx.Tx, error) + func (s *State) CloseBatch(ctx context.Context, receipt ProcessingReceipt, dbTx pgx.Tx) error + func (s *State) CloseWIPBatch(ctx context.Context, receipt ProcessingReceipt, dbTx pgx.Tx) error + func (s *State) DebugTransaction(ctx context.Context, transactionHash common.Hash, traceConfig TraceConfig, ...) (*runtime.ExecutionResult, error) + func (s *State) EstimateGas(transaction *types.Transaction, senderAddress common.Address, ...) (uint64, []byte, error) + func (s *State) ExecuteBatch(ctx context.Context, batch Batch, updateMerkleTree bool, dbTx pgx.Tx) (*executor.ProcessBatchResponse, error) + func (s *State) ExecuteBatchV2(ctx context.Context, batch Batch, L1InfoTreeRoot common.Hash, ...) (*executor.ProcessBatchResponseV2, error) + func (s *State) FlushMerkleTree(ctx context.Context, newStateRoot common.Hash) error + func (s *State) GetBalance(ctx context.Context, address common.Address, root common.Hash) (*big.Int, error) + func (s *State) GetBalanceByStateRoot(ctx context.Context, address common.Address, root common.Hash) (*big.Int, error) + func (s *State) GetBatchTimestamp(ctx context.Context, batchNumber uint64, forcedForkId *uint64, dbTx pgx.Tx) (*time.Time, error) + func (s *State) GetCode(ctx context.Context, address common.Address, root common.Hash) ([]byte, error) + func (s *State) GetCurrentL1InfoRoot(ctx context.Context, dbTx pgx.Tx) (common.Hash, error) + func (s *State) GetForkIDByBatchNumber(batchNumber uint64) uint64 + func (s *State) GetForkIDByBlockNumber(blockNumber uint64) uint64 + func (s *State) GetL1InfoTreeDataFromBatchL2Data(ctx context.Context, batchL2Data []byte, dbTx pgx.Tx) (map[uint32]L1DataV2, common.Hash, common.Hash, error) + func (s *State) GetLastBatch(ctx context.Context, dbTx pgx.Tx) (*Batch, error) + func (s *State) GetLastStateRoot(ctx context.Context, dbTx pgx.Tx) (common.Hash, error) + func (s *State) GetNonce(ctx context.Context, address common.Address, root common.Hash) (uint64, error) + func (s *State) GetNonceByStateRoot(ctx context.Context, address common.Address, root common.Hash) (*big.Int, error) + func (s *State) GetStorageAt(ctx context.Context, address common.Address, position *big.Int, ...) (*big.Int, error) + func (s *State) GetStoredFlushID(ctx context.Context) (uint64, string, error) + func (s *State) GetTree() *merkletree.StateTree + func (s *State) GetWIPBatch(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) (*Batch, error) + func (s *State) OpenBatch(ctx context.Context, processingContext ProcessingContext, dbTx pgx.Tx) error + func (s *State) OpenWIPBatch(ctx context.Context, batch Batch, dbTx pgx.Tx) error + func (s *State) PreProcessTransaction(ctx context.Context, tx *types.Transaction, dbTx pgx.Tx) (*ProcessBatchResponse, error) + func (s *State) PreProcessUnsignedTransaction(ctx context.Context, tx *types.Transaction, sender common.Address, ...) (*ProcessBatchResponse, error) + func (s *State) ProcessAndStoreClosedBatch(ctx context.Context, processingCtx ProcessingContext, encodedTxs []byte, ...) (common.Hash, uint64, string, error) + func (s *State) ProcessAndStoreClosedBatchV2(ctx context.Context, processingCtx ProcessingContextV2, dbTx pgx.Tx, ...) (common.Hash, uint64, string, error) + func (s *State) ProcessBatch(ctx context.Context, request ProcessRequest, updateMerkleTree bool) (*ProcessBatchResponse, error) + func (s *State) ProcessBatchV2(ctx context.Context, request ProcessRequest, updateMerkleTree bool) (*ProcessBatchResponse, error) + func (s *State) ProcessSequencerBatch(ctx context.Context, batchNumber uint64, batchL2Data []byte, ...) (*ProcessBatchResponse, error) + func (s *State) ProcessUnsignedTransaction(ctx context.Context, tx *types.Transaction, senderAddress common.Address, ...) (*runtime.ExecutionResult, error) + func (s *State) RegisterNewL2BlockEventHandler(h NewL2BlockEventHandler) + func (s *State) Reset(ctx context.Context, blockNumber uint64, dbTx pgx.Tx) error + func (s *State) ResetL1InfoTree() + func (s *State) SetGenesis(ctx context.Context, block Block, genesis Genesis, m metrics.CallerLabel, ...) (common.Hash, error) + func (s *State) StartToMonitorNewL2Blocks() + func (s *State) StoreL2Block(ctx context.Context, batchNumber uint64, l2Block *ProcessBlockResponse, ...) error + func (s *State) StoreTransaction(ctx context.Context, batchNumber uint64, ...) (*L2Header, error) + func (s *State) StoreTransactions(ctx context.Context, batchNumber uint64, ...) error + func (s *State) TestConvertToProcessBatchResponse(batchResponse *executor.ProcessBatchResponse) (*ProcessBatchResponse, error) + func (s *State) TestConvertToProcessBatchResponseV2(batchResponse *executor.ProcessBatchResponseV2) (*ProcessBatchResponse, error) + func (s *State) UpdateForkIDIntervalsInMemory(intervals []ForkIDInterval) + type StateTx struct + L1InfoTreeModified bool + func (tx *StateTx) Rollback(ctx context.Context) error + func (tx *StateTx) SetL1InfoTreeModified() + type StoreTxEGPData struct + EGPLog *EffectiveGasPriceLog + EffectivePercentage uint8 + type SyncInfoDataOnStorage struct + InitialSyncingBatch uint64 + LastBatchNumberConsolidated uint64 + LastBatchNumberSeen uint64 + type SyncingInfo struct + CurrentBlockNumber uint64 + EstimatedHighestBlock uint64 + InitialSyncingBlock uint64 + IsSynchronizing bool + type TraceConfig struct + DisableStack bool + DisableStorage bool + EnableMemory bool + EnableReturnData bool + Tracer *string + TracerConfig json.RawMessage + func (t *TraceConfig) Is4ByteTracer() bool + func (t *TraceConfig) IsCallTracer() bool + func (t *TraceConfig) IsDefaultTracer() bool + func (t *TraceConfig) IsJSCustomTracer() bool + func (t *TraceConfig) IsNoopTracer() bool + func (t *TraceConfig) IsPrestateTracer() bool + type TrustedReorg struct + BatchNumber uint64 + Reason string + type VerifiedBatch struct + Aggregator common.Address + BatchNumber uint64 + BlockNumber uint64 + IsTrusted bool + StateRoot common.Hash + TxHash common.Hash + type VirtualBatch struct + BatchNumber uint64 + BlockNumber uint64 + Coinbase common.Address + L1InfoRoot *common.Hash + SequencerAddr common.Address + TimestampBatchEtrog *time.Time + TxHash common.Hash + type ZKCounters struct + Arithmetics uint32 + Binaries uint32 + GasUsed uint64 + KeccakHashes uint32 + MemAligns uint32 + PoseidonHashes uint32 + PoseidonPaddings uint32 + Sha256Hashes_V2 uint32 + Steps uint32 + func (z *ZKCounters) Fits(other ZKCounters) (bool, string) + func (z *ZKCounters) Sub(other ZKCounters) (bool, string) + func (z *ZKCounters) SumUp(other ZKCounters)
Go to main page