ENT-14284 - Confidential Identity.

Author: mkitR3

Tokens/stockpaydividend/bridging-flows/build.gradle

@@ -49,6 +49,7 @@ dependencies {
 
     // CorDapp dependencies.
     cordapp project(":bridging-contracts")
+    cordapp project(":contracts")
 
     // Token SDK dependencies.
     cordaProvided "$tokens_release_group:tokens-contracts:$tokens_release_version"

Tokens/stockpaydividend/bridging-flows/src/main/kotlin/com/r3/corda/lib/tokens/bridging/flows/BridgingAuthorityBootstrapService.kt

@@ -0,0 +1,77 @@
+package com.r3.corda.lib.tokens.bridging.flows
+
+import com.r3.corda.lib.tokens.workflows.utilities.tokenAmountsByToken
+import net.corda.core.identity.PartyAndCertificate
+import net.corda.core.node.AppServiceHub
+import net.corda.core.node.services.CordaService
+import net.corda.core.serialization.SingletonSerializeAsToken
+import net.corda.samples.stockpaydividend.states.StockState
+import java.util.*
+
+@CordaService
+class BridgingAuthorityBootstrapService(appServiceHub: AppServiceHub) : SingletonSerializeAsToken() {
+    val holdingIdentityPartyAndCertificate: PartyAndCertificate
+    val bridgeAuthorityParty = appServiceHub.ourIdentity()
+
+    init {
+        val cfg = appServiceHub.getAppContext().config
+        val holdingIdentityLabel = UUID.fromString(cfg.getString("holdingIdentityLabel"))
+        val holdingIdentityPublicKey = appServiceHub
+            .identityService
+            .publicKeysForExternalId(holdingIdentityLabel)
+            .singleOrNull()
+        holdingIdentityPartyAndCertificate = if (holdingIdentityPublicKey == null) {
+            // Generate a new key pair and self-signed certificate for the holding identity
+            appServiceHub.keyManagementService.freshKeyAndCert(
+                identity = requireNotNull(appServiceHub.identityService.certificateFromKey(bridgeAuthorityParty.owningKey)) {
+                    "Could not find certificate for key ${bridgeAuthorityParty.owningKey}"
+                },
+                revocationEnabled = false,
+                externalId = holdingIdentityLabel
+            )
+        } else {
+            // Reuse the existing key pair and certificate for the holding identity
+            checkNotNull(appServiceHub.identityService.certificateFromKey(holdingIdentityPublicKey)) {
+                "Could not find certificate for key $holdingIdentityPublicKey"
+            }
+        }
+
+        onStartup(appServiceHub)
+    }
+
+    private fun onStartup(appServiceHub: AppServiceHub) {
+        //Retrieve states from receiver
+        val receivedStockStatesPages = appServiceHub.vaultService.queryBy(StockState::class.java).states
+        val receivedStockStates = receivedStockStatesPages.map { it.state.data }
+
+        callFlow(receivedStockStates, appServiceHub)
+        addVaultListener(appServiceHub)
+    }
+
+    private fun addVaultListener(appServiceHub: AppServiceHub) {
+        appServiceHub.vaultService.trackBy(StockState::class.java).updates.subscribe {
+            val producedStockStates = it.produced.map { it.state.data }
+            callFlow(producedStockStates, appServiceHub)
+        }
+    }
+
+    private fun callFlow(producedStockStates: Collection<StockState>, appServiceHub: AppServiceHub) {
+        producedStockStates.forEach { stockState ->
+            val tokens = appServiceHub.vaultService.tokenAmountsByToken(
+                stockState.toPointer(
+                    stockState.javaClass
+                )
+            ).states
+            appServiceHub.startFlow(
+                BridgeFungibleTokenFlow(
+                    holdingIdentityPartyAndCertificate.party,
+                    emptyList(),
+                    tokens.first(), //TODO handle multiple tokens
+                    bridgeAuthorityParty
+                )
+            )
+        }
+    }
+
+    private fun AppServiceHub.ourIdentity() = myInfo.legalIdentities.first()
+}

Tokens/stockpaydividend/workflows/src/test/kotlin/net/corda/samples/stockpaydividend/FlowTests.kt

@@ -126,7 +126,8 @@ class FlowTests {
         val baConfig = mapOf(
             "participants" to mapOf(COMPANY.name.toString() to tokenAccount.base58()),
             "mints" to mapOf(LINEAR_ID.toString() to tokenMint.base58()),
-            "mintAuthorities" to mapOf(LINEAR_ID.toString() to mintAuthority.account.base58())
+            "mintAuthorities" to mapOf(LINEAR_ID.toString() to mintAuthority.account.base58()),
+            "holdingIdentityLabel" to UUID.randomUUID().toString()
         )
         network = MockNetwork(
             MockNetworkParameters(