Modular aggregator

[arnaubennassar]

This discussion suggest changes to be done in the aggregator component for it to become more flexible, and enable alt implementations and/or different functionalities

Splitting proof aggregation from proof sending

The process of aggregating should be common to any system as long as there are no major changes on the proving schema and protocol.

However on the proof sending part, there is a big dependency on how the settlement layer is implemented (L1 SCs). Therefore it would be interesting to decouple the proof aggregation from the proof verification. In the current implementation this is done as follows:

// This function waits to receive a final proof from a prover. Once it receives
// the proof, it performs these steps in order:
// - send the final proof to L1
// - wait for the synchronizer to catch up
// - clean up the cache of recursive proofs
func (a *Aggregator) sendFinalProof() 

From all the steps performed by this function, the one that should be modularized is send the final proof to L1, actually it's more convinient to assume that L1 will always be Ethereum (or EVM based network), and split this step in two:

• Build the tx: step that should be modularized
• Send the tx: common step

The current implementation modularized should look like this:

package aggregator // aggregator/interfaces.go

// etherman contains the methods required to interact with ethereum
type etherman interface {
	GetLatestVerifiedBatchNum() (uint64, error) // Still needed for handling isSynced
	// BuildTrustedVerifyBatchesTxData(lastVerifiedBatch, newVerifiedBatch uint64, inputs *ethmanTypes.FinalProofInputs) (to *common.Address, data []byte, err error) ==> moved to package verifytxbuilder 
}

// ------

package aggregator // aggregator/aggregator.go

type VerifyTxBuilder interface{
    func BuildVerifyTx (recursiveProof *state.Proof, finalProof *pb.FinalProof) (to *common.Address, data []byte, err error)
}

// New creates a new aggregator.
func New(
	// ...
    l1TxBuilder L1TxBuilder,
    // ...
) (Aggregator, error) {
    // ...
    a := Aggregator{
		// ...
        l1TxBuilder: l1TxBuilder,
        // ...
	}
}

func (a *Aggregator) sendFinalProof() {
	for {
		select {
		case <-a.ctx.Done():
			return
		case msg := <-a.finalProof:
			// ...
            to, data, err := a.l1TxBuilder(proof, msg.finalProof)
			// ...
		}
	}
}

// ------
package verifytxbuilder // aggregator/verifytxbuilder/verifytxbuilder.go

type VerifyTxBuilder struct {
	// state
	// etherman
	// ...
}

func New(/*state, etherman, ...*/) VerifyTxBuilder

func (v *VerifyTxBuilder) BuildVerifyTx (recursiveProof *state.Proof, finalProof *pb.FinalProof) (to *common.Address, data []byte, err error) {
	finalBatch, err := v.State.GetBatchByNumber(ctx, proof.BatchNumberFinal, nil)
	if err != nil {
		return nil, nil, err
	}

	inputs := ethmanTypes.FinalProofInputs{
		FinalProof:       finalProof,
		NewLocalExitRoot: finalBatch.LocalExitRoot.Bytes(),
		NewStateRoot:     finalBatch.StateRoot.Bytes(),
	}

	log.Infof("Final proof inputs: NewLocalExitRoot [%#x], NewStateRoot [%#x]", inputs.NewLocalExitRoot, inputs.NewStateRoot)

	return v.Ethman.BuildTrustedVerifyBatchesTxData(recursiveProof.BatchNumber-1, recursiveProof.BatchNumberFinal, &inputs)
}

With the suggested changes, aggregator should be agnostic to the underlying smart contracts, instead verifytxbuilder should handle the relation between proof aggregation and SC specific logic. Still the ethtxsender abstraction is preserved for monitoring sending an monitoring L1