actions

package
v0.10.14 Latest Latest
Warning

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

 Go to latest Published: Feb 13, 2023 License: MIT Imports: 55 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	STATUS_INVALID         = &eth.ForkchoiceUpdatedResult{PayloadStatus: eth.PayloadStatusV1{Status: eth.ExecutionInvalid}, PayloadID: nil}
	STATUS_SYNCING         = &eth.ForkchoiceUpdatedResult{PayloadStatus: eth.PayloadStatusV1{Status: eth.ExecutionSyncing}, PayloadID: nil}
	INVALID_TERMINAL_BLOCK = eth.PayloadStatusV1{Status: eth.ExecutionInvalid, LatestValidHash: &common.Hash{}}
)
View Source 
var GarbageKinds = []GarbageKind{
	STRIP_VERSION,
	RANDOM,
	TRUNCATE_END,
	DIRTY_APPEND,
	INVALID_COMPRESSION,
	MALFORM_RLP,
}

Functions

This section is empty.

Types

type Action 

type Action func(t Testing)

Action is a function that may change the state of one or more actors or check their state. Action definitions are meant to be very small building blocks, and then composed into larger patterns to write more elaborate tests.

type ActionStatus 

type ActionStatus uint

ActionStatus defines the state of an action, to make a basic distinction between InvalidAction() and other calls. 

const (
	// ActionOK indicates the action is valid to apply
	ActionOK ActionStatus = iota
	// ActionInvalid indicates the action is not applicable, and a different next action may taken.
	ActionInvalid
)

type BasicUser added in v0.9.0 

type BasicUser[B any] struct {
	// contains filtered or unexported fields
}

BasicUser is an actor on a single ethereum layer, with one account key. The user maintains a set of standard txOpts to build its transactions with, along with configurable txToAddr and txCallData. The user has an RNG source with actions to randomize its transaction building.

func NewBasicUser added in v0.9.0 

func NewBasicUser[B any](log log.Logger, priv *ecdsa.PrivateKey, rng *rand.Rand) *BasicUser[B]

func (*BasicUser[B]) ActCheckReceiptStatusOfLastTx added in v0.9.0 

func (s *BasicUser[B]) ActCheckReceiptStatusOfLastTx(success bool) func(t Testing)

func (*BasicUser[B]) ActMakeTx added in v0.9.0 

func (s *BasicUser[B]) ActMakeTx(t Testing)

ActMakeTx makes a tx with the predetermined contents (see randomization and other actions) and sends it to the tx pool

func (*BasicUser[B]) ActRandomTxData added in v0.9.0 

func (s *BasicUser[B]) ActRandomTxData(t Testing)

func (*BasicUser[B]) ActRandomTxToAddr added in v0.9.0 

func (s *BasicUser[B]) ActRandomTxToAddr(t Testing)

func (*BasicUser[B]) ActRandomTxValue added in v0.9.0 

func (s *BasicUser[B]) ActRandomTxValue(t Testing)

func (*BasicUser[B]) ActResetTxOpts added in v0.9.0 

func (s *BasicUser[B]) ActResetTxOpts(t Testing)

ActResetTxOpts prepares the tx options to default values, based on the current pending block header.

func (*BasicUser[B]) ActSetTxCalldata added in v0.9.0 

func (s *BasicUser[B]) ActSetTxCalldata(calldata []byte) Action

func (*BasicUser[B]) ActSetTxToAddr added in v0.9.0 

func (s *BasicUser[B]) ActSetTxToAddr(to *common.Address) Action

func (*BasicUser[B]) ActSetTxValue added in v0.9.0 

func (s *BasicUser[B]) ActSetTxValue(value *big.Int) Action

func (*BasicUser[B]) CheckReceipt added in v0.9.0 

func (s *BasicUser[B]) CheckReceipt(t Testing, success bool, txHash common.Hash) *types.Receipt

func (*BasicUser[B]) LastTxReceipt added in v0.9.0 

func (s *BasicUser[B]) LastTxReceipt(t Testing) *types.Receipt

func (*BasicUser[B]) PendingNonce added in v0.9.0 

func (s *BasicUser[B]) PendingNonce(t Testing) uint64

