feat(exec) : adds the baseFee and the coinBase to the public inputs of the execution proof

Author: AlexandreBelling

prover/backend/execution/craft.go

@@ -33,6 +33,8 @@ func CraftProverOutput(
 		rsp             = Response{
 			BlocksData:           make([]BlockData, len(blocks)),
 			ChainID:              cfg.Layer2.ChainID,
+			BaseFee:              cfg.Layer2.BaseFee,
+			CoinBase:             types.EthAddress(cfg.Layer2.CoinBase),
 			L2BridgeAddress:      types.EthAddress(cfg.Layer2.MsgSvcContract),
 			MaxNbL2MessageHashes: cfg.TracesLimits.BlockL2L1Logs,
 		}
@@ -193,6 +195,8 @@ func (rsp *Response) FuncInput() *public_input.Execution {
 		fi         = &public_input.Execution{
 			L2MessageServiceAddr:  types.EthAddress(rsp.L2BridgeAddress),
 			ChainID:               uint64(rsp.ChainID),
+			BaseFee:               uint64(rsp.BaseFee),
+			CoinBase:              types.EthAddress(rsp.CoinBase),
 			FinalBlockTimestamp:   lastBlock.TimeStamp,
 			FinalBlockNumber:      uint64(rsp.FirstBlockNumber + len(rsp.BlocksData) - 1),
 			InitialBlockTimestamp: firstBlock.TimeStamp,
@@ -229,6 +233,8 @@ func NewWitness(cfg *config.Config, req *Request, rsp *Response) *Witness {
 			TxHashes:        txHashes,
 			L2BridgeAddress: cfg.Layer2.MsgSvcContract,
 			ChainID:         cfg.Layer2.ChainID,
+			BaseFee:         cfg.Layer2.BaseFee,
+			CoinBase:        types.EthAddress(cfg.Layer2.CoinBase),
 			BlockHashList:   getBlockHashList(rsp),
 		},
 		FuncInp: rsp.FuncInput(),

prover/backend/execution/response.go

@@ -51,11 +51,18 @@ type Response struct {
 	ExecDataChecksum types.Bytes32 `json:"execDataChecksum"`
 	// ChainID indicates which ChainID was used during the execution.
 	ChainID uint `json:"chainID"`
-	// L2BridgeAddress indicates which ChainID was used during the execution.
+	// L2BridgeAddress indicates the address of the L2 bridge was used during
+	// the execution.
 	L2BridgeAddress types.EthAddress `json:"l2BridgeAddress"`
 	// MaxNbL2MessageHashes indicates the max number of L2 Message hashes that
 	// can be processed by the execution prover at once in the config.
 	MaxNbL2MessageHashes int `json:"maxNbL2MessageHashes"`
+	// CoinBase indicates the coinbase of the L2 network that was used during
+	// the proof generation
+	CoinBase types.EthAddress `json:"coinBase"`
+	// BaseFee indicates the base fee of the L2 network that was used during
+	// the proof generation
+	BaseFee uint `json:"baseFee"`
 
 	// AllRollingHash stores the collection of all the rolling hash events
 	// occurring during the execution frame.

prover/circuits/execution/pi.go

@@ -107,6 +107,8 @@ type FunctionalPublicInputSnark struct {
 	InitialBlockNumber   frontend.Variable
 	ChainID              frontend.Variable
 	L2MessageServiceAddr frontend.Variable
+	BaseFee              frontend.Variable
+	CoinBase             frontend.Variable
 }
 
 // RangeCheck checks that values are within range
@@ -139,10 +141,26 @@ func (spi *FunctionalPublicInputSnark) Sum(api frontend.API, hsh gnarkHash.Field
 	)
 
 	hsh.Reset()
-	hsh.Write(spi.DataChecksum, l2MessagesSum,
-		spi.FinalStateRootHash, spi.FinalBlockNumber, spi.FinalBlockTimestamp, finalRollingHash[0], finalRollingHash[1], spi.LastRollingHashUpdateNumber,
-		spi.InitialStateRootHash, spi.InitialBlockNumber, spi.InitialBlockTimestamp, initialRollingHash[0], initialRollingHash[1], spi.FirstRollingHashUpdateNumber,
-		spi.ChainID, spi.L2MessageServiceAddr)
+	hsh.Write(
+		spi.DataChecksum,
+		l2MessagesSum,
+		spi.FinalStateRootHash,
+		spi.FinalBlockNumber,
+		spi.FinalBlockTimestamp,
+		finalRollingHash[0],
+		finalRollingHash[1],
+		spi.LastRollingHashUpdateNumber,
+		spi.InitialStateRootHash,
+		spi.InitialBlockNumber,
+		spi.InitialBlockTimestamp,
+		initialRollingHash[0],
+		initialRollingHash[1],
+		spi.FirstRollingHashUpdateNumber,
+		spi.ChainID,
+		spi.L2MessageServiceAddr,
+		spi.BaseFee,
+		spi.CoinBase,
+	)
 
 	return hsh.Sum()
 }
@@ -152,6 +170,8 @@ func (spi *FunctionalPublicInputSnark) Assign(pi *public_input.Execution) error
 	spi.InitialStateRootHash = pi.InitialStateRootHash[:]
 	spi.InitialBlockNumber = pi.InitialBlockNumber
 	spi.ChainID = pi.ChainID
+	spi.CoinBase = pi.CoinBase[:]
+	spi.BaseFee = pi.BaseFee
 	spi.L2MessageServiceAddr = pi.L2MessageServiceAddr[:]
 
 	return spi.FunctionalPublicInputQSnark.Assign(pi)

prover/circuits/execution/pi_test.go

@@ -22,6 +22,7 @@ func TestPIConsistency(t *testing.T) {
 		InitialBlockTimestamp:        2,
 		FirstRollingHashUpdateNumber: 3,
 		ChainID:                      7,
+		BaseFee:                      3,
 	}
 
 	utils.FillRange(pi.DataChecksum[:], 10)
@@ -32,6 +33,7 @@ func TestPIConsistency(t *testing.T) {
 	utils.FillRange(pi.FinalStateRootHash[:], 210)
 	utils.FillRange(pi.LastRollingHashUpdate[:], 250)
 	utils.FillRange(pi.L2MessageServiceAddr[:], 40)
+	utils.FillRange(pi.CoinBase[:], 22)
 
 	// state root hashes are field elements
 	pi.InitialStateRootHash[0] &= 0x0f

prover/circuits/execution/pi_wizard_extraction.go

@@ -135,6 +135,16 @@ func checkPublicInputs(
 
 	api.AssertIsEqual(bridgeAddress, gnarkFuncInp.L2MessageServiceAddr)
 
+	api.AssertIsEqual(
+		wvc.GetPublicInput(api, publicInput.BaseFee),
+		gnarkFuncInp.BaseFee,
+	)
+
+	api.AssertIsEqual(
+		wvc.GetPublicInput(api, publicInput.CoinBase),
+		gnarkFuncInp.CoinBase,
+	)
+
 }
 
 // execDataHash hash the execution-data with its length so that we can guard

prover/config/config.go

@@ -77,18 +77,18 @@ func newConfigFromFile(path string, withValidation bool) (*Config, error) {
 	logrus.SetLevel(logrus.Level(cfg.LogLevel)) // #nosec G115 -- overflow not possible (uint8 -> uint32)
 
 	// Extract the Layer2.MsgSvcContract address from the string
-	addr, err := common.NewMixedcaseAddressFromString(cfg.Layer2.MsgSvcContractStr)
+	lsMsgSvcAddress, err := common.NewMixedcaseAddressFromString(cfg.Layer2.MsgSvcContractStr)
 	if withValidation && err != nil {
 		return nil, fmt.Errorf("failed to extract Layer2.MsgSvcContract address: %w", err)
 	}
-	cfg.Layer2.MsgSvcContract = addr.Address()
+	cfg.Layer2.MsgSvcContract = lsMsgSvcAddress.Address()
 
 	// Extract the coinbase address from the string
-	// addr, err := common.NewMixedcaseAddressFromString(cfg.Layer2.CoinbaseStr)
-	// if withValidation && err != nil {
-	// 	return nil, fmt.Errorf("failed to extract Layer2.MsgSvcContract address: %w", err)
-	// }
-	// cfg.Layer2.MsgSvcContract = addr.Address()
+	coinBaseAddr, err := common.NewMixedcaseAddressFromString(cfg.Layer2.CoinBaseStr)
+	if withValidation && err != nil {
+		return nil, fmt.Errorf("failed to extract Layer2.MsgSvcContract address: %w", err)
+	}
+	cfg.Layer2.MsgSvcContract = coinBaseAddr.Address()
 
 	// ensure that asset dir / kzgsrs exists using os.Stat
 	srsDir := cfg.PathForSRS()
@@ -103,6 +103,7 @@ func newConfigFromFile(path string, withValidation bool) (*Config, error) {
 	cfg.PublicInputInterconnection.ChainID = uint64(cfg.Layer2.ChainID)
 	cfg.PublicInputInterconnection.BaseFee = uint64(cfg.Layer2.BaseFee)
 	cfg.PublicInputInterconnection.L2MsgServiceAddr = cfg.Layer2.MsgSvcContract
+	cfg.PublicInputInterconnection.CoinBase = cfg.Layer2.CoinBase
 
 	return &cfg, nil
 }
@@ -152,10 +153,12 @@ type Config struct {
 		// Use this field when you need the ETH address as a string.
 		MsgSvcContractStr string `mapstructure:"message_service_contract" validate:"required,eth_addr"`
 
-		// CoinbaseStr string `mapstructure:"coinbase" validate:"required,eth_addr"`
+		// CoinBaseStr stores the coinbase address of Linea as a string.
+		CoinBaseStr string `mapstructure:"coin_base" validate:"required,eth_addr"`
 
 		// MsgSvcContract stores the unique ID of the Service Contract (SC), as a common.Address.
 		MsgSvcContract common.Address `mapstructure:"-"`
+		CoinBase       common.Address `mapstructure:"-"`
 	}
 
 	TracesLimits      TracesLimits `mapstructure:"traces_limits" validate:"required"`
@@ -324,7 +327,7 @@ type PublicInput struct {
 	ChainID          uint64         // duplicate from Config
 	BaseFee          uint64         // duplicate from Config
 	L2MsgServiceAddr common.Address // duplicate from Config
-	// Coinbase         common.Address // duplicate from Config
+	CoinBase         common.Address // duplicate from Config
 }
 
 type Debug struct {

prover/public-input/execution.go

@@ -11,8 +11,6 @@ import (
 )
 
 type Execution struct {
-	L2MessageServiceAddr         types.EthAddress
-	ChainID                      uint64
 	InitialBlockTimestamp        uint64
 	FinalStateRootHash           [32]byte
 	FinalBlockNumber             uint64
@@ -25,6 +23,12 @@ type Execution struct {
 	L2MessageHashes              [][32]byte
 	InitialStateRootHash         [32]byte
 	InitialBlockNumber           uint64
+
+	// Dynamic chain config parameters
+	L2MessageServiceAddr types.EthAddress
+	ChainID              uint64
+	BaseFee              uint64
+	CoinBase             types.EthAddress
 }
 
 func (pi *Execution) Sum(hsh hash.Hash) []byte {
@@ -58,6 +62,8 @@ func (pi *Execution) Sum(hsh hash.Hash) []byte {
 	writeNum(hsh, pi.FirstRollingHashUpdateNumber)
 	writeNum(hsh, pi.ChainID)
 	hsh.Write(pi.L2MessageServiceAddr[:])
+	writeNum(hsh, pi.BaseFee)
+	hsh.Write(pi.CoinBase[:])
 
 	return hsh.Sum(nil)
 

prover/zkevm/limitless.go

@@ -1017,6 +1017,8 @@ var publicInputNames = []string{
 	publicInput.NBytesChainID,
 	publicInput.L2MessageServiceAddrHi,
 	publicInput.L2MessageServiceAddrLo,
+	publicInput.BaseFee,
+	publicInput.CoinBase,
 }
 
 // LogPublicInputs logs the list of the public inputs for the module

prover/zkevm/prover/publicInput/execution_data_collector/execution_data_collector.go

@@ -871,7 +871,7 @@ func ProjectionQueries(comp *wizard.CompiledIOP,
 	// compute the fetcher table, directly tied to the arithmetization.
 	timestampTable := []ifaces.Column{
 		timestamps.RelBlock,
-		timestamps.Data,
+		timestamps.DataLo,
 	}
 
 	// compute the ExecutionDataCollector table.
@@ -1311,7 +1311,7 @@ func AssignExecutionDataCollector(run *wizard.ProverRuntime,
 	rlpCt := 0
 	totalCt := 0
 
-	for blockCt := 0; blockCt < timestamps.Data.Size(); blockCt++ {
+	for blockCt := 0; blockCt < timestamps.DataLo.Size(); blockCt++ {
 		isBlockPresent := metadata.FilterFetched.GetColAssignmentAt(run, blockCt)
 		if isBlockPresent.IsOne() {
 			// block-wide information
@@ -1339,7 +1339,7 @@ func AssignExecutionDataCollector(run *wizard.ProverRuntime,
 			totalCt++
 
 			// row 1, load the timestamp
-			fetchedTimestamp := timestamps.Data.GetColAssignmentAt(run, blockCt)
+			fetchedTimestamp := timestamps.DataLo.GetColAssignmentAt(run, blockCt)
 			vect.IsTimestamp[totalCt].SetOne()
 			vect.NoBytes[totalCt].SetInt64(noBytesTimestamp)
 			genericLoadFunction(loadTimestamp, fetchedTimestamp)