add grpc support for PoS Ethereum

2022-07-29 17:42:19 +04:00
parent eb95c591f7
commit 1df7221c68
24 changed files with 302 additions and 230 deletions
--- a/src/main/kotlin/io/emeraldpay/dshackle/config/UpstreamsConfig.kt
+++ b/src/main/kotlin/io/emeraldpay/dshackle/config/UpstreamsConfig.kt
@@ -102,6 +102,7 @@ open class UpstreamsConfig {
        var host: String? = null
        var port: Int = 0
        var auth: AuthConfig.ClientTlsAuth? = null
+        var nodeRating: Int = 0
    }

    class EthereumConnection : RpcConnection() {
--- a/src/main/kotlin/io/emeraldpay/dshackle/config/UpstreamsConfigReader.kt
+++ b/src/main/kotlin/io/emeraldpay/dshackle/config/UpstreamsConfigReader.kt
@@ -106,6 +106,9 @@ class UpstreamsConfigReader(
                    config.upstreams.add(upstream)
                    val connection = UpstreamsConfig.GrpcConnection()
                    upstream.connection = connection
+                    getValueAsInt(connConfigNode, "node-rating")?.let {
+                        connection.nodeRating = it
+                    }
                    getValueAsString(connConfigNode, "host")?.let {
                        connection.host = it
                    }
--- a/src/main/kotlin/io/emeraldpay/dshackle/startup/ConfiguredUpstreams.kt
+++ b/src/main/kotlin/io/emeraldpay/dshackle/startup/ConfiguredUpstreams.kt
@@ -29,8 +29,8 @@ import io.emeraldpay.dshackle.upstream.bitcoin.ExtractBlock
 import io.emeraldpay.dshackle.upstream.bitcoin.ZMQServer
 import io.emeraldpay.dshackle.upstream.calls.CallMethods
 import io.emeraldpay.dshackle.upstream.calls.ManagedCallMethods
-import io.emeraldpay.dshackle.upstream.ethereum.EthereumPosUpstream
-import io.emeraldpay.dshackle.upstream.ethereum.EthereumUpstream
+import io.emeraldpay.dshackle.upstream.ethereum.EthereumPosRpcUpstream
+import io.emeraldpay.dshackle.upstream.ethereum.EthereumRpcUpstream
 import io.emeraldpay.dshackle.upstream.ethereum.EthereumWsFactory
 import io.emeraldpay.dshackle.upstream.ethereum.connectors.EthereumConnectorFactory
 import io.emeraldpay.dshackle.upstream.forkchoice.ForkChoice
@@ -160,7 +160,7 @@ open class ConfiguredUpstreams(
        if (connectorFactory == null) {
            return null
        }
-        val upstream = EthereumPosUpstream(
+        val upstream = EthereumPosRpcUpstream(
            config.id!!,
            chain,
            options, config.role,
@@ -218,7 +218,7 @@ open class ConfiguredUpstreams(
        config: UpstreamsConfig.Upstream<UpstreamsConfig.EthereumConnection>,
        chain: Chain,
        options: UpstreamsConfig.Options
-    ) : EthereumUpstream? {
+    ) : EthereumRpcUpstream? {
        val conn = config.connection!!

        val urls = ArrayList<URI>()
@@ -228,7 +228,7 @@ open class ConfiguredUpstreams(
        if (connectorFactory == null) {
            return null
        }
-        val upstream = EthereumUpstream(
+        val upstream = EthereumRpcUpstream(
            config.id!!,
            chain,
            options, config.role,
@@ -251,7 +251,8 @@ open class ConfiguredUpstreams(
            endpoint.host!!,
            endpoint.port,
            endpoint.auth,
-            fileResolver
+            fileResolver,
+            endpoint.nodeRating
        ).apply {
            timeout = options.timeout
        }
--- a/src/main/kotlin/io/emeraldpay/dshackle/upstream/CurrentMultistreamHolder.kt
+++ b/src/main/kotlin/io/emeraldpay/dshackle/upstream/CurrentMultistreamHolder.kt
@@ -24,10 +24,7 @@ import io.emeraldpay.dshackle.upstream.bitcoin.BitcoinUpstream
 import io.emeraldpay.dshackle.upstream.calls.CallMethods
 import io.emeraldpay.dshackle.upstream.calls.DefaultBitcoinMethods
 import io.emeraldpay.dshackle.upstream.calls.DefaultEthereumMethods
-import io.emeraldpay.dshackle.upstream.ethereum.EthereumMultistream
-import io.emeraldpay.dshackle.upstream.ethereum.EthereumPosMultistream
-import io.emeraldpay.dshackle.upstream.ethereum.EthereumPosUpstream
-import io.emeraldpay.dshackle.upstream.ethereum.EthereumUpstream
+import io.emeraldpay.dshackle.upstream.ethereum.*
 import io.emeraldpay.grpc.BlockchainType
 import io.emeraldpay.grpc.Chain
 import org.slf4j.LoggerFactory
--- a/src/main/kotlin/io/emeraldpay/dshackle/upstream/ethereum/ERC20Balance.kt
+++ b/src/main/kotlin/io/emeraldpay/dshackle/upstream/ethereum/ERC20Balance.kt
@@ -49,7 +49,7 @@ open class ERC20Balance {
        apis.request(1)
        return Flux.from(apis)
            .flatMap {
-                getBalance(it.cast(EthereumUpstream::class.java), token, address)
+                getBalance(it.cast(EthereumRpcUpstream::class.java), token, address)
            }
            .doOnNext {
                apis.resolve()
@@ -57,7 +57,7 @@ open class ERC20Balance {
            .next()
    }

-    open fun getBalance(upstream: EthereumUpstream, token: ERC20Token, address: Address): Mono<BigInteger> {
+    open fun getBalance(upstream: EthereumRpcUpstream, token: ERC20Token, address: Address): Mono<BigInteger> {
        return upstream
            .getApi()
            .read(prepareEthCall(token, address, upstream.getHead()))
--- a/src/main/kotlin/io/emeraldpay/dshackle/upstream/ethereum/EthereumRpcUpstream.kt
+++ b/src/main/kotlin/io/emeraldpay/dshackle/upstream/ethereum/EthereumRpcUpstream.kt
@@ -0,0 +1,98 @@
+/**
+ * Copyright (c) 2020 EmeraldPay, Inc
+ * Copyright (c) 2019 ETCDEV GmbH
+ *
+ * Licensed 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 io.emeraldpay.dshackle.upstream.ethereum
+
+import io.emeraldpay.dshackle.cache.Caches
+import io.emeraldpay.dshackle.cache.CachesEnabled
+import io.emeraldpay.dshackle.config.UpstreamsConfig
+import io.emeraldpay.dshackle.reader.Reader
+import io.emeraldpay.dshackle.startup.QuorumForLabels
+import io.emeraldpay.dshackle.upstream.*
+import io.emeraldpay.dshackle.upstream.calls.CallMethods
+import io.emeraldpay.dshackle.upstream.ethereum.connectors.ConnectorFactory
+import io.emeraldpay.dshackle.upstream.ethereum.connectors.EthereumConnector
+import io.emeraldpay.dshackle.upstream.rpcclient.JsonRpcRequest
+import io.emeraldpay.dshackle.upstream.rpcclient.JsonRpcResponse
+import io.emeraldpay.grpc.Chain
+import org.slf4j.LoggerFactory
+import org.springframework.context.Lifecycle
+import reactor.core.Disposable
+
+open class EthereumRpcUpstream(
+    id: String,
+    val chain: Chain,
+    options: UpstreamsConfig.Options,
+    role: UpstreamsConfig.UpstreamRole,
+    targets: CallMethods?,
+    private val node: QuorumForLabels.QuorumItem?,
+    connectorFactory: ConnectorFactory
+) : EthereumUpstream(id, options, role, targets, node), Lifecycle, Upstream, CachesEnabled {
+    private val log = LoggerFactory.getLogger(EthereumRpcUpstream::class.java)
+    private val validator : EthereumUpstreamValidator = EthereumUpstreamValidator(this, getOptions())
+    private val connector : EthereumConnector = connectorFactory.create(this, validator, chain)
+
+    private var validatorSubscription: Disposable? = null
+
+    override fun setCaches(caches: Caches) {
+        if (connector is CachesEnabled) {
+            connector.setCaches(caches)
+        }
+    }
+
+    override fun start() {
+        log.info("Configured for ${chain.chainName}")
+        connector.start()
+        if (getOptions().disableValidation != null && getOptions().disableValidation!!) {
+            log.warn("Disable validation for upstream ${this.getId()}")
+            this.setLag(0)
+            this.setStatus(UpstreamAvailability.OK)
+        } else {
+            log.debug("Start validation for upstream ${this.getId()}")
+            validatorSubscription = validator.start()
+                .subscribe(this::setStatus)
+        }
+    }
+    override fun getHead(): Head {
+        return connector.getHead()
+    }
+
+    override fun stop() {
+        validatorSubscription?.dispose()
+        validatorSubscription = null
+        connector.stop()
+    }
+
+    override fun isRunning(): Boolean {
+        return connector.isRunning
+    }
+
+    override fun getApi(): Reader<JsonRpcRequest, JsonRpcResponse> {
+        return connector.getApi()
+    }
+
+    override fun isGrpc(): Boolean {
+        return false
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    override fun <T : Upstream> cast(selfType: Class<T>): T {
+        if (!selfType.isAssignableFrom(this.javaClass)) {
+            throw ClassCastException("Cannot cast ${this.javaClass} to $selfType")
+        }
+        return this as T
+    }
+}
--- a/src/main/kotlin/io/emeraldpay/dshackle/upstream/ethereum/EthereumUpstream.kt
+++ b/src/main/kotlin/io/emeraldpay/dshackle/upstream/ethereum/EthereumUpstream.kt
@@ -16,78 +16,19 @@
 */
 package io.emeraldpay.dshackle.upstream.ethereum

-import io.emeraldpay.dshackle.cache.Caches
-import io.emeraldpay.dshackle.cache.CachesEnabled
 import io.emeraldpay.dshackle.config.UpstreamsConfig
-import io.emeraldpay.dshackle.reader.Reader
 import io.emeraldpay.dshackle.startup.QuorumForLabels
-import io.emeraldpay.dshackle.upstream.*
+import io.emeraldpay.dshackle.upstream.Capability
+import io.emeraldpay.dshackle.upstream.DefaultUpstream
 import io.emeraldpay.dshackle.upstream.calls.CallMethods
-import io.emeraldpay.dshackle.upstream.ethereum.connectors.ConnectorFactory
-import io.emeraldpay.dshackle.upstream.ethereum.connectors.EthereumConnector
-import io.emeraldpay.dshackle.upstream.ethereum.connectors.EthereumConnectorFactory
-import io.emeraldpay.dshackle.upstream.rpcclient.JsonRpcRequest
-import io.emeraldpay.dshackle.upstream.rpcclient.JsonRpcResponse
-import io.emeraldpay.grpc.Chain
-import org.slf4j.LoggerFactory
-import org.springframework.context.Lifecycle
-import reactor.core.Disposable

-open class EthereumUpstream(
+abstract class EthereumUpstream(
    id: String,
-    val chain: Chain,
    options: UpstreamsConfig.Options,
    role: UpstreamsConfig.UpstreamRole,
    targets: CallMethods?,
-    private val node: QuorumForLabels.QuorumItem?,
-    connectorFactory: ConnectorFactory
-) : DefaultUpstream(id, options, role, targets, node), Lifecycle, Upstream, CachesEnabled {
-    private val log = LoggerFactory.getLogger(EthereumUpstream::class.java)
-    private val validator : EthereumUpstreamValidator = EthereumUpstreamValidator(this, getOptions())
-    private val connector : EthereumConnector = connectorFactory.create(this, validator, chain)
-
-    private var validatorSubscription: Disposable? = null
-
-    override fun setCaches(caches: Caches) {
-        if (connector is CachesEnabled) {
-            connector.setCaches(caches)
-        }
-    }
-
-    override fun start() {
-        log.info("Configured for ${chain.chainName}")
-        connector.start()
-        if (getOptions().disableValidation != null && getOptions().disableValidation!!) {
-            log.warn("Disable validation for upstream ${this.getId()}")
-            this.setLag(0)
-            this.setStatus(UpstreamAvailability.OK)
-        } else {
-            log.debug("Start validation for upstream ${this.getId()}")
-            validatorSubscription = validator.start()
-                .subscribe(this::setStatus)
-        }
-    }
-    override fun getHead(): Head {
-        return connector.getHead()
-    }
-
-    override fun stop() {
-        validatorSubscription?.dispose()
-        validatorSubscription = null
-        connector.stop()
-    }
-
-    override fun isRunning(): Boolean {
-        return connector.isRunning
-    }
-
-    override fun getApi(): Reader<JsonRpcRequest, JsonRpcResponse> {
-        return connector.getApi()
-    }
-
-    override fun isGrpc(): Boolean {
-        return false
-    }
+    private val node: QuorumForLabels.QuorumItem?
+) : DefaultUpstream(id, options, role, targets, node) {

    private val capabilities = if (options.providesBalance != false) {
        setOf(Capability.RPC, Capability.BALANCE)
@@ -102,12 +43,4 @@ open class EthereumUpstream(
    override fun getLabels(): Collection<UpstreamsConfig.Labels> {
        return node?.let { listOf(it.labels) } ?: emptyList()
    }
-
-    @Suppress("UNCHECKED_CAST")
-    override fun <T : Upstream> cast(selfType: Class<T>): T {
-        if (!selfType.isAssignableFrom(this.javaClass)) {
-            throw ClassCastException("Cannot cast ${this.javaClass} to $selfType")
-        }
-        return this as T
-    }
-}
+}
--- a/src/main/kotlin/io/emeraldpay/dshackle/upstream/ethereum_pos/EthereumPosMultiStream.kt
+++ b/src/main/kotlin/io/emeraldpay/dshackle/upstream/ethereum_pos/EthereumPosMultiStream.kt
@@ -25,7 +25,6 @@ import io.emeraldpay.dshackle.upstream.MergedHead
 import io.emeraldpay.dshackle.upstream.Multistream
 import io.emeraldpay.dshackle.upstream.Selector
 import io.emeraldpay.dshackle.upstream.Upstream
-import io.emeraldpay.dshackle.upstream.forkchoice.MostWorkForkChoice
 import io.emeraldpay.dshackle.upstream.forkchoice.PriorityForkChoice
 import io.emeraldpay.dshackle.upstream.rpcclient.JsonRpcRequest
 import io.emeraldpay.dshackle.upstream.rpcclient.JsonRpcResponse
--- a/src/main/kotlin/io/emeraldpay/dshackle/upstream/ethereum_pos/EthereumPosRpcUpstream.kt
+++ b/src/main/kotlin/io/emeraldpay/dshackle/upstream/ethereum_pos/EthereumPosRpcUpstream.kt
@@ -0,0 +1,98 @@
+/**
+ * Copyright (c) 2020 EmeraldPay, Inc
+ * Copyright (c) 2019 ETCDEV GmbH
+ *
+ * Licensed 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 io.emeraldpay.dshackle.upstream.ethereum
+
+import io.emeraldpay.dshackle.cache.Caches
+import io.emeraldpay.dshackle.cache.CachesEnabled
+import io.emeraldpay.dshackle.config.UpstreamsConfig
+import io.emeraldpay.dshackle.reader.Reader
+import io.emeraldpay.dshackle.startup.QuorumForLabels
+import io.emeraldpay.dshackle.upstream.*
+import io.emeraldpay.dshackle.upstream.calls.CallMethods
+import io.emeraldpay.dshackle.upstream.ethereum.connectors.ConnectorFactory
+import io.emeraldpay.dshackle.upstream.ethereum.connectors.EthereumConnector
+import io.emeraldpay.dshackle.upstream.rpcclient.JsonRpcRequest
+import io.emeraldpay.dshackle.upstream.rpcclient.JsonRpcResponse
+import io.emeraldpay.grpc.Chain
+import org.slf4j.LoggerFactory
+import org.springframework.context.Lifecycle
+import reactor.core.Disposable
+
+open class EthereumPosRpcUpstream(
+    id: String,
+    val chain: Chain,
+    options: UpstreamsConfig.Options,
+    role: UpstreamsConfig.UpstreamRole,
+    targets: CallMethods?,
+    private val node: QuorumForLabels.QuorumItem?,
+    connectorFactory: ConnectorFactory
+) : EthereumPosUpstream(id, options, role, targets, node), Lifecycle, Upstream, CachesEnabled {
+    private val log = LoggerFactory.getLogger(EthereumPosRpcUpstream::class.java)
+    private val validator : EthereumUpstreamValidator = EthereumUpstreamValidator(this, getOptions())
+    private val connector : EthereumConnector = connectorFactory.create(this, validator, chain)
+
+    private var validatorSubscription: Disposable? = null
+
+    override fun setCaches(caches: Caches) {
+        if (connector is CachesEnabled) {
+            connector.setCaches(caches)
+        }
+    }
+
+    override fun start() {
+        log.info("Configured for ${chain.chainName}")
+        connector.start()
+        if (getOptions().disableValidation != null && getOptions().disableValidation!!) {
+            log.warn("Disable validation for upstream ${this.getId()}")
+            this.setLag(0)
+            this.setStatus(UpstreamAvailability.OK)
+        } else {
+            log.debug("Start validation for upstream ${this.getId()}")
+            validatorSubscription = validator.start()
+                .subscribe(this::setStatus)
+        }
+    }
+    override fun getHead(): Head {
+        return connector.getHead()
+    }
+
+    override fun stop() {
+        validatorSubscription?.dispose()
+        validatorSubscription = null
+        connector.stop()
+    }
+
+    override fun isRunning(): Boolean {
+        return connector.isRunning
+    }
+
+    override fun getApi(): Reader<JsonRpcRequest, JsonRpcResponse> {
+        return connector.getApi()
+    }
+
+    override fun isGrpc(): Boolean {
+        return false
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    override fun <T : Upstream> cast(selfType: Class<T>): T {
+        if (!selfType.isAssignableFrom(this.javaClass)) {
+            throw ClassCastException("Cannot cast ${this.javaClass} to $selfType")
+        }
+        return this as T
+    }
+}
--- a/src/main/kotlin/io/emeraldpay/dshackle/upstream/ethereum_pos/EthereumPosUpstream.kt
+++ b/src/main/kotlin/io/emeraldpay/dshackle/upstream/ethereum_pos/EthereumPosUpstream.kt
@@ -16,78 +16,19 @@
 */
 package io.emeraldpay.dshackle.upstream.ethereum

-import io.emeraldpay.dshackle.cache.Caches
-import io.emeraldpay.dshackle.cache.CachesEnabled
 import io.emeraldpay.dshackle.config.UpstreamsConfig
-import io.emeraldpay.dshackle.reader.Reader
 import io.emeraldpay.dshackle.startup.QuorumForLabels
-import io.emeraldpay.dshackle.upstream.*
+import io.emeraldpay.dshackle.upstream.Capability
+import io.emeraldpay.dshackle.upstream.DefaultUpstream
 import io.emeraldpay.dshackle.upstream.calls.CallMethods
-import io.emeraldpay.dshackle.upstream.ethereum.connectors.ConnectorFactory
-import io.emeraldpay.dshackle.upstream.ethereum.connectors.EthereumConnector
-import io.emeraldpay.dshackle.upstream.ethereum.connectors.EthereumConnectorFactory
-import io.emeraldpay.dshackle.upstream.rpcclient.JsonRpcRequest
-import io.emeraldpay.dshackle.upstream.rpcclient.JsonRpcResponse
-import io.emeraldpay.grpc.Chain
-import org.slf4j.LoggerFactory
-import org.springframework.context.Lifecycle
-import reactor.core.Disposable

-open class EthereumPosUpstream(
+abstract class EthereumPosUpstream(
    id: String,
-    val chain: Chain,
    options: UpstreamsConfig.Options,
    role: UpstreamsConfig.UpstreamRole,
    targets: CallMethods?,
-    private val node: QuorumForLabels.QuorumItem?,
-    connectorFactory: ConnectorFactory
-) : DefaultUpstream(id, options, role, targets, node), Lifecycle, Upstream, CachesEnabled {
-    private val log = LoggerFactory.getLogger(EthereumPosUpstream::class.java)
-    private val validator : EthereumUpstreamValidator = EthereumUpstreamValidator(this, getOptions())
-    private val connector : EthereumConnector = connectorFactory.create(this, validator, chain)
-
-    private var validatorSubscription: Disposable? = null
-
-    override fun setCaches(caches: Caches) {
-        if (connector is CachesEnabled) {
-            connector.setCaches(caches)
-        }
-    }
-
-    override fun start() {
-        log.info("Configured for ${chain.chainName}")
-        connector.start()
-        if (getOptions().disableValidation != null && getOptions().disableValidation!!) {
-            log.warn("Disable validation for upstream ${this.getId()}")
-            this.setLag(0)
-            this.setStatus(UpstreamAvailability.OK)
-        } else {
-            log.debug("Start validation for upstream ${this.getId()}")
-            validatorSubscription = validator.start()
-                .subscribe(this::setStatus)
-        }
-    }
-    override fun getHead(): Head {
-        return connector.getHead()
-    }
-
-    override fun stop() {
-        validatorSubscription?.dispose()
-        validatorSubscription = null
-        connector.stop()
-    }
-
-    override fun isRunning(): Boolean {
-        return connector.isRunning
-    }
-
-    override fun getApi(): Reader<JsonRpcRequest, JsonRpcResponse> {
-        return connector.getApi()
-    }
-
-    override fun isGrpc(): Boolean {
-        return false
-    }
+    private val node: QuorumForLabels.QuorumItem?
+) : DefaultUpstream(id, options, role, targets, node) {

    private val capabilities = if (options.providesBalance != false) {
        setOf(Capability.RPC, Capability.BALANCE)
@@ -102,12 +43,4 @@ open class EthereumPosUpstream(
    override fun getLabels(): Collection<UpstreamsConfig.Labels> {
        return node?.let { listOf(it.labels) } ?: emptyList()
    }
-
-    @Suppress("UNCHECKED_CAST")
-    override fun <T : Upstream> cast(selfType: Class<T>): T {
-        if (!selfType.isAssignableFrom(this.javaClass)) {
-            throw ClassCastException("Cannot cast ${this.javaClass} to $selfType")
-        }
-        return this as T
-    }
-}
+}
--- a/src/main/kotlin/io/emeraldpay/dshackle/upstream/grpc/EthereumGrpcUpstream.kt
+++ b/src/main/kotlin/io/emeraldpay/dshackle/upstream/grpc/EthereumGrpcUpstream.kt
@@ -50,7 +50,7 @@ open class EthereumGrpcUpstream(
    private val chain: Chain,
    private val remote: ReactorBlockchainGrpc.ReactorBlockchainStub,
    private val client: JsonRpcGrpcClient
-) : DefaultUpstream(
+) : EthereumUpstream(
    "${parentId}_${chain.chainCode.lowercase(Locale.getDefault())}",
    UpstreamsConfig.Options.getDefaults(),
    role,
--- a/src/main/kotlin/io/emeraldpay/dshackle/upstream/grpc/EthereumPosGrpcUpstream.kt
+++ b/src/main/kotlin/io/emeraldpay/dshackle/upstream/grpc/EthereumPosGrpcUpstream.kt
@@ -26,8 +26,8 @@ import io.emeraldpay.dshackle.reader.Reader
 import io.emeraldpay.dshackle.startup.QuorumForLabels
 import io.emeraldpay.dshackle.upstream.*
 import io.emeraldpay.dshackle.upstream.calls.CallMethods
-import io.emeraldpay.dshackle.upstream.ethereum.EthereumUpstream
-import io.emeraldpay.dshackle.upstream.forkchoice.MostWorkForkChoice
+import io.emeraldpay.dshackle.upstream.ethereum.EthereumPosUpstream
+import io.emeraldpay.dshackle.upstream.forkchoice.NoChoiceWithPriorityForkChoice
 import io.emeraldpay.dshackle.upstream.rpcclient.JsonRpcGrpcClient
 import io.emeraldpay.dshackle.upstream.rpcclient.JsonRpcRequest
 import io.emeraldpay.dshackle.upstream.rpcclient.JsonRpcResponse
@@ -48,9 +48,10 @@ open class EthereumPosGrpcUpstream(
    private val parentId: String,
    role: UpstreamsConfig.UpstreamRole,
    private val chain: Chain,
-    private val remote: ReactorBlockchainGrpc.ReactorBlockchainStub,
-    private val client: JsonRpcGrpcClient
-) : DefaultUpstream(
+    remote: ReactorBlockchainGrpc.ReactorBlockchainStub,
+    client: JsonRpcGrpcClient,
+    nodeRating: Int
+) : EthereumPosUpstream(
    "${parentId}_${chain.chainCode.lowercase(Locale.getDefault())}",
    UpstreamsConfig.Options.getDefaults(),
    role,
@@ -94,7 +95,7 @@ open class EthereumPosGrpcUpstream(

    private val log = LoggerFactory.getLogger(EthereumGrpcUpstream::class.java)
    private val upstreamStatus = GrpcUpstreamStatus()
-    private val grpcHead = GrpcHead(chain, this, remote, blockConverter, reloadBlock, MostWorkForkChoice())
+    private val grpcHead = GrpcHead(chain, this, remote, blockConverter, reloadBlock, NoChoiceWithPriorityForkChoice(nodeRating))
    private var capabilities: Set<Capability> = emptySet()

    private val defaultReader: Reader<JsonRpcRequest, JsonRpcResponse> = client.forSelector(Selector.empty)
--- a/src/main/kotlin/io/emeraldpay/dshackle/upstream/grpc/GrpcUpstreams.kt
+++ b/src/main/kotlin/io/emeraldpay/dshackle/upstream/grpc/GrpcUpstreams.kt
@@ -56,7 +56,8 @@ class GrpcUpstreams(
    private val host: String,
    private val port: Int,
    private val auth: AuthConfig.ClientTlsAuth? = null,
-    private val fileResolver: FileResolver
+    private val fileResolver: FileResolver,
+    private val nodeRating: Int
 ) {
    private val log = LoggerFactory.getLogger(GrpcUpstreams::class.java)

@@ -192,6 +193,8 @@ class GrpcUpstreams(
            return getOrCreateEthereum(chain, metrics)
        } else if (blockchainType == BlockchainType.BITCOIN) {
            return getOrCreateBitcoin(chain, metrics)
+        } else if (blockchainType == BlockchainType.ETHEREUM_POS) {
+            return getOrCreateEthereumPos(chain, metrics)
        } else {
            throw IllegalArgumentException("Unsupported blockchain: $chain")
        }
@@ -213,6 +216,22 @@ class GrpcUpstreams(
        }
    }

+    fun getOrCreateEthereumPos(chain: Chain, metrics: RpcMetrics): UpstreamChange {
+        lock.withLock {
+            val current = known[chain]
+            return if (current == null) {
+                val rpcClient = JsonRpcGrpcClient(client!!, chain, metrics)
+                val created = EthereumPosGrpcUpstream(id, role, chain, client!!, rpcClient, nodeRating)
+                created.timeout = this.timeout
+                known[chain] = created
+                created.start()
+                UpstreamChange(chain, created, UpstreamChange.ChangeType.ADDED)
+            } else {
+                UpstreamChange(chain, current, UpstreamChange.ChangeType.REVALIDATED)
+            }
+        }
+    }
+
    fun getOrCreateBitcoin(chain: Chain, metrics: RpcMetrics): UpstreamChange {
        lock.withLock {
            val current = known[chain]
--- a/src/test/groovy/io/emeraldpay/dshackle/config/UpstreamsConfigReaderSpec.groovy
+++ b/src/test/groovy/io/emeraldpay/dshackle/config/UpstreamsConfigReaderSpec.groovy
@@ -17,9 +17,6 @@
 package io.emeraldpay.dshackle.config

 import io.emeraldpay.dshackle.test.TestingCommons
-import io.emeraldpay.dshackle.upstream.ethereum.EthereumUpstream
-import io.emeraldpay.grpc.Chain
-import io.emeraldpay.etherjar.rpc.RpcClient
 import spock.lang.Specification

 class UpstreamsConfigReaderSpec extends Specification {
--- a/src/test/groovy/io/emeraldpay/dshackle/rpc/StreamHeadSpec.groovy
+++ b/src/test/groovy/io/emeraldpay/dshackle/rpc/StreamHeadSpec.groovy
@@ -22,10 +22,10 @@ import io.emeraldpay.api.proto.BlockchainOuterClass
 import io.emeraldpay.api.proto.Common
 import io.emeraldpay.dshackle.Global
 import io.emeraldpay.dshackle.data.BlockContainer
-import io.emeraldpay.dshackle.test.EthereumUpstreamMock
+import io.emeraldpay.dshackle.test.EthereumRpcUpstreamMock
 import io.emeraldpay.dshackle.test.TestingCommons
 import io.emeraldpay.dshackle.test.MultistreamHolderMock
-import io.emeraldpay.dshackle.upstream.ethereum.EthereumUpstream
+import io.emeraldpay.dshackle.upstream.ethereum.EthereumRpcUpstream
 import io.emeraldpay.grpc.Chain
 import io.emeraldpay.etherjar.domain.BlockHash
 import io.emeraldpay.etherjar.rpc.json.BlockJson
@@ -43,7 +43,7 @@ class StreamHeadSpec extends Specification {

    def "Errors on unavailable chain"() {
        setup:
-        def upstreams = new MultistreamHolderMock(Chain.ETHEREUM, Stub(EthereumUpstream))
+        def upstreams = new MultistreamHolderMock(Chain.ETHEREUM, Stub(EthereumRpcUpstream))
        def streamHead = new StreamHead(upstreams)
        when:
        def flux = streamHead.add(
@@ -78,7 +78,7 @@ class StreamHeadSpec extends Specification {
                .build()
        }

-        def upstream = new EthereumUpstreamMock(Chain.ETHEREUM, TestingCommons.api())
+        def upstream = new EthereumRpcUpstreamMock(Chain.ETHEREUM, TestingCommons.api())
        def upstreams = new MultistreamHolderMock(Chain.ETHEREUM, upstream)
        def streamHead = new StreamHead(upstreams)
        when:
--- a/src/test/groovy/io/emeraldpay/dshackle/rpc/TrackERC20AddressSpec.groovy
+++ b/src/test/groovy/io/emeraldpay/dshackle/rpc/TrackERC20AddressSpec.groovy
@@ -3,18 +3,12 @@ package io.emeraldpay.dshackle.rpc
 import io.emeraldpay.api.proto.BlockchainOuterClass
 import io.emeraldpay.api.proto.Common
 import io.emeraldpay.dshackle.config.TokensConfig
-import io.emeraldpay.dshackle.test.EthereumUpstreamMock
-import io.emeraldpay.dshackle.test.MultistreamHolderMock
-import io.emeraldpay.dshackle.test.ReaderMock
 import io.emeraldpay.dshackle.upstream.MultistreamHolder
 import io.emeraldpay.dshackle.upstream.ethereum.ERC20Balance
 import io.emeraldpay.dshackle.upstream.ethereum.EthereumMultistream
 import io.emeraldpay.dshackle.upstream.ethereum.EthereumSubscribe
-import io.emeraldpay.dshackle.upstream.ethereum.EthereumUpstream
 import io.emeraldpay.dshackle.upstream.ethereum.subscribe.ConnectLogs
 import io.emeraldpay.dshackle.upstream.ethereum.subscribe.json.LogMessage
-import io.emeraldpay.dshackle.upstream.rpcclient.JsonRpcRequest
-import io.emeraldpay.dshackle.upstream.rpcclient.JsonRpcResponse
 import io.emeraldpay.etherjar.domain.BlockHash
 import io.emeraldpay.etherjar.domain.TransactionId
 import io.emeraldpay.etherjar.hex.Hex32
@@ -22,11 +16,9 @@ import io.emeraldpay.grpc.Chain
 import io.emeraldpay.etherjar.domain.Address
 import io.emeraldpay.etherjar.erc20.ERC20Token
 import io.emeraldpay.etherjar.hex.HexData
-import io.emeraldpay.etherjar.rpc.json.TransactionCallJson
 import reactor.core.publisher.Flux
 import reactor.core.publisher.Mono
 import reactor.test.StepVerifier
-import spock.lang.Ignore
 import spock.lang.Specification

 import java.time.Duration
--- a/src/test/groovy/io/emeraldpay/dshackle/test/EthereumRpcUpstreamMock.groovy
+++ b/src/test/groovy/io/emeraldpay/dshackle/test/EthereumRpcUpstreamMock.groovy
@@ -25,7 +25,7 @@ import io.emeraldpay.dshackle.startup.QuorumForLabels
 import io.emeraldpay.dshackle.upstream.calls.DefaultBitcoinMethods
 import io.emeraldpay.dshackle.upstream.calls.DefaultEthereumMethods
 import io.emeraldpay.dshackle.upstream.calls.DirectCallMethods
-import io.emeraldpay.dshackle.upstream.ethereum.EthereumUpstream
+import io.emeraldpay.dshackle.upstream.ethereum.EthereumRpcUpstream
 import io.emeraldpay.dshackle.upstream.UpstreamAvailability
 import io.emeraldpay.dshackle.upstream.rpcclient.JsonRpcRequest
 import io.emeraldpay.dshackle.upstream.rpcclient.JsonRpcResponse
@@ -35,7 +35,7 @@ import org.jetbrains.annotations.NotNull
 import org.reactivestreams.Publisher


-class EthereumUpstreamMock extends EthereumUpstream {
+class EthereumRpcUpstreamMock extends EthereumRpcUpstream {
    EthereumHeadMock ethereumHeadMock


@@ -47,19 +47,19 @@ class EthereumUpstreamMock extends EthereumUpstream {
        ])
    }

-    EthereumUpstreamMock(@NotNull Chain chain, @NotNull Reader<JsonRpcRequest, JsonRpcResponse> api) {
+    EthereumRpcUpstreamMock(@NotNull Chain chain, @NotNull Reader<JsonRpcRequest, JsonRpcResponse> api) {
        this(chain, api, allMethods())
    }

-    EthereumUpstreamMock(@NotNull String id, @NotNull Chain chain, @NotNull Reader<JsonRpcRequest, JsonRpcResponse> api) {
+    EthereumRpcUpstreamMock(@NotNull String id, @NotNull Chain chain, @NotNull Reader<JsonRpcRequest, JsonRpcResponse> api) {
        this(id, chain, api, allMethods())
    }

-    EthereumUpstreamMock(@NotNull Chain chain, @NotNull Reader<JsonRpcRequest, JsonRpcResponse> api, CallMethods methods) {
+    EthereumRpcUpstreamMock(@NotNull Chain chain, @NotNull Reader<JsonRpcRequest, JsonRpcResponse> api, CallMethods methods) {
        this("test", chain, api, methods)
    }

-    EthereumUpstreamMock(@NotNull String id, @NotNull Chain chain, @NotNull Reader<JsonRpcRequest, JsonRpcResponse> api, CallMethods methods) {
+    EthereumRpcUpstreamMock(@NotNull String id, @NotNull Chain chain, @NotNull Reader<JsonRpcRequest, JsonRpcResponse> api, CallMethods methods) {
        super(id, chain,
                UpstreamsConfig.Options.getDefaults(),
                UpstreamsConfig.UpstreamRole.PRIMARY,
--- a/src/test/groovy/io/emeraldpay/dshackle/test/MultistreamHolderMock.groovy
+++ b/src/test/groovy/io/emeraldpay/dshackle/test/MultistreamHolderMock.groovy
@@ -28,7 +28,7 @@ import io.emeraldpay.dshackle.upstream.Upstream
 import io.emeraldpay.dshackle.upstream.MultistreamHolder
 import io.emeraldpay.dshackle.upstream.ethereum.EthereumMultistream
 import io.emeraldpay.dshackle.upstream.ethereum.EthereumReader
-import io.emeraldpay.dshackle.upstream.ethereum.EthereumUpstream
+import io.emeraldpay.dshackle.upstream.ethereum.EthereumRpcUpstream
 import io.emeraldpay.grpc.BlockchainType
 import io.emeraldpay.grpc.Chain
 import org.jetbrains.annotations.NotNull
@@ -48,8 +48,8 @@ class MultistreamHolderMock implements MultistreamHolder {
            if (BlockchainType.from(chain) == BlockchainType.ETHEREUM) {
                if (up instanceof EthereumMultistream) {
                    upstreams[chain] = up
-                } else if (up instanceof EthereumUpstream) {
-                    upstreams[chain] = new EthereumMultistreamMock(chain, [up as EthereumUpstream], Caches.default())
+                } else if (up instanceof EthereumRpcUpstream) {
+                    upstreams[chain] = new EthereumMultistreamMock(chain, [up as EthereumRpcUpstream], Caches.default())
                } else {
                    throw new IllegalArgumentException("Unsupported upstream type ${up.class}")
                }
@@ -105,15 +105,15 @@ class MultistreamHolderMock implements MultistreamHolder {
        CallMethods customMethods = null
        Head customHead = null

-        EthereumMultistreamMock(@NotNull Chain chain, @NotNull List<EthereumUpstream> upstreams, @NotNull Caches caches) {
+        EthereumMultistreamMock(@NotNull Chain chain, @NotNull List<EthereumRpcUpstream> upstreams, @NotNull Caches caches) {
            super(chain, upstreams, caches)
        }

-        EthereumMultistreamMock(@NotNull Chain chain, @NotNull List<EthereumUpstream> upstreams) {
+        EthereumMultistreamMock(@NotNull Chain chain, @NotNull List<EthereumRpcUpstream> upstreams) {
            this(chain, upstreams, Caches.default())
        }

-        EthereumMultistreamMock(@NotNull Chain chain, @NotNull EthereumUpstream upstream) {
+        EthereumMultistreamMock(@NotNull Chain chain, @NotNull EthereumRpcUpstream upstream) {
            this(chain, [upstream])
        }

--- a/src/test/groovy/io/emeraldpay/dshackle/test/TestingCommons.groovy
+++ b/src/test/groovy/io/emeraldpay/dshackle/test/TestingCommons.groovy
@@ -28,7 +28,7 @@ import io.emeraldpay.dshackle.reader.Reader
 import io.emeraldpay.dshackle.upstream.Multistream
 import io.emeraldpay.dshackle.upstream.calls.DirectCallMethods
 import io.emeraldpay.dshackle.upstream.ethereum.EthereumMultistream
-import io.emeraldpay.dshackle.upstream.ethereum.EthereumUpstream
+import io.emeraldpay.dshackle.upstream.ethereum.EthereumRpcUpstream
 import io.emeraldpay.dshackle.upstream.rpcclient.JsonRpcRequest
 import io.emeraldpay.dshackle.upstream.rpcclient.JsonRpcResponse
 import io.emeraldpay.grpc.Chain
@@ -46,35 +46,35 @@ class TestingCommons {
        return new ApiReaderMock()
    }

-    static EthereumUpstreamMock upstream() {
-        return new EthereumUpstreamMock(Chain.ETHEREUM, api())
+    static EthereumRpcUpstreamMock upstream() {
+        return new EthereumRpcUpstreamMock(Chain.ETHEREUM, api())
    }

-    static EthereumUpstreamMock upstream(String id) {
-        return new EthereumUpstreamMock(id, Chain.ETHEREUM, api())
+    static EthereumRpcUpstreamMock upstream(String id) {
+        return new EthereumRpcUpstreamMock(id, Chain.ETHEREUM, api())
    }

-    static EthereumUpstreamMock upstream(String id, Reader<JsonRpcRequest, JsonRpcResponse> api) {
-        return new EthereumUpstreamMock(id, Chain.ETHEREUM, api)
+    static EthereumRpcUpstreamMock upstream(String id, Reader<JsonRpcRequest, JsonRpcResponse> api) {
+        return new EthereumRpcUpstreamMock(id, Chain.ETHEREUM, api)
    }

-    static EthereumUpstreamMock upstream(Reader<JsonRpcRequest, JsonRpcResponse> api) {
-        return new EthereumUpstreamMock(Chain.ETHEREUM, api)
+    static EthereumRpcUpstreamMock upstream(Reader<JsonRpcRequest, JsonRpcResponse> api) {
+        return new EthereumRpcUpstreamMock(Chain.ETHEREUM, api)
    }

-    static EthereumUpstreamMock upstream(Reader<JsonRpcRequest, JsonRpcResponse> api, String method) {
+    static EthereumRpcUpstreamMock upstream(Reader<JsonRpcRequest, JsonRpcResponse> api, String method) {
        return upstream(api, [method])
    }

-    static EthereumUpstreamMock upstream(Reader<JsonRpcRequest, JsonRpcResponse> api, List<String> methods) {
-        return new EthereumUpstreamMock(Chain.ETHEREUM, api, new DirectCallMethods(methods))
+    static EthereumRpcUpstreamMock upstream(Reader<JsonRpcRequest, JsonRpcResponse> api, List<String> methods) {
+        return new EthereumRpcUpstreamMock(Chain.ETHEREUM, api, new DirectCallMethods(methods))
    }

    static Multistream multistream(Reader<JsonRpcRequest, JsonRpcResponse> api) {
        return multistream(upstream(api))
    }

-    static Multistream multistream(EthereumUpstream up) {
+    static Multistream multistream(EthereumRpcUpstream up) {
        return new EthereumMultistream(Chain.ETHEREUM, [up], Caches.default()).tap {
            start()
        }
--- a/src/test/groovy/io/emeraldpay/dshackle/upstream/CurrentMultistreamHolderSpec.groovy
+++ b/src/test/groovy/io/emeraldpay/dshackle/upstream/CurrentMultistreamHolderSpec.groovy
@@ -16,7 +16,7 @@
 package io.emeraldpay.dshackle.upstream

 import io.emeraldpay.dshackle.startup.UpstreamChange
-import io.emeraldpay.dshackle.test.EthereumUpstreamMock
+import io.emeraldpay.dshackle.test.EthereumRpcUpstreamMock
 import io.emeraldpay.dshackle.test.TestingCommons
 import io.emeraldpay.grpc.Chain
 import spock.lang.Specification
@@ -26,7 +26,7 @@ class CurrentMultistreamHolderSpec extends Specification {
    def "add upstream"() {
        setup:
        def current = new CurrentMultistreamHolder(TestingCommons.emptyCaches())
-        def up = new EthereumUpstreamMock("test", Chain.ETHEREUM, TestingCommons.api())
+        def up = new EthereumRpcUpstreamMock("test", Chain.ETHEREUM, TestingCommons.api())
        when:
        current.update(new UpstreamChange(Chain.ETHEREUM, up, UpstreamChange.ChangeType.ADDED))
        then:
@@ -37,9 +37,9 @@ class CurrentMultistreamHolderSpec extends Specification {
    def "add multiple upstreams"() {
        setup:
        def current = new CurrentMultistreamHolder(TestingCommons.emptyCaches())
-        def up1 = new EthereumUpstreamMock("test1", Chain.ETHEREUM, TestingCommons.api())
-        def up2 = new EthereumUpstreamMock("test2", Chain.ETHEREUM_CLASSIC, TestingCommons.api())
-        def up3 = new EthereumUpstreamMock("test3", Chain.ETHEREUM, TestingCommons.api())
+        def up1 = new EthereumRpcUpstreamMock("test1", Chain.ETHEREUM, TestingCommons.api())
+        def up2 = new EthereumRpcUpstreamMock("test2", Chain.ETHEREUM_CLASSIC, TestingCommons.api())
+        def up3 = new EthereumRpcUpstreamMock("test3", Chain.ETHEREUM, TestingCommons.api())
        when:
        current.update(new UpstreamChange(Chain.ETHEREUM, up1, UpstreamChange.ChangeType.ADDED))
        current.update(new UpstreamChange(Chain.ETHEREUM_CLASSIC, up2, UpstreamChange.ChangeType.ADDED))
@@ -53,10 +53,10 @@ class CurrentMultistreamHolderSpec extends Specification {
    def "remove upstream"() {
        setup:
        def current = new CurrentMultistreamHolder(TestingCommons.emptyCaches())
-        def up1 = new EthereumUpstreamMock("test1", Chain.ETHEREUM, TestingCommons.api())
-        def up2 = new EthereumUpstreamMock("test2", Chain.ETHEREUM_CLASSIC, TestingCommons.api())
-        def up3 = new EthereumUpstreamMock("test3", Chain.ETHEREUM, TestingCommons.api())
-        def up1_del = new EthereumUpstreamMock("test1", Chain.ETHEREUM, TestingCommons.api())
+        def up1 = new EthereumRpcUpstreamMock("test1", Chain.ETHEREUM, TestingCommons.api())
+        def up2 = new EthereumRpcUpstreamMock("test2", Chain.ETHEREUM_CLASSIC, TestingCommons.api())
+        def up3 = new EthereumRpcUpstreamMock("test3", Chain.ETHEREUM, TestingCommons.api())
+        def up1_del = new EthereumRpcUpstreamMock("test1", Chain.ETHEREUM, TestingCommons.api())
        when:
        current.update(new UpstreamChange(Chain.ETHEREUM, up1, UpstreamChange.ChangeType.ADDED))
        current.update(new UpstreamChange(Chain.ETHEREUM_CLASSIC, up2, UpstreamChange.ChangeType.ADDED))
@@ -71,7 +71,7 @@ class CurrentMultistreamHolderSpec extends Specification {
    def "available after adding"() {
        setup:
        def current = new CurrentMultistreamHolder(TestingCommons.emptyCaches())
-        def up1 = new EthereumUpstreamMock("test1", Chain.ETHEREUM, TestingCommons.api())
+        def up1 = new EthereumRpcUpstreamMock("test1", Chain.ETHEREUM, TestingCommons.api())

        when:
        def act = current.isAvailable(Chain.ETHEREUM)
--- a/src/test/groovy/io/emeraldpay/dshackle/upstream/FilteredApisSpec.groovy
+++ b/src/test/groovy/io/emeraldpay/dshackle/upstream/FilteredApisSpec.groovy
@@ -21,7 +21,7 @@ import io.emeraldpay.dshackle.startup.QuorumForLabels
 import io.emeraldpay.dshackle.test.EthereumApiStub
 import io.emeraldpay.dshackle.test.TestingCommons
 import io.emeraldpay.dshackle.upstream.calls.DefaultEthereumMethods
-import io.emeraldpay.dshackle.upstream.ethereum.EthereumUpstream
+import io.emeraldpay.dshackle.upstream.ethereum.EthereumRpcUpstream
 import io.emeraldpay.dshackle.upstream.ethereum.connectors.EthereumConnectorFactory
 import io.emeraldpay.dshackle.upstream.forkchoice.MostWorkForkChoice
 import io.emeraldpay.grpc.Chain
@@ -38,7 +38,7 @@ class FilteredApisSpec extends Specification {
    def "Verifies labels"() {
        setup:
        def i = 0
-        List<EthereumUpstream> upstreams = [
+        List<EthereumRpcUpstream> upstreams = [
                [test: "foo"],
                [test: "bar"],
                [test: "foo", test2: "baz"],
@@ -49,7 +49,7 @@ class FilteredApisSpec extends Specification {
                create(_, _) >> TestingCommons.api().tap { it.id = "${i++}" }
            }
            def connectorFactory = new EthereumConnectorFactory(false, null, httpFactory, new MostWorkForkChoice())
-            new EthereumUpstream(
+            new EthereumRpcUpstream(
                    "test",
                    Chain.ETHEREUM,
                    new UpstreamsConfig.Options(),
--- a/src/test/groovy/io/emeraldpay/dshackle/upstream/MultistreamSpec.groovy
+++ b/src/test/groovy/io/emeraldpay/dshackle/upstream/MultistreamSpec.groovy
@@ -20,7 +20,7 @@ import io.emeraldpay.dshackle.cache.Caches
 import io.emeraldpay.dshackle.config.UpstreamsConfig
 import io.emeraldpay.dshackle.quorum.AlwaysQuorum
 import io.emeraldpay.dshackle.reader.Reader
-import io.emeraldpay.dshackle.test.EthereumUpstreamMock
+import io.emeraldpay.dshackle.test.EthereumRpcUpstreamMock
 import io.emeraldpay.dshackle.test.TestingCommons
 import io.emeraldpay.dshackle.upstream.calls.DirectCallMethods
 import io.emeraldpay.dshackle.upstream.ethereum.EthereumMultistream
@@ -38,8 +38,8 @@ class MultistreamSpec extends Specification {

    def "Aggregates methods"() {
        setup:
-        def up1 = new EthereumUpstreamMock("test1", Chain.ETHEREUM, TestingCommons.api(), new DirectCallMethods(["eth_test1", "eth_test2"]))
-        def up2 = new EthereumUpstreamMock("test1", Chain.ETHEREUM, TestingCommons.api(), new DirectCallMethods(["eth_test2", "eth_test3"]))
+        def up1 = new EthereumRpcUpstreamMock("test1", Chain.ETHEREUM, TestingCommons.api(), new DirectCallMethods(["eth_test1", "eth_test2"]))
+        def up2 = new EthereumRpcUpstreamMock("test1", Chain.ETHEREUM, TestingCommons.api(), new DirectCallMethods(["eth_test2", "eth_test3"]))
        def aggr = new EthereumMultistream(Chain.ETHEREUM, [up1, up2], Caches.default())
        when:
        aggr.onUpstreamsUpdated()
--- a/src/test/groovy/io/emeraldpay/dshackle/upstream/ethereum/ERC20BalanceSpec.groovy
+++ b/src/test/groovy/io/emeraldpay/dshackle/upstream/ethereum/ERC20BalanceSpec.groovy
@@ -15,7 +15,7 @@
 */
 package io.emeraldpay.dshackle.upstream.ethereum

-import io.emeraldpay.dshackle.test.EthereumUpstreamMock
+import io.emeraldpay.dshackle.test.EthereumRpcUpstreamMock
 import io.emeraldpay.dshackle.test.ReaderMock
 import io.emeraldpay.dshackle.upstream.ApiSource
 import io.emeraldpay.dshackle.upstream.FilteredApis
@@ -47,7 +47,7 @@ class ERC20BalanceSpec extends Specification {
                        JsonRpcResponse.ok('"0x0000000000000000000000000000000000000000000000000000001f28d72868"')
                )

-        EthereumUpstream upstream = new EthereumUpstreamMock(Chain.ETHEREUM, api)
+        EthereumRpcUpstream upstream = new EthereumRpcUpstreamMock(Chain.ETHEREUM, api)
        ERC20Token token = new ERC20Token(Address.from("0x54EedeAC495271d0F6B175474E89094C44Da98b9"))
        ERC20Balance query = new ERC20Balance()

@@ -73,7 +73,7 @@ class ERC20BalanceSpec extends Specification {
                        JsonRpcResponse.ok('"0x0000000000000000000000000000000000000000000000000000001f28d72868"')
                )

-        EthereumUpstream upstream = new EthereumUpstreamMock(Chain.ETHEREUM, api)
+        EthereumRpcUpstream upstream = new EthereumRpcUpstreamMock(Chain.ETHEREUM, api)
        ERC20Token token = new ERC20Token(Address.from("0x54EedeAC495271d0F6B175474E89094C44Da98b9"))
        ERC20Balance query = new ERC20Balance()

--- a/src/test/groovy/io/emeraldpay/dshackle/upstream/ethereum/EthereumReaderSpec.groovy
+++ b/src/test/groovy/io/emeraldpay/dshackle/upstream/ethereum/EthereumReaderSpec.groovy
@@ -23,7 +23,7 @@ import io.emeraldpay.dshackle.data.BlockContainer
 import io.emeraldpay.dshackle.data.BlockId
 import io.emeraldpay.dshackle.data.TxContainer
 import io.emeraldpay.dshackle.data.TxId
-import io.emeraldpay.dshackle.test.EthereumUpstreamMock
+import io.emeraldpay.dshackle.test.EthereumRpcUpstreamMock
 import io.emeraldpay.dshackle.test.TestingCommons
 import io.emeraldpay.dshackle.upstream.Multistream
 import io.emeraldpay.dshackle.upstream.calls.CallMethods
@@ -203,7 +203,7 @@ class EthereumReaderSpec extends Specification {
        api.answerOnce("eth_getBalance", ["0x70b91ff87a902b53dc6e2f6bda8bb9b330ccd30c", "latest"], "0x10")
        // height 101 + 1 => 102 => 0x66
        api.answerOnce("eth_getBalance", ["0x70b91ff87a902b53dc6e2f6bda8bb9b330ccd30c", "0x66"], "0xff")
-        EthereumUpstreamMock upstream = new EthereumUpstreamMock(Chain.ETHEREUM, api)
+        EthereumRpcUpstreamMock upstream = new EthereumRpcUpstreamMock(Chain.ETHEREUM, api)
        def upstreams = TestingCommons.multistream(upstream)
        def reader = new EthereumReader(upstreams, Caches.default(), calls)
        reader.start()
@@ -241,7 +241,7 @@ class EthereumReaderSpec extends Specification {
        api.answerOnce("eth_getTransactionReceipt", ["0xf85b826fdf98ee0f48f7db001be00472e63ceb056846f4ecac5f0c32878b8ab2"], [
                transactionHash: "0xf85b826fdf98ee0f48f7db001be00472e63ceb056846f4ecac5f0c32878b8ab2"
        ])
-        EthereumUpstreamMock upstream = new EthereumUpstreamMock(Chain.ETHEREUM, api)
+        EthereumRpcUpstreamMock upstream = new EthereumRpcUpstreamMock(Chain.ETHEREUM, api)
        def upstreams = TestingCommons.multistream(upstream)
        def reader = new EthereumReader(upstreams, Caches.default(), calls)
        reader.start()
@@ -257,7 +257,7 @@ class EthereumReaderSpec extends Specification {
    def "Read receipt from cache if available"() {
        setup:
        def api = TestingCommons.api()
-        EthereumUpstreamMock upstream = new EthereumUpstreamMock(Chain.ETHEREUM, api)
+        EthereumRpcUpstreamMock upstream = new EthereumRpcUpstreamMock(Chain.ETHEREUM, api)
        def upstreams = TestingCommons.multistream(upstream)
        def receiptCache = Mock(ReceiptRedisCache) {
            1 * it.read(TxId.from("0xf85b826fdf98ee0f48f7db001be00472e63ceb056846f4ecac5f0c32878b8ab2")) >>