dsl

package
v1.16.13 Latest Latest
Warning

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

 Go to latest Published: Apr 16, 2026 License: MIT Imports: 55 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func AssertAncestorDescendantRelationship 

func AssertAncestorDescendantRelationship(t helpers.Testing, chain *Chain, ancestor, descendant eth.BlockID) bool

func Identifier 

func Identifier(chain *Chain, tx *types.Transaction, rcpt *types.Receipt) inbox.Identifier

func RecipeToDepSet 

func RecipeToDepSet(t helpers.Testing, recipe *interopgen.InteropDevRecipe) *depset.StaticConfigDependencySet

RecipeToDepSet converts a recipe into a dependency-set for the supervisor.

func RequireL1Heads 

func RequireL1Heads(t helpers.Testing, system *InteropDSL, latest, finalized uint64)

RequireL1Heads fetches the latest and finalized L1 block headers via the L1 miner client and asserts that their block numbers match the expected values, treating missing finalized blocks as zero.

func RequireSupervisorChainHeads 

func RequireSupervisorChainHeads(t helpers.Testing, super *SupervisorActor, chain *Chain, unsafe, crossUnsafe, localSafe, safe, finalized eth.BlockID)

RequireSupervisorChainHeads queries the supervisor actor for its sync status and asserts that the chain's LocalUnsafe, CrossUnsafe, LocalSafe, CrossSafe, and Finalized block IDs match the provided expected values. It fails the test if any assertion does not hold.

func RequireUnsafeTimeOffset 

func RequireUnsafeTimeOffset(t helpers.Testing, c *Chain, timeOffset uint64)

RequireUnsafeTimeOffset asserts that the difference between the sequencer's L2 unsafe block time and the chain's genesis L2 time matches the provided expected offset.

func SetBlockTimeForChainA added in v1.12.0 

func SetBlockTimeForChainA(blockTime uint64) setupOption

func SetBlockTimeForChainB added in v1.12.0 

func SetBlockTimeForChainB(blockTime uint64) setupOption

func SetInteropForkScheduledButInactive 

func SetInteropForkScheduledButInactive() setupOption

func SetInteropOffsetForAllL2s 

func SetInteropOffsetForAllL2s(offset uint64) setupOption

func SetMessageExpiryTime 

func SetMessageExpiryTime(expiryTime uint64) setupOption

func WithActIncludeTx 

func WithActIncludeTx(includeTxAction helpers.Action) func(*AdvanceL1Opts)

func WithChainAssertions 

func WithChainAssertions(chain *Chain, chainAssertions ...assertionOption) superchainAssertionOption

WithChainAssertions applies the given assertion options to the specified chain in the superchain configuration.

func WithChains 

func WithChains(chains ...*Chain) actSyncSupernodeOption

func WithCrossUnsafeAdvancesBy 

func WithCrossUnsafeAdvancesBy(advancesBy uint64) func(cfg *updateExpectedConfig)

func WithCrossUnsafeAdvancesTo 

func WithCrossUnsafeAdvancesTo(expectedCrossUnsafeNumber uint64) func(cfg *updateExpectedConfig)

func WithCrossUnsafeEquals 

func WithCrossUnsafeEquals(expectedCrossUnsafeNumber uint64) func(cfg *updateExpectedConfig)

func WithFinalizedAdvancesBy 

func WithFinalizedAdvancesBy(advancesBy uint64) func(cfg *updateExpectedConfig)

func WithFinalizedAdvancesTo 

func WithFinalizedAdvancesTo(expectedFinalizedNumber uint64) func(cfg *updateExpectedConfig)

WithFinalizedAdvancesToUnsafe returns an assertionOption asserting that Finalized advances to the Unsafe block ID.

func WithFinalizedEquals 

func WithFinalizedEquals(expectedFinalizedNumber uint64) func(cfg *updateExpectedConfig)

func WithFinalizedSignal 