func (*BasicUser[B]) SetUserEnv added in v0.9.0 

func (s *BasicUser[B]) SetUserEnv(env *BasicUserEnv[B])

SetUserEnv changes the user environment. This way a user can be initialized before being embedded in a genesis allocation, and change between different endpoints that may be initialized after the user.

func (*BasicUser[B]) TxValue added in v0.9.0 

func (s *BasicUser[B]) TxValue() *big.Int

type BasicUserEnv added in v0.9.0 

type BasicUserEnv[B any] struct {
	EthCl  *ethclient.Client
	Signer types.Signer

	AddressCorpora []common.Address

	Bindings B
}

BasicUserEnv provides access to the eth RPC, signer, and contract bindings for a single ethereum layer. This environment can be shared between different BasicUser instances.

type BatcherCfg added in v0.9.0 

type BatcherCfg struct {
	// Limit the size of txs
	MinL1TxSize uint64
	MaxL1TxSize uint64

	BatcherKey *ecdsa.PrivateKey

	GarbageCfg *GarbageChannelCfg
}

type BlocksAPI added in v0.9.0 

type BlocksAPI interface {
	BlockByNumber(ctx context.Context, number *big.Int) (*types.Block, error)
}

type ChannelOutIface added in v0.10.11 

type ChannelOutIface interface {
	ID() derive.ChannelID
	Reset() error
	AddBlock(block *types.Block) (uint64, error)
	ReadyBytes() int
	Flush() error
	Close() error
	OutputFrame(w *bytes.Buffer, maxSize uint64) (uint16, error)
}

ChannelOutIface is the interface implemented by ChannelOut & GarbageChannelOut

type CrossLayerUser added in v0.9.0 

type CrossLayerUser struct {
	L1 L1User
	L2 L2User
	// contains filtered or unexported fields
}

CrossLayerUser represents the same user account on L1 and L2, and provides actions to make cross-layer transactions.

func NewCrossLayerUser added in v0.9.0 

func NewCrossLayerUser(log log.Logger, priv *ecdsa.PrivateKey, rng *rand.Rand) *CrossLayerUser

func (*CrossLayerUser) ActCheckDepositStatus added in v0.9.0 

func (s *CrossLayerUser) ActCheckDepositStatus(l1Success, l2Success bool) Action

func (*CrossLayerUser) ActCheckStartWithdrawal added in v0.9.0 

func (s *CrossLayerUser) ActCheckStartWithdrawal(success bool) Action

ActCheckStartWithdrawal checks that a previous witdrawal tx was either successful or failed.

func (*CrossLayerUser) ActCompleteWithdrawal added in v0.9.0 

func (s *CrossLayerUser) ActCompleteWithdrawal(t Testing)

ActCompleteWithdrawal creates a L1 withdrawal finalization tx for latest withdrawal. The tx hash is remembered as the last L1 tx, to check as L1 actor. The withdrawal functions like CompleteWithdrawal

func (*CrossLayerUser) ActDeposit added in v0.9.0 

func (s *CrossLayerUser) ActDeposit(t Testing)

func (*CrossLayerUser) ActProveWithdrawal added in v0.10.1 

func (s *CrossLayerUser) ActProveWithdrawal(t Testing)

ActCompleteWithdrawal creates a L1 proveWithdrawal tx for latest withdrawal. The tx hash is remembered as the last L1 tx, to check as L1 actor.

func (*CrossLayerUser) ActStartWithdrawal added in v0.9.0 

func (s *CrossLayerUser) ActStartWithdrawal(t Testing)

func (*CrossLayerUser) Address added in v0.9.0 

func (s *CrossLayerUser) Address() common.Address

func (*CrossLayerUser) CheckDepositTx added in v0.9.0 

func (s *CrossLayerUser) CheckDepositTx(t Testing, l1TxHash common.Hash, index int, l1Success, l2Success bool)

func (*CrossLayerUser) CompleteWithdrawal added in v0.9.0 

func (s *CrossLayerUser) CompleteWithdrawal(t Testing, l2TxHash common.Hash) common.Hash

