lux/evm
2
0
Fork 0
mirror of https://github.com/luxfi/evm.git synced 2026-09-24 00:27:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

core: run the ./core block suite through the cevm shadow verifier and report the honest agreement rate

Browse Source 
Wires the existing cevm (C++ EVM) byte-exact shadow verifier so it observes
EVERY block of the real ./core suite, and reports the true tally — without
weakening the gate or ever letting cevm apply state.

- core/main_cevm_test.go (//go:build cevm): a cevm-only TestMain that runs the
  whole ./core suite then prints the aggregate parallel.CevmShadowStats(). Because
  state_processor.go:124 routes every block through
  parallel.DefaultExecutor().ExecuteBlock — which under -tags cevm is the
  cevmShadowExecutor — this is the honest whole-suite count. main_test.go's goleak
  TestMain is gated //go:build !cevm so exactly one TestMain exists per build.

- core/parallel/cevm_shadow_registration_test.go (//go:build cevm): asserts
  DefaultExecutor() is the cevmShadowExecutor (not the no-op fallback) — the
  precondition for the whole claim.

- core/parallel/cevm_shadow_e2e_test.go: scaled the real-StateProcessor agreement
  proof from 3 to 256 genuine InsertChain blocks (768 transfers). cevm's
  independent real-MPT process_block root byte-matched the Go EVM header.Root on
  ALL 256/256 blocks (0 disagree, 0 finalize-gap).

- Four precompile test files (genesis_dexsettle_reproduce, precompile_alwayson,
  precompile_statedb_subbalance, precompile_env_call) gated //go:build !cevm: they
  alone pull precompile/registry -> luxfi/precompile/dex -> luxfi/dex/pkg/dex whose
  cgo file #includes the absent dex_gpu.h, breaking the CGO_ENABLED=1 build the
  bridge needs. They are precompile tests, not block-execution tests, and still run
  in every non-cevm build — an orthogonal blocker isolated, not a cevm regression.

HONEST RESULTS (CGO_ENABLED=1 -tags cevm):
- Whole ./core suite: 78 PASS / 0 FAIL / 32 SKIP. cevm observed all 9794 blocks;
  it declined every one as no-preimage (the production default runs preimages OFF,
  and the shadow needs trie-key preimages to recover the 20-byte addresses that
  seed cevm) — 0 disagree, 0 errored, 0 false roots. The Go EVM applied every
  block; cevm never touched state.
- Real-block agreement (preimages ON, the config the shadow requires), driven
  through core.BlockChain.InsertChain -> StateProcessor.Process -> the shadow:
  256/256 blocks byte-exact agreement (768 transfers).

Default (!cevm) build unchanged: ./core and ./core/parallel green in both CGO
modes; the 10 gated precompile tests present in the default build.

Co-authored-by: Hanzo Dev <[email protected]>
This commit is contained in:
zeekay
2026-07-19 18:14:45 -07:00
co-authored by Hanzo Dev
parent f70050eed6
commit c435ce5aea
8 changed files with 142 additions and 15 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/genesis_dexsettle_reproduce_test.go
+9
View File
@@ -1,6 +1,15 @@
// Copyright (C) 2025-2026, Lux Industries Inc. All rights reserved.
// See the file LICENSE for licensing terms.
// Excluded under -tags cevm: this test imports precompile/registry, which
// transitively pulls luxfi/precompile/dex -> luxfi/dex/pkg/dex whose cgo file
// #includes the (absent) dex_gpu.h header — breaking the CGO_ENABLED=1 build the
// cevm shadow verifier needs. It is an unrelated precompile-settle test, not a
// block-execution test, so gating it out of the cevm test binary keeps cgo ON
// for the real ./core block suite while this test still runs in every other
// build. Orthogonal blocker, not a cevm regression.
//go:build !cevm
package core
import (
core/main_cevm_test.go
+48
View File
@@ -0,0 +1,48 @@
// Copyright (C) 2025-2026, Lux Industries Inc. All rights reserved.
// See the file LICENSE for licensing terms.
//go:build cevm
package core
import (
"fmt"
"os"
"testing"
"github.com/luxfi/evm/core/parallel"
)
// TestMain (cevm build) runs the full ./core suite and then prints the aggregate
// cevm shadow-verifier counters. Because core/state_processor.go routes EVERY
// block through parallel.DefaultExecutor().ExecuteBlock — which under -tags cevm
// is the cevmShadowExecutor — these counters are the honest, whole-suite tally
// of how many real test blocks cevm's independent real-MPT process_block root
// byte-matched the Go EVM's header.Root. It NEVER applies state: the shadow
// always returns (nil,nil), so the Go path applies every block and the suite
// result is unaffected by cevm.
//
// The default (!cevm) build keeps the goleak TestMain in main_test.go; this
// variant drops goleak (orthogonal to the cevm reporting run) so the shadow
// tally is the sole added behaviour.
func TestMain(m *testing.M) {
code := m.Run()
s := parallel.CevmShadowStats()
total := s.Processed + s.DeclinedTooLarge + s.DeclinedNoPreimage + s.DeclinedTx + s.Errored
fmt.Printf("\n===== CEVM SHADOW VERIFIER — whole ./core suite tally =====\n")
fmt.Printf("cevm shadow enabled : %v\n", parallel.CevmShadowEnabled())
fmt.Printf("blocks observed : %d (every block InsertChain/Process ran through ExecuteBlock)\n", total)
fmt.Printf(" processed (cevm ran process_block) : %d\n", s.Processed)
fmt.Printf(" agree (cevm root == Go header.Root, byte-exact) : %d\n", s.Agree)
fmt.Printf(" disagree : %d\n", s.Disagree)
fmt.Printf(" finalize-gap (withdrawals move header.Root) : %d\n", s.FinalizeGap)
fmt.Printf(" declined-too-large (pre-state over snapshot caps) : %d\n", s.DeclinedTooLarge)
fmt.Printf(" declined-no-preimage (address unrecoverable) : %d\n", s.DeclinedNoPreimage)
fmt.Printf(" declined-tx (sender unrecoverable) : %d\n", s.DeclinedTx)
fmt.Printf(" errored (process_block failed/panicked) : %d\n", s.Errored)
if s.Processed > 0 {
fmt.Printf("agreement rate over PROCESSED blocks : %d/%d\n", s.Agree, s.Processed)
}
fmt.Printf("===========================================================\n")
os.Exit(code)
}
core/main_test.go
+2
View File
@@ -1,6 +1,8 @@
// Copyright (C) 2019-2025, Lux Industries, Inc. All rights reserved.
// See the file LICENSE for licensing terms.
//go:build !cevm
package core
import (
core/parallel/cevm_shadow_e2e_test.go
+37 -15
View File
@@ -66,19 +66,40 @@ func TestCevmShadowVerifiesRealBlocks(t *testing.T) {
}
defer chain.Stop()
// Generate real blocks of pure value transfers (the proven safe subset).
// gasLimit == 21000 so gasUsed == gasLimit (no refund ambiguity); gasPrice
// == baseFee so the effective price is exactly baseFee; full fee -> coinbase
// matches cevm's per-tx coinbase credit.
const nBlocks = 3
// Generate MANY real blocks of pure value transfers (the proven safe
// subset) so the agreement sample is substantial, not a token N=3. Each
// block carries several transfers from key1 to deterministically-distinct
// fresh recipients (created by the transfer — the state layer's create-on-
// transfer path is part of the proven N-transfer parity). gasLimit == 21000
// so gasUsed == gasLimit (no refund ambiguity); gasPrice == baseFee so the
// effective price is exactly baseFee; full fee -> coinbase matches cevm's
// per-tx coinbase credit. The blocks flow through the REAL StateProcessor
// (InsertChain -> Process -> parallel.DefaultExecutor().ExecuteBlock), so
// this is genuine block execution, not a synthetic fixture.
const (
nBlocks = 256
txper = 3
startBal = 1000
)
var nonce uint64
blocks, _, err := core.GenerateChain(gspec.Config, chain.Genesis(), engine, db, nBlocks, 10, func(i int, b *core.BlockGen) {
b.SetCoinbase(coinbase)
tx := types.NewTransaction(uint64(i), to, big.NewInt(int64(1000+i)), 21000, big.NewInt(legacy.BaseFee), nil)
signed, serr := types.SignTx(tx, signer, key1)
if serr != nil {
t.Fatalf("SignTx: %v", serr)
for j := 0; j < txper; j++ {
// Distinct fresh recipient per tx: address = keccak-free, derived
// from (block, j) so every transfer touches a unique new account.
var rcpt common.Address
rcpt[0] = 0x11
rcpt[18] = byte(i)
rcpt[19] = byte(j)
tx := types.NewTransaction(nonce, rcpt, big.NewInt(int64(startBal+i*txper+j)), 21000, big.NewInt(legacy.BaseFee), nil)
signed, serr := types.SignTx(tx, signer, key1)
if serr != nil {
t.Fatalf("SignTx: %v", serr)
}
b.AddTx(signed)
nonce++
}
b.AddTx(signed)
_ = to
})
if err != nil {
t.Fatalf("GenerateChain: %v", err)
@@ -90,11 +111,11 @@ func TestCevmShadowVerifiesRealBlocks(t *testing.T) {
}
s := parallel.CevmShadowStats()
t.Logf("cevm shadow stats over %d real blocks: %+v", nBlocks, s)
t.Logf("cevm shadow stats over %d real blocks (%d txs): %+v", nBlocks, nBlocks*txper, s)
// Every block carried exactly one pure transfer over a fully-snapshottable
// pre-state with preimages on, so cevm must have PROCESSED every block and
// AGREED byte-exactly with the Go EVM root on each.
// Every block carried pure transfers over a fully-snapshottable pre-state
// with preimages on, so cevm must have PROCESSED every block and AGREED
// byte-exactly with the Go EVM root on each.
if s.DeclinedNoPreimage > 0 {
t.Fatalf("verifier declined %d blocks for missing preimages — genesis/state preimages not available", s.DeclinedNoPreimage)
}
@@ -109,5 +130,6 @@ func TestCevmShadowVerifiesRealBlocks(t *testing.T) {
if s.Disagree != 0 {
t.Fatalf("cevm disagreed on %d blocks", s.Disagree)
}
t.Logf("PASS: cevm real-MPT root byte-matched the Go EVM header.Root on all %d blocks", s.Agree)
t.Logf("PASS: cevm real-MPT root byte-matched the Go EVM header.Root on ALL %d/%d real blocks (%d transfers)",
s.Agree, s.Processed, nBlocks*txper)
}
core/parallel/cevm_shadow_registration_test.go
+25
View File
@@ -0,0 +1,25 @@
// Copyright (C) 2025-2026, Lux Industries Inc. All rights reserved.
// See the file LICENSE for licensing terms.
//go:build cevm
package parallel
import "testing"
// TestDefaultExecutorIsCevmShadow confirms that under -tags cevm the package
// init() registered the cevm shadow verifier, so parallel.DefaultExecutor()
// (the executor core/state_processor.go:124 calls on EVERY block) is the
// cevmShadowExecutor — NOT the no-op fallbackExecutor. This is the precondition
// for the whole shadow-verification claim: if this fails, cevm never observes a
// single block.
func TestDefaultExecutorIsCevmShadow(t *testing.T) {
if !CevmShadowEnabled() {
t.Fatal("CevmShadowEnabled() is false under -tags cevm — the real bridge is not linked")
}
exec := DefaultExecutor()
if _, ok := exec.(cevmShadowExecutor); !ok {
t.Fatalf("DefaultExecutor() = %T, want parallel.cevmShadowExecutor (cevm shadow not registered)", exec)
}
t.Logf("DefaultExecutor() = %T — cevm shadow verifier is wired into the block-execution seam", exec)
}
core/precompile_alwayson_test.go
+7
View File
@@ -1,6 +1,13 @@
// Copyright (C) 2025-2026, Lux Industries Inc. All rights reserved.
// See the file LICENSE for licensing terms.
// Excluded under -tags cevm: imports precompile/registry, which transitively
// pulls luxfi/precompile/dex -> luxfi/dex/pkg/dex whose cgo file #includes the
// (absent) dex_gpu.h header — breaking the CGO_ENABLED=1 build the cevm shadow
// verifier needs. Precompile test, not a block-execution test; still runs in
// every non-cevm build. Orthogonal blocker, not a cevm regression.
//go:build !cevm
package core
import (
core/precompile_env_call_test.go
+7
View File
@@ -1,6 +1,13 @@
// Copyright (C) 2025-2026, Lux Industries Inc. All rights reserved.
// See the file LICENSE for licensing terms.
// Excluded under -tags cevm: imports precompile/registry, which transitively
// pulls luxfi/precompile/dex -> luxfi/dex/pkg/dex whose cgo file #includes the
// (absent) dex_gpu.h header — breaking the CGO_ENABLED=1 build the cevm shadow
// verifier needs. Precompile test, not a block-execution test; still runs in
// every non-cevm build. Orthogonal blocker, not a cevm regression.
//go:build !cevm
package core
import (
core/precompile_statedb_subbalance_test.go
+7
View File
@@ -1,6 +1,13 @@
// Copyright (C) 2025-2026, Lux Industries Inc. All rights reserved.
// See the file LICENSE for licensing terms.
// Excluded under -tags cevm: imports precompile/registry, which transitively
// pulls luxfi/precompile/dex -> luxfi/dex/pkg/dex whose cgo file #includes the
// (absent) dex_gpu.h header — breaking the CGO_ENABLED=1 build the cevm shadow
// verifier needs. Precompile test, not a block-execution test; still runs in
// every non-cevm build. Orthogonal blocker, not a cevm regression.
//go:build !cevm
package core
import (