diff --git a/devp2p-eth/src/main/kotlin/org/apache/tuweni/devp2p/eth/BlockchainInformation.kt b/devp2p-eth/src/main/kotlin/org/apache/tuweni/devp2p/eth/BlockchainInformation.kt
index 8e9686d..c222e0e 100644
--- a/devp2p-eth/src/main/kotlin/org/apache/tuweni/devp2p/eth/BlockchainInformation.kt
+++ b/devp2p-eth/src/main/kotlin/org/apache/tuweni/devp2p/eth/BlockchainInformation.kt
@@ -66,15 +66,6 @@
   fun forks(): List<Long>
 
   /**
-   * Get our latest known fork
-   *
-   * @return the latest fork number we know
-   */
-  fun getLatestFork(): Long? {
-    return if (forks().isEmpty()) null else forks()[forks().size - 1]
-  }
-
-  /**
    * Get all our fork hashes
    *
    * @param all fork hashes, sorted
@@ -83,9 +74,7 @@
     val crc = CRC32()
     crc.update(genesisHash().toArrayUnsafe())
     val forkHashes = ArrayList<Bytes>(listOf(Bytes.ofUnsignedInt(crc.value)))
-    val forks = mutableListOf<Long>()
-    forks.addAll(forks())
-    for (fork in forks) {
+    for (fork in forks()) {
       val byteRepresentationFork = UInt64.valueOf(fork).toBytes()
       crc.update(byteRepresentationFork.toArrayUnsafe(), 0, byteRepresentationFork.size())
       forkHashes.add(Bytes.ofUnsignedInt(crc.value))
@@ -93,19 +82,11 @@
     return forkHashes
   }
 
-  /**
-   * Get latest fork hash, if known
-   *
-   * @return the hash of the latest fork hash we know of
-   */
-  fun getLatestForkHash(): Bytes? {
-    val hashes = getForkHashes()
-    return if (hashes.isEmpty()) {
-      null
-    } else hashes[hashes.size - 1]
-  }
+  fun getLastestApplicableFork(number: Long): ForkInfo
 }
 
+data class ForkInfo(val next: Long, val hash: Bytes)
+
 /**
  * POJO - constant representation of the blockchain information
  *
@@ -116,15 +97,41 @@
  * @param genesisHash the genesis block hash
  * @param forks known forks
  */