CompleteWithdrawal creates a L1 withdrawal finalization tx for the given L2 withdrawal tx, returning the tx hash. It's an invalid action to attempt to complete a withdrawal that has not passed the L1 finalization period yet

func (*CrossLayerUser) ProveWithdrawal added in v0.10.1 

func (s *CrossLayerUser) ProveWithdrawal(t Testing, l2TxHash common.Hash) common.Hash

ProveWithdrawal creates a L1 proveWithdrawal tx for the given L2 withdrawal tx, returning the tx hash.

type EngineOption added in v0.10.1 

type EngineOption func(ethCfg *ethconfig.Config, nodeCfg *node.Config) error

type GarbageChannelCfg added in v0.10.11 

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

GarbageChannelCfg is the configuration for a `GarbageChannelOut`

type GarbageChannelOut added in v0.10.11 

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

GarbageChannelOut is a modified `derive.ChannelOut` that can be configured to behave differently than the original

func NewGarbageChannelOut added in v0.10.11 

func NewGarbageChannelOut(cfg *GarbageChannelCfg) (*GarbageChannelOut, error)

NewGarbageChannelOut creates a new `GarbageChannelOut` with the given configuration.

func (*GarbageChannelOut) AddBlock added in v0.10.11 

func (co *GarbageChannelOut) AddBlock(block *types.Block) (uint64, error)

AddBlock adds a block to the channel. It returns an error if there is a problem adding the block. The only sentinel error that it returns is ErrTooManyRLPBytes. If this error is returned, the channel should be closed and a new one should be made.

func (*GarbageChannelOut) Close added in v0.10.11 

func (co *GarbageChannelOut) Close() error

func (*GarbageChannelOut) Flush added in v0.10.11 

func (co *GarbageChannelOut) Flush() error

Flush flushes the internal compression stage to the ready buffer. It enables pulling a larger & more complete frame. It reduces the compression efficiency.

func (*GarbageChannelOut) ID added in v0.10.11 

func (co *GarbageChannelOut) ID() derive.ChannelID

func (*GarbageChannelOut) OutputFrame added in v0.10.11 

func (co *GarbageChannelOut) OutputFrame(w *bytes.Buffer, maxSize uint64) (uint16, error)

OutputFrame writes a frame to w with a given max size Use `ReadyBytes`, `Flush`, and `Close` to modify the ready buffer. Returns io.EOF when the channel is closed & there are no more frames Returns nil if there is still more buffered data. Returns and error if it ran into an error during processing.

func (*GarbageChannelOut) ReadyBytes added in v0.10.11 

func (co *GarbageChannelOut) ReadyBytes() int

ReadyBytes returns the number of bytes that the channel out can immediately output into a frame. Use `Flush` or `Close` to move data from the compression buffer into the ready buffer if more bytes are needed. Add blocks may add to the ready buffer, but it is not guaranteed due to the compression stage.

func (*GarbageChannelOut) Reset added in v0.10.11 

func (co *GarbageChannelOut) Reset() error

TODO: reuse ChannelOut for performance

type GarbageKind added in v0.10.11 

type GarbageKind int64
const (
	STRIP_VERSION GarbageKind = iota
	RANDOM
	TRUNCATE_END
	DIRTY_APPEND
	INVALID_COMPRESSION
	MALFORM_RLP
)

type L1Bindings added in v0.9.0 

type L1Bindings struct {
	// contract bindings
	OptimismPortal *bindings.OptimismPortal

	L2OutputOracle *bindings.L2OutputOracle
}

func NewL1Bindings added in v0.9.0 

func NewL1Bindings(t Testing, l1Cl *ethclient.Client, deployments *e2eutils.DeploymentsL1) *L1Bindings

type L1CanonSrc added in v0.8.10 

type L1CanonSrc func(num uint64) *types.Block

L1CanonSrc is used to sync L1 from another node. The other node always has the canonical chain. May be nil if there is nothing to sync from

type L1Miner added in v0.8.10 

type L1Miner struct {
	L1Replica
	// contains filtered or unexported fields
}

L1Miner wraps a L1Replica with instrumented block building ability.

func NewL1Miner added in v0.8.10 

func NewL1Miner(t Testing, log log.Logger, genesis *core.Genesis) *L1Miner

