dsl

package
v1.19.2 Latest Latest
Warning

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

 Go to latest Published: Jun 26, 2026 License: MIT Imports: 67 Imported by: 1

Documentation

Overview

Package dsl provides DSL (domain specific language) to interact with a devstack system.

Each component in the devstack has a DSL wrapper. The wrapper itself does not have any state, and may be recreated or shallow-copied.

Each DSL wrapper provides an Escape method, in case the DSL is not sufficient for a given use-case. The Escape method is a temporary compromise to allow more incremental development of and migration to the DSL. It should be avoided whenever possible and will be removed in the future.

Index

Constants

View Source 
const DefaultTimeout = 30 * time.Second
View Source 
const (
	SaltEnvVar = "DEVSTACK_KEYS_SALT"
)

Variables

This section is empty.

Functions

func CalculateFjordL1Cost 

func CalculateFjordL1Cost(ctx context.Context, client apis.EthClient, rollupCostData types.RollupCostData, blockHash common.Hash) (*big.Int, error)

CalculateFjordL1Cost calculates L1 cost using Fjord formula with block-specific L1 state

func CheckAll 

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

func CheckForChainFork 

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

CheckForChainFork checks that the L2 chain has not forked now, and returns a function that check again (to be called at the end of the test). An error is returned from this function (and the returned function) if a chain fork has been detected.

func CreateUnsignedTransactionFromSigned 

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

CreateUnsignedTransactionFromSigned creates an unsigned transaction from a signed one

func FindSignedTransactionFromReceipt 

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

FindSignedTransactionFromReceipt finds the signed transaction from a receipt and block

func MakeInvalidBlockNumber 

func MakeInvalidBlockNumber(msg messages.Message) messages.Message

MakeInvalidBlockNumber returns a copy of the message with an incremented block number.

func MakeInvalidChainID 

func MakeInvalidChainID(msg messages.Message) messages.Message

MakeInvalidChainID returns a copy of the message with an incremented chain ID.

func MakeInvalidLogIndex 

func MakeInvalidLogIndex(msg messages.Message) messages.Message

MakeInvalidLogIndex returns a copy of the message with an incremented log index.

func MakeInvalidOrigin 

func MakeInvalidOrigin(msg messages.Message) messages.Message

MakeInvalidOrigin returns a copy of the message with an incremented origin address.

func MakeInvalidPayloadHash 

func MakeInvalidPayloadHash(msg messages.Message) messages.Message

MakeInvalidPayloadHash returns a copy of the message with an incremented payload hash.

func MakeInvalidTimestamp 

func MakeInvalidTimestamp(msg messages.Message) messages.Message

MakeInvalidTimestamp returns a copy of the message with an incremented timestamp.

func PrecomputeExecEventMessage 

func PrecomputeExecEventMessage(
	referencedMsg messages.Message,
	execChainID eth.ChainID,
	expectedBlockNum uint64,
	expectedLogIdx uint32,
	expectedTimestamp uint64,
) messages.Message

PrecomputeExecEventMessage computes the messages.Message that a CrossL2Inbox ExecutingMessage event will produce when executing the given referenced message. This allows precomputing exec-referencing-exec chains before any blocks are built.

func ReadGasPriceOracleL1FeeAt 

func ReadGasPriceOracleL1FeeAt(ctx context.Context, client apis.EthClient, gpo *bindings.GasPriceOracle, txUnsigned []byte, blockHash common.Hash) (*big.Int, error)

ReadGasPriceOracleL1FeeAt reads the L1 fee from GasPriceOracle for an unsigned transaction evaluated against a specific L2 block hash.

func ReadGasPriceOracleL1FeeUpperBoundAt 

func ReadGasPriceOracleL1FeeUpperBoundAt(ctx context.Context, client apis.EthClient, gpo *bindings.GasPriceOracle, txLen int, blockHash common.Hash) (*big.Int, error)

ReadGasPriceOracleL1FeeUpperBoundAt reads the L1 fee upper bound for a tx length pinned to a block hash.

func RunOperatorFeeTest 

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

func SubmitExecForMessage 

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

SubmitExecForMessage returns a planned exec transaction referencing the given message. Unlike SameTimestampPair.SubmitExecTo, this can reference any message including precomputed exec event messages for exec-referencing-exec chains.

func ValidateL1FeeMatches 

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

ValidateL1FeeMatches checks that the calculated L1 fee matches the actual receipt L1 fee

func WithMinRequiredL2Block 

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

Types

type AdvancedOption added in v1.19.0 

type AdvancedOption func(*advancedOpts)

AdvancedOption configures an AdvancedFn call.

func WithTimeout added in v1.19.0 

func WithTimeout(attempts int) AdvancedOption

WithTimeout overrides AdvancedFn's default polling budget. The argument is the number of attempts; each attempt polls 2 seconds apart, so attempts*2 is the total wall-clock timeout.

type BlockRefResult 

type BlockRefResult struct {
	T        devtest.T
	BlockRef eth.L2BlockRef
}

func (*BlockRefResult) IsGenesis 

func (r *BlockRefResult) IsGenesis() *BlockRefResult

func (*BlockRefResult) NumEqualTo 

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

type ChainBlockProvider added in v1.18.0 

type ChainBlockProvider interface {
	ChainBlockID(chainID eth.ChainID, number uint64) (eth.BlockID, error)
}

type CheckFunc 

type CheckFunc func() error

func InSyncFn added in v1.18.0 

func InSyncFn(node1, node2 SyncStatusProvider, log log.Logger, ctx context.Context, lvl safety.Level, chainID eth.ChainID, attempts int) CheckFunc

InSyncFn checks that two peer nodes are converged on the same canonical chain at the given safety level. Before the retry loop it records the higher of the two starting heads as a catch-up target, so the slower node must reach at least where the faster node was when the check began. On each attempt it re-samples both heads live and considers the nodes in sync when:

  1. the slower head has reached the catch-up target; and
  2. the two head numbers differ by at most maxInSyncGap; and
  3. at the lower of the two heights, both nodes agree on the canonical block hash.

The catch-up target prevents falsely passing when both heads sit below a recent divergence point and happen to agree on shared pre-reorg history. Unlike MatchedFn this does not require both live heads to be equal in the same polling tick. Unlike a single-snapshot approach it tolerates either side reorging during the wait, since both heads are re-sampled every attempt.

func LaggedFn 

func LaggedFn(baseNode, refNode SyncStatusProvider, log log.Logger, ctx context.Context, lvl safety.Level, chainID eth.ChainID, attempts int, allowMatch bool) CheckFunc

LaggedFn returns a lambda that checks the baseNode head with given safety level is lagged with the refNode chain sync status provider Composable with other lambdas to wait in parallel

func MatchedFn 

func MatchedFn(baseNode, refNode SyncStatusProvider, log log.Logger, ctx context.Context, lvl safety.Level, chainID eth.ChainID, attempts int) CheckFunc

MatchedFn returns a lambda that checks the baseNode head with given safety level is matched with the refNode chain sync status provider Composable with other lambdas to wait in parallel

func MatchedWithProgressFn added in v1.19.0 

func MatchedWithProgressFn(baseNode, refNode SyncStatusProvider, log log.Logger, ctx context.Context, matchLvl, progressLvl safety.Level, chainID eth.ChainID, maxWait, stallTimeout time.Duration) CheckFunc

MatchedWithProgressFn returns a lambda that waits for baseNode's head at matchLvl to match refNode's head at matchLvl, while requiring baseNode to make progress on progressLvl. It is intended for sync checks where the matchLvl head can stall behind a slow but progressing pipeline — for example the CrossSafe head behind initial EL-sync, where the CL keeps receiving unsafe payloads (progressLvl == LocalUnsafe) but the safe head cannot advance until the EL completes its initial snap-sync.

The check polls every 2s and succeeds as soon as the matchLvl heads match. It fails when one of:

  • the overall maxWait elapses; or
  • baseNode's progressLvl head has not advanced for stallTimeout (i.e. the underlying gossip / forward sync has truly stalled).