func WithFinalizedSignal() actSyncSupernodeOption

func WithFixedGasLimit 

func WithFixedGasLimit() func(opts *ExecuteOpts)

func WithIdentifier 

func WithIdentifier(ident inbox.Identifier) func(opts *ExecuteOpts)

func WithL1BlockCrossUnsafe 

func WithL1BlockCrossUnsafe() func(*AddL2BlockOpts)

func WithL2BlockTransactions 

func WithL2BlockTransactions(mkTxs ...TransactionCreator) func(*AddL2BlockOpts)

func WithL2BlocksUntilTimestamp 

func WithL2BlocksUntilTimestamp(timestamp uint64) func(*AddL2BlockOpts)

func WithLatestSignal 

func WithLatestSignal() actSyncSupernodeOption

func WithLocalSafeAdvancesBy 

func WithLocalSafeAdvancesBy(advancesBy uint64) func(cfg *updateExpectedConfig)

WithLocalSafeAdvancesBy returns an assertionOption asserting that LocalSafe advances by the given amount.

func WithLocalSafeAdvancesTo 

func WithLocalSafeAdvancesTo(expectedLocalSafeNumber uint64) func(cfg *updateExpectedConfig)

WithLocalSafeAdvancesToUnsafe returns an assertionOption asserting that LocalSafe advances to the Unsafe block ID.

func WithLocalSafeEquals 

func WithLocalSafeEquals(expectedLocalSafeNumber uint64) func(cfg *updateExpectedConfig)

func WithMapChainAssertions 

func WithMapChainAssertions(chainAssertions ...assertionOption) superchainAssertionOption

WithMapChainAssertions applies the given assertion options to all chains in the superchain configuration.

func WithMarkFinal 

func WithMarkFinal() batchAndMineOption

WithMarkFinal marks the L1 block with L2 batches as safe and finalized. Necessary for doing this is creating a second L1 block so that the final head can be be promoted.

func WithMarkSafe 

func WithMarkSafe() batchAndMineOption

func WithPayload 

func WithPayload(payload []byte) func(opts *ExecuteOpts)

func WithPendingMessage 

func WithPendingMessage(emitter *EmitterContract, chain *Chain, number uint64, logIndex int, msg string) func(opts *ExecuteOpts)

func WithRevertExpected 

func WithRevertExpected() func(*CheckIncludedOpts)

func WithSafeAdvancesBy 

func WithSafeAdvancesBy(advancesBy uint64) func(cfg *updateExpectedConfig)

func WithSafeAdvancesTo 

func WithSafeAdvancesTo(expectedSafeNumber uint64) func(cfg *updateExpectedConfig)

WithSafeAdvancesToUnsafe returns an assertionOption asserting that Safe advances to the Unsafe block ID.

func WithSafeEquals 

func WithSafeEquals(expectedSafeNumber uint64) func(cfg *updateExpectedConfig)

func WithSingleBatch added in v1.12.1 

func WithSingleBatch() func(*AdvanceSafeHeadsOpts)

func WithSkipCrossSafeUpdate 

func WithSkipCrossSafeUpdate() func(*SubmitBatchDataOpts)

func WithUnsafeAdvancesBy 

func WithUnsafeAdvancesBy(advancesBy uint64) func(cfg *updateExpectedConfig)

WithUnsafeAdvancesBy returns an assertionOption that checks UnsafeL2.Number advances by the given amount.

func WithUnsafeAdvancesTo 

func WithUnsafeAdvancesTo(expectedUnsafeNumber uint64) func(cfg *updateExpectedConfig)

WitUnsafeAdvancesTo returns an assertionOption that checks the next UnsafeL2.Number equals the expected value.

func WithUnsafeEquals 

func WithUnsafeEquals(expectedUnsafeNumber uint64) func(cfg *updateExpectedConfig)

Types

type AddL2BlockOpts 

