dsl

type AddL2BlockOpts ¶

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

type AdvanceL1Opts ¶

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

type Chain ¶

type Chain struct {
	ChainID eth.ChainID

	RollupCfg   *rollup.Config
	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 (c *ChainOpts) AddChain(chain *Chain)

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

type DSLUser ¶

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

func (u *DSLUser) TransactOpts(chain *Chain) (*bind.TransactOpts, common.Address)

type EmitterContract ¶

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

func NewEmitterContract(t helpers.Testing) *EmitterContract

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

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

func (c *EmitterContract) LastEmittedMessage() *GeneratedTransaction

type ExecuteOpts ¶

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

type GeneratedTransaction ¶

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

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

func (m *GeneratedTransaction) CheckIncluded()

func (m *GeneratedTransaction) CheckNotIncluded()

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

func (m *GeneratedTransaction) Include()

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

type InboxContract ¶

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

func NewInboxContract(t helpers.Testing) *InboxContract

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

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.

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 wil 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(t helpers.Testing) *InteropDSL

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

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

func (d *InteropDSL) CreateUser() *DSLUser

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

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

type InteropSetup ¶

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

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

func SetupInterop(t helpers.Testing) *InteropSetup

func (is *InteropSetup) CreateActors() *InteropActors

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 (d *Outputs) OptimisticBlockAtTimestamp(chain *Chain, timestamp uint64) types.OptimisticBlock

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

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

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 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(ctx context.Context, sources ...OutputRootSource) (*SuperRootSource, error)

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

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(t helpers.Testing, logger log.Logger, depSet depset.DependencySetSource) *SupervisorActor

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

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

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

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

type TransactionCreator ¶

type TransactionCreator func(chain *Chain) *GeneratedTransaction

type TxIncluder ¶

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