Using a stall detector lets the budget be generous without papering over genuinely stuck systems. The first sample of progressLvl is taken on entry and the stall clock resets every time the progressLvl head advances.

type Conductor 

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

func NewConductor 

func NewConductor(inner stack.Conductor) *Conductor

func (*Conductor) Escape 

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

func (*Conductor) FetchClusterMembership 

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

func (*Conductor) FetchLeader 

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

func (*Conductor) FetchPaused 

func (c *Conductor) FetchPaused() bool

func (*Conductor) FetchSequencerHealthy 

func (c *Conductor) FetchSequencerHealthy() bool

func (*Conductor) IsLeader 

func (c *Conductor) IsLeader() bool

func (*Conductor) String 

func (c *Conductor) String() string

func (*Conductor) TransferLeadershipTo 

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

type ConductorSet 

type ConductorSet []*Conductor

func NewConductorSet 

func NewConductorSet(inner []stack.Conductor) ConductorSet

type Deposit 

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

func (Deposit) GasCost 

func (d Deposit) GasCost() eth.ETH

type DepositEOA 

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

DepositEOA wraps an L2 EOA so that transactions are sent via L1 deposit transactions rather than direct L2 transactions.

func (*DepositEOA) DepositTx 

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

DepositTx sends a transaction to the given address with the given calldata via OptimismPortal2 on L1. It waits for L2 derivation and returns the L2 receipt.

func (*DepositEOA) SendInitMessage 

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

SendInitMessage sends an initiating message via an L1 deposit transaction. Returns an InitMessage with InteropOutput populated from the L2 receipt, fully compatible with SendExecMessage on the receiving chain.

func (*DepositEOA) SendRandomInitMessage 

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

SendRandomInitMessage creates a random initiating message and sends it via L1 deposit.

type ELNode 

type ELNode interface {
	ChainID() eth.ChainID
	// contains filtered or unexported methods
}

type EOA 

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

EOA is an Externally-Owned-Account: an account on a specific chain that is operated by a single private key.

func NewEOA 

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

func (*EOA) Address 

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

func (*EOA) ApproveToken 

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

ApproveToken approves a spender to spend tokens on behalf of this EOA

func (*EOA) AsEL 

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

func (*EOA) ChainID 

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

func (*EOA) DeployEventLogger 

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

func (*EOA) DeployWETH 

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

func (*EOA) GetBalance 

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

Try to avoid using this method where possible, use the VerifyBalance* methods instead.

func (*EOA) GetTokenBalance 

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

GetTokenBalance returns the token balance for this EOA

func (*EOA) Key 

func (u *EOA) Key() *Key

Key returns the cross-chain user identity/key, i.e. the user but detached it from the EL node.

func (*EOA) PendingNonce 

func (u *EOA) PendingNonce() uint64

PendingNonce looks up the user nonce in the pending state.

func (*EOA) Plan 

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

Plan creates the default tx-planning options, to perform a transaction with this Key, against the connected EL node and its chain.

func (*EOA) PlanAuth 

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

func (*EOA) PlanTransfer 

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

PlanTransfer creates the tx-plan options to perform a transfer of the given amount of ETH to the given account.

func (*EOA) PrepareExecTx 

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

PrepareExecTx builds and signs an executing-message transaction referencing the given init message, but does NOT submit it. Returns the raw signed transaction bytes and tx hash. The raw bytes are suitable for injection via TestSequencer.SequenceBlockWithTxs, bypassing mempool filtering.

func (*EOA) PrepareSameTimestampInit 

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

PrepareSameTimestampInit creates a precomputed init message for same-timestamp testing. The message identifier is computed for the expected block position (blockNum, logIdx, timestamp). This allows an exec message on another chain to reference this init before it's included.

Parameters:

  • rng: random source for generating topics and data
  • eventLogger: address of the EventLogger contract that will emit the init
  • expectedBlockNum: the block number where this init is expected to be included
  • expectedLogIdx: the log index within the block (0 if first log in block)
  • expectedTimestamp: the timestamp of the block

func (*EOA) SendExecMessage 

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

func (*EOA) SendInitMessage 

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

func (*EOA) SendInvalidExecMessage 

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

SendInvalidExecMessage sends an executing message with an invalid identifier. The log index is incremented to reference a non-existent log.

func (*EOA) SendPackedExecMessages 

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

SendPackedExecMessages batches every message and validates them via a single multicall

func (*EOA) SendPackedRandomInitMessages 

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

SendPackedRandomInitMessages batches random messages and initiates them via a single multicall

func (*EOA) SendRandomInitMessage 

func (u *EOA) SendRandomInitMessage(rng *rand.Rand, eventLoggerAddress common.Address, topicCount, dataLen int) *InitMessage

SendRandomInitMessage creates and sends a random initiating message using the given event logger. topicCount specifies the number of topics (clamped to 1-4), dataLen specifies the opaque data length (minimum 1).

func (*EOA) String 

func (u *EOA) String() string

func (*EOA) Transact 

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

Transact plans and executes a tx. The success-state, as defined by the tx-plan options, is required. The resulting evaluated tx is returned.

func (*EOA) Transfer 

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

Transfer transfers the given amount of ETH to the given account, immediately.

func (*EOA) VerifyBalanceAtLeast 

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

VerifyBalanceAtLeast verifies balance >= v

func (*EOA) VerifyBalanceExact 

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

VerifyBalanceExact verifies balance == v

func (*EOA) VerifyBalanceLessThan 

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

VerifyBalanceLessThan verifies balance < v

func (*EOA) VerifyTokenBalance 

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

VerifyTokenBalance verifies the token balance matches expected amount

func (*EOA) ViaDepositTx 

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

ViaDepositTx returns a DepositEOA that sends transactions through L1 deposit transactions. The caller must fund both the L1 and L2 identities.

func (*EOA) WaitForBalance 

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

func (*EOA) WaitForTokenBalance 

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

WaitForTokenBalance waits for a specific token balance to be reached

type EcotoneFees 

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

func NewEcotoneFees 

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

func (*EcotoneFees) LogResults 

func (ef *EcotoneFees) LogResults(result EcotoneFeesValidationResult)

func (*EcotoneFees) ValidateTransaction 

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

type EcotoneFeesValidationResult 

type EcotoneFeesValidationResult struct {
	TransactionReceipt *types.Receipt
	L1Fee              *big.Int
	L2Fee              *big.Int
	BaseFee            *big.Int
	PriorityFee        *big.Int
	TotalFee           *big.Int
	VaultBalances      VaultBalances
	WalletBalanceDiff  *big.Int
	TransferAmount     *big.Int
}

type ExecMessage 

type ExecMessage struct {
	Init    *InitMessage
	Tx      *txintent.IntentTx[*txintent.ExecTrigger, *txintent.InteropOutput]
	Receipt *types.Receipt
}

ExecMessage represents an executing message that has been sent and included on chain.

func (*ExecMessage) BlockHash 

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

BlockHash returns the block hash from the receipt.

func (*ExecMessage) BlockID 

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

BlockID returns the block ID from the receipt.

func (*ExecMessage) BlockNumber 

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

BlockNumber returns the block number from the receipt.

func (*ExecMessage) String 

func (m *ExecMessage) String() string

String returns a human-readable representation of the ExecMessage.

func (*ExecMessage) TxHash 

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

TxHash returns the transaction hash from the receipt.

type ExecMessageOpt 

type ExecMessageOpt func(*execMessageConfig)

ExecMessageOpt configures the behavior of SendExecMessage.

func WithExpectRevert 

func WithExpectRevert() ExecMessageOpt

WithExpectRevert indicates the transaction should be included but revert. The receipt status is asserted to be failed, and the log-count check is skipped.

func WithFixedGasLimit 

func WithFixedGasLimit(limit uint64) ExecMessageOpt

