forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-07-27 23:26:44 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

CI: test: use bor in matic-cli

Browse source
This commit is contained in:
Raneet Debnath 2022-11-25 12:19:20 +05:30
commit ca5fbadd70
13 changed files with 113 additions and 27 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
.github/workflows/ci.yml vendored
View file

@ -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

13
builder/files/genesis-testnet-v4.json
View file

@ -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",

2
cmd/utils/flags.go
View file

@ -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

25
eth/filters/api.go
View file

@ -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
}

2
eth/sync.go
View file

@ -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

12
integration-tests/bor_health.sh Normal file
View file

@ -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

9
internal/cli/server/chains/mumbai.go
View file

@ -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",

15
internal/cli/server/chains/test_files/chain_legacy_test.json
View file

@ -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",

15
internal/cli/server/chains/test_files/chain_test.json
View file

@ -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",

2
internal/cli/server/command.go
View file

@ -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()
}

26
internal/ethapi/api.go
View file

@ -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

9
params/config.go
View file

@ -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",

8
params/version.go
View file

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