test(etc): add live RPC tests for Mordor and ETC mainnet

tests/live_etc/helpers_test.go

@@ -0,0 +1,146 @@
+//go:build live
+
+// Package live_etc provides pre-fork integration tests that verify current
+// ETC and Mordor chain state via JSON-RPC. These tests require a running
+// core-geth node and are excluded from normal test runs.
+//
+// Run with: go test -tags live ./tests/live_etc/ -v
+//
+// Environment variables:
+//
+//	MORDOR_RPC  - Mordor RPC endpoint (default: http://localhost:8545)
+//	ETC_RPC     - ETC mainnet RPC endpoint (default: https://etc.rivet.link)
+package live_etc
+
+import (
+	"context"
+	"encoding/json"
+	"math/big"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/rpc"
+)
+
+// Pre-olympia chain constants (NO olympia-specific values here)
+const (
+	MordorChainID     = 63
+	ETCMainnetChainID = 61
+
+	// ECIP-1017 era parameters
+	ClassicEraLength = 5_000_000
+	MordorEraLength  = 2_000_000
+
+	// ECIP-1099 etchash fork blocks
+	ClassicECIP1099Block = 11_700_000
+	MordorECIP1099Block  = 2_520_000
+
+	// Gas limits (pre-olympia)
+	ETCGasLimit = 8_000_000
+)
+
+// Known genesis hashes
+var (
+	MordorGenesisHash = common.HexToHash("0xa68ebde7932f0bf2579b075499416f0a693de84c26b05cd01de86e60aad05ec0")
+	ETCGenesisHash    = common.HexToHash("0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3")
+)
+
+// rpcBlock is a minimal block structure for JSON-RPC responses.
+type rpcBlock struct {
+	Number     *hexutil.Big   `json:"number"`
+	Hash       common.Hash    `json:"hash"`
+	ParentHash common.Hash    `json:"parentHash"`
+	GasUsed    *hexutil.Big   `json:"gasUsed"`
+	GasLimit   *hexutil.Big   `json:"gasLimit"`
+	StateRoot  common.Hash    `json:"stateRoot"`
+	Miner      common.Address `json:"miner"`
+	Difficulty *hexutil.Big   `json:"difficulty"`
+	Nonce      string         `json:"nonce"`
+	MixHash    common.Hash    `json:"mixHash"`
+	Timestamp  *hexutil.Big   `json:"timestamp"`
+}
+
+// getMordorRPC returns the Mordor RPC endpoint.
+func getMordorRPC() string {
+	if v := os.Getenv("MORDOR_RPC"); v != "" {
+		return v
+	}
+	return "http://localhost:8545"
+}
+
+// getETCRPC returns the ETC mainnet RPC endpoint.
+func getETCRPC() string {
+	if v := os.Getenv("ETC_RPC"); v != "" {
+		return v
+	}
+	return "https://etc.rivet.link"
+}
+
+// dialRPC connects to an RPC endpoint with a 10-second timeout.
+func dialRPC(t *testing.T, endpoint string) *rpc.Client {
+	t.Helper()
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	client, err := rpc.DialContext(ctx, endpoint)
+	if err != nil {
+		t.Skipf("cannot connect to %s: %v", endpoint, err)
+	}
+	return client
+}
+
+// getChainID returns the chain ID from eth_chainId.
+func getChainID(t *testing.T, client *rpc.Client) uint64 {
+	t.Helper()
+	var result hexutil.Big
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	if err := client.CallContext(ctx, &result, "eth_chainId"); err != nil {
+		t.Fatalf("eth_chainId failed: %v", err)
+	}
+	return result.ToInt().Uint64()
+}
+
+// getBlockByNumber fetches a block by number.
+func getBlockByNumber(t *testing.T, client *rpc.Client, num *big.Int) *rpcBlock {
+	t.Helper()
+	var block rpcBlock
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	var numArg string
+	if num == nil {
+		numArg = "latest"
+	} else {
+		numArg = hexutil.EncodeBig(num)
+	}
+	if err := client.CallContext(ctx, &block, "eth_getBlockByNumber", numArg, false); err != nil {
+		t.Fatalf("eth_getBlockByNumber(%s) failed: %v", numArg, err)
+	}
+	return &block
+}
+
+// getNetVersion returns the network version from net_version.
+func getNetVersion(t *testing.T, client *rpc.Client) string {
+	t.Helper()
+	var result string
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	if err := client.CallContext(ctx, &result, "net_version"); err != nil {
+		t.Fatalf("net_version failed: %v", err)
+	}
+	return result
+}
+
+// getSyncing returns whether the node is syncing.
+func getSyncing(t *testing.T, client *rpc.Client) json.RawMessage {
+	t.Helper()
+	var result json.RawMessage
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	if err := client.CallContext(ctx, &result, "eth_syncing"); err != nil {
+		t.Fatalf("eth_syncing failed: %v", err)
+	}
+	return result
+}