-data class SimpleBlockchainInformation(
+class SimpleBlockchainInformation(
   val networkID: UInt256,
   val totalDifficulty: UInt256,
   val bestHash: Hash,
   val bestNumber: UInt256,
   val genesisHash: Hash,
-  val forks: List<Long>
+  possibleForks: List<Long>,
 ) : BlockchainInformation {
 
+  private val forkIds: List<ForkInfo>
+  private val forks: List<Long>
+
+  init {
+    this.forks = possibleForks.filter { it > 0 }.sorted().distinct()
+    val crc = CRC32()
+    crc.update(genesisHash.toArrayUnsafe())
+    val genesisHashCrc = Bytes.ofUnsignedInt(crc.value)
+    val forkHashes = mutableListOf(genesisHashCrc)
+    for (f in forks) {
+      val byteRepresentationFork = Bytes.ofUnsignedLong(f).toArrayUnsafe()
+      crc.update(byteRepresentationFork, 0, byteRepresentationFork.size)
+      forkHashes.add(Bytes.ofUnsignedInt(crc.value))
+    }
+    val mutableForkIds = mutableListOf<ForkInfo>()
+
+    // This loop is for all the fork hashes that have an associated "next fork"
+    for (i in forks.indices) {
+      mutableForkIds.add(ForkInfo(forks.get(i), forkHashes[i]))
+    }
+    if (forks.isNotEmpty()) {
+      mutableForkIds.add(ForkInfo(0, forkHashes.last()))
+    }
+    this.forkIds = mutableForkIds.toList()
+  }
+
   override fun networkID(): UInt256 = networkID
 
   override fun totalDifficulty(): UInt256 = totalDifficulty
@@ -136,4 +143,13 @@
   override fun genesisHash(): Hash = genesisHash
 
   override fun forks(): List<Long> = forks
+
+  override fun getLastestApplicableFork(number: Long): ForkInfo {
+    for (fork in forkIds) {
+      if (number < fork.next) {
+        return fork
+      }
+    }
+    return forkIds.last()
+  }
 }
diff --git a/devp2p-eth/src/main/kotlin/org/apache/tuweni/devp2p/eth/EthHandler.kt b/devp2p-eth/src/main/kotlin/org/apache/tuweni/devp2p/eth/EthHandler.kt
index 9290232..cfc328e 100644
--- a/devp2p-eth/src/main/kotlin/org/apache/tuweni/devp2p/eth/EthHandler.kt
+++ b/devp2p-eth/src/main/kotlin/org/apache/tuweni/devp2p/eth/EthHandler.kt
@@ -18,9 +18,11 @@
 
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.runBlocking
 import org.apache.tuweni.bytes.Bytes
 import org.apache.tuweni.concurrent.AsyncCompletion
 import org.apache.tuweni.concurrent.CompletableAsyncCompletion
+import org.apache.tuweni.concurrent.ExpiringMap
 import org.apache.tuweni.concurrent.coroutines.asyncCompletion
 import org.apache.tuweni.devp2p.eth.EthSubprotocol.Companion.ETH62
 import org.apache.tuweni.devp2p.eth.EthSubprotocol.Companion.ETH65
@@ -30,7 +32,6 @@
 import org.apache.tuweni.rlpx.wire.SubProtocolHandler
 import org.apache.tuweni.rlpx.wire.WireConnection
 import org.slf4j.LoggerFactory
-import java.util.WeakHashMap
 import kotlin.collections.ArrayList
 import kotlin.coroutines.CoroutineContext
 
@@ -41,7 +42,7 @@
   private val controller: EthController,
 ) : SubProtocolHandler, CoroutineScope {
 
-  private val pendingStatus = WeakHashMap<String, PeerInfo>()
+  private val pendingStatus = ExpiringMap<String, PeerInfo>(60000)
 
   companion object {
     val logger = LoggerFactory.getLogger(EthHandler::class.java)!!
@@ -227,26 +228,29 @@
     controller.addNewBlockHashes(message.hashes)
   }
 
-  override fun handleNewPeerConnection(connection: WireConnection): AsyncCompletion {
-    val newPeer = pendingStatus.computeIfAbsent(connection.uri()) { PeerInfo() }
-    val ethSubProtocol = connection.agreedSubprotocolVersion(EthSubprotocol.ETH65.name())
-    if (ethSubProtocol == null) {
-      newPeer.cancel()
-      return newPeer.ready
-    }
-    logger.info("Sending status message to ${connection.uri()}")
-    service.send(
-      ethSubProtocol, MessageType.Status.code, connection,
-      StatusMessage(
-        ethSubProtocol.version(),
-        blockchainInfo.networkID(), blockchainInfo.totalDifficulty(),
-        blockchainInfo.bestHash(), blockchainInfo.genesisHash(), blockchainInfo.getLatestForkHash(),
-        blockchainInfo.getLatestFork()
-      ).toBytes()
-    )
+  override fun handleNewPeerConnection(connection: WireConnection): AsyncCompletion =
+    runBlocking {
+      val newPeer = pendingStatus.computeIfAbsent(connection.uri()) { PeerInfo() }
+      val ethSubProtocol = connection.agreedSubprotocolVersion(EthSubprotocol.ETH65.name())
+      if (ethSubProtocol == null) {
+        newPeer.cancel()
+        return@runBlocking newPeer.ready
+      }
+      logger.info("Sending status message to ${connection.uri()}")
+      val forkId =
+        blockchainInfo.getLastestApplicableFork(controller.repository.retrieveChainHeadHeader().number.toLong())
+      service.send(
+        ethSubProtocol, MessageType.Status.code, connection,
+        StatusMessage(
+          ethSubProtocol.version(),
+          blockchainInfo.networkID(), blockchainInfo.totalDifficulty(),
+          blockchainInfo.bestHash(), blockchainInfo.genesisHash(), forkId.hash,
+          forkId.next
+        ).toBytes()
+      )
 
-    return newPeer.ready
-  }
+      return@runBlocking newPeer.ready
+    }
 
   override fun stop() = asyncCompletion {
   }
diff --git a/devp2p-eth/src/main/kotlin/org/apache/tuweni/devp2p/eth/EthHandler66.kt b/devp2p-eth/src/main/kotlin/org/apache/tuweni/devp2p/eth/EthHandler66.kt
index c45ad6b..d6553cf 100644
--- a/devp2p-eth/src/main/kotlin/org/apache/tuweni/devp2p/eth/EthHandler66.kt
+++ b/devp2p-eth/src/main/kotlin/org/apache/tuweni/devp2p/eth/EthHandler66.kt
@@ -18,8 +18,10 @@
 
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.runBlocking
 import org.apache.tuweni.bytes.Bytes
 import org.apache.tuweni.concurrent.AsyncCompletion
+import org.apache.tuweni.concurrent.ExpiringMap
 import org.apache.tuweni.concurrent.coroutines.asyncCompletion
 import org.apache.tuweni.concurrent.coroutines.await
 import org.apache.tuweni.eth.Hash
@@ -30,7 +32,6 @@
 import org.apache.tuweni.rlpx.wire.WireConnection
 import org.apache.tuweni.units.bigints.UInt64
 import org.slf4j.LoggerFactory
-import java.util.WeakHashMap
 import kotlin.collections.ArrayList
 import kotlin.coroutines.CoroutineContext
 
@@ -42,7 +43,7 @@
 ) : SubProtocolHandler, CoroutineScope {
 
   private val ethHandler = EthHandler(coroutineContext, blockchainInfo, service, controller)
-  private val pendingStatus = WeakHashMap<String, PeerInfo>()
+  private val pendingStatus = ExpiringMap<String, PeerInfo>(60000)
 
   companion object {
     val logger = LoggerFactory.getLogger(EthHandler66::class.java)!!
@@ -63,9 +64,9 @@
       val payload = pair.second
 
       when (messageType) {
-        MessageType.Status.code -> handleStatus(connection, StatusMessage.read(payload))
-        MessageType.NewBlockHashes.code -> handleNewBlockHashes(NewBlockHashes.read(payload))
-        MessageType.Transactions.code -> handleTransactions(Transactions.read(payload))
+        MessageType.Status.code -> handleStatus(connection, StatusMessage.read(message))
+        MessageType.NewBlockHashes.code -> handleNewBlockHashes(NewBlockHashes.read(message))
+        MessageType.Transactions.code -> handleTransactions(Transactions.read(message))
         MessageType.GetBlockHeaders.code -> handleGetBlockHeaders(
           connection,
           requestIdentifier,
@@ -78,13 +79,13 @@
           GetBlockBodies.read(payload)
         )
         MessageType.BlockBodies.code -> handleBlockBodies(connection, requestIdentifier, BlockBodies.read(payload))
-        MessageType.NewBlock.code -> handleNewBlock(NewBlock.read(payload))
+        MessageType.NewBlock.code -> handleNewBlock(NewBlock.read(message))
         MessageType.GetNodeData.code -> handleGetNodeData(connection, requestIdentifier, GetNodeData.read(payload))
         MessageType.NodeData.code -> handleNodeData(connection, requestIdentifier, NodeData.read(payload))
         MessageType.GetReceipts.code -> handleGetReceipts(connection, requestIdentifier, GetReceipts.read(payload))
         MessageType.Receipts.code -> handleReceipts(connection, requestIdentifier, Receipts.read(payload))
         MessageType.NewPooledTransactionHashes.code -> handleNewPooledTransactionHashes(
-          connection, NewPooledTransactionHashes.read(payload)
+          connection, NewPooledTransactionHashes.read(message)
         )
         MessageType.GetPooledTransactions.code -> handleGetPooledTransactions(
           connection, requestIdentifier,
@@ -272,32 +273,33 @@
     controller.addNewBlockHashes(message.hashes)
   }
 
-  override fun handleNewPeerConnection(connection: WireConnection): AsyncCompletion {
+  override fun handleNewPeerConnection(connection: WireConnection): AsyncCompletion = runBlocking {
     if (connection.agreedSubprotocolVersion(EthSubprotocol.ETH66.name()) != EthSubprotocol.ETH66) {
-      return ethHandler.handleNewPeerConnection(connection)
+      logger.debug("Downgrade connection from eth/66 to eth65")
+      return@runBlocking ethHandler.handleNewPeerConnection(connection)
     }
-    val newPeer = pendingStatus.computeIfAbsent(connection.uri()) { PeerInfo() }
+    val newPeer = pendingStatus.computeIfAbsent(connection.uri()) {
+      logger.debug("Register a new peer ${connection.uri()}")
+      PeerInfo()
+    }
     val ethSubProtocol = connection.agreedSubprotocolVersion(EthSubprotocol.ETH66.name())
     if (ethSubProtocol == null) {
       newPeer.cancel()
-      return newPeer.ready
+      return@runBlocking newPeer.ready
     }
+    val forkId =
+      blockchainInfo.getLastestApplicableFork(controller.repository.retrieveChainHeadHeader().number.toLong())
     service.send(
       ethSubProtocol, MessageType.Status.code, connection,
-      RLP.encodeList {
-        it.writeValue(UInt64.random().toBytes())
-        it.writeRLP(
-          StatusMessage(
-            ethSubProtocol.version(),
-            blockchainInfo.networkID(), blockchainInfo.totalDifficulty(),
-            blockchainInfo.bestHash(), blockchainInfo.genesisHash(), blockchainInfo.getLatestForkHash(),
-            blockchainInfo.getLatestFork()
-          ).toBytes()
-        )
-      }
+      StatusMessage(
+        ethSubProtocol.version(),
+        blockchainInfo.networkID(), blockchainInfo.totalDifficulty(),
+        blockchainInfo.bestHash(), blockchainInfo.genesisHash(), forkId.hash,
+        forkId.next
+      ).toBytes()
     )
 
-    return newPeer.ready
+    return@runBlocking newPeer.ready
   }
 
   override fun stop() = asyncCompletion {
diff --git a/devp2p-eth/src/main/kotlin/org/apache/tuweni/devp2p/eth/EthHelloHandler.kt b/devp2p-eth/src/main/kotlin/org/apache/tuweni/devp2p/eth/EthHelloHandler.kt
index da959b8..480937c 100644
--- a/devp2p-eth/src/main/kotlin/org/apache/tuweni/devp2p/eth/EthHelloHandler.kt
+++ b/devp2p-eth/src/main/kotlin/org/apache/tuweni/devp2p/eth/EthHelloHandler.kt
@@ -73,13 +73,15 @@
       newPeer.cancel()
       return newPeer.ready
     }
+    val forkId =
+      blockchainInfo.getLastestApplicableFork(0L)
     service.send(
       ethSubProtocol, MessageType.Status.code, connection,
       StatusMessage(
         ethSubProtocol.version(),
         blockchainInfo.networkID(), blockchainInfo.totalDifficulty(),
-        blockchainInfo.bestHash(), blockchainInfo.genesisHash(), blockchainInfo.getLatestForkHash(),
-        blockchainInfo.getLatestFork()
+        blockchainInfo.bestHash(), blockchainInfo.genesisHash(), forkId.hash,
+        forkId.next
       ).toBytes()
     )
 
diff --git a/devp2p-eth/src/test/kotlin/org/apache/tuweni/devp2p/eth/BlockchainInformationTest.kt b/devp2p-eth/src/test/kotlin/org/apache/tuweni/devp2p/eth/BlockchainInformationTest.kt
index 080cf2b..af8a532 100644
--- a/devp2p-eth/src/test/kotlin/org/apache/tuweni/devp2p/eth/BlockchainInformationTest.kt
+++ b/devp2p-eth/src/test/kotlin/org/apache/tuweni/devp2p/eth/BlockchainInformationTest.kt
@@ -42,7 +42,7 @@
     assertEquals(Bytes.fromHexString("0x3edd5b10"), info.getForkHashes()[4])
     assertEquals(Bytes.fromHexString("0xa00bc324"), info.getForkHashes()[5])
     assertEquals(Bytes.fromHexString("0x668db0af"), info.getForkHashes()[6])
-    assertEquals(Bytes.fromHexString("0xe029e991"), info.getLatestForkHash())
+    assertEquals(Bytes.fromHexString("0x879d6e30"), info.getForkHashes()[7])
   }
 
   @Test
@@ -54,6 +54,35 @@
       UInt256.valueOf(genesisFile.chainId.toLong()), genesisBlock.header.difficulty,
       genesisBlock.header.hash, UInt256.valueOf(42L), genesisBlock.header.hash, genesisFile.forks
     )
-    assertEquals(9200000L, info.getLatestFork())
+    assertEquals(1150000L, info.getLastestApplicableFork(0L).next)
+  }
+
+  @Test
+  fun testRopstenLatest() {
+    val contents = BlockchainInformationTest::class.java.getResourceAsStream("/genesis/ropsten.json").readAllBytes()
+    val genesisFile = GenesisFile.read(contents)
+    val genesisBlock = genesisFile.toBlock()
+    val info = SimpleBlockchainInformation(
+      UInt256.valueOf(genesisFile.chainId.toLong()), genesisBlock.header.difficulty,
+      genesisBlock.header.hash, UInt256.valueOf(42L), genesisBlock.header.hash, genesisFile.forks
+    )
+    assertEquals(Bytes.fromHexString("0x30c7ddbc"), info.getLastestApplicableFork(0L).hash)
+    assertEquals(10L, info.getLastestApplicableFork(0L).next)
+    assertEquals(Bytes.fromHexString("0x63760190"), info.getLastestApplicableFork(11L).hash)
+    assertEquals(1700000L, info.getLastestApplicableFork(11L).next)
+    assertEquals(Bytes.fromHexString("0x3ea159c7"), info.getLastestApplicableFork(1700001L).hash)
+    assertEquals(4230000L, info.getLastestApplicableFork(1700001L).next)
+    assertEquals(Bytes.fromHexString("0x97b544f3"), info.getLastestApplicableFork(4230000L).hash)
+    assertEquals(4939394, info.getLastestApplicableFork(4230000L).next)
+    assertEquals(Bytes.fromHexString("0xd6e2149b"), info.getLastestApplicableFork(4939394).hash)
+    assertEquals(6485846, info.getLastestApplicableFork(4939394).next)
+    assertEquals(Bytes.fromHexString("0x4bc66396"), info.getLastestApplicableFork(6485846).hash)
+    assertEquals(7117117, info.getLastestApplicableFork(6485846).next)
+    assertEquals(Bytes.fromHexString("0x6727ef90"), info.getLastestApplicableFork(7117117).hash)
+    assertEquals(9812189, info.getLastestApplicableFork(7117117).next)
+    assertEquals(Bytes.fromHexString("0xa157d377"), info.getLastestApplicableFork(9812189).hash)
+    assertEquals(10499401, info.getLastestApplicableFork(9812189).next)
+    assertEquals(Bytes.fromHexString("0x7119b6b3"), info.getLastestApplicableFork(10499401).hash)
+    assertEquals(0, info.getLastestApplicableFork(10499401).next)
   }
 }