type AddL2BlockOpts struct {
	BlockIsNotCrossUnsafe bool
	TransactionCreators   []TransactionCreator
	UntilTimestamp        uint64
}

type AdvanceL1Opts 

type AdvanceL1Opts struct {
	ChainOpts
	L1BlockTimeSeconds uint64
	TxInclusion        []helpers.Action
}

type AdvanceSafeHeadsOpts added in v1.12.1 

type AdvanceSafeHeadsOpts struct {
	SingleBatch bool
}

type Chain 

type Chain struct {
	ChainID eth.ChainID

	RollupCfg     *rollup.Config
	L1ChainConfig *params.ChainConfig
	DependencySet depset.DependencySet
	L2Genesis     *core.Genesis
	BatcherAddr   common.Address

	Sequencer       *helpers.L2Sequencer
	SequencerEngine *helpers.L2Engine
	Batcher         *helpers.L2Batcher
}

Chain holds the most common per-chain action-test data and actors

type ChainOpts 

type ChainOpts struct {
	Chains []*Chain
}

func (*ChainOpts) AddChain 

func (c *ChainOpts) AddChain(chain *Chain)

func (*ChainOpts) SetChains 

func (c *ChainOpts) SetChains(chains ...*Chain)

type ChainSyncStatusAsserter 

type ChainSyncStatusAsserter struct {
	PrevStatus *eth.SyncStatus
	// contains filtered or unexported fields
}

ChainSyncStatusAsserter tracks and asserts synchronization status changes for a single chain's sequencer.

func NewChainSyncStatusAsserter 

func NewChainSyncStatusAsserter(t helpers.Testing, system *InteropDSL, chain *Chain, strict bool) *ChainSyncStatusAsserter

NewChainSyncStatusAsserter initializes a ChainSyncStatusAsserter capturing the current sync status and strict mode preference.

func (*ChainSyncStatusAsserter) LogSyncStatus 

func (a *ChainSyncStatusAsserter) LogSyncStatus()

LogSyncStatus logs the current expected sync status values for the chain for debugging purposes.

func (*ChainSyncStatusAsserter) RequireInitialSeqSyncStatus 

func (a *ChainSyncStatusAsserter) RequireInitialSeqSyncStatus(options ...assertionOption)

RequireInitialSeqSyncStatus asserts the current synchronization status using provided assertion options without running an action.

func (*ChainSyncStatusAsserter) RequireSeqSyncStatus 

func (a *ChainSyncStatusAsserter) RequireSeqSyncStatus(action func(), options ...assertionOption)

RequireSeqSyncStatus runs a pre-check, executes the provided action, then applies the assertion options to verify expected synchronization status changes.

func (*ChainSyncStatusAsserter) RequireSupChainHeadsBySyncStatus 

func (a *ChainSyncStatusAsserter) RequireSupChainHeadsBySyncStatus()

RequireSupChainHeadsBySyncStatus asserts that the supervisor actor's chain heads match the asserter's PrevStatus values.

type CheckIncludedOpts 

type CheckIncludedOpts struct {
	ExpectRevert bool
}

type DSLUser 

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

func (*DSLUser) TransactOpts 

func (u *DSLUser) TransactOpts(chainID *big.Int) (*bind.TransactOpts, common.Address)

type EmitterContract 

type EmitterContract struct {
	EmittedMessages []*GeneratedTransaction
	// contains filtered or unexported fields
}

func NewEmitterContract 

func NewEmitterContract(t helpers.Testing) *EmitterContract

func (*EmitterContract) Address 

func (c *EmitterContract) Address(chain *Chain) common.Address

func (*EmitterContract) Deploy 

func (c *EmitterContract) Deploy(user *DSLUser) TransactionCreator

func (*EmitterContract) EmitMessage 

func (c *EmitterContract) EmitMessage(user *DSLUser, message string) TransactionCreator

func (*EmitterContract) LastEmittedMessage 