NewL1Miner creates a new L1Replica that can also build blocks.

func (*L1Miner) ActEmptyBlock added in v0.9.0 

func (s *L1Miner) ActEmptyBlock(t Testing)

func (*L1Miner) ActL1EndBlock added in v0.8.10 

func (s *L1Miner) ActL1EndBlock(t Testing)

ActL1EndBlock finishes the new L1 block, and applies it to the chain as unsafe block

func (*L1Miner) ActL1IncludeTx added in v0.8.10 

func (s *L1Miner) ActL1IncludeTx(from common.Address) Action

ActL1IncludeTx includes the next tx from L1 tx pool from the given account

func (*L1Miner) ActL1SetFeeRecipient added in v0.8.10 

func (s *L1Miner) ActL1SetFeeRecipient(coinbase common.Address)

func (*L1Miner) ActL1StartBlock added in v0.8.10 

func (s *L1Miner) ActL1StartBlock(timeDelta uint64) Action

ActL1StartBlock returns an action to build a new L1 block on top of the head block, with timeDelta added to the head block time.

func (*L1Miner) Close added in v0.8.10 

func (s *L1Miner) Close() error

type L1Replica added in v0.8.10 

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

L1Replica is an instrumented in-memory L1 geth node that: - can sync from the given canonical L1 blocks source - can rewind the chain back (for reorgs) - can provide an RPC with mock errors

func NewL1Replica added in v0.8.10 

func NewL1Replica(t Testing, log log.Logger, genesis *core.Genesis) *L1Replica

NewL1Replica constructs a L1Replica starting at the given genesis.

func (*L1Replica) ActL1FinalizeNext added in v0.8.10 

func (s *L1Replica) ActL1FinalizeNext(t Testing)

ActL1FinalizeNext finalizes the next block, which must be marked as safe before doing so (see ActL1SafeNext).

func (*L1Replica) ActL1RPCFail added in v0.8.10 

func (s *L1Replica) ActL1RPCFail(t Testing)

ActL1RPCFail makes the next L1 RPC request to this node fail

func (*L1Replica) ActL1RewindDepth added in v0.8.10 

func (s *L1Replica) ActL1RewindDepth(depth uint64) Action

func (*L1Replica) ActL1RewindToParent added in v0.8.10 

func (s *L1Replica) ActL1RewindToParent(t Testing)

ActL1RewindToParent rewinds the L1 chain to parent block of head

func (*L1Replica) ActL1SafeNext added in v0.8.10 

func (s *L1Replica) ActL1SafeNext(t Testing)

ActL1SafeNext marks the next unsafe block as safe.

func (*L1Replica) ActL1Sync added in v0.8.10 

func (s *L1Replica) ActL1Sync(canonL1 func(num uint64) *types.Block) Action

ActL1Sync processes the next canonical L1 block, or rewinds one block if the canonical block cannot be applied to the head.

func (*L1Replica) CanonL1Chain added in v0.8.10 

func (s *L1Replica) CanonL1Chain() func(num uint64) *types.Block

func (*L1Replica) Close added in v0.8.10 

func (s *L1Replica) Close() error

func (*L1Replica) EthClient added in v0.8.10 

func (s *L1Replica) EthClient() *ethclient.Client

func (*L1Replica) L1Client added in v0.9.0 

func (s *L1Replica) L1Client(t Testing, cfg *rollup.Config) *sources.L1Client

func (*L1Replica) MockL1RPCErrors added in v0.10.6 

func (s *L1Replica) MockL1RPCErrors(fn func() error)

func (*L1Replica) RPCClient added in v0.8.10 

func (s *L1Replica) RPCClient() client.RPC

type L1TxAPI added in v0.9.0 

type L1TxAPI interface {
	PendingNonceAt(ctx context.Context, account common.Address) (uint64, error)
	HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error)
	SendTransaction(ctx context.Context, tx *types.Transaction) error
}

type L1User added in v0.9.0 

type L1User struct {
	BasicUser[*L1Bindings]
}

type L2API added in v0.9.0 

