convert to upgrade

Signed-off-by: Angelo De Caro <[email protected]>

Author: adecaro

integration/token/fungible/support.go

@@ -1254,12 +1254,12 @@ func CheckPrometheusMetrics(ii *integration.Infrastructure, viewName string) {
 	}
 }
 
-func Conversion(network *integration.Infrastructure, wpm *WalletManagerProvider, user *token3.NodeReference, wallet string, typ token.Type, auditor *token3.NodeReference, issuer *token3.NodeReference, expectedErrorMsgs ...string) string {
+func TokensUpgrade(network *integration.Infrastructure, wpm *WalletManagerProvider, user *token3.NodeReference, wallet string, typ token.Type, auditor *token3.NodeReference, issuer *token3.NodeReference, expectedErrorMsgs ...string) string {
 	var recipientData *token2.RecipientData
 	if wpm != nil {
 		recipientData = wpm.RecipientData(user.Id(), wallet)
 	}
-	txid, err := network.Client(user.ReplicaName()).CallView("Conversion", common.JSONMarshall(&views.Conversion{
+	txid, err := network.Client(user.ReplicaName()).CallView("TokensUpgrade", common.JSONMarshall(&views.TokensUpgrade{
 		Wallet:        wallet,
 		TokenType:     typ,
 		Issuer:        issuer.Id(),
@@ -1269,7 +1269,7 @@ func Conversion(network *integration.Infrastructure, wpm *WalletManagerProvider,
 	if len(expectedErrorMsgs) == 0 {
 		Expect(err).NotTo(HaveOccurred())
 		txID := common.JSONUnmarshalString(txid)
-		fmt.Printf("Conversion txID [%s]\n", txID)
+		fmt.Printf("TokensUpgrade txID [%s]\n", txID)
 		common2.CheckFinality(network, user, txID, nil, false)
 		common2.CheckFinality(network, auditor, txID, nil, false)
 		common2.CheckFinality(network, issuer, txID, nil, false)

integration/token/fungible/tests.go

@@ -1175,7 +1175,7 @@ func TestStress(network *integration.Infrastructure, auditorId string, selector
 
 }
 
-func TestUpdatability(network *integration.Infrastructure, auditorId string, onRestart OnRestartFunc, sel *token3.ReplicaSelector) {
+func TestTokensUpgrade(network *integration.Infrastructure, auditorId string, onRestart OnRestartFunc, sel *token3.ReplicaSelector) {
 	// we start with fabtoken 16bits, performs a few operation, and then switch
 	auditor := sel.Get(auditorId)
 	issuer := sel.Get("issuer")
@@ -1221,7 +1221,7 @@ func TestUpdatability(network *integration.Infrastructure, auditorId string, onR
 	CheckBalanceAndHolding(network, alice, "", "EUR", 110, auditor)
 
 	TransferCash(network, alice, "", "EUR", 110, bob, auditor, "insufficient funds, only [0] tokens of type [EUR] are available, but [110] were requested and no other process has any tokens locked")
-	Conversion(network, nil, alice, "", "EUR", auditor, issuer)
+	TokensUpgrade(network, nil, alice, "", "EUR", auditor, issuer)
 	TransferCash(network, alice, "", "EUR", 110, bob, auditor)
 	CopyDBsTo(network, "./testdata", alice)
 	CheckOwnerDB(network, nil, issuer, alice, bob, charlie, manager)

integration/token/fungible/topology/topology.go

@@ -64,7 +64,7 @@ func Topology(opts common.Opts) []api.Topology {
 	)
 	issuer.AddOptions(opts.ReplicationOpts.For("issuer")...)
 	issuer.RegisterResponder(&views.WithdrawalResponderView{}, &views.WithdrawalInitiatorView{})
-	issuer.RegisterResponder(&views.ConversionResponderView{}, &views.ConversionInitiatorView{})
+	issuer.RegisterResponder(&views.TokensUpgradeResponderView{}, &views.TokensUpgradeInitiatorView{})
 	issuer.RegisterViewFactory("issue", &views.IssueCashViewFactory{})
 	issuer.RegisterViewFactory("transfer", &views.TransferViewFactory{})
 	issuer.RegisterViewFactory("transferWithSelector", &views.TransferWithSelectorViewFactory{})
@@ -210,7 +210,7 @@ func Topology(opts common.Opts) []api.Topology {
 	alice.RegisterViewFactory("TxFinality", &views2.TxFinalityViewFactory{})
 	alice.RegisterViewFactory("MaliciousTransfer", &views.MaliciousTransferViewFactory{})
 	alice.RegisterViewFactory("TxStatus", &views.TxStatusViewFactory{})
-	alice.RegisterViewFactory("Conversion", &views.ConversionInitiatorViewFactory{})
+	alice.RegisterViewFactory("TokensUpgrade", &views.TokensUpgradeInitiatorViewFactory{})
 	alice.RegisterViewFactory("SetSpendableFlag", &views.SetSpendableFlagViewFactory{})
 
 	bob := fscTopology.AddNodeByName("bob").AddOptions(
@@ -251,7 +251,7 @@ func Topology(opts common.Opts) []api.Topology {
 	bob.RegisterViewFactory("RegisterRecipientData", &views.RegisterRecipientDataViewFactory{})
 	bob.RegisterViewFactory("TxFinality", &views2.TxFinalityViewFactory{})
 	bob.RegisterViewFactory("TxStatus", &views.TxStatusViewFactory{})
-	bob.RegisterViewFactory("Conversion", &views.ConversionInitiatorViewFactory{})
+	bob.RegisterViewFactory("TokensUpgrade", &views.TokensUpgradeInitiatorViewFactory{})
 
 	charlie := fscTopology.AddNodeByName("charlie").AddOptions(
 		fabric.WithOrganization("Org2"),

integration/token/fungible/update/update_test.go

@@ -20,7 +20,7 @@ import (
 
 var _ = Describe("EndToEnd", func() {
 	for _, t := range integration.AllTestTypes {
-		Describe("Updatability with Auditor ne Issuer", t.Label, func() {
+		Describe("Tokens Upgrade with Auditor ne Issuer", t.Label, func() {
 			ts, selector := newTestSuite(t.CommType, []common.TMSOpts{
 				{
 					Alias:               "dlog-32bits",
@@ -30,7 +30,7 @@ var _ = Describe("EndToEnd", func() {
 			}, t.ReplicationFactor, "alice", "bob", "charlie")
 			BeforeEach(ts.Setup)
 			AfterEach(ts.TearDown)
-			It("succeeded", Label("T1"), func() { fungible.TestUpdatability(ts.II, "auditor", nil, selector) })
+			It("succeeded", Label("T1"), func() { fungible.TestTokensUpgrade(ts.II, "auditor", nil, selector) })
 		})
 	}
 })

…ation/token/fungible/views/conversion.go …egration/token/fungible/views/upgrade.gointegration/token/fungible/views/conversion.go renamed to integration/token/fungible/views/upgrade.go integration/token/fungible/views/conversion.go renamed to integration/token/fungible/views/upgrade.go

@@ -20,7 +20,7 @@ import (
 	token2 "github.com/hyperledger-labs/fabric-token-sdk/token/token"
 )
 
-type Conversion struct {
+type TokensUpgrade struct {
 	// TMSID the token management service identifier
 	TMSID token.TMSID
 	// Wallet of the recipient of the cash to be issued
@@ -35,15 +35,15 @@ type Conversion struct {
 	NotAnonymous bool
 }
 
-type ConversionInitiatorView struct {
-	*Conversion
+type TokensUpgradeInitiatorView struct {
+	*TokensUpgrade
 }
 
-func (i *ConversionInitiatorView) Call(context view.Context) (interface{}, error) {
-	span := context.StartSpan("conversion_initiator_view")
+func (i *TokensUpgradeInitiatorView) Call(context view.Context) (interface{}, error) {
+	span := context.StartSpan("upgrade_initiator_view")
 	defer span.End()
 
-	// First, the initiator selects the tokens to convert, namely those that cannot be spent.
+	// First, the initiator selects the tokens to upgrade, namely those that are unsupported.
 	tms := token.GetManagementService(context, token.WithTMSID(i.TMSID))
 	assert.NotNil(tms, "failed getting token management service for [%s]", i.TMSID)
 	w := tms.WalletManager().OwnerWallet(i.Wallet)
@@ -59,17 +59,17 @@ func (i *ConversionInitiatorView) Call(context view.Context) (interface{}, error
 	unspendableTokens, err := collections.ReadAll(it)
 	assert.NoError(err, "failed getting tokens")
 
-	// Then, the initiator sends a conversion request to the issuer.
+	// Then, the initiator sends a upgrade request to the issuer.
 	// If the initiator has already some recipient data, it uses that directly
 	var id view.Identity
 	var session view.Session
 	if i.RecipientData != nil {
 		// Use the passed RecipientData.
 		// First register it locally
 		assert.NoError(w.RegisterRecipient(i.RecipientData), "failed to register remote recipient")
-		// Then request conversion
-		span.AddEvent("request_conversion_for_recipient")
-		id, session, err = ttx.RequestConversionForRecipient(
+		// Then request upgrade
+		span.AddEvent("request_upgrade_for_recipient")
+		id, session, err = ttx.RequestTokensUpgradeForRecipient(
 			context,
 			view.Identity(i.Issuer),
 			i.Wallet,
@@ -79,8 +79,8 @@ func (i *ConversionInitiatorView) Call(context view.Context) (interface{}, error
 			token.WithTMSID(tms.ID()),
 		)
 	} else {
-		span.AddEvent("request_conversion")
-		id, session, err = ttx.RequestConversion(
+		span.AddEvent("request_upgrade")
+		id, session, err = ttx.RequestTokensUpgrade(
 			context,
 			view.Identity(i.Issuer),
 			i.Wallet,
@@ -89,16 +89,16 @@ func (i *ConversionInitiatorView) Call(context view.Context) (interface{}, error
 			token.WithTMSID(tms.ID()),
 		)
 	}
-	assert.NoError(err, "failed to send conversion request")
+	assert.NoError(err, "failed to send upgrade request")
 
-	// Request conversion
+	// Request upgrade
 
 	// At this point we have an inversion of roles.
 	// The initiator becomes a responder.
 	// This is a trick to the reuse the same API independently of the role a party plays.
 	return context.RunView(nil, view.AsResponder(session), view.WithViewCall(
 		func(context view.Context) (interface{}, error) {
-			span := context.StartSpan("conversion_respond_view")
+			span := context.StartSpan("upgrade_respond_view")
 			defer span.End()
 			// At some point, the recipient receives the token transaction that in the meantime has been assembled
 			tx, err := ttx.ReceiveTransaction(context)
@@ -118,7 +118,7 @@ func (i *ConversionInitiatorView) Call(context view.Context) (interface{}, error
 			// 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.
-			span.AddEvent("accept_conversion")
+			span.AddEvent("accept_upgrade")
 			_, err = context.RunView(ttx.NewAcceptView(tx))
 			assert.NoError(err, "failed to accept new tokens")
 
@@ -132,26 +132,26 @@ func (i *ConversionInitiatorView) Call(context view.Context) (interface{}, error
 	))
 }
 
-type ConversionInitiatorViewFactory struct{}
+type TokensUpgradeInitiatorViewFactory struct{}
 
-func (p *ConversionInitiatorViewFactory) NewView(in []byte) (view.View, error) {
-	f := &ConversionInitiatorView{Conversion: &Conversion{}}
-	err := json.Unmarshal(in, f.Conversion)
+func (p *TokensUpgradeInitiatorViewFactory) NewView(in []byte) (view.View, error) {
+	f := &TokensUpgradeInitiatorView{TokensUpgrade: &TokensUpgrade{}}
+	err := json.Unmarshal(in, f.TokensUpgrade)
 	assert.NoError(err, "failed unmarshalling input")
 
 	return f, nil
 }
 
-type ConversionResponderView struct {
+type TokensUpgradeResponderView struct {
 	Auditor string
 }
 
-func (p *ConversionResponderView) Call(context view.Context) (interface{}, error) {
-	span := context.StartSpan("conversion_responder_view")
+func (p *TokensUpgradeResponderView) Call(context view.Context) (interface{}, error) {
+	span := context.StartSpan("upgrade_responder_view")
 	defer span.End()
-	// First the issuer receives the conversion request
-	conversionRequest, err := ttx.ReceiveConversionRequest(context)
-	assert.NoError(err, "failed to receive conversion request")
+	// First the issuer receives the upgrade request
+	upgradeRequest, err := ttx.ReceiveTokensUpgradeRequest(context)
+	assert.NoError(err, "failed to receive upgrade request")
 
 	// Now we have an inversion of roles. The issuer becomes an initiator.
 	// This is a trick to reuse the code used in IssueCashView
@@ -160,7 +160,7 @@ func (p *ConversionResponderView) Call(context view.Context) (interface{}, error
 		// In this example, if the token type is USD, the issuer checks that no more than 230 units of USD
 		// have been issued already including the current request.
 		// No check is performed for other types.
-		wallet := token.GetManagementService(context, token.WithTMSID(conversionRequest.TMSID)).WalletManager().IssuerWallet("")
+		wallet := token.GetManagementService(context, token.WithTMSID(upgradeRequest.TMSID)).WalletManager().IssuerWallet("")
 		assert.NotNil(wallet, "issuer wallet not found")
 
 		// At this point, the issuer is ready to prepare the token transaction.
@@ -173,21 +173,21 @@ func (p *ConversionResponderView) Call(context view.Context) (interface{}, error
 			auditorID = p.Auditor
 		}
 		auditor := view2.GetIdentityProvider(context).Identity(auditorID)
-		if !conversionRequest.NotAnonymous {
+		if !upgradeRequest.NotAnonymous {
 			// The issuer creates an anonymous transaction (for Fabric, this means that the resulting transaction will be signed using idemix),
-			tx, err = ttx.NewAnonymousTransaction(context, ttx.WithAuditor(auditor), ttx.WithTMSID(conversionRequest.TMSID))
+			tx, err = ttx.NewAnonymousTransaction(context, ttx.WithAuditor(auditor), ttx.WithTMSID(upgradeRequest.TMSID))
 		} else {
 			// The issuer creates a nominal transaction using the default identity
-			tx, err = ttx.NewTransaction(context, nil, ttx.WithAuditor(auditor), ttx.WithTMSID(conversionRequest.TMSID))
+			tx, err = ttx.NewTransaction(context, nil, ttx.WithAuditor(auditor), ttx.WithTMSID(upgradeRequest.TMSID))
 		}
 		assert.NoError(err, "failed creating issue transaction")
 
 		// The issuer adds a new issue operation to the transaction following the instruction received
-		err = tx.Convert(
+		err = tx.Upgrade(
 			wallet,
-			conversionRequest.RecipientData.Identity,
-			conversionRequest.Tokens,
-			conversionRequest.Proof,
+			upgradeRequest.RecipientData.Identity,
+			upgradeRequest.Tokens,
+			upgradeRequest.Proof,
 		)
 		assert.NoError(err, "failed adding new issued token")
 

token/core/common/tokens.go

@@ -19,7 +19,7 @@ func NewTokensService() *TokensService {
 	return &TokensService{}
 }
 
-func (s *TokensService) NewConversionChallenge() (driver.ConversionChallenge, error) {
+func (s *TokensService) NewUpgradeChallenge() (driver.TokenUpgradeChallenge, error) {
 	// generate a 32 bytes secure random slice
 	key := make([]byte, 32)
 	_, err := rand.Read(key)
@@ -29,10 +29,10 @@ func (s *TokensService) NewConversionChallenge() (driver.ConversionChallenge, er
 	return key, nil
 }
 
-func (s *TokensService) GenConversionProof(ch driver.ConversionChallenge, tokens []token.LedgerToken) ([]byte, error) {
+func (s *TokensService) GenUpgradeProof(ch driver.TokenUpgradeChallenge, tokens []token.LedgerToken) ([]byte, error) {
 	return nil, nil
 }
 
-func (s *TokensService) CheckConversionProof(ch driver.ConversionChallenge, proof driver.ConversionProof, tokens []token.LedgerToken) (bool, error) {
+func (s *TokensService) CheckUpgradeProof(ch driver.TokenUpgradeChallenge, proof driver.TokenUpgradeProof, tokens []token.LedgerToken) (bool, error) {
 	return true, nil
 }

token/core/zkatdlog/nogh/issue.go

@@ -83,7 +83,7 @@ func (s *IssueService) Issue(ctx context.Context, issuerIdentity driver.Identity
 		}
 		values = []uint64{totalValue}
 
-		s.Logger.Debugf("conversion: extracted token type [%s] and value [%d] from the passed tokens", tokenType, totalValue)
+		s.Logger.Debugf("upgrade: extracted token type [%s] and value [%d] from the passed tokens", tokenType, totalValue)
 
 		// fetch issuer identity
 		issuerIdentity, err = opts.Wallet.GetIssuerIdentity(tokenType)

token/core/zkatdlog/nogh/tokens.go

@@ -77,7 +77,7 @@ func (s *TokensService) SupportedTokenFormats() []token.Format {
 
 func (s *TokensService) DeserializeToken(outputFormat token.Format, outputRaw []byte, metadataRaw []byte) (*token2.Token, *token2.Metadata, *token2.ConversionWitness, error) {
 	// Here we have to check if what we get in input is already as expected.
-	// If not, we need to check if a conversion is possible.
+	// If not, we need to check if a token upgrade is possible.
 	// If not, a failure is to be returned
 	if outputFormat != s.OutputTokenFormat {
 		return nil, nil, nil, errors.Errorf("invalid token type [%s], expected [%s]", outputFormat, s.OutputTokenFormat)
@@ -99,12 +99,12 @@ func (s *TokensService) DeserializeToken(outputFormat token.Format, outputRaw []
 	return output, metadata, nil, nil
 }
 
-func (s *TokensService) GenConversionProof(ch driver.ConversionChallenge, tokens []token.LedgerToken) ([]byte, error) {
+func (s *TokensService) GenUpgradeProof(ch driver.TokenUpgradeChallenge, tokens []token.LedgerToken) ([]byte, error) {
 	// TODO: implement
 	return nil, nil
 }
 
-func (s *TokensService) CheckConversionProof(ch driver.ConversionChallenge, proof driver.ConversionProof, tokens []token.LedgerToken) (bool, error) {
+func (s *TokensService) CheckUpgradeProof(ch driver.TokenUpgradeChallenge, proof driver.TokenUpgradeProof, tokens []token.LedgerToken) (bool, error) {
 	// TODO: implement
 	return true, nil
 }
@@ -161,15 +161,15 @@ func supportedTokenFormat(pp *crypto.PublicParams) (token.Format, error) {
 
 func (s *TokensService) ProcessTokenConversionRequest(utp *driver.TokenConversionRequest) ([]token.Type, []uint64, error) {
 	if utp == nil {
-		return nil, nil, errors.New("nil token conversion request")
+		return nil, nil, errors.New("nil token upgrade request")
 	}
 
-	ok, err := s.CheckConversionProof(utp.Challenge, utp.Proof, utp.Tokens)
+	ok, err := s.CheckUpgradeProof(utp.Challenge, utp.Proof, utp.Tokens)
 	if err != nil {
-		return nil, nil, errors.Wrap(err, "failed to check conversion proof")
+		return nil, nil, errors.Wrap(err, "failed to check upgrade proof")
 	}
 	if !ok {
-		return nil, nil, errors.New("invalid conversion proof")
+		return nil, nil, errors.New("invalid upgrade proof")
 	}
 
 	var tokenTypes []token.Type

token/driver/issue.go

@@ -15,11 +15,11 @@ import (
 // TokenConversionRequest is a request to convert tokens
 type TokenConversionRequest struct {
 	// Challenge is a challenge to be solved by the prover
-	Challenge ConversionChallenge
+	Challenge TokenUpgradeChallenge
 	// Tokens is a list of tokens to be converted
 	Tokens []token.LedgerToken
 	// Proof is a proof that the prover has solved the challenge
-	Proof ConversionProof
+	Proof TokenUpgradeProof
 }
 
 // IssueOptions models the options that can be passed to the issue command