func (c *EmitterContract) LastEmittedMessage() *GeneratedTransaction

type ExecuteOpts 

type ExecuteOpts struct {
	Identifier *inbox.Identifier
	Payload    *[]byte
	GasLimit   uint64
}

type GeneratedTransaction 

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

func NewGeneratedTransaction 

func NewGeneratedTransaction(t helpers.Testing, chain *Chain, tx *types.Transaction, from common.Address) *GeneratedTransaction

func (*GeneratedTransaction) CheckIncluded 

func (m *GeneratedTransaction) CheckIncluded(args ...func(opts *CheckIncludedOpts))

func (*GeneratedTransaction) CheckNotIncluded 

func (m *GeneratedTransaction) CheckNotIncluded()

func (*GeneratedTransaction) Identifier 

func (m *GeneratedTransaction) Identifier() inbox.Identifier

func (*GeneratedTransaction) Include 

func (m *GeneratedTransaction) Include()

func (*GeneratedTransaction) IncludeDepositOK 

func (m *GeneratedTransaction) IncludeDepositOK(l1User *DSLUser, depositTxOpts *bind.TransactOpts, l1Miner *helpers.L1Miner)

IncludeDepositOK includes the GeneratedTransaction via a user deposit transaction.

func (*GeneratedTransaction) IncludeOK 

func (m *GeneratedTransaction) IncludeOK()

func (*GeneratedTransaction) MessagePayload 

func (m *GeneratedTransaction) MessagePayload() []byte

func (*GeneratedTransaction) PendingIdentifier 

func (m *GeneratedTransaction) PendingIdentifier(chain *Chain, logIndex int) inbox.Identifier

type InboxContract 

type InboxContract struct {
	Transactions []*GeneratedTransaction
	// contains filtered or unexported fields
}

func NewInboxContract 

func NewInboxContract(t helpers.Testing) *InboxContract

func (*InboxContract) Execute 

func (i *InboxContract) Execute(user *DSLUser, initTx *GeneratedTransaction, args ...func(opts *ExecuteOpts)) TransactionCreator

func (*InboxContract) LastTransaction 

func (i *InboxContract) LastTransaction() *GeneratedTransaction

type InteropActors 

type InteropActors struct {
	L1Miner    *helpers.L1Miner
	Supervisor *SupervisorActor
	ChainA     *Chain
	ChainB     *Chain
}

InteropActors holds a bundle of global actors and actors of 2 chains.

func (*InteropActors) ActBatchAndMine 

func (actors *InteropActors) ActBatchAndMine(t helpers.Testing, opts ...batchAndMineOption)

Creates a new L2 block, submits it to L1, and mines the L1 block.

func (*InteropActors) PrepareAndVerifyInitialState 

func (actors *InteropActors) PrepareAndVerifyInitialState(t helpers.Testing)

func (*InteropActors) PrepareChainState 

func (actors *InteropActors) PrepareChainState(t helpers.Testing)

func (*InteropActors) SyncStatuses 

func (actors *InteropActors) SyncStatuses(t helpers.Testing, chain *Chain) (*eth.SyncStatus, *eth.SupervisorChainSyncStatus)

func (*InteropActors) VerifyGenesisState 

func (actors *InteropActors) VerifyGenesisState(t helpers.Testing)

type InteropDSL 

type InteropDSL struct {
	Actors  *InteropActors
	Outputs *Outputs

	InboxContract *InboxContract
	// contains filtered or unexported fields
}

InteropDSL provides a high-level API to drive interop action tests so that the actual test reads more declaratively and is separated from the details of how each action is actually executed. DSL methods will typically:

  1. Check (and if needed, wait) for any required preconditions
  2. Perform the action, allowing components to fully process the effects of it
  3. Assert that the action completed. These are intended to be a sanity check to ensure tests fail fast if something doesn't work as expected. Options may be provided to perform more detailed or specific assertions

