dsl

package

Go to main page

Versions in this module

v1

v1.16.6

Jan 19, 2026

v1.16.5

Jan 13, 2026

v1.16.4

Dec 18, 2025

Changes in this version

type L2CLNode

+ func (cl *L2CLNode) CurrentL1MatchedFn(refNode *L2CLNode, attempts int) CheckFunc

+ func (cl *L2CLNode) SetSequencerRecoverMode(b bool) error

type L2ELNode

+ func (el *L2ELNode) FinalizedHead() *BlockRefResult

+ func (el *L2ELNode) WaitForPendingNonceMatch(account common.Address, nonce uint64, attempts int, duration time.Duration)

+ func (el *L2ELNode) WaitForPendingNonceMatchFn(account common.Address, nonce uint64, attempts int, duration time.Duration) CheckFunc

v1.16.3

Dec 4, 2025

Changes in this version

type BlockRefResult

+ func (r *BlockRefResult) IsGenesis() *BlockRefResult

+ type FlashblocksWSClient struct

+ func NewFlashblocksWSClient(inner stack.FlashblocksWSClient) *FlashblocksWSClient

+ func (c *FlashblocksWSClient) Escape() stack.FlashblocksWSClient

+ func (c *FlashblocksWSClient) ListenFor(ctx context.Context, logger log.Logger, duration time.Duration, ...) error

+ func (c *FlashblocksWSClient) String() string

+ type FlashblocksWSClientSet []*FlashblocksWSClient

+ func NewFlashblocksWSClientSet(inner []stack.FlashblocksWSClient) FlashblocksWSClientSet

type L2CLNode

+ func (cl *L2CLNode) AdvancedUnsafe(delta uint64, attempts int)

+ func (cl *L2CLNode) MatchedUnsafe(refNode SyncStatusProvider, attempts int)

+ func (cl *L2CLNode) NotAdvancedUnsafe(attempts int)

+ func (cl *L2CLNode) ReachedUnsafe(target uint64, attempts int)

+ func (cl *L2CLNode) SafeHead() *BlockRefResult

type L2ELNode

+ func (el *L2ELNode) MatchedUnsafe(refNode SyncStatusProvider, attempts int)

+ func (el *L2ELNode) NotAdvancedUnsafe(attempts int)

type L2Network

+ func (n *L2Network) DeriveData(blocks int) (channels []derive.ChannelID, channelFrames map[derive.ChannelID][]derive.Frame, ...)

+ type OPRBuilderNode struct

+ func NewOPRBuilderNode(inner stack.OPRBuilderNode, control stack.ControlPlane) *OPRBuilderNode

+ func (c *OPRBuilderNode) Escape() stack.OPRBuilderNode

+ func (c *OPRBuilderNode) FlashblocksClient() *opclient.WSClient

+ func (c *OPRBuilderNode) String() string

+ func (el *OPRBuilderNode) Start()

+ func (el *OPRBuilderNode) Stop()

+ type OPRBuilderNodeSet []*OPRBuilderNode

+ func NewOPRBuilderNodeSet(inner []stack.OPRBuilderNode, control stack.ControlPlane) OPRBuilderNodeSet

+ type RollupBoostNode struct

+ func NewRollupBoostNode(inner stack.RollupBoostNode, control stack.ControlPlane) *RollupBoostNode

+ func (r *RollupBoostNode) Escape() stack.RollupBoostNode

+ func (r *RollupBoostNode) FlashblocksClient() *opclient.WSClient

+ type RollupBoostNodesSet []*RollupBoostNode

+ func NewRollupBoostNodesSet(inner []stack.RollupBoostNode, control stack.ControlPlane) RollupBoostNodesSet

type TestSequencer

+ func (s *TestSequencer) SequenceBlock(t devtest.T, chainID eth.ChainID, parent common.Hash)

v1.16.2

Nov 14, 2025

Changes in this version

type L2Network

+ func (n *L2Network) IsForkActiveAt(forkName forks.Name, timestamp uint64) bool

v1.16.1

Nov 4, 2025

v1.16.0

Oct 28, 2025

Changes in this version

+ type BlockRefResult struct

+ BlockRef eth.L2BlockRef

+ T devtest.T

+ func (r *BlockRefResult) NumEqualTo(num uint64) *BlockRefResult

type ForkchoiceUpdateResult

+ InvalidCnt int

+ RefreshCnt int

+ SyncingCnt int

+ ValidCnt int

+ func (r *ForkchoiceUpdateResult) ResultAllSyncing()

+ func (r *ForkchoiceUpdateResult) Retry(attempts int) *ForkchoiceUpdateResult

type L2CLNode

+ func (cl *L2CLNode) PostUnsafePayload(payload *eth.ExecutionPayloadEnvelope)

+ func (cl *L2CLNode) UnsafeHead() *BlockRefResult

type L2ELNode