type L2API interface {
	derive.Engine
	L2BlockRefByNumber(ctx context.Context, num uint64) (eth.L2BlockRef, error)
	InfoByHash(ctx context.Context, hash common.Hash) (eth.BlockInfo, error)
	// GetProof returns a proof of the account, it may return a nil result without error if the address was not found.
	GetProof(ctx context.Context, address common.Address, storage []common.Hash, blockTag string) (*eth.AccountResult, error)
}

type L2Batcher added in v0.9.0 

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

L2Batcher buffers and submits L2 batches to L1.

TODO: note the batcher shares little logic/state with actual op-batcher, tests should only use this actor to build batch contents for rollup node actors to consume, until the op-batcher is refactored and can be covered better.

func NewL2Batcher added in v0.9.0 

func NewL2Batcher(log log.Logger, rollupCfg *rollup.Config, batcherCfg *BatcherCfg, api SyncStatusAPI, l1 L1TxAPI, l2 BlocksAPI) *L2Batcher

func (*L2Batcher) ActBufferAll added in v0.9.0 

func (s *L2Batcher) ActBufferAll(t Testing)

func (*L2Batcher) ActL2BatchBuffer added in v0.9.0 

func (s *L2Batcher) ActL2BatchBuffer(t Testing)

ActL2BatchBuffer adds the next L2 block to the batch buffer. If the buffer is being submitted, the buffer is wiped.

func (*L2Batcher) ActL2BatchSubmit added in v0.9.0 

func (s *L2Batcher) ActL2BatchSubmit(t Testing)

ActL2BatchSubmit constructs a batch tx from previous buffered L2 blocks, and submits it to L1

func (*L2Batcher) ActL2BatchSubmitGarbage added in v0.10.11 

func (s *L2Batcher) ActL2BatchSubmitGarbage(t Testing, kind GarbageKind)

ActL2BatchSubmitGarbage constructs a malformed channel frame and submits it to the batch inbox. This *should* cause the batch inbox to reject the blocks encoded within the frame, even if the blocks themselves are valid.

func (*L2Batcher) ActL2ChannelClose added in v0.9.0 

func (s *L2Batcher) ActL2ChannelClose(t Testing)

func (*L2Batcher) ActSubmitAll added in v0.9.0 

func (s *L2Batcher) ActSubmitAll(t Testing)

func (*L2Batcher) SubmittingData added in v0.9.0 

func (s *L2Batcher) SubmittingData() bool

SubmittingData indicates if the actor is submitting buffer data. All data must be submitted before it can safely continue buffering more L2 blocks.

type L2Bindings added in v0.9.0 

type L2Bindings struct {
	L2ToL1MessagePasser *bindings.L2ToL1MessagePasser

	ProofClient withdrawals.ProofClient
}

func NewL2Bindings added in v0.9.0 

func NewL2Bindings(t Testing, l2Cl *ethclient.Client, proofCl withdrawals.ProofClient) *L2Bindings

type L2Engine added in v0.8.10 

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

L2Engine is an in-memory implementation of the Engine API, without support for snap-sync, and no concurrency or background processes.

func NewL2Engine added in v0.8.10 

func NewL2Engine(t Testing, log log.Logger, genesis *core.Genesis, rollupGenesisL1 eth.BlockID, jwtPath string, options ...EngineOption) *L2Engine

func (*L2Engine) ActL2IncludeTx added in v0.8.10 

func (e *L2Engine) ActL2IncludeTx(from common.Address) Action

ActL2IncludeTx includes the next transaction from the given address in the block that is being built

func (*L2Engine) ActL2RPCFail added in v0.8.10 

func (e *L2Engine) ActL2RPCFail(t Testing)

ActL2RPCFail makes the next L2 RPC request fail

func (*L2Engine) Close added in v0.8.10 

func (e *L2Engine) Close() error

func (*L2Engine) EngineClient added in v0.9.0 

func (e *L2Engine) EngineClient(t Testing, cfg *rollup.Config) *sources.EngineClient

func (*L2Engine) EthClient added in v0.8.10 

func (s *L2Engine) EthClient() *ethclient.Client

func (*L2Engine) GethClient added in v0.9.0 

func (s *L2Engine) GethClient() *gethclient.Client