WithFixedGasLimit sets a fixed gas limit, bypassing eth_estimateGas. Use when the transaction is expected to revert (estimation would fail).

type Faucet 

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

Faucet wraps a stack.Faucet interface for DSL operations. A Faucet is chain-specific. Note: Faucet wraps a stack component, to share faucet operations in kurtosis by hosting it as service, and prevent race-conditions with the account that sends out the faucet funds.

func NewFaucet 

func NewFaucet(inner stack.Faucet) *Faucet

NewFaucet creates a new Faucet DSL wrapper

func (*Faucet) Escape 

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

Escape returns the underlying stack.Faucet

func (*Faucet) Fund 

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

Fund funds the given address with the given amount of ETH

func (*Faucet) String 

func (f *Faucet) String() string

type FjordFees 

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

func NewFjordFees 

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

func (*FjordFees) ValidateTransaction 

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

ValidateTransaction validates the transaction and returns the validation result

type FjordFeesValidationResult 

type FjordFeesValidationResult struct {
	TransactionReceipt  *types.Receipt
	L1Fee               *big.Int
	L2Fee               *big.Int
	BaseFee             *big.Int
	PriorityFee         *big.Int
	TotalFee            *big.Int
	VaultBalances       VaultBalances
	WalletBalanceDiff   *big.Int
	TransferAmount      *big.Int
	FastLzSize          uint64
	EstimatedBrotliSize *big.Int
	OperatorFee         *big.Int
	CoinbaseDiff        *big.Int
}

type ForkchoiceUpdateResult 

type ForkchoiceUpdateResult struct {
	T          devtest.T
	Refresh    func()
	Result     *eth.ForkchoiceUpdatedResult
	ValidCnt   int // count for VALID response
	SyncingCnt int // count for SYNCING response
	InvalidCnt int // count for INVALID response
	RefreshCnt int
	Err        error
}

func (*ForkchoiceUpdateResult) IsForkchoiceUpdatedStatus 

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

func (*ForkchoiceUpdateResult) IsSyncing 

func (r *ForkchoiceUpdateResult) IsSyncing() *ForkchoiceUpdateResult

func (*ForkchoiceUpdateResult) IsValid 

func (r *ForkchoiceUpdateResult) IsValid() *ForkchoiceUpdateResult

func (*ForkchoiceUpdateResult) ResultAllSyncing 

func (r *ForkchoiceUpdateResult) ResultAllSyncing()

func (*ForkchoiceUpdateResult) Retry 

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

func (*ForkchoiceUpdateResult) WaitUntilValid 

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

type Funder 

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

func NewFunder 

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

func (*Funder) Fund 

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

func (*Funder) FundAtLeast 

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

func (*Funder) FundNoWait 

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

func (*Funder) NewFundedEOA 

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

func (*Funder) NewFundedEOAs 

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

type HDWallet 

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

HDWallet is a collection of deterministic accounts, generated from an underlying devkeys keyring, using the standard cross-chain user identities.

func NewHDWallet 

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

func NewRandomHDWallet 

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

func (*HDWallet) NewEOA 

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

NewEOA creates a new Key and wraps it with an EL node into a new EOA

func (*HDWallet) NewKey 

func (w *HDWallet) NewKey() *Key

NewKey creates a new chain-agnostic account identity

func (*HDWallet) String 

func (w *HDWallet) String() string

type HeaderProvider 

type HeaderProvider interface {
	InfoByNumber(ctx context.Context, number uint64) (eth.BlockInfo, error)
	InfoByLabel(ctx context.Context, label eth.BlockLabel) (eth.BlockInfo, error)
	InfoByHash(ctx context.Context, hash common.Hash) (eth.BlockInfo, error)
}

HeaderProvider interface for multi-client operations

type InitMessage 

type InitMessage struct {
	Tx      *txintent.IntentTx[*txintent.InitTrigger, *txintent.InteropOutput]
	Receipt *types.Receipt
}

InitMessage represents an initiating message that has been sent and included on chain.

func (*InitMessage) BlockHash 

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

BlockHash returns the block hash from the receipt.

func (*InitMessage) BlockID 

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

BlockID returns the block ID from the receipt.

func (*InitMessage) BlockNumber 

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

BlockNumber returns the block number from the receipt.

func (*InitMessage) String 

func (m *InitMessage) String() string

String returns a human-readable representation of the InitMessage.

func (*InitMessage) TxHash 

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

TxHash returns the transaction hash from the receipt.

type InvalidMsgFn 

type InvalidMsgFn func(messages.Message) messages.Message

InvalidMsgFn is a function that takes a valid message and returns an invalid copy.

type Key 

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

Key is an ethereum private key. This is a key with an address identity. The Key may be used on different chains: it is chain-agnostic.

func NewKey 

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

func (*Key) Address 

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

func (*Key) Plan 

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

Plan returns the tx-plan option to use this Key for signing of a transaction.

func (*Key) Priv 

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

func (*Key) String 

func (a *Key) String() string

func (*Key) User 

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

EOA combines this Key with an EL node into a single-chain EOA.

type L1CLNode 

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

L1CLNode wraps a stack.L1CLNode interface for DSL operations

func NewL1CLNode 

func NewL1CLNode(inner stack.L1CLNode) *L1CLNode

NewL1CLNode creates a new L1CLNode DSL wrapper

func (*L1CLNode) BeaconHTTPAddr added in v1.19.2 

func (cl *L1CLNode) BeaconHTTPAddr() string

func (*L1CLNode) Escape 

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

Escape returns the underlying stack.L1CLNode

func (*L1CLNode) Start 

func (cl *L1CLNode) Start()

func (*L1CLNode) Stop 

func (cl *L1CLNode) Stop()

func (*L1CLNode) String 

func (cl *L1CLNode) String() string

type L1ELNode 

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

L1ELNode wraps a stack.L1ELNode interface for DSL operations

func NewL1ELNode 

func NewL1ELNode(inner stack.L1ELNode) *L1ELNode

NewL1ELNode creates a new L1ELNode DSL wrapper

func (*L1ELNode) BlockRefByLabel 

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

func (*L1ELNode) BlockRefByNumber 

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

func (L1ELNode) ChainID 

func (el L1ELNode) ChainID() eth.ChainID

func (*L1ELNode) Escape 

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

Escape returns the underlying stack.L1ELNode

func (*L1ELNode) EstimateBlockTime 

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

EstimateBlockTime estimates the L1 block based on the last 1000 blocks (or since genesis, if insufficient blocks).

func (*L1ELNode) EthClient 

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

func (L1ELNode) IsCanonical 

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

func (*L1ELNode) ReorgTriggered 

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

func (*L1ELNode) ReorgTriggeredFn 

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

ReorgTriggeredFn returns a lambda that checks that a L1 reorg occurred on the expected block Composable with other lambdas to wait in parallel

func (*L1ELNode) String 

func (el *L1ELNode) String() string

func (*L1ELNode) TransactionTimeout 

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

func (L1ELNode) WaitForBlock 

func (el L1ELNode) WaitForBlock() eth.BlockRef

func (L1ELNode) WaitForBlockNumber 

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

func (L1ELNode) WaitForFinalization 

func (el L1ELNode) WaitForFinalization() eth.BlockRef

WaitForFinalization waits for the current block height to be finalized. Note that it does not ensure that the finalized block is the same as the current unsafe block (i.e., it is not reorg-aware).

func (L1ELNode) WaitForLabel 

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

func (L1ELNode) WaitForLabelRef 

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

func (L1ELNode) WaitForOnline 

func (el L1ELNode) WaitForOnline()

func (L1ELNode) WaitForTime 

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

WaitForTime waits until the chain has reached or surpassed the given timestamp.

func (L1ELNode) WaitForUnsafe 

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

func (L1ELNode) WaitForUnsafeRef 

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

type L1Network 

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

L1Network wraps a stack.L1Network interface for DSL operations

func NewL1Network 

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

NewL1Network creates a new L1Network DSL wrapper