+ func (el *L2ELNode) ForkchoiceUpdateRaw(unsafe, safe, finalized common.Hash, attr *eth.PayloadAttributes) *ForkchoiceUpdateResult

+ func (el *L2ELNode) NewPayloadRaw(payload *eth.ExecutionPayloadEnvelope) *NewPayloadResult

+ func (el *L2ELNode) SafeHead() *BlockRefResult

+ func (el *L2ELNode) UnsafeHead() *BlockRefResult

type NewPayloadResult

+ func (r *NewPayloadResult) IsInvalid() *NewPayloadResult

v1.14.3

Oct 23, 2025

Changes in this version

+ func RunOperatorFeeTest(t devtest.T, l2Chain *L2Network, l1EL *L1ELNode, funderL1, funderL2 *Funder)

type L1ELNode

+ func (el L1ELNode) WaitForLabel(label eth.BlockLabel, predicate func(eth.BlockInfo) (bool, error)) eth.BlockInfo

+ func (el L1ELNode) WaitForLabelRef(label eth.BlockLabel, predicate func(eth.BlockInfo) (bool, error)) eth.BlockRef

+ func (el L1ELNode) WaitForUnsafe(predicate func(eth.BlockInfo) (bool, error)) eth.BlockInfo

+ func (el L1ELNode) WaitForUnsafeRef(predicate func(eth.BlockInfo) (bool, error)) eth.BlockRef

type L2CLNode

+ func (cl *L2CLNode) AppendUnsafePayloadUntilTip(verEL, seqEL *L2ELNode, maxAttempts int)

+ func (cl *L2CLNode) Reset(lvl types.SafetyLevel, target eth.L2BlockRef)

type L2ELNode

+ func (el *L2ELNode) ChainSyncStatus(chainID eth.ChainID, lvl types.SafetyLevel) eth.BlockID

+ func (el *L2ELNode) FinishedELSync(refNode *L2ELNode, unsafe, safe, finalized uint64)

+ func (el *L2ELNode) L1OriginReachedFn(label eth.BlockLabel, l1OriginTarget uint64, attempts int) CheckFunc

+ func (el *L2ELNode) Matched(refNode SyncStatusProvider, lvl types.SafetyLevel, attempts int)

+ func (el *L2ELNode) MatchedFn(refNode SyncStatusProvider, lvl types.SafetyLevel, attempts int) CheckFunc

+ func (el *L2ELNode) WaitL1OriginReached(label eth.BlockLabel, l1OriginTarget uint64, attempts int)

+ func (el L2ELNode) WaitForLabel(label eth.BlockLabel, predicate func(eth.BlockInfo) (bool, error)) eth.BlockInfo

+ func (el L2ELNode) WaitForLabelRef(label eth.BlockLabel, predicate func(eth.BlockInfo) (bool, error)) eth.BlockRef

+ func (el L2ELNode) WaitForUnsafe(predicate func(eth.BlockInfo) (bool, error)) eth.BlockInfo

+ func (el L2ELNode) WaitForUnsafeRef(predicate func(eth.BlockInfo) (bool, error)) eth.BlockRef

type L2Network

+ func (n *L2Network) IsForkActive(forkName rollup.ForkName, timestamp uint64) bool

v1.14.1

Oct 8, 2025

Changes in this version

type ForkchoiceUpdateResult

+ Refresh func()

+ func (r *ForkchoiceUpdateResult) WaitUntilValid(attempts int) *ForkchoiceUpdateResult

type L2ELNode

+ func (el *L2ELNode) DisconnectPeerWith(peer *L2ELNode)

v1.14.0

Oct 7, 2025

Changes in this version

+ type ForkchoiceUpdateResult struct

+ Err error

+ Result *eth.ForkchoiceUpdatedResult

+ T devtest.T

+ func (r *ForkchoiceUpdateResult) IsForkchoiceUpdatedStatus(status eth.ExecutePayloadStatus) *ForkchoiceUpdateResult

+ func (r *ForkchoiceUpdateResult) IsSyncing() *ForkchoiceUpdateResult

+ func (r *ForkchoiceUpdateResult) IsValid() *ForkchoiceUpdateResult

type L1ELNode

+ func (el L1ELNode) WaitForTime(timestamp uint64) eth.BlockRef

type L2CLNode

+ func (cl *L2CLNode) SignalTarget(el *L2ELNode, targetNum uint64)

type L2ELNode

+ func (el *L2ELNode) BlockRefByHash(hash common.Hash) eth.L2BlockRef

+ func (el *L2ELNode) ForkchoiceUpdate(refNode *L2ELNode, unsafe, safe, finalized uint64, attr *eth.PayloadAttributes) *ForkchoiceUpdateResult

+ func (el *L2ELNode) NewPayload(refNode *L2ELNode, number uint64) *NewPayloadResult

+ func (el *L2ELNode) PayloadByNumber(number uint64) *eth.ExecutionPayloadEnvelope

