[FAB-11526] Prover: Request Transfer

This change-set does the following:
- Impliments support for the SignedCommand related to
a request trasnfer
- Local interfaces have been introduces to reduce
dependency from TMS

Change-Id: I8501cda493a5cb04ac3a02e2e992aad01031dba9
Signed-off-by: Angelo De Caro <adc@zurich.ibm.com>
Signed-off-by: Mathias Bjoerkqvist <mbj@zurich.ibm.com>

Author: adecaro

protos/token/prover.pb.go

@@ -71,7 +71,7 @@ message ImportRequest {
 message TransferRequest {
     bytes credential = 1;
 
-    repeated bytes tokenIDs = 2;
+    repeated bytes token_ids = 2;
 
     repeated RecipientTransferShare shares = 3;
 }

protos/token/prover.proto

@@ -57,7 +57,7 @@ func (prover *ProverPeer) RequestTransfer(
 
 	tr := &token.TransferRequest{
 		Shares:   shares,
-		TokenIDs: tokenIDs,
+		TokenIds: tokenIDs,
 	}
 	payload := &token.Command_TransferRequest{TransferRequest: tr}
 

token/client/prover.go

@@ -197,7 +197,7 @@ func prepareInputsForRequestTransfer(t *testing.T) ([][]byte, []*token.Recipient
 
 	tr := &token.TransferRequest{
 		Shares:   shares,
-		TokenIDs: tokenIDs,
+		TokenIds: tokenIDs,
 	}
 
 	nonce := make([]byte, 32)

token/client/prover_test.go

@@ -55,6 +55,8 @@ func (s *Prover) ProcessCommand(ctx context.Context, sc *token.SignedCommand) (*
 	switch t := command.GetPayload().(type) {
 	case *token.Command_ImportRequest:
 		payload, err = s.RequestImport(ctx, command.Header, t.ImportRequest)
+	case *token.Command_TransferRequest:
+		payload, err = s.RequestTransfer(ctx, command.Header, t.TransferRequest)
 	case *token.Command_ListRequest:
 		payload, err = s.ListUnspentTokens(ctx, command.Header, t.ListRequest)
 	default:
@@ -84,6 +86,20 @@ func (s *Prover) RequestImport(ctx context.Context, header *token.Header, reques
 	return &token.CommandResponse_TokenTransaction{TokenTransaction: tokenTransaction}, nil
 }
 
+func (s *Prover) RequestTransfer(ctx context.Context, header *token.Header, request *token.TransferRequest) (*token.CommandResponse_TokenTransaction, error) {
+	transactor, err := s.TMSManager.GetTransactor(header.ChannelId, request.Credential, header.Creator)
+	if err != nil {
+		return nil, err
+	}
+
+	tokenTransaction, err := transactor.RequestTransfer(request)
+	if err != nil {
+		return nil, err
+	}
+
+	return &token.CommandResponse_TokenTransaction{TokenTransaction: tokenTransaction}, nil
+}
+
 func (s *Prover) ListUnspentTokens(ctxt context.Context, header *token.Header, listRequest *token.ListRequest) (*token.CommandResponse_UnspentTokens, error) {
 	transactor, err := s.TMSManager.GetTransactor(header.ChannelId, listRequest.Credential, header.Creator)
 	if err != nil {

token/server/mock/transactor.go

@@ -46,6 +46,9 @@ var _ = Describe("Prover", func() {
 		tokenTransaction  *token.TokenTransaction
 		marshaledResponse *token.SignedCommandResponse
 
+		transferRequest    *token.TransferRequest
+		trTokenTransaction *token.TokenTransaction
+
 		listRequest      *token.ListRequest
 		unspentTokens    *token.UnspentTokens
 		transactorTokens []*token.TokenOutput
@@ -72,13 +75,34 @@ var _ = Describe("Prover", func() {
 		fakeIssuer = &mock.Issuer{}
 		fakeIssuer.RequestImportReturns(tokenTransaction, nil)
 
+		trTokenTransaction = &token.TokenTransaction{
+			Action: &token.TokenTransaction_PlainAction{
+				PlainAction: &token.PlainTokenAction{
+					Data: &token.PlainTokenAction_PlainTransfer{
+						PlainTransfer: &token.PlainTransfer{
+							Inputs: []*token.InputId{{
+								TxId:  []byte("txid"),
+								Index: 0,
+							}},
+							Outputs: []*token.PlainOutput{{
+								Owner:    []byte("token-owner"),
+								Type:     "PDQ",
+								Quantity: 777,
+							}},
+						},
+					},
+				},
+			},
+		}
+		fakeTransactor = &mock.Transactor{}
+		fakeTransactor.RequestTransferReturns(trTokenTransaction, nil)
+
 		transactorTokens = []*token.TokenOutput{
 			{Id: []byte("idaz"), Type: "typeaz", Quantity: 135},
 			{Id: []byte("idby"), Type: "typeby", Quantity: 79},
 		}
 		unspentTokens = &token.UnspentTokens{Tokens: transactorTokens}
 
-		fakeTransactor = &mock.Transactor{}
 		fakeTransactor.ListTokensReturns(unspentTokens, nil)
 
 		fakeTMSManager = &mock.TMSManager{}
@@ -119,6 +143,15 @@ var _ = Describe("Prover", func() {
 			Signature: []byte("command-signature"),
 		}
 
+		transferRequest = &token.TransferRequest{
+			Credential: []byte("credential"),
+			TokenIds:   [][]byte{},
+			Shares: []*token.RecipientTransferShare{{
+				Recipient: []byte("recipient"),
+				Quantity:  99,
+			}},
+		}
+
 		listRequest = &token.ListRequest{
 			Credential: []byte("credential"),
 		}
@@ -281,6 +314,55 @@ var _ = Describe("Prover", func() {
 		})
 	})
 
+	Describe("ProcessCommand_RequestImport", func() {
+		It("returns a signed command response", func() {
+			resp, err := prover.ProcessCommand(context.Background(), signedCommand)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(resp).To(Equal(marshaledResponse))
+
+			Expect(fakeMarshaler.MarshalCommandResponseCallCount()).To(Equal(1))
+			cmd, payload := fakeMarshaler.MarshalCommandResponseArgsForCall(0)
+			Expect(cmd).To(Equal(marshaledCommand))
+			Expect(payload).To(Equal(&token.CommandResponse_TokenTransaction{
+				TokenTransaction: tokenTransaction,
+			}))
+		})
+	})
+
+	Describe("ProcessCommand_RequestTransfer", func() {
+		BeforeEach(func() {
+			command = &token.Command{
+				Header: &token.Header{
+					ChannelId: "channel-id",
+					Creator:   []byte("creator"),
+					Nonce:     []byte("nonce"),
+				},
+				Payload: &token.Command_TransferRequest{
+					TransferRequest: transferRequest,
+				},
+			}
+			marshaledCommand = ProtoMarshal(command)
+			signedCommand = &token.SignedCommand{
+				Command:   marshaledCommand,
+				Signature: []byte("command-signature"),
+			}
+			fakeMarshaler.MarshalCommandResponseReturns(marshaledResponse, nil)
+		})
+
+		It("returns a signed command response", func() {
+			resp, err := prover.ProcessCommand(context.Background(), signedCommand)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(resp).To(Equal(marshaledResponse))
+
+			Expect(fakeMarshaler.MarshalCommandResponseCallCount()).To(Equal(1))
+			cmd, payload := fakeMarshaler.MarshalCommandResponseArgsForCall(0)
+			Expect(cmd).To(Equal(marshaledCommand))
+			Expect(payload).To(Equal(&token.CommandResponse_TokenTransaction{
+				TokenTransaction: trTokenTransaction,
+			}))
+		})
+	})
+
 	Describe("Process RequestImport command", func() {
 		It("returns a signed command response", func() {
 			resp, err := prover.ProcessCommand(context.Background(), signedCommand)
@@ -376,6 +458,53 @@ var _ = Describe("Prover", func() {
 		})
 	})
 
+	Describe("RequestTransfer", func() {
+		It("gets a transactor", func() {
+			_, err := prover.RequestTransfer(context.Background(), command.Header, transferRequest)
+			Expect(err).NotTo(HaveOccurred())
+
+			Expect(fakeTMSManager.GetTransactorCallCount()).To(Equal(1))
+			channel, cred, creator := fakeTMSManager.GetTransactorArgsForCall(0)
+			Expect(channel).To(Equal("channel-id"))
+			Expect(cred).To(Equal([]byte("credential")))
+			Expect(creator).To(Equal([]byte("creator")))
+		})
+
+		It("uses the transactor to request a transfer", func() {
+			resp, err := prover.RequestTransfer(context.Background(), command.Header, transferRequest)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(resp).To(Equal(&token.CommandResponse_TokenTransaction{
+				TokenTransaction: trTokenTransaction,
+			}))
+
+			Expect(fakeTransactor.RequestTransferCallCount()).To(Equal(1))
+			tr := fakeTransactor.RequestTransferArgsForCall(0)
+			Expect(tr).To(Equal(transferRequest))
+		})
+
+		Context("when the TMS manager fails to get a transactor", func() {
+			BeforeEach(func() {
+				fakeTMSManager.GetTransactorReturns(nil, errors.New("boing boing"))
+			})
+
+			It("retuns the error", func() {
+				_, err := prover.RequestTransfer(context.Background(), command.Header, transferRequest)
+				Expect(err).To(MatchError("boing boing"))
+			})
+		})
+
+		Context("when the transactor fails to transfer", func() {
+			BeforeEach(func() {
+				fakeTransactor.RequestTransferReturns(nil, errors.New("watermelon"))
+			})
+
+			It("retuns the error", func() {
+				_, err := prover.RequestTransfer(context.Background(), command.Header, transferRequest)
+				Expect(err).To(MatchError("watermelon"))
+			})
+		})
+	})
+
 	Describe("Issue tokens by a plain issuer", func() {
 		var (
 			manager         *server.Manager

token/server/prover.go

@@ -21,6 +21,11 @@ type Issuer interface {
 
 // Transactor allows to operate on issued tokens
 type Transactor interface {
+	// RequestTransfer Create data associated to the transfer of a token assuming
+	// an application-level identity. The inTokens bytes are the identifiers
+	// of the outputs, the details of which need to be looked up from the ledger.
+	RequestTransfer(request *token.TransferRequest) (*token.TokenTransaction, error)
+
 	// ListTokens returns a slice of unspent tokens owned by this transactor
 	ListTokens() (*token.UnspentTokens, error)
 }

token/server/prover_test.go

@@ -26,6 +26,11 @@ type Transactor struct {
 	Ledger           ledger.LedgerReader
 }
 
+// RequestTransfer creates a TokenTransaction of type transfer request
+func (t *Transactor) RequestTransfer(request *token.TransferRequest) (*token.TokenTransaction, error) {
+	panic("not implemented!")
+}
+
 // ListTokens creates a TokenTransaction that lists the unspent tokens owned by owner.
 func (t *Transactor) ListTokens() (*token.UnspentTokens, error) {
 	iterator, err := t.Ledger.GetStateRangeScanIterator(namespace, "", "")