CORDA-696 - Create separate transaction types for contract upgrade transactions (#2589)

* CORDA-986 and CORDA-985 CompositeKey and Signature verification performance fixes (#2467)

* CORDA-696: Create separate transaction types for contract upgrade transactions.

Add rationale around upgrade transactions

Move contract upgrade transaction resolution logic into internal until it's stabilised.

Throw a better exception when contract attachment not found

Default legacy contract constraint to always accepting - needs to be changed to whitelist constraint before merging

Introduce a new upgraded contract interface that allows specifying the legacy constraint.

Remove StateLoader, make all tx resolution functions take in ServicesForResolution

Contract upgrade transactions can handle whitelist by zone constraints

When creating a contract upgrade transaction, make sure the attachment of the old cordapp gets attached when using hash constraints.
Attachment lookup for a given contract class name only scans currently loaded cordapps, and we don't load old versions of cordapps.

CORDA-696: Update upgrade docs

node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt

@@ -208,17 +208,24 @@ abstract class AbstractNode(val configuration: NodeConfiguration,
             val networkMapCache = NetworkMapCacheImpl(PersistentNetworkMapCache(database, networkParameters.notaries).start(), identityService)
             val (keyPairs, nodeInfo) = initNodeInfo(networkMapCache, identity, identityKeyPair)
             identityService.loadIdentities(nodeInfo.legalIdentitiesAndCerts)
+            val metrics = MetricRegistry()
             val transactionStorage = makeTransactionStorage(database, configuration.transactionCacheSizeBytes)
+            attachments = NodeAttachmentService(metrics, configuration.attachmentContentCacheSizeBytes, configuration.attachmentCacheBound)
+            val cordappProvider = CordappProviderImpl(cordappLoader, CordappConfigFileProvider(), attachments, networkParameters.whitelistedContractImplementations)
+            val servicesForResolution = ServicesForResolutionImpl(identityService, attachments, cordappProvider, networkParameters, transactionStorage)
             val nodeProperties = NodePropertiesPersistentStore(StubbedNodeUniqueIdProvider::value, database)
             val nodeServices = makeServices(
                     keyPairs,
                     schemaService,
                     transactionStorage,
+                    metrics,
+                    servicesForResolution,
                     database,
                     nodeInfo,
                     identityService,
                     networkMapCache,
                     nodeProperties,
+                    cordappProvider,
                     networkParameters)
             val notaryService = makeNotaryService(nodeServices, database)
             val smm = makeStateMachineManager(database)
@@ -228,7 +235,7 @@ abstract class AbstractNode(val configuration: NodeConfiguration,
                     platformClock,
                     database,
                     flowStarter,
-                    transactionStorage,
+                    servicesForResolution,
                     unfinishedSchedules = busyNodeLatch,
                     serverThread = serverThread,
                     flowLogicRefFactory = flowLogicRefFactory,
@@ -547,16 +554,17 @@ abstract class AbstractNode(val configuration: NodeConfiguration,
     private fun makeServices(keyPairs: Set<KeyPair>,
                              schemaService: SchemaService,
                              transactionStorage: WritableTransactionStorage,
+                             metrics: MetricRegistry,
+                             servicesForResolution: ServicesForResolution,
                              database: CordaPersistence,
                              nodeInfo: NodeInfo,
                              identityService: IdentityServiceInternal,
                              networkMapCache: NetworkMapCacheInternal,
                              nodeProperties: NodePropertiesStore,
+                             cordappProvider: CordappProviderInternal,
                              networkParameters: NetworkParameters): MutableList<Any> {
         checkpointStorage = DBCheckpointStorage()
-        val metrics = MetricRegistry()
-        attachments = NodeAttachmentService(metrics, configuration.attachmentContentCacheSizeBytes, configuration.attachmentCacheBound)
-        val cordappProvider = CordappProviderImpl(cordappLoader, CordappConfigFileProvider(), attachments, networkParameters.whitelistedContractImplementations)
+
         val keyManagementService = makeKeyManagementService(identityService, keyPairs)
         _services = ServiceHubInternalImpl(
                 identityService,
@@ -569,7 +577,8 @@ abstract class AbstractNode(val configuration: NodeConfiguration,
                 nodeInfo,
                 networkMapCache,
                 nodeProperties,
-                networkParameters)
+                networkParameters,
+                servicesForResolution)
         network = makeMessagingService(database, nodeInfo, nodeProperties, networkParameters)
         val tokenizableServices = mutableListOf(attachments, network, services.vaultService,
                 services.keyManagementService, services.identityService, platformClock,
@@ -760,8 +769,8 @@ abstract class AbstractNode(val configuration: NodeConfiguration,
     }
 
     protected open fun generateKeyPair() = cryptoGenerateKeyPair()
-    protected open fun makeVaultService(keyManagementService: KeyManagementService, stateLoader: StateLoader, hibernateConfig: HibernateConfiguration): VaultServiceInternal {
-        return NodeVaultService(platformClock, keyManagementService, stateLoader, hibernateConfig)
+    protected open fun makeVaultService(keyManagementService: KeyManagementService, services: ServicesForResolution, hibernateConfig: HibernateConfiguration): VaultServiceInternal {
+        return NodeVaultService(platformClock, keyManagementService, services, hibernateConfig)
     }
 
     /** Load configured JVM agents */
@@ -794,13 +803,14 @@ abstract class AbstractNode(val configuration: NodeConfiguration,
             override val myInfo: NodeInfo,
             override val networkMapCache: NetworkMapCacheInternal,
             override val nodeProperties: NodePropertiesStore,
-            override val networkParameters: NetworkParameters
-    ) : SingletonSerializeAsToken(), ServiceHubInternal, StateLoader by validatedTransactions {
+            override val networkParameters: NetworkParameters,
+            private val servicesForResolution: ServicesForResolution
+    ) : SingletonSerializeAsToken(), ServiceHubInternal, ServicesForResolution by servicesForResolution {
         override val rpcFlows = ArrayList<Class<out FlowLogic<*>>>()
         override val stateMachineRecordedTransactionMapping = DBTransactionMappingStorage()
         override val auditService = DummyAuditService()
         override val transactionVerifierService by lazy { makeTransactionVerifierService() }
-        override val vaultService by lazy { makeVaultService(keyManagementService, validatedTransactions, database.hibernateConfig) }
+        override val vaultService by lazy { makeVaultService(keyManagementService, servicesForResolution, database.hibernateConfig) }
         override val contractUpgradeService by lazy { ContractUpgradeServiceImpl() }
         override val attachments: AttachmentStorage get() = this@AbstractNode.attachments
         override val networkService: MessagingService get() = network

node/src/main/kotlin/net/corda/node/internal/ServiesForResolutionImpl.kt

@@ -0,0 +1,32 @@
+package net.corda.node.internal
+
+import net.corda.core.contracts.*
+import net.corda.core.cordapp.CordappProvider
+import net.corda.core.node.NetworkParameters
+import net.corda.core.node.ServicesForResolution
+import net.corda.core.node.services.AttachmentStorage
+import net.corda.core.node.services.IdentityService
+import net.corda.core.node.services.TransactionStorage
+
+data class ServicesForResolutionImpl(
+        override val identityService: IdentityService,
+        override val attachments: AttachmentStorage,
+        override val cordappProvider: CordappProvider,
+        override val networkParameters: NetworkParameters,
+        private val validatedTransactions: TransactionStorage
+) : ServicesForResolution {
+    @Throws(TransactionResolutionException::class)
+    override fun loadState(stateRef: StateRef): TransactionState<*> {
+        val stx = validatedTransactions.getTransaction(stateRef.txhash) ?: throw TransactionResolutionException(stateRef.txhash)
+        return stx.resolveBaseTransaction(this).outputs[stateRef.index]
+    }
+
+    @Throws(TransactionResolutionException::class)
+    override fun loadStates(stateRefs: Set<StateRef>): Set<StateAndRef<ContractState>> {
+        return stateRefs.groupBy { it.txhash }.map {
+            val stx = validatedTransactions.getTransaction(it.key) ?: throw TransactionResolutionException(it.key)
+            val baseTx = stx.resolveBaseTransaction(this)
+            it.value.map { StateAndRef(baseTx.outputs[it.index], it) }
+        }.flatMap { it }.toSet()
+    }
+}

node/src/main/kotlin/net/corda/node/internal/cordapp/CordappLoader.kt

@@ -4,6 +4,7 @@ import io.github.lukehutch.fastclasspathscanner.FastClasspathScanner
 import io.github.lukehutch.fastclasspathscanner.scanner.ScanResult
 import net.corda.core.contracts.Contract
 import net.corda.core.contracts.UpgradedContract
+import net.corda.core.contracts.UpgradedContractWithLegacyConstraint
 import net.corda.core.cordapp.Cordapp
 import net.corda.core.flows.*
 import net.corda.core.internal.*
@@ -241,7 +242,13 @@ class CordappLoader private constructor(private val cordappJarPaths: List<Restri
     }
 
     private fun findContractClassNames(scanResult: RestrictedScanResult): List<String> {
-        return (scanResult.getNamesOfClassesImplementing(Contract::class) + scanResult.getNamesOfClassesImplementing(UpgradedContract::class)).distinct()
+        return (scanResult.getNamesOfClassesImplementing(Contract::class) +
+                scanResult.getNamesOfClassesImplementing(UpgradedContract::class) +
+                // Even though UpgradedContractWithLegacyConstraint implements UpgradedContract
+                // we need to specify it separately. Otherwise, classes implementing UpgradedContractWithLegacyConstraint
+                // don't get picked up.
+                scanResult.getNamesOfClassesImplementing(UpgradedContractWithLegacyConstraint::class))
+                .distinct()
     }
 
     private fun findPlugins(cordappJarPath: RestrictedURL): List<SerializationWhitelist> {

node/src/main/kotlin/net/corda/node/services/CoreFlowHandlers.kt

@@ -7,6 +7,7 @@ import net.corda.core.contracts.requireThat
 import net.corda.core.flows.*
 import net.corda.core.identity.Party
 import net.corda.core.internal.ContractUpgradeUtils
+import net.corda.core.transactions.ContractUpgradeWireTransaction
 import net.corda.core.node.StatesToRecord
 import net.corda.core.transactions.SignedTransaction
 
@@ -56,13 +57,13 @@ class ContractUpgradeHandler(otherSide: FlowSession) : AbstractStateReplacementF
         val oldStateAndRef = ourSTX!!.tx.outRef<ContractState>(proposal.stateRef.index)
         val authorisedUpgrade = serviceHub.contractUpgradeService.getAuthorisedContractUpgrade(oldStateAndRef.ref) ?:
                 throw IllegalStateException("Contract state upgrade is unauthorised. State hash : ${oldStateAndRef.ref}")
-        val proposedTx = stx.tx
-        val expectedTx = ContractUpgradeUtils.assembleBareTx(oldStateAndRef, proposal.modification, proposedTx.privacySalt).toWireTransaction(serviceHub)
+        val proposedTx = stx.coreTransaction as ContractUpgradeWireTransaction
+        val expectedTx = ContractUpgradeUtils.assembleUpgradeTx(oldStateAndRef, proposal.modification, proposedTx.privacySalt, serviceHub)
         requireThat {
             "The instigator is one of the participants" using (initiatingSession.counterparty in oldStateAndRef.state.data.participants)
             "The proposed upgrade ${proposal.modification.javaClass} is a trusted upgrade path" using (proposal.modification.name == authorisedUpgrade)
             "The proposed tx matches the expected tx for this upgrade" using (proposedTx == expectedTx)
         }
-        proposedTx.toLedgerTransaction(serviceHub).verify()
+        proposedTx.resolve(serviceHub, stx.sigs)
     }
 }

node/src/main/kotlin/net/corda/node/services/api/ServiceHubInternal.kt

@@ -81,7 +81,6 @@ interface ServiceHubInternal : ServiceHub {
         }
 
         if (statesToRecord != StatesToRecord.NONE) {
-            val toNotify = recordedTransactions.map { if (it.isNotaryChangeTransaction()) it.notaryChangeTx else it.tx }
             // When the user has requested StatesToRecord.ALL we may end up recording and relationally mapping states
             // that do not involve us and that we cannot sign for. This will break coin selection and thus a warning
             // is present in the documentation for this feature (see the "Observer nodes" tutorial on docs.corda.net).
@@ -116,7 +115,7 @@ interface ServiceHubInternal : ServiceHub {
             //
             // Because the primary use case for recording irrelevant states is observer/regulator nodes, who are unlikely
             // to make writes to the ledger very often or at all, we choose to punt this issue for the time being.
-            vaultService.notifyAll(statesToRecord, toNotify)
+            vaultService.notifyAll(statesToRecord, txs.map { it.coreTransaction })
         }
     }
 

node/src/main/kotlin/net/corda/node/services/events/NodeSchedulerService.kt

@@ -16,7 +16,7 @@ import net.corda.core.internal.VisibleForTesting
 import net.corda.core.internal.concurrent.flatMap
 import net.corda.core.internal.join
 import net.corda.core.internal.until
-import net.corda.core.node.StateLoader
+import net.corda.core.node.ServicesForResolution
 import net.corda.core.schemas.PersistentStateRef
 import net.corda.core.serialization.SingletonSerializeAsToken
 import net.corda.core.utilities.contextLogger
@@ -58,7 +58,7 @@ import com.google.common.util.concurrent.SettableFuture as GuavaSettableFuture
 class NodeSchedulerService(private val clock: CordaClock,
                            private val database: CordaPersistence,
                            private val flowStarter: FlowStarter,
-                           private val stateLoader: StateLoader,
+                           private val servicesForResolution: ServicesForResolution,
                            private val unfinishedSchedules: ReusableLatch = ReusableLatch(),
                            private val serverThread: Executor,
                            private val flowLogicRefFactory: FlowLogicRefFactory,
@@ -311,7 +311,7 @@ class NodeSchedulerService(private val clock: CordaClock,
     }
 
     private fun getScheduledActivity(scheduledState: ScheduledStateRef): ScheduledActivity? {
-        val txState = stateLoader.loadState(scheduledState.ref)
+        val txState = servicesForResolution.loadState(scheduledState.ref)
         val state = txState.data as SchedulableState
         return try {
             // This can throw as running contract code.

node/src/main/kotlin/net/corda/node/services/transactions/NonValidatingNotaryFlow.kt

@@ -10,6 +10,7 @@ import net.corda.core.flows.NotarisationRequest
 import net.corda.core.internal.validateRequest
 import net.corda.core.node.services.TrustedAuthorityNotaryService
 import net.corda.core.transactions.CoreTransaction
+import net.corda.core.transactions.ContractUpgradeFilteredTransaction
 import net.corda.core.transactions.FilteredTransaction
 import net.corda.core.transactions.NotaryChangeWireTransaction
 import net.corda.core.utilities.unwrap
@@ -44,6 +45,7 @@ class NonValidatingNotaryFlow(otherSideSession: FlowSession, service: TrustedAut
                 val notary = tx.notary
                 TransactionParts(tx.id, tx.inputs, tx.timeWindow, notary)
             }
+            is ContractUpgradeFilteredTransaction -> TransactionParts(tx.id, tx.inputs, null, tx.notary)
             is NotaryChangeWireTransaction -> TransactionParts(tx.id, tx.inputs, null, tx.notary)
             else -> {
                 throw IllegalArgumentException("Received unexpected transaction type: ${tx::class.java.simpleName}," +

node/src/main/kotlin/net/corda/node/services/transactions/ValidatingNotaryFlow.kt

@@ -4,13 +4,12 @@ import co.paralleluniverse.fibers.Suspendable
 import net.corda.core.contracts.TimeWindow
 import net.corda.core.contracts.TransactionVerificationException
 import net.corda.core.flows.*
-import net.corda.core.flows.NotarisationPayload
-import net.corda.core.flows.NotarisationRequest
 import net.corda.core.internal.ResolveTransactionsFlow
 import net.corda.core.internal.validateRequest
 import net.corda.core.node.services.TrustedAuthorityNotaryService
 import net.corda.core.transactions.SignedTransaction
 import net.corda.core.transactions.TransactionWithSignatures
+import net.corda.core.transactions.WireTransaction
 import net.corda.core.utilities.unwrap
 import java.security.SignatureException
 
@@ -31,12 +30,9 @@ class ValidatingNotaryFlow(otherSideSession: FlowSession, service: TrustedAuthor
             val stx = receiveTransaction()
             val notary = stx.notary
             checkNotary(notary)
-            val timeWindow: TimeWindow? = if (stx.isNotaryChangeTransaction())
-                null
-            else
-                stx.tx.timeWindow
             resolveAndContractVerify(stx)
             verifySignatures(stx)
+            val timeWindow: TimeWindow? = if (stx.coreTransaction is WireTransaction) stx.tx.timeWindow else null
             return TransactionParts(stx.id, stx.inputs, timeWindow, notary!!)
         } catch (e: Exception) {
             throw when (e) {

node/src/main/kotlin/net/corda/node/services/vault/NodeVaultService.kt

@@ -6,15 +6,13 @@ import net.corda.core.contracts.*
 import net.corda.core.crypto.SecureHash
 import net.corda.core.internal.*
 import net.corda.core.messaging.DataFeed
-import net.corda.core.node.StateLoader
+import net.corda.core.node.ServicesForResolution
 import net.corda.core.node.StatesToRecord
 import net.corda.core.node.services.*
 import net.corda.core.node.services.vault.*
 import net.corda.core.schemas.PersistentStateRef
 import net.corda.core.serialization.SingletonSerializeAsToken
-import net.corda.core.transactions.CoreTransaction
-import net.corda.core.transactions.NotaryChangeWireTransaction
-import net.corda.core.transactions.WireTransaction
+import net.corda.core.transactions.*
 import net.corda.core.utilities.*
 import net.corda.node.services.api.VaultServiceInternal
 import net.corda.node.services.statemachine.FlowStateMachineImpl
@@ -49,7 +47,7 @@ private fun CriteriaBuilder.executeUpdate(session: Session, configure: Root<*>.(
 class NodeVaultService(
         private val clock: Clock,
         private val keyManagementService: KeyManagementService,
-        private val stateLoader: StateLoader,
+        private val servicesForResolution: ServicesForResolution,
         hibernateConfig: HibernateConfiguration
 ) : SingletonSerializeAsToken(), VaultServiceInternal {
     private companion object {
@@ -108,41 +106,29 @@ class NodeVaultService(
     override val updates: Observable<Vault.Update<ContractState>>
         get() = mutex.locked { _updatesInDbTx }
 
+    /** Groups adjacent transactions into batches to generate separate net updates per transaction type. */
     override fun notifyAll(statesToRecord: StatesToRecord, txns: Iterable<CoreTransaction>) {
-        if (statesToRecord == StatesToRecord.NONE)
-            return
+        if (statesToRecord == StatesToRecord.NONE || !txns.any()) return
+        val batch = mutableListOf<CoreTransaction>()
 
-        // It'd be easier to just group by type, but then we'd lose ordering.
-        val regularTxns = mutableListOf<WireTransaction>()
-        val notaryChangeTxns = mutableListOf<NotaryChangeWireTransaction>()
-
-        for (tx in txns) {
-            when (tx) {
-                is WireTransaction -> {
-                    regularTxns.add(tx)
-                    if (notaryChangeTxns.isNotEmpty()) {
-                        notifyNotaryChange(notaryChangeTxns.toList(), statesToRecord)
-                        notaryChangeTxns.clear()
-                    }
-                }
-                is NotaryChangeWireTransaction -> {
-                    notaryChangeTxns.add(tx)
-                    if (regularTxns.isNotEmpty()) {
-                        notifyRegular(regularTxns.toList(), statesToRecord)
-                        regularTxns.clear()
-                    }
-                }
-            }
+        fun flushBatch() {
+            val updates = makeUpdates(batch, statesToRecord)
+            processAndNotify(updates)
+            batch.clear()
         }
 
-        if (regularTxns.isNotEmpty()) notifyRegular(regularTxns.toList(), statesToRecord)
-        if (notaryChangeTxns.isNotEmpty()) notifyNotaryChange(notaryChangeTxns.toList(), statesToRecord)
+        for (tx in txns) {
+            if (batch.isNotEmpty() && tx.javaClass != batch.last().javaClass) {
+                flushBatch()
+            }
+            batch.add(tx)
+        }
+        flushBatch()
     }
 
-    private fun notifyRegular(txns: Iterable<WireTransaction>, statesToRecord: StatesToRecord) {
-        fun makeUpdate(tx: WireTransaction): Vault.Update<ContractState> {
+    private fun makeUpdates(batch: Iterable<CoreTransaction>, statesToRecord: StatesToRecord): List<Vault.Update<ContractState>> {
+        fun makeUpdate(tx: WireTransaction): Vault.Update<ContractState>? {
             val myKeys = keyManagementService.filterMyKeys(tx.outputs.flatMap { it.data.participants.map { it.owningKey } })
-
             val ourNewStates = when (statesToRecord) {
                 StatesToRecord.NONE -> throw AssertionError("Should not reach here")
                 StatesToRecord.ONLY_RELEVANT -> tx.outputs.filter { isRelevant(it.data, myKeys.toSet()) }
@@ -155,45 +141,48 @@ class NodeVaultService(
             // Is transaction irrelevant?
             if (consumedStates.isEmpty() && ourNewStates.isEmpty()) {
                 log.trace { "tx ${tx.id} was irrelevant to this vault, ignoring" }
-                return Vault.NoUpdate
+                return null
             }
 
             return Vault.Update(consumedStates.toSet(), ourNewStates.toSet())
         }
 
-        val netDelta = txns.fold(Vault.NoUpdate) { netDelta, txn -> netDelta + makeUpdate(txn) }
-        processAndNotify(netDelta)
-    }
-
-    private fun notifyNotaryChange(txns: Iterable<NotaryChangeWireTransaction>, statesToRecord: StatesToRecord) {
-        fun makeUpdate(tx: NotaryChangeWireTransaction): Vault.Update<ContractState> {
+        fun resolveAndMakeUpdate(tx: CoreTransaction): Vault.Update<ContractState>? {
             // We need to resolve the full transaction here because outputs are calculated from inputs
-            // We also can't do filtering beforehand, since output encumbrance pointers get recalculated based on
-            // input positions
-            val ltx = tx.resolve(stateLoader, emptyList())
+            // We also can't do filtering beforehand, since for notary change transactions output encumbrance pointers
+            // get recalculated based on input positions.
+            val ltx: FullTransaction = when (tx) {
+                is NotaryChangeWireTransaction -> tx.resolve(servicesForResolution, emptyList())
+                is ContractUpgradeWireTransaction -> tx.resolve(servicesForResolution, emptyList())
+                else -> throw IllegalArgumentException("Unsupported transaction type: ${tx.javaClass.name}")
+            }
             val myKeys = keyManagementService.filterMyKeys(ltx.outputs.flatMap { it.data.participants.map { it.owningKey } })
             val (consumedStateAndRefs, producedStates) = ltx.inputs.
                     zip(ltx.outputs).
                     filter { (_, output) ->
-                        if (statesToRecord == StatesToRecord.ONLY_RELEVANT)
-                            isRelevant(output.data, myKeys.toSet())
-                        else
-                            true
+                        if (statesToRecord == StatesToRecord.ONLY_RELEVANT) isRelevant(output.data, myKeys.toSet())
+                        else true
                     }.
                     unzip()
 
             val producedStateAndRefs = producedStates.map { ltx.outRef<ContractState>(it.data) }
-
             if (consumedStateAndRefs.isEmpty() && producedStateAndRefs.isEmpty()) {
                 log.trace { "tx ${tx.id} was irrelevant to this vault, ignoring" }
-                return Vault.NoNotaryUpdate
+                return null
             }
 
-            return Vault.Update(consumedStateAndRefs.toHashSet(), producedStateAndRefs.toHashSet(), null, Vault.UpdateType.NOTARY_CHANGE)
+            val updateType = if (tx is ContractUpgradeWireTransaction) {
+                Vault.UpdateType.CONTRACT_UPGRADE
+            } else {
+                Vault.UpdateType.NOTARY_CHANGE
+            }
+            return Vault.Update(consumedStateAndRefs.toSet(), producedStateAndRefs.toSet(), null, updateType)
         }
 
-        val netDelta = txns.fold(Vault.NoNotaryUpdate) { netDelta, txn -> netDelta + makeUpdate(txn) }
-        processAndNotify(netDelta)
+
+        return batch.mapNotNull {
+            if (it is WireTransaction) makeUpdate(it) else resolveAndMakeUpdate(it)
+        }
     }
 
     private fun loadStates(refs: Collection<StateRef>): Collection<StateAndRef<ContractState>> {
@@ -202,13 +191,15 @@ class NodeVaultService(
         else emptySet()
     }
 
-    private fun processAndNotify(update: Vault.Update<ContractState>) {
-        if (!update.isEmpty()) {
-            recordUpdate(update)
+    private fun processAndNotify(updates: List<Vault.Update<ContractState>>) {
+        if (updates.isEmpty()) return
+        val netUpdate = updates.reduce { update1, update2 -> update1 + update2 }
+        if (!netUpdate.isEmpty()) {
+            recordUpdate(netUpdate)
             mutex.locked {
                 // flowId required by SoftLockManager to perform auto-registration of soft locks for new states
                 val uuid = (Strand.currentStrand() as? FlowStateMachineImpl<*>)?.id?.uuid
-                val vaultUpdate = if (uuid != null) update.copy(flowId = uuid) else update
+                val vaultUpdate = if (uuid != null) netUpdate.copy(flowId = uuid) else netUpdate
                 updatesPublisher.onNext(vaultUpdate)
             }
         }
@@ -457,7 +448,7 @@ class NodeVaultService(
                         }
                     }
             if (stateRefs.isNotEmpty())
-                statesAndRefs.addAll(stateLoader.loadStates(stateRefs) as Collection<StateAndRef<T>>)
+                statesAndRefs.addAll(servicesForResolution.loadStates(stateRefs) as Collection<StateAndRef<T>>)
 
             return Vault.Page(states = statesAndRefs, statesMetadata = statesMeta, stateTypes = criteriaParser.stateTypes, totalStatesAvailable = totalStates, otherResults = otherResults)
         } catch (e: java.lang.Exception) {

node/src/test/kotlin/net/corda/node/services/events/NodeSchedulerServiceTest.kt

@@ -9,7 +9,7 @@ import net.corda.core.flows.FlowLogicRefFactory
 import net.corda.core.internal.FlowStateMachine
 import net.corda.core.internal.concurrent.openFuture
 import net.corda.core.internal.uncheckedCast
-import net.corda.core.node.StateLoader
+import net.corda.core.node.ServicesForResolution
 import net.corda.core.utilities.days
 import net.corda.node.services.api.FlowStarter
 import net.corda.node.services.api.NodePropertiesStore
@@ -48,7 +48,7 @@ class NodeSchedulerServiceTest {
         doReturn(flowsDraingMode).whenever(it).flowsDrainingMode
     }
     private val transactionStates = mutableMapOf<StateRef, TransactionState<*>>()
-    private val stateLoader = rigorousMock<StateLoader>().also {
+    private val servicesForResolution = rigorousMock<ServicesForResolution>().also {
         doLookup(transactionStates).whenever(it).loadState(any())
     }
     private val flows = mutableMapOf<FlowLogicRef, FlowLogic<*>>()
@@ -63,7 +63,7 @@ class NodeSchedulerServiceTest {
             testClock,
             database,
             flowStarter,
-            stateLoader,
+            servicesForResolution,
             serverThread = MoreExecutors.directExecutor(),
             flowLogicRefFactory = flowLogicRefFactory,
             nodeProperties = nodeProperties,

node/src/test/kotlin/net/corda/node/services/persistence/HibernateConfigurationTest.kt

@@ -118,7 +118,7 @@ class HibernateConfigurationTest {
             services = object : MockServices(cordappPackages, BOB_NAME, rigorousMock<IdentityServiceInternal>().also {
                 doNothing().whenever(it).justVerifyAndRegisterIdentity(argThat { name == BOB_NAME })
             }, generateKeyPair(), dummyNotary.keyPair) {
-                override val vaultService = NodeVaultService(Clock.systemUTC(), keyManagementService, validatedTransactions, hibernateConfig)
+                override val vaultService = NodeVaultService(Clock.systemUTC(), keyManagementService, servicesForResolution, hibernateConfig)
                 override fun recordTransactions(statesToRecord: StatesToRecord, txs: Iterable<SignedTransaction>) {
                     for (stx in txs) {
                         validatedTransactions.addTransaction(stx)

node/src/test/kotlin/net/corda/node/services/vault/VaultSoftLockManagerTest.kt

@@ -11,7 +11,7 @@ import net.corda.core.identity.AbstractParty
 import net.corda.core.internal.FlowStateMachine
 import net.corda.core.internal.packageName
 import net.corda.core.internal.uncheckedCast
-import net.corda.core.node.StateLoader
+import net.corda.core.node.ServicesForResolution
 import net.corda.core.node.services.KeyManagementService
 import net.corda.core.node.services.queryBy
 import net.corda.core.node.services.vault.QueryCriteria.SoftLockingCondition
@@ -83,8 +83,8 @@ class VaultSoftLockManagerTest {
     }
     private val mockNet = InternalMockNetwork(cordappPackages = listOf(ContractImpl::class.packageName), defaultFactory = { args ->
         object : InternalMockNetwork.MockNode(args) {
-            override fun makeVaultService(keyManagementService: KeyManagementService, stateLoader: StateLoader, hibernateConfig: HibernateConfiguration): VaultServiceInternal {
-                val realVault = super.makeVaultService(keyManagementService, stateLoader, hibernateConfig)
+            override fun makeVaultService(keyManagementService: KeyManagementService, services: ServicesForResolution, hibernateConfig: HibernateConfiguration): VaultServiceInternal {
+                val realVault = super.makeVaultService(keyManagementService, services, hibernateConfig)
                 return object : VaultServiceInternal by realVault {
                     override fun softLockRelease(lockId: UUID, stateRefs: NonEmptySet<StateRef>?) {
                         mockVault.softLockRelease(lockId, stateRefs) // No need to also call the real one for these tests.