+ func (el *L2ELNode) Reached(label eth.BlockLabel, block uint64, attempts int)

+ func (el *L2ELNode) ReachedFn(label eth.BlockLabel, target uint64, attempts int) CheckFunc

+ func (el L2ELNode) WaitForTime(timestamp uint64) eth.BlockRef

+ type NewPayloadResult struct

+ Err error

+ Status *eth.PayloadStatusV1

+ T devtest.T

+ func (r *NewPayloadResult) IsPayloadStatus(status eth.ExecutePayloadStatus) *NewPayloadResult

+ func (r *NewPayloadResult) IsSyncing() *NewPayloadResult

+ func (r *NewPayloadResult) IsValid() *NewPayloadResult

v1.13.7

Sep 19, 2025

Changes in this version

type L2CLNode

+ func (cl *L2CLNode) IsP2PConnected(peer *L2CLNode)

+ func (cl *L2CLNode) WaitForNonZeroUnsafeTime(ctx context.Context) *eth.SyncStatus

type StandardBridge

+ func (b *StandardBridge) PortalVersion() string

v1.13.6

Sep 2, 2025

Changes in this version

+ func CalculateFjordL1Cost(ctx context.Context, client apis.EthClient, ...) (*big.Int, error)

+ func CheckForChainFork(ctx context.Context, networks []*L2Network, logger log.Logger) (func(bool) error, error)

+ func CreateUnsignedTransactionFromSigned(signedTx *types.Transaction) (*types.Transaction, error)

+ func FindSignedTransactionFromReceipt(ctx context.Context, client apis.EthClient, receipt *types.Receipt) (*types.Transaction, error)

+ func IsForkActivated(c *params.ChainConfig, forkName rollup.ForkName, timestamp uint64) (bool, error)

+ func ReadGasPriceOracleL1FeeAt(ctx context.Context, client apis.EthClient, gpo *bindings.GasPriceOracle, ...) (*big.Int, error)

+ func ReadGasPriceOracleL1FeeUpperBoundAt(ctx context.Context, client apis.EthClient, gpo *bindings.GasPriceOracle, ...) (*big.Int, error)

+ func RequiresL2Fork(ctx context.Context, system L2NetworkProvider, networkIdx int, ...) error

+ func RequiresL2WithoutFork(ctx context.Context, system L2NetworkProvider, networkIdx int, ...) error

+ func ValidateL1FeeMatches(t devtest.T, calculatedFee, receiptFee *big.Int)

type EOA

+ func (u *EOA) ApproveToken(tokenAddr common.Address, spender common.Address, amount eth.ETH)

+ func (u *EOA) DeployWETH() common.Address

+ func (u *EOA) GetTokenBalance(tokenAddr common.Address) eth.ETH

+ func (u *EOA) PlanAuth(code common.Address) txplan.Option

+ func (u *EOA) VerifyTokenBalance(tokenAddr common.Address, expectedBalance eth.ETH)

+ func (u *EOA) WaitForTokenBalance(tokenAddr common.Address, expectedBalance eth.ETH)

+ type EcotoneFees struct

+ func NewEcotoneFees(t devtest.T, l2Network *L2Network) *EcotoneFees

+ func (ef *EcotoneFees) LogResults(result EcotoneFeesValidationResult)

+ func (ef *EcotoneFees) ValidateTransaction(from *EOA, to *EOA, amount *big.Int) EcotoneFeesValidationResult

+ type EcotoneFeesValidationResult struct

+ BaseFee *big.Int

+ L1Fee *big.Int

+ L2Fee *big.Int

+ PriorityFee *big.Int

+ TotalFee *big.Int

+ TransactionReceipt *types.Receipt

+ TransferAmount *big.Int

+ VaultBalances VaultBalances

+ WalletBalanceDiff *big.Int

+ type FjordFees struct

+ func NewFjordFees(t devtest.T, l2Network *L2Network) *FjordFees

+ func (ff *FjordFees) ValidateTransaction(from *EOA, to *EOA, amount *big.Int) FjordFeesValidationResult

+ type FjordFeesValidationResult struct

+ BaseFee *big.Int

+ CoinbaseDiff *big.Int

+ EstimatedBrotliSize *big.Int

+ FastLzSize uint64

+ L1Fee *big.Int

+ L2Fee *big.Int

+ OperatorFee *big.Int

+ PriorityFee *big.Int

+ TotalFee *big.Int

+ TransactionReceipt *types.Receipt

+ TransferAmount *big.Int

+ VaultBalances VaultBalances

+ WalletBalanceDiff *big.Int

type HDWallet

+ func NewRandomHDWallet(t devtest.T, startIndex uint64) *HDWallet

+ type HeaderProvider interface

+ InfoByHash func(ctx context.Context, hash common.Hash) (eth.BlockInfo, error)

+ InfoByLabel func(ctx context.Context, label eth.BlockLabel) (eth.BlockInfo, error)

