adding interfaces for the aggregator and sequencer

aggregator/aggregator.go

@@ -0,0 +1,39 @@
+package aggregator
+
+import "github.com/ethereum/go-ethereum/core/types"
+
+type Aggregator struct {
+	State          state.State
+	BatchProcessor state.BatchProcessor
+	EthClient      eth.Client
+	Synchronizer   SynchronizerClient
+}
+
+func NewAggregator(cfg Config) (Aggregator, error) {
+	state := state.NewState()
+	bp := state.NewBatchProcessor(cfg.StartingHash, cfg.WithProofCalulation)
+	ethClient := eth.NewClient()
+	synchronizerClient := NewSynchronizerClient()
+	return Aggregator{
+		State:          state,
+		BatchProcessor: bp,
+		EthClient:      ethClient,
+		Synchronizer:   synchronizerClient,
+	}, nil
+}
+
+func (agr *Aggregator) generateAndSendProofs() {
+	// reads from batchesChan
+	// TODO: get txs from MT by batchNum
+	// check if it's profitable or not
+	// send proof + txs to the prover
+	// send proof + txs to the SC
+}
+
+func (agr *Aggregator) isProfitable(txs []types.Transaction) bool {
+	// get strategy from the config and check
+}
+
+func (agr *Aggregator) Run() {
+
+}

aggregator/cmd/main.go

@@ -0,0 +1,5 @@
+package cmd
+
+func main() {
+
+}

aggregator/config.go

@@ -0,0 +1,4 @@
+package aggregator
+
+type Config struct {
+}

aggregator/go.mod

@@ -0,0 +1,5 @@
+module aggregator
+
+go 1.16
+
+require github.com/ethereum/go-ethereum v1.10.12

aggregator/prover.go

@@ -0,0 +1,8 @@
+package aggregator
+
+type ProverClient struct {
+}
+
+func NewProverClient() ProverClient {
+	return ProverClient{}
+}

aggregator/syncronizer.go

@@ -0,0 +1,18 @@
+package aggregator
+
+import "math/big"
+
+type SyncEvent struct {
+	LastStateRoot *big.Int
+	// ??? which type proof will be?
+	Proof *big.Int
+}
+
+type SynchronizerClient struct {
+	SyncEventChan chan SyncEvent
+}
+
+func NewSynchronizerClient() SynchronizerClient {
+	syncEventChan := make(chan SyncEvent)
+	return SynchronizerClient{SyncEventChan: syncEventChan}
+}

go.mod

@@ -1,3 +1,9 @@
 module github.com/hermeznetwork/hermez-core
 
 go 1.16
+
+require (
+	github.com/ethereum/go-ethereum v1.10.12
+	github.com/jmoiron/sqlx v1.3.4
+	github.com/lib/pq v1.10.4
+)

pool/pool.go

@@ -0,0 +1,40 @@
+package pool
+
+import (
+	"time"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/jmoiron/sqlx"
+	//nolint:errcheck // driver for postgres DB
+	_ "github.com/lib/pq"
+)
+
+type Pool struct {
+	db     *sqlx.DB
+	ttl    time.Duration
+	maxTxs uint32
+}
+
+func NewPool(
+	db *sqlx.DB,
+	ttl time.Duration,
+	maxTxs uint32,
+) *Pool {
+	return &Pool{
+		db:     db,
+		ttl:    ttl,
+		maxTxs: maxTxs,
+	}
+}
+
+func (pool *Pool) GetPendingTxs() ([]Transaction, error) {
+	panic("not implemented")
+}
+
+func (pool *Pool) UpdateTxState(hash common.Hash, newState TxState) error {
+	panic("not implemented")
+}
+
+func (pool *Pool) CleanUpInvalidAndNonSelectedTx() error {
+	panic("not implemented")
+}

pool/transaction.go

@@ -0,0 +1,16 @@
+package pool
+
+import "github.com/ethereum/go-ethereum/core/types"
+
+type TxState string
+
+const (
+	TxStatePending  TxState = "pending"
+	TxStateInvalid  TxState = "invalid"
+	TxStateSelected TxState = "selected"
+)
+
+type Transaction struct {
+	types.Transaction
+	state TxState
+}

sequencer/cmd/main.go

@@ -0,0 +1,5 @@
+package cmd
+
+func main() {
+
+}

sequencer/config.go

@@ -0,0 +1,4 @@
+package sequencer
+
+type Config struct {
+}

sequencer/go.mod

@@ -0,0 +1,9 @@
+module github.com/hermeznetwork/hermez-core/sequencer
+
+go 1.16
+
+require (
+	github.com/ethereum/go-ethereum v1.10.12
+	github.com/jmoiron/sqlx v1.3.4
+	github.com/lib/pq v1.2.0
+)

sequencer/sequencer.go

@@ -0,0 +1,62 @@
+package sequencer
+
+import (
+	"github.com/hermeznetwork/hermez-core/pool"
+	"github.com/jmoiron/sqlx"
+	"time"
+)
+
+type Sequencer struct {
+	Pool               pool.Pool
+	State              state.State
+	BatchProcessor     state.BatchProcessor
+	EthClient          eth.Client
+	SynchronizerClient SynchronizerClient
+}
+
+func NewSequencer(cfg Config) (Sequencer, error) {
+	db, err := sqlx.Connect("postgres", "")
+	if err != nil {
+		return Sequencer{}, err
+	}
+	pool := pool.NewPool()
+	state := state.NewState()
+	bp := state.NewBatchProcessor(cfg.StartingHash, cfg.WithProofCalulation)
+	ethClient := eth.NewClient()
+	synchronizer := NewSynchronizerClient()
+	return Sequencer{
+		Pool:           pool,
+		State:          state,
+		EthClient:      ethClient,
+		BatchProcessor: bp,
+		Synchronizer:   synchronizer,
+	}, nil
+}
+
+func (s *Sequencer) Start() {
+	// Infinite for loop:
+	// 1. Wait for synchronizer to sync last batch
+	// 2. Estimate available time to run selection
+	// 3. Run selection
+	// 4. Is selection profitable?
+	// YES: send selection to Ethereum
+	// NO: discard selection and wait for the new batch
+}
+
+type batch struct {
+	txs []pool.Transaction
+}
+
+// selectTxs process txs and split valid txs into batches of txs. This process should be completed in less than selectionTime
+func (s *Sequencer) selectTxs(pendingTxs []pool.Transaction, selectionTime time.Duration) ([]batch, error) {
+	panic("not implemented")
+}
+
+// estimateTime Estimate available time to run selection
+func (s *Sequencer) estimateTime() (time.Duration, error) {
+	panic("not implemented")
+}
+
+func (s *Sequencer) isSelectionProfitable(b batch) bool {
+	panic("not implemented")
+}

sequencer/synchronizer.go

@@ -0,0 +1,16 @@
+package sequencer
+
+type SynchronizerClient struct {
+	IsSynced chan int
+}
+
+func NewSynchronizerClient() SynchronizerClient {
+	// connect to synch to get signal, that it's synced
+	isSynced := make(chan int)
+	return SynchronizerClient{IsSynced: isSynced}
+}
+
+func (sc *SynchronizerClient) subscrToSyncedSignal() {
+	// get signal
+	sc.IsSynced <- 1
+}