func (*L1Network) ChainID 

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

func (*L1Network) Escape 

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

Escape returns the underlying stack.L1Network

func (*L1Network) PrimaryCL 

func (n *L1Network) PrimaryCL() *L1CLNode

func (*L1Network) PrimaryEL 

func (n *L1Network) PrimaryEL() *L1ELNode

func (*L1Network) PrintChain 

func (n *L1Network) PrintChain()

PrintChain is used for testing/debugging, it prints the blockchain hashes and parent hashes to logs, which is useful when developing reorg tests

func (*L1Network) String 

func (n *L1Network) String() string

func (*L1Network) WaitForBlock 

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

func (*L1Network) WaitForFinalization 

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

func (*L1Network) WaitForOnline 

func (n *L1Network) WaitForOnline()

type L2Batcher 

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

L2Batcher wraps a stack.L2Batcher interface for DSL operations

func NewL2Batcher 

func NewL2Batcher(inner stack.L2Batcher) *L2Batcher

NewL2Batcher creates a new L2Batcher DSL wrapper

func (*L2Batcher) ActivityAPI 

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

func (*L2Batcher) Escape 

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

Escape returns the underlying stack.L2Batcher

func (*L2Batcher) Start 

func (b *L2Batcher) Start()

func (*L2Batcher) Stop 

func (b *L2Batcher) Stop()

func (*L2Batcher) String 

func (b *L2Batcher) String() string

type L2CLNode 

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

L2CLNode wraps a stack.L2CLNode interface for DSL operations

func NewL2CLNode 

func NewL2CLNode(inner stack.L2CLNode) *L2CLNode

NewL2CLNode creates a new L2CLNode DSL wrapper

func (*L2CLNode) Advanced 

func (cl *L2CLNode) Advanced(lvl safety.Level, delta uint64, attempts int)

func (*L2CLNode) AdvancedFn 

func (cl *L2CLNode) AdvancedFn(lvl safety.Level, delta uint64, attempts int) CheckFunc

AdvancedFn returns a lambda that checks the L2CL chain head with given safety level advanced more than delta block number Composable with other lambdas to wait in parallel

func (*L2CLNode) AdvancedUnsafe 

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

func (*L2CLNode) AllHeadsAdvancedFn added in v1.19.0 

func (cl *L2CLNode) AllHeadsAdvancedFn() CheckFunc

AllHeadsAdvancedFn asserts every safety head advances from the head observed at call time, using DefaultSafetyHeadsAdvancement.

func (*L2CLNode) AllHeadsReachedFn added in v1.19.0 

func (cl *L2CLNode) AllHeadsReachedFn(snap SafetyHeads) CheckFunc

AllHeadsReachedFn asserts every safety head reaches snap + the default delta. Used to assert catch-up after a resync.

func (*L2CLNode) AppendUnsafePayloadUntilTip 

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

func (*L2CLNode) AwaitMinL1Processed 

func (cl *L2CLNode) AwaitMinL1Processed(minL1 uint64)

func (*L2CLNode) ChainBlockID added in v1.18.0 

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

func (*L2CLNode) ChainID 

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

func (*L2CLNode) ChainSyncStatus 

func (cl *L2CLNode) ChainSyncStatus(chainID eth.ChainID, lvl safety.Level) eth.BlockID

ChainSyncStatus satisfies that the L2CLNode can provide sync status per chain

func (*L2CLNode) ConnectPeer 

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

func (*L2CLNode) CurrentL1MatchedFn 

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

func (*L2CLNode) DisconnectPeer 

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

func (*L2CLNode) Escape 

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

Escape returns the underlying stack.L2CLNode

func (*L2CLNode) HeadBlockRef 

func (cl *L2CLNode) HeadBlockRef(lvl safety.Level) eth.L2BlockRef

HeadBlockRef fetches L2CL sync status and returns block ref with given safety level

func (*L2CLNode) InSync added in v1.18.0 

func (cl *L2CLNode) InSync(other SyncStatusProvider, lvl safety.Level, attempts int)

func (*L2CLNode) InSyncFn added in v1.18.0 

func (cl *L2CLNode) InSyncFn(other SyncStatusProvider, lvl safety.Level, attempts int) CheckFunc

func (*L2CLNode) IsP2PConnected 

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

func (*L2CLNode) Lagged 

func (cl *L2CLNode) Lagged(refNode SyncStatusProvider, lvl safety.Level, attempts int, allowMatch bool)

func (*L2CLNode) LaggedFn 

func (cl *L2CLNode) LaggedFn(refNode SyncStatusProvider, lvl safety.Level, attempts int, allowMatch bool) CheckFunc

LaggedFn returns a lambda that checks the L2CL chain head with given safety level is lagged with the reference chain sync status provider Composable with other lambdas to wait in parallel

func (*L2CLNode) LocalGameInputs added in v1.18.0 

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

func (*L2CLNode) ManagePeer 

func (cl *L2CLNode) ManagePeer(peer *L2CLNode)

func (*L2CLNode) Matched 

func (cl *L2CLNode) Matched(refNode SyncStatusProvider, lvl safety.Level, attempts int)

func (*L2CLNode) MatchedFn 

func (cl *L2CLNode) MatchedFn(refNode SyncStatusProvider, lvl safety.Level, attempts int) CheckFunc

MatchedFn returns a lambda that checks the L2CLNode head with given safety level is matched with the refNode chain sync status provider Composable with other lambdas to wait in parallel

func (*L2CLNode) MatchedUnsafe 

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

func (*L2CLNode) MatchedWithProgressFn added in v1.19.0 

func (cl *L2CLNode) MatchedWithProgressFn(refNode SyncStatusProvider, matchLvl, progressLvl safety.Level, maxWait, stallTimeout time.Duration) CheckFunc

MatchedWithProgressFn returns a lambda that waits for cl's matchLvl head to match refNode's matchLvl head while requiring cl to keep making progress on progressLvl. See MatchedWithProgressFn in check.go for the precise semantics. Composable with other lambdas to wait in parallel.

func (*L2CLNode) Name 

func (cl *L2CLNode) Name() string

func (*L2CLNode) NotAdvanced 

func (cl *L2CLNode) NotAdvanced(lvl safety.Level, attempts int)

func (*L2CLNode) NotAdvancedFn 

func (cl *L2CLNode) NotAdvancedFn(lvl safety.Level, attempts int) CheckFunc

func (*L2CLNode) NotAdvancedUnsafe 

func (cl *L2CLNode) NotAdvancedUnsafe(attempts int)

func (*L2CLNode) PeerInfo 

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

func (*L2CLNode) Peers 

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

func (*L2CLNode) PostUnsafePayload 

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

func (*L2CLNode) Reached 

func (cl *L2CLNode) Reached(lvl safety.Level, target uint64, attempts int)

func (*L2CLNode) ReachedFn 

func (cl *L2CLNode) ReachedFn(lvl safety.Level, target uint64, attempts int) CheckFunc

ReachedFn returns a lambda that checks the L2CL chain head with given safety level reaches the target block number Composable with other lambdas to wait in parallel

func (*L2CLNode) ReachedRef 

func (cl *L2CLNode) ReachedRef(lvl safety.Level, target eth.BlockID, attempts int)

func (*L2CLNode) ReachedRefFn 

func (cl *L2CLNode) ReachedRefFn(lvl safety.Level, target eth.BlockID, attempts int) CheckFunc

ReachedRefFn is same as Reached, but has an additional check to ensure that the block referenced is not reorged Composable with other lambdas to wait in parallel

func (*L2CLNode) ReachedTimeWithoutRegressionFn added in v1.19.0 

func (cl *L2CLNode) ReachedTimeWithoutRegressionFn(lvl safety.Level, targetTime uint64) CheckFunc

ReachedTimeWithoutRegressionFn waits for the head's block timestamp to reach targetTime, failing on any regression. Requires a non-zero baseline behind targetTime so a regression to genesis isn't vacuous (0 >= 0). Polls every 100ms; deadline is targetTime + 5min.