Optional inputs can be used to control lower level details of the operation. While it is also possible to directly access the Actors and low level actions, this should only be required when specifically testing low level details of that functionality. It is generally preferable to use optional inputs to the DSL methods to achieve the desired result rather than having to use the low level APIs directly.

Methods may also be provided specifically to verify some state. Methods may return some data from the system (e.g. OutputRootAtTimestamp) but it is generally preferred to provide an assertion method rather than a getter where that is viable. Assertion methods allow the DSL to provide more helpful information in failure messages and ensure the comparison is done correctly and consistently across tests rather than duplicating the assertion code in many tests.

Required inputs to methods are specified as normal parameters, so type checking enforces their presence. Optional inputs to methods are specified by a config struct and accept a vararg of functions that can update that struct. This is roughly inline with the typical opts pattern in Golang but with significantly reduced boilerplate code since so many methods will define their own config. With* methods are only provided for the most common optional args and tests will normally supply a custom function that sets all the optional values they need at once. Common options can be extracted to a reusable struct (e.g. ChainOpts above) which may expose helper methods to aid test readability and reduce boilerplate.

func NewInteropDSL 

func NewInteropDSL(t helpers.Testing, opts ...setupOption) *InteropDSL

func (*InteropDSL) ActSyncSupernode 

func (d *InteropDSL) ActSyncSupernode(t helpers.Testing, opts ...actSyncSupernodeOption)

func (*InteropDSL) AddL2Block 

func (d *InteropDSL) AddL2Block(chain *Chain, optionalArgs ...func(*AddL2BlockOpts))

AddL2Block adds a new unsafe block to the specified chain and fully processes it in the supervisor

func (*InteropDSL) AdvanceL1 

func (d *InteropDSL) AdvanceL1(optionalArgs ...func(*AdvanceL1Opts))

AdvanceL1 adds a new L1 block with the specified transactions and ensures it is processed by the specified chains and the supervisor.

func (*InteropDSL) AdvanceL2ToLastBlockOfOrigin 

func (d *InteropDSL) AdvanceL2ToLastBlockOfOrigin(chain *Chain, l1OriginHeight uint64)

AdvanceL2ToLastBlockOfOrigin advances the chain to the last block of the epoch at the specified L1 origin.

func (*InteropDSL) AdvanceSafeHeads added in v1.12.1 

func (d *InteropDSL) AdvanceSafeHeads(optionalArgs ...func(*AdvanceSafeHeadsOpts))

AdvanceSafeHeads advances the safe heads for all chains by adding a new L2 block and submitting batch data for each chain. By default, submits batch data for each chain in separate L1 blocks.

func (*InteropDSL) CreateUser 

func (d *InteropDSL) CreateUser() *DSLUser

func (*InteropDSL) DepSet 

func (d *InteropDSL) DepSet() *depset.StaticConfigDependencySet

func (*InteropDSL) DeployEmitterContracts 

func (d *InteropDSL) DeployEmitterContracts() *EmitterContract

DeployEmitterContracts deploys an emitter contract on both chains

func (*InteropDSL) FinalizeL1 

func (d *InteropDSL) FinalizeL1()

func (*InteropDSL) ProcessCrossSafe 

func (d *InteropDSL) ProcessCrossSafe(optionalArgs ...func(*ProcessCrossSafeOpts))

ProcessCrossSafe processes evens in the supervisor and nodes to ensure the cross-safe head is fully updated.

func (*InteropDSL) SubmitBatchData 

func (d *InteropDSL) SubmitBatchData(optionalArgs ...func(*SubmitBatchDataOpts))

SubmitBatchData submits batch data to L1 and processes the new L1 blocks, advancing the safe heads. By default, submits all batch data for all chains.

func (*InteropDSL) SubmitBatches 

func (d *InteropDSL) SubmitBatches(t helpers.Testing, l1BlockTimeSeconds uint64)