diff --git a/eth-client-ui/build.gradle b/eth-client-ui/build.gradle
index 6f468ef..64a0bea 100644
--- a/eth-client-ui/build.gradle
+++ b/eth-client-ui/build.gradle
@@ -26,12 +26,16 @@
   implementation 'javax.servlet:javax.servlet-api'
   implementation 'javax.ws.rs:javax.ws.rs-api'
 
+  implementation project(':bytes')
   implementation project(':concurrent')
   implementation project(':config')
   implementation project(':concurrent-coroutines')
   implementation project(':crypto')
+  implementation project(':eth')
   implementation project(':eth-client')
+  implementation project(':eth-repository')
   implementation project(':peer-repository')
+  implementation project(':units')
 
   testImplementation project(':junit')
   testImplementation 'org.bouncycastle:bcprov-jdk15on'
diff --git a/eth-client-ui/src/integrationTest/kotlin/org/apache/tuweni/ethclientui/UIIntegrationTest.kt b/eth-client-ui/src/integrationTest/kotlin/org/apache/tuweni/ethclientui/UIIntegrationTest.kt
index 353fa3e..19f0e0b 100644
--- a/eth-client-ui/src/integrationTest/kotlin/org/apache/tuweni/ethclientui/UIIntegrationTest.kt
+++ b/eth-client-ui/src/integrationTest/kotlin/org/apache/tuweni/ethclientui/UIIntegrationTest.kt
@@ -17,22 +17,42 @@
 package org.apache.tuweni.ethclientui
 
 import io.vertx.core.Vertx