Uses an explicit ticker/deadline loop and returns errors through the CheckFunc contract. require.Eventuallyf would call FailNow inside the dsl.CheckAll worker goroutine, which is not safe.

func (*L2CLNode) ReachedUnsafe 

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

func (*L2CLNode) Reset 

func (cl *L2CLNode) Reset(lvl safety.Level, target eth.L2BlockRef)

func (*L2CLNode) Rewinded 

func (cl *L2CLNode) Rewinded(lvl safety.Level, delta uint64, attempts int)

func (*L2CLNode) RewindedFn 

func (cl *L2CLNode) RewindedFn(lvl safety.Level, delta uint64, attempts int) CheckFunc

RewindedFn returns a lambda that checks the L2CL chain head with given safety level rewinded more than the delta block number Composable with other lambdas to wait in parallel

func (*L2CLNode) SafeHead 

func (cl *L2CLNode) SafeHead() *BlockRefResult

func (*L2CLNode) SafeL2BlockRef 

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

func (*L2CLNode) SafetyHeads added in v1.19.0 

func (cl *L2CLNode) SafetyHeads() SafetyHeads

func (*L2CLNode) SetSequencerRecoverMode 

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

func (*L2CLNode) SignalTarget 

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

func (*L2CLNode) Start 

func (cl *L2CLNode) Start()

func (*L2CLNode) StartSequencer 

func (cl *L2CLNode) StartSequencer()

func (*L2CLNode) Stop 

func (cl *L2CLNode) Stop()

func (*L2CLNode) StopSequencer 

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

func (*L2CLNode) String 

func (cl *L2CLNode) String() string

func (*L2CLNode) SyncStatus 

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

func (*L2CLNode) UnsafeHead 

func (cl *L2CLNode) UnsafeHead() *BlockRefResult

func (*L2CLNode) VerifySafeHeadDatabaseMatches 

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

func (*L2CLNode) WaitForNonZeroUnsafeTime 

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

func (*L2CLNode) WaitForPeerDisconnected 

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

func (*L2CLNode) WaitForStall 

func (cl *L2CLNode) WaitForStall(lvl safety.Level)

awaitSafeHeadsStalled waits until every node's safe head has stopped advancing for at least 10 seconds.

type L2Challenger 

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

L2Challenger wraps a stack.L2Challenger interface for DSL operations

func NewL2Challenger 

func NewL2Challenger(inner stack.L2Challenger) *L2Challenger

NewL2Challenger creates a new L2Challenger DSL wrapper

func (*L2Challenger) Escape 

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

Escape returns the underlying stack.L2Challenger

func (*L2Challenger) String 

func (c *L2Challenger) String() string

type L2ELNode 

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

L2ELNode wraps a stack.L2ELNode interface for DSL operations

func NewL2ELNode 

func NewL2ELNode(inner stack.L2ELNode) *L2ELNode

NewL2ELNode creates a new L2ELNode DSL wrapper

func (*L2ELNode) Advanced 

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

func (*L2ELNode) AdvancedFn 

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

func (*L2ELNode) AssertExecMessageNotInBlock 

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

func (*L2ELNode) AssertTxInBlock 

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

AssertTxInBlock asserts that a transaction with the given hash does not exist in the block at the given number.

func (*L2ELNode) AssertTxNotInBlock 

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

AssertTxNotInBlock asserts that a transaction with the given hash does not exist in the block at the given number.

func (*L2ELNode) BlockRefByHash 

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

func (*L2ELNode) BlockRefByLabel 

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

func (*L2ELNode) BlockRefByNumber 

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

func (*L2ELNode) ChainBlockID added in v1.18.0 

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

func (L2ELNode) ChainID 

func (el L2ELNode) ChainID() eth.ChainID

func (*L2ELNode) ChainSyncStatus 

func (el *L2ELNode) ChainSyncStatus(chainID eth.ChainID, lvl safety.Level) eth.BlockID

func (*L2ELNode) DisconnectPeerWith 

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

func (*L2ELNode) Escape 

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

Escape returns the underlying stack.L2ELNode

func (*L2ELNode) EthClient 

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

func (*L2ELNode) FinalizedHead 

func (el *L2ELNode) FinalizedHead() *BlockRefResult

func (*L2ELNode) FinishedELSync 

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

func (*L2ELNode) ForkchoiceUpdate 

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

ForkchoiceUpdate fetches FCU target hashes from the reference EL node, and FCU update with attributes

func (*L2ELNode) ForkchoiceUpdateRaw 

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

ForkchoiceUpdateRaw calls FCU with block hashes with attributes

func (*L2ELNode) GasLimitAtBlock added in v1.19.1 

func (el *L2ELNode) GasLimitAtBlock(num uint64) uint64

GasLimitAtBlock returns the gas limit of the block at the given number.

func (*L2ELNode) InSync added in v1.18.0 

func (el *L2ELNode) InSync(other SyncStatusProvider, lvl safety.Level, attempts int)

func (*L2ELNode) InSyncFn added in v1.18.0 

func (el *L2ELNode) InSyncFn(other SyncStatusProvider, lvl safety.Level, attempts int) CheckFunc

func (L2ELNode) IsCanonical 

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

func (*L2ELNode) L1OriginReachedFn 

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

L1OriginReachedFn returns a lambda that waits for the L1 origin to reach the target block number.

func (*L2ELNode) Matched 

func (el *L2ELNode) Matched(refNode SyncStatusProvider, lvl safety.Level, attempts int)

func (*L2ELNode) MatchedFn 

func (el *L2ELNode) MatchedFn(refNode SyncStatusProvider, lvl safety.Level, attempts int) CheckFunc

func (*L2ELNode) MatchedUnsafe 

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

func (*L2ELNode) NewPayload 

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

NewPayload fetches payload for target number from the reference EL Node, and inserts the payload

func (*L2ELNode) NewPayloadRaw 

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

func (*L2ELNode) NotAdvanced 

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

func (*L2ELNode) NotAdvancedFn 

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

func (*L2ELNode) NotAdvancedUnsafe 

func (el *L2ELNode) NotAdvancedUnsafe(attempts int)

func (*L2ELNode) PayloadByNumber 

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

func (*L2ELNode) PeerWith 

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

func (*L2ELNode) Reached 

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

func (*L2ELNode) ReachedFn 

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

func (*L2ELNode) ReorgExact 

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

func (*L2ELNode) ReorgExactFn 

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

ReorgExactFn returns a lambda that checks that a L2 reorg occurred on the exact target L2 block. If an L2 block prior to target was reorged, this function will block forever. Composable with other lambdas to wait in parallel.

func (*L2ELNode) ReorgTriggered 

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

func (*L2ELNode) ReorgTriggeredFn 

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

ReorgTriggeredFn returns a lambda that checks that a L2 reorg occurred on or before the expected block Composable with other lambdas to wait in parallel

func (*L2ELNode) ResendUntilSafe added in v1.19.1 

func (el *L2ELNode) ResendUntilSafe(makeTx func() *txplan.PlannedTx, sendAttempts, pollPerAttempt int) (uint64, common.Hash)

ResendUntilSafe broadcasts a transaction from makeTx and waits for it to derive onto this node's irreversible safe chain, retrying with a newly built transaction whenever a broadcast fails to settle. It returns the block number and hash where the transaction landed, and fails the test if nothing settles within sendAttempts broadcasts of pollPerAttempt seconds each.

makeTx is invoked once per send attempt and must return a transaction ready to broadcast. It does not have to build a brand-new transaction every time, but it is responsible for nonce safety across retries: a previous attempt's broadcast may still be pending or have been orphaned, so reusing an account naively can hit "nonce too low" or underpriced-replacement rejections. Returning a transaction from a freshly funded account each call is the simplest way to keep nonce space clean.

func (*L2ELNode) SafeHead 

func (el *L2ELNode) SafeHead() *BlockRefResult

