アカウントライブラリ(Accounts library)入門

buildscript {
ext {
accounts_release_group = 'com.r3.corda.lib.accounts'
accounts_release_version = '1.0'
confidential_id_release_group = "com.r3.corda.lib.ci"
confidential_id_release_version = "1.0"
}
}

dependencies {
cordapp "$confidential_id_release_group:ci-workflows:$confidential_id_release_version"
cordapp "$accounts_release_group:accounts-contracts:$accounts_release_version"
cordapp "$accounts_release_group:accounts-workflows:$accounts_release_version"
}

task deployNodes() {
nodeDefaults {
cordapp("$accounts_release_group:accounts-contracts:$accounts_release_version")
cordapp("$accounts_release_group:accounts-workflows:$accounts_release_version")
}
}

dependencies {
// in contracts build.gradle
cordaCompile "$accounts_release_group:accounts-contracts:$accounts_release_version"

// in workflows build.gradle
cordaCompile "$confidential_id_release_group:ci-workflows:$confidential_id_release_version"
cordaCompile "$accounts_release_group:accounts-workflows:$accounts_release_version"
}

// Create account by invoking flow via RPC.
val accountInfo: StateAndRef<AccountInfo> = rpcProxy.startFlow(::CreateAccount, "Roger's account").returnValue.getOrThrow()

// Create account by using sub flow (from inside a flow).
val accountInfo: StateAndRef<AccountInfo> = subFlow(CreateAccount("Roger's account"))

// The AccountService provides access to triggering Account related flows from within a Corda Service.
val accountInfo: StateAndRef<AccountInfo> = accountService.createAccount("Roger's account").getOrThrow()

fun accountInfo(id: UUID): StateAndRef<AccountInfo>?
fun accountInfo(name: String): List<StateAndRef<AccountInfo>>?

subFlow(AccountInfoByName(id: UUID)): StateAndRef<AccountInfo>?
subFlow(AccountInfoByUUID(name: String)): List<StateAndRef<AccountInfo>>?

// Requestor flow.
// Assumption is that we already have the AccountInfo.
val accountInfo: StateAndRef<AccountInfo> = accountService.accountInfo("Some account name")
val newKey: AnonymousParty = subFlow(RequestKeyForAccountFlow(accountInfo = accountInfo,
hostSession = initiateFlow(accountInfo.state.data.host)
))

// Responder flow.
subFlow(SendKeyForAccountFlow(otherSideSession))

// retrieve the public keys associated with the account ID
val accountKeys = accountService.accountKeys(accountInfo.identifier.id)
return if (accountKeys.isEmpty()) {
// generate a new key if no other keys are found
subFlow(RequestKeyForAccount(accountInfo))
} else {
// return an AnonymousParty reusing an old one
AnonymousParty(accountKeys.first())
}

// party is another Corda node <Party>
subFlow(ShareAccountInfo(account, party))

rpcProxy.vaultQueryByCriteria(
QueryCriteria.VaultQueryCriteria(externalIds = listOf(accountId)), StateClass::class.java
)

serviceHub.vaultService.queryBy(
QueryCriteria.VaultQueryCriteria(externalIds = listOf(accountId)),StateClass::class.java
)

// retrieve the public key of the account from its AccountInfo.
// This returns an AnonymousParty.
val account : AnonymousParty = subFlow(RequestKeyForAccount(accountInfo))

// initially sign the transaction using the public key of the account
val partiallySignedTx : SignedTransaction = serviceHub.signInitialTransaction(txBuilder,listOf(account.owningKey))

// retrieve the identity of the hosting node of the remote account
val remoteHost : Party? = serviceHub.identityService.partyFromKey(remote-account.owningKey)

// open the session with the hosting node
val session : FlowSession = initiateFlow(remoteHost)

// call the CollectSignatureFlow using this session
subFlow(CollectSignaturesFlow(partiallySignedTx, session))