SubmitBatches checks if there are any pending batches to be submitted for either chain, and if so, submits them and advances L1 to process them.

func (*InteropDSL) SubmitBatchesAndAdvanceL1 

func (d *InteropDSL) SubmitBatchesAndAdvanceL1(t helpers.Testing, l1BlockTimeSeconds uint64)

SubmitBatchesAndAdvanceL1 submits the latest batches for all chains and synchronizes supervisor the latest data on L1

type InteropSetup 

type InteropSetup struct {
	Log        log.Logger
	Deployment *interopgen.WorldDeployment
	Out        *interopgen.WorldOutput
	CfgSet     depset.FullConfigSetMerged
	Keys       devkeys.Keys
	T          helpers.Testing
}

InteropSetup holds the chain deployment and config contents, before instantiating any services.

func SetupInterop 

func SetupInterop(t helpers.Testing, opts ...setupOption) *InteropSetup

SetupInterop creates an InteropSetup to instantiate actors on, with 2 L2 chains.

func (*InteropSetup) CreateActors 

func (is *InteropSetup) CreateActors() *InteropActors

type Message added in v1.12.1 

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

func NewMessage added in v1.12.1 

func NewMessage(dsl *InteropDSL, chain *Chain, emitter *EmitterContract, message string) *Message

func (*Message) ActEmitDeposit added in v1.12.2 

func (m *Message) ActEmitDeposit(l1User *DSLUser) helpers.Action

ActEmitDeposit returns an action that emits a message via a user deposit transaction.

func (*Message) CheckEmitted added in v1.12.1 

func (m *Message) CheckEmitted()

func (*Message) CheckExecuted added in v1.12.1 

func (m *Message) CheckExecuted()

func (*Message) CheckNotEmitted added in v1.12.1 

func (m *Message) CheckNotEmitted()

func (*Message) CheckNotExecuted added in v1.12.1 

func (m *Message) CheckNotExecuted()

func (*Message) Emit added in v1.12.1 

func (m *Message) Emit() *Message

func (*Message) EmitDeposit added in v1.12.2 

func (m *Message) EmitDeposit(l1User *DSLUser) *Message

EmitDeposit emits a message via a user deposit transaction.

func (*Message) ExecuteIdentifier added in v1.12.1 

func (m *Message) ExecuteIdentifier() inbox.Identifier

func (*Message) ExecuteOn added in v1.12.1 

func (m *Message) ExecuteOn(target *Chain, execOpts ...func(*ExecuteOpts)) *Message

func (*Message) ExecutePayload added in v1.12.1 

func (m *Message) ExecutePayload() []byte

func (*Message) ExecutePendingOn added in v1.12.2 

func (m *Message) ExecutePendingOn(target *Chain, pendingMessageBlockNumber uint64, execOpts ...func(*ExecuteOpts)) *Message

ExecutePendingOn executes a message that may not have been emitted yet.

type OutputRootSource 

type OutputRootSource interface {
	OutputAtBlock(ctx context.Context, blockNum uint64) (*eth.OutputResponse, error)
	RollupConfig(ctx context.Context) (*rollup.Config, error)
}

type Outputs 

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

func (*Outputs) OptimisticBlockAtTimestamp 

func (d *Outputs) OptimisticBlockAtTimestamp(chain *Chain, timestamp uint64) types.OptimisticBlock

func (*Outputs) OutputRootAtTimestamp 

func (d *Outputs) OutputRootAtTimestamp(chain *Chain, timestamp uint64) *eth.OutputResponse

func (*Outputs) SuperRoot 

func (d *Outputs) SuperRoot(timestamp uint64) eth.Super

func (*Outputs) TransitionState 

func (d *Outputs) TransitionState(timestamp uint64, step uint64, pendingProgress ...types.OptimisticBlock) *types.TransitionState

type ProcessCrossSafeOpts 

type ProcessCrossSafeOpts struct {
	ChainOpts
}

