github.com/0xPolygon/supernets2-node@v0.0.0-20230711153321-2fe574524eaa/sequencer/closingsignalsmanager_test.go (about)

     1  package sequencer
     2  
     3  import (
     4  	"context"
     5  	"fmt"
     6  	"testing"
     7  	"time"
     8  
     9  	"github.com/0xPolygon/supernets2-node/db"
    10  	"github.com/0xPolygon/supernets2-node/event"
    11  	"github.com/0xPolygon/supernets2-node/event/nileventstorage"
    12  	"github.com/0xPolygon/supernets2-node/log"
    13  	"github.com/0xPolygon/supernets2-node/merkletree"
    14  	mtDBclientpb "github.com/0xPolygon/supernets2-node/merkletree/pb"
    15  	"github.com/0xPolygon/supernets2-node/state"
    16  	"github.com/0xPolygon/supernets2-node/state/runtime/executor"
    17  	executorclientpb "github.com/0xPolygon/supernets2-node/state/runtime/executor/pb"
    18  	"github.com/0xPolygon/supernets2-node/test/dbutils"
    19  	"github.com/0xPolygon/supernets2-node/test/testutils"
    20  	"github.com/ethereum/go-ethereum/common"
    21  	"github.com/jackc/pgx/v4/pgxpool"
    22  	"github.com/stretchr/testify/assert"
    23  	"github.com/stretchr/testify/require"
    24  	"google.golang.org/grpc"
    25  )
    26  
    27  const numberOfForcesBatches = 10
    28  
    29  var (
    30  	localStateDb                                 *pgxpool.Pool
    31  	localTestDbManager                           *dbManager
    32  	localCtx                                     context.Context
    33  	localMtDBCancel, localExecutorCancel         context.CancelFunc
    34  	localMtDBServiceClient                       mtDBclientpb.StateDBServiceClient
    35  	localMtDBClientConn, localExecutorClientConn *grpc.ClientConn
    36  	localState                                   *state.State
    37  	localExecutorClient                          executorclientpb.ExecutorServiceClient
    38  	testGER                                      = common.HexToAddress("0x617b3a3528F9cDd6630fd3301B9c8911F7Bf063D")
    39  	testAddr                                     = common.HexToAddress("0x617b3a3528F9cDd6630fd3301B9c8911F7Bf063D")
    40  	testRawData                                  = common.Hex2Bytes("0xee80843b9aca00830186a0944d5cf5032b2a844602278b01199ed191a86c93ff88016345785d8a0000808203e880801cee7e01dc62f69a12c3510c6d64de04ee6346d84b6a017f3e786c7d87f963e75d8cc91fa983cd6d9cf55fff80d73bd26cd333b0f098acc1e58edb1fd484ad731b")
    41  )
    42  
    43  type mocks struct {
    44  	Etherman *EthermanMock
    45  }
    46  
    47  func setupTest(t *testing.T) {
    48  	initOrResetDB()
    49  
    50  	localCtx = context.Background()
    51  
    52  	localStateDb, err = db.NewSQLDB(dbutils.NewStateConfigFromEnv())
    53  	if err != nil {
    54  		panic(err)
    55  	}
    56  
    57  	zkProverURI := testutils.GetEnv("ZKPROVER_URI", "localhost")
    58  	localMtDBServerConfig := merkletree.Config{URI: fmt.Sprintf("%s:50061", zkProverURI)}
    59  	localExecutorServerConfig := executor.Config{URI: fmt.Sprintf("%s:50071", zkProverURI)}
    60  
    61  	localExecutorClient, localExecutorClientConn, localExecutorCancel = executor.NewExecutorClient(localCtx, localExecutorServerConfig)
    62  	s := localExecutorClientConn.GetState()
    63  	log.Infof("executorClientConn state: %s", s.String())
    64  
    65  	localMtDBServiceClient, localMtDBClientConn, localMtDBCancel = merkletree.NewMTDBServiceClient(localCtx, localMtDBServerConfig)
    66  	s = localMtDBClientConn.GetState()
    67  	log.Infof("localStateDbClientConn state: %s", s.String())
    68  
    69  	eventStorage, err := nileventstorage.NewNilEventStorage()
    70  	if err != nil {
    71  		panic(err)
    72  	}
    73  	eventLog := event.NewEventLog(event.Config{}, eventStorage)
    74  
    75  	localStateTree := merkletree.NewStateTree(localMtDBServiceClient)
    76  	localState = state.NewState(stateCfg, state.NewPostgresStorage(localStateDb), localExecutorClient, localStateTree, eventLog)
    77  
    78  	batchConstraints := batchConstraints{
    79  		MaxTxsPerBatch:       150,
    80  		MaxBatchBytesSize:    129848,
    81  		MaxCumulativeGasUsed: 30000000,
    82  		MaxKeccakHashes:      468,
    83  		MaxPoseidonHashes:    279620,
    84  		MaxPoseidonPaddings:  149796,
    85  		MaxMemAligns:         262144,
    86  		MaxArithmetics:       262144,
    87  		MaxBinaries:          262144,
    88  		MaxSteps:             8388608,
    89  	}
    90  
    91  	localTestDbManager = newDBManager(localCtx, dbManagerCfg, nil, localState, nil, closingSignalCh, txsStore, batchConstraints)
    92  
    93  	// Set genesis batch
    94  	dbTx, err := localState.BeginStateTransaction(localCtx)
    95  	require.NoError(t, err)
    96  	_, err = localState.SetGenesis(localCtx, state.Block{}, state.Genesis{}, dbTx)
    97  	require.NoError(t, err)
    98  	require.NoError(t, dbTx.Commit(localCtx))
    99  }
   100  
   101  func cleanup(t *testing.T) {
   102  	localMtDBCancel()
   103  	localMtDBClientConn.Close()
   104  	localExecutorCancel()
   105  	localExecutorClientConn.Close()
   106  }
   107  
   108  func prepareForcedBatches(t *testing.T) {
   109  	// Create block
   110  	const sql = `INSERT INTO state.forced_batch (forced_batch_num, global_exit_root, timestamp, raw_txs_data, coinbase, block_num) VALUES ($1, $2, $3, $4, $5, $6)`
   111  
   112  	for x := 0; x < numberOfForcesBatches; x++ {
   113  		forcedBatchNum := int64(x)
   114  		_, err := localState.PostgresStorage.Exec(localCtx, sql, forcedBatchNum, testGER.String(), time.Now(), testRawData, testAddr.String(), 0)
   115  		assert.NoError(t, err)
   116  	}
   117  }
   118  
   119  func TestClosingSignalsManager(t *testing.T) {
   120  	m := mocks{
   121  		Etherman: NewEthermanMock(t),
   122  	}
   123  
   124  	setupTest(t)
   125  	channels := ClosingSignalCh{
   126  		ForcedBatchCh: make(chan state.ForcedBatch),
   127  	}
   128  
   129  	prepareForcedBatches(t)
   130  	closingSignalsManager := newClosingSignalsManager(localCtx, localTestDbManager, channels, cfg, m.Etherman)
   131  	closingSignalsManager.Start()
   132  
   133  	newCtx, cancelFunc := context.WithTimeout(localCtx, time.Second*3)
   134  	defer cancelFunc()
   135  
   136  	var fb *state.ForcedBatch
   137  
   138  	for {
   139  		select {
   140  		case <-newCtx.Done():
   141  			log.Infof("received context done, Err: %s", newCtx.Err())
   142  			return
   143  		// Forced  batch ch
   144  		case fb := <-channels.ForcedBatchCh:
   145  			log.Debug("Forced batch received", "forced batch", fb)
   146  		}
   147  
   148  		if fb != nil {
   149  			break
   150  		}
   151  	}
   152  
   153  	require.NotEqual(t, (*state.ForcedBatch)(nil), fb)
   154  	require.Equal(t, nil, fb.BlockNumber)
   155  	require.Equal(t, int64(1), fb.ForcedBatchNumber)
   156  	require.Equal(t, testGER, fb.GlobalExitRoot)
   157  	require.Equal(t, testAddr, fb.Sequencer)
   158  	require.Equal(t, testRawData, fb.RawTxsData)
   159  
   160  	cleanup(t)
   161  }