func (*L2ELNode) Start 

func (el *L2ELNode) Start()

func (*L2ELNode) Stop 

func (el *L2ELNode) Stop()

func (*L2ELNode) String 

func (el *L2ELNode) String() string

func (*L2ELNode) TransactionTimeout 

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

func (*L2ELNode) UnsafeHead 

func (el *L2ELNode) UnsafeHead() *BlockRefResult

func (*L2ELNode) VerifyWithdrawalHashChangedIn 

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

VerifyWithdrawalHashChangedIn verifies that the withdrawal hash changed between the parent and current block. This is used to verify that the withdrawal hash changed in the block where the withdrawal was initiated.

Some EL backends, such as op-reth, can briefly lag in serving historical proofs for a block that has already been inserted. Retry until the proof backend catches up instead of failing immediately.

func (L2ELNode) WaitForBlock 

func (el L2ELNode) WaitForBlock() eth.BlockRef

func (L2ELNode) WaitForBlockNumber 

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

func (L2ELNode) WaitForFinalization 

func (el L2ELNode) WaitForFinalization() eth.BlockRef

WaitForFinalization waits for the current block height to be finalized. Note that it does not ensure that the finalized block is the same as the current unsafe block (i.e., it is not reorg-aware).

func (L2ELNode) WaitForLabel 

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

func (L2ELNode) WaitForLabelRef 

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

func (L2ELNode) WaitForOnline 

func (el L2ELNode) WaitForOnline()

func (*L2ELNode) WaitForPendingNonceMatch 

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

WaitForPendingNonceMatch waits for the pending nonce of an account to match the reference nonce

func (*L2ELNode) WaitForPendingNonceMatchFn 

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

WaitForPendingNonceMatchFn returns a lambda that waits for the pending nonce of an account to match the provided reference nonce

func (*L2ELNode) WaitForReceipt 

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

WaitForReceipt waits for a transaction receipt to be available, retrying until found or timeout.

func (L2ELNode) WaitForTime 

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

WaitForTime waits until the chain has reached or surpassed the given timestamp.

func (L2ELNode) WaitForUnsafe 

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

func (L2ELNode) WaitForUnsafeRef 

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

func (*L2ELNode) WaitL1OriginHash 

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

WaitL1OriginHash polls until the L2 chain at the given label references the target L1 block. If the head's L1 origin has advanced past the target number (e.g. due to a large batch), it walks back through L2 blocks to find one with the target L1 origin number and checks its hash.

func (*L2ELNode) WaitL1OriginReached 

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

WaitL1OriginReached waits for the L1 origin to reach the target block number.

type L2Network 

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

L2Network wraps a stack.L2Network interface for DSL operations

func NewL2Network 

func NewL2Network(inner stack.L2Network, primaryEL *L2ELNode, primaryCL *L2CLNode, primaryL1 *L1ELNode, archiveEL *L2ELNode, publicRPC *L2ELNode) *L2Network

NewL2Network creates a new L2Network DSL wrapper

func (*L2Network) ArchiveEL 

func (n *L2Network) ArchiveEL() *L2ELNode

func (*L2Network) AwaitActivation 

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

AwaitActivation awaits the fork activation time, and returns the activation block

func (*L2Network) CatchUpTo 

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

func (*L2Network) ChainID 

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

func (*L2Network) DepositContractAddr 

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

func (*L2Network) DeriveData 

func (n *L2Network) DeriveData(blocks int) (channels []derive.ChannelID, channelFrames map[derive.ChannelID][]derive.Frame, l2Txs map[common.Address][]*ethtypes.Transaction)

func (*L2Network) DisputeGameFactoryProxyAddr 

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

func (*L2Network) Escape 

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

Escape returns the underlying stack.L2Network

func (*L2Network) IsActivated 

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

IsActivated checks if a given fork has been activated

func (*L2Network) IsForkActive 

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

func (*L2Network) IsForkActiveAt 

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

func (*L2Network) L2ELNodes 

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

func (*L2Network) LatestBlockBeforeTimestamp 

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

LatestBlockBeforeTimestamp finds the latest block before fork activation

func (*L2Network) PrimaryCL 

func (n *L2Network) PrimaryCL() *L2CLNode

func (*L2Network) PrimaryEL 

func (n *L2Network) PrimaryEL() *L2ELNode

func (*L2Network) PrimaryL1EL 

func (n *L2Network) PrimaryL1EL() *L1ELNode

func (*L2Network) PrintChain 

func (n *L2Network) PrintChain()

PrintChain is used for testing/debugging, it prints the blockchain hashes and parent hashes to logs, which is useful when developing reorg tests

func (*L2Network) PublicRPC 

func (n *L2Network) PublicRPC() *L2ELNode

func (*L2Network) String 

func (n *L2Network) String() string

func (*L2Network) TimestampForBlockNum 

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

TimestampForBlockNum returns the timestamp for the given L2 block number.

func (*L2Network) WaitForBlock 

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

type L2Proposer 

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

L2Proposer wraps a stack.L2Proposer interface for DSL operations

func NewL2Proposer 

func NewL2Proposer(inner stack.L2Proposer) *L2Proposer

NewL2Proposer creates a new L2Proposer DSL wrapper

func (*L2Proposer) Escape 

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

Escape returns the underlying stack.L2Proposer

func (*L2Proposer) String 

func (p *L2Proposer) String() string

type MultiClient 

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

MultiClient is a simple client that checks hash consistency between underlying clients

func MultiClientForL1Network 

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

MultiClientForL1Network creates a MultiClient from an L1Network

func MultiClientForL2Network 

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

MultiClientForL2Network creates a MultiClient from an L2Network

func NewMultiClient 

func NewMultiClient(clients []HeaderProvider) *MultiClient

NewMultiClient creates a new MultiClient with the specified underlying clients

func (*MultiClient) InfoByHash 

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

InfoByHash returns block info from the first client while verifying hash consistency

func (*MultiClient) InfoByLabel 

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

InfoByLabel returns block info from the first client while verifying hash consistency

func (*MultiClient) InfoByNumber 

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

InfoByNumber returns block info from the first client while verifying hash consistency

type NewPayloadResult 

type NewPayloadResult struct {
	T      devtest.T
	Status *eth.PayloadStatusV1
	Err    error
}

func (*NewPayloadResult) IsInvalid 

func (r *NewPayloadResult) IsInvalid() *NewPayloadResult

func (*NewPayloadResult) IsPayloadStatus 

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

func (*NewPayloadResult) IsSyncing 

func (r *NewPayloadResult) IsSyncing() *NewPayloadResult

func (*NewPayloadResult) IsValid 

func (r *NewPayloadResult) IsValid() *NewPayloadResult

type OPRBuilderNode 

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

func NewOPRBuilderNode 

func NewOPRBuilderNode(inner stack.OPRBuilderNode) *OPRBuilderNode

func (*OPRBuilderNode) Escape 

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

func (*OPRBuilderNode) FlashblocksClient 

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

func (*OPRBuilderNode) Start 

func (el *OPRBuilderNode) Start()

func (*OPRBuilderNode) Stop 

func (el *OPRBuilderNode) Stop()

func (*OPRBuilderNode) String 

func (c *OPRBuilderNode) String() string

func (*OPRBuilderNode) UpdateRuleSet 

func (el *OPRBuilderNode) UpdateRuleSet(rulesYaml string)

type OPRBuilderNodeSet 

type OPRBuilderNodeSet []*OPRBuilderNode

func NewOPRBuilderNodeSet 

func NewOPRBuilderNodeSet(inner []stack.OPRBuilderNode) OPRBuilderNodeSet

type OperatorFee 

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

func NewOperatorFee 

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

func (*OperatorFee) CheckCompatibility 

func (of *OperatorFee) CheckCompatibility() bool

func (*OperatorFee) GetSystemOwner 

func (of *OperatorFee) GetSystemOwner() *EOA

func (*OperatorFee) RestoreOriginalConfig 

