backend/src/main/java/djmil/cordacheckers/cordaclient/CordaClient.java

@@ -150,7 +150,7 @@ public class CordaClient {
         return actionResult.successStatus();
     }
 
-    public GameBoard gameProposalAccept(
+    public UUID gameProposalAccept( // TODO shall return newGameBoard
         HoldingIdentity myHoldingIdentity,
         UUID gameProposalUuid
     ) {

backend/src/main/java/djmil/cordacheckers/cordaclient/dao/flow/arguments/GameProposalCommandAcceptRes.java

@@ -1,7 +1,7 @@
 package djmil.cordacheckers.cordaclient.dao.flow.arguments;
 
-import djmil.cordacheckers.cordaclient.dao.GameBoard;
+import java.util.UUID;
 
-public record GameProposalCommandAcceptRes(GameBoard successStatus, String transactionId, String failureStatus) {
+public record GameProposalCommandAcceptRes(UUID successStatus, String transactionId, String failureStatus) {
     
 }

backend/src/test/java/djmil/cordacheckers/cordaclient/CordaClientTest.java

@@ -143,16 +143,16 @@ public class CordaClientTest {
                 gpUuid);
         });
 
-        final GameBoard gbState = cordaClient.gameProposalAccept(
+        final UUID newGameBoardId = cordaClient.gameProposalAccept(
             holdingIdentityResolver.getByUsername(gpAcquier),
             gpUuid);
 
-        System.out.println("New GameBoard UUID "+gbState);
+        System.out.println("New GameBoard UUID "+newGameBoardId);
 
         List<GameBoard> gbListIssuer = cordaClient.gameBoardList(
             holdingIdentityResolver.getByUsername(gpIssuer));
 
-        GameBoard gbAlice = findByUuid(gbListIssuer, gbState.id());
+        GameBoard gbAlice = findByUuid(gbListIssuer, newGameBoardId);
         assertThat(gbAlice).isNotNull();
         assertThat(gbAlice.opponentName()).isEqualToIgnoringCase(gpAcquier);
         assertThat(gbAlice.opponentColor()).isEqualByComparingTo(gpAcquierColor);
@@ -162,7 +162,7 @@ public class CordaClientTest {
         List<GameBoard> gbListAcquier = cordaClient.gameBoardList(
         holdingIdentityResolver.getByUsername(gpAcquier));
 
-        GameBoard bgBob = findByUuid(gbListAcquier, gbState.id());
+        GameBoard bgBob = findByUuid(gbListAcquier, newGameBoardId);
         assertThat(bgBob).isNotNull();
         assertThat(bgBob.opponentName()).isEqualToIgnoringCase(gpIssuer);
         assertThat(bgBob.opponentColor()).isEqualByComparingTo(Piece.Color.BLACK);
@@ -196,14 +196,14 @@ public class CordaClientTest {
 
         System.out.println("New GameProposal UUID "+ gpUuid);
 
-        final GameBoard gbState = cordaClient.gameProposalAccept(
+        final UUID newGameBoardId = cordaClient.gameProposalAccept(
             hiBob, gpUuid
         );
 
-        System.out.println("New GameBoard UUID "+ gbState.id());
+        System.out.println("New GameBoard UUID "+ newGameBoardId);
 
-        final GameBoard gbSurrender = cordaClient.gameBoardCommand(
+        GameBoard gbSurrender = cordaClient.gameBoardCommand(
-            hiBob, gbState.id(), 
+            hiBob, newGameBoardId, 
             new GameBoardCommand(GameBoardCommand.Type.SURRENDER)
             );
 

corda/contracts/src/main/java/djmil/cordacheckers/contracts/GameBoardCommand.java

@@ -2,20 +2,16 @@ package djmil.cordacheckers.contracts;
 
 import java.util.List;
 
-import net.corda.v5.base.annotations.ConstructorForDeserialization;
-import net.corda.v5.base.annotations.CordaSerializable;
 import net.corda.v5.base.exceptions.CordaRuntimeException;
 import net.corda.v5.ledger.utxo.Command;
 
 public class GameBoardCommand implements Command {
-
-    @CordaSerializable
     public static enum Type {
         MOVE,
         SURRENDER,
-        DRAW,
+        REQUEST_DRAW,
-        VICTORY,
+        REQUEST_VICTORY,
-        ACCEPT; // aka accept opponents DRAW or VICTORY request
+        FINISH; // aka accept DRAW or VICTORY request
     }
 
     private final Type type;
@@ -27,12 +23,6 @@ public class GameBoardCommand implements Command {
         this.move = null;
     }
 
-    @ConstructorForDeserialization
-    public GameBoardCommand(Type type, List<Integer> move) {
-        this.type = type;
-        this.move = move;
-    }
-
     public GameBoardCommand(Type type) {
         if (type == Type.MOVE)
             throw new CordaRuntimeException (BAD_ACTIONMOVE_CONSTRUCTOR);

corda/contracts/src/main/java/djmil/cordacheckers/contracts/GameBoardContract.java

@@ -22,34 +22,23 @@ public class GameBoardContract implements net.corda.v5.ledger.utxo.Contract {
     public void verify(UtxoLedgerTransaction trx) {
         log.info("GameBoardContract.verify() called");
 
-        requireThat(trx.getCommands().size() == 1, REQUIRE_SINGLE_COMMAND);
         final Command command = getSingleCommand(trx, Command.class);
 
         if (command instanceof GameProposalCommand) {
             log.info("GameBoardContract.verify() as GameProposalCommand "+(GameProposalCommand)command);
-            switch ((GameProposalCommand)command) {
-                case ACCEPT:
-                    GameProposalCommand.validateAcceptTrx(trx);
-                    break;
-
-                default:
-                    throw new CordaRuntimeException(UNKNOWN_COMMAND);
-            }
         } else 
         if (command instanceof GameBoardCommand) {
             log.info("GameBoardContract.verify() as GameBoardCommand "+((GameBoardCommand)command).getType());
             switch (((GameBoardCommand)command).getType()) {
                 case MOVE:
                 break;
-                
                 case SURRENDER:
                 break;
-
+                case REQUEST_DRAW:
-                case DRAW:
                 break;
-                case VICTORY:
+                case REQUEST_VICTORY:
                 break;
-                case ACCEPT:
+                case FINISH:
                 break;
             }
         } else {

corda/contracts/src/main/java/djmil/cordacheckers/contracts/GameProposalCommand.java

@@ -1,15 +1,9 @@
 package djmil.cordacheckers.contracts;
 
-import djmil.cordacheckers.states.GameBoardState;
 import djmil.cordacheckers.states.GameProposalState;
 import net.corda.v5.base.types.MemberX500Name;
 import net.corda.v5.ledger.utxo.Command;
 import net.corda.v5.ledger.utxo.StateAndRef;
-import net.corda.v5.ledger.utxo.transaction.UtxoLedgerTransaction;
-
-import static djmil.cordacheckers.contracts.UtxoLedgerTransactionUtil.getSingleInputState;
-import static djmil.cordacheckers.contracts.UtxoLedgerTransactionUtil.getSingleOutputState;
-import static djmil.cordacheckers.contracts.UtxoLedgerTransactionUtil.requireThat;
 
 public enum GameProposalCommand implements Command { 
     CREATE,
@@ -51,52 +45,5 @@ public enum GameProposalCommand implements Command {
         return getRespondent(utxoGameProposal.getState().getContractState());
     }
 
-    public static void validateCreateTrx(UtxoLedgerTransaction trx) {
-        requireThat(trx.getInputContractStates().isEmpty(), CREATE_INPUT_STATE);
-        requireThat(trx.getOutputContractStates().size() == 1, CREATE_OUTPUT_STATE);
-
-        GameProposalState outputState = getSingleOutputState(trx, GameProposalState.class);
-
-        requireThat(outputState.getAcquierColor() != null, NON_NULL_RECIPIENT_COLOR);
-    }
-
-    public static void validateAcceptTrx(UtxoLedgerTransaction trx) {
-        requireThat(trx.getInputContractStates().size() == 1, ACCEPT_INPUT_STATE);
-        requireThat(trx.getOutputContractStates().size() == 1, ACCEPT_OUTPUT_STATE);
-
-        GameProposalState inGameProposal = getSingleInputState(trx, GameProposalState.class);
-        GameBoardState outGameBoard      = getSingleOutputState(trx, GameBoardState.class);
-
-        requireThat(outGameBoard.getParticipants().containsAll(inGameProposal.getParticipants()), ACCEPT_PARTICIPANTS);
-    }
-
-    public static void validateRejectTrx(UtxoLedgerTransaction trx) {
-        requireThat(trx.getInputContractStates().size() == 1, REJECT_INPUT_STATE);
-        requireThat(trx.getOutputContractStates().isEmpty(), REJECT_OUTPUT_STATE);
-
-        getSingleInputState(trx, GameProposalState.class);
-    }
-
-    public static void validateCancelTrx(UtxoLedgerTransaction trx) {
-        requireThat(trx.getInputContractStates().size() == 1, CANCEL_INPUT_STATE);
-        requireThat(trx.getOutputContractStates().isEmpty(), CANCEL_OUTPUT_STATE);
-        
-        getSingleInputState(trx, GameProposalState.class);
-    }
-
     public static final String UNSUPPORTED_VALUE_OF = "Unsupported GameProposalCommand value: ";
-
-    static final String CREATE_INPUT_STATE  = "Create command should have no input states";
-    static final String CREATE_OUTPUT_STATE = "Create command should output exactly one GameProposal state";
-    static final String NON_NULL_RECIPIENT_COLOR = "GameProposal.recipientColor field can not be null";
-
-    static final String REJECT_INPUT_STATE  = "Reject command should have exactly one GameProposal input state";
-    static final String REJECT_OUTPUT_STATE = "Reject command should have no output states";
-
-    static final String CANCEL_INPUT_STATE  = "Cancel command should have exactly one GameProposal input state";
-    static final String CANCEL_OUTPUT_STATE = "Cancel command should have no output states";
-
-    static final String ACCEPT_INPUT_STATE  = "Accept command should have exactly one GameProposal input state";
-    static final String ACCEPT_OUTPUT_STATE = "Accept command should have exactly one GameBoard output state";
-    static final String ACCEPT_PARTICIPANTS = "Accept command: GameBoard participants should math GameProposal participants";
 }

corda/contracts/src/main/java/djmil/cordacheckers/contracts/GameProposalContract.java

@@ -1,14 +1,17 @@
 package djmil.cordacheckers.contracts;
 
+import static djmil.cordacheckers.contracts.UtxoLedgerTransactionUtil.getSingleCommand;
+import static djmil.cordacheckers.contracts.UtxoLedgerTransactionUtil.getSingleInputState;
+import static djmil.cordacheckers.contracts.UtxoLedgerTransactionUtil.getSingleOutputState;
+
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import djmil.cordacheckers.states.GameBoardState;
+import djmil.cordacheckers.states.GameProposalState;
 import net.corda.v5.base.exceptions.CordaRuntimeException;
 import net.corda.v5.ledger.utxo.transaction.UtxoLedgerTransaction;
 
-import static djmil.cordacheckers.contracts.UtxoLedgerTransactionUtil.getSingleCommand;
-import static djmil.cordacheckers.contracts.UtxoLedgerTransactionUtil.requireThat;
-
 public class GameProposalContract implements net.corda.v5.ledger.utxo.Contract {
 
     private final static Logger log = LoggerFactory.getLogger(GameProposalContract.class);
@@ -17,31 +20,67 @@ public class GameProposalContract implements net.corda.v5.ledger.utxo.Contract {
     public void verify(UtxoLedgerTransaction trx) {
         log.info("GameProposalContract.verify() called");
 
-        requireThat(trx.getCommands().size() == 1, REQUIRE_SINGLE_COMMAND);
         final GameProposalCommand command = getSingleCommand(trx, GameProposalCommand.class);
 
         switch (command) {
-            case CREATE:
+            case CREATE: {
-                GameProposalCommand.validateCreateTrx(trx);
+                requireThat(trx.getInputContractStates().isEmpty(), CREATE_INPUT_STATE);
-                break;
+                requireThat(trx.getOutputContractStates().size() == 1, CREATE_OUTPUT_STATE);
 
-            case ACCEPT:
+                GameProposalState outputState = getSingleOutputState(trx, GameProposalState.class);
-                GameProposalCommand.validateAcceptTrx(trx);
-                break;
 
-            case REJECT:
+                requireThat(outputState.getAcquierColor() != null, NON_NULL_RECIPIENT_COLOR);
-                GameProposalCommand.validateRejectTrx(trx);
+                break; }
-                break;
+
+            case ACCEPT: {
+                requireThat(trx.getInputContractStates().size() == 1, ACCEPT_INPUT_STATE);
+                requireThat(trx.getOutputContractStates().size() == 1, ACCEPT_OUTPUT_STATE);
+
+                GameProposalState inGameProposal = getSingleInputState(trx, GameProposalState.class);
+                GameBoardState outGameBoard      = getSingleOutputState(trx, GameBoardState.class);
+
+                requireThat(outGameBoard.getParticipants().containsAll(inGameProposal.getParticipants()), ACCEPT_PARTICIPANTS);
+                break; } 
+
+            case REJECT: {
+                requireThat(trx.getInputContractStates().size() == 1, REJECT_INPUT_STATE);
+                requireThat(trx.getOutputContractStates().isEmpty(), REJECT_OUTPUT_STATE);
+
+                getSingleInputState(trx, GameProposalState.class);
+                break; }
 
             case CANCEL:
-                GameProposalCommand.validateCancelTrx(trx);
+                requireThat(trx.getInputContractStates().size() == 1, CANCEL_INPUT_STATE);
+                requireThat(trx.getOutputContractStates().isEmpty(), CANCEL_OUTPUT_STATE);
+                
+                getSingleInputState(trx, GameProposalState.class);
                 break;
 
             default:
                 throw new CordaRuntimeException(UNKNOWN_COMMAND);
         }
     }
+    
+    private void requireThat(boolean asserted, String errorMessage) {
+        if (!asserted) {
+            throw new CordaRuntimeException("Failed requirement: " + errorMessage);
+        }
+    }
 
     static final String REQUIRE_SINGLE_COMMAND = "Require a single command";
     static final String UNKNOWN_COMMAND = "Unsupported command";
-  }
+
+    static final String CREATE_INPUT_STATE  = "Create command should have no input states";
+    static final String CREATE_OUTPUT_STATE = "Create command should output exactly one GameProposal state";
+    static final String NON_NULL_RECIPIENT_COLOR = "GameProposal.recipientColor field can not be null";
+
+    static final String REJECT_INPUT_STATE  = "Reject command should have exactly one GameProposal input state";
+    static final String REJECT_OUTPUT_STATE = "Reject command should have no output states";
+
+    static final String CANCEL_INPUT_STATE  = "Cancel command should have exactly one GameProposal input state";
+    static final String CANCEL_OUTPUT_STATE = "Cancel command should have no output states";
+
+    static final String ACCEPT_INPUT_STATE  = "Accept command should have exactly one GameProposal input state";
+    static final String ACCEPT_OUTPUT_STATE = "Accept command should have exactly one GameBoard output state";
+    static final String ACCEPT_PARTICIPANTS = "Accept command: GameBoard participants should math GameProposal participants";
+}

corda/contracts/src/main/java/djmil/cordacheckers/contracts/UtxoLedgerTransactionUtil.java

@@ -40,12 +40,6 @@ public class UtxoLedgerTransactionUtil {
         return optional(utxoTrx.getOutputStates(clazz), clazz);
     }
 
-    public static void requireThat(boolean asserted, String errorMessage) {
-        if (!asserted) {
-            throw new IllegalStateException("Failed requirement: " + errorMessage);
-        }
-    }
-
     private static <T> Optional<T> optional(List<T> list, Class<T> clazz) {
         return list
             .stream()

corda/workflows/src/main/java/djmil/cordacheckers/gameboard/ListFlow.java

@@ -67,7 +67,9 @@ public class ListFlow implements ClientStartableFlow {
         final UtxoLedgerTransaction utxoGameBoard = utxoLedgerService
             .findLedgerTransaction(trxId);
 
-        return new GameBoardView(myName, utxoGameBoard);
+        var newGbView = new GameBoardView(myName, utxoGameBoard);
+
+        return newGbView;
     }
     
 }

corda/workflows/src/main/java/djmil/cordacheckers/gameproposal/CommandFlow.java

@@ -6,9 +6,7 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import djmil.cordacheckers.FlowResult;
-import djmil.cordacheckers.contracts.GameBoardCommand;
 import djmil.cordacheckers.contracts.GameProposalCommand;
-import djmil.cordacheckers.gameboard.GameBoardView;
 import djmil.cordacheckers.states.GameBoardState;
 import djmil.cordacheckers.states.GameProposalState;
 import net.corda.v5.application.flows.ClientRequestBody;
@@ -16,13 +14,10 @@ import net.corda.v5.application.flows.ClientStartableFlow;
 import net.corda.v5.application.flows.CordaInject;
 import net.corda.v5.application.flows.FlowEngine;
 import net.corda.v5.application.marshalling.JsonMarshallingService;
-import net.corda.v5.application.membership.MemberLookup;
 import net.corda.v5.base.annotations.Suspendable;
-import net.corda.v5.base.types.MemberX500Name;
 import net.corda.v5.crypto.SecureHash;
 import net.corda.v5.ledger.utxo.StateAndRef;
 import net.corda.v5.ledger.utxo.UtxoLedgerService;
-import net.corda.v5.ledger.utxo.transaction.UtxoLedgerTransaction;
 import net.corda.v5.ledger.utxo.transaction.UtxoSignedTransaction;
 import net.corda.v5.ledger.utxo.transaction.UtxoTransactionBuilder;
 
@@ -37,14 +32,11 @@ public class CommandFlow implements ClientStartableFlow {
     public JsonMarshallingService jsonMarshallingService;
 
     @CordaInject
-    public UtxoLedgerService utxoLedgerService;
+    public UtxoLedgerService ledgerService;
 
     @CordaInject
     public FlowEngine flowEngine;
 
-    @CordaInject
-    public MemberLookup memberLookup;    
-
     @Override
     @Suspendable
     public String call(ClientRequestBody requestBody) {
@@ -52,17 +44,17 @@ public class CommandFlow implements ClientStartableFlow {
             final CommandFlowArgs args = requestBody.getRequestBodyAs(jsonMarshallingService, CommandFlowArgs.class);
             final GameProposalCommand command = args.getCommand();
 
-            final StateAndRef<GameProposalState> gpStateAndRef = findUnconsumedGameProposalState(args.getGameProposalUuid());
+            final StateAndRef<GameProposalState> utxoGameProposal = findUnconsumedGameProposalState(args.getGameProposalUuid());
 
-            final UtxoSignedTransaction trxCandidate = prepareSignedTransaction(command, gpStateAndRef);
+            final UtxoSignedTransaction trx = prepareSignedTransaction(command, utxoGameProposal);
 
             final SecureHash trxId = this.flowEngine
-                .subFlow( new CommitSubFlow(trxCandidate, command.getRespondent(gpStateAndRef)) );
+                .subFlow( new CommitSubFlow(trx, command.getRespondent(utxoGameProposal)) );
 
             if (command == GameProposalCommand.ACCEPT) {
-                final GameBoardView gbView = prepareGameBoardView(trxId);
+                GameBoardState newGb = (GameBoardState)trx.getOutputStateAndRefs().get(0).getState().getContractState();
 
-                return new FlowResult(gbView, trxId) 
+                return new FlowResult(newGb.getId(), trxId) 
                     .toJsonEncodedString(jsonMarshallingService);
             }
 
@@ -77,16 +69,16 @@ public class CommandFlow implements ClientStartableFlow {
     }
 
     @Suspendable
-    private StateAndRef<GameProposalState> findUnconsumedGameProposalState (UUID gpUuid) {
+    private StateAndRef<GameProposalState> findUnconsumedGameProposalState (UUID gameProposalUuid) {
         /*
          * Get list of all unconsumed aka 'active' GameProposalStates, then filter by UUID.
          * Note, this is an inefficient way to perform this operation if there are a large
          * number of 'active' GameProposals exists in storage.
          */
-        return this.utxoLedgerService
+        return this.ledgerService
             .findUnconsumedStatesByType(GameProposalState.class)
             .stream()
-            .filter(sar -> sar.getState().getContractState().getId().equals(gpUuid))
+            .filter(sar -> sar.getState().getContractState().getId().equals(gameProposalUuid))
             .reduce((a, b) -> {throw new IllegalStateException("Multiple states: " +a +", " +b);})
             .get();
     }
@@ -94,18 +86,18 @@ public class CommandFlow implements ClientStartableFlow {
     @Suspendable
     private UtxoSignedTransaction prepareSignedTransaction(
         GameProposalCommand command,
-        StateAndRef<GameProposalState> gpStateAndRef
+        StateAndRef<GameProposalState> utxoGameProposal
     ) {
-        UtxoTransactionBuilder trxBuilder = utxoLedgerService.createTransactionBuilder()
+        UtxoTransactionBuilder trxBuilder = ledgerService.createTransactionBuilder()
-            .setNotary(gpStateAndRef.getState().getNotaryName())
+            .setNotary(utxoGameProposal.getState().getNotaryName())
             .setTimeWindowBetween(Instant.now(), Instant.now().plusMillis(Duration.ofDays(1).toMillis()))
-            .addInputState(gpStateAndRef.getRef())
+            .addInputState(utxoGameProposal.getRef())
             .addCommand(command)
-            .addSignatories(gpStateAndRef.getState().getContractState().getParticipants());
+            .addSignatories(utxoGameProposal.getState().getContractState().getParticipants());
 
         if (command == GameProposalCommand.ACCEPT) {
             trxBuilder = trxBuilder
-                .addOutputState(new GameBoardState(gpStateAndRef));
+                .addOutputState(new GameBoardState(utxoGameProposal));
                 //A state cannot be both an input and a reference input in the same transaction
                 //.addReferenceState(utxoGameProposal.getRef());
         }
@@ -113,14 +105,4 @@ public class CommandFlow implements ClientStartableFlow {
         return trxBuilder.toSignedTransaction();
     }
 
-    @Suspendable
-    private GameBoardView prepareGameBoardView(SecureHash gbUtxoTrxId) {
-        final MemberX500Name myName = memberLookup.myInfo().getName();
-
-        final UtxoLedgerTransaction utxoGameBoard = utxoLedgerService
-            .findLedgerTransaction(gbUtxoTrxId);
-
-        return new GameBoardView(myName, utxoGameBoard);
-    }
-
 }