dsl

package

Go to main page

Versions in this module

v1

v1.18.1

May 14, 2026

Changes in this version

type Supernode

+ func (s *Supernode) AwaitFullyProcessedL1(targetL1 uint64)

v1.18.0

May 6, 2026

Changes in this version

+ type ChainBlockProvider interface

+ ChainBlockID func(chainID eth.ChainID, number uint64) (eth.BlockID, error)

type CheckFunc

+ func InSyncFn(node1, node2 SyncStatusProvider, log log.Logger, ctx context.Context, ...) CheckFunc

type L2CLNode

+ func (cl *L2CLNode) ChainBlockID(chainID eth.ChainID, number uint64) (eth.BlockID, error)

+ func (cl *L2CLNode) InSync(other SyncStatusProvider, lvl types.SafetyLevel, attempts int)

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

+ func (cl *L2CLNode) LocalGameInputs(agreedBlock, claimBlock uint64) *utils.LocalGameInputs

type L2ELNode

+ func (el *L2ELNode) ChainBlockID(chainID eth.ChainID, number uint64) (eth.BlockID, error)

+ func (el *L2ELNode) InSync(other SyncStatusProvider, lvl suptypes.SafetyLevel, attempts int)

+ func (el *L2ELNode) InSyncFn(other SyncStatusProvider, lvl suptypes.SafetyLevel, attempts int) CheckFunc

v1.17.0

Apr 28, 2026

v1.16.13

Apr 16, 2026

v1.16.12

Apr 9, 2026

v1.16.11

Apr 1, 2026

v1.16.10

Mar 25, 2026

v1.16.9

Mar 18, 2026

v1.16.7

Feb 19, 2026

Changes in this version

type L2CLNode

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

type Supernode

+ func (s *Supernode) ID() stack.SupernodeID

v1.16.6

Jan 19, 2026

v1.16.5

Jan 13, 2026

v1.16.4

Dec 18, 2025

v1.16.3

Dec 4, 2025

Changes in this version

+ 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

v1.16.2

Nov 14, 2025

v1.16.1

Nov 4, 2025

v1.16.0

Oct 28, 2025

v1.14.3

Oct 23, 2025

v1.14.1

Oct 8, 2025

v1.14.0

Oct 7, 2025

v1.13.7

Sep 19, 2025

v1.13.6

Sep 2, 2025

Changes in this version

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

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

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

+ type L2NetworkProvider interface

+ L2Networks func() []*L2Network

v1.13.5

Jul 11, 2025

Changes in this version

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 L2CLNode

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

type L2ELNode

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

type ProvenWithdrawalParameters

+ OutputRootIndex *big.Int

+ SuperRootProof *bindings.SuperRootProof

v1.13.4

Jun 17, 2025

Changes in this version

+ 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

v1.13.3

May 15, 2025

Changes in this version

+ type Cluster struct

+ func NewCluster(inner stack.Cluster) *Cluster

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

+ func (c *Cluster) String() string

type L2ELNode

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

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

type L2Network

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

+ 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

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

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

v0

v0.32.0

Apr 27, 2026

Changes in this version

+ const DefaultTimeout

+ const SaltEnvVar

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

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

+ 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 MakeInvalidBlockNumber(msg suptypes.Message) suptypes.Message

+ func MakeInvalidChainID(msg suptypes.Message) suptypes.Message

+ func MakeInvalidLogIndex(msg suptypes.Message) suptypes.Message

+ func MakeInvalidOrigin(msg suptypes.Message) suptypes.Message

+ func MakeInvalidPayloadHash(msg suptypes.Message) suptypes.Message

+ func MakeInvalidTimestamp(msg suptypes.Message) suptypes.Message

+ func PrecomputeExecEventMessage(referencedMsg suptypes.Message, execChainID eth.ChainID, ...) suptypes.Message

+ 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 RunOperatorFeeTest(t devtest.T, l2Chain *L2Network, l1EL *L1ELNode, funderL1, funderL2 *Funder)