+import kotlinx.coroutines.runBlocking
 import org.apache.tuweni.ethclient.EthereumClient
 import org.apache.tuweni.ethclient.EthereumClientConfig
+import org.apache.tuweni.junit.BouncyCastleExtension
+import org.apache.tuweni.junit.TempDirectory
+import org.apache.tuweni.junit.TempDirectoryExtension
 import org.apache.tuweni.junit.VertxExtension
 import org.apache.tuweni.junit.VertxInstance
+import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Assertions.assertTrue
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.extension.ExtendWith
 import java.net.HttpURLConnection
 import java.net.URL
+import java.nio.file.Path
 
-@ExtendWith(VertxExtension::class)
+@ExtendWith(VertxExtension::class, BouncyCastleExtension::class, TempDirectoryExtension::class)
 class UIIntegrationTest {
 
   @Test
-  fun testServerComesUp(@VertxInstance vertx: Vertx) {
-    val ui = UI(client = EthereumClient(vertx, EthereumClientConfig.fromString("[storage.forui]\npath=\"data\"")))
+  fun testServerComesUp(@VertxInstance vertx: Vertx, @TempDirectory tempDir: Path) = runBlocking {
+    val ui = UI(
+      client = EthereumClient(
+        vertx,
+        EthereumClientConfig.fromString(
+          """[storage.default]
+path="${tempDir.toAbsolutePath()}"
+genesis="default"
+[genesis.default]
+path="classpath:/genesis/dev.json"
+[peerRepository.default]
+type="memory""""
+        )
+      )
+    )
+    ui.client.start()
     ui.start()
     val url = URL("http://localhost:" + ui.actualPort)
     val con = url.openConnection() as HttpURLConnection
@@ -45,6 +65,12 @@
     con2.requestMethod = "GET"
     val response2 = con2.inputStream.readAllBytes()
     assertTrue(response2.isNotEmpty())
+    val url3 = URL("http://localhost:" + ui.actualPort + "/rest/state")
+    val con3 = url3.openConnection() as HttpURLConnection
+    con3.requestMethod = "GET"
+    val response3 = con3.inputStream.readAllBytes()
+    assertTrue(response3.isNotEmpty())
+    assertEquals("""{"peerCounts":{"default":0},"bestBlocks":{"default":{"hash":"0xa08d1edb37ba1c62db764ef7c2566cbe368b850f5b3762c6c24114a3fd97b87f","number":"0x0000000000000000000000000000000000000000000000000000000000000000"}}}""", String(response3))
     ui.stop()
   }
 }
diff --git a/eth-client-ui/src/main/kotlin/org/apache/tuweni/ethclientui/JSONProvider.kt b/eth-client-ui/src/main/kotlin/org/apache/tuweni/ethclientui/JSONProvider.kt
new file mode 100644
index 0000000..365beb5
--- /dev/null
+++ b/eth-client-ui/src/main/kotlin/org/apache/tuweni/ethclientui/JSONProvider.kt
@@ -0,0 +1,56 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.tuweni.ethclientui
+
+import com.fasterxml.jackson.databind.ObjectMapper
+import jakarta.ws.rs.Produces
+import jakarta.ws.rs.core.Feature
+import jakarta.ws.rs.core.FeatureContext
+import jakarta.ws.rs.core.MediaType
+import jakarta.ws.rs.ext.MessageBodyReader
+import jakarta.ws.rs.ext.MessageBodyWriter
+import jakarta.ws.rs.ext.Provider
+import org.apache.tuweni.eth.EthJsonModule
+import org.glassfish.jersey.jackson.internal.jackson.jaxrs.cfg.Annotations
+import org.glassfish.jersey.jackson.internal.jackson.jaxrs.json.JacksonJaxbJsonProvider
+
+@Provider
+@Produces(MediaType.APPLICATION_JSON)
+class JSONProvider : JacksonJaxbJsonProvider {
+
+  constructor() : super()
+  constructor(vararg annotationsToUse: Annotations?) : super(mapper, annotationsToUse)
+
+  companion object {
+    val mapper = ObjectMapper()
+
+    init {
+      mapper.registerModule(EthJsonModule())
+    }
+  }
+
+  init {
+    setMapper(mapper)
+  }
+}
+
+class MarshallingFeature : Feature {
+  override fun configure(context: FeatureContext): Boolean {
+    context.register(JSONProvider::class.java, MessageBodyReader::class.java, MessageBodyWriter::class.java)
+    return true
+  }
+}
diff --git a/eth-client-ui/src/main/kotlin/org/apache/tuweni/ethclientui/StateService.kt b/eth-client-ui/src/main/kotlin/org/apache/tuweni/ethclientui/StateService.kt
index f37461e..9eee076 100644
--- a/eth-client-ui/src/main/kotlin/org/apache/tuweni/ethclientui/StateService.kt
+++ b/eth-client-ui/src/main/kotlin/org/apache/tuweni/ethclientui/StateService.kt
@@ -23,6 +23,13 @@
 import jakarta.ws.rs.Produces
 import jakarta.ws.rs.core.Context
 import jakarta.ws.rs.core.MediaType
+import kotlinx.coroutines.runBlocking
+import org.apache.tuweni.bytes.Bytes32
+import org.apache.tuweni.units.bigints.UInt256
+
+data class BlockHashAndNumber(val hash: Bytes32, val number: UInt256)
+
+data class State(val peerCounts: Map<String, Long>, val bestBlocks: Map<String, BlockHashAndNumber>)
 
 @Path("state")
 class StateService {
@@ -32,12 +39,18 @@
 
   @GET
   @Produces(MediaType.APPLICATION_JSON)
-  fun get(): Map<String, Long> {
+  fun get(): State {
     val client = context!!.getAttribute("ethclient") as EthereumClient
 
-    val pairs = client.peerRepositories.entries.map {
+    val peerCounts = client.peerRepositories.entries.map {
       Pair(it.key, it.value.activeConnections().count())
     }
-    return mapOf(*pairs.toTypedArray())
+    val bestBlocks = client.storageRepositories.entries.map {
+      runBlocking {
+        val bestBlock = it.value.retrieveChainHeadHeader()
+        Pair(it.key, BlockHashAndNumber(bestBlock.hash, bestBlock.number))
+      }
+    }
+    return State(mapOf(*peerCounts.toTypedArray()), mapOf(*bestBlocks.toTypedArray()))
   }
 }
diff --git a/eth-client-ui/src/main/kotlin/org/apache/tuweni/ethclientui/UI.kt b/eth-client-ui/src/main/kotlin/org/apache/tuweni/ethclientui/UI.kt
index 4157090..fad640c 100644
--- a/eth-client-ui/src/main/kotlin/org/apache/tuweni/ethclientui/UI.kt
+++ b/eth-client-ui/src/main/kotlin/org/apache/tuweni/ethclientui/UI.kt
@@ -45,7 +45,7 @@
     ctx.contextPath = path
     newServer.handler = ctx
 
-    val config = ResourceConfig().packages(true, "org.apache.tuweni.ethclientui")
+    val config = ResourceConfig().packages(true, "org.apache.tuweni.ethclientui").register(MarshallingFeature::class.java)
     val holder = ServletHolder(ServletContainer(config))
     holder.initOrder = 1
     ctx.addServlet(holder, "/rest/*")
diff --git a/eth-client/src/main/kotlin/org/apache/tuweni/ethclient/EthereumClient.kt b/eth-client/src/main/kotlin/org/apache/tuweni/ethclient/EthereumClient.kt
index 15bfbed..061b102 100644
--- a/eth-client/src/main/kotlin/org/apache/tuweni/ethclient/EthereumClient.kt
+++ b/eth-client/src/main/kotlin/org/apache/tuweni/ethclient/EthereumClient.kt
@@ -83,8 +83,8 @@
 
   private var metricsService: MetricsService? = null
   private val genesisFiles = mutableMapOf<String, GenesisFile>()
-  private val services = mutableMapOf<String, RLPxService>()
-  private val storageRepositories = mutableMapOf<String, BlockchainRepository>()
+  private val rlpxServices = mutableMapOf<String, RLPxService>()
+  val storageRepositories = mutableMapOf<String, BlockchainRepository>()
   val peerRepositories = mutableMapOf<String, EthereumPeerRepository>()
   private val dnsClients = mutableMapOf<String, DNSClient>()
   private val discoveryServices = mutableMapOf<String, DiscoveryService>()
@@ -198,6 +198,7 @@
       discoveryServices[it.getName()] = discoveryService
       logger.info("Started discovery service ${it.getName()}")
     }
+    val adapters = mutableMapOf<String, WireConnectionPeerRepositoryAdapter>()
 
     AsyncCompletion.allOf(
       config.rlpxServices().map { rlpxConfig ->
@@ -252,7 +253,8 @@
           meter,
           adapter
         )
-        services[rlpxConfig.getName()] = service
+        adapters[rlpxConfig.getName()] = adapter
+        rlpxServices[rlpxConfig.getName()] = service
         peerRepository.addIdentityListener {
           service.connectTo(
             it.publicKey(),
@@ -287,9 +289,9 @@
 
       for (sync in config.synchronizers()) {
         val syncRepository = storageRepositories[sync.getRepository()] ?: throw IllegalArgumentException("Repository ${sync.getRepository()} missing for synchronizer ${sync.getName()}")
-        val syncService = services[sync.getRlpxService()] ?: throw IllegalArgumentException("Service ${sync.getRlpxService()} missing for synchronizer ${sync.getName()}")
+        val syncService = rlpxServices[sync.getRlpxService()] ?: throw IllegalArgumentException("Service ${sync.getRlpxService()} missing for synchronizer ${sync.getName()}")
         val syncPeerRepository = peerRepositories[sync.getPeerRepository()] ?: throw IllegalArgumentException("Peer repository ${sync.getPeerRepository()} missing for synchronizer ${sync.getName()}")
-        val adapter = WireConnectionPeerRepositoryAdapter(syncPeerRepository)
+        val adapter = adapters[sync.getRlpxService()] ?: throw IllegalArgumentException("Service ${sync.getRlpxService()} missing for synchronizer ${sync.getName()}")
 
         when (sync.getType()) {
           SynchronizerType.best -> {
@@ -397,7 +399,7 @@
     managerHandler.forEach {
       it.stop()
     }
-    AsyncCompletion.allOf(services.values.map(RLPxService::stop)).await()
+    AsyncCompletion.allOf(rlpxServices.values.map(RLPxService::stop)).await()
     storageRepositories.values.forEach(BlockchainRepository::close)
     metricsService?.close()
     Unit
diff --git a/eth-client/src/main/kotlin/org/apache/tuweni/ethclient/WireConnectionPeerRepositoryAdapter.kt b/eth-client/src/main/kotlin/org/apache/tuweni/ethclient/WireConnectionPeerRepositoryAdapter.kt
index ccb0112..442ba77 100644
--- a/eth-client/src/main/kotlin/org/apache/tuweni/ethclient/WireConnectionPeerRepositoryAdapter.kt
+++ b/eth-client/src/main/kotlin/org/apache/tuweni/ethclient/WireConnectionPeerRepositoryAdapter.kt
@@ -21,6 +21,7 @@
 import org.apache.tuweni.rlpx.WireConnectionRepository
 import org.apache.tuweni.rlpx.wire.SubProtocolIdentifier
 import org.apache.tuweni.rlpx.wire.WireConnection
+import org.slf4j.LoggerFactory
 import java.time.Instant
 import java.util.concurrent.ConcurrentHashMap
 
@@ -29,6 +30,10 @@
  */
 class WireConnectionPeerRepositoryAdapter(val peerRepository: EthereumPeerRepository) : WireConnectionRepository {
 
+  companion object {
+    val logger = LoggerFactory.getLogger(WireConnectionPeerRepositoryAdapter::class.java)
+  }
+
   private val wireConnectionToIdentities = ConcurrentHashMap<String, Identity>()
   private val connections = ConcurrentHashMap<String, WireConnection>()
   private val connectionListeners = ArrayList<WireConnectionRepository.Listener>()
@@ -79,7 +84,11 @@
   }
 
   fun get(ethereumConnection: EthereumConnection): WireConnection {
-    val conn = connections[ethereumConnection.identity().id()] ?: throw NoSuchElementException("No connection available")
+    val conn = connections[ethereumConnection.identity().id()]
+    if (conn == null) {
+      logger.info("Connection ${ethereumConnection.identity().id()} not found, present are: ${connections.keys.joinToString(",")}}")
+      throw NoSuchElementException("No connection available")
+    }
     return conn
   }
 
diff --git a/eth-client/src/main/resources/logback.xml b/eth-client/src/main/resources/logback.xml
index cb63fd5..4d1a5fe 100644
--- a/eth-client/src/main/resources/logback.xml
+++ b/eth-client/src/main/resources/logback.xml
@@ -11,7 +11,7 @@
  an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
  specific language governing permissions and limitations under the License.
 -->
-<configuration>
+<configuration scan="true">
 
     <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
         <!-- encoders are assigned the type
@@ -20,8 +20,20 @@
             <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
         </encoder>
     </appender>
+    <logger level="info" name="org.infinispan" additivity="false">
+        <appender-ref ref="STDOUT" />
+    </logger>
+    <logger level="info" name="io.netty.buffer" additivity="false">
+        <appender-ref ref="STDOUT" />
+    </logger>
+    <logger level="info" name="org.xbill.DNS" additivity="false">
+        <appender-ref ref="STDOUT" />
+    </logger>
+    <logger level="info" name="org.eclipse.jetty" additivity="false">
+        <appender-ref ref="STDOUT" />
+    </logger>
 
-    <root level="info">
+    <root level="${root.log.level:-INFO}">
         <appender-ref ref="STDOUT" />
     </root>
 </configuration>
\ No newline at end of file
diff --git a/eth/src/main/java/org/apache/tuweni/eth/genesis/GenesisFile.java b/eth/src/main/java/org/apache/tuweni/eth/genesis/GenesisFile.java
index a49b474..bad79bf 100644
--- a/eth/src/main/java/org/apache/tuweni/eth/genesis/GenesisFile.java
+++ b/eth/src/main/java/org/apache/tuweni/eth/genesis/GenesisFile.java
@@ -94,14 +94,14 @@
     if (gasLimit == null) {
       throw new IllegalArgumentException("gasLimit must be provided");
     }
-    this.nonce = Bytes.fromHexString(nonce);
+    this.nonce = Bytes.fromHexStringLenient(nonce);
     this.difficulty = UInt256.fromHexString(difficulty);
     this.mixhash = Hash.fromHexString(mixhash);
     this.coinbase = Address.fromHexString(coinbase);
     this.timestamp = "0x0".equals(timestamp) ? Instant.ofEpochSecond(0)
-        : Instant.ofEpochSecond(Bytes.fromHexString(timestamp).toLong());
+        : Instant.ofEpochSecond(Bytes.fromHexStringLenient(timestamp).toLong());
     this.extraData = Bytes.fromHexString(extraData);
-    this.gasLimit = Gas.valueOf(Bytes.fromHexString(gasLimit).toLong());
+    this.gasLimit = Gas.valueOf(Bytes.fromHexStringLenient(gasLimit).toLong());
     this.allocs = new HashMap<>();
     for (Map.Entry<String, String> entry : allocs.entrySet()) {
       Address addr = null;
diff --git a/eth/src/main/resources/genesis/ropsten.json b/eth/src/main/resources/genesis/ropsten.json
index 939e0a3..3912705 100644
--- a/eth/src/main/resources/genesis/ropsten.json
+++ b/eth/src/main/resources/genesis/ropsten.json
@@ -10,6 +10,7 @@
     "muirGlacierBlock": 7117117,
     "berlinBlock": 9812189,
     "londonBlock": 10499401,
+    "terminalTotalDifficulty": 50000000000000000,
     "ethash": {
     },
     "discovery": {
@@ -20,6 +21,11 @@
         "enode://30b7ab30a01c124a6cceca36863ece12c4f5fa68e3ba9b0b51407ccc002eeed3b3102d20a88f1c1d3c3154e2449317b8ef95090e77b312d5cc39354f86d5d606@52.176.7.10:30303",
         "enode://865a63255b3bb68023b6bffd5095118fcc13e79dcf014fe4e47e065c350c7cc72af2e53eff895f11ba1bbb6a2b33271c1116ee870f266618eadfc2e78aa7349c@52.176.100.77:30303"
       ]
+    },
+    "checkpoint": {
+      "hash": "0x43de216f876d897e59b9757dd24186e5b53be28bc425ca6a966335b48daaa50c",
+      "number": 12200000,
+      "totalDifficulty": "0x928D05243C1CF4"
     }
   },
   "nonce": "0x0000000000000042",
@@ -885,4 +891,4 @@
       "balance": "1000000000000000000000000000000"
     }
   }
-}
\ No newline at end of file
+}
diff --git a/evm-dsl/src/main/kotlin/org/apache/tuweni/evmdsl/Code.kt b/evm-dsl/src/main/kotlin/org/apache/tuweni/evmdsl/Code.kt
index abe1db3..1afd665 100644
--- a/evm-dsl/src/main/kotlin/org/apache/tuweni/evmdsl/Code.kt
+++ b/evm-dsl/src/main/kotlin/org/apache/tuweni/evmdsl/Code.kt
@@ -51,6 +51,8 @@
     var stackSize = 0
     val visited = mutableSetOf<Int>()
     var index = 0
+    val jumpDests = mutableSetOf<Int>()
+    val jumpSrcs = mutableMapOf<Int, Int>()
     while (visited.add(index)) {
       val currentInstruction = instructions.getOrNull(index) ?: break
       if (currentInstruction.stackItemsNeeded() > stackSize) {
@@ -63,11 +65,15 @@
       if (currentInstruction is Invalid) {
         return CodeValidationError(currentInstruction, index, Error.HIT_INVALID_OPCODE)
       }
-      // TODO cannot follow jumps right now.
       if (currentInstruction == Jump || currentInstruction == Jumpi) {
-        break
+        jumpSrcs.put(index, stackSize)
       }
-
+      if (currentInstruction == JumpDest) {
+        jumpDests.add(index)
+      }
+      if (currentInstruction.end()) {
+        stackSize = 0
+      }
       index++
     }
     return null
diff --git a/evm-dsl/src/main/kotlin/org/apache/tuweni/evmdsl/Instructions.kt b/evm-dsl/src/main/kotlin/org/apache/tuweni/evmdsl/Instructions.kt
index 04be3e1..3cc12ec 100644
--- a/evm-dsl/src/main/kotlin/org/apache/tuweni/evmdsl/Instructions.kt
+++ b/evm-dsl/src/main/kotlin/org/apache/tuweni/evmdsl/Instructions.kt
@@ -31,6 +31,8 @@
   fun stackItemsConsumed(): Int
 
   fun stackItemsProduced(): Int
+
+  fun end(): Boolean = false
 }
 
 data class InstructionModel(val opcode: Byte, val additionalBytesToRead: Int = 0, val creator: (code: Bytes, index: Int) -> Instruction)
@@ -665,6 +667,7 @@
   override fun toString(): String = "RETURN"
   override fun stackItemsConsumed() = 2
   override fun stackItemsProduced() = 0
+  override fun end() = true
 }
 
 object DelegateCall : Instruction {
@@ -696,6 +699,7 @@
   override fun toString(): String = "REVERT"
   override fun stackItemsConsumed() = 2
   override fun stackItemsProduced() = 0
+  override fun end() = true
 }
 
 object SelfDestruct : Instruction {
@@ -728,3 +732,10 @@
   override fun stackItemsConsumed() = logIndex + 2
   override fun stackItemsProduced() = 0
 }
+
+data class Custom(val bytes: Bytes, val str: String, val consumed: Int, val produced: Int) : Instruction {
+  override fun toBytes() = bytes
+  override fun toString() = str
+  override fun stackItemsConsumed() = consumed
+  override fun stackItemsProduced() = produced
+}
diff --git a/evm-dsl/src/test/kotlin/org/apache/tuweni/evmdsl/CodeTest.kt b/evm-dsl/src/test/kotlin/org/apache/tuweni/evmdsl/CodeTest.kt
index dcdd648..e1cc2c4 100644
--- a/evm-dsl/src/test/kotlin/org/apache/tuweni/evmdsl/CodeTest.kt
+++ b/evm-dsl/src/test/kotlin/org/apache/tuweni/evmdsl/CodeTest.kt
@@ -17,6 +17,7 @@
 package org.apache.tuweni.evmdsl
 
 import org.apache.tuweni.bytes.Bytes
+import org.apache.tuweni.bytes.Bytes32
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Assertions.assertNull
 import org.junit.jupiter.api.Test
@@ -114,4 +115,47 @@
     )
     assertNull(code.validate()?.error)
   }