+ InfoByNumber func(ctx context.Context, number uint64) (eth.BlockInfo, error)

type L1ELNode

+ func (el L1ELNode) WaitForFinalization() eth.BlockRef

type L1Network

+ func (n *L1Network) WaitForFinalization() eth.BlockRef

type L2ELNode

+ func (el *L2ELNode) VerifyWithdrawalHashChangedIn(blockHash common.Hash)

+ func (el L2ELNode) WaitForFinalization() eth.BlockRef

+ type L2NetworkProvider interface

+ L2Networks func() []*L2Network

+ type MultiClient struct

+ func MultiClientForL1Network(network *L1Network) (*MultiClient, error)

+ func MultiClientForL2Network(network *L2Network) (*MultiClient, error)

+ func NewMultiClient(clients []HeaderProvider) *MultiClient

+ func (mc *MultiClient) InfoByHash(ctx context.Context, hash common.Hash) (eth.BlockInfo, error)

+ func (mc *MultiClient) InfoByLabel(ctx context.Context, label eth.BlockLabel) (eth.BlockInfo, error)

+ func (mc *MultiClient) InfoByNumber(ctx context.Context, number uint64) (eth.BlockInfo, error)

+ type OperatorFee struct

+ func NewOperatorFee(t devtest.T, l2Network *L2Network, l1EL *L1ELNode) *OperatorFee

+ func (of *OperatorFee) CheckCompatibility() bool

+ func (of *OperatorFee) GetSystemOwner() *EOA

+ func (of *OperatorFee) RestoreOriginalConfig()

+ func (of *OperatorFee) SetOperatorFee(scalar uint32, constant uint64)

+ func (of *OperatorFee) ValidateTransactionFees(from *EOA, to *EOA, amount *big.Int, expectedScalar uint32, ...) OperatorFeeValidationResult

+ func (of *OperatorFee) VerifyL2Config(expectedScalar uint32, expectedConstant uint64)

+ func (of *OperatorFee) WaitForL2Sync(expectedScalar uint32, expectedConstant uint64)

+ func (of *OperatorFee) WaitForL2SyncWithCurrentL1State()

+ type OperatorFeeValidationResult struct

+ ActualTotalFee *big.Int

+ ExpectedOperatorFee *big.Int

+ TransactionReceipt *types.Receipt

+ VaultBalanceIncrease *big.Int

type StandardBridge

+ func (b *StandardBridge) CreateL2Token(l1TokenAddr common.Address, name string, symbol string, from *EOA) common.Address

+ func (b *StandardBridge) ERC20Deposit(l1TokenAddr common.Address, l2TokenAddr common.Address, amount eth.ETH, ...) *Deposit

+ type SyncTester struct

+ func NewSyncTester(inner stack.SyncTester) *SyncTester

+ func (s *SyncTester) ChainID(sessionID string) eth.ChainID

+ func (s *SyncTester) DeleteSession(sessionID string)

+ func (s *SyncTester) Escape() stack.SyncTester

+ func (s *SyncTester) GetSession(sessionID string) eth.SyncTesterSession

+ func (s *SyncTester) ListSessions() []string

+ type VaultBalances struct

+ BaseFeeVault *big.Int

+ L1FeeVault *big.Int

+ OperatorVault *big.Int

+ SequencerVault *big.Int

type Withdrawal

+ func (w *Withdrawal) InitiateBlockHash() common.Hash

v1.13.5

Jul 11, 2025

Changes in this version

+ func WithMinRequiredL2Block(blockNum uint64) func(opts *safeHeadDbMatchOpts)

+ type Deposit struct

+ func (d Deposit) GasCost() eth.ETH

type FlashblocksBuilderNode

+ func (c *FlashblocksBuilderNode) Conductor() *Conductor

+ func (c *FlashblocksBuilderNode) ListenFor(logger log.Logger, duration time.Duration, output chan<- []byte, ...) error

type FlashblocksBuilderSet

+ func (f FlashblocksBuilderSet) Leader() *FlashblocksBuilderNode

+ type FlashblocksWebsocketProxy struct

+ func NewFlashblocksWebsocketProxy(inner stack.FlashblocksWebsocketProxy) *FlashblocksWebsocketProxy

+ func (c *FlashblocksWebsocketProxy) Escape() stack.FlashblocksWebsocketProxy

+ func (c *FlashblocksWebsocketProxy) ListenFor(logger log.Logger, duration time.Duration, output chan<- []byte, ...) error

+ func (c *FlashblocksWebsocketProxy) String() string

+ type FlashblocksWebsocketProxySet []*FlashblocksWebsocketProxy

+ func NewFlashblocksWebsocketProxySet(inner []stack.FlashblocksWebsocketProxy) FlashblocksWebsocketProxySet

type Funder

+ func (f *Funder) FundNoWait(wallet *EOA, amount eth.ETH)

type L2CLNode

