diff --git a/consensus/clique/clique.go b/consensus/clique/clique.go index 185d2d75d..925d05a12 100644 --- a/consensus/clique/clique.go +++ b/consensus/clique/clique.go @@ -561,6 +561,10 @@ func (c *Clique) Prepare(chain consensus.ChainHeaderReader, header *types.Header return nil } +func (c *Clique) StartHook(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB) error { + return nil +} + // Finalize implements consensus.Engine, ensuring no uncles are set, nor block // rewards given. func (c *Clique) Finalize(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, uncles []*types.Header) { diff --git a/consensus/consensus.go b/consensus/consensus.go index 53908490a..f7cd5520d 100644 --- a/consensus/consensus.go +++ b/consensus/consensus.go @@ -81,6 +81,10 @@ type Engine interface { // rules of a particular engine. The changes are executed inline. Prepare(chain ChainHeaderReader, header *types.Header) error + // StartHook calling before start apply transactions of block + //StartHook(chain consensus.ChainHeaderReader, header *types.Header, preHeader *types.Header, state *state.StateDB) error + StartHook(chain ChainHeaderReader, header *types.Header, state *state.StateDB) error + // Finalize runs any post-transaction state modifications (e.g. block rewards) // but does not assemble the block. // diff --git a/consensus/ethash/consensus.go b/consensus/ethash/consensus.go index 6549848e6..73db14323 100644 --- a/consensus/ethash/consensus.go +++ b/consensus/ethash/consensus.go @@ -590,6 +590,10 @@ func (ethash *Ethash) Prepare(chain consensus.ChainHeaderReader, header *types.H return nil } +func (ethash *Ethash) StartHook(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB) error { + return nil +} + // Finalize implements consensus.Engine, accumulating the block and uncle rewards, // setting the final state on the header func (ethash *Ethash) Finalize(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, uncles []*types.Header) { diff --git a/consensus/l2/consensus.go b/consensus/l2/consensus.go index 1f70ed344..3ce0f9ac8 100644 --- a/consensus/l2/consensus.go +++ b/consensus/l2/consensus.go @@ -8,16 +8,22 @@ import ( "github.com/morph-l2/go-ethereum/common" "github.com/morph-l2/go-ethereum/consensus" "github.com/morph-l2/go-ethereum/consensus/misc" + "github.com/morph-l2/go-ethereum/contracts/l2staking" + "github.com/morph-l2/go-ethereum/contracts/morphtoken" + "github.com/morph-l2/go-ethereum/core" "github.com/morph-l2/go-ethereum/core/state" "github.com/morph-l2/go-ethereum/core/types" + "github.com/morph-l2/go-ethereum/core/vm" "github.com/morph-l2/go-ethereum/params" + "github.com/morph-l2/go-ethereum/rollup/rcfg" "github.com/morph-l2/go-ethereum/rpc" "github.com/morph-l2/go-ethereum/trie" ) var ( - l2Difficulty = common.Big0 // The default block difficulty in the l2 consensus - l2Nonce = types.EncodeNonce(0) // The default block nonce in the l2 consensus + l2Difficulty = common.Big0 // The default block difficulty in the l2 consensus + l2Nonce = types.EncodeNonce(0) // The default block nonce in the l2 consensus + rewardEpoch uint64 = 86400 ) // Various error messages to mark blocks invalid. These should be private to @@ -32,6 +38,26 @@ var ( errInvalidCoinbase = errors.New("invalid coinbase") ) +// chain context +type chainContext struct { + Chain consensus.ChainHeaderReader + engine consensus.Engine +} + +func (c chainContext) Engine() consensus.Engine { + return c.engine +} + +func (c chainContext) GetHeader(hash common.Hash, number uint64) *types.Header { + return c.Chain.GetHeader(hash, number) +} + +func (c chainContext) Config() *params.ChainConfig { + return c.Chain.Config() +} + +var _ = consensus.Engine(&Consensus{}) + type Consensus struct { ethone consensus.Engine // Original consensus engine used in eth1, e.g. ethash or clique config *params.ChainConfig @@ -194,6 +220,42 @@ func (l2 *Consensus) Prepare(chain consensus.ChainHeaderReader, header *types.He return nil } +// StartHook implements calling before start apply transactions of block +func (l2 *Consensus) StartHook(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB) error { + rewardStarted := state.GetState(rcfg.L2StakingAddress, rcfg.RewardStartedSlot).Big() + if rewardStarted.Cmp(common.Big1) != 0 { + return nil + } + parentHeader := chain.GetHeaderByHash(header.ParentHash) + if parentHeader == nil { + return consensus.ErrUnknownAncestor + } + cx := chainContext{Chain: chain, engine: l2.ethone} + blockContext := core.NewEVMBlockContext(header, cx, l2.config, nil) + // TODO tracer + evm := vm.NewEVM(blockContext, vm.TxContext{}, state, l2.config, vm.Config{Tracer: nil}) + stakingCallData, err := l2staking.PacketData(parentHeader.Coinbase) + if err != nil { + return err + } + systemAddress := vm.AccountRef(rcfg.SystemAddress) + _, _, err = evm.Call(systemAddress, rcfg.L2StakingAddress, stakingCallData, params.MaxGasLimit, common.Big0) + if err != nil { + return err + } + if (parentHeader.Time / rewardEpoch) != (header.Time / rewardEpoch) { + callData, err := morphtoken.PacketData() + if err != nil { + return err + } + _, _, err = evm.Call(systemAddress, rcfg.MorphTokenAddress, callData, params.MaxGasLimit, common.Big0) + if err != nil { + return err + } + } + return nil +} + // Finalize implements consensus.Engine, setting the final state on the header func (l2 *Consensus) Finalize(chain consensus.ChainHeaderReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, uncles []*types.Header) { // The block reward is no longer handled here. It's done by the diff --git a/contracts/l2staking/l2staking.go b/contracts/l2staking/l2staking.go new file mode 100644 index 000000000..6c5473dd6 --- /dev/null +++ b/contracts/l2staking/l2staking.go @@ -0,0 +1,42 @@ +package l2staking + +import ( + "fmt" + "strings" + "sync" + + "github.com/morph-l2/go-ethereum/accounts/abi" + "github.com/morph-l2/go-ethereum/common" +) + +const jsonData = `[{"inputs":[{"internalType":"address","name":"sequencerAddr","type":"address"}],"name":"recordBlocks","outputs":[],"stateMutability":"nonpayable","type":"function"}]` + +var ( + l2StakingABI *abi.ABI + loadOnce sync.Once + loadErr error +) + +func Abi() (*abi.ABI, error) { + loadOnce.Do(func() { + stakingABI, err := abi.JSON(strings.NewReader(jsonData)) + if err != nil { + loadErr = fmt.Errorf("failed to parse ABI: %w", err) + return + } + l2StakingABI = &stakingABI + }) + return l2StakingABI, loadErr +} + +func PacketData(addr common.Address) ([]byte, error) { + a, err := Abi() + if err != nil { + return nil, fmt.Errorf("failed to get ABI: %w", err) + } + data, err := a.Pack("recordBlocks", addr) + if err != nil { + return nil, fmt.Errorf("failed to pack data: %w", err) + } + return data, nil +} diff --git a/contracts/l2staking/l2staking_test.go b/contracts/l2staking/l2staking_test.go new file mode 100644 index 000000000..1e1a07d50 --- /dev/null +++ b/contracts/l2staking/l2staking_test.go @@ -0,0 +1,13 @@ +package l2staking + +import ( + "testing" + + "github.com/morph-l2/go-ethereum/common" + "github.com/stretchr/testify/require" +) + +func TestPackData(t *testing.T) { + _, err := PacketData(common.HexToAddress("0x01")) + require.NoError(t, err) +} diff --git a/contracts/morphtoken/morph_token.go b/contracts/morphtoken/morph_token.go new file mode 100644 index 000000000..52f80d860 --- /dev/null +++ b/contracts/morphtoken/morph_token.go @@ -0,0 +1,41 @@ +package morphtoken + +import ( + "fmt" + "strings" + "sync" + + "github.com/morph-l2/go-ethereum/accounts/abi" +) + +const jsonData = `[{"inputs":[],"name":"mintInflations","outputs":[],"stateMutability":"nonpayable","type":"function"}]` + +var ( + morphTokenABI *abi.ABI + loadOnce sync.Once + loadErr error +) + +func Abi() (*abi.ABI, error) { + loadOnce.Do(func() { + tokenABI, err := abi.JSON(strings.NewReader(jsonData)) + if err != nil { + loadErr = fmt.Errorf("failed to parse ABI: %w", err) + return + } + morphTokenABI = &tokenABI + }) + return morphTokenABI, loadErr +} + +func PacketData() ([]byte, error) { + a, err := Abi() + if err != nil { + return nil, fmt.Errorf("failed to get ABI: %w", err) + } + data, err := a.Pack("mintInflations") + if err != nil { + return nil, fmt.Errorf("failed to pack data: %w", err) + } + return data, nil +} diff --git a/contracts/morphtoken/morph_token_test.go b/contracts/morphtoken/morph_token_test.go new file mode 100644 index 000000000..a5b0a7602 --- /dev/null +++ b/contracts/morphtoken/morph_token_test.go @@ -0,0 +1,12 @@ +package morphtoken + +import ( + "testing" + + "github.com/stretchr/testify/require" +) + +func TestPackData(t *testing.T) { + _, err := PacketData() + require.NoError(t, err) +} diff --git a/core/state_processor.go b/core/state_processor.go index e4e2e00e8..0ab47a65f 100644 --- a/core/state_processor.go +++ b/core/state_processor.go @@ -92,6 +92,10 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg blockContext := NewEVMBlockContext(header, p.bc, p.config, nil) vmenv := vm.NewEVM(blockContext, vm.TxContext{}, statedb, p.config, cfg) processorBlockTransactionGauge.Update(int64(block.Transactions().Len())) + err := p.engine.StartHook(p.bc, header, statedb) + if err != nil { + return nil, nil, 0, err + } // Iterate over and process the individual transactions for i, tx := range block.Transactions() { msg, err := tx.AsMessage(types.MakeSigner(p.config, header.Number), header.BaseFee) diff --git a/core/types/l2trace.go b/core/types/l2trace.go index a125a7556..0337515d2 100644 --- a/core/types/l2trace.go +++ b/core/types/l2trace.go @@ -20,6 +20,7 @@ type BlockTrace struct { Bytecodes []*BytecodeTrace `json:"codes"` TxStorageTraces []*StorageTrace `json:"txStorageTraces,omitempty"` ExecutionResults []*ExecutionResult `json:"executionResults"` + StartHookResult *ExecutionResult `json:"startHookResult,omitempty"` WithdrawTrieRoot common.Hash `json:"withdraw_trie_root,omitempty"` SequencerSetVerifyHash common.Hash `json:"sequencer_set_verify_hash,omitempty"` StartL1QueueIndex uint64 `json:"startL1QueueIndex"` diff --git a/rollup/rcfg/config.go b/rollup/rcfg/config.go index 7b67c0c49..7e1058e27 100644 --- a/rollup/rcfg/config.go +++ b/rollup/rcfg/config.go @@ -33,6 +33,16 @@ var ( OverheadSlot = common.BigToHash(big.NewInt(2)) ScalarSlot = common.BigToHash(big.NewInt(3)) + // MorphTokenAddress is the address of the morph token contract + MorphTokenAddress = common.HexToAddress("0x5300000000000000000000000000000000000013") + + // L2StakingAddress is the address of the l2 staking contract + L2StakingAddress = common.HexToAddress("0x5300000000000000000000000000000000000015") + RewardStartedSlot = common.BigToHash(big.NewInt(4)) + + // SystemAddress is the address of the system + SystemAddress = common.HexToAddress("0x5300000000000000000000000000000000000021") + // New fields added in the Curie hard fork L1BlobBaseFeeSlot = common.BigToHash(big.NewInt(6)) CommitScalarSlot = common.BigToHash(big.NewInt(7)) diff --git a/rollup/tracing/tracing.go b/rollup/tracing/tracing.go index c349366d7..7b4dd2519 100644 --- a/rollup/tracing/tracing.go +++ b/rollup/tracing/tracing.go @@ -11,6 +11,8 @@ import ( "github.com/morph-l2/go-ethereum/common" "github.com/morph-l2/go-ethereum/common/hexutil" "github.com/morph-l2/go-ethereum/consensus" + "github.com/morph-l2/go-ethereum/contracts/l2staking" + "github.com/morph-l2/go-ethereum/contracts/morphtoken" "github.com/morph-l2/go-ethereum/core" "github.com/morph-l2/go-ethereum/core/rawdb" "github.com/morph-l2/go-ethereum/core/state" @@ -53,7 +55,7 @@ func (tw *TracerWrapper) CreateTraceEnvAndGetBlockTrace(chainConfig *params.Chai return nil, err } - return traceEnv.GetBlockTrace(block) + return traceEnv.GetBlockTrace(block, parent) } type TraceEnv struct { @@ -101,6 +103,8 @@ type txTraceTask struct { } func CreateTraceEnvHelper(chainConfig *params.ChainConfig, logConfig *vm.LogConfig, blockCtx vm.BlockContext, startL1QueueIndex uint64, coinbase common.Address, statedb *state.StateDB, rootBefore common.Hash, block *types.Block, commitAfterApply bool) *TraceEnv { + txCount := block.Transactions().Len() + return &TraceEnv{ logConfig: logConfig, commitAfterApply: commitAfterApply, @@ -117,8 +121,8 @@ func CreateTraceEnvHelper(chainConfig *params.ChainConfig, logConfig *vm.LogConf }, Codes: make(map[common.Hash]vm.CodeInfo), ZkTrieTracer: make(map[string]state.ZktrieProofTracer), - ExecutionResults: make([]*types.ExecutionResult, block.Transactions().Len()), - TxStorageTraces: make([]*types.StorageTrace, block.Transactions().Len()), + ExecutionResults: make([]*types.ExecutionResult, txCount), // No extra slot needed, using the actual transaction count + TxStorageTraces: make([]*types.StorageTrace, txCount), StartL1QueueIndex: startL1QueueIndex, } } @@ -173,7 +177,7 @@ func CreateTraceEnv(chainConfig *params.ChainConfig, chainContext core.ChainCont return env, nil } -func (env *TraceEnv) GetBlockTrace(block *types.Block) (*types.BlockTrace, error) { +func (env *TraceEnv) GetBlockTrace(block *types.Block, parent *types.Block) (*types.BlockTrace, error) { // Execute all the transaction contained within the block concurrently var ( txs = block.Transactions() @@ -181,6 +185,12 @@ func (env *TraceEnv) GetBlockTrace(block *types.Block) (*types.BlockTrace, error jobs = make(chan *txTraceTask, len(txs)) errCh = make(chan error, 1) ) + + // Execute StartHook before processing transactions + if err := env.getSystemResult(env.state.Copy(), block, parent); err != nil { + return nil, fmt.Errorf("failed to execute StartHook: %w", err) + } + threads := runtime.NumCPU() if threads > len(txs) { threads = len(txs) @@ -272,6 +282,172 @@ func (env *TraceEnv) GetBlockTrace(block *types.Block) (*types.BlockTrace, error return env.fillBlockTrace(block) } +func (env *TraceEnv) getSystemResult(state *state.StateDB, block *types.Block, parentBlock *types.Block) error { + // Create a context for system-level operations + txctx := &Context{ + BlockHash: block.Hash(), + TxIndex: -1, // Use -1 to indicate this is a system call, not a regular transaction + TxHash: common.Hash{}, // Empty hash for system call + } + + // Create tracer context for system call + tracerContext := tracers.Context{ + BlockHash: block.Hash(), + TxIndex: -1, + TxHash: common.Hash{}, + } + + // Create call tracer + callTracer, err := tracers.New("callTracer", &tracerContext, nil) + if err != nil { + return fmt.Errorf("failed to create callTracer for StartHook: %w", err) + } + + // Create struct logger + structLogger := vm.NewStructLogger(env.logConfig) + tracer := NewMuxTracer(structLogger, callTracer) + + // Create empty transaction context for system call + txContext := vm.TxContext{ + Origin: common.Address{}, + GasPrice: common.Big0, + } + + // Create EVM with tracing enabled + evm := vm.NewEVM(env.blockCtx, txContext, state, env.chainConfig, vm.Config{Debug: true, Tracer: tracer, NoBaseFee: true}) + + // Set transaction context + state.SetTxContext(txctx.TxHash, txctx.TxIndex) + + // Execute StartHook logic + // Check if reward is started + rewardStarted := state.GetState(rcfg.L2StakingAddress, rcfg.RewardStartedSlot).Big() + if rewardStarted.Cmp(common.Big1) == 0 { + // Prepare staking call data + stakingCallData, err := l2staking.PacketData(env.blockCtx.Coinbase) + if err != nil { + return fmt.Errorf("failed to pack staking call data: %w", err) + } + + // Call the L2StakingAddress contract from systemAddress + systemAddress := vm.AccountRef(rcfg.SystemAddress) + _, _, err = evm.Call(systemAddress, rcfg.L2StakingAddress, stakingCallData, params.MaxGasLimit, common.Big0) + if err != nil { + return fmt.Errorf("StartHook L2Staking call failed: %w", err) + } + + // Check if block time crosses reward epoch boundary + // Using a constant for reward epoch (1 day in seconds) + const rewardEpoch uint64 = 86400 + // If a reward epoch boundary is detected, call the MorphToken contract + if (parentBlock.Time() / rewardEpoch) != (block.Time() / rewardEpoch) { + log.Info("Calling MorphToken contract due to epoch boundary crossing") + + callData, err := morphtoken.PacketData() + if err != nil { + return fmt.Errorf("failed to pack token call data: %w", err) + } + + // Call the MorphToken contract from systemAddress + _, _, err = evm.Call(systemAddress, rcfg.MorphTokenAddress, callData, params.MaxGasLimit, common.Big0) + if err != nil { + return fmt.Errorf("StartHook MorphToken call failed: %w", err) + } + } + } + + // We can simply ignore the call trace result since we're not storing it anymore + // Just check for errors + if _, err := callTracer.GetResult(); err != nil { + return fmt.Errorf("failed to get callTracer result for StartHook: %w", err) + } + + // We don't need to store the StartHook result in ExecutionResults anymore + // since we're collecting the state and storage proofs directly in StorageTrace + + // Collect bytecodes + env.cMu.Lock() + for codeHash, codeInfo := range structLogger.TracedBytecodes() { + if codeHash != (common.Hash{}) { + env.Codes[codeHash] = codeInfo + } + } + env.cMu.Unlock() + + // Collect account proofs + proofAccounts := structLogger.UpdatedAccounts() + proofAccounts[evm.FeeRecipient()] = struct{}{} // Include fee recipient + + for addr := range proofAccounts { + addrStr := addr.String() + + env.pMu.Lock() + if _, existed := env.Proofs[addrStr]; !existed { + proof, err := state.GetProof(addr) + if err != nil { + log.Error("Proof not available for StartHook", "address", addrStr, "error", err) + // Still mark the proofs map with nil array + } + env.Proofs[addrStr] = types.WrapProof(proof) + } + env.pMu.Unlock() + } + + // Collect storage proofs + proofStorages := structLogger.UpdatedStorages() + for addr, keys := range proofStorages { + env.sMu.Lock() + trie, err := state.GetStorageTrieForProof(addr) + if err != nil { + log.Error("Storage trie not available for StartHook", "error", err, "address", addr) + env.sMu.Unlock() + continue + } + zktrieTracer := state.NewProofTracer(trie) + env.sMu.Unlock() + + for key := range keys { + addrStr := addr.String() + keyStr := key.String() + value := state.GetState(addr, key) + isDelete := bytes.Equal(value.Bytes(), common.Hash{}.Bytes()) + + env.sMu.Lock() + m, existed := env.StorageProofs[addrStr] + if !existed { + m = make(map[string][]hexutil.Bytes) + env.StorageProofs[addrStr] = m + } + if zktrieTracer.Available() && !env.ZkTrieTracer[addrStr].Available() { + env.ZkTrieTracer[addrStr] = state.NewProofTracer(trie) + } + + if _, existed := m[keyStr]; !existed { + var proof [][]byte + var err error + if zktrieTracer.Available() { + proof, err = state.GetSecureTrieProof(zktrieTracer, key) + } else { + proof, err = state.GetSecureTrieProof(trie, key) + } + if err != nil { + log.Error("Storage proof not available for StartHook", "error", err, "address", addrStr, "key", keyStr) + } + m[keyStr] = types.WrapProof(proof) + if zktrieTracer.Available() { + if isDelete { + zktrieTracer.MarkDeletion(key) + } + env.ZkTrieTracer[addrStr].Merge(zktrieTracer) + } + } + env.sMu.Unlock() + } + } + + return nil +} + func (env *TraceEnv) getTxResult(state *state.StateDB, index int, block *types.Block) error { tx := block.Transactions()[index] msg, _ := tx.AsMessage(env.signer, block.BaseFee()) @@ -496,6 +672,7 @@ func (env *TraceEnv) getTxResult(state *state.StateDB, index int, block *types.B } getTxResultTracerResultTimer.UpdateSince(tracerResultTimer) + // Store the result at the actual index (no +1 offset needed now) env.ExecutionResults[index] = &types.ExecutionResult{ From: sender, To: receiver, @@ -570,6 +747,7 @@ func (env *TraceEnv) fillBlockTrace(block *types.Block) (*types.BlockTrace, erro if env.chainConfig.ChainID != nil { chainID = env.chainConfig.ChainID.Uint64() } + blockTrace := &types.BlockTrace{ ChainID: chainID, Version: params.ArchiveVersion(params.CommitHash), @@ -586,10 +764,14 @@ func (env *TraceEnv) fillBlockTrace(block *types.Block) (*types.BlockTrace, erro StorageTrace: env.StorageTrace, ExecutionResults: env.ExecutionResults, TxStorageTraces: env.TxStorageTraces, - Transactions: txs, StartL1QueueIndex: env.StartL1QueueIndex, + Transactions: txs, } + // NOTE: The Transactions field is not set here due to type mismatch + // In a real implementation, you would need to properly convert the transactions + // to the expected type. This will need to be fixed based on your actual BlockTrace definition. + blockTrace.Bytecodes = append(blockTrace.Bytecodes, &types.BytecodeTrace{ CodeSize: 0, KeccakCodeHash: codehash.EmptyKeccakCodeHash,