Lux EVM

// OLD (deprecated):

// NEW (correct):

# Get latest block number
curl -X POST http://localhost:9630/ext/bc/C/rpc \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}'

# Get account balance
curl -X POST http://localhost:9630/ext/bc/C/rpc \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_getBalance","params":["0x...","latest"]}'

# Send raw transaction
curl -X POST http://localhost:9630/ext/bc/C/rpc \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_sendRawTransaction","params":["0x..."]}'

# Get chain ID
curl -X POST http://localhost:9630/ext/bc/C/rpc \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_chainId","params":[]}'

# Get fee config (Lux-specific)
curl -X POST http://localhost:9630/ext/bc/C/rpc \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_feeConfig","params":[]}'

client, err := ethclient.Dial("http://localhost:9630/ext/bc/C/rpc")
if err != nil {
    return err
}

blockNum, _ := client.BlockNumber(ctx)
balance, _ := client.BalanceAt(ctx, addr, nil)
chainID, _ := client.ChainID(ctx)

    "github.com/luxfi/evm/precompile/contract"
    "github.com/luxfi/evm/precompile/modules"
    "github.com/luxfi/geth/common"
)

// Register a precompile module at a specific address
var Module = modules.Module{
    Address:      common.HexToAddress("0x0300000000000000000000000000000000000001"),
    Contract:     MyPrecompile,
    Configurer:   &MyConfigurator{},
}

// Use the precompile code generator for boilerplate:
// go run cmd/precompilegen/main.go --abi MyContract.abi --out precompile/contracts/mycontract/

github.com/luxfi/evm
├── plugin/              -- Plugin entry point and VM implementation
│   ├── main.go          -- Binary entry point (loaded by luxd)
│   ├── runner/          -- Plugin runner (gRPC server lifecycle)
│   └── evm/             -- Core VM implementation
│       ├── vm.go        -- Main VM struct (Initialize, BuildBlock, Verify, Accept)
│       ├── block.go     -- Block construction and verification
│       ├── block_builder.go  -- Async block building engine
│       ├── config/      -- VM configuration (Config struct, defaults)
│       ├── service.go   -- Validators API (gRPC service)
│       ├── admin.go     -- Admin API (CPU profiler, logging)
│       ├── admin_api.go -- Admin API (import chain, db operations)
│       ├── gossip/      -- Transaction gossip handlers
│       ├── message/     -- P2P message types
│       ├── header/      -- Custom header verification
│       ├── customtypes/ -- Block extra data types
│       ├── customrawdb/ -- Raw database operations
│       ├── validators/  -- Validator management
│       └── upgrade/     -- EVM-specific upgrade handling
├── core/                -- Core blockchain logic (forked from geth)
│   ├── blockchain.go    -- Blockchain state machine
│   ├── state_processor.go   -- Transaction execution
│   ├── state_transition.go  -- EVM state transitions
│   ├── genesis.go       -- Genesis block initialization
│   ├── txpool/          -- Transaction pool management
│   ├── state/           -- State database (StateDB)
│   ├── vm/runtime/      -- EVM runtime
│   └── precompile_overrider.go -- Precompile injection into EVM
├── consensus/           -- Consensus engine interface
│   ├── consensus.go     -- Engine interface (ChainHeaderReader, Engine)
│   └── dummy/           -- Dummy engine (delegates ordering to luxd)
├── eth/                 -- Ethereum protocol implementation
│   ├── backend.go       -- ETH backend (chain access, filters, gas price)
│   ├── api_backend.go   -- API backend for eth_* namespace
│   ├── api_debug.go     -- Debug API (tracing, stack dumps)
│   ├── api_admin.go     -- Admin API (export chain)
│   ├── api_dev.go       -- Dev API (mine blocks on demand)
│   ├── ethconfig/       -- ETH configuration
│   ├── filters/         -- Log/block/tx filters
│   ├── gasprice/        -- Gas price oracle
│   ├── gasestimator/    -- Gas estimation
│   └── tracers/         -- EVM execution tracers (JS, native)
├── precompile/          -- Stateful precompile framework
│   ├── contracts/       -- Built-in precompile implementations
│   │   ├── deployerallowlist/  -- Contract deployer allow list (0x10201)
│   │   ├── txallowlist/        -- Transaction sender allow list (0x10301)
│   │   ├── nativeminter/       -- Native token minting (0x10401)
│   │   ├── feemanager/         -- Dynamic fee configuration (0x13F01)
│   │   ├── rewardmanager/      -- Block reward distribution (0x10205)
│   │   └── warp/               -- Warp cross-chain messaging (0x16201)
│   ├── allowlist/       -- Role-based access control framework
│   ├── contract/        -- Precompile contract interface
│   ├── modules/         -- Module registration and LP-aligned addressing
│   ├── precompileconfig/ -- Config interfaces
│   ├── precompiletest/  -- Test utilities
│   └── registry/        -- Auto-registration via init()
├── params/              -- Chain configuration and parameters
│   ├── config.go        -- ChainConfig (EVM forks, chain IDs)
│   └── extras/          -- Lux-specific extensions
│       ├── config.go          -- FeeConfig, NetworkUpgrades, GenesisPrecompiles
│       ├── network_upgrades.go -- EVM/Durango/Etna/Fortuna/Granite timestamps
│       ├── precompiles.go     -- Precompile configuration
│       ├── rules.go           -- Chain rules per block
│       └── state_upgrade.go   -- State upgrade definitions
├── commontype/          -- Shared types (FeeConfig)
├── ethclient/           -- Go Ethereum client (standard ethclient API)
├── accounts/            -- Account management
├── contracts/           -- Solidity contracts and Hardhat project
│   └── contracts/       -- Precompile Solidity interfaces
│       ├── AllowList.sol
│       ├── ERC20NativeMinter.sol
│       ├── ExampleFeeManager.sol
│       ├── ExampleRewardManager.sol
│       ├── ExampleWarp.sol
│       ├── FeeGovernor.sol
│       └── interfaces/  -- IAllowList, IFeeManager, INativeMinter, IRewardManager, IWarpMessenger
├── miner/               -- Block mining/building
├── node/                -- Ethereum node stack (P2P disabled in Lux)
├── network/             -- Transaction gossip network
├── rpc/                 -- JSON-RPC server framework
├── sync/                -- State sync (client/server)
│   ├── client/          -- State trie fetching from peers
│   └── statesync/       -- State sync server
├── warp/                -- Warp messaging (aggregator, signer, verifier)
│   ├── aggregator.go    -- Collects BLS signatures from validators
│   ├── backend.go       -- Warp backend (message storage)
│   ├── client.go        -- Warp client for querying signatures
│   ├── service.go       -- Warp RPC service
│   └── validators/      -- Validator set for Warp verification
├── cmd/                 -- CLI tools
│   ├── abigen/          -- ABI binding generator
│   ├── evm/             -- EVM execution tool
│   ├── simulator/       -- Local network simulator
│   ├── precompilegen/   -- Precompile code generator
│   ├── export/          -- Chain export tool
│   └── utils/           -- CLI utilities
└── interfaces/          -- Shared interface definitions

