diff --git a/ethereum/eth/src/main/java/tech/pegasys/pantheon/ethereum/eth/manager/task/GetNodeDataFromPeerTask.java b/ethereum/eth/src/main/java/tech/pegasys/pantheon/ethereum/eth/manager/task/GetNodeDataFromPeerTask.java
index c9582af02e..a4087c1d10 100644
--- a/ethereum/eth/src/main/java/tech/pegasys/pantheon/ethereum/eth/manager/task/GetNodeDataFromPeerTask.java
+++ b/ethereum/eth/src/main/java/tech/pegasys/pantheon/ethereum/eth/manager/task/GetNodeDataFromPeerTask.java
@@ -12,7 +12,7 @@
  */
 package tech.pegasys.pantheon.ethereum.eth.manager.task;
 
-import static java.util.Collections.emptyList;
+import static java.util.Collections.emptyMap;
 
 import tech.pegasys.pantheon.ethereum.core.Hash;
 import tech.pegasys.pantheon.ethereum.eth.manager.EthContext;
@@ -27,15 +27,17 @@
 import tech.pegasys.pantheon.util.bytes.BytesValue;
 
 import java.util.Collection;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
 
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
-public class GetNodeDataFromPeerTask extends AbstractPeerRequestTask<List<BytesValue>> {
+public class GetNodeDataFromPeerTask extends AbstractPeerRequestTask<Map<Hash, BytesValue>> {
 
   private static final Logger LOG = LogManager.getLogger();
 
@@ -63,18 +65,20 @@ protected ResponseStream sendRequest(final EthPeer peer) throws PeerNotConnected
   }
 
   @Override
-  protected Optional<List<BytesValue>> processResponse(
+  protected Optional<Map<Hash, BytesValue>> processResponse(
       final boolean streamClosed, final MessageData message, final EthPeer peer) {
     if (streamClosed) {
       // We don't record this as a useless response because it's impossible to know if a peer has
       // the data we're requesting.
-      return Optional.of(emptyList());
+      return Optional.of(emptyMap());
     }
     final NodeDataMessage nodeDataMessage = NodeDataMessage.readFrom(message);
     final List<BytesValue> nodeData = nodeDataMessage.nodeData();
-    if (nodeData.isEmpty()) {
+    final Map<Hash, BytesValue> nodeDataByHash = mapNodeDataByHash(nodeData);
+
+    if (nodeDataByHash.isEmpty()) {
       return Optional.empty();
-    } else if (nodeData.size() > hashes.size()) {
+    } else if (nodeDataByHash.entrySet().size() > hashes.size()) {
       // Can't be the response to our request
       return Optional.empty();
     }
@@ -83,6 +87,13 @@ protected Optional<List<BytesValue>> processResponse(
       // Message contains unrequested data, must not be the response to our request.
       return Optional.empty();
     }
-    return Optional.of(nodeData);
+    return Optional.of(nodeDataByHash);
+  }
+
+  private Map<Hash, BytesValue> mapNodeDataByHash(final List<BytesValue> data) {
+    // Map data by hash
+    final Map<Hash, BytesValue> dataByHash = new HashMap<>();
+    data.forEach(d -> dataByHash.put(Hash.hash(d), d));
+    return dataByHash;
   }
 }
diff --git a/ethereum/eth/src/main/java/tech/pegasys/pantheon/ethereum/eth/sync/worldstate/WorldStateDownloader.java b/ethereum/eth/src/main/java/tech/pegasys/pantheon/ethereum/eth/sync/worldstate/WorldStateDownloader.java
index e7786c3140..4c31e7fdd4 100644
--- a/ethereum/eth/src/main/java/tech/pegasys/pantheon/ethereum/eth/sync/worldstate/WorldStateDownloader.java
+++ b/ethereum/eth/src/main/java/tech/pegasys/pantheon/ethereum/eth/sync/worldstate/WorldStateDownloader.java
@@ -240,7 +240,7 @@ private CompletableFuture<?> waitForNewPeer() {
         .timeout(WaitForPeerTask.create(ethContext, ethTasksTimer), Duration.ofSeconds(5));
   }
 
-  private CompletableFuture<AbstractPeerTask<List<BytesValue>>> sendAndProcessRequests(
+  private CompletableFuture<AbstractPeerTask<Map<Hash, BytesValue>>> sendAndProcessRequests(
       final EthPeer peer,
       final List<Task<NodeDataRequest>> requestTasks,
       final BlockHeader blockHeader) {
@@ -250,13 +250,12 @@ private CompletableFuture<AbstractPeerTask<List<BytesValue>>> sendAndProcessRequ
             .map(NodeDataRequest::getHash)
             .distinct()
             .collect(Collectors.toList());
-    final AbstractPeerTask<List<BytesValue>> ethTask =
+    final AbstractPeerTask<Map<Hash, BytesValue>> ethTask =
         GetNodeDataFromPeerTask.forHashes(ethContext, hashes, ethTasksTimer).assignPeer(peer);
     outstandingRequests.add(ethTask);
     return ethTask
         .run()
         .thenApply(PeerTaskResult::getResult)
-        .thenApply(this::mapNodeDataByHash)
         .exceptionally(
             error -> {
               final Throwable rootCause = ExceptionUtils.rootCause(error);
@@ -276,10 +275,10 @@ private CompletableFuture<AbstractPeerTask<List<BytesValue>>> sendAndProcessRequ
                         () -> storeData(requestTasks, blockHeader, ethTask, data)));
   }
 
-  private CompletableFuture<AbstractPeerTask<List<BytesValue>>> storeData(
+  private CompletableFuture<AbstractPeerTask<Map<Hash, BytesValue>>> storeData(
       final List<Task<NodeDataRequest>> requestTasks,
       final BlockHeader blockHeader,
-      final AbstractPeerTask<List<BytesValue>> ethTask,
+      final AbstractPeerTask<Map<Hash, BytesValue>> ethTask,
       final Map<Hash, BytesValue> data) {
     final Updater storageUpdater = worldStateStorage.updater();
     for (final Task<NodeDataRequest> task : requestTasks) {
diff --git a/ethereum/eth/src/test/java/tech/pegasys/pantheon/ethereum/eth/manager/task/DeconstructedGetNodeDataFromPeerTaskTest.java b/ethereum/eth/src/test/java/tech/pegasys/pantheon/ethereum/eth/manager/task/DeconstructedGetNodeDataFromPeerTaskTest.java
index 2bae199055..0cfd136f93 100644
--- a/ethereum/eth/src/test/java/tech/pegasys/pantheon/ethereum/eth/manager/task/DeconstructedGetNodeDataFromPeerTaskTest.java
+++ b/ethereum/eth/src/test/java/tech/pegasys/pantheon/ethereum/eth/manager/task/DeconstructedGetNodeDataFromPeerTaskTest.java
@@ -31,6 +31,7 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -73,15 +74,16 @@ public void getNodeDataFromPeerTaskTest() {
     }
 
     // Execute task and wait for response
-    final AtomicReference<AbstractPeerTask.PeerTaskResult<List<BytesValue>>> actualResult =
+    final AtomicReference<AbstractPeerTask.PeerTaskResult<Map<Hash, BytesValue>>> actualResult =
         new AtomicReference<>();
     final AtomicBoolean done = new AtomicBoolean(false);
 
     final List<Hash> hashes = requestedData.stream().map(Hash::hash).collect(toList());
-    final EthTask<AbstractPeerTask.PeerTaskResult<List<BytesValue>>> task =
+    final EthTask<AbstractPeerTask.PeerTaskResult<Map<Hash, BytesValue>>> task =
         GetNodeDataFromPeerTask.forHashes(ethContext, hashes, ethTasksTimer);
 
-    final CompletableFuture<AbstractPeerTask.PeerTaskResult<List<BytesValue>>> future = task.run();
+    final CompletableFuture<AbstractPeerTask.PeerTaskResult<Map<Hash, BytesValue>>> future =
+        task.run();
     respondingPeer.respondWhile(responder, () -> !future.isDone());
     future.whenComplete(
         (result, error) -> {
@@ -90,7 +92,10 @@ public void getNodeDataFromPeerTaskTest() {
         });
 
     assertThat(done).isTrue();
-    assertThat(actualResult.get().getResult()).containsExactlyInAnyOrderElementsOf(requestedData);
+
+    final List<BytesValue> resultData = new ArrayList<>(actualResult.get().getResult().values());
+
+    assertThat(resultData).containsExactlyInAnyOrderElementsOf(requestedData);
     assertThat(actualResult.get().getPeer()).isEqualTo(respondingPeer.getEthPeer());
   }
 }
diff --git a/ethereum/eth/src/test/java/tech/pegasys/pantheon/ethereum/eth/manager/task/GetNodeDataFromPeerTaskTest.java b/ethereum/eth/src/test/java/tech/pegasys/pantheon/ethereum/eth/manager/task/GetNodeDataFromPeerTaskTest.java
index c22988d8a6..438049ad4f 100644
--- a/ethereum/eth/src/test/java/tech/pegasys/pantheon/ethereum/eth/manager/task/GetNodeDataFromPeerTaskTest.java
+++ b/ethereum/eth/src/test/java/tech/pegasys/pantheon/ethereum/eth/manager/task/GetNodeDataFromPeerTaskTest.java
@@ -23,42 +23,49 @@
 import tech.pegasys.pantheon.util.bytes.BytesValue;
 
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
-public class GetNodeDataFromPeerTaskTest extends PeerMessageTaskTest<List<BytesValue>> {
+public class GetNodeDataFromPeerTaskTest extends PeerMessageTaskTest<Map<Hash, BytesValue>> {
 
   @Override
-  protected List<BytesValue> generateDataToBeRequested() {
-    final List<BytesValue> requestedData = new ArrayList<>();
+  protected Map<Hash, BytesValue> generateDataToBeRequested() {
+    final Map<Hash, BytesValue> requestedData = new HashMap<>();
     for (int i = 0; i < 3; i++) {
       final BlockHeader blockHeader = blockchain.getBlockHeader(10 + i).get();
-      requestedData.add(
+      requestedData.put(
+          Hash.fromHexStringLenient(Integer.toHexString(i)),
           protocolContext.getWorldStateArchive().getNodeData(blockHeader.getStateRoot()).get());
     }
     return requestedData;
   }
 
   @Override
-  protected EthTask<PeerTaskResult<List<BytesValue>>> createTask(
-      final List<BytesValue> requestedData) {
-    final List<Hash> hashes = requestedData.stream().map(Hash::hash).collect(toList());
+  protected EthTask<PeerTaskResult<Map<Hash, BytesValue>>> createTask(
+      final Map<Hash, BytesValue> requestedData) {
+    final List<Hash> hashes = requestedData.values().stream().map(Hash::hash).collect(toList());
     return GetNodeDataFromPeerTask.forHashes(ethContext, hashes, ethTasksTimer);
   }
 
   @Override
   protected void assertPartialResultMatchesExpectation(
-      final List<BytesValue> requestedData, final List<BytesValue> partialResponse) {
+      final Map<Hash, BytesValue> requestedData, final Map<Hash, BytesValue> partialResponse) {
     assertThat(partialResponse.size()).isLessThanOrEqualTo(requestedData.size());
     assertThat(partialResponse.size()).isGreaterThan(0);
-    assertThat(requestedData).containsAll(partialResponse);
+    final List<BytesValue> requestData = new ArrayList<>(requestedData.values());
+    final List<BytesValue> resultData = new ArrayList<>(partialResponse.values());
+    assertThat(requestData).containsAll(resultData);
   }
 
   @Override
   protected void assertResultMatchesExpectation(
-      final List<BytesValue> requestedData,
-      final PeerTaskResult<List<BytesValue>> response,
+      final Map<Hash, BytesValue> requestedData,
+      final PeerTaskResult<Map<Hash, BytesValue>> response,
       final EthPeer respondingPeer) {
-    assertThat(response.getResult()).containsExactlyInAnyOrderElementsOf(requestedData);
+    final List<BytesValue> requestData = new ArrayList<>(requestedData.values());
+    final List<BytesValue> resultData = new ArrayList<>(response.getResult().values());
+    assertThat(resultData).containsExactlyInAnyOrderElementsOf(requestData);
     assertThat(response.getPeer()).isEqualTo(respondingPeer);
   }
 }