tests/live_etc/mainnet_test.go

@@ -0,0 +1,108 @@
+//go:build live
+
+package live_etc
+
+import (
+	"math/big"
+	"testing"
+)
+
+// TestETCMainnetChainID verifies the ETC mainnet reports chain ID 61.
+func TestETCMainnetChainID(t *testing.T) {
+	client := dialRPC(t, getETCRPC())
+	defer client.Close()
+
+	chainID := getChainID(t, client)
+	if chainID != ETCMainnetChainID {
+		t.Errorf("ETC mainnet chain ID = %d, want %d", chainID, ETCMainnetChainID)
+	}
+}
+
+// TestETCMainnetGenesisHash verifies the ETC mainnet genesis block hash
+// (same as original Ethereum genesis — the chain split happened at block 1,920,000).
+func TestETCMainnetGenesisHash(t *testing.T) {
+	client := dialRPC(t, getETCRPC())
+	defer client.Close()
+
+	genesis := getBlockByNumber(t, client, big.NewInt(0))
+	if genesis.Hash != ETCGenesisHash {
+		t.Errorf("ETC genesis hash = %s, want %s", genesis.Hash.Hex(), ETCGenesisHash.Hex())
+	}
+}
+
+// TestETCMainnetPoW verifies that ETC mainnet blocks have valid PoW fields.
+func TestETCMainnetPoW(t *testing.T) {
+	client := dialRPC(t, getETCRPC())
+	defer client.Close()
+
+	block := getBlockByNumber(t, client, nil) // latest
+	if block.Difficulty == nil || block.Difficulty.ToInt().Sign() <= 0 {
+		t.Error("latest block has zero or nil difficulty — not PoW")
+	}
+}
+
+// TestETCMainnetECIP1017Era verifies the current ECIP-1017 era based on
+// the latest block number. As of 2026, ETC is in era 4 (blocks 20M-25M).
+func TestETCMainnetECIP1017Era(t *testing.T) {
+	client := dialRPC(t, getETCRPC())
+	defer client.Close()
+
+	block := getBlockByNumber(t, client, nil)
+	blockNum := block.Number.ToInt().Int64()
+
+	if blockNum < ClassicEraLength {
+		t.Skipf("block %d is before era 1 start", blockNum)
+	}
+
+	era := (blockNum - 1) / ClassicEraLength
+	t.Logf("ETC mainnet block %d is in era %d", blockNum, era)
+
+	// As of early 2026, should be in era 4 (20M+) heading toward era 5 (25M+)
+	if era < 3 {
+		t.Errorf("expected era >= 3 for current ETC mainnet, got era %d (block %d)", era, blockNum)
+	}
+}
+
+// TestETCMainnetGasLimit verifies the ETC mainnet gas limit is around 8M.
+func TestETCMainnetGasLimit(t *testing.T) {
+	client := dialRPC(t, getETCRPC())
+	defer client.Close()
+
+	block := getBlockByNumber(t, client, nil)
+	gasLimit := block.GasLimit.ToInt().Uint64()
+
+	if gasLimit < 7_000_000 || gasLimit > 9_000_000 {
+		t.Errorf("ETC mainnet gas limit = %d, expected ~8M", gasLimit)
+	}
+}
+
+// TestETCMainnetNetVersion verifies net_version returns "1" (ETC network ID).
+func TestETCMainnetNetVersion(t *testing.T) {
+	client := dialRPC(t, getETCRPC())
+	defer client.Close()
+
+	version := getNetVersion(t, client)
+	if version != "1" {
+		t.Errorf("ETC mainnet net_version = %q, want %q", version, "1")
+	}
+}
+
+// TestETCMainnetDAOForkBlock verifies that ETC did NOT execute the DAO fork.
+// Block 1,920,000 should have the "classic" state root (no irregular state change).
+func TestETCMainnetDAOForkBlock(t *testing.T) {
+	client := dialRPC(t, getETCRPC())
+	defer client.Close()
+
+	// The DAO fork block
+	block := getBlockByNumber(t, client, big.NewInt(1920000))
+
+	if block.Number.ToInt().Int64() != 1920000 {
+		t.Fatalf("expected block 1920000, got %d", block.Number.ToInt().Int64())
+	}
+
+	// ETC's block 1920000 hash — confirms this chain rejected the DAO fork
+	expectedHash := "0x94365e3a8c0b35089c1d1195081fe7489b528a84b22199c916180db8b28ade7f"
+	if block.Hash.Hex() != expectedHash {
+		t.Errorf("DAO fork block hash = %s, want %s (ETC classic chain)", block.Hash.Hex(), expectedHash)
+	}
+}