+ func SubmitExecForMessage(msg suptypes.Message, executor *EOA) *txplan.PlannedTx

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

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

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

+ type BlockRefResult struct

+ BlockRef eth.L2BlockRef

+ T devtest.T

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

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

+ type CheckFunc func() error

+ 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 Deposit struct

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

+ type DepositEOA struct

+ func (d *DepositEOA) DepositTx(to common.Address, calldata []byte) *ethtypes.Receipt

+ func (d *DepositEOA) SendInitMessage(trigger *txintent.InitTrigger) *InitMessage

+ func (d *DepositEOA) SendRandomInitMessage(rng *rand.Rand, eventLoggerAddress common.Address) *InitMessage

+ 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) ApproveToken(tokenAddr common.Address, spender common.Address, amount eth.ETH)

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

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

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

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

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

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

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

+ func (u *EOA) PendingNonce() uint64

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

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

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

+ func (u *EOA) PrepareExecTx(initMsg *InitMessage) (rawTx []byte, txHash common.Hash)

+ func (u *EOA) PrepareSameTimestampInit(rng *rand.Rand, eventLogger common.Address, expectedBlockNum uint64, ...) *SameTimestampPair

+ func (u *EOA) SendExecMessage(initMsg *InitMessage, opts ...ExecMessageOpt) *ExecMessage

+ func (u *EOA) SendInitMessage(trigger *txintent.InitTrigger) *InitMessage

+ func (u *EOA) SendInvalidExecMessage(initMsg *InitMessage) *ExecMessage

+ 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) SendRandomInitMessage(rng *rand.Rand, eventLoggerAddress common.Address, topicCount, dataLen int) *InitMessage

+ 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) VerifyBalanceAtLeast(v eth.ETH)

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

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

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

+ func (u *EOA) ViaDepositTx(l1 *EOA, l2EL *L2ELNode, l2Net *L2Network) *DepositEOA

+ func (u *EOA) WaitForBalance(v 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 ExecMessage struct

+ Init *InitMessage

+ Receipt *types.Receipt

+ Tx *txintent.IntentTx[*txintent.ExecTrigger, *txintent.InteropOutput]

+ func (m *ExecMessage) BlockHash() common.Hash

+ func (m *ExecMessage) BlockID() eth.BlockID

+ func (m *ExecMessage) BlockNumber() *big.Int

+ func (m *ExecMessage) String() string

+ func (m *ExecMessage) TxHash() common.Hash

+ type ExecMessageOpt func(*execMessageConfig)

+ func WithExpectRevert() ExecMessageOpt

+ func WithFixedGasLimit(limit uint64) ExecMessageOpt

+ 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 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 ForkchoiceUpdateResult struct

+ Err error

+ InvalidCnt int

+ Refresh func()

+ RefreshCnt int

+ Result *eth.ForkchoiceUpdatedResult

+ SyncingCnt int

+ T devtest.T

+ ValidCnt int

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

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

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

+ func (r *ForkchoiceUpdateResult) ResultAllSyncing()

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

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

+ type Funder struct

+ func NewFunder(w *HDWallet, f *Faucet, el ELNode) *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) FundNoWait(wallet *EOA, amount eth.ETH)

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

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

+ type HDWallet struct

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

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

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

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

+ func (w *HDWallet) String() string

+ 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 InitMessage struct

+ Receipt *types.Receipt

+ Tx *txintent.IntentTx[*txintent.InitTrigger, *txintent.InteropOutput]

+ func (m *InitMessage) BlockHash() common.Hash

+ func (m *InitMessage) BlockID() eth.BlockID

+ func (m *InitMessage) BlockNumber() *big.Int

+ func (m *InitMessage) String() string

+ func (m *InitMessage) TxHash() common.Hash

+ type InvalidMsgFn func(suptypes.Message) suptypes.Message

+ 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) Priv() *ecdsa.PrivateKey

+ 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) Start()

+ func (cl *L1CLNode) Stop()