+ func (cl *L2CLNode) AwaitMinL1Processed(minL1 uint64)

+ func (cl *L2CLNode) ID() stack.L2CLNodeID

+ func (cl *L2CLNode) VerifySafeHeadDatabaseMatches(sourceOfTruth *L2CLNode, args ...func(opts *safeHeadDbMatchOpts))

type L2ELNode

+ func (el *L2ELNode) ID() stack.L2ELNodeID

+ func (el *L2ELNode) PeerWith(peer *L2ELNode)

+ func (el *L2ELNode) Start()

+ func (el *L2ELNode) Stop()

type L2Network

+ func (n *L2Network) DepositContractAddr() common.Address

+ func (n *L2Network) L2ELNodes() []*L2ELNode

+ type ProvenWithdrawalParameters struct

+ Data []byte

+ DisputeGameAddress common.Address

+ DisputeGameIndex *big.Int

+ GasLimit *big.Int

+ Nonce *big.Int

+ OutputRootIndex *big.Int

+ OutputRootProof bindings.OutputRootProof

+ Sender common.Address

+ SuperRootProof *bindings.SuperRootProof

+ Target common.Address

+ Value *big.Int

+ WithdrawalProof [][]byte

+ type StandardBridge struct

+ func NewStandardBridge(t devtest.T, l2Network *L2Network, supervisor *Supervisor, l1EL *L1ELNode) *StandardBridge

+ func (b *StandardBridge) Deposit(amount eth.ETH, from *EOA) Deposit

+ func (b *StandardBridge) DisputeGameFinalityDelay() time.Duration

+ func (b *StandardBridge) GameResolutionDelay() time.Duration

+ func (b *StandardBridge) InitiateWithdrawal(amount eth.ETH, from *EOA) *Withdrawal

+ func (b *StandardBridge) RespectedGameType() uint32

+ func (b *StandardBridge) UsesSuperRoots() bool

+ func (b *StandardBridge) WithdrawalDelay() time.Duration

type Supervisor

+ func (s *Supervisor) AwaitMinCrossSafeTimestamp(timestamp uint64)

+ type Withdrawal struct

+ func (w *Withdrawal) Finalize(user *EOA)

+ func (w *Withdrawal) FinalizeGasCost() eth.ETH

+ func (w *Withdrawal) InitiateGasCost() eth.ETH

+ func (w *Withdrawal) Prove(user *EOA)

+ func (w *Withdrawal) ProveGasCost() eth.ETH

+ func (w *Withdrawal) WaitForDisputeGameResolved()

v1.13.4

Jun 17, 2025

Changes in this version

+ const SaltEnvVar

type CheckFunc

+ func LaggedFn(baseNode, refNode SyncStatusProvider, log log.Logger, ctx context.Context, ...) CheckFunc

+ func MatchedFn(baseNode, refNode SyncStatusProvider, log log.Logger, ctx context.Context, ...) CheckFunc

+ type Conductor struct

+ func NewConductor(inner stack.Conductor) *Conductor

+ func (c *Conductor) Escape() stack.Conductor

+ func (c *Conductor) FetchClusterMembership() *consensus.ClusterMembership

+ func (c *Conductor) FetchLeader() *consensus.ServerInfo

+ func (c *Conductor) FetchPaused() bool

+ func (c *Conductor) FetchSequencerHealthy() bool

+ func (c *Conductor) IsLeader() bool

+ func (c *Conductor) String() string

+ func (c *Conductor) TransferLeadershipTo(targetLeaderInfo consensus.ServerInfo)

+ type ConductorSet []*Conductor

+ func NewConductorSet(inner []stack.Conductor) ConductorSet

type EOA

+ func (u *EOA) AsEL(el ELNode) *EOA

+ func (u *EOA) GetBalance() eth.ETH

+ func (u *EOA) PendingNonce() uint64

+ func (u *EOA) SendPackedExecMessages(dependOn *txintent.IntentTx[*txintent.MultiTrigger, *txintent.InteropOutput]) (*txintent.IntentTx[*txintent.MultiTrigger, *txintent.InteropOutput], ...)

+ func (u *EOA) SendPackedRandomInitMessages(rng *rand.Rand, eventLoggerAddress common.Address) (*txintent.IntentTx[*txintent.MultiTrigger, *txintent.InteropOutput], ...)

+ func (u *EOA) VerifyBalanceAtLeast(v eth.ETH)

+ func (u *EOA) WaitForBalance(v eth.ETH)

+ type FlashblocksBuilderNode struct

+ func NewFlashblocksBuilderNode(inner stack.FlashblocksBuilderNode) *FlashblocksBuilderNode

+ func (c *FlashblocksBuilderNode) Escape() stack.FlashblocksBuilderNode

+ func (c *FlashblocksBuilderNode) String() string

+ type FlashblocksBuilderSet []*FlashblocksBuilderNode

+ func NewFlashblocksBuilderSet(inner []stack.FlashblocksBuilderNode) FlashblocksBuilderSet