func (of *OperatorFee) RestoreOriginalConfig()

func (*OperatorFee) SetOperatorFee 

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

func (*OperatorFee) ValidateTransactionFees 

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

func (*OperatorFee) VerifyL2Config 

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

func (*OperatorFee) WaitForL2Sync 

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

func (*OperatorFee) WaitForL2SyncWithCurrentL1State 

func (of *OperatorFee) WaitForL2SyncWithCurrentL1State()

type OperatorFeeValidationResult 

type OperatorFeeValidationResult struct {
	TransactionReceipt   *types.Receipt
	ExpectedOperatorFee  *big.Int
	ActualTotalFee       *big.Int
	VaultBalanceIncrease *big.Int
}

type ProvenWithdrawalParameters 

type ProvenWithdrawalParameters struct {
	Nonce              *big.Int
	Sender             common.Address
	Target             common.Address
	Value              *big.Int
	GasLimit           *big.Int
	DisputeGameAddress common.Address
	DisputeGameIndex   *big.Int
	Data               []byte
	OutputRootProof    bindings.OutputRootProof
	WithdrawalProof    [][]byte // List of trie nodes to prove L2 storage
}

ProvenWithdrawalParameters is the set of parameters to pass to the ProveWithdrawalTransaction and FinalizeWithdrawalTransaction functions

type RollupBoostNode 

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

RollupBoostNode wraps a stack.RollupBoostNode interface for DSL operations

func NewRollupBoostNode 

func NewRollupBoostNode(inner stack.RollupBoostNode) *RollupBoostNode

NewRollupBoostNode creates a new RollupBoostNode DSL wrapper

func (*RollupBoostNode) Escape 

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

func (*RollupBoostNode) FlashblocksClient 

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

type RollupBoostNodesSet 

type RollupBoostNodesSet []*RollupBoostNode

func NewRollupBoostNodesSet 

func NewRollupBoostNodesSet(inner []stack.RollupBoostNode) RollupBoostNodesSet

type SafetyHeads added in v1.19.0 

type SafetyHeads struct {
	Unsafe    uint64
	Safe      uint64
	CrossSafe uint64
	Finalized uint64
}

SafetyHeads is a snapshot of an L2 CL's unsafe/safe/cross-safe/finalized block numbers.

type SafetyHeadsAdvancement added in v1.19.0 

type SafetyHeadsAdvancement struct {
	UnsafeDelta       uint64
	UnsafeAttempts    int
	SafeDelta         uint64
	SafeAttempts      int
	CrossSafeDelta    uint64
	CrossSafeAttempts int
	FinalizedDelta    uint64
	FinalizedAttempts int
}

SafetyHeadsAdvancement is the per-level delta and attempt budget for asserting unsafe + safe + cross-safe + finalized progress together.

func DefaultSafetyHeadsAdvancement added in v1.19.0 

func DefaultSafetyHeadsAdvancement() SafetyHeadsAdvancement

DefaultSafetyHeadsAdvancement: unsafe + safe + cross-safe within ~60s, finalized within ~720s (in-process L1 has FinalizedDistance=20 blocks @ 6s).

type SameTimestampPair 

type SameTimestampPair struct {
	Trigger *txintent.InitTrigger
	Message messages.Message
	// contains filtered or unexported fields
}

SameTimestampPair holds a precomputed init message for same-timestamp interop testing. It allows creating exec messages that reference the init before it's actually included on chain. This is necessary for same-timestamp scenarios where the exec needs to reference an init that will be included in a block at the same timestamp.

func (*SameTimestampPair) SubmitExecTo 

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

SubmitExecTo returns a planned exec transaction to the given EOA's chain, referencing this init. The test harness assigns deterministic nonces and includes the signed tx directly.

func (*SameTimestampPair) SubmitInit 

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

SubmitInit returns a planned init transaction for same-timestamp testing. The test harness assigns deterministic nonces and includes the signed tx directly.

func (*SameTimestampPair) SubmitInvalidExecTo 

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

SubmitInvalidExecTo submits an exec message with an invalid log index. This creates an exec that references a non-existent log, which should be detected as invalid. Returns the planned tx; the test harness assigns deterministic nonces and includes the signed tx directly.

type StandardBridge 

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

func NewStandardBridge 

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

func (*StandardBridge) CreateL2Token 

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

CreateL2Token creates an L2 token using OptimismMintableERC20Factory and returns the token address

func (*StandardBridge) Deposit 

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

func (*StandardBridge) DisputeGameFinalityDelay 

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

func (*StandardBridge) ERC20Deposit 

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

ERC20Deposit performs an ERC20 deposit from L1 to L2

func (*StandardBridge) GameResolutionDelay 

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

func (*StandardBridge) InitiateWithdrawal 

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

func (*StandardBridge) PortalVersion 

func (b *StandardBridge) PortalVersion() string

func (*StandardBridge) ProveWithFaultProofParams added in v1.19.1 

func (b *StandardBridge) ProveWithFaultProofParams(user *EOA, params withdrawals.ProvenWithdrawalParameters) *types.Receipt

func (*StandardBridge) RespectedGameType 

func (b *StandardBridge) RespectedGameType() uint32

func (*StandardBridge) UsesSuperRoots 

func (b *StandardBridge) UsesSuperRoots() bool

func (*StandardBridge) VerifyRespectedGameType 

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

func (*StandardBridge) WithdrawalDelay 

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

type Supernode 

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

Supernode wraps a stack.Supernode interface for DSL operations

func NewSupernode 

func NewSupernode(inner stack.Supernode) *Supernode

NewSupernode creates a new Supernode DSL wrapper

func NewSupernodeWithTestControl 

func NewSupernodeWithTestControl(inner stack.Supernode, testControl stack.SupernodeTestControl) *Supernode

NewSupernodeWithTestControl creates a new Supernode DSL wrapper with test control support. The testControl parameter can be nil if no test control is needed.

func (*Supernode) ActivationTimestamp added in v1.19.0 

func (s *Supernode) ActivationTimestamp() uint64

ActivationTimestamp returns the configured interop activation timestamp. Requires NewSupernodeWithTestControl.

func (*Supernode) AssertBackfillCovers 

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

AssertBackfillCovers verifies, for each supplied chain, that the interop logs DB contains blocks spanning from a first-seal at or near the expected T_lo all the way to a latest-seal at or near the safe tip. Specifically it asserts the three invariants log backfill must preserve:

  1. firstSealed.Timestamp + blockTime > ActivationTimestamp (the first seal is at most one block before activation; when activation is not aligned to a block boundary, the block representing the chain state as of activation is the correct pairing anchor and is sealed).
  2. firstSealed.Timestamp < FirstVerifiableTimestamp() (the post-backfill handoff happens strictly after the backfilled range)
  3. firstSealed.Timestamp <= max(ActivationTimestamp, latestSealed.Timestamp - depth) + blockTime (backfill reached ~depth back, or all the way to activation if the chain is younger than depth)

This is the strongest test-side evidence that backfill actually populated the DB, rather than the supernode simply resuming off of existing disk state. Requires the Supernode to be created with NewSupernodeWithTestControl.

func (*Supernode) AssertSuperRootAtTimestamp 

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

AssertSuperRootAtTimestamp asserts that the super-root at the given timestamp matches the expected root claim

func (*Supernode) AwaitBackfillAttempts 

func (s *Supernode) AwaitBackfillAttempts(minAttempts int32)

AwaitBackfillAttempts blocks until BackfillAttempts() >= minAttempts or the timeout elapses. Fails the test on timeout. Requires the Supernode to be created with NewSupernodeWithTestControl.

func (*Supernode) AwaitBackfillCompleted 

func (s *Supernode) AwaitBackfillCompleted()

AwaitBackfillCompleted blocks until the interop activity finishes its log backfill phase, or the timeout elapses. Fails the test on timeout. Requires the Supernode to be created with NewSupernodeWithTestControl.