// IAllowList.sol -- base for all precompiles with access control
interface IAllowList {
    function readAllowList(address addr) external view returns (uint256);
    function setAdmin(address addr) external;
    function setManager(address addr) external;
    function setEnabled(address addr) external;
    function setNone(address addr) external;
}

// IFeeManager.sol -- dynamic fee configuration
interface IFeeManager is IAllowList {
    function getFeeConfig() external view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256);
    function getFeeConfigLastChangedAt() external view returns (uint256);
    function setFeeConfig(uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256) external;
}

// INativeMinter.sol -- native token minting
interface INativeMinter is IAllowList {
    function mintNativeCoin(address addr, uint256 amount) external;
}

// IWarpMessenger.sol -- cross-chain messaging
interface IWarpMessenger {
    function sendWarpMessage(bytes calldata payload) external returns (bytes32);
    function getVerifiedWarpMessage(uint32 index) external view returns (WarpMessage memory, bool);
    function getVerifiedWarpBlockHash(uint32 index) external view returns (WarpBlockHash memory, bool);
    function getBlockchainID() external view returns (bytes32);
}

POST /ext/bc/C/rpc          -- Standard EVM JSON-RPC
WS   /ext/bc/C/ws           -- WebSocket subscriptions
POST /ext/bc/C/lux          -- Lux-specific APIs (validators)
POST /ext/bc/C/admin        -- Admin APIs (import/export, profiling)

{
  "pruning-enabled": true,
  "commit-interval": 4096,
  "trie-clean-cache": 512,
  "trie-dirty-cache": 512,
  "snapshot-cache": 256,
  "rpc-gas-cap": 50000000,
  "rpc-tx-fee-cap": 100,
  "metrics-expensive-enabled": true,
  "admin-api-enabled": true,
  "validator-api-enabled": true,
  "enabled-eth-apis": ["eth", "eth-filter", "net", "web3", "internal-eth", "internal-blockchain", "internal-transaction"],
  "log-level": "info",
  "db-type": "badgerdb",
  "state-sync-min-blocks": 300000,
  "state-sync-request-size": 1024,
  "batch-request-limit": 1000,
  "batch-response-max-size": 25000000
}

{
  "config": {
    "chainId": 96369,
    "homesteadBlock": 0,
    "eip150Block": 0,
    "eip155Block": 0,
    "eip158Block": 0,
    "byzantiumBlock": 0,
    "constantinopleBlock": 0,
    "petersburgBlock": 0,
    "istanbulBlock": 0,
    "muirGlacierBlock": 0,
    "berlinBlock": 0,
    "londonBlock": 0,
    "shanghaiTime": 0,
    "cancunTime": 0,
    "feeConfig": {
      "gasLimit": 8000000,
      "targetBlockRate": 2,
      "minBaseFee": 25000000000,
      "targetGas": 15000000,
      "baseFeeChangeDenominator": 36,
      "minBlockGasCost": 0,
      "maxBlockGasCost": 1000000,
      "blockGasCostStep": 200000
    },
    "contractDeployerAllowListConfig": {
      "adminAddresses": ["0x..."]
    }
  },
  "alloc": {
    "0x...": { "balance": "0x..." }
  }
}

cd ~/work/lux/evm

# Build plugin binary
go build -o evm ./plugin/

# Build with race detector (development)
go build -race -o evm ./plugin/

# Run tests
go test ./...

# Run specific package tests
go test ./core/... -v
go test ./precompile/... -v

# Generate precompile from ABI
go run cmd/precompilegen/main.go --abi path/to/Contract.abi --out precompile/contracts/mycontract/

# Generate ABI bindings
go run cmd/abigen/main.go --abi path/to/Contract.abi --pkg mypackage --out bindings.go

# Run Hardhat tests for Solidity precompile interfaces
cd contracts && npx hardhat test