type SubmitBatchDataOpts 

type SubmitBatchDataOpts struct {
	ChainOpts
	SkipCrossSafeUpdate bool
}

type SuperNodeActor 

type SuperNodeActor struct {
	*sources.SuperNodeClient
}

SuperNodeActor exposes a real op-supernode instance to interop action tests.

func NewSuperNode 

func NewSuperNode(t helpers.Testing, logger log.Logger, l1Miner *helpers.L1Miner, chains ...*Chain) *SuperNodeActor

type SuperRootSource 

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

SuperRootSource is a testing helper to create a Super Root from a set of rollup clients

func NewSuperRootSource 

func NewSuperRootSource(ctx context.Context, sources ...OutputRootSource) (*SuperRootSource, error)

func (*SuperRootSource) CreateSuperRoot 

func (s *SuperRootSource) CreateSuperRoot(ctx context.Context, timestamp uint64) (*eth.SuperV1, error)

type SuperchainSyncStatusAsserter 

type SuperchainSyncStatusAsserter struct {
	ChainAsserters map[eth.ChainID]*ChainSyncStatusAsserter
	// contains filtered or unexported fields
}

SuperchainSyncStatusAsserter provides utilities to assert the synchronization status of multiple chains within the superchain context, tracking per-chain sync assertions.

func NewSuperchainSyncStatusAsserter 

func NewSuperchainSyncStatusAsserter(t helpers.Testing, system *InteropDSL, chains []*Chain, strict bool) *SuperchainSyncStatusAsserter

NewSuperchainSyncStatusAsserter constructs an asserter for each chain, initializing with the current sync status. If strict is true, any status change outside explicit assertions will cause failures.

func (*SuperchainSyncStatusAsserter) RequireAllInitialSeqSyncStatuses 

func (a *SuperchainSyncStatusAsserter) RequireAllInitialSeqSyncStatuses(options ...assertionOption)

RequireAllInitialSeqSyncStatuses asserts the initial synchronization status for all chains using the provided assertion options without executing any action.

func (*SuperchainSyncStatusAsserter) RequireAllSeqSyncStatuses 

func (a *SuperchainSyncStatusAsserter) RequireAllSeqSyncStatuses(action func(), options ...superchainAssertionOption)

RequireAllSeqSyncStatuses runs a pre-check for all chains, executes the provided action, and then asserts post-action synchronization status updates per chain using given options.

type SupervisorActor 

type SupervisorActor struct {
	sources.SupervisorClient
	// contains filtered or unexported fields
}

SupervisorActor represents a supervisor, instrumented to run synchronously for action-test purposes.

func NewSupervisor 

func NewSupervisor(t helpers.Testing, logger log.Logger, fullCfgSet depset.FullConfigSetSource) *SupervisorActor

NewSupervisor creates a new SupervisorActor, to action-test the supervisor with.

func (*SupervisorActor) ProcessFull 

func (sa *SupervisorActor) ProcessFull(t helpers.Testing)

func (*SupervisorActor) Rewind 

func (sa *SupervisorActor) Rewind(chain eth.ChainID, block eth.BlockID) error

func (*SupervisorActor) SignalFinalizedL1 

func (sa *SupervisorActor) SignalFinalizedL1(t helpers.Testing)

func (*SupervisorActor) SignalLatestL1 

func (sa *SupervisorActor) SignalLatestL1(t helpers.Testing)

type SyncStatusAssertion 

type SyncStatusAssertion func(t assert.TestingT, prevSyncStatus, nextSyncStatus *eth.SyncStatus) bool

SyncStatusAssertion defines the signature for a function that asserts conditions between previous and next sync statuses.

type TransactionCreator 

type TransactionCreator func(chain *Chain) *GeneratedTransaction

type TxIncluder 

type TxIncluder interface {
	IncludeTx(transaction *types.Transaction, from common.Address) (*types.Receipt, error)
}

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.