Skip to content

Comments

update#6

Open
JustXxx wants to merge 8933 commits intoJustXxx:develop_4aryfrom
ethereum-optimism:develop
Open

update#6
JustXxx wants to merge 8933 commits intoJustXxx:develop_4aryfrom
ethereum-optimism:develop

Conversation

@JustXxx
Copy link
Owner

@JustXxx JustXxx commented Apr 16, 2024

No description provided.

geoknee and others added 30 commits February 4, 2026 18:41
… components (#19060)

* Generalize generate-release-notes recipe to support multiple components

* update justfile command hint/comment to suggest gh auth token
Introduce a new unified ID type system using Go generics to address the                                                                                                                                                                                                                                                  
parallel type system problem in op-devstack. The current system has 19                                                                                                                                                                                                                                                   
separate ID types, each with ~150 lines of boilerplate for marshal/unmarshal,                                                                                                                                                                                                                                            
String(), sorting, and matcher methods.                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                         
The new system provides:                                                                                                                                                                                                                                                                                                 
- ComponentID: single underlying struct for all IDs                                                                                                                                                                                                                                                                      
- ID[T]: generic wrapper with KindMarker constraint for type safety                                                                                                                                                                                                                                                      
- Marker types (L2BatcherMarker, etc.) to avoid circular dependencies                                                                                                                                                                                                                                                    
- IDShape enum to handle three ID formats (key+chain, chain-only, key-only)                                                                                                                                                                                                                                              
- Conversion helpers for incremental migration from old to new types                                                                                                                                                                                                                                                     
                                                                                                                                                                                                                                                                                                                         
New types use a "2" suffix (L2BatcherID2, NewL2BatcherID2) to coexist with                                                                                                                                                                                                                                               
the existing system during migration. Serialization output is identical to                                                                                                                                                                                                                                               
the old system for compatibility.                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                         
This is Phase 1 of a multi-phase refactor. Future phases will introduce a                                                                                                                                                                                                                                                
unified registry and capability interfaces for polymorphic lookups.                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                         
See docs/design/id-type-system-refactor.md for the full design document.
…9084)

During OPCM super-roots migration we temporarily transfer each OptimismPortal’s
ProxyAdmin ownership to the DelegateCallProxy. Restore each portal
ProxyAdmin back to the L1PAO after shared admin contracts are reset
so both portals report the expected proxyAdminOwner()

With this we can re-enable the TestInteropReadiness acceptance-test
* supernode: Handle genesis L2 block in L1AtSafeHead lookup

Add special case in L1AtSafeHead to return genesis L1 directly when
querying for the genesis L2 block, avoiding unnecessary SafeDB walkback
that would otherwise fail at genesis boundary.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

* for the genesis case; check the entire blockid