+
+  @Test
+  fun testSomeWorkshopCode() {
+    val code = Code(
+      buildList {
+        this.add(Push(Bytes.fromHexString("0x00")))
+        this.add(CallDataLoad) // load from position 0
+        this.add(Custom(Bytes.fromHexString("0xf6"), "SHAREDSECRET", 1, 1))
+        this.add(Push(Bytes.fromHexString("0x11"))) // push jump destination
+        this.add(Jumpi) // if custom returns 0, keep going, else go to jumpdest at byte 0x11
+        this.add(Push(Bytes.fromHexString("0x00"))) // value
+        this.add(Push(Bytes.fromHexString("0x00"))) // location
+        this.add(Mstore) // store 0 in memory
+        this.add(Push(Bytes.fromHexString("0x01"))) // length
+        this.add(Push(Bytes.fromHexString("0x1f"))) // location
+        this.add(Return) // return 0
+        this.add(JumpDest)
+        this.add(Push(Bytes.fromHexString("0x01"))) // value
+        this.add(Push(Bytes.fromHexString("0x00"))) // location
+        this.add(Mstore) // store 1 in memory
+        this.add(Push(Bytes.fromHexString("0x01"))) // length
+        this.add(Push(Bytes.fromHexString("0x1f"))) // location
+        this.add(Return)
+      }
+    )
+    assertNull(code.validate()?.error)
+    println(code.toString())
+    println(code.toBytes().toHexString())
+
+    // surround with instructions to deploy.
+    val deployment = Code(
+      buildList {
+        this.add(Push(Bytes32.rightPad(code.toBytes()))) // pad the code with zeros to create a word
+        this.add(Push(Bytes.fromHexString("0x00"))) // set the location of the memory to store
+        this.add(Mstore)
+        this.add(Push(Bytes.ofUnsignedInt(code.toBytes().size().toLong()))) // length
+        this.add(Push(Bytes.fromHexString("0x00"))) // location
+        this.add(Return) // return the code
+      }
+    )
+
+    println(deployment.toBytes().toHexString())
+  }
 }