func (*L2Engine) RPCClient added in v0.8.10 

func (e *L2Engine) RPCClient() client.RPC

type L2EngineAPI added in v0.8.10 

type L2EngineAPI L2Engine

L2EngineAPI wraps an engine actor, and implements the RPC backend required to serve the engine API. This re-implements some of the Geth API work, but changes the API backend so we can deterministically build and control the L2 block contents to reach very specific edge cases as desired for testing.

func (*L2EngineAPI) ForkchoiceUpdatedV1 added in v0.8.10 

func (ea *L2EngineAPI) ForkchoiceUpdatedV1(ctx context.Context, state *eth.ForkchoiceState, attr *eth.PayloadAttributes) (*eth.ForkchoiceUpdatedResult, error)

func (*L2EngineAPI) GetPayloadV1 added in v0.8.10 

func (ea *L2EngineAPI) GetPayloadV1(ctx context.Context, payloadId eth.PayloadID) (*eth.ExecutionPayload, error)

func (*L2EngineAPI) NewPayloadV1 added in v0.8.10 

func (ea *L2EngineAPI) NewPayloadV1(ctx context.Context, payload *eth.ExecutionPayload) (*eth.PayloadStatusV1, error)

type L2Proposer added in v0.9.0 

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

func NewL2Proposer added in v0.9.0 

func NewL2Proposer(t Testing, log log.Logger, cfg *ProposerCfg, l1 *ethclient.Client, rollupCl *sources.RollupClient) *L2Proposer

func (*L2Proposer) ActMakeProposalTx added in v0.9.0 

func (p *L2Proposer) ActMakeProposalTx(t Testing)

func (*L2Proposer) CanPropose added in v0.9.0 

func (p *L2Proposer) CanPropose(t Testing) bool

func (*L2Proposer) LastProposalTx added in v0.9.0 

func (p *L2Proposer) LastProposalTx() common.Hash

type L2Sequencer added in v0.9.0 

type L2Sequencer struct {
	L2Verifier
	// contains filtered or unexported fields
}

L2Sequencer is an actor that functions like a rollup node, without the full P2P/API/Node stack, but just the derivation state, and simplified driver with sequencing ability.

func NewL2Sequencer added in v0.9.0 

func NewL2Sequencer(t Testing, log log.Logger, l1 derive.L1Fetcher, eng L2API, cfg *rollup.Config, seqConfDepth uint64) *L2Sequencer

func (*L2Sequencer) ActBuildToL1Head added in v0.9.0 

func (s *L2Sequencer) ActBuildToL1Head(t Testing)

ActBuildToL1Head builds empty blocks until (incl.) the L1 head becomes the L2 origin

func (*L2Sequencer) ActBuildToL1HeadExcl added in v0.9.0 

func (s *L2Sequencer) ActBuildToL1HeadExcl(t Testing)

ActBuildToL1HeadExcl builds empty blocks until (excl.) the L1 head becomes the L2 origin

func (*L2Sequencer) ActL2EndBlock added in v0.9.0 

func (s *L2Sequencer) ActL2EndBlock(t Testing)

ActL2EndBlock completes a new L2 block and applies it to the L2 chain as new canonical unsafe head

func (*L2Sequencer) ActL2KeepL1Origin added in v0.9.0 

func (s *L2Sequencer) ActL2KeepL1Origin(t Testing)

ActL2KeepL1Origin makes the sequencer use the current L1 origin, even if the next origin is available.

func (*L2Sequencer) ActL2StartBlock added in v0.9.0 

func (s *L2Sequencer) ActL2StartBlock(t Testing)

ActL2StartBlock starts building of a new L2 block on top of the head

type L2User added in v0.9.0 

type L2User struct {
	BasicUser[*L2Bindings]
}

type L2Verifier added in v0.8.10 

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

L2Verifier is an actor that functions like a rollup node, without the full P2P/API/Node stack, but just the derivation state, and simplified driver.

func NewL2Verifier added in v0.8.10 

func NewL2Verifier(t Testing, log log.Logger, l1 derive.L1Fetcher, eng L2API, cfg *rollup.Config) *L2Verifier

