improve: splitting the forced batches tests in 3 groups

Signed-off-by: Nikolay Nedkov <nikolai_nedkov@yahoo.com>
0xPolygonHermez · May 26, 2023 · a519b31 · a519b31
1 parent 03f41d0
commit a519b31
Show file tree

Hide file tree

Showing 29 changed files with 491 additions and 14 deletions.
diff --git a/.github/workflows/test-e2e.yml b/.github/workflows/test-e2e.yml
@@ -17,7 +17,7 @@ jobs:
       matrix:
         go-version: [ 1.19.x ]
         goarch: [ "amd64" ]
-        e2e-group: [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]
+        e2e-group: [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 ]
     runs-on: ubuntu-latest
     steps:
     - name: Checkout code

diff --git a/ci/e2e-group9/forced_batches_test.go → ci/e2e-group10/forced_batches_test.go b/ci/e2e-group9/forced_batches_test.go → ci/e2e-group10/forced_batches_test.go
@@ -21,6 +21,15 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+const (
+	toAddressHex      = "0x4d5Cf5032B2a844602278b01199ED191A86c93ff"
+	gerFinalityBlocks = uint64(250)
+)
+
+var (
+	toAddress = common.HexToAddress(toAddressHex)
+)
+
 func TestForcedBatches(t *testing.T) {
 	if testing.Short() {
 		t.Skip()

diff --git a/ci/e2e-group9/forced_batches_vector_test.go → ...up10/forced_batches_vector_group2_test.go b/ci/e2e-group9/forced_batches_vector_test.go → ...up10/forced_batches_vector_group2_test.go
@@ -28,7 +28,7 @@ func TestForcedBatchesVectorFiles(t *testing.T) {
 	if testing.Short() {
 		t.Skip()
 	}
-	vectorFilesDir := "./../vectors/src/state-transition/forced-tx"
+	vectorFilesDir := "./../vectors/src/state-transition/forced-tx/group2"
 	ctx := context.Background()
 	err := filepath.Walk(vectorFilesDir, func(path string, info os.FileInfo, err error) error {
 		if err != nil {

diff --git a/ci/e2e-group11/forced_batches_vector_group3_test.go b/ci/e2e-group11/forced_batches_vector_group3_test.go
@@ -0,0 +1,228 @@
+package e2e
+
+import (
+	"context"
+	"math/big"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/0xPolygonHermez/zkevm-node/etherman/smartcontracts/polygonzkevm"
+	"github.com/0xPolygonHermez/zkevm-node/hex"
+	"github.com/0xPolygonHermez/zkevm-node/log"
+	"github.com/0xPolygonHermez/zkevm-node/state"
+	"github.com/0xPolygonHermez/zkevm-node/test/constants"
+	"github.com/0xPolygonHermez/zkevm-node/test/operations"
+	"github.com/0xPolygonHermez/zkevm-node/test/vectors"
+	"github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/ethclient"
+	"github.com/stretchr/testify/require"
+)
+
+func TestForcedBatchesVectorFiles(t *testing.T) {
+
+	if testing.Short() {
+		t.Skip()
+	}
+	vectorFilesDir := "./../vectors/src/state-transition/forced-tx/group3"
+	ctx := context.Background()
+	err := filepath.Walk(vectorFilesDir, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+		if !info.IsDir() && !strings.HasSuffix(info.Name(), "list.json") {
+
+			t.Run(info.Name(), func(t *testing.T) {
+
+				defer func() {
+					require.NoError(t, operations.Teardown())
+				}()
+
+				// Load test vectors
+				log.Info("=====================================================================")
+				log.Info(path)
+				log.Info("=====================================================================")
+				testCase, err := vectors.LoadStateTransitionTestCaseV2(path)
+				require.NoError(t, err)
+
+				opsCfg := operations.GetDefaultOperationsConfig()
+				opsCfg.State.MaxCumulativeGasUsed = 80000000000
+				opsman, err := operations.NewManager(ctx, opsCfg)
+				require.NoError(t, err)
+
+				// Setting Genesis
+				log.Info("###################")
+				log.Info("# Setting Genesis #")
+				log.Info("###################")
+				genesisActions := vectors.GenerateGenesisActions(testCase.Genesis)
+				require.NoError(t, opsman.SetGenesis(genesisActions))
+				require.NoError(t, opsman.Setup())
+
+				// Check initial root
+				log.Info("################################")
+				log.Info("# Verifying initial state root #")
+				log.Info("################################")
+				actualOldStateRoot, err := opsman.State().GetLastStateRoot(ctx, nil)
+				require.NoError(t, err)
+				require.Equal(t, testCase.ExpectedOldStateRoot, actualOldStateRoot.Hex())
+				decodedData, err := hex.DecodeHex(testCase.BatchL2Data)
+				require.NoError(t, err)
+				_, txBytes, err := state.DecodeTxs(decodedData)
+				forcedBatch, err := sendForcedBatchForVector(t, txBytes, opsman)
+				require.NoError(t, err)
+				actualNewStateRoot := forcedBatch.StateRoot
+				isClosed, err := opsman.State().IsBatchClosed(ctx, forcedBatch.BatchNumber, nil)
+				require.NoError(t, err)
+
+				// wait until is closed
+				for !isClosed {
+					time.Sleep(1 * time.Second)
+					isClosed, err = opsman.State().IsBatchClosed(ctx, forcedBatch.BatchNumber, nil)
+					require.NoError(t, err)
+				}
+
+				log.Info("#######################")
+				log.Info("# Verifying new leafs #")
+				log.Info("#######################")
+				merkleTree := opsman.State().GetTree()
+				for _, expectedNewLeaf := range testCase.ExpectedNewLeafs {
+					if expectedNewLeaf.IsSmartContract {
+						log.Info("Smart Contract Address: ", expectedNewLeaf.Address)
+					} else {
+						log.Info("Account Address: ", expectedNewLeaf.Address)
+					}
+					log.Info("Verifying Balance...")
+					actualBalance, err := merkleTree.GetBalance(ctx, common.HexToAddress(expectedNewLeaf.Address), actualNewStateRoot.Bytes())
+					require.NoError(t, err)
+					require.Equal(t, expectedNewLeaf.Balance.String(), actualBalance.String())
+
+					log.Info("Verifying Nonce...")
+					actualNonce, err := merkleTree.GetNonce(ctx, common.HexToAddress(expectedNewLeaf.Address), actualNewStateRoot.Bytes())
+					require.NoError(t, err)
+					require.Equal(t, expectedNewLeaf.Nonce, actualNonce.String())
+					if expectedNewLeaf.IsSmartContract {
+						log.Info("Verifying Storage...")
+						for positionHex, expectedNewStorageHex := range expectedNewLeaf.Storage {
+							position, ok := big.NewInt(0).SetString(positionHex[2:], 16)
+							require.True(t, ok)
+							expectedNewStorage, ok := big.NewInt(0).SetString(expectedNewStorageHex[2:], 16)
+							require.True(t, ok)
+							actualStorage, err := merkleTree.GetStorageAt(ctx, common.HexToAddress(expectedNewLeaf.Address), position, actualNewStateRoot.Bytes())
+							require.NoError(t, err)
+							require.Equal(t, expectedNewStorage, actualStorage)
+						}
+
+						log.Info("Verifying HashBytecode...")
+						actualHashByteCode, err := merkleTree.GetCodeHash(ctx, common.HexToAddress(expectedNewLeaf.Address), actualNewStateRoot.Bytes())
+						require.NoError(t, err)
+						require.Equal(t, expectedNewLeaf.HashBytecode, common.BytesToHash(actualHashByteCode).String())
+					}
+				}
+				return
+			})
+
+			return nil
+		}
+		return nil
+	})
+	require.NoError(t, err)
+}
+
+func sendForcedBatchForVector(t *testing.T, txs []byte, opsman *operations.Manager) (*state.Batch, error) {
+	ctx := context.Background()
+	st := opsman.State()
+	// Connect to ethereum node
+	ethClient, err := ethclient.Dial(operations.DefaultL1NetworkURL)
+	require.NoError(t, err)
+
+	// Create smc client
+	zkEvmAddr := common.HexToAddress(operations.DefaultL1ZkEVMSmartContract)
+	zkEvm, err := polygonzkevm.NewPolygonzkevm(zkEvmAddr, ethClient)
+	require.NoError(t, err)
+
+	auth, err := operations.GetAuth(operations.DefaultSequencerPrivateKey, operations.DefaultL1ChainID)
+	require.NoError(t, err)
+
+	log.Info("Using address: ", auth.From)
+	num, err := zkEvm.LastForceBatch(&bind.CallOpts{Pending: false})
+	require.NoError(t, err)
+	log.Info("Number of forceBatches in the smc: ", num)
+
+	// Get tip
+	tip, err := zkEvm.GetForcedBatchFee(&bind.CallOpts{Pending: false})
+	require.NoError(t, err)
+
+	disallowed, err := zkEvm.IsForcedBatchDisallowed(&bind.CallOpts{Pending: false})
+	require.NoError(t, err)
+	if disallowed {
+		tx, err := zkEvm.ActivateForceBatches(auth)
+		require.NoError(t, err)
+		err = operations.WaitTxToBeMined(ctx, ethClient, tx, operations.DefaultTimeoutTxToBeMined)
+		require.NoError(t, err)
+	}
+
+	// Send forceBatch
+	tx, err := zkEvm.ForceBatch(auth, txs, tip)
+	require.NoError(t, err)
+
+	log.Info("Forced Batch Submit to L1 TxHash: ", tx.Hash())
+	time.Sleep(1 * time.Second)
+
+	err = operations.WaitTxToBeMined(ctx, ethClient, tx, operations.DefaultTimeoutTxToBeMined)
+	require.NoError(t, err)
+
+	currentBlock, err := ethClient.BlockByNumber(ctx, nil)
+	require.NoError(t, err)
+	log.Debug("currentBlock.Time(): ", currentBlock.Time())
+
+	query := ethereum.FilterQuery{
+		FromBlock: currentBlock.Number(),
+		Addresses: []common.Address{zkEvmAddr},
+	}
+	logs, err := ethClient.FilterLogs(ctx, query)
+	require.NoError(t, err)
+
+	var forcedBatch *state.Batch
+	for _, vLog := range logs {
+		if vLog.Topics[0] != constants.ForcedBatchSignatureHash {
+			logs, err = ethClient.FilterLogs(ctx, query)
+			require.NoError(t, err)
+			continue
+		}
+		fb, err := zkEvm.ParseForceBatch(vLog)
+		if err != nil {
+			log.Errorf("failed to parse force batch log event, err: ", err)
+		}
+		log.Debugf("log decoded: %+v", fb)
+		ger := fb.LastGlobalExitRoot
+		log.Info("GlobalExitRoot: ", ger)
+		log.Info("Transactions: ", common.Bytes2Hex(fb.Transactions))
+		fullBlock, err := ethClient.BlockByHash(ctx, vLog.BlockHash)
+		if err != nil {
+			log.Errorf("error getting hashParent. BlockNumber: %d. Error: %v", vLog.BlockNumber, err)
+			return nil, err
+		}
+		log.Info("MinForcedTimestamp: ", fullBlock.Time())
+		forcedBatch, err = st.GetBatchByForcedBatchNum(ctx, fb.ForceBatchNum, nil)
+		for err == state.ErrStateNotSynchronized {
+			time.Sleep(1 * time.Second)
+			forcedBatch, err = st.GetBatchByForcedBatchNum(ctx, fb.ForceBatchNum, nil)
+		}
+		require.NoError(t, err)
+		require.NotNil(t, forcedBatch)
+
+		log.Info("Waiting Forced Batch to be virtualized ...")
+		err = operations.WaitBatchToBeVirtualized(forcedBatch.BatchNumber, 4*time.Minute, st)
+		require.NoError(t, err)
+
+		log.Info("Waiting Forced Batch to be consolidated ...")
+		err = operations.WaitBatchToBeConsolidated(forcedBatch.BatchNumber, 4*time.Minute, st)
+		require.NoError(t, err)
+	}
+
+	return forcedBatch, nil
+}