Prover/limitless backend controller

prover/backend/aggregation/craft.go

@@ -60,7 +60,7 @@ func collectFields(cfg *config.Config, req *Request) (*CollectedFields, error) {
 		var (
 			po              execution.Response
 			l2MessageHashes []string
-			fpath           = path.Join(cfg.Execution.DirTo(), execReqFPath)
+			fpath           = path.Join(cfg.Execution.DirTo(0), execReqFPath)
 			f               = files.MustRead(fpath)
 		)
 
@@ -155,7 +155,7 @@ func collectFields(cfg *config.Config, req *Request) (*CollectedFields, error) {
 
 	for i, decompReqFPath := range req.DecompressionProofs {
 		dp := &blobdecompression.Response{}
-		fpath := path.Join(cfg.BlobDecompression.DirTo(), decompReqFPath)
+		fpath := path.Join(cfg.BlobDecompression.DirTo(0), decompReqFPath)
 		f := files.MustRead(fpath)
 
 		if err := json.NewDecoder(f).Decode(dp); err != nil {

prover/backend/blobsubmission/craft_eip4844.go

@@ -4,6 +4,7 @@ import (
 	"crypto/sha256"
 	"errors"
 	"fmt"
+
 	"github.com/consensys/linea-monorepo/prover/lib/compressor/blob/encode"
 
 	blob "github.com/consensys/linea-monorepo/prover/lib/compressor/blob/v1"
@@ -171,5 +172,4 @@ func compressedStreamToBlob(compressedStream []byte) (blob kzg4844.Blob, err err
 		}
 	}
 	return blob, nil
-
 }

prover/backend/execution/craft.go

@@ -35,14 +35,15 @@ func CraftProverOutput(
 	req *Request,
 ) Response {
 
-	// Split the embedded file contents into a string slice
-	constraintsVersions := strings.Split(strings.TrimSpace(constraintsVersionsStr), "\n")
+	/*
+		// Split the embedded file contents into a string slice
+		constraintsVersions := strings.Split(strings.TrimSpace(constraintsVersionsStr), "\n")
 
-	// Check the arithmetization version used to generate the trace is contained in the prover request
-	// and fail fast if the constraint version is not supported
-	if err := checkArithmetizationVersion(req.ConflatedExecutionTracesFile, req.TracesEngineVersion, constraintsVersions); err != nil {
-		panic(err.Error())
-	}
+		// Check the arithmetization version used to generate the trace is contained in the prover request
+		// and fail fast if the constraint version is not supported
+		if err := checkArithmetizationVersion(req.ConflatedExecutionTracesFile, req.TracesEngineVersion, constraintsVersions); err != nil {
+			panic(err.Error())
+		} */
 
 	var (
 		l2BridgeAddress = cfg.Layer2.MsgSvcContract
@@ -73,7 +74,7 @@ func CraftProverOutput(
 			l2l1MessageHashes = bridge.L2L1MessageHashes(logs, l2BridgeAddress)
 		)
 
-		// This encodes the block as it will be by the compressor before running
+		// This encodes the block as it will be used by the compressor before running
 		// the compression algorithm.
 		blob.EncodeBlockForCompression(block, execDataBuf)
 

prover/backend/execution/limitless/mock.go

@@ -0,0 +1,110 @@
+// THIS FILE IS MEANT ONLY TO BE A PLACEHOLDER AND SERVE AS A MOCK DEFINING THE COMPONENTS REQUIRED
+// FOR LIMITLESS PROVER. THERE ARE NO INTERACTIONS WITH THE ACTUAL CRYPTOGRAPHIC COMPONENTS.
+// EACH COMPONENTS PREFIX BEGINS WITH 'M' SIGNIFYING MOCK.
+// SEE https://app.diagrams.net/#G1U6S4MTrt7lsipc3TZrL4xXjvvVeghc8k#%7B%22pageId%22%3A%2206rcgNj9AqHDneUgptMC%22%7D
+
+package mock
+
+import "github.com/consensys/linea-monorepo/prover/backend/execution"
+
+// Specifies the number of segments ideally set in the config. file
+var segments int
+
+// MBootStrapper initializes the prover with the necessary data
+type MBootStrapper struct {
+}
+
+// MDistMetadata handles metadata about the distribution of module ID/segment ID pairs
+type MDistMetadata struct {
+	// Map from Module ID to Segment ID
+	ModSegMap map[int]int `json:"modSegMap"`
+
+	// Request ID
+	ReqId string `json:"reqId"`
+}
+
+// MSubmoduleGLProver handles global-local proof generation
+type MSubmoduleGLProver struct {
+}
+
+// MGLReq represents a request to the global-local prover
+type MGLReq struct {
+	ReqId                        string `json:"reqId"`
+	ModuleId                     string `json:"moduleId"`
+	SegmentId                    int    `json:"segmentId"`
+	ConflatedExecutionTracesFile string `json:"conflatedExecutionTracesFile"`
+}
+
+// Mocked Public Inputs
+type MPublicInputs struct {
+}
+
+// MGLResp represents a response from the global-local prover
+type MGLResp struct {
+	ModId       string          `json:"modId"`
+	SegmentID   int             `json:"segmentId"`
+	ModProof    string          `json:"modProof"`
+	QueryResult string          `json:"queryResult"`
+	Auxilliary  []MPublicInputs `json:"auxilliary"`
+}
+
+// initBootstrap initializes the bootstrapping process
+// Outputs the submodule request for global-local prover for round 0
+func (b MBootStrapper) initBootstrap(req execution.Request) (MGLReq, MDistMetadata, error) {
+	return MGLReq{}, MDistMetadata{}, nil
+}
+
+// RandomnessBeacon provides randomness for the proof generation process
+type RandomnessBeacon struct {
+}
+
+// MLPPBeaconReq represents a request for LPP beacon data
+type MLPPBeaconReq struct {
+	LPPColumns     []string `json:"lppColumns"`
+	LPPCommitments []string `json:"lppCommitments"`
+	ModuleID       string   `json:"moduleId"`
+}
+
+// generateRandomness generates randomness for the proof generation process
+func (b RandomnessBeacon) generateLPPProofReq(req MLPPBeaconReq, metadata MDistMetadata) (MLPPRequest, error) {
+	return MLPPRequest{}, nil
+}
+
+// proveGL generates a mock GL proof
+func (gl *MSubmoduleGLProver) proveGL(req MGLReq) (MGLResp, error) {
+	dummyProof := MGLResp{}
+	return dummyProof, nil
+}
+
+// MSubmoduleLPPProver handles LPP proof generation
+type MSubmoduleLPPProver struct {
+}
+
+// MLPPRequest represents a request for LPP proof data
+type MLPPRequest struct {
+	LPPReq     MLPPBeaconReq `json:"lppReq"`
+	Randomseed string        `json:"randomseed"`
+}
+
+// MLPPResponse represents a response from the LPP prover
+type MLPPResponse struct {
+	ModuleID            string   `json:"moduleId"`
+	SegmentID           string   `json:"segmentId"`
+	ModuleProof         string   `json:"moduleProof"`
+	QueryPartialResults []string `json:"queryPartialResults"`
+}
+
+// proveLPP generates a mock LPP proof
+func (lpp *MSubmoduleLPPProver) proveLPP(req MLPPRequest) (MLPPResponse, error) {
+	dummyproof := MLPPResponse{}
+	return dummyproof, nil
+}
+
+// MExecConglomerator combines various proofs into a final execution proof
+type MExecConglomerator struct {
+}
+
+// prove combines GL and LPP responses into a final execution proof
+func (cong *MExecConglomerator) prove(glresp MGLResp, lppresp MLPPResponse, dmetadata MDistMetadata) (execution.Response, error) {
+	return execution.Response{}, nil
+}

prover/backend/execution/prove.go

@@ -158,7 +158,7 @@ func mustProveAndPass(
 			utils.Panic("traces checksum in the setup manifest does not match the one in the config")
 		}
 
-		// TODO: implements the collection of the functional inputs from the prover response
+		// TODO: implement the collection of the functional inputs from the prover response
 		return execution.MakeProof(traces, setup, fullZkEvm.WizardIOP, proof, *w.FuncInp), setup.VerifyingKeyDigest()
 
 	case config.ProverModeBench:

prover/cmd/controller/controller/command.go

@@ -44,18 +44,57 @@ func cobraControllerRunCmd(c *cobra.Command, args []string) {
 	}
 	cfg.Controller.LocalID = fLocalID
 
+	// Disable for testing
+	// cfg.Controller.EnableExecution = true
+	// cfg.Controller.EnableBlobDecompression = false
+	// cfg.Controller.EnableAggregation = false
+	// cfg.Controller.EnableExecBootstrap = false
+	// cfg.Controller.EnableExecGL = false
+	// cfg.Controller.EnableExecRndBeacon = false
+	// cfg.Controller.EnableExecLPP = false
+	// cfg.Controller.EnableExecConglomeration = false
+
 	// TODO @gbotrel @AlexandreBelling check who is responsible for creating the directories
 	// create the sub directories if they do not exist
 	dirs := []string{
-		cfg.Execution.DirDone(),
-		cfg.Execution.DirFrom(),
-		cfg.Execution.DirTo(),
-		cfg.BlobDecompression.DirDone(),
-		cfg.BlobDecompression.DirFrom(),
-		cfg.BlobDecompression.DirTo(),
-		cfg.Aggregation.DirDone(),
-		cfg.Aggregation.DirFrom(),
-		cfg.Aggregation.DirTo(),
+		cfg.Execution.DirDone(0),
+		cfg.Execution.DirFrom(0),
+		cfg.Execution.DirTo(0),
+		cfg.BlobDecompression.DirDone(0),
+		cfg.BlobDecompression.DirFrom(0),
+		cfg.BlobDecompression.DirTo(0),
+		cfg.Aggregation.DirDone(0),
+		cfg.Aggregation.DirFrom(0),
+		cfg.Aggregation.DirTo(0),
+
+		// Dirs. for Limitless controller
+		cfg.ExecBootstrap.DirFrom(0),
+		cfg.ExecBootstrap.DirDone(0),
+		cfg.ExecBootstrap.DirTo(0),
+		cfg.ExecBootstrap.DirTo(1),
+
+		cfg.ExecGL.DirFrom(0),
+		cfg.ExecGL.DirDone(0),
+		cfg.ExecGL.DirTo(0),
+		cfg.ExecGL.DirTo(1),
+
+		cfg.ExecRndBeacon.DirFrom(0),
+		cfg.ExecRndBeacon.DirFrom(1),
+		cfg.ExecRndBeacon.DirDone(0),
+		cfg.ExecRndBeacon.DirDone(1),
+		cfg.ExecRndBeacon.DirTo(0),
+
+		cfg.ExecLPP.DirFrom(0),
+		cfg.ExecLPP.DirDone(0),
+		cfg.ExecLPP.DirTo(0),
+
+		cfg.ExecConglomeration.DirFrom(0),
+		cfg.ExecConglomeration.DirFrom(1),
+		cfg.ExecConglomeration.DirFrom(2),
+		cfg.ExecConglomeration.DirDone(0),
+		cfg.ExecConglomeration.DirDone(1),
+		cfg.ExecConglomeration.DirDone(2),
+		cfg.ExecConglomeration.DirTo(0),
 	}
 
 	for _, dir := range dirs {