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

     1  package sequencer
     2  
     3  import (
     4  	"context"
     5  	"fmt"
     6  	"sync"
     7  	"testing"
     8  	"time"
     9  
    10  	"github.com/0xPolygon/supernets2-node/config/types"
    11  	"github.com/0xPolygon/supernets2-node/db"
    12  	"github.com/0xPolygon/supernets2-node/event"
    13  	"github.com/0xPolygon/supernets2-node/event/nileventstorage"
    14  	"github.com/0xPolygon/supernets2-node/log"
    15  	"github.com/0xPolygon/supernets2-node/merkletree"
    16  	mtDBclientpb "github.com/0xPolygon/supernets2-node/merkletree/pb"
    17  	"github.com/0xPolygon/supernets2-node/state"
    18  	executorclientpb "github.com/0xPolygon/supernets2-node/state/runtime/executor/pb"
    19  	"github.com/0xPolygon/supernets2-node/test/dbutils"
    20  	"github.com/0xPolygon/supernets2-node/test/testutils"
    21  	"github.com/ethereum/go-ethereum/common"
    22  	"github.com/jackc/pgx/v4/pgxpool"
    23  	"github.com/stretchr/testify/require"
    24  	"google.golang.org/grpc"
    25  )
    26  
    27  var (
    28  	mtDBCancel context.CancelFunc
    29  	ctx        context.Context
    30  	testState  *state.State
    31  	stateTree  *merkletree.StateTree
    32  	stateDb    *pgxpool.Pool
    33  	err        error
    34  	stateDBCfg = dbutils.NewStateConfigFromEnv()
    35  	stateCfg   = state.Config{
    36  		MaxCumulativeGasUsed: 800000,
    37  		ChainID:              1000,
    38  	}
    39  	dbManagerCfg      = DBManagerCfg{PoolRetrievalInterval: types.NewDuration(500 * time.Millisecond)}
    40  	executorClient    executorclientpb.ExecutorServiceClient
    41  	mtDBServiceClient mtDBclientpb.StateDBServiceClient
    42  	mtDBClientConn    *grpc.ClientConn
    43  	testDbManager     *dbManager
    44  )
    45  
    46  func setupDBManager() {
    47  	initOrResetDB()
    48  	ctx = context.Background()
    49  
    50  	stateDb, err = db.NewSQLDB(stateDBCfg)
    51  	if err != nil {
    52  		panic(err)
    53  	}
    54  
    55  	zkProverURI := testutils.GetEnv("ZKPROVER_URI", "localhost")
    56  	mtDBServerConfig := merkletree.Config{URI: fmt.Sprintf("%s:50061", zkProverURI)}
    57  
    58  	mtDBServiceClient, mtDBClientConn, mtDBCancel = merkletree.NewMTDBServiceClient(ctx, mtDBServerConfig)
    59  	s := mtDBClientConn.GetState()
    60  	log.Infof("stateDbClientConn state: %s", s.String())
    61  
    62  	eventStorage, err := nileventstorage.NewNilEventStorage()
    63  	if err != nil {
    64  		panic(err)
    65  	}
    66  	eventLog := event.NewEventLog(event.Config{}, eventStorage)
    67  
    68  	stateTree = merkletree.NewStateTree(mtDBServiceClient)
    69  	testState = state.NewState(stateCfg, state.NewPostgresStorage(stateDb), executorClient, stateTree, eventLog)
    70  
    71  	// DBManager
    72  	closingSignalCh := ClosingSignalCh{
    73  		ForcedBatchCh: make(chan state.ForcedBatch),
    74  		GERCh:         make(chan common.Hash),
    75  		L2ReorgCh:     make(chan L2ReorgEvent),
    76  	}
    77  
    78  	txsStore := TxsStore{
    79  		Ch: make(chan *txToStore),
    80  		Wg: new(sync.WaitGroup),
    81  	}
    82  
    83  	batchConstraints := batchConstraints{
    84  		MaxTxsPerBatch:       150,
    85  		MaxBatchBytesSize:    129848,
    86  		MaxCumulativeGasUsed: 30000000,
    87  		MaxKeccakHashes:      468,
    88  		MaxPoseidonHashes:    279620,
    89  		MaxPoseidonPaddings:  149796,
    90  		MaxMemAligns:         262144,
    91  		MaxArithmetics:       262144,
    92  		MaxBinaries:          262144,
    93  		MaxSteps:             8388608,
    94  	}
    95  
    96  	testDbManager = newDBManager(ctx, dbManagerCfg, nil, testState, nil, closingSignalCh, txsStore, batchConstraints)
    97  }
    98  
    99  func initOrResetDB() {
   100  	if err := dbutils.InitOrResetState(stateDBCfg); err != nil {
   101  		panic(err)
   102  	}
   103  }
   104  
   105  func cleanupDBManager() {
   106  	mtDBCancel()
   107  	mtDBClientConn.Close()
   108  }
   109  
   110  func TestOpenBatch(t *testing.T) {
   111  	setupDBManager()
   112  	defer stateDb.Close()
   113  
   114  	dbTx, err := testState.BeginStateTransaction(ctx)
   115  	require.NoError(t, err)
   116  
   117  	_, err = testState.SetGenesis(ctx, state.Block{}, state.Genesis{}, dbTx)
   118  	require.NoError(t, err)
   119  
   120  	processingContext := state.ProcessingContext{
   121  		BatchNumber:    1,
   122  		Coinbase:       common.Address{},
   123  		Timestamp:      time.Now().UTC(),
   124  		GlobalExitRoot: common.Hash{},
   125  	}
   126  
   127  	err = testDbManager.OpenBatch(ctx, processingContext, dbTx)
   128  	require.NoError(t, err)
   129  	err = dbTx.Commit(ctx)
   130  	require.NoError(t, err)
   131  	cleanupDBManager()
   132  }
   133  
   134  func TestGetLastBatchNumber(t *testing.T) {
   135  	setupDBManager()
   136  	defer stateDb.Close()
   137  
   138  	dbTx, err := testState.BeginStateTransaction(ctx)
   139  	require.NoError(t, err)
   140  
   141  	_, err = testState.SetGenesis(ctx, state.Block{}, state.Genesis{}, dbTx)
   142  	require.NoError(t, err)
   143  
   144  	processingContext := state.ProcessingContext{
   145  		BatchNumber:    1,
   146  		Coinbase:       common.Address{},
   147  		Timestamp:      time.Now().UTC(),
   148  		GlobalExitRoot: common.Hash{},
   149  	}
   150  
   151  	err = testDbManager.OpenBatch(ctx, processingContext, dbTx)
   152  	require.NoError(t, err)
   153  	err = dbTx.Commit(ctx)
   154  	require.NoError(t, err)
   155  
   156  	lastBatchNum, err := testDbManager.GetLastBatchNumber(ctx)
   157  	require.NoError(t, err)
   158  	require.Equal(t, uint64(1), lastBatchNum)
   159  	cleanupDBManager()
   160  }
   161  
   162  func TestCreateFirstBatch(t *testing.T) {
   163  	setupDBManager()
   164  	defer stateDb.Close()
   165  
   166  	dbTx, err := testState.BeginStateTransaction(ctx)
   167  	require.NoError(t, err)
   168  	_, err = testState.SetGenesis(ctx, state.Block{}, state.Genesis{}, dbTx)
   169  	require.NoError(t, err)
   170  	err = dbTx.Commit(ctx)
   171  	require.NoError(t, err)
   172  
   173  	processingContext := testDbManager.CreateFirstBatch(ctx, common.Address{})
   174  	require.Equal(t, uint64(1), processingContext.BatchNumber)
   175  	cleanupDBManager()
   176  }