Merge pull request #977 from NilFoundation/beneficiary

feat: add coinbase address to block structure and RPC

Author: x-mass

nil/internal/execution/state.go

@@ -38,6 +38,9 @@ const (
 	ModeSyncReplay   = "syncer-replay"
 	ModeManualReplay = "manual-replay"
 	ModeVerify       = "verify"
+
+	// TODO: align with protocol – currently using a dummy address to match Ethereum block structure
+	CoinbaseShardIndependentAddr = "0x0"
 )
 
 var blocksTracer *BlocksTracer
@@ -109,6 +112,8 @@ type ExecutionState struct {
 
 	GasUsed types.Gas
 
+	CoinbaseAddress types.Address
+
 	// Transient storage
 	transientStorage transientStorage
 
@@ -281,6 +286,7 @@ func NewEVMBlockContext(es *ExecutionState) (*vm.BlockContext, error) {
 		BlobBaseFee: big.NewInt(10),
 		GasLimit:    es.GasLimit.Uint64(),
 		Time:        time,
+		Coinbase:    es.CoinbaseAddress,
 
 		RollbackCounter: rollbackCounter,
 	}, nil
@@ -352,6 +358,7 @@ func NewExecutionState(tx db.RoTx, shardId types.ShardId, params StateParams) (*
 		Logs:             map[common.Hash][]*types.Log{},
 		DebugLogs:        map[common.Hash][]*types.DebugLog{},
 		Errors:           map[common.Hash]error{},
+		CoinbaseAddress:  types.ShardAndHexToAddress(shardId, CoinbaseShardIndependentAddr),
 
 		journal:          newJournal(),
 		transientStorage: newTransientStorage(),
@@ -1185,6 +1192,11 @@ func (es *ExecutionState) HandleTransaction(
 	default:
 		res = es.handleExecutionTransaction(ctx, txn)
 	}
+
+	if err := es.transferPriorityFee(res.GasUsed.ToValue(txn.MaxPriorityFeePerGas)); err != nil {
+		return NewExecutionResult().SetFatal(fmt.Errorf("transferPriorityFee failed: %w", err))
+	}
+
 	responseWasSent := false
 	bounced := false
 	if txn.IsRequest() {
@@ -2191,3 +2203,7 @@ func VerboseTracingHooks(logger logging.Logger) *tracing.Hooks {
 		},
 	}
 }
+
+func (es *ExecutionState) transferPriorityFee(priorityFee types.Value) error {
+	return es.AddBalance(es.CoinbaseAddress, priorityFee, tracing.BalanceIncreaseRewardTransactionFee)
+}

nil/internal/types/block.go

@@ -51,6 +51,7 @@ type BlockData struct {
 	BaseFee             Value            `json:"gasPrice" ch:"gas_price"`
 	GasUsed             Gas              `json:"gasUsed" ch:"gas_used"`
 	L1BlockNumber       uint64           `json:"l1BlockNumber" ch:"l1_block_number"`
+	Coinbase            Address          `json:"miner" ch:"miner"`
 
 	// Incremented after every rollback, used to prevent rollback replay attacks
 	RollbackCounter uint32 `json:"rollbackCounter" ch:"rollback_counter"`

nil/internal/types/serialization_test.go

@@ -34,7 +34,7 @@ func TestSerializeBlock(t *testing.T) {
 	h, err := common.Keccak(&block2)
 	require.NoError(t, err)
 
-	h2, err := hex.DecodeString("24ff2a9b05d533266c08cc1906bffcd746ecd1a427255de2319f9a9a45fa1a75")
+	h2, err := hex.DecodeString("03b723f064c70966267e9ded7d13fc07e1a082f5ea4e2156c77765cfe933c657")
 	require.NoError(t, err)
 
 	require.Equal(t, common.BytesToHash(h2), common.BytesToHash(h[:]))

nil/services/cliservice/block.go

@@ -123,6 +123,7 @@ Block #{{ .block.Id }} [{{ .color.bold }}{{ .block.Hash .shardId }}{{ .color.res
   PrevBlock: {{ .block.PrevBlock }}
   BaseFee: {{ .block.BaseFee }}
   GasUsed: {{ .block.GasUsed }}
+  Coinbase: {{ .block.Coinbase }}
   ChildBlocksRootHash: {{ .block.ChildBlocksRootHash }}
 {{- if len .block.ChildBlocks}}
   ChildBlocks:

nil/services/cliservice/block_format_test.go

@@ -147,10 +147,11 @@ func TestDebugBlockToText(t *testing.T) {
 		text, err := s.debugBlockToText(types.ShardId(13), block, false, false)
 		require.NoError(t, err)
 
-		expectedText := `Block #100500 [0x000d1288cfedf4f9c748f80d9d0e3edb422c092a2a17725878e36aa9383c6bfa] @ 13 shard
+		expectedText := `Block #100500 [0x000dcc04885a7be4c360239bfbad32edb62f486770189fe98244c43c793ae9b6] @ 13 shard
   PrevBlock: 0x00000000000000000000000000000000000000000000000000000000deadbeef
   BaseFee: 0
   GasUsed: 1234
+  Coinbase: 0x0000000000000000000000000000000000000000
   ChildBlocksRootHash: 0x00000000000000000000000000000000000000000000000000000000deadbabe
   ChildBlocks:
     - 1: 0x0000000000000000000000000000000000000000000000000000000000000111

nil/services/rpc/jsonrpc/eth_block_test.go

@@ -91,6 +91,7 @@ func (suite *SuiteEthBlock) TestGetBlockByHash() {
 	suite.Require().NoError(err)
 	suite.Require().NotNil(data)
 	suite.Equal(suite.lastBlockHash, data.Hash)
+	suite.Equal(data.Coinbase, types.ShardAndHexToAddress(shardId, "0x0"))
 }
 
 func (suite *SuiteEthBlock) TestGetBlockTransactionCountByHash() {

nil/services/rpc/jsonrpc/types.go

@@ -72,6 +72,7 @@ type RPCInTransaction struct {
 // @componentprop ParentHash parentHash string true "The hash of the parent block."
 // @componentprop ReceiptsRoot receiptsRoot string true "The root of the block receipts."
 // @componentprop ShardId shardId integer true "The ID of the shard where the block was generated."
+// @componentprop Coinbase miner string true "The address of the fee recipient that receives priority fees."
 type RPCBlock struct {
 	Number              types.BlockNumber   `json:"number"`
 	Hash                common.Hash         `json:"hash"`
@@ -93,6 +94,7 @@ type RPCBlock struct {
 	L1Number            uint64              `json:"l1Number"`
 	LogsBloom           hexutil.Bytes       `json:"logsBloom,omitempty"`
 	GasUsed             types.Gas           `json:"gasUsed,omitempty"`
+	Coinbase            types.Address       `json:"miner"`
 }
 
 type ShardCount struct {
@@ -435,6 +437,7 @@ func NewRPCBlock(shardId types.ShardId, data *BlockWithEntities, fullTx bool) (*
 		LogsBloom:           bloom,
 		L1Number:            block.L1BlockNumber,
 		GasUsed:             block.GasUsed,
+		Coinbase:            block.Coinbase,
 	}, nil
 }
 

nil/services/synccommittee/prover/tracer/internal/mpttracer/mpt_tracer.go

@@ -55,8 +55,12 @@ func (mt *MPTTracer) GetAccountState(addr types.Address, createIfNotExists bool)
 	// try to fetch from cache
 	smartContract, err := contractTrie.Fetch(addr.Hash())
 	if smartContract != nil {
-		// we fetched this contract before (in could be even updated by this time)
-		return mt.accountsTraceableStates[addr], nil
+		cachedAcc, exists := mt.accountsTraceableStates[addr]
+		if exists {
+			return cachedAcc, nil
+		}
+		// it could exist in the trie, but not in cache. E.g., the trie is reused between tracing
+		return mt.createTraceableAccount(addr, smartContract)
 	}
 	if err != nil && !errors.Is(err, db.ErrKeyNotFound) {
 		return nil, err
@@ -86,6 +90,13 @@ func (mt *MPTTracer) GetAccountState(addr types.Address, createIfNotExists bool)
 		return nil, nil
 	}
 
+	return mt.createTraceableAccount(addr, contract)
+}
+
+func (mt *MPTTracer) createTraceableAccount(
+	addr types.Address,
+	contract *types.SmartContract,
+) (*TraceableAccount, error) {
 	traceableAcc, err := NewTracableAccountState(mt, addr, contract, mt.logger)
 	if err != nil {
 		return nil, err