func (*Supernode) AwaitFinalizationAdvanced added in v1.19.0 

func (s *Supernode) AwaitFinalizationAdvanced() uint64

AwaitFinalizationAdvanced reads the supernode's current finalized timestamp from supernode_syncStatus and waits until it strictly advances past that value, then returns the new finalized timestamp. The first call therefore guarantees finalization has progressed past genesis (since genesis is the initial finalized timestamp).

func (*Supernode) AwaitFullyProcessedL1 added in v1.18.1 

func (s *Supernode) AwaitFullyProcessedL1(targetL1 uint64)

AwaitFullyProcessedL1 waits until the supernode has fully processed the given L1 block number. SuperRootAtTimestamp's CurrentL1 names the block currently being processed (L1[<CurrentL1] is fully processed), so this returns once CurrentL1.Number > targetL1.

func (*Supernode) AwaitValidatedTimestamp 

func (s *Supernode) AwaitValidatedTimestamp(timestamp uint64)

AwaitValidatedTimestamp waits for the super-root at the given timestamp to be fully validated

func (*Supernode) AwaitVerificationStartsAt added in v1.19.0 

func (s *Supernode) AwaitVerificationStartsAt(expected uint64)

AwaitVerificationStartsAt blocks until cold-start init completes, then asserts VerificationStartTimestamp equals expected. Requires NewSupernodeWithTestControl.

func (*Supernode) BackfillAttempts 

func (s *Supernode) BackfillAttempts() int32

BackfillAttempts returns the number of log-backfill attempts since the running interop activity's most recent (re)start. Requires the Supernode to be created with NewSupernodeWithTestControl.

func (*Supernode) ClientRPC added in v1.19.2 

func (s *Supernode) ClientRPC() opclient.RPC

func (*Supernode) EnsureInteropPaused 

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

EnsureInteropPaused pauses the interop activity and verifies it has stopped. It takes the local safe timestamps from two CL nodes, uses the maximum, then: 1. Pauses interop at localSafeTimestamp + pauseOffset 2. Awaits validation of localSafeTimestamp + pauseOffset - 1 3. Finds the first timestamp that is NOT verified (the actual pause point) Returns the first unverified timestamp (adjusted if pause came in late). Requires the Supernode to be created with NewSupernodeWithTestControl.

func (*Supernode) Escape 

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

Escape returns the underlying stack.Supernode

func (*Supernode) ManageVN added in v1.19.0 

func (s *Supernode) ManageVN(vn *L2CLNode)

ManageVN registers a VN-proxy L2CLNode as hosted by this supernode so that Start() can re-establish its DSL-managed peer connections after a Stop/Start cycle. Initial peering is done by the sysgo runtime; this hook only matters across restarts driven through Supernode.Start.

func (*Supernode) Name 

func (s *Supernode) Name() string

func (*Supernode) PauseInterop 

func (s *Supernode) PauseInterop(ts uint64)

PauseInterop pauses the interop activity at the given timestamp. When the interop activity attempts to process this timestamp, it returns early. This function is for integration test control only. Requires the Supernode to be created with NewSupernodeWithTestControl.

func (*Supernode) QueryAPI 

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

QueryAPI returns the supernode's query API

func (*Supernode) RestartWithFreshDataDir added in v1.19.0 

func (s *Supernode) RestartWithFreshDataDir()

RestartWithFreshDataDir stops the supernode, deletes its on-disk data directory in full, and starts a fresh supernode against the same chain containers, virtual nodes, and externally-visible RPC address. Requires NewSupernodeWithTestControl.

func (*Supernode) ResumeInterop 

func (s *Supernode) ResumeInterop()

ResumeInterop clears any pause on the interop activity, allowing normal processing. This function is for integration test control only. Requires the Supernode to be created with NewSupernodeWithTestControl.

func (*Supernode) Start added in v1.19.0 

func (s *Supernode) Start()

Start brings the supernode back up after Stop. Requires NewSupernodeWithTestControl. After the supernode is up, any VNs registered via ManageVN have their DSL-managed peer connections re-established, mirroring L2CLNode.Start.

func (*Supernode) Stop added in v1.19.0 

func (s *Supernode) Stop()

Stop halts the supernode while preserving its data directory and RPC address. Requires NewSupernodeWithTestControl.

func (*Supernode) String 

func (s *Supernode) String() string

func (*Supernode) SuperRootAt added in v1.19.0 

func (s *Supernode) SuperRootAt(timestamp uint64, expectedChainIDs ...eth.ChainID) eth.SuperRootAtTimestampResponse

SuperRootAt returns the validated super-root at the given timestamp, asserting that all expectedChainIDs are present. The timestamp must already be finalized; this method does not wait for finalization.

func (*Supernode) SuperRootAtTimestamp 

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

SuperRootAtTimestamp fetches the super-root at the given timestamp

func (*Supernode) UserRPC added in v1.19.2 

func (s *Supernode) UserRPC() string

func (*Supernode) VerificationStartTimestamp added in v1.19.0 

func (s *Supernode) VerificationStartTimestamp() uint64

VerificationStartTimestamp returns the L2 timestamp the current interop activity began verifying at. Returns 0 before cold-start init completes. Requires NewSupernodeWithTestControl.

type SyncStatusProvider 

type SyncStatusProvider interface {
	ChainSyncStatus(chainID eth.ChainID, lvl safety.Level) eth.BlockID
	String() string
}

type SyncTester 

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

SyncTester wraps a stack.SyncTester interface for DSL operations

func NewSyncTester 

func NewSyncTester(inner stack.SyncTester) *SyncTester

NewSyncTester creates a new Sync Tester DSL wrapper

func (*SyncTester) ChainID 

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

func (*SyncTester) DeleteSession 

func (s *SyncTester) DeleteSession(sessionID string)

func (*SyncTester) Escape 

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

Escape returns the underlying stack.SyncTester

func (*SyncTester) GetSession 

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

func (*SyncTester) ListSessions 

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

func (*SyncTester) ResetAllSessions added in v1.19.0 

func (s *SyncTester) ResetAllSessions()

func (*SyncTester) ResetSession added in v1.19.0 

func (s *SyncTester) ResetSession(sessionID string)

type TestSequencer 

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

func NewTestSequencer 

func NewTestSequencer(inner stack.TestSequencer) *TestSequencer

func (*TestSequencer) Escape 

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

func (*TestSequencer) SequenceBlock 

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

SequenceBlock builds a block at deterministic timestamp (parent.Time + blockTime). This is useful for tests that need predictable block timestamps.

func (*TestSequencer) SequenceBlockWithTxs 

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

SequenceBlockWithTxs builds a block with timestamp parent.Time + blockTime with the supplied transactions (bypassing the mempool). This makes it ideal for same-timestamp interop testing, and avoids the chance that transactions are sequenced into later blocks.

func (*TestSequencer) String 

func (s *TestSequencer) String() string

type VaultBalances 

type VaultBalances struct {
	BaseFeeVault   *big.Int
	L1FeeVault     *big.Int
	SequencerVault *big.Int
	OperatorVault  *big.Int
}

type Withdrawal 

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

func (*Withdrawal) FaultProofProveParams added in v1.19.1 

func (w *Withdrawal) FaultProofProveParams(advanceTime ...func(time.Duration)) withdrawals.ProvenWithdrawalParameters

func (*Withdrawal) Finalize 

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

func (*Withdrawal) FinalizeGasCost 

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

func (*Withdrawal) InitiateBlockHash 

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

func (*Withdrawal) InitiateGasCost 

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

func (*Withdrawal) InitiateTxHash added in v1.19.1 

func (w *Withdrawal) InitiateTxHash() common.Hash

func (*Withdrawal) Prove 

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

func (*Withdrawal) ProveGasCost 

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

func (*Withdrawal) WaitForDisputeGameResolved 

func (w *Withdrawal) WaitForDisputeGameResolved()

Source Files

View all Source files

Directories

Path Synopsis

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.