func (*L2Verifier) ActL1FinalizedSignal added in v0.9.0 

func (s *L2Verifier) ActL1FinalizedSignal(t Testing)

func (*L2Verifier) ActL1HeadSignal added in v0.9.0 

func (s *L2Verifier) ActL1HeadSignal(t Testing)

func (*L2Verifier) ActL1SafeSignal added in v0.9.0 

func (s *L2Verifier) ActL1SafeSignal(t Testing)

func (*L2Verifier) ActL2PipelineFull added in v0.8.10 

func (s *L2Verifier) ActL2PipelineFull(t Testing)

func (*L2Verifier) ActL2PipelineStep added in v0.8.10 

func (s *L2Verifier) ActL2PipelineStep(t Testing)

ActL2PipelineStep runs one iteration of the L2 derivation pipeline

func (*L2Verifier) ActL2UnsafeGossipReceive added in v0.8.10 

func (s *L2Verifier) ActL2UnsafeGossipReceive(payload *eth.ExecutionPayload) Action

ActL2UnsafeGossipReceive creates an action that can receive an unsafe execution payload, like gossipsub

func (*L2Verifier) ActRPCFail added in v0.9.0 

func (s *L2Verifier) ActRPCFail(t Testing)

ActRPCFail makes the next L2 RPC request fail

func (*L2Verifier) L2Finalized added in v0.9.0 

func (s *L2Verifier) L2Finalized() eth.L2BlockRef

func (*L2Verifier) L2Safe added in v0.9.0 

func (s *L2Verifier) L2Safe() eth.L2BlockRef

func (*L2Verifier) L2Unsafe added in v0.9.0 

func (s *L2Verifier) L2Unsafe() eth.L2BlockRef

func (*L2Verifier) RPCClient added in v0.9.0 

func (s *L2Verifier) RPCClient() client.RPC

func (*L2Verifier) RollupClient added in v0.9.0 

func (s *L2Verifier) RollupClient() *sources.RollupClient

func (*L2Verifier) SyncStatus added in v0.8.10 

func (s *L2Verifier) SyncStatus() *eth.SyncStatus

type MockL1OriginSelector added in v0.10.12 

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

MockL1OriginSelector is a shim to override the origin as sequencer, so we can force it to stay on an older origin.

func (*MockL1OriginSelector) FindL1Origin added in v0.10.12 

func (m *MockL1OriginSelector) FindL1Origin(ctx context.Context, l2Head eth.L2BlockRef) (eth.L1BlockRef, error)

type ProposerCfg added in v0.9.0 

type ProposerCfg struct {
	OutputOracleAddr  common.Address
	ProposerKey       *ecdsa.PrivateKey
	AllowNonFinalized bool
}

type StatefulTesting added in v0.8.10 

type StatefulTesting interface {
	Testing
	Reset(actionCtx context.Context)
	State() ActionStatus
}

func NewDefaultTesting added in v0.8.10 

func NewDefaultTesting(tb e2eutils.TestingBase) StatefulTesting

NewDefaultTesting returns a new testing obj, and enables parallel test execution. Returns an interface, we're likely changing the behavior here as we build more action tests.

type SyncStatusAPI added in v0.9.0 

type SyncStatusAPI interface {
	SyncStatus(ctx context.Context) (*eth.SyncStatus, error)
}

type Testing 

type Testing interface {
	e2eutils.TestingBase
	// Ctx shares a context to execute an action with, the test runner may interrupt the action without stopping the test.
	Ctx() context.Context
	// InvalidAction indicates the failure is due to action incompatibility, does not stop the test.
	InvalidAction(format string, args ...any)
}

Testing is an interface to Go-like testing, extended with a context getter for the test runner to shut down individual actions without interrupting the test, and a signaling function for when an invalid action is hit. This helps custom test runners navigate slow or invalid actions, e.g. during fuzzing.

type Writer added in v0.10.11 

type Writer interface {
	Close() error
	Flush() error
	Reset(io.Writer)
	Write([]byte) (int, error)
}

Writer is the interface shared between `zlib.Writer` and `gzip.Writer`

Source Files

View all Source files

Jump to

Keyboard shortcuts

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