ExternalVendorCode/corda
1
0
Fork 0
mirror of https://github.com/corda/corda.git synced 2025-04-06 10:57:18 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

Minor: auto-format of module: finance

Browse Source
This commit is contained in:
Mike Hearn 2017-04-11 12:39:27 +02:00
parent 6f200562b3
commit 3a7bcee15b
14 changed files with 67 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
finance/isolated/src/main/kotlin/net/corda/core/node/DummyContractBackdoor.kt
View File

@ -2,8 +2,8 @@ package net.corda.core.node
import net.corda.core.contracts.ContractState
import net.corda.core.contracts.PartyAndReference
import net.corda.core.transactions.TransactionBuilder
import net.corda.core.crypto.Party
import net.corda.core.transactions.TransactionBuilder
interface DummyContractBackdoor {
fun generateInitial(owner: PartyAndReference, magicNumber: Int, notary: Party): TransactionBuilder

47
finance/src/main/java/net/corda/contracts/JavaCommercialPaper.java
View File

@ -1,34 +1,23 @@
package net.corda.contracts;
import com.google.common.collect.ImmutableList;
import kotlin.Pair;
import kotlin.Unit;
import net.corda.contracts.asset.CashKt;
import com.google.common.collect.*;
import kotlin.*;
import net.corda.contracts.asset.*;
import net.corda.core.contracts.*;
import net.corda.core.contracts.TransactionForContract.InOutGroup;
import net.corda.core.contracts.clauses.AnyOf;
import net.corda.core.contracts.clauses.Clause;
import net.corda.core.contracts.clauses.ClauseVerifier;
import net.corda.core.contracts.clauses.GroupClauseVerifier;
import net.corda.core.crypto.CompositeKey;
import net.corda.core.crypto.CryptoUtilities;
import net.corda.core.crypto.Party;
import net.corda.core.crypto.SecureHash;
import net.corda.core.node.services.VaultService;
import net.corda.core.transactions.TransactionBuilder;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import net.corda.core.contracts.Contract;
import net.corda.core.contracts.TransactionForContract.*;
import net.corda.core.contracts.clauses.*;
import net.corda.core.crypto.*;
import net.corda.core.node.services.*;
import net.corda.core.transactions.*;
import org.jetbrains.annotations.*;
import java.time.Instant;
import java.util.Collections;
import java.util.Currency;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import java.time.*;
import java.util.*;
import java.util.stream.*;
import static kotlin.collections.CollectionsKt.single;
import static net.corda.core.contracts.ContractsDSL.requireSingleCommand;
import static net.corda.core.contracts.ContractsDSL.requireThat;
import static kotlin.collections.CollectionsKt.*;
import static net.corda.core.contracts.ContractsDSL.*;
/**
@ -144,9 +133,9 @@ public class JavaCommercialPaper implements Contract {
@SuppressWarnings("unchecked")
Group() {
super(new AnyOf<>(
new Clauses.Redeem(),
new Clauses.Move(),
new Clauses.Issue()
new Clauses.Redeem(),
new Clauses.Move(),
new Clauses.Issue()
));
}

6
finance/src/main/kotlin/net/corda/contracts/CommercialPaper.kt
View File

@ -104,9 +104,9 @@ class CommercialPaper : Contract {
interface Clauses {
class Group : GroupClauseVerifier<State, Commands, Issued<Terms>>(
AnyOf(
Redeem(),
Move(),
Issue())) {
Redeem(),
Move(),
Issue())) {
override fun groupStates(tx: TransactionForContract): List<TransactionForContract.InOutGroup<State, Issued<Terms>>>
= tx.groupStates<State, Issued<Terms>> { it.token }
}

2
finance/src/main/kotlin/net/corda/contracts/CommercialPaperLegacy.kt
View File

@ -106,7 +106,7 @@ class CommercialPaperLegacy : Contract {
}
}
// TODO: Think about how to evolve contracts over time with new commands.
// TODO: Think about how to evolve contracts over time with new commands.
else -> throw IllegalArgumentException("Unrecognised command")
}
}

48
finance/src/main/kotlin/net/corda/contracts/asset/Obligation.kt
View File

@ -29,7 +29,7 @@ val OBLIGATION_PROGRAM_ID = Obligation<Currency>()
*
* @param P the product the obligation is for payment of.
*/
class Obligation<P: Any> : Contract {
class Obligation<P : Any> : Contract {
/**
* TODO:
@ -47,7 +47,7 @@ class Obligation<P: Any> : Contract {
/**
* Parent clause for clauses that operate on grouped states (those which are fungible).
*/
class Group<P: Any> : GroupClauseVerifier<State<P>, Commands, Issued<Terms<P>>>(
class Group<P : Any> : GroupClauseVerifier<State<P>, Commands, Issued<Terms<P>>>(
AllOf(
NoZeroSizedOutputs<State<P>, Commands, Terms<P>>(),
FirstOf(
@ -70,19 +70,19 @@ class Obligation<P: Any> : Contract {
/**
* Generic issuance clause
*/
class Issue<P: Any> : AbstractIssue<State<P>, Commands, Terms<P>>({ -> sumObligations() }, { token: Issued<Terms<P>> -> sumObligationsOrZero(token) }) {
class Issue<P : Any> : AbstractIssue<State<P>, Commands, Terms<P>>({ -> sumObligations() }, { token: Issued<Terms<P>> -> sumObligationsOrZero(token) }) {
override val requiredCommands: Set<Class<out CommandData>> = setOf(Commands.Issue::class.java)
}
/**
* Generic move/exit clause for fungible assets
*/
class ConserveAmount<P: Any> : AbstractConserveAmount<State<P>, Commands, Terms<P>>()
class ConserveAmount<P : Any> : AbstractConserveAmount<State<P>, Commands, Terms<P>>()
/**
* Clause for supporting netting of obligations.
*/
class Net<C : CommandData, P: Any> : NetClause<C, P>() {
class Net<C : CommandData, P : Any> : NetClause<C, P>() {
val lifecycleClause = Clauses.VerifyLifecycle<ContractState, C, Unit, P>()
override fun toString(): String = "Net obligations"
@ -95,7 +95,7 @@ class Obligation<P: Any> : Contract {
/**
* Obligation-specific clause for changing the lifecycle of one or more states.
*/
class SetLifecycle<P: Any> : Clause<State<P>, Commands, Issued<Terms<P>>>() {
class SetLifecycle<P : Any> : Clause<State<P>, Commands, Issued<Terms<P>>>() {
override val requiredCommands: Set<Class<out CommandData>> = setOf(Commands.SetLifecycle::class.java)
override fun verify(tx: TransactionForContract,
@ -115,7 +115,7 @@ class Obligation<P: Any> : Contract {
* Obligation-specific clause for settling an outstanding obligation by witnessing
* change of ownership of other states to fulfil
*/
class Settle<P: Any> : Clause<State<P>, Commands, Issued<Terms<P>>>() {
class Settle<P : Any> : Clause<State<P>, Commands, Issued<Terms<P>>>() {
override val requiredCommands: Set<Class<out CommandData>> = setOf(Commands.Settle::class.java)
override fun verify(tx: TransactionForContract,
inputs: List<State<P>>,
@ -204,7 +204,7 @@ class Obligation<P: Any> : Contract {
* any lifecycle change clause, which is the only clause that involve
* non-standard lifecycle states on input/output.
*/
class VerifyLifecycle<S : ContractState, C : CommandData, T : Any, P: Any> : Clause<S, C, T>() {
class VerifyLifecycle<S : ContractState, C : CommandData, T : Any, P : Any> : Clause<S, C, T>() {
override fun verify(tx: TransactionForContract,
inputs: List<S>,
outputs: List<S>,
@ -245,7 +245,7 @@ class Obligation<P: Any> : Contract {
* @param P the product the obligation is for payment of.
*/
@CordaSerializable
data class Terms<P: Any>(
data class Terms<P : Any>(
/** The hash of the asset contract we're willing to accept in payment for this debt. */
val acceptableContracts: NonEmptySet<SecureHash>,
/** The parties whose assets we are willing to accept in payment for this debt. */
@ -266,7 +266,7 @@ class Obligation<P: Any> : Contract {
*
* @param P the product the obligation is for payment of.
*/
data class State<P: Any>(
data class State<P : Any>(
var lifecycle: Lifecycle = Lifecycle.NORMAL,
/** Where the debt originates from (obligor) */
val obligor: AnonymousParty,
@ -354,7 +354,7 @@ class Obligation<P: Any> : Contract {
* state object to the beneficiary. If this reduces the balance to zero, the state object is destroyed.
* @see [MoveCommand].
*/
data class Settle<P: Any>(val amount: Amount<Issued<Terms<P>>>) : Commands
data class Settle<P : Any>(val amount: Amount<Issued<Terms<P>>>) : Commands
/**
* A command stating that the beneficiary is moving the contract into the defaulted state as it has not been settled
@ -372,7 +372,7 @@ class Obligation<P: Any> : Contract {
* A command stating that the debt is being released by the beneficiary. Normally would indicate
* either settlement outside of the ledger, or that the obligor is unable to pay.
*/
data class Exit<P: Any>(override val amount: Amount<Issued<Terms<P>>>) : Commands, FungibleAsset.Commands.Exit<Terms<P>>
data class Exit<P : Any>(override val amount: Amount<Issued<Terms<P>>>) : Commands, FungibleAsset.Commands.Exit<Terms<P>>
}
override fun verify(tx: TransactionForContract) = verifyClause<Commands>(tx, FirstOf<ContractState, Commands, Unit>(
@ -629,7 +629,7 @@ class Obligation<P: Any> : Contract {
*
* @return a map of obligor/beneficiary pairs to the balance due.
*/
fun <P: Any> extractAmountsDue(product: Obligation.Terms<P>, states: Iterable<Obligation.State<P>>): Map<Pair<CompositeKey, CompositeKey>, Amount<Obligation.Terms<P>>> {
fun <P : Any> extractAmountsDue(product: Obligation.Terms<P>, states: Iterable<Obligation.State<P>>): Map<Pair<CompositeKey, CompositeKey>, Amount<Obligation.Terms<P>>> {
val balances = HashMap<Pair<CompositeKey, CompositeKey>, Amount<Obligation.Terms<P>>>()
states.forEach { state ->
@ -644,7 +644,7 @@ fun <P: Any> extractAmountsDue(product: Obligation.Terms<P>, states: Iterable<Ob
/**
* Net off the amounts due between parties.
*/
fun <P: Any> netAmountsDue(balances: Map<Pair<CompositeKey, CompositeKey>, Amount<P>>): Map<Pair<CompositeKey, CompositeKey>, Amount<P>> {
fun <P : Any> netAmountsDue(balances: Map<Pair<CompositeKey, CompositeKey>, Amount<P>>): Map<Pair<CompositeKey, CompositeKey>, Amount<P>> {
val nettedBalances = HashMap<Pair<CompositeKey, CompositeKey>, Amount<P>>()
balances.forEach { balance ->
@ -669,7 +669,7 @@ fun <P: Any> netAmountsDue(balances: Map<Pair<CompositeKey, CompositeKey>, Amoun
* @param balances payments due, indexed by obligor and beneficiary. Zero balances are stripped from the map before being
* returned.
*/
fun <P: Any> sumAmountsDue(balances: Map<Pair<CompositeKey, CompositeKey>, Amount<P>>): Map<CompositeKey, Long> {
fun <P : Any> sumAmountsDue(balances: Map<Pair<CompositeKey, CompositeKey>, Amount<P>>): Map<CompositeKey, Long> {
val sum = HashMap<CompositeKey, Long>()
// Fill the map with zeroes initially
@ -699,25 +699,25 @@ fun <P: Any> sumAmountsDue(balances: Map<Pair<CompositeKey, CompositeKey>, Amoun
}
/** Sums the obligation states in the list, throwing an exception if there are none. All state objects in the list are presumed to be nettable. */
fun <P: Any> Iterable<ContractState>.sumObligations(): Amount<Issued<Obligation.Terms<P>>>
fun <P : Any> Iterable<ContractState>.sumObligations(): Amount<Issued<Obligation.Terms<P>>>
= filterIsInstance<Obligation.State<P>>().map { it.amount }.sumOrThrow()
/** Sums the obligation states in the list, returning null if there are none. */
fun <P: Any> Iterable<ContractState>.sumObligationsOrNull(): Amount<Issued<Obligation.Terms<P>>>?
fun <P : Any> Iterable<ContractState>.sumObligationsOrNull(): Amount<Issued<Obligation.Terms<P>>>?
= filterIsInstance<Obligation.State<P>>().filter { it.lifecycle == Obligation.Lifecycle.NORMAL }.map { it.amount }.sumOrNull()
/** Sums the obligation states in the list, returning zero of the given product if there are none. */
fun <P: Any> Iterable<ContractState>.sumObligationsOrZero(issuanceDef: Issued<Obligation.Terms<P>>): Amount<Issued<Obligation.Terms<P>>>
fun <P : Any> Iterable<ContractState>.sumObligationsOrZero(issuanceDef: Issued<Obligation.Terms<P>>): Amount<Issued<Obligation.Terms<P>>>
= filterIsInstance<Obligation.State<P>>().filter { it.lifecycle == Obligation.Lifecycle.NORMAL }.map { it.amount }.sumOrZero(issuanceDef)
infix fun <T: Any> Obligation.State<T>.at(dueBefore: Instant) = copy(template = template.copy(dueBefore = dueBefore))
infix fun <T: Any> Obligation.State<T>.between(parties: Pair<AbstractParty, CompositeKey>) = copy(obligor = parties.first.toAnonymous(), beneficiary = parties.second)
infix fun <T: Any> Obligation.State<T>.`owned by`(owner: CompositeKey) = copy(beneficiary = owner)
infix fun <T: Any> Obligation.State<T>.`issued by`(party: AbstractParty) = copy(obligor = party.toAnonymous())
infix fun <T : Any> Obligation.State<T>.at(dueBefore: Instant) = copy(template = template.copy(dueBefore = dueBefore))
infix fun <T : Any> Obligation.State<T>.between(parties: Pair<AbstractParty, CompositeKey>) = copy(obligor = parties.first.toAnonymous(), beneficiary = parties.second)
infix fun <T : Any> Obligation.State<T>.`owned by`(owner: CompositeKey) = copy(beneficiary = owner)
infix fun <T : Any> Obligation.State<T>.`issued by`(party: AbstractParty) = copy(obligor = party.toAnonymous())
// For Java users:
@Suppress("unused") fun <T: Any> Obligation.State<T>.ownedBy(owner: CompositeKey) = copy(beneficiary = owner)
@Suppress("unused") fun <T : Any> Obligation.State<T>.ownedBy(owner: CompositeKey) = copy(beneficiary = owner)
@Suppress("unused") fun <T: Any> Obligation.State<T>.issuedBy(party: AnonymousParty) = copy(obligor = party)
@Suppress("unused") fun <T : Any> Obligation.State<T>.issuedBy(party: AnonymousParty) = copy(obligor = party)
/** A randomly generated key. */
val DUMMY_OBLIGATION_ISSUER_KEY by lazy { entropyToKeyPair(BigInteger.valueOf(10)) }

2
finance/src/main/kotlin/net/corda/contracts/clause/AbstractConserveAmount.kt
View File

@ -16,7 +16,7 @@ import java.util.*
abstract class AbstractConserveAmount<S : FungibleAsset<T>, C : CommandData, T : Any> : Clause<S, C, Issued<T>>() {
private companion object {
val log = loggerFor<AbstractConserveAmount<*,*,*>>()
val log = loggerFor<AbstractConserveAmount<*, *, *>>()
}
/**

8
finance/src/main/kotlin/net/corda/contracts/clause/Net.kt
View File

@ -12,7 +12,7 @@ import net.corda.core.crypto.CompositeKey
* Common interface for the state subsets used when determining nettability of two or more states. Exposes the
* underlying issued thing.
*/
interface NetState<P: Any> {
interface NetState<P : Any> {
val template: Obligation.Terms<P>
}
@ -21,7 +21,7 @@ interface NetState<P: Any> {
* If two obligation state objects produce equal bilateral net states, they are considered safe to net directly.
* Bilateral states are used in close-out netting.
*/
data class BilateralNetState<P: Any>(
data class BilateralNetState<P : Any>(
val partyKeys: Set<CompositeKey>,
override val template: Obligation.Terms<P>
) : NetState<P>
@ -34,7 +34,7 @@ data class BilateralNetState<P: Any>(
* input and output is handled elsewhere.
* Used in cases where all parties (or their proxies) are signing, such as central clearing.
*/
data class MultilateralNetState<P: Any>(
data class MultilateralNetState<P : Any>(
override val template: Obligation.Terms<P>
) : NetState<P>
@ -42,7 +42,7 @@ data class MultilateralNetState<P: Any>(
* Clause for netting contract states. Currently only supports obligation contract.
*/
// TODO: Make this usable for any nettable contract states
open class NetClause<C : CommandData, P: Any> : Clause<ContractState, C, Unit>() {
open class NetClause<C : CommandData, P : Any> : Clause<ContractState, C, Unit>() {
override val requiredCommands: Set<Class<out CommandData>> = setOf(Obligation.Commands.Net::class.java)
@Suppress("ConvertLambdaToReference")

2
finance/src/main/kotlin/net/corda/contracts/testing/DummyLinearContract.kt
View File

@ -8,7 +8,7 @@ import net.corda.core.crypto.CompositeKey
import net.corda.core.crypto.SecureHash
import java.security.PublicKey
class DummyLinearContract: Contract {
class DummyLinearContract : Contract {
override val legalContractReference: SecureHash = SecureHash.sha256("Test")
val clause: Clause<State, CommandData, Unit> = LinearState.ClauseVerifier()

5
finance/src/main/kotlin/net/corda/flows/IssuerFlow.kt
View File

@ -29,7 +29,7 @@ object IssuerFlow {
* Returns the transaction created by the Issuer to move the cash to the Requester.
*/
class IssuanceRequester(val amount: Amount<Currency>, val issueToParty: Party, val issueToPartyRef: OpaqueBytes,
val issuerBankParty: Party): FlowLogic<SignedTransaction>() {
val issuerBankParty: Party) : FlowLogic<SignedTransaction>() {
@Suspendable
@Throws(CashException::class)
override fun call(): SignedTransaction {
@ -42,12 +42,13 @@ object IssuerFlow {
* Issuer refers to a Node acting as a Bank Issuer of [FungibleAsset], and processes requests from a [IssuanceRequester] client.
* Returns the generated transaction representing the transfer of the [Issued] [FungibleAsset] to the issue requester.
*/
class Issuer(val otherParty: Party): FlowLogic<SignedTransaction>() {
class Issuer(val otherParty: Party) : FlowLogic<SignedTransaction>() {
companion object {
object AWAITING_REQUEST : ProgressTracker.Step("Awaiting issuance request")
object ISSUING : ProgressTracker.Step("Self issuing asset")
object TRANSFERRING : ProgressTracker.Step("Transferring asset to issuance requester")
object SENDING_CONFIRM : ProgressTracker.Step("Confirming asset issuance to requester")
fun tracker() = ProgressTracker(AWAITING_REQUEST, ISSUING, TRANSFERRING, SENDING_CONFIRM)
private val VALID_CURRENCIES = listOf(USD, GBP, EUR, CHF)
}

2
finance/src/main/kotlin/net/corda/flows/TwoPartyTradeFlow.kt
View File

@ -72,6 +72,7 @@ object TwoPartyTradeFlow {
object COMMITTING : ProgressTracker.Step("Committing transaction to the ledger") {
override fun childProgressTracker() = FinalityFlow.tracker()
}
// DOCEND 3
object SENDING_FINAL_TX : ProgressTracker.Step("Sending final transaction to buyer")
@ -143,6 +144,7 @@ object TwoPartyTradeFlow {
val typeToBuy: Class<out OwnableState>) : FlowLogic<SignedTransaction>() {
// DOCSTART 2
object RECEIVING : ProgressTracker.Step("Waiting for seller trading info")
object VERIFYING : ProgressTracker.Step("Verifying seller assets")
object SIGNING : ProgressTracker.Step("Generating and signing transaction proposal")
object SENDING_SIGNATURES : ProgressTracker.Step("Sending signatures to the seller")

4
finance/src/main/kotlin/net/corda/schemas/CashSchemaV1.kt
View File

@ -2,7 +2,9 @@ package net.corda.schemas
import net.corda.core.schemas.MappedSchema
import net.corda.core.schemas.PersistentState
import javax.persistence.*
import javax.persistence.Column
import javax.persistence.Entity
import javax.persistence.Table
/**
* An object used to fully qualify the [CashSchema] family name (i.e. independent of version).

2
finance/src/main/kotlin/net/corda/schemas/CommercialPaperSchemaV1.kt
View File

@ -1,9 +1,7 @@
package net.corda.schemas
import io.requery.Convert
import net.corda.core.schemas.MappedSchema
import net.corda.core.schemas.PersistentState
import net.corda.core.schemas.requery.converters.InstantConverter
import java.time.Instant
import javax.persistence.Column
import javax.persistence.Entity

10
finance/src/test/java/net/corda/flows/AbstractStateReplacementFlowTest.java
View File

@ -1,8 +1,8 @@
package net.corda.flows;
import net.corda.core.crypto.Party;
import net.corda.core.utilities.ProgressTracker;
import org.jetbrains.annotations.NotNull;
import net.corda.core.crypto.*;
import net.corda.core.utilities.*;
import org.jetbrains.annotations.*;
@SuppressWarnings("unused")
public class AbstractStateReplacementFlowTest {
@ -12,7 +12,9 @@ public class AbstractStateReplacementFlowTest {
public TestAcceptorCanBeInheritedInJava(@NotNull Party otherSide, @NotNull ProgressTracker progressTracker) {
super(otherSide, progressTracker);
}
@Override
protected void verifyProposal(@NotNull AbstractStateReplacementFlow.Proposal proposal) {}
protected void verifyProposal(@NotNull AbstractStateReplacementFlow.Proposal proposal) {
}
}
}

1
finance/src/test/kotlin/net/corda/flows/CashPaymentFlowTests.kt
View File

@ -12,7 +12,6 @@ import net.corda.testing.node.MockNetwork.MockNode
import org.junit.After
import org.junit.Before
import org.junit.Test
import java.util.concurrent.ExecutionException
import kotlin.test.assertEquals
import kotlin.test.assertFailsWith