type Funder

+ func (f *Funder) Fund(wallet *EOA, amount eth.ETH) eth.ETH

+ func (f *Funder) FundAtLeast(wallet *EOA, amount eth.ETH) eth.ETH

+ func (f *Funder) NewFundedEOAs(count int, amount eth.ETH) []*EOA

type Key

+ func (a *Key) Priv() *ecdsa.PrivateKey

type L1ELNode

+ func (el *L1ELNode) BlockRefByLabel(label eth.BlockLabel) eth.L1BlockRef

+ func (el *L1ELNode) BlockRefByNumber(number uint64) eth.L1BlockRef

+ func (el *L1ELNode) EstimateBlockTime() time.Duration

+ func (el *L1ELNode) EthClient() apis.EthClient

+ func (el *L1ELNode) ReorgTriggered(target eth.L1BlockRef, attempts int)

+ func (el *L1ELNode) ReorgTriggeredFn(target eth.L1BlockRef, attempts int) CheckFunc

+ func (el *L1ELNode) TransactionTimeout() time.Duration

+ func (el L1ELNode) IsCanonical(ref eth.BlockID) bool

+ func (el L1ELNode) WaitForBlockNumber(targetBlock uint64) eth.BlockRef

+ func (el L1ELNode) WaitForOnline()

type L1Network

+ func (n *L1Network) PrintChain()

+ func (n *L1Network) WaitForOnline()

type L2Batcher

+ func (b *L2Batcher) Start()

+ func (b *L2Batcher) Stop()

type L2CLNode

+ func (cl *L2CLNode) AdvancedFn(lvl types.SafetyLevel, delta uint64, attempts int) CheckFunc

+ func (cl *L2CLNode) ChainSyncStatus(chainID eth.ChainID, lvl types.SafetyLevel) eth.BlockID

+ func (cl *L2CLNode) ConnectPeer(peer *L2CLNode)

+ func (cl *L2CLNode) Lagged(refNode SyncStatusProvider, lvl types.SafetyLevel, attempts int, ...)

+ func (cl *L2CLNode) LaggedFn(refNode SyncStatusProvider, lvl types.SafetyLevel, attempts int, ...) CheckFunc

+ func (cl *L2CLNode) Matched(refNode SyncStatusProvider, lvl types.SafetyLevel, attempts int)

+ func (cl *L2CLNode) MatchedFn(refNode SyncStatusProvider, lvl types.SafetyLevel, attempts int) CheckFunc

+ func (cl *L2CLNode) NotAdvanced(lvl types.SafetyLevel, attempts int)

+ func (cl *L2CLNode) NotAdvancedFn(lvl types.SafetyLevel, attempts int) CheckFunc

+ func (cl *L2CLNode) ReachedFn(lvl types.SafetyLevel, target uint64, attempts int) CheckFunc

+ func (cl *L2CLNode) ReachedRef(lvl types.SafetyLevel, target eth.BlockID, attempts int)

+ func (cl *L2CLNode) ReachedRefFn(lvl types.SafetyLevel, target eth.BlockID, attempts int) CheckFunc

+ func (cl *L2CLNode) Rewinded(lvl types.SafetyLevel, delta uint64, attempts int)

+ func (cl *L2CLNode) RewindedFn(lvl types.SafetyLevel, delta uint64, attempts int) CheckFunc

+ func (cl *L2CLNode) StartSequencer()

+ func (cl *L2CLNode) StopSequencer() common.Hash

type L2ELNode

+ func (el *L2ELNode) Advanced(label eth.BlockLabel, block uint64)

+ func (el *L2ELNode) AdvancedFn(label eth.BlockLabel, block uint64) CheckFunc

+ func (el *L2ELNode) NotAdvanced(label eth.BlockLabel)

+ func (el *L2ELNode) NotAdvancedFn(label eth.BlockLabel) CheckFunc

+ func (el *L2ELNode) ReorgTriggered(target eth.L2BlockRef, attempts int)

+ func (el *L2ELNode) ReorgTriggeredFn(target eth.L2BlockRef, attempts int) CheckFunc

+ func (el *L2ELNode) TransactionTimeout() time.Duration

+ func (el L2ELNode) IsCanonical(ref eth.BlockID) bool

+ func (el L2ELNode) WaitForBlockNumber(targetBlock uint64) eth.BlockRef

+ func (el L2ELNode) WaitForOnline()

type L2Network

+ func (n *L2Network) DisputeGameFactoryProxyAddr() common.Address

+ func (n *L2Network) IsActivated(timestamp uint64) bool

+ func (n *L2Network) PublicRPC() *L2ELNode

type Supervisor

+ func (s *Supervisor) AddManagedL2CL(cl *L2CLNode)

+ func (s *Supervisor) AwaitMinL1(minL1 uint64)

