forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-08-15 16:33:47 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

refactor

Browse source
This commit is contained in:
Arpit Temani 2022-10-19 22:49:15 +05:30
parent 4afed25f7a
commit fe5b6adac0
3 changed files with 496 additions and 529 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

860
tests/bor/bor_sprint_length_change_test.go
View file

@ -1,529 +1,495 @@
//go:build integration
// +build integration
package bor package bor
// import ( import (
// "crypto/ecdsa" "crypto/ecdsa"
// "encoding/csv" "encoding/csv"
// "encoding/json" "fmt"
// "fmt" "io/ioutil" // nolint: staticcheck
// "io/ioutil" _log "log"
// _log "log" "math/big"
// "math/big" "os"
// "os" "sync"
// "sync" "testing"
// "testing" "time"
// "time"
// "github.com/ethereum/go-ethereum/accounts/keystore" "gotest.tools/assert"
// "github.com/ethereum/go-ethereum/common"
// "github.com/ethereum/go-ethereum/common/fdlimit"
// "github.com/ethereum/go-ethereum/core"
// "github.com/ethereum/go-ethereum/crypto"
// "github.com/ethereum/go-ethereum/eth"
// "github.com/ethereum/go-ethereum/eth/downloader"
// "github.com/ethereum/go-ethereum/eth/ethconfig"
// "github.com/ethereum/go-ethereum/log"
// "github.com/ethereum/go-ethereum/miner"
// "github.com/ethereum/go-ethereum/node"
// "github.com/ethereum/go-ethereum/p2p"
// "github.com/ethereum/go-ethereum/p2p/enode"
// "github.com/ethereum/go-ethereum/params"
// "gotest.tools/assert"
// )
// var ( "github.com/ethereum/go-ethereum/accounts/keystore"
// // addr1 = 0x71562b71999873DB5b286dF957af199Ec94617F7 "github.com/ethereum/go-ethereum/common/fdlimit"
// pkey12, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291") "github.com/ethereum/go-ethereum/core"
// // addr2 = 0x9fB29AAc15b9A4B7F17c3385939b007540f4d791 "github.com/ethereum/go-ethereum/crypto"
// pkey22, _ = crypto.HexToECDSA("9b28f36fbd67381120752d6172ecdcf10e06ab2d9a1367aac00cdcd6ac7855d3") "github.com/ethereum/go-ethereum/eth"
// keys2 = []*ecdsa.PrivateKey{pkey12, pkey22} "github.com/ethereum/go-ethereum/eth/downloader"
// ) "github.com/ethereum/go-ethereum/eth/ethconfig"
"github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/miner"
"github.com/ethereum/go-ethereum/node"
"github.com/ethereum/go-ethereum/p2p"
"github.com/ethereum/go-ethereum/p2p/enode"
"github.com/ethereum/go-ethereum/params"
)
// // Sprint length change tests var (
// func TestValidatorsBlockProduction(t *testing.T) { // addr1 = 0x71562b71999873DB5b286dF957af199Ec94617F7
pkey12, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
// addr2 = 0x9fB29AAc15b9A4B7F17c3385939b007540f4d791
pkey22, _ = crypto.HexToECDSA("9b28f36fbd67381120752d6172ecdcf10e06ab2d9a1367aac00cdcd6ac7855d3")
keys2 = []*ecdsa.PrivateKey{pkey12, pkey22}
)
// log.Root().SetHandler(log.LvlFilterHandler(log.LvlInfo, log.StreamHandler(os.Stderr, log.TerminalFormat(true)))) // Sprint length change tests
// fdlimit.Raise(2048) func TestValidatorsBlockProduction(t *testing.T) {
t.Parallel()
// // Generate a batch of accounts to seal and fund with log.Root().SetHandler(log.LvlFilterHandler(log.LvlInfo, log.StreamHandler(os.Stderr, log.TerminalFormat(true))))
// faucets := make([]*ecdsa.PrivateKey, 128)
// for i := 0; i < len(faucets); i++ {
// faucets[i], _ = crypto.GenerateKey()
// }
// // Create an Ethash network based off of the Ropsten config _, err := fdlimit.Raise(2048)
// genesis := InitGenesisWithSprint(t, faucets, "./testdata/genesis_sprint_length_change.json", 32)
// var ( if err != nil {
// nodes []*eth.Ethereum panic(err)
// enodes []*enode.Node }
// )
// for i := 0; i < 2; i++ {
// // Start the node and wait until it's up
// stack, ethBackend, err := InitMiner1(genesis, keys2[i], true)
// if err != nil {
// panic(err)
// }
// defer stack.Close()
// for stack.Server().NodeInfo().Ports.Listener == 0 { // Generate a batch of accounts to seal and fund with
// time.Sleep(250 * time.Millisecond) faucets := make([]*ecdsa.PrivateKey, 128)
// } for i := 0; i < len(faucets); i++ {
// // Connect the node to all the previous ones faucets[i], _ = crypto.GenerateKey()
// for _, n := range enodes { }
// stack.Server().AddPeer(n)
// }
// // Start tracking the node and its enode
// nodes = append(nodes, ethBackend)
// enodes = append(enodes, stack.Server().Self())
// }
// // Iterate over all the nodes and start mining // Create an Ethash network based off of the Ropsten config
// time.Sleep(3 * time.Second) genesis := InitGenesis(t, faucets, "./testdata/genesis_sprint_length_change.json", 32)
// for _, node := range nodes { nodes := make([]*eth.Ethereum, 2)
// if err := node.StartMining(1); err != nil { enodes := make([]*enode.Node, 2)
// panic(err)
// }
// }
// for { for i := 0; i < 2; i++ {
// Start the node and wait until it's up
stack, ethBackend, err := InitMiner(genesis, keys2[i], true)
if err != nil {
panic(err)
}
defer stack.Close()
// // for block 0 to 7, the primary validator is node0 for stack.Server().NodeInfo().Ports.Listener == 0 {
// // for block 8 to 15, the primary validator is node1 time.Sleep(250 * time.Millisecond)
// // for block 16 to 19, the primary validator is node0 }
// // for block 20 to 23, the primary validator is node1 // Connect the node to all the previous ones
// blockHeaderVal0 := nodes[0].BlockChain().CurrentHeader() for _, n := range enodes {
stack.Server().AddPeer(n)
}
// Start tracking the node and its enode
nodes[i] = ethBackend
enodes[i] = stack.Server().Self()
}
// if blockHeaderVal0.Number.Uint64() == 24 { // Iterate over all the nodes and start mining
// break time.Sleep(3 * time.Second)
// }
// } for _, node := range nodes {
if err := node.StartMining(1); err != nil {
panic(err)
}
}
// // check block 7 miner ; expected author is node0 signer for {
// blockHeaderVal0 := nodes[0].BlockChain().GetHeaderByNumber(7) // for block 0 to 7, the primary validator is node0
// blockHeaderVal1 := nodes[1].BlockChain().GetHeaderByNumber(7) // for block 8 to 15, the primary validator is node1
// authorVal0, err := nodes[0].Engine().Author(blockHeaderVal0) // for block 16 to 19, the primary validator is node0
// if err != nil { // for block 20 to 23, the primary validator is node1
// log.Error("Error in getting author", "err", err) blockHeaderVal0 := nodes[0].BlockChain().CurrentHeader()
// }
// authorVal1, err := nodes[1].Engine().Author(blockHeaderVal1)
// if err != nil {
// log.Error("Error in getting author", "err", err)
// }
// // check both nodes have the same block 7 if blockHeaderVal0.Number.Uint64() == 24 {
// assert.Equal(t, authorVal0, authorVal1) break
}
}
// // check block mined by node0 // check block 7 miner ; expected author is node0 signer
// assert.Equal(t, authorVal0, nodes[0].AccountManager().Accounts()[0]) blockHeaderVal0 := nodes[0].BlockChain().GetHeaderByNumber(7)
blockHeaderVal1 := nodes[1].BlockChain().GetHeaderByNumber(7)
authorVal0, err := nodes[0].Engine().Author(blockHeaderVal0)
// // check block 15 miner ; expected author is node1 signer if err != nil {
// blockHeaderVal0 = nodes[0].BlockChain().GetHeaderByNumber(15) log.Error("Error in getting author", "err", err)
// blockHeaderVal1 = nodes[1].BlockChain().GetHeaderByNumber(15) }
// authorVal0, err = nodes[0].Engine().Author(blockHeaderVal0)
// if err != nil {
// log.Error("Error in getting author", "err", err)
// }
// authorVal1, err = nodes[1].Engine().Author(blockHeaderVal1)
// if err != nil {
// log.Error("Error in getting author", "err", err)
// }
// // check both nodes have the same block 15 authorVal1, err := nodes[1].Engine().Author(blockHeaderVal1)
// assert.Equal(t, authorVal0, authorVal1)
// // check block mined by node1 if err != nil {
// assert.Equal(t, authorVal0, nodes[1].AccountManager().Accounts()[0]) log.Error("Error in getting author", "err", err)
}
// // check block 19 miner ; expected author is node0 signer // check both nodes have the same block 7
// blockHeaderVal0 = nodes[0].BlockChain().GetHeaderByNumber(19) assert.Equal(t, authorVal0, authorVal1)
// blockHeaderVal1 = nodes[1].BlockChain().GetHeaderByNumber(19)
// authorVal0, err = nodes[0].Engine().Author(blockHeaderVal0)
// if err != nil {
// log.Error("Error in getting author", "err", err)
// }
// authorVal1, err = nodes[1].Engine().Author(blockHeaderVal1)
// if err != nil {
// log.Error("Error in getting author", "err", err)
// }
// // check both nodes have the same block 19 // check block mined by node0
// assert.Equal(t, authorVal0, authorVal1) assert.Equal(t, authorVal0, nodes[0].AccountManager().Accounts()[0])
// // check block mined by node0 // check block 15 miner ; expected author is node1 signer
// assert.Equal(t, authorVal0, nodes[0].AccountManager().Accounts()[0]) blockHeaderVal0 = nodes[0].BlockChain().GetHeaderByNumber(15)
blockHeaderVal1 = nodes[1].BlockChain().GetHeaderByNumber(15)
authorVal0, err = nodes[0].Engine().Author(blockHeaderVal0)
// // check block 23 miner ; expected author is node1 signer if err != nil {
// blockHeaderVal0 = nodes[0].BlockChain().GetHeaderByNumber(23) log.Error("Error in getting author", "err", err)
// blockHeaderVal1 = nodes[1].BlockChain().GetHeaderByNumber(23) }
// authorVal0, err = nodes[0].Engine().Author(blockHeaderVal0)
// if err != nil {
// log.Error("Error in getting author", "err", err)
// }
// authorVal1, err = nodes[1].Engine().Author(blockHeaderVal1)
// if err != nil {
// log.Error("Error in getting author", "err", err)
// }
// // check both nodes have the same block 23 authorVal1, err = nodes[1].Engine().Author(blockHeaderVal1)
// assert.Equal(t, authorVal0, authorVal1)
// // check block mined by node1 if err != nil {
// assert.Equal(t, authorVal0, nodes[1].AccountManager().Accounts()[0]) log.Error("Error in getting author", "err", err)
}
// } // check both nodes have the same block 15
assert.Equal(t, authorVal0, authorVal1)
// func TestSprintLengths(t *testing.T) { // check block mined by node1
// testBorConfig := params.TestChainConfig.Bor assert.Equal(t, authorVal0, nodes[1].AccountManager().Accounts()[0])
// testBorConfig.Sprint = map[string]uint64{
// "0": 16,
// "8": 4,
// }
// assert.Equal(t, testBorConfig.CalculateSprint(0), uint64(16))
// assert.Equal(t, testBorConfig.CalculateSprint(8), uint64(4))
// assert.Equal(t, testBorConfig.CalculateSprint(9), uint64(4))
// }
// func TestProducerDelay(t *testing.T) { // check block 19 miner ; expected author is node0 signer
// testBorConfig := params.TestChainConfig.Bor blockHeaderVal0 = nodes[0].BlockChain().GetHeaderByNumber(19)
// testBorConfig.ProducerDelay = map[string]uint64{ blockHeaderVal1 = nodes[1].BlockChain().GetHeaderByNumber(19)
// "0": 16, authorVal0, err = nodes[0].Engine().Author(blockHeaderVal0)
// "8": 4,
// }
// assert.Equal(t, testBorConfig.CalculateProducerDelay(0), uint64(16))
// assert.Equal(t, testBorConfig.CalculateProducerDelay(8), uint64(4))
// assert.Equal(t, testBorConfig.CalculateProducerDelay(9), uint64(4))
// }
// var keys_21val = []map[string]string{ if err != nil {
// // 2 log.Error("Error in getting author", "err", err)
}
authorVal1, err = nodes[1].Engine().Author(blockHeaderVal1)
if err != nil {
log.Error("Error in getting author", "err", err)
}
// check both nodes have the same block 19
assert.Equal(t, authorVal0, authorVal1)
// check block mined by node0
assert.Equal(t, authorVal0, nodes[0].AccountManager().Accounts()[0])
// check block 23 miner ; expected author is node1 signer
blockHeaderVal0 = nodes[0].BlockChain().GetHeaderByNumber(23)
blockHeaderVal1 = nodes[1].BlockChain().GetHeaderByNumber(23)
authorVal0, err = nodes[0].Engine().Author(blockHeaderVal0)
if err != nil {
log.Error("Error in getting author", "err", err)
}
authorVal1, err = nodes[1].Engine().Author(blockHeaderVal1)
if err != nil {
log.Error("Error in getting author", "err", err)
}
// check both nodes have the same block 23
assert.Equal(t, authorVal0, authorVal1)
// check block mined by node1
assert.Equal(t, authorVal0, nodes[1].AccountManager().Accounts()[0])
}
func TestSprintLengths(t *testing.T) {
t.Parallel()
testBorConfig := params.TestChainConfig.Bor
testBorConfig.Sprint = map[string]uint64{
"0": 16,
"8": 4,
}
assert.Equal(t, testBorConfig.CalculateSprint(0), uint64(16))
assert.Equal(t, testBorConfig.CalculateSprint(8), uint64(4))
assert.Equal(t, testBorConfig.CalculateSprint(9), uint64(4))
}
func TestProducerDelay(t *testing.T) {
t.Parallel()
testBorConfig := params.TestChainConfig.Bor
testBorConfig.ProducerDelay = map[string]uint64{
"0": 16,
"8": 4,
}
assert.Equal(t, testBorConfig.CalculateProducerDelay(0), uint64(16))
assert.Equal(t, testBorConfig.CalculateProducerDelay(8), uint64(4))
assert.Equal(t, testBorConfig.CalculateProducerDelay(9), uint64(4))
}
var keys_21val = []map[string]string{
// 2
{
"address": "0x73E033779C9030D4528d86FbceF5B02e97488921",
"priv_key": "61eb51cf8936309151ab7b931841ea033b6a09931f6a100b464fbbd74f3e0bd7",
"pub_key": "0x04f9a5e9bf76b45ac58f1b018ccba4b83b3531010cdadf42174c18a9db9879ef1dcb5d1254ce834bc108b110cd8d0186ed69a0387528a142bdb5936faf58bf98c9",
},
// 1
{
"address": "0x5C3E1B893B9315a968fcC6bce9EB9F7d8E22edB3",
"priv_key": "c19fac8e538447124ad2408d9fbaeda2bb686fee763dca7a6bab58ea12442413",
"pub_key": "0x0495421933eda03dcc37f9186c24e255b569513aefae71e96d55d0db3df17502e24e86297b01a167fab9ce1174f06ee3110510ac242e39218bd964de5b345edbd6",
},
// 5
{
"address": "0xb005bc07015170266Bd430f3EC1322938603be20",
"priv_key": "17cd9b38c2b3a639c7d97ccbf2bb6c7140ab8f625aec4c249bc8e4cfd3bf9a96",
"pub_key": "0x04435a70d343aa569e6f3386c73e39a1aa6f88c30e5943baedda9618b55cc944a2de1d114aff6d0e9fa002bebc780b04ef6c1b8a06bbf0d41c10d1efa55390f198",
},
// 4
{
"address": "0xA464DC4810Bc79B956810759e314d85BcE35cD1c",
"priv_key": "3efcf3f7014a6257f4a443119851414111820c681b27525dab3f35e72e28e51e",
"pub_key": "0x040180920306bf598ea050e258f2c7e50804a77a64f5a11705e08d18ee71eb0a80fafc95d0a42b92371ded042edda16c1f0b5f2fef7c4113ad66c59a71c29d977e",
},
// 6
{
"address": "0xE8d02Da3dFeeB3e755472D95D666BD6821D92129",
"priv_key": "45c9ef66361a2283cef14184f128c41949103b791aa622ead3c0bc844648b835",
"pub_key": "0x04a14651ddc80467eb589d72d95153fa695e4cb2e4bb99edeb912e840d309d61313b6f4676081b099f29e6598ecf98cb7b44bb862d019920718b558f27ba94ca51",
},
// 7
{
"address": "0xF93B54Cf36E917f625B48e1e3C9F93BC2344Fb06",
"priv_key": "93788a1305605808df1f9a96b5e1157da191680cf08bc15e077138f517563cd5",
"pub_key": "0x045eee11dceccd9cccc371ca3d96d74c848e785223f1e5df4d1a7f08efdfeb90bd8f0035342a9c26068cf6c7ab395ca3ceea555541325067fc187c375390efa57d",
},
// 3
{
"address": "0x751eC4877450B8a4D652d0D70197337FC38a42e6",
"priv_key": "6e7f48d012c9c0baadbdc88af32521e2e477fd6898a9b65e6abe19fd6652cb2e",
"pub_key": "0x0479db4c0b757bf0e5d9b8954b078ab7c0e91d6c19697904d23d07ea4853c8584382de91174929ba5c598214b8a991471ae051458ea787cdc15a4e435a55ef8059",
},
}
func getTestSprintLengthReorgCases() []map[string]uint64 {
sprintSizes := []uint64{64, 32, 16, 8}
faultyNodes := []uint64{1, 0}
reorgsLengthTests := make([]map[string]uint64, 0)
for i := uint64(0); i < uint64(len(sprintSizes)); i++ {
maxReorgLength := sprintSizes[i] * 4
for j := uint64(3); j <= maxReorgLength; j = j + 4 {
maxStartBlock := sprintSizes[i] - 1
for k := sprintSizes[i] / 2; k <= maxStartBlock; k = k + 4 {
for l := uint64(0); l < uint64(len(faultyNodes)); l++ {
if j+k < sprintSizes[i] {
continue
}
reorgsLengthTest := map[string]uint64{
"reorgLength": j,
"startBlock": k,
"sprintSize": sprintSizes[i],
"faultyNode": faultyNodes[l], // node 1(index) is primary validator of the first sprint
}
reorgsLengthTests = append(reorgsLengthTests, reorgsLengthTest)
}
}
}
}
// reorgsLengthTests := []map[string]uint64{
// { // {
// "address": "0x73E033779C9030D4528d86FbceF5B02e97488921", // "reorgLength": 3,
// "priv_key": "61eb51cf8936309151ab7b931841ea033b6a09931f6a100b464fbbd74f3e0bd7", // "startBlock": 7,
// "pub_key": "0x04f9a5e9bf76b45ac58f1b018ccba4b83b3531010cdadf42174c18a9db9879ef1dcb5d1254ce834bc108b110cd8d0186ed69a0387528a142bdb5936faf58bf98c9", // "sprintSize": 8,
// }, // "faultyNode": 1,
// // 1
// {
// "address": "0x5C3E1B893B9315a968fcC6bce9EB9F7d8E22edB3",
// "priv_key": "c19fac8e538447124ad2408d9fbaeda2bb686fee763dca7a6bab58ea12442413",
// "pub_key": "0x0495421933eda03dcc37f9186c24e255b569513aefae71e96d55d0db3df17502e24e86297b01a167fab9ce1174f06ee3110510ac242e39218bd964de5b345edbd6",
// },
// // 5
// {
// "address": "0xb005bc07015170266Bd430f3EC1322938603be20",
// "priv_key": "17cd9b38c2b3a639c7d97ccbf2bb6c7140ab8f625aec4c249bc8e4cfd3bf9a96",
// "pub_key": "0x04435a70d343aa569e6f3386c73e39a1aa6f88c30e5943baedda9618b55cc944a2de1d114aff6d0e9fa002bebc780b04ef6c1b8a06bbf0d41c10d1efa55390f198",
// },
// // 4
// {
// "address": "0xA464DC4810Bc79B956810759e314d85BcE35cD1c",
// "priv_key": "3efcf3f7014a6257f4a443119851414111820c681b27525dab3f35e72e28e51e",
// "pub_key": "0x040180920306bf598ea050e258f2c7e50804a77a64f5a11705e08d18ee71eb0a80fafc95d0a42b92371ded042edda16c1f0b5f2fef7c4113ad66c59a71c29d977e",
// },
// // 6
// {
// "address": "0xE8d02Da3dFeeB3e755472D95D666BD6821D92129",
// "priv_key": "45c9ef66361a2283cef14184f128c41949103b791aa622ead3c0bc844648b835",
// "pub_key": "0x04a14651ddc80467eb589d72d95153fa695e4cb2e4bb99edeb912e840d309d61313b6f4676081b099f29e6598ecf98cb7b44bb862d019920718b558f27ba94ca51",
// },
// // 7
// {
// "address": "0xF93B54Cf36E917f625B48e1e3C9F93BC2344Fb06",
// "priv_key": "93788a1305605808df1f9a96b5e1157da191680cf08bc15e077138f517563cd5",
// "pub_key": "0x045eee11dceccd9cccc371ca3d96d74c848e785223f1e5df4d1a7f08efdfeb90bd8f0035342a9c26068cf6c7ab395ca3ceea555541325067fc187c375390efa57d",
// },
// // 3
// {
// "address": "0x751eC4877450B8a4D652d0D70197337FC38a42e6",
// "priv_key": "6e7f48d012c9c0baadbdc88af32521e2e477fd6898a9b65e6abe19fd6652cb2e",
// "pub_key": "0x0479db4c0b757bf0e5d9b8954b078ab7c0e91d6c19697904d23d07ea4853c8584382de91174929ba5c598214b8a991471ae051458ea787cdc15a4e435a55ef8059",
// }, // },
// } // }
return reorgsLengthTests
}
// func getTestSprintLengthReorgCases(t *testing.T) []map[string]uint64 { func SprintLengthReorgIndividual(t *testing.T, index int, tt map[string]uint64) (uint64, uint64, uint64, uint64, uint64, uint64) {
// sprintSizes := []uint64{64, 32, 16, 8} t.Helper()
// faultyNodes := []uint64{1, 0}
// reorgsLengthTests := make([]map[string]uint64, 0)
// for i := uint64(0); i < uint64(len(sprintSizes)); i++ {
// maxReorgLength := sprintSizes[i] * 4
// for j := uint64(3); j <= maxReorgLength; j = j + 4 {
// maxStartBlock := sprintSizes[i] - 1
// for k := sprintSizes[i] / 2; k <= maxStartBlock; k = k + 4 {
// for l := uint64(0); l < uint64(len(faultyNodes)); l++ {
// if j+k < sprintSizes[i] {
// continue
// }
// reorgsLengthTest := map[string]uint64{
// "reorgLength": j,
// "startBlock": k,
// "sprintSize": sprintSizes[i],
// "faultyNode": faultyNodes[l], // node 1(index) is primary validator of the first sprint
// }
// reorgsLengthTests = append(reorgsLengthTests, reorgsLengthTest)
// }
// }
// }
// }
// // reorgsLengthTests := []map[string]uint64{
// // {
// // "reorgLength": 3,
// // "startBlock": 7,
// // "sprintSize": 8,
// // "faultyNode": 1,
// // },
// // }
// return reorgsLengthTests
// }
// func SprintLengthReorgIndividual(t *testing.T, index int, tt map[string]uint64) (uint64, uint64, uint64, uint64, uint64, uint64) { log.Warn("Case ----- ", "Index", index, "InducedReorgLength", tt["reorgLength"], "BlockStart", tt["startBlock"], "SprintSize", tt["sprintSize"], "DisconnectedNode", tt["faultyNode"])
// t.Helper() observerOldChainLength, faultyOldChainLength := SetupValidatorsAndTest(t, tt)
// log.Warn("Case ----- ", "Index", index, "InducedReorgLength", tt["reorgLength"], "BlockStart", tt["startBlock"], "SprintSize", tt["sprintSize"], "DisconnectedNode", tt["faultyNode"]) if observerOldChainLength > 0 {
// observerOldChainLength, faultyOldChainLength := SetupValidatorsAndTest(t, tt) log.Warn("Observer", "Old Chain length", observerOldChainLength)
}
// if observerOldChainLength > 0 { if faultyOldChainLength > 0 {
// log.Warn("Observer", "Old Chain length", observerOldChainLength) log.Warn("Faulty", "Old Chain length", faultyOldChainLength)
// } }
// if faultyOldChainLength > 0 {
// log.Warn("Faulty", "Old Chain length", faultyOldChainLength)
// }
// return tt["reorgLength"], tt["startBlock"], tt["sprintSize"], tt["faultyNode"], faultyOldChainLength, observerOldChainLength return tt["reorgLength"], tt["startBlock"], tt["sprintSize"], tt["faultyNode"], faultyOldChainLength, observerOldChainLength
// } }
// func TestSprintLengthReorg(t *testing.T) { func TestSprintLengthReorg(t *testing.T) {
// reorgsLengthTests := getTestSprintLengthReorgCases(t) t.Skip()
// f, err := os.Create("sprintReorg.csv") t.Parallel()
// defer f.Close()
// if err != nil { reorgsLengthTests := getTestSprintLengthReorgCases()
// _log.Fatalln("failed to open file", err) f, err := os.Create("sprintReorg.csv")
// }
// w := csv.NewWriter(f) defer func() {
// w.Write([]string{"Induced Reorg Length", "Start Block", "Sprint Size", "Disconnected Node Id", "Disconnected Node Id's Reorg Length", "Observer Node Id's Reorg Length"}) err = f.Close()
// w.Flush()
// var wg sync.WaitGroup if err != nil {
// for index, tt := range reorgsLengthTests { panic(err)
// if index%4 == 0 { }
// wg.Wait() }()
// }
// wg.Add(1)
// go SprintLengthReorgIndividualHelper(t, index, tt, w, &wg)
// }
// } if err != nil {
_log.Fatalln("failed to open file", err)
}
// func SprintLengthReorgIndividualHelper(t *testing.T, index int, tt map[string]uint64, w *csv.Writer, wg *sync.WaitGroup) { w := csv.NewWriter(f)
// t.Helper() err = w.Write([]string{"Induced Reorg Length", "Start Block", "Sprint Size", "Disconnected Node Id", "Disconnected Node Id's Reorg Length", "Observer Node Id's Reorg Length"})
w.Flush()
// r1, r2, r3, r4, r5, r6 := SprintLengthReorgIndividual(t, index, tt) if err != nil {
// w.Write([]string{fmt.Sprint(r1), fmt.Sprint(r2), fmt.Sprint(r3), fmt.Sprint(r4), fmt.Sprint(r5), fmt.Sprint(r6)}) panic(err)
// w.Flush() }
// (*wg).Done()
// }
// func SetupValidatorsAndTest(t *testing.T, tt map[string]uint64) (uint64, uint64) { var wg sync.WaitGroup
// log.Root().SetHandler(log.LvlFilterHandler(3, log.StreamHandler(os.Stderr, log.TerminalFormat(true))))
// fdlimit.Raise(2048)
// // Create an Ethash network based off of the Ropsten config for index, tt := range reorgsLengthTests {
// genesis := InitGenesisWithSprint(t, nil, "./testdata/genesis_7val.json", tt["sprintSize"]) if index%4 == 0 {
wg.Wait()
}
// var ( wg.Add(1)
// nodes []*eth.Ethereum
// enodes []*enode.Node
// stacks []*node.Node
// )
// pkeys_21val := make([]*ecdsa.PrivateKey, len(keys_21val)) go SprintLengthReorgIndividualHelper(t, index, tt, w, &wg)
// for index, signerdata := range keys_21val { }
// pkeys_21val[index], _ = crypto.HexToECDSA(signerdata["priv_key"]) }
// }
// for i := 0; i < len(keys_21val); i++ { func SprintLengthReorgIndividualHelper(t *testing.T, index int, tt map[string]uint64, w *csv.Writer, wg *sync.WaitGroup) {
// // Start the node and wait until it's up t.Helper()
// stack, ethBackend, err := InitMiner1(genesis, pkeys_21val[i], true)
// if err != nil {
// panic(err)
// }
// defer stack.Close()
// for stack.Server().NodeInfo().Ports.Listener == 0 { r1, r2, r3, r4, r5, r6 := SprintLengthReorgIndividual(t, index, tt)
// time.Sleep(250 * time.Millisecond) err := w.Write([]string{fmt.Sprint(r1), fmt.Sprint(r2), fmt.Sprint(r3), fmt.Sprint(r4), fmt.Sprint(r5), fmt.Sprint(r6)})
// }
// // Connect the node to all the previous ones
// for _, n := range enodes {
// stack.Server().AddPeer(n)
// }
// // Start tracking the node and its enode
// stacks = append(stacks, stack)
// nodes = append(nodes, ethBackend)
// enodes = append(enodes, stack.Server().Self())
// }
// // Iterate over all the nodes and start mining if err != nil {
// time.Sleep(3 * time.Second) panic(err)
}
// for _, node := range nodes { w.Flush()
// if err := node.StartMining(1); err != nil { (*wg).Done()
// panic(err) }
// }
// }
// chain2HeadChObserver := make(chan core.Chain2HeadEvent, 64) // nolint: gocognit
// chain2HeadChFaulty := make(chan core.Chain2HeadEvent, 64) func SetupValidatorsAndTest(t *testing.T, tt map[string]uint64) (uint64, uint64) {
t.Helper()
// var observerOldChainLength, faultyOldChainLength uint64 log.Root().SetHandler(log.LvlFilterHandler(3, log.StreamHandler(os.Stderr, log.TerminalFormat(true))))
// faultyProducerIndex := tt["faultyNode"] // node causing reorg :: faulty :: _, err := fdlimit.Raise(2048)
// subscribedNodeIndex := 5 // node on different partition, produces 7th sprint but our testcase does not run till 7th sprint. :: observer ::
// nodes[subscribedNodeIndex].BlockChain().SubscribeChain2HeadEvent(chain2HeadChObserver) if err != nil {
// nodes[faultyProducerIndex].BlockChain().SubscribeChain2HeadEvent(chain2HeadChFaulty) panic(err)
}
// stacks[faultyProducerIndex].Server().NoDiscovery = true // Create an Ethash network based off of the Ropsten config
genesis := InitGenesis(t, nil, "./testdata/genesis_7val.json", tt["sprintSize"])
// for { nodes := make([]*eth.Ethereum, len(keys_21val))
// blockHeaderObserver := nodes[subscribedNodeIndex].BlockChain().CurrentHeader() enodes := make([]*enode.Node, len(keys_21val))
// blockHeaderFaulty := nodes[faultyProducerIndex].BlockChain().CurrentHeader() stacks := make([]*node.Node, len(keys_21val))
pkeys_21val := make([]*ecdsa.PrivateKey, len(keys_21val))
// log.Warn("Current Observer block", "number", blockHeaderObserver.Number, "hash", blockHeaderObserver.Hash()) for index, signerdata := range keys_21val {
// log.Warn("Current Faulty block", "number", blockHeaderFaulty.Number, "hash", blockHeaderFaulty.Hash()) pkeys_21val[index], _ = crypto.HexToECDSA(signerdata["priv_key"])
}
// if blockHeaderFaulty.Number.Uint64() == tt["startBlock"] { for i := 0; i < len(keys_21val); i++ {
// stacks[faultyProducerIndex].Server().MaxPeers = 0 // Start the node and wait until it's up
stack, ethBackend, err := InitMiner(genesis, pkeys_21val[i], true)
if err != nil {
panic(err)
}
defer stack.Close()
// for _, enode := range enodes { for stack.Server().NodeInfo().Ports.Listener == 0 {
// stacks[faultyProducerIndex].Server().RemovePeer(enode) time.Sleep(250 * time.Millisecond)
// } }
// } // Connect the node to all the previous ones
for _, n := range enodes {
stack.Server().AddPeer(n)
}
// Start tracking the node and its enode
nodes[i] = ethBackend
enodes[i] = stack.Server().Self()
stacks[i] = stack
}
// if blockHeaderObserver.Number.Uint64() >= tt["startBlock"] && blockHeaderObserver.Number.Uint64() < tt["startBlock"]+tt["reorgLength"] { // Iterate over all the nodes and start mining
// for _, enode := range enodes { time.Sleep(3 * time.Second)
// stacks[faultyProducerIndex].Server().RemovePeer(enode)
// }
// }
// if blockHeaderObserver.Number.Uint64() == tt["startBlock"]+tt["reorgLength"] { for _, node := range nodes {
// stacks[faultyProducerIndex].Server().NoDiscovery = false if err := node.StartMining(1); err != nil {
// stacks[faultyProducerIndex].Server().MaxPeers = 100 panic(err)
}
}
// for _, enode := range enodes { chain2HeadChObserver := make(chan core.Chain2HeadEvent, 64)
// stacks[faultyProducerIndex].Server().AddPeer(enode) chain2HeadChFaulty := make(chan core.Chain2HeadEvent, 64)
// }
// }
// if blockHeaderFaulty.Number.Uint64() >= 255 { var observerOldChainLength, faultyOldChainLength uint64
// break
// }
// select { faultyProducerIndex := tt["faultyNode"] // node causing reorg :: faulty ::
// case ev := <-chain2HeadChObserver: subscribedNodeIndex := 5 // node on different partition, produces 7th sprint but our testcase does not run till 7th sprint. :: observer ::
// if ev.Type == core.Chain2HeadReorgEvent {
// if len(ev.OldChain) > 1 { nodes[subscribedNodeIndex].BlockChain().SubscribeChain2HeadEvent(chain2HeadChObserver)
// observerOldChainLength = uint64(len(ev.OldChain)) nodes[faultyProducerIndex].BlockChain().SubscribeChain2HeadEvent(chain2HeadChFaulty)
// return observerOldChainLength, 0
// }
// }
// case ev := <-chain2HeadChFaulty: stacks[faultyProducerIndex].Server().NoDiscovery = true
// if ev.Type == core.Chain2HeadReorgEvent {
// if len(ev.OldChain) > 1 {
// faultyOldChainLength = uint64(len(ev.OldChain))
// return 0, faultyOldChainLength
// }
// }
// default: for {
// time.Sleep(500 * time.Millisecond) blockHeaderObserver := nodes[subscribedNodeIndex].BlockChain().CurrentHeader()
// } blockHeaderFaulty := nodes[faultyProducerIndex].BlockChain().CurrentHeader()
// }
// return 0, 0 log.Warn("Current Observer block", "number", blockHeaderObserver.Number, "hash", blockHeaderObserver.Hash())
// } log.Warn("Current Faulty block", "number", blockHeaderFaulty.Number, "hash", blockHeaderFaulty.Hash())
// func InitMiner1(genesis *core.Genesis, privKey *ecdsa.PrivateKey, withoutHeimdall bool) (*node.Node, *eth.Ethereum, error) { if blockHeaderFaulty.Number.Uint64() == tt["startBlock"] {
// // Define the basic configurations for the Ethereum node stacks[faultyProducerIndex].Server().MaxPeers = 0
// datadir, _ := ioutil.TempDir("", "")
// config := &node.Config{ for _, enode := range enodes {
// Name: "geth", stacks[faultyProducerIndex].Server().RemovePeer(enode)
// Version: params.Version, }
// DataDir: datadir, }
// P2P: p2p.Config{
// ListenAddr: "0.0.0.0:0",
// NoDiscovery: true,
// MaxPeers: 25,
// },
// UseLightweightKDF: true,
// }
// // Create the node and configure a full Ethereum node on it
// stack, err := node.New(config)
// if err != nil {
// return nil, nil, err
// }
// ethBackend, err := eth.New(stack, &ethconfig.Config{ if blockHeaderObserver.Number.Uint64() >= tt["startBlock"] && blockHeaderObserver.Number.Uint64() < tt["startBlock"]+tt["reorgLength"] {
// Genesis: genesis, for _, enode := range enodes {
// NetworkId: genesis.Config.ChainID.Uint64(), stacks[faultyProducerIndex].Server().RemovePeer(enode)
// SyncMode: downloader.FullSync, }
// DatabaseCache: 256, }
// DatabaseHandles: 256,
// TxPool: core.DefaultTxPoolConfig,
// GPO: ethconfig.Defaults.GPO,
// Ethash: ethconfig.Defaults.Ethash,
// Miner: miner.Config{
// Etherbase: crypto.PubkeyToAddress(privKey.PublicKey),
// GasCeil: genesis.GasLimit * 11 / 10,
// GasPrice: big.NewInt(1),
// Recommit: time.Second,
// },
// WithoutHeimdall: withoutHeimdall,
// })
// if err != nil { if blockHeaderObserver.Number.Uint64() == tt["startBlock"]+tt["reorgLength"] {
// return nil, nil, err stacks[faultyProducerIndex].Server().NoDiscovery = false
// } stacks[faultyProducerIndex].Server().MaxPeers = 100
// // register backend to account manager with keystore for signing for _, enode := range enodes {
// keydir := stack.KeyStoreDir() stacks[faultyProducerIndex].Server().AddPeer(enode)
}
}
// n, p := keystore.StandardScryptN, keystore.StandardScryptP if blockHeaderFaulty.Number.Uint64() >= 255 {
// kStore := keystore.NewKeyStore(keydir, n, p) break
}
// kStore.ImportECDSA(privKey, "") select {
// acc := kStore.Accounts()[0] case ev := <-chain2HeadChObserver:
// kStore.Unlock(acc, "") if ev.Type == core.Chain2HeadReorgEvent {
// // proceed to authorize the local account manager in any case if len(ev.OldChain) > 1 {
// ethBackend.AccountManager().AddBackend(kStore) observerOldChainLength = uint64(len(ev.OldChain))
return observerOldChainLength, 0
}
}
// // ethBackend.AccountManager().AddBackend() case ev := <-chain2HeadChFaulty:
// err = stack.Start() if ev.Type == core.Chain2HeadReorgEvent {
if len(ev.OldChain) > 1 {
faultyOldChainLength = uint64(len(ev.OldChain))
return 0, faultyOldChainLength
}
}
// return stack, ethBackend, err default:
// } time.Sleep(500 * time.Millisecond)
}
}
// func InitGenesisWithSprint(t *testing.T, faucets []*ecdsa.PrivateKey, fileLocation string, sprintSize uint64) *core.Genesis { return 0, 0
// t.Helper() }
// // sprint size = 8 in genesis
// genesisData, err := os.ReadFile(fileLocation)
// if err != nil {
// t.Fatalf("%s", err)
// }
// genesis := &core.Genesis{}
// if err := json.Unmarshal(genesisData, genesis); err != nil {
// t.Fatalf("%s", err)
// }
// genesis.Config.ChainID = big.NewInt(15001)
// genesis.Config.EIP150Hash = common.Hash{}
// genesis.Config.Bor.Sprint["0"] = sprintSize
// return genesis
// }