+ func (cl *L1CLNode) String() string

+ type L1ELNode struct

+ func NewL1ELNode(inner stack.L1ELNode) *L1ELNode

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

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

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

+ 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) String() string

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

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

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

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

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

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

+ 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) WaitForOnline()

+ func (el L1ELNode) WaitForTime(timestamp uint64) 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 L1Network struct

+ func NewL1Network(inner stack.L1Network, primaryEL *L1ELNode, primaryCL *L1CLNode) *L1Network

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

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

+ func (n *L1Network) PrimaryCL() *L1CLNode

+ func (n *L1Network) PrimaryEL() *L1ELNode

+ func (n *L1Network) PrintChain()

+ func (n *L1Network) String() string

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

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

+ func (n *L1Network) WaitForOnline()

+ type L2Batcher struct

+ func NewL2Batcher(inner stack.L2Batcher) *L2Batcher

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

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

+ func (b *L2Batcher) Start()

+ func (b *L2Batcher) Stop()

+ func (b *L2Batcher) String() string

+ type L2CLNode struct

+ func NewL2CLNode(inner stack.L2CLNode) *L2CLNode

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

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

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

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

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

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

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

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

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

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

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

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

+ func (cl *L2CLNode) IsP2PConnected(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) ManagePeer(peer *L2CLNode)

+ 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) MatchedUnsafe(refNode SyncStatusProvider, attempts int)

+ func (cl *L2CLNode) Name() string

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

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

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

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

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

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

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

+ 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) ReachedUnsafe(target uint64, attempts int)

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

+ 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) SafeHead() *BlockRefResult

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

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

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

+ func (cl *L2CLNode) Start()

+ func (cl *L2CLNode) StartSequencer()

+ func (cl *L2CLNode) Stop()

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

+ func (cl *L2CLNode) String() string

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

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

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

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

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

+ func (cl *L2CLNode) WaitForStall(lvl types.SafetyLevel)

+ 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) Advanced(label eth.BlockLabel, block uint64)

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

+ func (el *L2ELNode) AssertExecMessageNotInBlock(execMessage *ExecMessage)

+ func (el *L2ELNode) AssertTxInBlock(blockNumber uint64, txHash common.Hash)

+ func (el *L2ELNode) AssertTxNotInBlock(blockNumber uint64, txHash common.Hash)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ 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) ReorgExact(target eth.L2BlockRef, attempts int)

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

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

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

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

+ func (el *L2ELNode) Start()

+ func (el *L2ELNode) Stop()

+ func (el *L2ELNode) String() string

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

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

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

+ 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

+ func (el *L2ELNode) WaitForReceipt(txHash common.Hash) *types.Receipt

+ func (el *L2ELNode) WaitL1OriginHash(label eth.BlockLabel, target eth.BlockID, attempts int)

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

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

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

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

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

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

+ 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) WaitForOnline()

+ func (el L2ELNode) WaitForTime(timestamp uint64) 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 struct

+ func NewL2Network(inner stack.L2Network, primaryEL *L2ELNode, primaryCL *L2CLNode, ...) *L2Network

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

+ func (n *L2Network) AwaitActivation(t devtest.T, forkName rollup.ForkName) eth.BlockID

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

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

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

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

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

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

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

+ func (n *L2Network) IsForkActive(fork forks.Name) bool

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

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

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

+ func (n *L2Network) PrimaryCL() *L2CLNode

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

+ func (n *L2Network) PrimaryL1EL() *L1ELNode

+ func (n *L2Network) PrintChain()

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

+ func (n *L2Network) String() string

+ func (n *L2Network) TimestampForBlockNum(blockNum uint64) uint64

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

+ type L2Proposer struct

+ func NewL2Proposer(inner stack.L2Proposer) *L2Proposer

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

+ func (p *L2Proposer) String() string

+ 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 NewPayloadResult struct

+ Err error

+ Status *eth.PayloadStatusV1

+ T devtest.T

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

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

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

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

+ type OPRBuilderNode struct