tests/live_etc/mordor_test.go

@@ -0,0 +1,99 @@
+//go:build live
+
+package live_etc
+
+import (
+	"math/big"
+	"testing"
+)
+
+// TestMordorChainID verifies the Mordor testnet reports chain ID 63.
+func TestMordorChainID(t *testing.T) {
+	client := dialRPC(t, getMordorRPC())
+	defer client.Close()
+
+	chainID := getChainID(t, client)
+	if chainID != MordorChainID {
+		t.Errorf("Mordor chain ID = %d, want %d", chainID, MordorChainID)
+	}
+}
+
+// TestMordorGenesisHash verifies the Mordor genesis block hash.
+func TestMordorGenesisHash(t *testing.T) {
+	client := dialRPC(t, getMordorRPC())
+	defer client.Close()
+
+	genesis := getBlockByNumber(t, client, big.NewInt(0))
+	if genesis.Hash != MordorGenesisHash {
+		t.Errorf("Mordor genesis hash = %s, want %s", genesis.Hash.Hex(), MordorGenesisHash.Hex())
+	}
+}
+
+// TestMordorPoWFields verifies that Mordor blocks have valid PoW fields
+// (non-zero difficulty, non-empty nonce and mixHash).
+func TestMordorPoWFields(t *testing.T) {
+	client := dialRPC(t, getMordorRPC())
+	defer client.Close()
+
+	block := getBlockByNumber(t, client, nil) // latest
+	if block.Difficulty == nil || block.Difficulty.ToInt().Sign() <= 0 {
+		t.Error("latest block has zero or nil difficulty — not PoW")
+	}
+	if block.Nonce == "" || block.Nonce == "0x0000000000000000" {
+		t.Error("latest block has empty nonce — not PoW")
+	}
+	if block.MixHash == (MordorGenesisHash) {
+		// MixHash should be a unique hash from the PoW computation
+		t.Log("warning: mixHash equals genesis hash — unusual but not necessarily wrong")
+	}
+}
+
+// TestMordorGasLimit verifies that Mordor gas limit is around 8M (pre-olympia).
+func TestMordorGasLimit(t *testing.T) {
+	client := dialRPC(t, getMordorRPC())
+	defer client.Close()
+
+	block := getBlockByNumber(t, client, nil) // latest
+	gasLimit := block.GasLimit.ToInt().Uint64()
+
+	// Gas limit should be near 8M (within adjustment bounds)
+	if gasLimit < 7_000_000 || gasLimit > 9_000_000 {
+		t.Errorf("Mordor gas limit = %d, expected ~8M (pre-olympia)", gasLimit)
+	}
+}
+
+// TestMordorDifficultyProgression verifies that difficulty is non-trivial
+// and blocks have incrementing numbers.
+func TestMordorDifficultyProgression(t *testing.T) {
+	client := dialRPC(t, getMordorRPC())
+	defer client.Close()
+
+	latest := getBlockByNumber(t, client, nil)
+	latestNum := latest.Number.ToInt().Int64()
+
+	if latestNum < 10_000_000 {
+		t.Skipf("Mordor chain height %d too low for meaningful difficulty check", latestNum)
+	}
+
+	// Check a block from around 1M blocks ago
+	oldNum := latestNum - 1_000_000
+	oldBlock := getBlockByNumber(t, client, big.NewInt(oldNum))
+
+	if oldBlock.Difficulty == nil || latest.Difficulty == nil {
+		t.Fatal("difficulty is nil")
+	}
+
+	t.Logf("Block %d difficulty: %s", oldNum, oldBlock.Difficulty.ToInt().String())
+	t.Logf("Block %d difficulty: %s", latestNum, latest.Difficulty.ToInt().String())
+}
+
+// TestMordorNetVersion verifies net_version returns "7" (Mordor network ID).
+func TestMordorNetVersion(t *testing.T) {
+	client := dialRPC(t, getMordorRPC())
+	defer client.Close()
+
+	version := getNetVersion(t, client)
+	if version != "7" {
+		t.Errorf("Mordor net_version = %q, want %q", version, "7")
+	}
+}