+ func (s *Supervisor) ChainSyncStatus(chainID eth.ChainID, lvl types.SafetyLevel) eth.BlockID

+ func (s *Supervisor) FetchSuperRootAtTimestamp(timestamp uint64) eth.SuperRootResponse

+ func (s *Supervisor) Start()

+ func (s *Supervisor) Stop()

+ func (s *Supervisor) WaitForL2HeadToAdvance(chainID eth.ChainID, delta uint64, lvl types.SafetyLevel, attempts int)

+ func (s *Supervisor) WaitForL2HeadToAdvanceTo(chainID eth.ChainID, lvl types.SafetyLevel, blockID eth.BlockID)

+ func (s *Supervisor) WaitForUnsafeHeadToAdvance(chainID eth.ChainID, delta uint64)

+ type SyncStatusProvider interface

+ ChainSyncStatus func(chainID eth.ChainID, lvl types.SafetyLevel) eth.BlockID

+ String func() string

+ type TestSequencer struct

+ func NewTestSequencer(inner stack.TestSequencer) *TestSequencer

+ func (s *TestSequencer) Escape() stack.TestSequencer

+ func (s *TestSequencer) String() string

v1.13.3

May 15, 2025

Changes in this version

+ const DefaultTimeout

+ func CheckAll(t devtest.T, checks ...CheckFunc)

+ func WithAllLocalUnsafeHeadsAdvancedBy(blocks uint64) func(cfg *VerifySyncStatusConfig)

+ type CheckFunc func() error

+ type Cluster struct

+ func NewCluster(inner stack.Cluster) *Cluster

+ func (c *Cluster) Escape() stack.Cluster

+ func (c *Cluster) String() string

+ type ELNode interface

+ ChainID func() eth.ChainID

+ type EOA struct

+ func NewEOA(key *Key, el ELNode) *EOA

+ func (u *EOA) Address() common.Address

+ func (u *EOA) ChainID() eth.ChainID

+ func (u *EOA) DeployEventLogger() common.Address

+ func (u *EOA) Key() *Key

+ func (u *EOA) Plan() txplan.Option

+ func (u *EOA) PlanTransfer(to common.Address, amount eth.ETH) txplan.Option

+ func (u *EOA) SendExecMessage(initIntent *txintent.IntentTx[*txintent.InitTrigger, *txintent.InteropOutput], ...) (*txintent.IntentTx[*txintent.ExecTrigger, *txintent.InteropOutput], ...)

+ func (u *EOA) SendInitMessage(trigger *txintent.InitTrigger) (*txintent.IntentTx[*txintent.InitTrigger, *txintent.InteropOutput], ...)

+ func (u *EOA) String() string

+ func (u *EOA) Transact(opts ...txplan.Option) *txplan.PlannedTx

+ func (u *EOA) Transfer(to common.Address, amount eth.ETH) *txplan.PlannedTx

+ func (u *EOA) VerifyBalanceExact(v eth.ETH)

+ func (u *EOA) VerifyBalanceLessThan(v eth.ETH)

+ type Faucet struct

+ func NewFaucet(inner stack.Faucet) *Faucet

+ func (f *Faucet) Escape() stack.Faucet

+ func (f *Faucet) Fund(addr common.Address, amount eth.ETH)

+ func (f *Faucet) String() string

+ type Funder struct

+ func NewFunder(w *HDWallet, f *Faucet, el ELNode) *Funder

+ func (f *Funder) NewFundedEOA(amount eth.ETH) *EOA

+ type HDWallet struct

+ func NewHDWallet(t devtest.T, mnemonic string, startIndex uint64) *HDWallet

+ func (w *HDWallet) NewEOA(el ELNode) *EOA

+ func (w *HDWallet) NewKey() *Key

+ func (w *HDWallet) String() string

+ type Key struct

+ func NewKey(t devtest.T, priv *ecdsa.PrivateKey) *Key

+ func (a *Key) Address() common.Address

+ func (a *Key) Plan() txplan.Option

+ func (a *Key) String() string

+ func (a *Key) User(el ELNode) *EOA

+ type L1CLNode struct

+ func NewL1CLNode(inner stack.L1CLNode) *L1CLNode

+ func (cl *L1CLNode) Escape() stack.L1CLNode

+ func (cl *L1CLNode) String() string

+ type L1ELNode struct

+ func NewL1ELNode(inner stack.L1ELNode) *L1ELNode

+ func (el *L1ELNode) Escape() stack.L1ELNode

+ func (el *L1ELNode) String() string

+ func (el L1ELNode) ChainID() eth.ChainID

+ func (el L1ELNode) WaitForBlock()

+ type L1Network struct

+ func NewL1Network(inner stack.L1Network) *L1Network

+ func (n *L1Network) ChainID() eth.ChainID

+ func (n *L1Network) Escape() stack.L1Network

+ func (n *L1Network) String() string

+ func (n *L1Network) WaitForBlock()

+ type L2Batcher struct

