ethereum as generic upstream

foundation/src/main/kotlin/org/drpc/chainsconfig/ChainsConfig.kt

@@ -33,7 +33,10 @@ data class ChainsConfig(private val chains: List<ChainConfig>) : Iterable<Chains
     ) {
         companion object {
             @JvmStatic
-            fun default() = ChainConfig(
+            fun default() = defaultWithContract(null)
+
+            @JvmStatic
+            fun defaultWithContract(callLimitContract: String?) = ChainConfig(
                 Duration.ofSeconds(12),
                 6,
                 1,
@@ -43,11 +46,14 @@ data class ChainsConfig(private val chains: List<ChainConfig>) : Iterable<Chains
                 0,
                 "UNKNOWN",
                 emptyList(),
-                null,
+                callLimitContract,
                 "undefined",
                 "undefined",
             )
         }
+
+
+
     }
 
     fun resolve(chain: String): ChainConfig {

src/main/kotlin/io/emeraldpay/dshackle/BlockchainType.kt

@@ -1,27 +1,21 @@
 package io.emeraldpay.dshackle
 
 enum class BlockchainType {
-    BITCOIN, EVM_POW, EVM_POS, STARKNET;
+    BITCOIN, ETHEREUM, STARKNET;
 
     companion object {
-
-        val pow = setOf(
-            Chain.ETHEREUM_CLASSIC__MAINNET,
-        )
         val bitcoin = setOf(Chain.BITCOIN__MAINNET, Chain.BITCOIN__TESTNET)
 
         val starknet = setOf(Chain.STARKNET__MAINNET, Chain.STARKNET__TESTNET, Chain.STARKNET__TESTNET_2)
 
         @JvmStatic
         fun from(chain: Chain): BlockchainType {
-            return if (pow.contains(chain)) {
-                EVM_POW
-            } else if (bitcoin.contains(chain)) {
+            return if (bitcoin.contains(chain)) {
                 BITCOIN
             } else if (starknet.contains(chain)) {
                 STARKNET
             } else {
-                EVM_POS
+                ETHEREUM
             }
         }
     }

src/main/kotlin/io/emeraldpay/dshackle/cache/CachesFactory.kt

@@ -97,7 +97,6 @@ open class CachesFactory(
             caches.setReceipts(ReceiptRedisCache(redis.reactive(), chain))
             caches.setHeightByHash(HeightByHashRedisCache(redis.reactive(), chain))
         }
-        caches.setCacheEnabled(cacheConfig.requestsCacheEnabled)
         return caches.build()
     }
 

src/main/kotlin/io/emeraldpay/dshackle/config/CacheConfig.kt

@@ -17,8 +17,6 @@ package io.emeraldpay.dshackle.config
 
 class CacheConfig {
 
-    var requestsCacheEnabled = true
-
     var redis: Redis? = null
 
     class Redis(

src/main/kotlin/io/emeraldpay/dshackle/config/CacheConfigReader.kt

@@ -16,21 +16,13 @@
 package io.emeraldpay.dshackle.config
 
 import io.emeraldpay.dshackle.foundation.YamlConfigReader
-import org.slf4j.LoggerFactory
 import org.yaml.snakeyaml.nodes.MappingNode
 
 class CacheConfigReader : YamlConfigReader<CacheConfig>() {
 
-    companion object {
-        private val log = LoggerFactory.getLogger(CacheConfigReader::class.java)
-    }
-
     override fun read(input: MappingNode?): CacheConfig? {
         return getMapping(input, "cache")?.let { node ->
             val config = CacheConfig()
-            getValueAsBool(node, "requests-cache-enabled")?.let {
-                config.requestsCacheEnabled = it
-            }
             getMapping(node, "redis")?.let { redisNode ->
                 val redis = CacheConfig.Redis()
                 val enabled = getValueAsBool(redisNode, "enabled") ?: true
@@ -50,7 +42,7 @@ class CacheConfigReader : YamlConfigReader<CacheConfig>() {
                     config.redis = redis
                 }
             }
-            if (config.redis == null && config.requestsCacheEnabled) {
+            if (config.redis == null) {
                 return null
             }
             config

src/main/kotlin/io/emeraldpay/dshackle/config/TokensConfig.kt

@@ -41,7 +41,7 @@ class TokensConfig(
                 type == null -> type
                 address.isNullOrBlank() -> "address"
                 blockchain != null &&
-                    (BlockchainType.from(blockchain!!) == BlockchainType.EVM_POS || BlockchainType.from(blockchain!!) == BlockchainType.EVM_POW) &&
+                    (BlockchainType.from(blockchain!!) == BlockchainType.ETHEREUM) &&
                     !Address.isValidAddress(address) -> "address"
                 else -> null
             }

src/main/kotlin/io/emeraldpay/dshackle/config/context/MultistreamsConfig.kt

@@ -2,16 +2,12 @@ package io.emeraldpay.dshackle.config.context
 
 import io.emeraldpay.dshackle.BlockchainType
 import io.emeraldpay.dshackle.BlockchainType.BITCOIN
-import io.emeraldpay.dshackle.BlockchainType.EVM_POS
-import io.emeraldpay.dshackle.BlockchainType.EVM_POW
-import io.emeraldpay.dshackle.BlockchainType.STARKNET
 import io.emeraldpay.dshackle.Chain
 import io.emeraldpay.dshackle.cache.CachesFactory
 import io.emeraldpay.dshackle.upstream.CallTargetsHolder
 import io.emeraldpay.dshackle.upstream.Multistream
 import io.emeraldpay.dshackle.upstream.bitcoin.BitcoinMultistream
-import io.emeraldpay.dshackle.upstream.ethereum.EthereumMultistream
-import io.emeraldpay.dshackle.upstream.ethereum.EthereumPosMultiStream
+import io.emeraldpay.dshackle.upstream.generic.ChainSpecificRegistry
 import io.emeraldpay.dshackle.upstream.generic.GenericMultistream
 import org.springframework.beans.factory.annotation.Qualifier
 import org.springframework.beans.factory.config.ConfigurableListableBeanFactory
@@ -31,14 +27,13 @@ open class MultistreamsConfig(val beanFactory: ConfigurableListableBeanFactory)
         headScheduler: Scheduler,
         tracer: Tracer,
     ): List<Multistream> {
-        return Chain.values()
+        return Chain.entries
             .filterNot { it == Chain.UNSPECIFIED }
             .map { chain ->
-                when (BlockchainType.from(chain)) {
-                    EVM_POS -> ethereumPosMultistream(chain, cachesFactory, headScheduler, tracer)
-                    EVM_POW -> ethereumMultistream(chain, cachesFactory, headScheduler, tracer)
-                    BITCOIN -> bitcoinMultistream(chain, cachesFactory, headScheduler)
-                    STARKNET -> genericMultistream(chain, cachesFactory, headScheduler)
+                if (BlockchainType.from(chain) == BITCOIN) {
+                    bitcoinMultistream(chain, cachesFactory, headScheduler)
+                } else {
+                    genericMultistream(chain, cachesFactory, headScheduler, tracer)
                 }
             }
     }
@@ -47,47 +42,18 @@ open class MultistreamsConfig(val beanFactory: ConfigurableListableBeanFactory)
         chain: Chain,
         cachesFactory: CachesFactory,
         headScheduler: Scheduler,
+        tracer: Tracer,
     ): Multistream {
         val name = "multi-$chain"
+        val cs = ChainSpecificRegistry.resolve(chain)
         return GenericMultistream(
             chain,
             CopyOnWriteArrayList(),
             cachesFactory.getCaches(chain),
             headScheduler,
-        ).also { register(it, name) }
-    }
-
-    private fun ethereumMultistream(
-        chain: Chain,
-        cachesFactory: CachesFactory,
-        headScheduler: Scheduler,
-        tracer: Tracer,
-    ): EthereumMultistream {
-        val name = "multi-ethereum-$chain"
-
-        return EthereumMultistream(
-            chain,
-            CopyOnWriteArrayList(),
-            cachesFactory.getCaches(chain),
-            headScheduler,
-            tracer,
-        ).also { register(it, name) }
-    }
-
-    open fun ethereumPosMultistream(
-        chain: Chain,
-        cachesFactory: CachesFactory,
-        headScheduler: Scheduler,
-        tracer: Tracer,
-    ): EthereumPosMultiStream {
-        val name = "multi-ethereum-pos-$chain"
-
-        return EthereumPosMultiStream(
-            chain,
-            CopyOnWriteArrayList(),
-            cachesFactory.getCaches(chain),
-            headScheduler,
-            tracer,
+            cs.makeCachingReaderBuilder(tracer),
+            cs::localReaderBuilder,
+            cs.subscriptionBuilder(headScheduler),
         ).also { register(it, name) }
     }
 

src/main/kotlin/io/emeraldpay/dshackle/rpc/NativeCall.kt

@@ -20,7 +20,7 @@ import com.fasterxml.jackson.databind.ObjectMapper
 import com.google.protobuf.ByteString
 import io.emeraldpay.api.proto.BlockchainOuterClass
 import io.emeraldpay.dshackle.BlockchainType
-import io.emeraldpay.dshackle.BlockchainType.EVM_POS
+import io.emeraldpay.dshackle.BlockchainType.ETHEREUM
 import io.emeraldpay.dshackle.Chain
 import io.emeraldpay.dshackle.Global
 import io.emeraldpay.dshackle.Global.Companion.nullValue
@@ -76,7 +76,6 @@ open class NativeCall(
     private val log = LoggerFactory.getLogger(NativeCall::class.java)
     private val objectMapper: ObjectMapper = Global.objectMapper
 
-    private val localRouterEnabled = config.cache?.requestsCacheEnabled ?: true
     private val passthrough = config.passthrough
 
     var rpcReaderFactory: RpcReaderFactory = RpcReaderFactory.default()
@@ -85,7 +84,7 @@ open class NativeCall(
     @EventListener
     fun onUpstreamChangeEvent(event: UpstreamChangeEvent) {
         multistreamHolder.getUpstream(event.chain).let { up ->
-            if (BlockchainType.from(up.chain) == EVM_POS) {
+            if (BlockchainType.from(up.chain) == ETHEREUM) {
                 ethereumCallSelectors.putIfAbsent(
                     event.chain,
                     EthereumCallSelector(up.caches),
@@ -307,7 +306,7 @@ open class NativeCall(
         }
         // for ethereum the actual block needed for the call may be specified in the call parameters
         val callSpecificMatcher: Mono<Selector.Matcher> =
-            if (BlockchainType.from(upstream.chain) == BlockchainType.EVM_POS || BlockchainType.from(upstream.chain) == BlockchainType.EVM_POW) {
+            if (BlockchainType.from(upstream.chain) == ETHEREUM) {
                 ethereumCallSelectors[chain]?.getMatcher(method, params, upstream.getHead(), passthrough)
             } else {
                 null
@@ -359,7 +358,7 @@ open class NativeCall(
         if (method in DefaultEthereumMethods.newFilterMethods) CreateFilterDecorator() else NoneResultDecorator()
 
     fun fetch(ctx: ValidCallContext<ParsedCallDetails>): Mono<CallResult> {
-        return ctx.upstream.getLocalReader(localRouterEnabled)
+        return ctx.upstream.getLocalReader()
             .flatMap { api ->
                 SpannedReader(api, tracer, LOCAL_READER)
                     .read(JsonRpcRequest(ctx.payload.method, ctx.payload.params, ctx.nonce, ctx.forwardedSelector))

src/main/kotlin/io/emeraldpay/dshackle/rpc/NativeSubscribe.kt

@@ -57,7 +57,7 @@ open class NativeSubscribe(
 
     fun start(request: BlockchainOuterClass.NativeSubscribeRequest): Publisher<ResponseHolder> {
         val chain = Chain.byId(request.chainValue)
-        if (BlockchainType.from(chain) != BlockchainType.EVM_POS && BlockchainType.from(chain) != BlockchainType.EVM_POW) {
+        if (BlockchainType.from(chain) != BlockchainType.ETHEREUM) {
             return Mono.error(UnsupportedOperationException("Native subscribe is not supported for ${chain.chainCode}"))
         }