---------

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
…clude the v prefix (#19090)

* op-program: Fix reproducibility test. The short version should not include the v prefix.

* Fix short string for legacy kona too.
* op-acceptance: Add start of test to run FPP program across a chain.

* op-acceptance: Execute kona-interop for the generated chain.

* Back to kona release build path.

* Tidy up code.
The Blob Tip Oracle (BTO) previously used ethclient.SubscribeNewHead() for header notifications, which only works over WebSocket connections. This change converts it to polling for new headers instead, allowing it to work with HTTP connections. The polling uses the existing PollRate configuration (2.5s default) to check for new headers at regular intervals.

Co-authored-by: Claude Haiku 4.5 <noreply@anthropic.com>
…zz tests (#19094)

* test(contracts): enhance OptimismMintableERC721 test coverage with fuzz tests

- Convert constructor test to fuzz test with variable remoteChainId
- Convert safeMint test to fuzz test with variable recipient and tokenId
- Convert safeMint notBridge test to fuzz test with variable caller
- Convert burn test to fuzz test with variable tokenId
- Convert burn notBridge test to fuzz test with variable caller
- Convert tokenURI test to fuzz test with variable tokenId
- Add supportsInterface test for unsupported interfaces
- Add version format validation test using SemverComp.parse()

* fix(test): add IERC721Metadata to supportsInterface fuzz exclusions

The contract inherits IERC721Metadata from ERC721, so it must be excluded
from the unsupported interface fuzz test to prevent false failures.

---------

Co-authored-by: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>
* fix: safer safes interface and deploy

* feat: DeploySaferSafes test

* fix: error string

* fix: forge fmt
* op-acceptance-tests: Add InvalidMessageHalt test for supernode interop

This TDD test verifies the Interop Activity's behavior when an invalid
executing message is included in a chain:
- Validity should NEVER advance to include the invalid block's timestamp
- Safety and unsafety for both chains should continue to advance

The test sends a valid initiating message on chain A, then sends an invalid
executing message on chain B (with an impossible log index), and observes
that the Supernode correctly halts validity advancement while allowing
safety heads to progress.

* op-supernode: Add logsDB infrastructure for interop activity

This prepares the interop activity for implementing the actual interop
algorithm by:

1. Moving stubbed algorithm functions to algo.go:
   - loadLogs: loads and persists logs up to a timestamp
   - verifyInteropMessages: validates executing messages
   - invalidateBlock: handles invalid blocks

2. Adding per-chain logs.DB for log persistence:
   - Uses op-supervisor's logs.DB directly (no wrapper)
   - openLogsDB helper creates DB per chain in data directory
   - Full persistence support (data survives restart)

3. Extending ChainContainer interface with FetchReceipts:
   - Added to ChainContainer, EngineController, and l2Provider interfaces
   - Enables interop activity to fetch receipts for log processing

4. Initializing logsDBs in Interop activity:
   - Creates one logs.DB per chain on startup
   - Properly closes all logsDBs on Stop()

5. Unit tests for log persistence:
   - Tests for open/close, seal block, persistence
   - Tests for multiple chain isolation

* op-supernode: Refactor interop logdb and improve test coverage

This commit reorganizes the interop activity code and adds comprehensive tests:

1. File reorganization:
   - Renamed algo.go to logdb.go for log persistence code
   - Created new algo.go with just verifyInteropMessages
   - Moved invalidateBlock back to interop.go

2. Added LogsDB interface:
   - Defines interface around logs.DB for better testability
   - Enables mock implementations in unit tests

3. Added chain continuity check:
   - verifyPreviousTimestampSealed now returns previous block hash
   - loadLogs verifies block parent matches logsDB hash
   - Added ErrParentHashMismatch error

4. Expanded unit test coverage for logdb:
   - Tests for verifyPreviousTimestampSealed (activation/non-activation)
   - Tests for processBlockLogs (empty, with logs, errors)
   - Tests for loadLogs parent hash mismatch

5. Improved interop_test.go assertions:
   - Verify logsDBs population in constructor tests
   - Verify verifyFn receives correct args
   - Verify timestamps before activation return true
   - Verify Result.IsEmpty for various scenarios
   - Verify data retrieval after handleResult
   - Full cycle tests verify logsDB and L2Heads

* op-supernode: Implement interop message verification

This commit implements the core verification logic for the interop activity,
completing the TDD cycle for the InvalidMessageHalt acceptance test.

Key changes:
- Implement verifyInteropMessages to validate executing messages at each timestamp
- Verify initiating messages exist in source chain's logsDB via Contains query
- Verify timestamp ordering: initiating timestamp < executing timestamp
- Fix verifyPreviousTimestampSealed to accept any sealed block timestamp < ts
  (not just ts-1), handling block times > 1 second
- Add comprehensive unit tests for verification logic

The acceptance test now passes, demonstrating that:
- Valid cross-chain messages are verified successfully
- Invalid executing messages (wrong LogIndex) halt validity advancement
- Safe/unsafe heads continue to advance independently

* op-supernode: Consolidate interop unit tests

Refactor tests for better organization and reduced redundancy:

- Create logdb_test.go for logsDB infrastructure tests
  - TestLogsDB_Persistence (data persistence, multi-chain isolation)
  - TestVerifyPreviousTimestampSealed (7 table-driven cases)
  - TestProcessBlockLogs (5 subtests)
  - TestLoadLogs_ParentHashMismatch

- Rewrite algo_test.go for verification algorithm only
  - TestVerifyInteropMessages_ValidBlocks (3 subtests)
  - TestVerifyInteropMessages_InvalidBlocks (5 subtests)
  - TestVerifyInteropMessages_Errors

- Consolidate interop_test.go for lifecycle/coordination
  - Merge related tests into table-driven patterns
  - Remove trivial getter/empty-case tests

Test count: 62 functions → 19 functions (~55 cases via subtests)
Removed 8 trivial tests that added no value.

* remove unused code

* validate timestamp gap using block time

* implement message expiry time validation

* simplify verifyExecutingMessage logic

* fix logdb timing check and track local safe in acceptance test

* fix loadLogs to process blocks when DB is empty

* simplify timestamp progression test baseline logic

* skip logsDB loading and verification at activation timestamp

For activation-after-genesis, the logsDB cannot handle non-sequential block
sealing (starting from block N instead of genesis). At activation timestamp:
- Skip loading logs (logsDB requires sequential blocks from genesis)
- Skip verification (can't verify cross-chain messages referencing pre-activation data)
- Trust blocks at activation time

Also allow empty logsDB at activation+blockTime (the first real timestamp).

* fix logsDB to start at activation block instead of genesis

* move invalid_message_halt_test to separate package to avoid test pollution
* fix: gaps in VerifyOPCM

* fix: broken test init

* fix: correct env loading

* fix: outdated code

* fix: more outdated code

* fix: bad parsing

* fix: wrong function call

* fix: remove unused MIN verification, fix test env vars

- Remove documented but unimplemented MIN:<value> check type
- Remove unused _verifyMinValue function
- Add missing env vars to test_verifyOpcmCorrectness_succeeds:
  - EXPECTED_L1_PAO_MULTISIG
  - EXPECTED_CHALLENGER
  - EXPECTED_WITHDRAWAL_DELAY_SECONDS

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

* fix: skip mainnet-only checks in testing environment

The _verifyZeroOnMainnet check should also be skipped in testing
environments where we can't control the actual chain state.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

* fix: use vm mock for isolation

* fix: format

* fix: final test tweaks

---------

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
* fix: SuperchainConfig comments and test refactoring

- Remove outdated warning comment from SuperchainConfig
- Bump SuperchainConfig version to 2.4.1
- Fix comment in OPContractsManagerV2
- Refactor test helpers: move NeedsSuperchainConfigUpgrade to testutil package
- Update add-game-type-v2 tests to deploy a full OP chain

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

* fix: semver lock

* fix: broken test when applying superchain config upgrade

---------

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
…19076)

* chore: return migrator address on ReadImplementationAddresses output (#819)

* chore: return migrator address on ReadImplementationAddresses output

* chore: use fixed solidity version

* chore: just pr ready

* test: add zero length code test for opcm

* chore: update tests on migrator (#822)

* refactor: replace contract mocks with vm.mock

* fix: read impl typo

* fix: remove nonexistent delayedWETHPermissionedGameProxy from test

The test referenced input_.delayedWETHPermissionedGameProxy which doesn't
exist in the ReadImplementationAddresses.Input struct. The delayedWETH
implementation is read from OPCM's implementations() return value, not
from an input proxy address.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

* fix: use common test

* fix: handle OPCM V2 feature flag in ReadImplementationAddresses tests

The test was using the `opcm` variable directly, which is only set when
OPCM_V2 feature is disabled. Added `_opcm()` helper to return the correct
instance based on the feature flag.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

---------

Co-authored-by: IamFlux <175354924+0xiamflux@users.noreply.github.com>
Co-authored-by: niha <205694301+0xniha@users.noreply.github.com>
Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
* docs: add TODO checker workflow to docs/ai/ci-ops.md

Adds detailed operational instructions for resolving TODO checker
CI failures in a dedicated file following the docs/ai/ pattern.

The workflow includes:
- CircleCI API commands to find the latest scheduled pipeline
- Parsing job output to identify closed issues
- GitHub API commands to find who closed the issue
- Proper reopening comment format with attribution and traceability

This enables natural language commands like "fix the latest TODO
checker failure" to work automatically via AGENTS.md/CLAUDE.md
guidance that Claude Code reads.

References the new ci-ops.md file from AGENTS.md alongside other
topic-specific documentation.

* Simplify docs

* docs: fix TODO checker workflow to work without CIRCLECI_TOKEN

Updates the TODO checker workflow with two key fixes:

1. Remove CIRCLECI_TOKEN requirement - CircleCI API is publicly
   accessible for this repository, so no authentication needed

2. Fix "who closed the issue" detection - Use GraphQL to find the
   most recent person who closed the issue from the timeline, not
   just the closing PR author. This correctly handles cases where
   an issue was closed via PR, then reopened, then closed directly
   by a different user.

Also improves Step 2 to search through recent scheduled pipelines
to find one with the actual "scheduled-todo-issues" workflow, since
the latest may only contain a "setup" workflow.

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

* Add claude skill for fixing todo check job.

* Put detail in the skill file and simple more human readable instructions in ci-ops.md

---------

Co-authored-by: Claude Sonnet 4.5 <noreply@anthropic.com>
* feat(op-deployer): build contracts in docker

* fix(tests): comments

* fix(tests): comments

* fix(tests): comments

* fix(tests): comments
* op-acceptance: Change to creating super cannon kona games

* op-acceptance: Use the interop prestate dir for kona

* Fix lint

* Enable super cannon kona game type in challenger.
#19077)

* fix: only allow enabling permissioned game types in opcmv2 deployment (#835)

* fix: only allow permissioned game types in opcmv2 deployment

* docs: add comment for permissionless games config in deployopchain

* feat: add isInitialDeployment argument to std validator script

* fix: undo OPCMv1 changes

* fix: old test content

* fix: expect validator errors for disabled games in deploy test

CANNON and CANNON_KONA are intentionally disabled during initial deployment,
so no implementations are registered. The validator correctly flags this as
PLDG-10 and CKDG-10 errors. Update test to expect these errors.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

* fix: revert on non-PERMISSIONED_CANNON game type in DeployOPChain

Address review feedback: raise an error instead of silently overwriting
the disputeGameType input. Only PERMISSIONED_CANNON is valid for initial
deployment since no prestate exists for permissionless games.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

---------

Co-authored-by: niha <205694301+0xniha@users.noreply.github.com>
Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
…elated code (#19080)

* Revert "Revert "op-service: rip out deprecated blob sidecars client and relat…"

This reverts commit aaa41a0.

* Remove unused GetBlobs method from MockBlobsFetcher

* Add NewBlobHint and NewLegacyBlobHint methods

* Refactor blob hint generation in PreimageOracle

* Add Test for Blob Hints in Prefetcher

This commit adds comprehensive testing for blob hints in the prefetcher,
covering both legacy and current blob hint types. The test verifies that
the prefetcher can correctly handle and retrieve blob data based on
different hint implementations.

* Refactor Blob Hint Parsing with Improved Validation

Add parseBlobHint function to handle legacy and current blob hint
formats, improving error handling and hint parsing for blob-related
operations

* Remove trailing newline in prefetcher test file
Add descriptions for the `ai/` and `handbook/` directories in the docs README. Refine the CODEOWNERS pattern for security-reviews to be more specific, and fix the trailing slash formatting for consistency.

Co-authored-by: Claude Haiku 4.5 <noreply@anthropic.com>
* Update RewindFinalizedHeadBackward test to expect panic

* Fix rewind test finalized block reference

* Use error handling instead of panic
* mise: upgrade semgrep from 1.90.0 to 1.131.0

Semgrep 1.90.0 has a transitive dependency on opentelemetry-instrumentation
which imports pkg_resources from setuptools. Python 3.12 does not include
setuptools by default in venvs, so when the mise cache is invalidated (by
any change to mise.toml), a fresh pipx install of semgrep 1.90.0 fails with:

  ModuleNotFoundError: No module named 'pkg_resources'

This was reported as semgrep/semgrep#11069 and fixed in later versions.
Upgrading to 1.131.0 resolves the issue.

Co-Authored-By: Kelvin Fichter <kelvinfichter@gmail.com>

* mise: upgrade semgrep from 1.131.0 to 1.137.0

v1.137.0 is the first version that actually bumps the opentelemetry
packages (PR semgrep/semgrep#11180), fixing the pkg_resources
ModuleNotFoundError on Python 3.12 without setuptools.

Co-Authored-By: Kelvin Fichter <kelvinfichter@gmail.com>

---------

Co-authored-by: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>
Co-authored-by: Kelvin Fichter <kelvinfichter@gmail.com>
* chore(rust): merge all the rust workspaces

* chore(ci): formatting, fixing dockerfile and ci

* chore: more ci fixes

* Update .circleci/continue/rust-ci.yml

Co-authored-by: Sebastian Stammler <seb@oplabs.co>

* Update .circleci/continue/rust-e2e.yml

Co-authored-by: Sebastian Stammler <seb@oplabs.co>

* Update .circleci/continue/rust-e2e.yml

Co-authored-by: Sebastian Stammler <seb@oplabs.co>

* chore: pr comments

* nit: fix kona path in op-challenger

* chore: fix prestate artifacts path

---------

Co-authored-by: Sebastian Stammler <seb@oplabs.co>
#18866)

* fix: alt da: handle no commitments case when finalized head is updated

* add tests

* update fix
…block (#19114)

* Update L1 genesis handling for genesis L2 block

Clarify that for the genesis L2 block, we always return L1 block 0
without relying on the original configuration's L1 genesis. This allows
for more flexibility in dispute game scenarios involving earlier L1
blocks.

* empty commit to trigger CI checks
)

* op-acceptance: Add test for next super root not being available.

* Move fpp tests to their own package so they can run in parallel with other challenger tests.  Restart the sequencer after the test.
…19136)

The rust workspace unification moved op-alloy under rust/, but the
semgrepignore pattern was not updated, causing semgrep to flag the
mdbook theme's JavaScript try/catch blocks as Solidity violations.

Co-authored-by: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>
Co-authored-by: Kelvin Fichter <kelvinfichter@gmail.com>
The [alias] section in mise.toml has been deprecated in favor of
[tool_alias]. This fixes the deprecation warning on mise startup.
dhyaniarun1993 and others added 9 commits February 17, 2026 15:43
…h#650)

This PR added support to run op-reth in sequencer and op-reth(with
proof) in validator for the e2e test.

Note: In this setup pruning test isn't supported(at this moment) since
this test is falling outside the proof window of reth.

---------

Co-authored-by: Emilia Hane <elsaemiliaevahane@gmail.com>
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
Closes op-rs/op-reth#528

---------

Co-authored-by: Emilia Hane <elsaemiliaevahane@gmail.com>
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
Co-authored-by: Sadiqur Rahman <sadiqurr8@gmail.com>
Co-authored-by: Emilia Hane <elsaemiliaevahane@gmail.com>
Co-authored-by: Himess <95512809+Himess@users.noreply.github.com>
Co-authored-by: Himess <semihcvlk53@gmail.com>
Co-authored-by: jagroot <4516586+itschaindev@users.noreply.github.com>
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
Co-authored-by: Julian Meyer <julianmeyer2000@gmail.com>
* ci: Fix make reproducible-prestate.

Adjust reproducible-prestate so the op-program and kona prestates can be built in parallel.
Depend on the full prestate build in CI to ensure it always works.

* Use machine executor.

* Remove remote docker setup.

* Remove separate cannon-kona build job.

* Build cannon and op-program binaries.

* Depend on go-binaries-for-sysgo in e2e tests

* ci: Only build the specified rust binary
* feat(op-deployer): remove default l1 and l2 PAOs and move docs

* feat(op-deployer): add more tests
…ed output (#19219)

- add JSON Schema to session creation so Devin populates the structured_output API field
- fix double-nested extraction that always returned empty dict

Co-authored-by: Ariel Ignacio Diaz <ariel@Ariels-MBP.localdomain>
* ci: Fix rust workflow references to prestate builds.

* Run all rust tests when .circleci changes.
…-proofs

feat(op-reth): port historical proofs from op-rs/op-reth
sebastianst and others added 20 commits February 18, 2026 12:18
chore(rust/op-reth): update reth to rev 2c5d00f and bump alloy deps
Change from route-based admin API (/admin with custom JWT handler) to a
dedicated port approach (like op-node's interop RPC).

Before:
  Port 9545 → supervisor API (public) + /admin (JWT via custom handler)

After:
  Port 9545 → supervisor API (public)
  Port 8546 → admin API (server-wide JWT)

New flags:
- --admin.rpc.addr: Address to bind admin RPC (empty = disabled)
- --admin.rpc.port: Port for admin RPC (default: 8546)

Admin RPC is disabled by default and requires --admin.jwt-secret when enabled.

Co-authored-by: opsuperchain <opsuperchain@slop.bot>
Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
* proofs: add interop FP trace extension action test to devstack

* fix flakes; leave batcher alone
* Refactor blob handling to remove indexed blob references

* Refactor Blob Hint Tests to Improve Clarity and Readability

* Add doc comment formatting fix to blob provider

* Fix rustdoc syntax for trait documentation
… (superAuthority) (#19110)

* op-supernode: add SuperAuthority interface and wire into op-node

- Add SuperAuthority interface in supernode resources package
- Add SupernodeAuthority implementation (empty for now)
- Add SuperAuthority field to InitializationOverrides in op-node
- Attach SuperAuthority to OpNode struct during initialization
- Wire SupernodeAuthority through supernode to all chain containers

* Replace `safeHead` with dynamic method `SafeL2Head()`

* WIP

* WIP

* Move SuperAuthority interface and related code to chain_container
package

* WIP

* Implement SafeL2Head method for chain container.

Establish a new method 	LatestVerifiedTimestamp() (uint64, bool) on the
verifier interface:

* Update LatestVerifiedTimestamp method to LatestVerifiedL2Block

* Update SuperAuthority interface method name
Rename SafeL2Head to FullyVerifiedL2Head in SuperAuthority interface

* Fix SafeL2Head to use superAuthority field

add TODOs

* Refactor BlockAtTimestamp to use TargetBlockNumber and
L2BlockRefByNumber

* Rename BlockAtTimestamp to LocalSafeBlockAtTimestamp

* Remove BlockLabel parameter from LocalSafeBlockAtTimestamp

* remove accidental ressurected code

from rebasing

* Refactor BlockAtTimestamp method to LocalSafeBlockAtTimestamp

* Update sync status logging to use LocalSafeL2 fields

* Update sync status struct field names in timestamp progression test

* Remove unused mock struct fields in chain container test

* Replace SafeL2 with LocalSafeL2 in Superroot activity

* Add VerifiedSafeBlockAtTimestamp method to chain container

The new method computes and returns the safe L2 block at a given
timestamp, with additional checks against the current safe head.

* Replace VerifiedSafeBlockAtTimestamp with LocalSafeBlockAtTimestamp

* enhance error msg

* remove unused getter

* Add local safe head tracking for SafeDB in interop mode

* simplify
Simplify safe head reset logic in sync deriver

* Update comments to clarify local safe head references

* Update test comments to clarify "safe head" terminology

* Remove local safe update handling in SyncDeriver

* Add block time to test chain config to prevent division by zero

* Add deprecated safe head field to EngineController

* Remove commented-out test functions

* Add additional assertions for L2 block references

* Move check on safe head to a test which actually advances it

and conditionalize the check on the safe head being nonzero

* move again

* fix test

* Change FullyVerifiedL2Head to return BlockID instead of L2BlockRef

* Updatee Safe Heamd Retrioeval with Context aned Improved Panic Message

* Add tests for SafeL2Head in engine controller

* Add tests for LocalSafeBlockAtTimestamp method

* Update FullyVerifiedL2Head to track earliest verified block

* Add safe head progression tests for supernode interop

* Add test coverage for FullyVerifiedL2Head method

update implementation to panic if verifiers disagree on block hash for
the same timestamp

* Add test mocks for engine controller forkchoice update

* adopt superAuthority wiring from
#19091

* fix compiler errors after merging with main branch

* Gracefully Handle SuperAuthority L2 Head Ahead of Local Safe Head

Modify SafeL2Head() to log a debug message and return the local safe
head when the SuperAuthority's verified head is ahead of the local safe
head, instead of panicking.

This change prevents unexpected crashes and provides a fallback
mechanism that maintains node stability while logging the discrepancy
for investigation.

* Add safe head progression test for supernode interop

This commit updates the safe head progression test in
op-acceptance-tests
to validate cross-chain safe head synchronization behavior. Key changes
include:

- Pause and resume interop verification to test safe head stalling
- Add assertions for cross-safe and local-safe head progression
- Check execution layer safe label consistency
- Simplify test structure for better readability and reliability

* speed up test by 2x

* DSL: Coordinate Interop Activity Pause for Acceptance Testing

* self review fixes

* finish moving code

* Remove BlockAtTimestamp method from EngineController interface

* Fix chain container test temp directory config

* Add robust pause timestamp calculation for supernode interop test

allows the test to work on chains with different block times

* Refactor Safe Head Progression Test for Conciseness

* Update safe head progression test comment for clarity

* Remove unnecessary imports and batcher configuration in supernode init
test

* add safety-labels.md

* Add safe head validation check in supernode interop test

* Update MockEngineForInvalidation to Simplify Block Retrieval

* Refactor EnsureInteropPaused to simplify timestamp selection

* Refactor Safe Head Progression Test for Dynamic Timestamp Handling

* Increase timeout for supernode timestamp validation

Extends the context timeout in `AwaitValidatedTimestamp` from
`DefaultTimeout` to `5*DefaultTimeout` to provide more time for
timestamp validation, reducing potential race conditions.

Removes verbose commentary in safety-labels.md, simplifying the
explanation while preserving the core concept of avoiding multiple
stateful controllers.

* Update safety-labels.md

* Handle logsDB reset by early return when timestamp not sealed

* op-supernode: pass invalidated BlockRef through Reset callback chain

This change modifies the Reset callback to pass the invalidated BlockRef
directly to activities, allowing resetLogsDB to use the block info
without making RPC calls to LocalSafeBlockAtTimestamp during reset.

The problem was that during a reset, LocalSafeBlockAtTimestamp could fail
if the chain container's safe head hadn't yet caught up after the rewind,
causing the logsDB to be cleared entirely instead of rewound to the
correct position.

Changes:
- Activity.Reset now takes invalidatedBlock eth.BlockRef parameter
- ResetCallback type updated to include invalidatedBlock
- RewindEngine accepts invalidatedBlock and passes to callback
- InvalidateBlock constructs BlockRef from the invalidated block
- Interop.resetLogsDB uses BlockRef directly (Number-1, ParentHash)
- verifiedDB.RewindAfter keeps reset timestamp, removes only after
- All test mocks updated for new signatures

* Make Proofs wait on LocalSafe instead of Safe

* Adjust 4 More Proofs Tests to LocalSafe

* Revert "Adjust 4 More Proofs Tests to LocalSafe"

This reverts commit 0b28c12.

* Revert "Make Proofs wait on LocalSafe instead of Safe"

This reverts commit cbdb215.

* Improve fallback mechanism for fully verified L2 head

Enhance `FullyVerifiedL2Head()` to handle scenarios with no verifiers or
incomplete verification:

- Add explicit fallback to local-safe head when no verifiers are
  registered
- Improve logging for better traceability of fallback mechanism
- Gracefully handle cases where rollup client or sync status retrieval
  fails
- Prevent potential nil pointer dereference

* tidy

* Update SuperAuthority interface to support local-safe fallback

* Remove unnecessary nil checks on logger

---------

Co-authored-by: axelKingsley <axel.kingsley@gmail.com>
* refactor: add InitMessage struct and update SendInitMessage

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

* refactor: update SendRandomInitMessage to return InitMessage

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

* refactor: update invalid_message_reorg_test.go to use InitMessage

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

* refactor: update cross_message_test.go to use InitMessage

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

* refactor: update interop_happy_tx_test.go to use InitMessage

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

* refactor: update interop_mon_test.go to use InitMessage

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

* refactor: update upgrade/post_test.go to use InitMessage

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

* refactor: update remaining op-acceptance-tests to use InitMessage

Updates upgrade/pre_test.go and interop_msg_test.go to use the new
InitMessage pattern.

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

* refactor: update kona supervisor tests to use InitMessage

Updates all kona supervisor test files to use the new InitMessage pattern:
- message/interop_happy_tx_test.go
- message/interop_msg_test.go
- pre_interop/post_test.go
- pre_interop/pre_test.go
- rpc/rpc_test.go

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

* refactor: add convenience accessors to InitMessage

Add BlockNumber(), TxHash(), and BlockHash() methods to InitMessage
for direct access to commonly-used Receipt fields. Update all test
files to use these new accessors instead of accessing Receipt fields
directly.

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

* refactor: simplify SendExecMessage to accept InitMessage

Update SendExecMessage and SendInvalidExecMessage to accept InitMessage
directly instead of IntentTx. Remove the eventIdx parameter which was
always 0. This simplifies the API and makes the relationship between
init and exec messages clearer.

Updated all call sites across op-acceptance-tests and kona tests.

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

* refactor: introduce ExecMessage struct

Create ExecMessage struct to encapsulate exec transaction intent and receipt,
mirroring the InitMessage pattern. Add convenience accessors BlockNumber(),
TxHash(), and BlockHash(). Update SendExecMessage and SendInvalidExecMessage
to return ExecMessage. Update all call sites across op-acceptance-tests and
kona tests.

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

* Introduce BlockID method.

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

* Simplify logging of init and exec messages.

---------

Co-authored-by: Claude Sonnet 4.5 <noreply@anthropic.com>
…s. (#19229)

* op-acceptance: Add tests to prove validation of valid interop messages.

* kona-proofs: Fix interop header_by_number lookup.

Previously it would often enter an infinite loop because it would always look up the current block header and return that, never making any progress.
The commit modifies the configuration handling for interop activation
timestamp to use a pointer, allowing explicit nil state and more
flexible configuration across several files in the op-supernode and
op-devstack packages.
* chore: update to Reth 1.11.0 commit

* Use tag instead of rev for reth deps
kona-client is an FPVM guest program (#![no_std]) with no CLI argument
handling. The `--version` smoke test doesn't apply to it.

Fixes #19255
…8873)

Introduce a unified Registry type that can replace the 14+ separate                                                                                                                                                                                                                                                      
locks.RWMap instances in the Orchestrator. The Registry provides:                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                         
- Single map storage keyed by ComponentID (from Phase 1)                                                                                                                                                                                                                                                                 
- Secondary indexes by ComponentKind and ChainID for efficient queries                                                                                                                                                                                                                                                   
- Type-safe generic accessor functions (RegistryGet, RegistryGetByKind, etc.)                                                                                                                                                                                                                                            
- Thread-safe concurrent access via sync.RWMutex                                                                                                                                                                                                                                                                         
- Registrable interface for self-registering components                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                         
Also adds HasChainID() helper to ComponentID to reduce code duplication.                                                                                                                                                                                                                                                 
                                                                                                                                                                                                                                                                                                                         
This is Phase 2 of the ID type system refactor. The Registry is designed                                                                                                                                                                                                                                                 
to coexist with existing RWMap fields during incremental migration.


Amendments:
* op-devstack: avoid calling range callbacks under lock
…artifact output paths (#19251)

Move kona-node, op-reth, and related docker image references from
ghcr.io (op-rs/kona, paradigmxyz) to the oplabs-tools-artifacts GCP
registry. Also fix the prestate build output directory to use an
absolute path and update CI to write artifacts to a dedicated
per-kind directory.

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
…19189)

* Refactor Finalized Head Management in EngineController

This commit updates the engine controller to introduce a more flexible
finalized head management approach. Key changes include:

- Introduce `FinalizedHead()` method to dynamically select finalized
  head
- Deprecate direct `finalizedHead` field in favor of new method
- Add support

* add stubs

* Implement FinalizedL2Head with cross-verifier consensus check

* WIP

* Update FinalizedL2Head method with improved fallback logic

The changes modify the `FinalizedL2Head` method in multiple files to:
- Introduce a second return value to signal when local finalized head
  should be used
- Handle cases with no registered verifiers
- Provide more detailed logging
- Improve error handling for unfinalized verifier states

* Refactor Interop Service Finalized L2 Block Tracking

The commit introduces a robust implementation for tracking finalized L2
blocks in the Interop service. Key changes include:

- Implement `LatestFinalizedL2Block` method with logic to find the
  latest verified L2 block based on the finalized L1 block
- Add finalized L2 head tracking in `mockSuperAuthority` for testing
- Expand test coverage for finalized head progression in
  `head_progression_test.go`

* Rename Test to Better Describe Safe Head Progression

* Add Safe and Finalized Head Progression Checks

Extend head progression test to verify both safe and finalized
block progression in the supernode interop scenario. Ensures that
both safe and finalized heads stall when interop activity is
paused and correctly catch

* Update Supernode interop safe head progression test

This commit enhances the `TestSupernodeInterop_SafeHeadProgression` test
by
adding an additional validation step. It now checks that the L1 origin
of
finalized L2 blocks is at or behind the L1 finalized head, providing an
extra
layer of sanity checking for cross-chain head progression.

* Return to Genesis Block as Safe/Finalized Head Fallback

This change modifies the `SafeL2Head()` and `FinalizedHead()` methods to
return the genesis block when no safe or finalized head is yet
established, instead of returning an empty `L2BlockRef`.

The key changes are:
- Fetch the genesis block from the engine when no safe/finalized head is
  available
- Panic if the genesis block cannot be retrieved, as this represents a
  critical system failure

* Add time travel to supernode interop tests

* Update Interop verification to include L1 head context

* Replace `L1Head` with `L1Inclusion` in interop functionality

* lint

* Add FinalizedHead tests to engine and supernode

* engine-controller: update localFinalizedHead

* Update SafeL2Head test to return genesis block with empty SuperAuthority

* add comment

* interop activity: expose VerifiedBlockAtL1 instead of
LatestFinalizedL2Block

the chain container calls this with the finalized l1 of its virtual
node, in order to satisfy the FinalizedL2Head() API

* interop algo: update result.L1Inclusion semantics

the earliest L1 block such that all L2 blocks at the supplied timestamp
were derived from a source at or before that L1 block

* interop verification: return error when there are no chains

add unit test coverage for the algo

* remove unused fn

* do not panic if we cannot get genesis block from engine

* fix test

* add comments

* tidy
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.