mirror of
https://github.com/hyperledger/fabric-samples.git
synced 2026-06-17 07:25:10 +00:00
83 lines
2.8 KiB
Go
83 lines
2.8 KiB
Go
/*
|
|
Copyright IBM Corp. All Rights Reserved.
|
|
|
|
SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
package service
|
|
|
|
import (
|
|
"github.com/hyperledger-labs/fabric-smart-client/pkg/api"
|
|
"github.com/hyperledger-labs/fabric-smart-client/platform/view/services/flogging"
|
|
"github.com/hyperledger-labs/fabric-smart-client/platform/view/view"
|
|
"github.com/hyperledger-labs/fabric-token-sdk/token/services/ttx"
|
|
"github.com/pkg/errors"
|
|
)
|
|
|
|
var logger = flogging.MustGetLogger("owner")
|
|
|
|
type TokenService struct {
|
|
FSC api.ServiceProvider
|
|
}
|
|
|
|
type AcceptCashView struct{}
|
|
|
|
func (v *AcceptCashView) Call(context view.Context) (interface{}, error) {
|
|
logger.Infof("incoming session from [%s]", context.Session().Info().Endpoint)
|
|
|
|
// The recipient of a token (issued or transfer) responds, as first operation,
|
|
// to a request for a recipient. The recipient identity is a new nym key and not the main key of the wallet.
|
|
id, err := ttx.RespondRequestRecipientIdentity(context)
|
|
if err != nil {
|
|
return "", errors.Wrap(err, "failed to respond to identity request")
|
|
}
|
|
logger.Infof("shared recipient id: [%s]", id.UniqueID())
|
|
|
|
// After we responded with the recipient identity, the counterparty assembles
|
|
// the transaction that assigns the tokens to the recipient id and sends it to us.
|
|
tx, err := ttx.ReceiveTransaction(context)
|
|
if err != nil {
|
|
err = errors.Wrap(err, "failed to receive tokens")
|
|
logger.Error(err.Error())
|
|
return "", err
|
|
}
|
|
logger.Infof("transaction received: [%s]", tx.ID())
|
|
|
|
// The recipient can perform any check on the transaction as required by the business process
|
|
// In particular, here, the recipient checks that the transaction contains at least one output, and
|
|
// that there is at least one output that names the recipient. (The recipient is receiving something.
|
|
outputs, err := tx.Outputs()
|
|
if err != nil {
|
|
err = errors.Wrap(err, "failed getting outputs")
|
|
logger.Error(err.Error())
|
|
return "", err
|
|
}
|
|
if outputs.Count() <= 0 {
|
|
err = errors.New("outputs should be more than zero")
|
|
logger.Error(err.Error())
|
|
return "", err
|
|
}
|
|
if outputs.ByRecipient(id).Count() <= 0 {
|
|
err = errors.New("outputs to me should be more than zero")
|
|
logger.Error(err.Error())
|
|
return "", err
|
|
}
|
|
|
|
// If everything is fine, the recipient accepts and sends back her signature.
|
|
// Notice that, a signature from the recipient might or might not be required to make the transaction valid.
|
|
// This depends on the driver implementation.
|
|
_, err = context.RunView(ttx.NewAcceptView(tx))
|
|
if err != nil {
|
|
return "", errors.Wrap(err, "failed to accept new tokens")
|
|
}
|
|
logger.Infof("transaction accepted: [%s]", tx.ID())
|
|
|
|
// Before completing, the recipient waits for finality of the transaction
|
|
_, err = context.RunView(ttx.NewFinalityView(tx))
|
|
if err != nil {
|
|
return "", errors.Wrap(err, "new tokens were not committed")
|
|
}
|
|
logger.Infof("transaction committed: [%s]", tx.ID())
|
|
|
|
return nil, nil
|
|
}
|