Refactored wallet registry

integration/token/fungible/wmp.go

@@ -9,6 +9,8 @@ package fungible
 import (
 	"path/filepath"
 
+	identity2 "github.com/hyperledger-labs/fabric-token-sdk/token/sdk/identity"
+
 	"github.com/hyperledger-labs/fabric-smart-client/integration"
 	"github.com/hyperledger-labs/fabric-smart-client/platform/view/core/config"
 	"github.com/hyperledger-labs/fabric-smart-client/platform/view/core/sig"
@@ -111,9 +113,10 @@ func (l *walletManagerLoader) Load(user string) *token.WalletManager {
 	Expect(sp.RegisterService(dm)).ToNot(HaveOccurred())
 	kvss, err := kvs.NewWithConfig(sp, "memory", "", configProvider)
 	Expect(err).ToNot(HaveOccurred())
-	Expect(sp.RegisterService(kvss))
+	Expect(sp.RegisterService(kvss)).ToNot(HaveOccurred())
 	sigService := sig.NewSignService(sp, nil, kvss)
-	Expect(sp.RegisterService(sigService))
+	Expect(sp.RegisterService(sigService)).ToNot(HaveOccurred())
+	Expect(sp.RegisterService(identity2.NewKVSStorageProvider(sp))).ToNot(HaveOccurred())
 
 	wm, err := token.NewWalletManager(sp, tms.Network, tms.Channel, tms.Namespace, ppRaw)
 	Expect(err).ToNot(HaveOccurred())

token/core/fabtoken/driver/driver.go

@@ -96,13 +96,20 @@ func (d *Driver) NewTokenService(sp view.ServiceProvider, publicParamsFetcher dr
 		Channel:   channel,
 		Namespace: namespace,
 	}
+	storageProvider, err := identity.GetStorageProvider(sp)
+	if err != nil {
+		return nil, errors.Wrapf(err, "failed to get identity storage provider")
+	}
+	identityStorage, err := storageProvider.New(tmsID)
+	if err != nil {
+		return nil, errors.Wrapf(err, "failed to get identity storage provider")
+	}
 	ws := fabtoken.NewWalletService(
-		tmsID,
 		msp.NewSigService(view.GetSigService(sp)),
 		identity.NewProvider(view.GetSigService(sp), view.GetEndpointService(sp), fscIdentity, fabtoken.NewEnrollmentIDDeserializer(), wallets),
 		qe,
 		fabtoken.NewDeserializer(),
-		kvs.GetService(sp),
+		identityStorage,
 	)
 
 	service := fabtoken.NewService(
@@ -195,13 +202,20 @@ func (d *Driver) NewWalletService(sp view.ServiceProvider, networkID string, cha
 		Namespace: namespace,
 	}
 	// wallet service
+	storageProvider, err := identity.GetStorageProvider(sp)
+	if err != nil {
+		return nil, errors.Wrapf(err, "failed to get identity storage provider")
+	}
+	identityStorage, err := storageProvider.New(tmsID)
+	if err != nil {
+		return nil, errors.Wrapf(err, "failed to get identity storage provider")
+	}
 	ws := fabtoken.NewWalletService(
-		tmsID,
 		msp.NewSigService(view.GetSigService(sp)),
 		identity.NewProvider(view.GetSigService(sp), nil, nil, fabtoken.NewEnrollmentIDDeserializer(), wallets),
 		nil,
 		fabtoken.NewDeserializer(),
-		kvs.GetService(sp),
+		identityStorage,
 	)
 
 	return ws, nil

token/core/fabtoken/service.go

@@ -7,7 +7,6 @@ SPDX-License-Identifier: Apache-2.0
 package fabtoken
 
 import (
-	"github.com/hyperledger-labs/fabric-smart-client/platform/view/services/kvs"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/driver"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/driver/config"
 	token2 "github.com/hyperledger-labs/fabric-token-sdk/token/token"
@@ -32,13 +31,6 @@ type PublicParametersManager interface {
 	PublicParams() *PublicParams
 }
 
-type KVS interface {
-	Exists(id string) bool
-	Put(id string, state interface{}) error
-	Get(id string, state interface{}) error
-	GetByPartialCompositeID(prefix string, attrs []string) (kvs.Iterator, error)
-}
-
 type Service struct {
 	*WalletService
 	PPM         PublicParametersManager

token/core/fabtoken/wallet.go

@@ -9,7 +9,6 @@ package fabtoken
 import (
 	"github.com/hyperledger-labs/fabric-smart-client/platform/view/services/hash"
 	"github.com/hyperledger-labs/fabric-smart-client/platform/view/view"
-	token2 "github.com/hyperledger-labs/fabric-token-sdk/token"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/core/identity"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/core/identity/msp/common"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/driver"
@@ -34,21 +33,20 @@ type WalletService struct {
 }
 
 func NewWalletService(
-	tmsID token2.TMSID,
 	SignerService common.SignerService,
 	identityProvider driver.IdentityProvider,
 	walletServiceBacked WalletServiceBacked,
 	Deserializer driver.Deserializer,
-	kvs KVS,
+	store identity.Storage,
 ) *WalletService {
 	return &WalletService{
 		SignerService:          SignerService,
 		identityProvider:       identityProvider,
 		WalletServiceBacked:    walletServiceBacked,
 		Deserializer:           Deserializer,
-		OwnerWalletsRegistry:   identity.NewWalletsRegistry(tmsID, identityProvider, driver.OwnerRole, kvs),
-		IssuerWalletsRegistry:  identity.NewWalletsRegistry(tmsID, identityProvider, driver.IssuerRole, kvs),
-		AuditorWalletsRegistry: identity.NewWalletsRegistry(tmsID, identityProvider, driver.AuditorRole, kvs),
+		OwnerWalletsRegistry:   identity.NewWalletsRegistry(identityProvider, driver.OwnerRole, store),
+		IssuerWalletsRegistry:  identity.NewWalletsRegistry(identityProvider, driver.IssuerRole, store),
+		AuditorWalletsRegistry: identity.NewWalletsRegistry(identityProvider, driver.AuditorRole, store),
 	}
 }
 

token/core/identity/kvs/store.go

@@ -0,0 +1,90 @@
+/*
+Copyright IBM Corp. All Rights Reserved.
+
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package kvs
+
+import (
+	"fmt"
+
+	"github.com/hyperledger-labs/fabric-token-sdk/token/core/identity"
+
+	"github.com/hyperledger-labs/fabric-smart-client/platform/view/services/kvs"
+	"github.com/hyperledger-labs/fabric-smart-client/platform/view/view"
+	"github.com/hyperledger-labs/fabric-token-sdk/token"
+	"github.com/pkg/errors"
+)
+
+type KVS interface {
+	Exists(id string) bool
+	Put(id string, state interface{}) error
+	Get(id string, state interface{}) error
+	GetByPartialCompositeID(prefix string, attrs []string) (kvs.Iterator, error)
+}
+
+type IdentityStorage struct {
+	kvs   KVS
+	tmsID token.TMSID
+}
+
+func NewIdentityStorage(kvs KVS, tmsID token.TMSID) *IdentityStorage {
+	return &IdentityStorage{kvs: kvs, tmsID: tmsID}
+}
+
+func (s *IdentityStorage) StoreWalletID(wID identity.WalletID) error {
+	return s.kvs.Put(kvs.CreateCompositeKeyOrPanic("wallets", []string{s.tmsID.Network, s.tmsID.Channel, s.tmsID.Namespace, wID}), wID)
+}
+
+func (s *IdentityStorage) GetWalletID(id view.Identity) (identity.WalletID, error) {
+	var wID identity.WalletID
+	if err := s.kvs.Get(id.Hash(), &wID); err != nil {
+		return "", err
+	}
+	return wID, nil
+}
+
+func (s *IdentityStorage) GetWalletIDs() ([]identity.WalletID, error) {
+	it, err := s.kvs.GetByPartialCompositeID("wallets", []string{s.tmsID.Network, s.tmsID.Channel, s.tmsID.Namespace})
+	if err != nil {
+		return nil, errors.Wrapf(err, "failed to get wallets iterator")
+	}
+	var walletIDs []string
+	for it.HasNext() {
+		var wID string
+		if _, err := it.Next(&wID); err != nil {
+			return nil, errors.Wrapf(err, "failed to get next wallets from iterator")
+		}
+		walletIDs = append(walletIDs, wID)
+	}
+	return walletIDs, nil
+}
+
+func (s *IdentityStorage) StoreIdentity(identity view.Identity, wID identity.WalletID, meta any) error {
+	idHash := identity.Hash()
+	if err := s.kvs.Put(idHash, wID); err != nil {
+		return errors.WithMessagef(err, "failed to store identity's wallet [%s]", identity)
+	}
+	if meta != nil {
+		if err := s.kvs.Put("meta"+idHash, meta); err != nil {
+			return errors.WithMessagef(err, "failed to store identity's metadata [%s]", identity)
+		}
+	}
+	if err := s.kvs.Put(s.walletPrefix(wID)+idHash, wID); err != nil {
+		return errors.WithMessagef(err, "failed to store identity's wallet reference[%s]", identity)
+	}
+	return nil
+}
+
+func (s *IdentityStorage) LoadMeta(identity view.Identity, meta any) error {
+	return s.kvs.Get("meta"+identity.Hash(), meta)
+}
+
+func (s *IdentityStorage) IdentityExists(identity view.Identity, wID identity.WalletID) bool {
+	return s.kvs.Exists(s.walletPrefix(wID) + identity.Hash())
+}
+
+func (s *IdentityStorage) walletPrefix(wID identity.WalletID) string {
+	return fmt.Sprintf("%s-%s-%s-%s", s.tmsID.Network, s.tmsID.Channel, s.tmsID.Namespace, wID)
+}