diff --git a/cmd/devp2p/internal/ethtest/chain.go b/cmd/devp2p/internal/ethtest/chain.go
index 654888a4caed1dd19bf51c085fe1dc5a2d0993f0..d67387e80bf46535769bb5c0dd26cadd9e10ac66 100644
--- a/cmd/devp2p/internal/ethtest/chain.go
+++ b/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
- 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
- }
-
- return &Chain{
- blocks: blocks,
- chainConfig: gen.Config,
- }, nil
+ c := &Chain{blocks: blocks, chainConfig: gen.Config}
+ return c, nil
}
diff --git a/cmd/devp2p/internal/ethtest/testdata/chain.rlp.gz b/cmd/devp2p/internal/ethtest/testdata/chain.rlp.gz
old mode 100755
new mode 100644
index bdd6290ce6e569c50323c02fcf3cb12b0d803d1e..957e53bc0fe248e8184d29eb7a4148930910dbe7
Binary files a/cmd/devp2p/internal/ethtest/testdata/chain.rlp.gz and b/cmd/devp2p/internal/ethtest/testdata/chain.rlp.gz differ
diff --git a/cmd/devp2p/internal/ethtest/testdata/genesis.json b/cmd/devp2p/internal/ethtest/testdata/genesis.json
index ea5e2725b569251b678d4c54d727269f45bb8c93..ed78488b67d6a16f52ee94fa11dc5164bafcdcb2 100644
--- a/cmd/devp2p/internal/ethtest/testdata/genesis.json
+++ b/cmd/devp2p/internal/ethtest/testdata/genesis.json
@@ -1,6 +1,6 @@
{
"config": {
- "chainId": 1,
+ "chainId": 19763,
"homesteadBlock": 0,
"eip150Block": 0,
"eip155Block": 0,
@@ -11,16 +11,16 @@
"nonce": "0xdeadbeefdeadbeef",
"timestamp": "0x0",
"extraData": "0x0000000000000000000000000000000000000000000000000000000000000000",
- "gasLimit": "0x8000000",
- "difficulty": "0x10",
+ "gasLimit": "0x80000000",
+ "difficulty": "0x20000",
"mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
"coinbase": "0x0000000000000000000000000000000000000000",
"alloc": {
"71562b71999873db5b286df957af199ec94617f7": {
- "balance": "0xf4240"
+ "balance": "0xffffffff"
}
},
"number": "0x0",
"gasUsed": "0x0",
"parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000"
-}
\ No newline at end of file
+}
diff --git a/cmd/devp2p/internal/ethtest/types.go b/cmd/devp2p/internal/ethtest/types.go
index b6298e808327535dd7b0c8563dced13a015fb2c1..b8fa0f8f86ab073921c74a4dc1fa58ecda550a6a 100644
--- a/cmd/devp2p/internal/ethtest/types.go
+++ b/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 {