introduction of upstream update event

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

@@ -1,6 +1,7 @@
 package io.emeraldpay.dshackle.config.context
 
 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
@@ -13,13 +14,31 @@ import org.springframework.context.annotation.Configuration
 @Configuration
 class MultistreamsConfig {
     @Bean
-    fun allMultistreams(cachesFactory: CachesFactory): List<Multistream> {
+    fun allMultistreams(
+        cachesFactory: CachesFactory,
+        callTargetsHolder: CallTargetsHolder
+    ): List<Multistream> {
         return Chain.values()
             .mapNotNull { chain ->
                 when (BlockchainType.from(chain)) {
-                    BlockchainType.EVM_POS -> EthereumPosMultiStream(chain, ArrayList(), cachesFactory.getCaches(chain))
-                    BlockchainType.EVM_POW -> EthereumMultistream(chain, ArrayList(), cachesFactory.getCaches(chain))
-                    BlockchainType.BITCOIN -> BitcoinMultistream(chain, ArrayList(), cachesFactory.getCaches(chain))
+                    BlockchainType.EVM_POS -> EthereumPosMultiStream(
+                        chain,
+                        ArrayList(),
+                        cachesFactory.getCaches(chain),
+                        callTargetsHolder
+                    )
+                    BlockchainType.EVM_POW -> EthereumMultistream(
+                        chain,
+                        ArrayList(),
+                        cachesFactory.getCaches(chain),
+                        callTargetsHolder
+                    )
+                    BlockchainType.BITCOIN -> BitcoinMultistream(
+                        chain,
+                        ArrayList(),
+                        cachesFactory.getCaches(chain),
+                        callTargetsHolder
+                    )
                     else -> null
                 }
             }

src/main/kotlin/io/emeraldpay/dshackle/startup/ConfiguredUpstreams.kt

@@ -21,13 +21,7 @@ import io.emeraldpay.dshackle.FileResolver
 import io.emeraldpay.dshackle.Global
 import io.emeraldpay.dshackle.config.UpstreamsConfig
 import io.emeraldpay.dshackle.reader.Reader
-import io.emeraldpay.dshackle.upstream.BlockValidator
-import io.emeraldpay.dshackle.upstream.CurrentMultistreamHolder
-import io.emeraldpay.dshackle.upstream.Head
-import io.emeraldpay.dshackle.upstream.HttpRpcFactory
-import io.emeraldpay.dshackle.upstream.MergedHead
-import io.emeraldpay.dshackle.upstream.Selector
-import io.emeraldpay.dshackle.upstream.Upstream
+import io.emeraldpay.dshackle.upstream.*
 import io.emeraldpay.dshackle.upstream.bitcoin.BitcoinRpcHead
 import io.emeraldpay.dshackle.upstream.bitcoin.BitcoinRpcUpstream
 import io.emeraldpay.dshackle.upstream.bitcoin.BitcoinZMQHead
@@ -50,19 +44,20 @@ import io.emeraldpay.dshackle.upstream.rpcclient.JsonRpcResponse
 import io.emeraldpay.grpc.BlockchainType
 import io.emeraldpay.grpc.Chain
 import org.slf4j.LoggerFactory
-import org.springframework.beans.factory.annotation.Autowired
-import org.springframework.stereotype.Repository
+import org.springframework.context.ApplicationEventPublisher
+import org.springframework.stereotype.Component
 import java.net.URI
 import java.util.concurrent.atomic.AtomicInteger
 import java.util.function.Function
 import javax.annotation.PostConstruct
 import kotlin.math.abs
 
-@Repository
+@Component
 open class ConfiguredUpstreams(
-    @Autowired private val currentUpstreams: CurrentMultistreamHolder,
-    @Autowired private val fileResolver: FileResolver,
-    @Autowired private val config: UpstreamsConfig
+    private val fileResolver: FileResolver,
+    private val config: UpstreamsConfig,
+    private val callTargets: CallTargetsHolder,
+    private val eventPublisher: ApplicationEventPublisher
 ) {
 
     private val log = LoggerFactory.getLogger(ConfiguredUpstreams::class.java)
@@ -115,7 +110,8 @@ open class ConfiguredUpstreams(
                     }
                 }
                 upstream?.let {
-                    currentUpstreams.update(UpstreamChange(chain, upstream, UpstreamChange.ChangeType.ADDED))
+                    val event = UpstreamChangeEvent(chain, upstream, UpstreamChangeEvent.ChangeType.ADDED)
+                    eventPublisher.publishEvent(event)
                 }
             }
         }
@@ -150,7 +146,7 @@ open class ConfiguredUpstreams(
     fun buildMethods(config: UpstreamsConfig.Upstream<*>, chain: Chain): CallMethods {
         return if (config.methods != null) {
             ManagedCallMethods(
-                currentUpstreams.getDefaultMethods(chain),
+                callTargets.getDefaultMethods(chain),
                 config.methods!!.enabled.map { it.name }.toSet(),
                 config.methods!!.disabled.map { it.name }.toSet()
             ).also {
@@ -164,7 +160,7 @@ open class ConfiguredUpstreams(
                 }
             }
         } else {
-            currentUpstreams.getDefaultMethods(chain)
+            callTargets.getDefaultMethods(chain)
         }
     }
 
@@ -315,7 +311,7 @@ open class ConfiguredUpstreams(
             .doOnNext {
                 log.info("Chain ${it.chain} ${it.type} through gRPC at ${endpoint.host}:${endpoint.port}. With caps: ${it.upstream.getCapabilities()}")
             }
-            .subscribe(currentUpstreams::update)
+            .subscribe(eventPublisher::publishEvent)
     }
 
     private fun buildHttpFactory(conn: UpstreamsConfig.RpcConnection, urls: ArrayList<URI>? = null): HttpRpcFactory? {

src/main/kotlin/io/emeraldpay/dshackle/startup/UpstreamChangeEvent.kt

@@ -24,7 +24,7 @@ import io.emeraldpay.grpc.Chain
 /**
  * An update event to the list of currently available upstreams.
  */
-class UpstreamChange(
+class UpstreamChangeEvent(
     /**
      * Target blockchain
      */

src/main/kotlin/io/emeraldpay/dshackle/upstream/CallTargetsHolder.kt

@@ -0,0 +1,29 @@
+package io.emeraldpay.dshackle.upstream
+
+import io.emeraldpay.dshackle.upstream.calls.CallMethods
+import io.emeraldpay.dshackle.upstream.calls.DefaultBitcoinMethods
+import io.emeraldpay.dshackle.upstream.calls.DefaultEthereumMethods
+import io.emeraldpay.grpc.BlockchainType
+import io.emeraldpay.grpc.Chain
+import org.springframework.stereotype.Component
+import java.util.HashMap
+
+@Component
+class CallTargetsHolder {
+    private val callTargets = HashMap<Chain, CallMethods>()
+
+    fun getDefaultMethods(chain: Chain): CallMethods {
+        return callTargets[chain] ?: return setupDefaultMethods(chain)
+    }
+
+    private fun setupDefaultMethods(chain: Chain): CallMethods {
+        val created = when (BlockchainType.from(chain)) {
+            BlockchainType.EVM_POW -> DefaultEthereumMethods(chain)
+            BlockchainType.BITCOIN -> DefaultBitcoinMethods()
+            BlockchainType.EVM_POS -> DefaultEthereumMethods(chain)
+            else -> throw IllegalStateException("Unsupported chain: $chain")
+        }
+        callTargets[chain] = created
+        return created
+    }
+}

src/main/kotlin/io/emeraldpay/dshackle/upstream/CurrentMultistreamHolder.kt

@@ -16,15 +16,6 @@
  */
 package io.emeraldpay.dshackle.upstream
 
-import io.emeraldpay.dshackle.cache.CachesEnabled
-import io.emeraldpay.dshackle.startup.UpstreamChange
-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.EthereumPosUpstream
-import io.emeraldpay.dshackle.upstream.ethereum.EthereumUpstream
-import io.emeraldpay.grpc.BlockchainType
 import io.emeraldpay.grpc.Chain
 import org.slf4j.LoggerFactory
 import org.springframework.stereotype.Component
@@ -49,61 +40,8 @@ open class CurrentMultistreamHolder(
     private val chainsBus = Sinks.many()
         .multicast()
         .directBestEffort<Chain>()
-    private val callTargets = HashMap<Chain, CallMethods>()
     private val updateLock = ReentrantLock()
 
-    fun update(change: UpstreamChange) {
-        updateLock.withLock {
-            log.debug("Upstream update: ${change.type} ${change.chain} via ${change.upstream.getId()}")
-            val chain = change.chain
-            try {
-                when (BlockchainType.from(chain)) {
-                    BlockchainType.EVM_POW -> {
-                        val up = change.upstream.cast(EthereumUpstream::class.java)
-                        val current = chainMapping.getValue(chain)
-                        processUpdate(change, up, current)
-                    }
-
-                    BlockchainType.EVM_POS -> {
-                        val up = change.upstream.cast(EthereumPosUpstream::class.java)
-                        val current = chainMapping.getValue(chain)
-                        processUpdate(change, up, current)
-                    }
-
-                    BlockchainType.BITCOIN -> {
-                        val up = change.upstream.cast(BitcoinUpstream::class.java)
-                        val current = chainMapping.getValue(chain)
-                        processUpdate(change, up, current)
-                    }
-
-                    else -> {
-                        log.error("Update for unsupported chain: $chain")
-                    }
-                }
-            } catch (e: Throwable) {
-                log.error("Failed to update upstream", e)
-            }
-        }
-    }
-
-    fun processUpdate(change: UpstreamChange, up: Upstream, current: Multistream) {
-        val chain = change.chain
-        if (change.type == UpstreamChange.ChangeType.REMOVED) {
-            current.removeUpstream(up.getId())
-            log.info("Upstream ${change.upstream.getId()} with chain $chain has been removed")
-        } else {
-            if (up is CachesEnabled) {
-                up.setCaches(current.caches)
-            }
-            current.addUpstream(up)
-
-            if (!callTargets.containsKey(chain)) {
-                setupDefaultMethods(chain)
-            }
-            log.info("Upstream ${change.upstream.getId()} with chain $chain has been added")
-        }
-    }
-
     override fun getUpstream(chain: Chain): Multistream? {
         return chainMapping[chain]
     }
@@ -122,23 +60,8 @@ open class CurrentMultistreamHolder(
         )
     }
 
-    override fun getDefaultMethods(chain: Chain): CallMethods {
-        return callTargets[chain] ?: return setupDefaultMethods(chain)
-    }
-
-    fun setupDefaultMethods(chain: Chain): CallMethods {
-        val created = when (BlockchainType.from(chain)) {
-            BlockchainType.EVM_POW -> DefaultEthereumMethods(chain)
-            BlockchainType.BITCOIN -> DefaultBitcoinMethods()
-            BlockchainType.EVM_POS -> DefaultEthereumMethods(chain)
-            else -> throw IllegalStateException("Unsupported chain: $chain")
-        }
-        callTargets[chain] = created
-        return created
-    }
-
     override fun isAvailable(chain: Chain): Boolean {
-        return chainMapping.containsKey(chain) && callTargets.containsKey(chain)
+        return chainMapping.getValue(chain).isAvailable()
     }
 
     @PreDestroy

src/main/kotlin/io/emeraldpay/dshackle/upstream/Multistream.kt

@@ -17,8 +17,10 @@
 package io.emeraldpay.dshackle.upstream
 
 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.UpstreamChangeEvent
 import io.emeraldpay.dshackle.upstream.calls.AggregatedCallMethods
 import io.emeraldpay.dshackle.upstream.calls.CallMethods
 import io.emeraldpay.dshackle.upstream.rpcclient.JsonRpcRequest
@@ -30,6 +32,7 @@ import org.apache.commons.collections4.Factory
 import org.apache.commons.collections4.FunctorException
 import org.slf4j.LoggerFactory
 import org.springframework.context.Lifecycle
+import org.springframework.context.event.EventListener
 import reactor.core.Disposable
 import reactor.core.publisher.Flux
 import reactor.core.publisher.Mono
@@ -48,7 +51,8 @@ abstract class Multistream(
     val chain: Chain,
     private val upstreams: MutableList<Upstream>,
     val caches: Caches,
-    val postprocessor: RequestPostprocessor
+    val postprocessor: RequestPostprocessor,
+    val callTargetsHolder: CallTargetsHolder
 ) : Upstream, Lifecycle {
 
     companion object {
@@ -316,6 +320,23 @@ abstract class Multistream(
         log.info("State of ${chain.chainCode}: height=${height ?: '?'}, status=[$statuses], lag=[$lag], weak=[$weak]")
     }
 
+    @EventListener
+    fun onUpstreamChange(event: UpstreamChangeEvent) {
+        val chain = event.chain
+        if (this.chain == chain) {
+            if (event.type == UpstreamChangeEvent.ChangeType.REMOVED) {
+                removeUpstream(event.upstream.getId())
+                log.info("Upstream ${event.upstream.getId()} with chain $chain has been removed")
+            } else {
+                if (event.upstream is CachesEnabled) {
+                    event.upstream.setCaches(caches)
+                }
+                addUpstream(event.upstream)
+                log.info("Upstream ${event.upstream.getId()} with chain $chain has been added")
+            }
+        }
+    }
+
     // --------------------------------------------------------------------------------------------------------
 
     class UpstreamStatus(val upstream: Upstream, val status: UpstreamAvailability, val ts: Instant = Instant.now())

src/main/kotlin/io/emeraldpay/dshackle/upstream/MultistreamHolder.kt

@@ -16,7 +16,6 @@
  */
 package io.emeraldpay.dshackle.upstream
 
-import io.emeraldpay.dshackle.upstream.calls.CallMethods
 import io.emeraldpay.grpc.Chain
 import reactor.core.publisher.Flux
 
@@ -27,6 +26,5 @@ interface MultistreamHolder {
     fun getUpstream(chain: Chain): Multistream?
     fun getAvailable(): List<Chain>
     fun observeChains(): Flux<Chain>
-    fun getDefaultMethods(chain: Chain): CallMethods
     fun isAvailable(chain: Chain): Boolean
 }

src/main/kotlin/io/emeraldpay/dshackle/upstream/bitcoin/BitcoinMultistream.kt

@@ -18,14 +18,7 @@ package io.emeraldpay.dshackle.upstream.bitcoin
 import io.emeraldpay.dshackle.cache.Caches
 import io.emeraldpay.dshackle.config.UpstreamsConfig
 import io.emeraldpay.dshackle.reader.Reader
-import io.emeraldpay.dshackle.upstream.ChainFees
-import io.emeraldpay.dshackle.upstream.EmptyHead
-import io.emeraldpay.dshackle.upstream.Head
-import io.emeraldpay.dshackle.upstream.MergedHead
-import io.emeraldpay.dshackle.upstream.Multistream
-import io.emeraldpay.dshackle.upstream.RequestPostprocessor
-import io.emeraldpay.dshackle.upstream.Selector
-import io.emeraldpay.dshackle.upstream.Upstream
+import io.emeraldpay.dshackle.upstream.*
 import io.emeraldpay.dshackle.upstream.calls.DefaultBitcoinMethods
 import io.emeraldpay.dshackle.upstream.forkchoice.MostWorkForkChoice
 import io.emeraldpay.dshackle.upstream.rpcclient.JsonRpcRequest
@@ -39,8 +32,9 @@ import reactor.core.publisher.Mono
 open class BitcoinMultistream(
     chain: Chain,
     private val sourceUpstreams: MutableList<BitcoinUpstream>,
-    caches: Caches
-) : Multistream(chain, sourceUpstreams as MutableList<Upstream>, caches, RequestPostprocessor.Empty()), Lifecycle {
+    caches: Caches,
+    callTargetsHolder: CallTargetsHolder
+) : Multistream(chain, sourceUpstreams as MutableList<Upstream>, caches, RequestPostprocessor.Empty(), callTargetsHolder), Lifecycle {
 
     companion object {
         private val log = LoggerFactory.getLogger(BitcoinMultistream::class.java)

src/main/kotlin/io/emeraldpay/dshackle/upstream/ethereum/EthereumMultistream.kt

@@ -20,13 +20,7 @@ import io.emeraldpay.api.proto.BlockchainOuterClass
 import io.emeraldpay.dshackle.cache.Caches
 import io.emeraldpay.dshackle.config.UpstreamsConfig
 import io.emeraldpay.dshackle.reader.Reader
-import io.emeraldpay.dshackle.upstream.ChainFees
-import io.emeraldpay.dshackle.upstream.EmptyHead
-import io.emeraldpay.dshackle.upstream.Head
-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.*
 import io.emeraldpay.dshackle.upstream.forkchoice.MostWorkForkChoice
 import io.emeraldpay.dshackle.upstream.grpc.GrpcUpstream
 import io.emeraldpay.dshackle.upstream.rpcclient.JsonRpcRequest
@@ -42,8 +36,9 @@ import reactor.core.publisher.Mono
 open class EthereumMultistream(
     chain: Chain,
     val upstreams: MutableList<EthereumUpstream>,
-    caches: Caches
-) : Multistream(chain, upstreams as MutableList<Upstream>, caches, CacheRequested(caches)), EthereumLikeMultistream {
+    caches: Caches,
+    callTargetsHolder: CallTargetsHolder
+) : Multistream(chain, upstreams as MutableList<Upstream>, caches, CacheRequested(caches), callTargetsHolder), EthereumLikeMultistream {
 
     companion object {
         private val log = LoggerFactory.getLogger(EthereumMultistream::class.java)

src/main/kotlin/io/emeraldpay/dshackle/upstream/ethereum_pos/EthereumPosMultiStream.kt

@@ -20,13 +20,7 @@ import io.emeraldpay.api.proto.BlockchainOuterClass
 import io.emeraldpay.dshackle.cache.Caches
 import io.emeraldpay.dshackle.config.UpstreamsConfig
 import io.emeraldpay.dshackle.reader.Reader
-import io.emeraldpay.dshackle.upstream.ChainFees
-import io.emeraldpay.dshackle.upstream.EmptyHead
-import io.emeraldpay.dshackle.upstream.Head
-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.*
 import io.emeraldpay.dshackle.upstream.forkchoice.PriorityForkChoice
 import io.emeraldpay.dshackle.upstream.grpc.GrpcUpstream
 import io.emeraldpay.dshackle.upstream.rpcclient.JsonRpcRequest
@@ -42,8 +36,9 @@ import reactor.core.publisher.Mono
 open class EthereumPosMultiStream(
     chain: Chain,
     val upstreams: MutableList<EthereumPosUpstream>,
-    caches: Caches
-) : Multistream(chain, upstreams as MutableList<Upstream>, caches, CacheRequested(caches)), EthereumLikeMultistream {
+    caches: Caches,
+    callTargetsHolder: CallTargetsHolder
+) : Multistream(chain, upstreams as MutableList<Upstream>, caches, CacheRequested(caches), callTargetsHolder), EthereumLikeMultistream {
 
     companion object {
         private val log = LoggerFactory.getLogger(EthereumPosMultiStream::class.java)

src/main/kotlin/io/emeraldpay/dshackle/upstream/grpc/GrpcUpstreams.kt

@@ -22,7 +22,7 @@ import io.emeraldpay.dshackle.Defaults
 import io.emeraldpay.dshackle.FileResolver
 import io.emeraldpay.dshackle.config.AuthConfig
 import io.emeraldpay.dshackle.config.UpstreamsConfig
-import io.emeraldpay.dshackle.startup.UpstreamChange
+import io.emeraldpay.dshackle.startup.UpstreamChangeEvent
 import io.emeraldpay.dshackle.upstream.DefaultUpstream
 import io.emeraldpay.dshackle.upstream.UpstreamAvailability
 import io.emeraldpay.dshackle.upstream.rpcclient.JsonRpcGrpcClient
@@ -69,7 +69,7 @@ class GrpcUpstreams(
     private val known = HashMap<Chain, DefaultUpstream>()
     private val lock = ReentrantLock()
 
-    fun start(): Flux<UpstreamChange> {
+    fun start(): Flux<UpstreamChangeEvent> {
         val channel: ManagedChannelBuilder<*> = if (auth != null && StringUtils.isNotEmpty(auth.ca)) {
             NettyChannelBuilder.forAddress(host, port)
                 // some messages are very large. many of them in megabytes, some even in gigabytes (ex. ETH Traces)
@@ -122,7 +122,7 @@ class GrpcUpstreams(
         return updates
     }
 
-    fun processDescription(value: BlockchainOuterClass.DescribeResponse): Flux<UpstreamChange> {
+    fun processDescription(value: BlockchainOuterClass.DescribeResponse): Flux<UpstreamChangeEvent> {
         val current = value.chainsList.filter {
             Chain.byId(it.chain.number) != Chain.UNSPECIFIED
         }.mapNotNull { chainDetails ->
@@ -138,14 +138,14 @@ class GrpcUpstreams(
         }
 
         val added = current.filter {
-            it.type == UpstreamChange.ChangeType.ADDED
+            it.type == UpstreamChangeEvent.ChangeType.ADDED
         }
 
         val removed = known.filterNot { kv ->
             val stillCurrent = current.any { c -> c.chain == kv.key }
             stillCurrent
         }.map {
-            UpstreamChange(it.key, known.remove(it.key)!!, UpstreamChange.ChangeType.REMOVED)
+            UpstreamChangeEvent(it.key, known.remove(it.key)!!, UpstreamChangeEvent.ChangeType.REMOVED)
         }
         return Flux.fromIterable(removed + added)
     }
@@ -172,7 +172,7 @@ class GrpcUpstreams(
         return sslContext.build()
     }
 
-    fun getOrCreate(chain: Chain): UpstreamChange {
+    fun getOrCreate(chain: Chain): UpstreamChangeEvent {
         val metricsTags = listOf(
             Tag.of("upstream", id),
             Tag.of("chain", chain.chainCode)
@@ -202,7 +202,7 @@ class GrpcUpstreams(
         }
     }
 
-    fun getOrCreateEthereum(chain: Chain, metrics: RpcMetrics): UpstreamChange {
+    fun getOrCreateEthereum(chain: Chain, metrics: RpcMetrics): UpstreamChangeEvent {
         lock.withLock {
             val current = known[chain]
             return if (current == null) {
@@ -211,14 +211,14 @@ class GrpcUpstreams(
                 created.timeout = this.timeout
                 known[chain] = created
                 created.start()
-                UpstreamChange(chain, created, UpstreamChange.ChangeType.ADDED)
+                UpstreamChangeEvent(chain, created, UpstreamChangeEvent.ChangeType.ADDED)
             } else {
-                UpstreamChange(chain, current, UpstreamChange.ChangeType.REVALIDATED)
+                UpstreamChangeEvent(chain, current, UpstreamChangeEvent.ChangeType.REVALIDATED)
             }
         }
     }
 
-    fun getOrCreateEthereumPos(chain: Chain, metrics: RpcMetrics): UpstreamChange {
+    fun getOrCreateEthereumPos(chain: Chain, metrics: RpcMetrics): UpstreamChangeEvent {
         lock.withLock {
             val current = known[chain]
             return if (current == null) {
@@ -227,14 +227,14 @@ class GrpcUpstreams(
                 created.timeout = this.timeout
                 known[chain] = created
                 created.start()
-                UpstreamChange(chain, created, UpstreamChange.ChangeType.ADDED)
+                UpstreamChangeEvent(chain, created, UpstreamChangeEvent.ChangeType.ADDED)
             } else {
-                UpstreamChange(chain, current, UpstreamChange.ChangeType.REVALIDATED)
+                UpstreamChangeEvent(chain, current, UpstreamChangeEvent.ChangeType.REVALIDATED)
             }
         }
     }
 
-    fun getOrCreateBitcoin(chain: Chain, metrics: RpcMetrics): UpstreamChange {
+    fun getOrCreateBitcoin(chain: Chain, metrics: RpcMetrics): UpstreamChangeEvent {
         lock.withLock {
             val current = known[chain]
             return if (current == null) {
@@ -243,9 +243,9 @@ class GrpcUpstreams(
                 created.timeout = this.timeout
                 known[chain] = created
                 created.start()
-                UpstreamChange(chain, created, UpstreamChange.ChangeType.ADDED)
+                UpstreamChangeEvent(chain, created, UpstreamChangeEvent.ChangeType.ADDED)
             } else {
-                UpstreamChange(chain, current, UpstreamChange.ChangeType.REVALIDATED)
+                UpstreamChangeEvent(chain, current, UpstreamChangeEvent.ChangeType.REVALIDATED)
             }
         }
     }