diff --git a/rlpx/src/main/java/org/apache/tuweni/rlpx/wire/DefaultWireConnection.java b/rlpx/src/main/java/org/apache/tuweni/rlpx/wire/DefaultWireConnection.java
index 73e1f8b..032efd3 100644
--- a/rlpx/src/main/java/org/apache/tuweni/rlpx/wire/DefaultWireConnection.java
+++ b/rlpx/src/main/java/org/apache/tuweni/rlpx/wire/DefaultWireConnection.java
@@ -170,9 +170,9 @@
       return;
     } else if (message.messageId() == 1) {
       DisconnectMessage disconnect = DisconnectMessage.read(message.content());
-      logger.debug("Received disconnect {}", disconnect);
+      logger.debug("Received disconnect {} {}", disconnect.disconnectReason(), uri());
       disconnectReceived = true;
-      disconnectReason = DisconnectReason.valueOf(disconnect.reason());
+      disconnectReason = disconnect.disconnectReason();
       disconnectHandler.run();
       if (!ready.isDone()) {
         ready.complete(this); // Return the connection as is.
@@ -315,7 +315,7 @@
   }
 
   public void sendMessage(SubProtocolIdentifier subProtocolIdentifier, int messageType, Bytes message) {
-    logger.trace("Sending sub-protocol message {} {}", messageType, message);
+    logger.trace("Sending sub-protocol message {} {} {}", messageType, message, uri());
     Integer offset = null;
     for (Map.Entry<Range<Integer>, SubProtocolIdentifier> entry : subprotocolRangeMap.asMapOfRanges().entrySet()) {
       if (entry.getValue().equals(subProtocolIdentifier)) {
diff --git a/rlpx/src/main/java/org/apache/tuweni/rlpx/wire/DisconnectMessage.java b/rlpx/src/main/java/org/apache/tuweni/rlpx/wire/DisconnectMessage.java
index ec5b65c..08634b4 100644
--- a/rlpx/src/main/java/org/apache/tuweni/rlpx/wire/DisconnectMessage.java
+++ b/rlpx/src/main/java/org/apache/tuweni/rlpx/wire/DisconnectMessage.java
@@ -37,19 +37,19 @@
     }
   }
 
-  private final int reason;
-
-  DisconnectMessage(DisconnectReason reason) {
-    this(reason.code);
-  }
+  private final DisconnectReason reason;
 
   DisconnectMessage(int reason) {
+    this(DisconnectReason.valueOf(reason));
+  }
+
+  DisconnectMessage(DisconnectReason reason) {
     this.reason = reason;
   }
 
   @Override
   public Bytes toBytes() {
-    return RLP.encodeList(writer -> writer.writeInt(reason));
+    return RLP.encodeList(writer -> writer.writeInt(reason.code));
   }
 
   @Override
@@ -58,11 +58,15 @@
   }
 
   int reason() {
+    return reason.code;
+  }
+
+  DisconnectReason disconnectReason() {
     return reason;
   }
 
   @Override
   public String toString() {
-    return "DisconnectMessage reason=" + DisconnectReason.valueOf(reason).text;
+    return "DisconnectMessage reason=" + reason.text;
   }
 }