+ func NewOPRBuilderNode(inner stack.OPRBuilderNode) *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()

+ func (el *OPRBuilderNode) UpdateRuleSet(rulesYaml string)

+ type OPRBuilderNodeSet []*OPRBuilderNode

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

+ 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 ProvenWithdrawalParameters struct

+ Data []byte

+ DisputeGameAddress common.Address

+ DisputeGameIndex *big.Int

+ GasLimit *big.Int

+ Nonce *big.Int

+ OutputRootProof bindings.OutputRootProof

+ Sender common.Address

+ Target common.Address

+ Value *big.Int

+ WithdrawalProof [][]byte

+ type RollupBoostNode struct

+ func NewRollupBoostNode(inner stack.RollupBoostNode) *RollupBoostNode

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

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

+ type RollupBoostNodesSet []*RollupBoostNode

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

+ type SameTimestampPair struct

+ Message suptypes.Message

+ Trigger *txintent.InitTrigger

+ func (p *SameTimestampPair) SubmitExecTo(executor *EOA) *txplan.PlannedTx

+ func (p *SameTimestampPair) SubmitInit() *txplan.PlannedTx

+ func (p *SameTimestampPair) SubmitInvalidExecTo(executor *EOA) *txplan.PlannedTx

+ type StandardBridge struct

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

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

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

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

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

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

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

+ func (b *StandardBridge) PortalVersion() string

+ func (b *StandardBridge) RespectedGameType() uint32

+ func (b *StandardBridge) UsesSuperRoots() bool

+ func (b *StandardBridge) VerifyRespectedGameType(expected gameTypes.GameType)

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

+ type Supernode struct

+ func NewSupernode(inner stack.Supernode) *Supernode

+ func NewSupernodeWithTestControl(inner stack.Supernode, testControl stack.InteropTestControl) *Supernode

+ func (s *Supernode) AssertBackfillCovers(depth time.Duration, blockTime uint64, chains ...eth.ChainID)

+ func (s *Supernode) AssertSuperRootAtTimestamp(l2SequenceNumber uint64, rootClaim common.Hash)

+ func (s *Supernode) AwaitBackfillAttempts(minAttempts int32)

+ func (s *Supernode) AwaitBackfillCompleted()

+ func (s *Supernode) AwaitValidatedTimestamp(timestamp uint64)

+ func (s *Supernode) BackfillAttempts() int32

+ func (s *Supernode) EnsureInteropPaused(clA, clB *L2CLNode, pauseOffset uint64) uint64

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

+ func (s *Supernode) Name() string

+ func (s *Supernode) PauseInterop(ts uint64)

+ func (s *Supernode) QueryAPI() apis.SupernodeQueryAPI

+ func (s *Supernode) RestartInterop(wipeLogsDBs bool)

+ func (s *Supernode) ResumeInterop()

+ func (s *Supernode) String() string

+ func (s *Supernode) SuperRootAtTimestamp(timestamp uint64) eth.SuperRootAtTimestampResponse

+ type Supervisor struct

+ func NewSupervisor(inner stack.Supervisor) *Supervisor

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

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

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

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

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

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

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

+ 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) Start()

+ func (s *Supervisor) Stop()

+ func (s *Supervisor) String() string

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

+ 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 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 TestSequencer struct

+ func NewTestSequencer(inner stack.TestSequencer) *TestSequencer

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

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

+ func (s *TestSequencer) SequenceBlockWithTxs(t devtest.T, chainID eth.ChainID, parent common.Hash, rawTxs [][]byte)

+ func (s *TestSequencer) String() string

+ type VaultBalances struct

+ BaseFeeVault *big.Int

+ L1FeeVault *big.Int

+ OperatorVault *big.Int

+ SequencerVault *big.Int

+ type VerifySyncStatusConfig struct

+ AllUnsafeHeadsAdvance uint64

+ type Withdrawal struct

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

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

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

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

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

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

+ func (w *Withdrawal) WaitForDisputeGameResolved()

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