CI: test: use bor in matic-cli

.github/workflows/ci.yml

@@ -143,7 +143,9 @@ jobs:
             bash docker-heimdall-start-all.sh
             bash docker-bor-setup.sh
             bash docker-bor-start-all.sh
+            cd code/
             timeout 2m bash bor/integration-tests/bor_health.sh
+            cd -
             bash ganache-deployment-bor.sh
             bash ganache-deployment-sync.sh
 

builder/files/genesis-testnet-v4.json

@@ -15,19 +15,24 @@
     "londonBlock": 22640000,
     "bor": {
       "jaipurBlock": 22770000,
+      "delhiBlock": 29638656,
       "period": {
         "0": 2,
-        "25275000": 5
+        "25275000": 5,
+        "29638656": 2
       },
       "producerDelay": {
-        "0": 6
+        "0": 6,
+        "29638656": 4
       },
       "sprint": {
-        "0": 64
+        "0": 64,
+        "29638656": 16
       },
       "backupMultiplier": {
         "0": 2,
-        "25275000": 5
+        "25275000": 5,
+        "29638656": 2
       },
       "validatorContract": "0x0000000000000000000000000000000000001000",
       "stateReceiverContract": "0x0000000000000000000000000000000000001001",

cmd/utils/flags.go

@@ -1504,7 +1504,7 @@ func setPeerRequiredBlocks(ctx *cli.Context, cfg *ethconfig.Config) {
 
 	if peerRequiredBlocks == "" {
 		if ctx.GlobalIsSet(LegacyWhitelistFlag.Name) {
-			log.Warn("The flag --rpc is deprecated and will be removed, please use --peer.requiredblocks")
+			log.Warn("The flag --whitelist is deprecated and will be removed, please use --eth.requiredblocks")
 			peerRequiredBlocks = ctx.GlobalString(LegacyWhitelistFlag.Name)
 		} else {
 			return

eth/filters/api.go

@@ -416,10 +416,20 @@ func (api *PublicFilterAPI) GetFilterLogs(ctx context.Context, id rpc.ID) ([]*ty
 		return nil, fmt.Errorf("filter not found")
 	}
 
+	borConfig := api.chainConfig.Bor
+
 	var filter *Filter
+
+	var borLogsFilter *BorBlockLogsFilter
+
 	if f.crit.BlockHash != nil {
 		// Block filter requested, construct a single-shot filter
 		filter = NewBlockFilter(api.backend, *f.crit.BlockHash, f.crit.Addresses, f.crit.Topics)
+
+		// Block bor filter
+		if api.borLogs {
+			borLogsFilter = NewBorBlockLogsFilter(api.backend, borConfig, *f.crit.BlockHash, f.crit.Addresses, f.crit.Topics)
+		}
 	} else {
 		// Convert the RPC block numbers into internal representations
 		begin := rpc.LatestBlockNumber.Int64()
@@ -432,12 +442,27 @@ func (api *PublicFilterAPI) GetFilterLogs(ctx context.Context, id rpc.ID) ([]*ty
 		}
 		// Construct the range filter
 		filter = NewRangeFilter(api.backend, begin, end, f.crit.Addresses, f.crit.Topics)
+
+		if api.borLogs {
+			borLogsFilter = NewBorBlockLogsRangeFilter(api.backend, borConfig, begin, end, f.crit.Addresses, f.crit.Topics)
+		}
 	}
 	// Run the filter and return all the logs
 	logs, err := filter.Logs(ctx)
 	if err != nil {
 		return nil, err
 	}
+
+	if borLogsFilter != nil {
+		// Run the filter and return all the logs
+		borBlockLogs, err := borLogsFilter.Logs(ctx)
+		if err != nil {
+			return nil, err
+		}
+
+		return returnLogs(types.MergeBorLogs(logs, borBlockLogs)), nil
+	}
+
 	return returnLogs(logs), nil
 }
 

eth/sync.go

@@ -230,7 +230,7 @@ func (cs *chainSyncer) modeAndLocalHead() (downloader.SyncMode, *big.Int) {
 	// 		return downloader.SnapSync, td
 	// 	}
 	// }
-	// Nope, we're really full syncing
+	// // Nope, we're really full syncing
 	// head := cs.handler.chain.CurrentBlock()
 	// td := cs.handler.chain.GetTd(head.Hash(), head.NumberU64())
 	// return downloader.FullSync, td

integration-tests/bor_health.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+set -e
+
+while true
+do
+    peers=$(docker exec bor0 bash -c "bor attach /root/.bor/data/bor.ipc -exec 'admin.peers'")
+    block-$(docker exec bor0 bash -c "bor attach /root/.bor/data/bor.ipc -exec 'eth.blockNumber'")
+
+    if [[ -n "$peers" ]] && [[ -n "$block" ]] then
+        break
+    fi
+done

internal/cli/server/chains/mumbai.go

@@ -30,19 +30,24 @@ var mumbaiTestnet = &Chain{
 			LondonBlock:         big.NewInt(22640000),
 			Bor: &params.BorConfig{
 				JaipurBlock: big.NewInt(22770000),
+				DelhiBlock:  big.NewInt(29638656),
 				Period: map[string]uint64{
 					"0":        2,
 					"25275000": 5,
+					"29638656": 2,
 				},
 				ProducerDelay: map[string]uint64{
-					"0": 6,
+					"0":        6,
+					"29638656": 4,
 				},
 				Sprint: map[string]uint64{
-					"0": 64,
+					"0":        64,
+					"29638656": 16,
 				},
 				BackupMultiplier: map[string]uint64{
 					"0":        2,
 					"25275000": 5,
+					"29638656": 2,
 				},
 				ValidatorContract:     "0x0000000000000000000000000000000000001000",
 				StateReceiverContract: "0x0000000000000000000000000000000000001001",

internal/cli/server/chains/test_files/chain_legacy_test.json

@@ -17,17 +17,21 @@
     "bor": {
       "period": {
         "0": 2,
-        "25275000": 5
+        "25275000": 5,
+        "29638656": 2
       },
       "producerDelay": {
-        "0": 6
+        "0": 6,
+        "29638656": 4
       },
       "sprint": {
-        "0": 64
+        "0": 64,
+        "29638656": 16
       },
       "backupMultiplier": {
         "0": 2,
-        "25275000": 5
+        "25275000": 5,
+        "29638656": 2
       },
       "validatorContract": "0x0000000000000000000000000000000000001000",
       "stateReceiverContract": "0x0000000000000000000000000000000000001001",
@@ -43,7 +47,8 @@
       "burntContract": {
         "22640000": "0x70bcA57F4579f58670aB2d18Ef16e02C17553C38"
       },
-      "jaipurBlock": 22770000
+      "jaipurBlock": 22770000,
+      "delhiBlock": 29638656
     }
   },
   "nonce": "0x0",

internal/cli/server/chains/test_files/chain_test.json

@@ -19,17 +19,21 @@
         "bor":{
           "period":{
             "0":2,
-            "25275000": 5
+            "25275000": 5,
+            "29638656": 2
           },
           "producerDelay":{
-            "0": 6
+            "0": 6,
+            "29638656": 4
           },
           "sprint":{
-            "0": 64
+            "0": 64,
+            "29638656": 16
           },
           "backupMultiplier":{
             "0": 2,
-            "25275000": 5
+            "25275000": 5,
+            "29638656": 2
           },
           "validatorContract":"0x0000000000000000000000000000000000001000",
           "stateReceiverContract":"0x0000000000000000000000000000000000001001",
@@ -45,7 +49,8 @@
           "burntContract":{
             "22640000":"0x70bcA57F4579f58670aB2d18Ef16e02C17553C38"
           },
-          "jaipurBlock":22770000
+          "jaipurBlock":22770000,
+          "delhiBlock": 29638656
         }
       },
       "nonce":"0x0",

internal/cli/server/command.go

@@ -41,7 +41,7 @@ func (c *Command) MarkDown() string {
 // Help implements the cli.Command interface
 func (c *Command) Help() string {
 	return `Usage: bor [options]
-  
+
 	Run the Bor server.
   ` + c.Flags().Help()
 }

internal/ethapi/api.go

@@ -1615,6 +1615,26 @@ type PublicTransactionPoolAPI struct {
 	signer    types.Signer
 }
 
+// returns block transactions along with state-sync transaction if present
+// nolint: unparam
+func (api *PublicTransactionPoolAPI) getAllBlockTransactions(ctx context.Context, block *types.Block) (types.Transactions, bool) {
+	txs := block.Transactions()
+
+	stateSyncPresent := false
+
+	borReceipt := rawdb.ReadBorReceipt(api.b.ChainDb(), block.Hash(), block.NumberU64())
+	if borReceipt != nil {
+		txHash := types.GetDerivedBorTxHash(types.BorReceiptKey(block.Number().Uint64(), block.Hash()))
+		if txHash != (common.Hash{}) {
+			borTx, _, _, _, _ := api.b.GetBorBlockTransactionWithBlockHash(ctx, txHash, block.Hash())
+			txs = append(txs, borTx)
+			stateSyncPresent = true
+		}
+	}
+
+	return txs, stateSyncPresent
+}
+
 // NewPublicTransactionPoolAPI creates a new RPC service with methods specific for the transaction pool.
 func NewPublicTransactionPoolAPI(b Backend, nonceLock *AddrLocker) *PublicTransactionPoolAPI {
 	// The signer used by the API should always be the 'latest' known one because we expect
@@ -1626,7 +1646,8 @@ func NewPublicTransactionPoolAPI(b Backend, nonceLock *AddrLocker) *PublicTransa
 // GetBlockTransactionCountByNumber returns the number of transactions in the block with the given block number.
 func (s *PublicTransactionPoolAPI) GetBlockTransactionCountByNumber(ctx context.Context, blockNr rpc.BlockNumber) *hexutil.Uint {
 	if block, _ := s.b.BlockByNumber(ctx, blockNr); block != nil {
-		n := hexutil.Uint(len(block.Transactions()))
+		txs, _ := s.getAllBlockTransactions(ctx, block)
+		n := hexutil.Uint(len(txs))
 		return &n
 	}
 	return nil
@@ -1635,7 +1656,8 @@ func (s *PublicTransactionPoolAPI) GetBlockTransactionCountByNumber(ctx context.
 // GetBlockTransactionCountByHash returns the number of transactions in the block with the given hash.
 func (s *PublicTransactionPoolAPI) GetBlockTransactionCountByHash(ctx context.Context, blockHash common.Hash) *hexutil.Uint {
 	if block, _ := s.b.BlockByHash(ctx, blockHash); block != nil {
-		n := hexutil.Uint(len(block.Transactions()))
+		txs, _ := s.getAllBlockTransactions(ctx, block)
+		n := hexutil.Uint(len(txs))
 		return &n
 	}
 	return nil

params/config.go

@@ -350,19 +350,24 @@ var (
 		LondonBlock:         big.NewInt(22640000),
 		Bor: &BorConfig{
 			JaipurBlock: big.NewInt(22770000),
+			DelhiBlock:  big.NewInt(29638656),
 			Period: map[string]uint64{
 				"0":        2,
 				"25275000": 5,
+				"29638656": 2,
 			},
 			ProducerDelay: map[string]uint64{
-				"0": 6,
+				"0":        6,
+				"29638656": 4,
 			},
 			Sprint: map[string]uint64{
-				"0": 64,
+				"0":        64,
+				"29638656": 16,
 			},
 			BackupMultiplier: map[string]uint64{
 				"0":        2,
 				"25275000": 5,
+				"29638656": 2,
 			},
 			ValidatorContract:     "0x0000000000000000000000000000000000001000",
 			StateReceiverContract: "0x0000000000000000000000000000000000001001",

params/version.go

@@ -21,10 +21,10 @@ import (
 )
 
 const (
-	VersionMajor = 0      // Major version component of the current release
+	VersionMajor = 0        // Major version component of the current release
-	VersionMinor = 3      // Minor version component of the current release
+	VersionMinor = 3        // Minor version component of the current release
-	VersionPatch = 1      // Patch version component of the current release
+	VersionPatch = 1        // Patch version component of the current release
-	VersionMeta  = "beta" // Version metadata to append to the version string
+	VersionMeta  = "mumbai" // Version metadata to append to the version string
 )
 
 // Version holds the textual version string.