+ func NewL2Batcher(inner stack.L2Batcher) *L2Batcher

+ func (b *L2Batcher) ActivityAPI() apis.BatcherActivity

+ func (b *L2Batcher) Escape() stack.L2Batcher

+ func (b *L2Batcher) String() string

+ type L2CLNode struct

+ func NewL2CLNode(inner stack.L2CLNode, control stack.ControlPlane, chainID eth.ChainID) *L2CLNode

+ func (cl *L2CLNode) Advanced(lvl types.SafetyLevel, delta uint64, attempts int) CheckFunc

+ func (cl *L2CLNode) ChainID() eth.ChainID

+ func (cl *L2CLNode) DisconnectPeer(peer *L2CLNode)

+ func (cl *L2CLNode) Escape() stack.L2CLNode

+ func (cl *L2CLNode) HeadBlockRef(lvl types.SafetyLevel) eth.L2BlockRef

+ func (cl *L2CLNode) PeerInfo() *apis.PeerInfo

+ func (cl *L2CLNode) Peers() *apis.PeerDump

+ func (cl *L2CLNode) Reached(lvl types.SafetyLevel, target uint64, attempts int) CheckFunc

+ func (cl *L2CLNode) SafeL2BlockRef() eth.L2BlockRef

+ func (cl *L2CLNode) Start()

+ func (cl *L2CLNode) Stop()

+ func (cl *L2CLNode) String() string

+ func (cl *L2CLNode) SyncStatus() *eth.SyncStatus

+ type L2Challenger struct

+ func NewL2Challenger(inner stack.L2Challenger) *L2Challenger

+ func (c *L2Challenger) Escape() stack.L2Challenger

+ func (c *L2Challenger) String() string

+ type L2ELNode struct

+ func NewL2ELNode(inner stack.L2ELNode) *L2ELNode

+ func (el *L2ELNode) Advance(label eth.BlockLabel, block uint64) CheckFunc

+ func (el *L2ELNode) BlockRefByLabel(label eth.BlockLabel) eth.BlockRef

+ func (el *L2ELNode) BlockRefByNumber(num uint64) eth.BlockRef

+ func (el *L2ELNode) DoesNotAdvance(label eth.BlockLabel) CheckFunc

+ func (el *L2ELNode) Escape() stack.L2ELNode

+ func (el *L2ELNode) String() string

+ func (el L2ELNode) ChainID() eth.ChainID

+ func (el L2ELNode) WaitForBlock()

+ type L2Network struct

+ func NewL2Network(inner stack.L2Network) *L2Network

+ func (n *L2Network) AwaitActivation(t devtest.T, forkTimestamp *uint64) eth.BlockRef

+ func (n *L2Network) CatchUpTo(o *L2Network)

+ func (n *L2Network) ChainID() eth.ChainID

+ func (n *L2Network) Escape() stack.L2Network

+ func (n *L2Network) LatestBlockBeforeTimestamp(t devtest.T, timestamp uint64) eth.BlockRef

+ func (n *L2Network) PrintChain()

+ func (n *L2Network) String() string

+ func (n *L2Network) UnsafeHeadRef() eth.BlockRef

+ func (n *L2Network) WaitForBlock()

+ type L2Proposer struct

+ func NewL2Proposer(inner stack.L2Proposer) *L2Proposer

+ func (p *L2Proposer) Escape() stack.L2Proposer

+ func (p *L2Proposer) String() string

+ type Sequencer struct

+ func NewSequencer(inner stack.Sequencer) *Sequencer

+ func (s *Sequencer) Escape() stack.Sequencer

+ func (s *Sequencer) String() string

+ type Superchain struct

+ func NewSuperchain(inner stack.Superchain) *Superchain

+ func (s *Superchain) Escape() stack.Superchain

+ func (s *Superchain) String() string

+ type Supervisor struct

+ func NewSupervisor(inner stack.Supervisor) *Supervisor

+ func (s *Supervisor) AdvancedL2Head(chainID eth.ChainID, delta uint64, lvl types.SafetyLevel, attempts int)

+ func (s *Supervisor) AdvancedSafeHead(chainID eth.ChainID, block uint64, attempts int)

+ func (s *Supervisor) AdvancedUnsafeHead(chainID eth.ChainID, block uint64)

+ func (s *Supervisor) Escape() stack.Supervisor

+ func (s *Supervisor) FetchSyncStatus() eth.SupervisorSyncStatus

+ func (s *Supervisor) L2HeadBlockID(chainID eth.ChainID, lvl types.SafetyLevel) eth.BlockID

+ func (s *Supervisor) SafeBlockID(chainID eth.ChainID) eth.BlockID

+ func (s *Supervisor) String() string

+ func (s *Supervisor) VerifySyncStatus(opts ...func(config *VerifySyncStatusConfig))

+ type VerifySyncStatusConfig struct

+ AllUnsafeHeadsAdvance uint64

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