package coordinator import ( "context" "fmt" "time" ethCommon "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" "github.com/hermeznetwork/hermez-node/batchbuilder" "github.com/hermeznetwork/hermez-node/common" "github.com/hermeznetwork/hermez-node/db/historydb" "github.com/hermeznetwork/hermez-node/eth" "github.com/hermeznetwork/hermez-node/log" "github.com/hermeznetwork/hermez-node/txselector" ) var errTODO = fmt.Errorf("TODO") // ErrStop is returned when the function is stopped asynchronously via the stop // channel. It doesn't indicate an error. var ErrStop = fmt.Errorf("Stopped") // Config contains the Coordinator configuration type Config struct { ForgerAddress ethCommon.Address } // Coordinator implements the Coordinator type type Coordinator struct { forging bool // rw *sync.RWMutex // isForgeSeq bool // WIP just for testing while implementing config Config batchNum common.BatchNum serverProofPool *ServerProofPool // synchronizer *synchronizer.Synchronizer hdb *historydb.HistoryDB txsel *txselector.TxSelector batchBuilder *batchbuilder.BatchBuilder ethClient eth.ClientInterface ethTxs []*types.Transaction // ethTxStore kvdb.Storage } // NewCoordinator creates a new Coordinator func NewCoordinator(conf Config, hdb *historydb.HistoryDB, txsel *txselector.TxSelector, bb *batchbuilder.BatchBuilder, serverProofs []ServerProofInterface, ethClient eth.ClientInterface) *Coordinator { // once synchronizer is ready, synchronizer.Synchronizer will be passed as parameter here serverProofPool := NewServerProofPool(len(serverProofs)) for _, serverProof := range serverProofs { serverProofPool.Add(serverProof) } c := Coordinator{ config: conf, serverProofPool: serverProofPool, hdb: hdb, txsel: txsel, batchBuilder: bb, ethClient: ethClient, ethTxs: make([]*types.Transaction, 0), // ethTxStore: memory.NewMemoryStorage(), // rw: &sync.RWMutex{}, } return &c } // TODO(Edu): Change the current design of the coordinator structur: // - Move Start and Stop functions (from node/node.go) here // - Add concept of StartPipeline, StopPipeline, that spawns and stops the goroutines // - Add a Manager that calls StartPipeline and StopPipeline, checks when it's time to forge, schedules new batches, etc. // - Add a TxMonitor that monitors successful ForgeBatch ethereum transactions and waits for N blocks of confirmation, and reports back errors to the Manager. // ForgeLoopFn is the function ran in a loop that checks if it's time to forge // and forges a batch if so and sends it to outBatchCh. Returns true if it's // the coordinator turn to forge. func (c *Coordinator) ForgeLoopFn(outBatchCh chan *BatchInfo, stopCh chan bool) (forgetime bool, err error) { // TODO: Move the logic to check if it's forge time or not outside the pipeline isForgeSequence, err := c.isForgeSequence() if err != nil { return false, err } if !isForgeSequence { if c.forging { log.Info("ForgeLoopFn: forging state end") c.forging = false } log.Debug("ForgeLoopFn: not in forge time") return false, nil } log.Debug("ForgeLoopFn: forge time") if !c.forging { // Start pipeline from a batchNum state taken from synchronizer log.Info("ForgeLoopFn: forging state begin") // c.batchNum = c.hdb.GetLastBatchNum() // uncomment when HistoryDB is ready err := c.txsel.Reset(c.batchNum) if err != nil { log.Errorw("ForgeLoopFn: TxSelector.Reset", "error", err) return true, err } err = c.batchBuilder.Reset(c.batchNum, true) if err != nil { log.Errorw("ForgeLoopFn: BatchBuilder.Reset", "error", err) return true, err } // c.batchQueue = NewBatchQueue() c.forging = true } // TODO once synchronizer has this method ready: // If there's been a reorg, handle it // handleReorg() function decides if the reorg must restart the pipeline or not // if c.synchronizer.Reorg(): _ = c.handleReorg() defer func() { if err == ErrStop { log.Info("ForgeLoopFn: forgeLoopFn stopped") } }() // 0. Wait for an available server proof // blocking call serverProof, err := c.serverProofPool.Get(stopCh) if err != nil { return true, err } defer func() { if !forgetime || err != nil { c.serverProofPool.Add(serverProof) } }() log.Debugw("ForgeLoopFn: using serverProof", "server", serverProof) log.Debugw("ForgeLoopFn: forge start") // forge for batchNum = batchNum + 1. batchInfo, err := c.forge(serverProof) if err != nil { log.Errorw("forge", "error", err) return true, err } log.Debugw("ForgeLoopFn: forge end", "batchNum", batchInfo.batchNum) outBatchCh <- batchInfo return true, nil } // GetProofCallForgeLoopFn is the function ran in a loop that gets a forged // batch via inBatchCh, waits for the proof server to finish, calls the ForgeBatch // function in the Rollup Smart Contract, and sends the batch to outBatchCh. func (c *Coordinator) GetProofCallForgeLoopFn(inBatchCh, outBatchCh chan *BatchInfo, stopCh chan bool) (err error) { defer func() { if err == ErrStop { log.Info("GetProofCallForgeLoopFn: forgeLoopFn stopped") } }() select { case <-stopCh: return ErrStop case batchInfo := <-inBatchCh: log.Debugw("GetProofCallForgeLoopFn: getProofCallForge start", "batchNum", batchInfo.batchNum) if err := c.getProofCallForge(batchInfo, stopCh); err != nil { return err } log.Debugw("GetProofCallForgeLoopFn: getProofCallForge end", "batchNum", batchInfo.batchNum) outBatchCh <- batchInfo } return nil } // ForgeCallConfirmLoopFn is the function ran in a loop that gets a batch that // has been sent to the Rollup Smart Contract via inBatchCh and waits for the // ethereum transaction confirmation. func (c *Coordinator) ForgeCallConfirmLoopFn(inBatchCh chan *BatchInfo, stopCh chan bool) (err error) { defer func() { if err == ErrStop { log.Info("ForgeCallConfirmLoopFn: forgeConfirmLoopFn stopped") } }() select { case <-stopCh: return ErrStop case batchInfo := <-inBatchCh: log.Debugw("ForgeCallConfirmLoopFn: forgeCallConfirm start", "batchNum", batchInfo.batchNum) if err := c.forgeCallConfirm(batchInfo, stopCh); err != nil { return err } log.Debugw("ForgeCallConfirmLoopFn: forgeCallConfirm end", "batchNum", batchInfo.batchNum) } return nil } func (c *Coordinator) forge(serverProof ServerProofInterface) (*BatchInfo, error) { // remove transactions from the pool that have been there for too long err := c.purgeRemoveByTimeout() if err != nil { return nil, err } c.batchNum = c.batchNum + 1 batchInfo := NewBatchInfo(c.batchNum, serverProof) // to accumulate metadata of the batch var poolL2Txs []common.PoolL2Tx // var feesInfo var l1UserTxsExtra, l1OperatorTxs []common.L1Tx // 1. Decide if we forge L2Tx or L1+L2Tx if c.shouldL1L2Batch() { // 2a: L1+L2 txs // l1UserTxs, toForgeL1TxsNumber := c.hdb.GetNextL1UserTxs() // TODO once HistoryDB is ready, uncomment var l1UserTxs []common.L1Tx = nil // tmp, depends on HistoryDB l1UserTxsExtra, l1OperatorTxs, poolL2Txs, err = c.txsel.GetL1L2TxSelection(c.batchNum, l1UserTxs) // TODO once feesInfo is added to method return, add the var if err != nil { return nil, err } } else { // 2b: only L2 txs poolL2Txs, err = c.txsel.GetL2TxSelection(c.batchNum) // TODO once feesInfo is added to method return, add the var if err != nil { return nil, err } l1UserTxsExtra = nil l1OperatorTxs = nil } // Run purger to invalidate transactions that become invalid beause of // the poolL2Txs selected. Will mark as invalid the txs that have a // (fromIdx, nonce) which already appears in the selected txs (includes // all the nonces smaller than the current one) err = c.purgeInvalidDueToL2TxsSelection(poolL2Txs) if err != nil { return nil, err } // 3. Save metadata from TxSelector output for BatchNum batchInfo.SetTxsInfo(l1UserTxsExtra, l1OperatorTxs, poolL2Txs) // TODO feesInfo // 4. Call BatchBuilder with TxSelector output configBatch := &batchbuilder.ConfigBatch{ ForgerAddress: c.config.ForgerAddress, } zkInputs, err := c.batchBuilder.BuildBatch(configBatch, l1UserTxsExtra, l1OperatorTxs, poolL2Txs, nil) // TODO []common.TokenID --> feesInfo if err != nil { return nil, err } // 5. Save metadata from BatchBuilder output for BatchNum batchInfo.SetZKInputs(zkInputs) // 6. Call an idle server proof with BatchBuilder output, save server proof info for batchNum err = batchInfo.serverProof.CalculateProof(zkInputs) if err != nil { return nil, err } return &batchInfo, nil } // getProofCallForge gets the generated zkProof & sends it to the SmartContract func (c *Coordinator) getProofCallForge(batchInfo *BatchInfo, stopCh chan bool) error { serverProof := batchInfo.serverProof proof, err := serverProof.GetProof(stopCh) // blocking call, until not resolved don't continue. Returns when the proof server has calculated the proof c.serverProofPool.Add(serverProof) batchInfo.serverProof = nil if err != nil { return err } batchInfo.SetProof(proof) forgeBatchArgs := c.prepareForgeBatchArgs(batchInfo) ethTx, err := c.ethClient.RollupForgeBatch(forgeBatchArgs) if err != nil { return err } // TODO: Move this to the next step (forgeCallConfirm) log.Debugf("ethClient ForgeCall sent, batchNum: %d", c.batchNum) batchInfo.SetEthTx(ethTx) // TODO(FUTURE) once tx data type is defined, store ethTx (returned by ForgeCall) // TBD if use ethTxStore as a disk k-v database, or use a Queue // tx, err := c.ethTxStore.NewTx() // if err != nil { // return err // } // tx.Put(ethTx.Hash(), ethTx.Bytes()) // if err := tx.Commit(); err!=nil { // return nil // } return nil } func (c *Coordinator) forgeCallConfirm(batchInfo *BatchInfo, stopCh chan bool) error { // TODO strategy of this sequence TBD // confirm eth txs and mark them as accepted sequence // IDEA: Keep an array in Coordinator with the list of sent ethTx. // Here, loop over them and only delete them once the number of // confirmed blocks is over a configured value. If the tx is rejected, // return error. // ethTx := ethTxStore.GetFirstPending() // waitForAccepted(ethTx) // blocking call, returns once the ethTx is mined // ethTxStore.MarkAccepted(ethTx) txID := batchInfo.ethTx.Hash() // TODO: Follow EthereumClient.waitReceipt logic count := 0 // TODO: Define this waitTime in the config waitTime := 100 * time.Millisecond //nolint:gomnd select { case <-time.After(waitTime): receipt, err := c.ethClient.EthTransactionReceipt(context.TODO(), txID) if err != nil { return err } if receipt != nil { if receipt.Status == types.ReceiptStatusFailed { return fmt.Errorf("receipt status is failed") } else if receipt.Status == types.ReceiptStatusSuccessful { return nil } } // TODO: Call go-ethereum: // if err == nil && receipt == nil : // `func (ec *Client) TransactionByHash(ctx context.Context, hash common.Hash) (tx *types.Transaction, isPending bool, err error) {` count++ if time.Duration(count)*waitTime > 60*time.Second { log.Warnw("Waiting for ethTx receipt for more than 60 seconds", "tx", batchInfo.ethTx) // TODO: Decide if we resend the Tx with higher gas price } case <-stopCh: return ErrStop } return fmt.Errorf("timeout") } func (c *Coordinator) handleReorg() error { return nil // TODO } // isForgeSequence returns true if the node is the Forger in the current ethereum block func (c *Coordinator) isForgeSequence() (bool, error) { // TODO: Consider checking if we can forge by quering the Synchronizer instead of using ethClient blockNum, err := c.ethClient.EthCurrentBlock() if err != nil { return false, err } addr, err := c.ethClient.EthAddress() if err != nil { return false, err } return c.ethClient.AuctionCanForge(*addr, blockNum+1) } func (c *Coordinator) purgeRemoveByTimeout() error { return nil // TODO } func (c *Coordinator) purgeInvalidDueToL2TxsSelection(l2Txs []common.PoolL2Tx) error { return nil // TODO } func (c *Coordinator) shouldL1L2Batch() bool { return false // TODO } func (c *Coordinator) prepareForgeBatchArgs(batchInfo *BatchInfo) *eth.RollupForgeBatchArgs { // TODO return ð.RollupForgeBatchArgs{} }