cmd/devp2p/internal/ethtest: update test chain (#21742)

The old one was wrong in two ways: the first block in chain.rlp was the
genesis block, and the genesis difficulty was below minimum difficulty.

This also contains some other fixes to the test.

cmd/devp2p/internal/ethtest/chain.go

@@ -124,13 +124,22 @@ func (c *Chain) GetHeaders(req GetBlockHeaders) (BlockHeaders, error) {
 // loadChain takes the given chain.rlp file, and decodes and returns
 // the blocks from the file.
 func loadChain(chainfile string, genesis string) (*Chain, error) {
-	// Open the file handle and potentially unwrap the gzip stream
+	chainConfig, err := ioutil.ReadFile(genesis)
+	if err != nil {
+		return nil, err
+	}
+	var gen core.Genesis
+	if err := json.Unmarshal(chainConfig, &gen); err != nil {
+		return nil, err
+	}
+	gblock := gen.ToBlock(nil)
+
+	// Load chain.rlp.
 	fh, err := os.Open(chainfile)
 	if err != nil {
 		return nil, err
 	}
 	defer fh.Close()
-
 	var reader io.Reader = fh
 	if strings.HasSuffix(chainfile, ".gz") {
 		if reader, err = gzip.NewReader(reader); err != nil {
@@ -138,29 +147,21 @@ func loadChain(chainfile string, genesis string) (*Chain, error) {
 		}
 	}
 	stream := rlp.NewStream(reader, 0)
-	var blocks []*types.Block
+	var blocks = make([]*types.Block, 1)
+	blocks[0] = gblock
 	for i := 0; ; i++ {
 		var b types.Block
 		if err := stream.Decode(&b); err == io.EOF {
 			break
 		} else if err != nil {
-			return nil, fmt.Errorf("at block %d: %v", i, err)
+			return nil, fmt.Errorf("at block index %d: %v", i, err)
+		}
+		if b.NumberU64() != uint64(i+1) {
+			return nil, fmt.Errorf("block at index %d has wrong number %d", i, b.NumberU64())
 		}
 		blocks = append(blocks, &b)
 	}
 
-	// Open the file handle and potentially unwrap the gzip stream
+	c := &Chain{blocks: blocks, chainConfig: gen.Config}
-	chainConfig, err := ioutil.ReadFile(genesis)
+	return c, nil
-	if err != nil {
-		return nil, err
-	}
-	var gen core.Genesis
-	if err := json.Unmarshal(chainConfig, &gen); err != nil {
-		return nil, err
-	}
-
-	return &Chain{
-		blocks:      blocks,
-		chainConfig: gen.Config,
-	}, nil
 }

cmd/devp2p/internal/ethtest/testdata/genesis.json

@@ -1,6 +1,6 @@
 {
     "config": {
-        "chainId": 1,
+        "chainId": 19763,
         "homesteadBlock": 0,
         "eip150Block": 0,
         "eip155Block": 0,
@@ -11,13 +11,13 @@
     "nonce": "0xdeadbeefdeadbeef",
     "timestamp": "0x0",
     "extraData": "0x0000000000000000000000000000000000000000000000000000000000000000",
-    "gasLimit": "0x8000000",
+    "gasLimit": "0x80000000",
-    "difficulty": "0x10",
+    "difficulty": "0x20000",
     "mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
     "coinbase": "0x0000000000000000000000000000000000000000",
     "alloc": {
         "71562b71999873db5b286df957af199ec94617f7": {
-            "balance": "0xf4240"
+            "balance": "0xffffffff"
         }
     },
     "number": "0x0",

cmd/devp2p/internal/ethtest/types.go

@@ -242,12 +242,14 @@ func (c *Conn) Write(msg Message) error {
 	}
 	_, err = c.Conn.Write(uint64(msg.Code()), payload)
 	return err
-
 }
 
 // handshake checks to make sure a `HELLO` is received.
 func (c *Conn) handshake(t *utesting.T) Message {
-	// write protoHandshake to client
+	defer c.SetDeadline(time.Time{})
+	c.SetDeadline(time.Now().Add(10 * time.Second))
+
+	// write hello to client
 	pub0 := crypto.FromECDSAPub(&c.ourKey.PublicKey)[1:]
 	ourHandshake := &Hello{
 		Version: 5,
@@ -260,14 +262,13 @@ func (c *Conn) handshake(t *utesting.T) Message {
 	if err := c.Write(ourHandshake); err != nil {
 		t.Fatalf("could not write to connection: %v", err)
 	}
-	// read protoHandshake from client
+	// read hello from client
 	switch msg := c.Read().(type) {
 	case *Hello:
 		// set snappy if version is at least 5
 		if msg.Version >= 5 {
 			c.SetSnappy(true)
 		}
-
 		c.negotiateEthProtocol(msg.Caps)
 		if c.ethProtocolVersion == 0 {
 			t.Fatalf("unexpected eth protocol version")
@@ -297,9 +298,11 @@ func (c *Conn) negotiateEthProtocol(caps []p2p.Cap) {
 // statusExchange performs a `Status` message exchange with the given
 // node.
 func (c *Conn) statusExchange(t *utesting.T, chain *Chain) Message {
+	defer c.SetDeadline(time.Time{})
+	c.SetDeadline(time.Now().Add(20 * time.Second))
+
 	// read status message from client
 	var message Message
-
 loop:
 	for {
 		switch msg := c.Read().(type) {
@@ -331,7 +334,7 @@ loop:
 	// write status message to client
 	status := Status{
 		ProtocolVersion: uint32(c.ethProtocolVersion),
-		NetworkID:       1,
+		NetworkID:       chain.chainConfig.ChainID.Uint64(),
 		TD:              chain.TD(chain.Len()),
 		Head:            chain.blocks[chain.Len()-1].Hash(),
 		Genesis:         chain.blocks[0].Hash(),
@@ -347,12 +350,15 @@ loop:
 // waitForBlock waits for confirmation from the client that it has
 // imported the given block.
 func (c *Conn) waitForBlock(block *types.Block) error {
+	defer c.SetReadDeadline(time.Time{})
+
+	timeout := time.Now().Add(20 * time.Second)
+	c.SetReadDeadline(timeout)
 	for {
 		req := &GetBlockHeaders{Origin: hashOrNumber{Hash: block.Hash()}, Amount: 1}
 		if err := c.Write(req); err != nil {
 			return err
 		}
-
 		switch msg := c.Read().(type) {
 		case *BlockHeaders:
 			if len(*msg) > 0 {