2
tests/bor/bor_test.go
View file

@ -59,7 +59,7 @@ func TestValidatorWentOffline(t *testing.T) {
} }
// Create an Ethash network based off of the Ropsten config // Create an Ethash network based off of the Ropsten config
genesis := InitGenesis(t, faucets, "./testdata/genesis_2val.json") genesis := InitGenesis(t, faucets, "./testdata/genesis_2val.json", 8)
var ( var (
stacks []*node.Node stacks []*node.Node

3
tests/bor/helper.go
View file

@ -428,7 +428,7 @@ func InitMiner(genesis *core.Genesis, privKey *ecdsa.PrivateKey, withoutHeimdall
return stack, ethBackend, err return stack, ethBackend, err
} }
func InitGenesis(t *testing.T, faucets []*ecdsa.PrivateKey, fileLocation string) *core.Genesis { func InitGenesis(t *testing.T, faucets []*ecdsa.PrivateKey, fileLocation string, sprintSize uint64) *core.Genesis {
// sprint size = 8 in genesis // sprint size = 8 in genesis
genesisData, err := ioutil.ReadFile(fileLocation) genesisData, err := ioutil.ReadFile(fileLocation)
@ -444,6 +444,7 @@ func InitGenesis(t *testing.T, faucets []*ecdsa.PrivateKey, fileLocation string)
genesis.Config.ChainID = big.NewInt(15001) genesis.Config.ChainID = big.NewInt(15001)
genesis.Config.EIP150Hash = common.Hash{} genesis.Config.EIP150Hash = common.Hash{}
genesis.Config.Bor.Sprint["0"] = sprintSize
return genesis return genesis
} }