some refactoring + pp.PublicParameters proto usage

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

cmd/tokengen/cobra/certfier/keypairgen.go

@@ -11,9 +11,9 @@ import (
 	"os"
 	"path/filepath"
 
+	driver2 "github.com/hyperledger-labs/fabric-token-sdk/token/core"
 	fabtoken "github.com/hyperledger-labs/fabric-token-sdk/token/core/fabtoken/driver"
 	dlog "github.com/hyperledger-labs/fabric-token-sdk/token/core/zkatdlog/nogh/driver"
-	driver2 "github.com/hyperledger-labs/fabric-token-sdk/token/driver"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 )

cmd/tokengen/cobra/pp/printpp/print.go

@@ -10,9 +10,9 @@ import (
 	"fmt"
 	"os"
 
+	"github.com/hyperledger-labs/fabric-token-sdk/token/core"
 	fabtoken "github.com/hyperledger-labs/fabric-token-sdk/token/core/fabtoken/driver"
 	dlog "github.com/hyperledger-labs/fabric-token-sdk/token/core/zkatdlog/nogh/driver"
-	"github.com/hyperledger-labs/fabric-token-sdk/token/driver"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 )
@@ -62,7 +62,7 @@ func Print(args *Args) error {
 	if err != nil {
 		return errors.Wrapf(err, "failed to read file at [%s]", args.InputFile)
 	}
-	s := driver.NewPPManagerFactoryService(fabtoken.NewPPMFactory(), dlog.NewPPMFactory())
+	s := core.NewPPManagerFactoryService(fabtoken.NewPPMFactory(), dlog.NewPPMFactory())
 	pp, err := s.PublicParametersFromBytes(raw)
 	if err != nil {
 		return errors.Wrapf(err, "failed to unmarshal pp from [%s]", args.InputFile)

cmd/tokengen/main_test.go

@@ -13,10 +13,10 @@ import (
 	"testing"
 
 	"github.com/hyperledger-labs/fabric-token-sdk/cmd/tokengen/cobra/pp/common"
+	"github.com/hyperledger-labs/fabric-token-sdk/token/core"
 	fabtoken "github.com/hyperledger-labs/fabric-token-sdk/token/core/fabtoken/driver"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/core/zkatdlog/crypto"
 	dlog "github.com/hyperledger-labs/fabric-token-sdk/token/core/zkatdlog/nogh/driver"
-	"github.com/hyperledger-labs/fabric-token-sdk/token/driver"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/msp"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/services/utils/slices"
 	. "github.com/onsi/gomega"
@@ -221,7 +221,7 @@ func TestGenFailure(t *testing.T) {
 	testGenRun(gt, tokengen, []string{"gen", "fabtoken", "--output", tempOutput})
 	raw, err := os.ReadFile(filepath.Join(tempOutput, "fabtoken_pp.json"))
 	gt.Expect(err).NotTo(HaveOccurred())
-	is := driver.NewPPManagerFactoryService(fabtoken.NewPPMFactory(), dlog.NewPPMFactory())
+	is := core.NewPPManagerFactoryService(fabtoken.NewPPMFactory(), dlog.NewPPMFactory())
 	pp, err := is.PublicParametersFromBytes(raw)
 	gt.Expect(err).NotTo(HaveOccurred())
 	_, err = is.DefaultValidator(pp)

integration/token/fungible/views/info.go

@@ -13,9 +13,9 @@ import (
 	"github.com/hyperledger-labs/fabric-smart-client/platform/view/services/hash"
 	"github.com/hyperledger-labs/fabric-smart-client/platform/view/view"
 	"github.com/hyperledger-labs/fabric-token-sdk/token"
+	"github.com/hyperledger-labs/fabric-token-sdk/token/core"
 	fabtoken "github.com/hyperledger-labs/fabric-token-sdk/token/core/fabtoken/driver"
 	dlog "github.com/hyperledger-labs/fabric-token-sdk/token/core/zkatdlog/nogh/driver"
-	"github.com/hyperledger-labs/fabric-token-sdk/token/driver"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/services/network"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/services/ttx"
 	token2 "github.com/hyperledger-labs/fabric-token-sdk/token/token"
@@ -72,7 +72,7 @@ func (p *CheckPublicParamsMatchView) Call(context view.Context) (interface{}, er
 
 	fetchedPPRaw, err := network.GetInstance(context, tms.Network(), tms.Channel()).FetchPublicParameters(tms.Namespace())
 	assert.NoError(err, "failed to fetch public params")
-	is := driver.NewPPManagerFactoryService(fabtoken.NewPPMFactory(), dlog.NewPPMFactory())
+	is := core.NewPPManagerFactoryService(fabtoken.NewPPMFactory(), dlog.NewPPMFactory())
 	pp, err := is.PublicParametersFromBytes(fetchedPPRaw)
 	assert.NoError(err, "failed deserializing public parameters")
 	assert.NotNil(pp)

integration/token/fungible/wmp.go

@@ -18,9 +18,9 @@ import (
 	token2 "github.com/hyperledger-labs/fabric-token-sdk/integration/nwo/token"
 	topology2 "github.com/hyperledger-labs/fabric-token-sdk/integration/nwo/token/topology"
 	"github.com/hyperledger-labs/fabric-token-sdk/token"
+	"github.com/hyperledger-labs/fabric-token-sdk/token/core"
 	fabtoken "github.com/hyperledger-labs/fabric-token-sdk/token/core/fabtoken/driver"
 	dlog "github.com/hyperledger-labs/fabric-token-sdk/token/core/zkatdlog/nogh/driver"
-	"github.com/hyperledger-labs/fabric-token-sdk/token/driver"
 	identity2 "github.com/hyperledger-labs/fabric-token-sdk/token/sdk/identity"
 	config2 "github.com/hyperledger-labs/fabric-token-sdk/token/services/config"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/services/logging"
@@ -113,7 +113,7 @@ func (l *walletManagerLoader) Load(user string) *token.WalletManager {
 	kvss, err := kvs.NewWithConfig(&mem.Driver{}, "", configProvider)
 	Expect(err).ToNot(HaveOccurred())
 	storageProvider := identity2.NewKVSStorageProvider(kvss)
-	s := driver.NewWalletServiceFactoryService(
+	s := core.NewWalletServiceFactoryService(
 		fabtoken.NewWalletServiceFactory(storageProvider),
 		dlog.NewWalletServiceFactory(storageProvider))
 	tmsConfig, err := configService.ConfigurationFor(tms.Network, tms.Channel, tms.Namespace)

token/core/fabtoken/driver/base.go

@@ -7,6 +7,8 @@ SPDX-License-Identifier: Apache-2.0
 package driver
 
 import (
+	"github.com/hyperledger-labs/fabric-token-sdk/token/core"
+	"github.com/hyperledger-labs/fabric-token-sdk/token/core/common"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/core/fabtoken"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/driver"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/services/identity"
@@ -39,7 +41,7 @@ func (d *base) DefaultValidator(pp driver.PublicParameters) (driver.Validator, e
 }
 
 func (d *base) newWalletService(
-	tmsConfig driver.Config,
+	tmsConfig core.Config,
 	binder driver2.NetworkBinderService,
 	storageProvider identity.StorageProvider,
 	qe driver.QueryEngine,

token/core/fabtoken/driver/driver.go

@@ -10,6 +10,7 @@ import (
 	"github.com/hyperledger-labs/fabric-smart-client/platform/view"
 	"github.com/hyperledger-labs/fabric-smart-client/platform/view/services/hash"
 	view2 "github.com/hyperledger-labs/fabric-smart-client/platform/view/services/server/view"
+	"github.com/hyperledger-labs/fabric-token-sdk/token/core"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/core/common"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/core/common/metrics"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/core/fabtoken"
@@ -43,8 +44,8 @@ func NewDriver(
 	identityProvider view2.IdentityProvider,
 	endpointService *view.EndpointService,
 	networkProvider *network.Provider,
-) driver.NamedFactory[driver.Driver] {
-	return driver.NamedFactory[driver.Driver]{
+) core.NamedFactory[driver.Driver] {
+	return core.NamedFactory[driver.Driver]{
 		Name: fabtoken.PublicParameters,
 		Driver: &Driver{
 			base:             &base{},

token/core/fabtoken/driver/ppm_factory.go

@@ -7,6 +7,7 @@ SPDX-License-Identifier: Apache-2.0
 package driver
 
 import (
+	"github.com/hyperledger-labs/fabric-token-sdk/token/core"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/core/common"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/core/fabtoken"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/driver"
@@ -16,8 +17,8 @@ import (
 // PPMFactory contains the static logic of the driver
 type PPMFactory struct{ *base }
 
-func NewPPMFactory() driver.NamedFactory[driver.PPMFactory] {
-	return driver.NamedFactory[driver.PPMFactory]{
+func NewPPMFactory() core.NamedFactory[driver.PPMFactory] {
+	return core.NamedFactory[driver.PPMFactory]{
 		Name:   fabtoken.PublicParameters,
 		Driver: &PPMFactory{},
 	}

token/core/fabtoken/driver/ws_factory.go

@@ -7,6 +7,7 @@ SPDX-License-Identifier: Apache-2.0
 package driver
 
 import (
+	"github.com/hyperledger-labs/fabric-token-sdk/token/core"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/core/fabtoken"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/driver"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/services/identity"
@@ -19,14 +20,14 @@ type WalletServiceFactory struct {
 	storageProvider identity.StorageProvider
 }
 
-func NewWalletServiceFactory(storageProvider identity.StorageProvider) driver.NamedFactory[driver.WalletServiceFactory] {
-	return driver.NamedFactory[driver.WalletServiceFactory]{
+func NewWalletServiceFactory(storageProvider identity.StorageProvider) core.NamedFactory[driver.WalletServiceFactory] {
+	return core.NamedFactory[driver.WalletServiceFactory]{
 		Name:   fabtoken.PublicParameters,
 		Driver: &WalletServiceFactory{storageProvider: storageProvider},
 	}
 }
 
-func (d *WalletServiceFactory) NewWalletService(tmsConfig driver.Config, pp driver.PublicParameters) (driver.WalletService, error) {
+func (d *WalletServiceFactory) NewWalletService(tmsConfig driver.Configuration, params driver.PublicParameters) (driver.WalletService, error) {
 	tmsID := tmsConfig.ID()
 	logger := logging.DriverLogger("token-sdk.driver.fabtoken", tmsID.Network, tmsID.Channel, tmsID.Namespace)
 	return d.base.newWalletService(
@@ -37,7 +38,7 @@ func (d *WalletServiceFactory) NewWalletService(tmsConfig driver.Config, pp driv
 		logger,
 		nil,
 		nil,
-		pp,
+		params,
 		true,
 	)
 }

token/core/fabtoken/setup.go

@@ -10,6 +10,7 @@ import (
 	"encoding/json"
 
 	"github.com/hyperledger-labs/fabric-token-sdk/token/driver"
+	pp2 "github.com/hyperledger-labs/fabric-token-sdk/token/driver/protos-go/pp"
 	"github.com/pkg/errors"
 )
 
@@ -100,20 +101,20 @@ func (pp *PublicParams) Serialize() ([]byte, error) {
 	if err != nil {
 		return nil, err
 	}
-	return json.Marshal(&driver.SerializedPublicParameters{
+	return json.Marshal(&pp2.PublicParameters{
 		Identifier: pp.Label,
 		Raw:        raw,
 	})
 }
 
 // Deserialize un-marshals the passed bytes into PublicParams
 func (pp *PublicParams) Deserialize(raw []byte) error {
-	publicParams := &driver.SerializedPublicParameters{}
+	publicParams := &pp2.PublicParameters{}
 	if err := json.Unmarshal(raw, publicParams); err != nil {
 		return err
 	}
 	if publicParams.Identifier != pp.Label {
-		return errors.Errorf("invalid identifier, expecting 'fabtoken', got [%s]", publicParams.Identifier)
+		return errors.Errorf("invalid identifier, expecting 'fabtoken', got [%s]", publicParams.Raw)
 	}
 	return json.Unmarshal(publicParams.Raw, pp)
 }

token/driver/service.go → token/core/service.go

@@ -4,22 +4,33 @@ Copyright IBM Corp. All Rights Reserved.
 SPDX-License-Identifier: Apache-2.0
 */
 
-package driver
+package core
 
 import (
+	"encoding/json"
+
+	"github.com/hyperledger-labs/fabric-token-sdk/token/driver"
+	"github.com/hyperledger-labs/fabric-token-sdk/token/driver/protos-go/pp"
 	"github.com/pkg/errors"
 )
 
+type Config interface {
+	ID() driver.TMSID
+	TranslatePath(path string) string
+	UnmarshalKey(key string, rawVal interface{}) error
+}
+
+type TokenDriverName string
 type NamedFactory[T any] struct {
 	Name   TokenDriverName
 	Driver T
 }
 
-type factoryDirectory[T PPReader] struct {
+type factoryDirectory[T driver.PPReader] struct {
 	factories map[TokenDriverName]T
 }
 
-func newFactoryDirectory[T PPReader](fs ...NamedFactory[T]) *factoryDirectory[T] {
+func newFactoryDirectory[T driver.PPReader](fs ...NamedFactory[T]) *factoryDirectory[T] {
 	factories := make(map[TokenDriverName]T, len(fs))
 	for _, f := range fs {
 		factories[f.Name] = f.Driver
@@ -30,7 +41,7 @@ func newFactoryDirectory[T PPReader](fs ...NamedFactory[T]) *factoryDirectory[T]
 // PublicParametersFromBytes unmarshals the bytes to a driver.PublicParameters instance.
 // The passed bytes are expected to encode a driver.SerializedPublicParameters instance.
 // If no driver is registered for the public params' identifier, it returns an error.
-func (s *factoryDirectory[T]) PublicParametersFromBytes(params []byte) (PublicParameters, error) {
+func (s *factoryDirectory[T]) PublicParametersFromBytes(params []byte) (driver.PublicParameters, error) {
 	pp, err := serializedPublicParametersFromBytes(params)
 	if err != nil {
 		return nil, errors.Wrapf(err, "failed unmarshalling public params")
@@ -43,47 +54,47 @@ func (s *factoryDirectory[T]) PublicParametersFromBytes(params []byte) (PublicPa
 }
 
 // serializedPublicParametersFromBytes returns a driver.SerializedPublicParameters instance from the passed bytes.
-func serializedPublicParametersFromBytes(raw []byte) (*SerializedPublicParameters, error) {
-	pp := &SerializedPublicParameters{}
-	if err := pp.Deserialize(raw); err != nil {
+func serializedPublicParametersFromBytes(raw []byte) (*pp.PublicParameters, error) {
+	pp := &pp.PublicParameters{}
+	if err := json.Unmarshal(raw, pp); err != nil {
 		return nil, errors.Wrap(err, "failed deserializing public parameters")
 	}
 	return pp, nil
 }
 
 type PPManagerFactoryService struct {
-	*factoryDirectory[PPMFactory]
+	*factoryDirectory[driver.PPMFactory]
 }
 
-func NewPPManagerFactoryService(instantiators ...NamedFactory[PPMFactory]) *PPManagerFactoryService {
+func NewPPManagerFactoryService(instantiators ...NamedFactory[driver.PPMFactory]) *PPManagerFactoryService {
 	return &PPManagerFactoryService{factoryDirectory: newFactoryDirectory(instantiators...)}
 }
 
 // NewPublicParametersManager returns a new instance of driver.PublicParamsManager for the passed parameters.
 // If no driver is registered for the public params' identifier, it returns an error
-func (s *PPManagerFactoryService) NewPublicParametersManager(pp PublicParameters) (PublicParamsManager, error) {
+func (s *PPManagerFactoryService) NewPublicParametersManager(pp driver.PublicParameters) (driver.PublicParamsManager, error) {
 	if instantiator, ok := s.factories[TokenDriverName(pp.Identifier())]; ok {
 		return instantiator.NewPublicParametersManager(pp)
 	}
 	return nil, errors.Errorf("cannot load public paramenters, driver [%s] not found", pp.Identifier())
 }
 
-func (s *PPManagerFactoryService) DefaultValidator(pp PublicParameters) (Validator, error) {
+func (s *PPManagerFactoryService) DefaultValidator(pp driver.PublicParameters) (driver.Validator, error) {
 	if instantiator, ok := s.factories[TokenDriverName(pp.Identifier())]; ok {
 		return instantiator.DefaultValidator(pp)
 	}
 	return nil, errors.Errorf("cannot load default validator, driver [%s] not found", pp.Identifier())
 }
 
 type WalletServiceFactoryService struct {
-	*factoryDirectory[WalletServiceFactory]
+	*factoryDirectory[driver.WalletServiceFactory]
 }
 
-func NewWalletServiceFactoryService(fs ...NamedFactory[WalletServiceFactory]) *WalletServiceFactoryService {
+func NewWalletServiceFactoryService(fs ...NamedFactory[driver.WalletServiceFactory]) *WalletServiceFactoryService {
 	return &WalletServiceFactoryService{factoryDirectory: newFactoryDirectory(fs...)}
 }
 
-func (s *WalletServiceFactoryService) NewWalletService(tmsConfig Config, ppRaw []byte) (WalletService, error) {
+func (s *WalletServiceFactoryService) NewWalletService(tmsConfig driver.Configuration, ppRaw []byte) (driver.WalletService, error) {
 	pp, err := s.PublicParametersFromBytes(ppRaw)
 	if err != nil {
 		return nil, err
@@ -95,14 +106,14 @@ func (s *WalletServiceFactoryService) NewWalletService(tmsConfig Config, ppRaw [
 }
 
 type TokenDriverService struct {
-	*factoryDirectory[Driver]
+	*factoryDirectory[driver.Driver]
 }
 
-func NewTokenDriverService(factories []NamedFactory[Driver]) *TokenDriverService {
+func NewTokenDriverService(factories []NamedFactory[driver.Driver]) *TokenDriverService {
 	return &TokenDriverService{factoryDirectory: newFactoryDirectory(factories...)}
 }
 
-func (s *TokenDriverService) NewTokenService(tmsID TMSID, publicParams []byte) (TokenManagerService, error) {
+func (s *TokenDriverService) NewTokenService(tmsID driver.TMSID, publicParams []byte) (driver.TokenManagerService, error) {
 	pp, err := s.PublicParametersFromBytes(publicParams)
 	if err != nil {
 		return nil, err
@@ -113,7 +124,7 @@ func (s *TokenDriverService) NewTokenService(tmsID TMSID, publicParams []byte) (
 	return nil, errors.Errorf("no token driver named '%s' found", TokenDriverName(pp.Identifier()))
 }
 
-func (s *TokenDriverService) NewDefaultValidator(pp PublicParameters) (Validator, error) {
+func (s *TokenDriverService) NewDefaultValidator(pp driver.PublicParameters) (driver.Validator, error) {
 	if driver, ok := s.factories[TokenDriverName(pp.Identifier())]; ok {
 		return driver.NewDefaultValidator(pp)
 	}
@@ -122,7 +133,7 @@ func (s *TokenDriverService) NewDefaultValidator(pp PublicParameters) (Validator
 
 var managerType = &TokenDriverService{}
 
-func GetTokenDriverService(sp ServiceProvider) (*TokenDriverService, error) {
+func GetTokenDriverService(sp driver.ServiceProvider) (*TokenDriverService, error) {
 	s, err := sp.GetService(managerType)
 	if err != nil {
 		return nil, errors.Wrapf(err, "failed to get token driver service")

token/core/tms.go

@@ -40,13 +40,13 @@ type TMSProvider struct {
 	configProvider     ConfigProvider
 	vault              Vault
 	callback           CallbackFunc
-	tokenDriverService *driver.TokenDriverService
+	tokenDriverService *TokenDriverService
 
 	lock     sync.RWMutex
 	services map[string]driver.TokenManagerService
 }
 
-func NewTMSProvider(logger logging.Logger, configProvider ConfigProvider, vault Vault, tokenDriverService *driver.TokenDriverService) *TMSProvider {
+func NewTMSProvider(logger logging.Logger, configProvider ConfigProvider, vault Vault, tokenDriverService *TokenDriverService) *TMSProvider {
 	ms := &TMSProvider{
 		logger:             logger,
 		configProvider:     configProvider,

token/core/zkatdlog/crypto/setup.go

@@ -16,6 +16,7 @@ import (
 	"github.com/hyperledger-labs/fabric-smart-client/platform/common/utils/collections"
 	math2 "github.com/hyperledger-labs/fabric-token-sdk/token/core/zkatdlog/crypto/math"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/driver"
+	pp2 "github.com/hyperledger-labs/fabric-token-sdk/token/driver/protos-go/pp"
 	"github.com/pkg/errors"
 )
 
@@ -178,7 +179,7 @@ func (pp *PublicParams) Serialize() ([]byte, error) {
 	if err != nil {
 		return nil, err
 	}
-	return json.Marshal(&driver.SerializedPublicParameters{
+	return json.Marshal(&pp2.PublicParameters{
 		Identifier: pp.Label,
 		Raw:        raw,
 	})
@@ -189,7 +190,7 @@ func (pp *PublicParams) Precision() uint64 {
 }
 
 func (pp *PublicParams) Deserialize(raw []byte) error {
-	publicParams := &driver.SerializedPublicParameters{}
+	publicParams := &pp2.PublicParameters{}
 	if err := json.Unmarshal(raw, publicParams); err != nil {
 		return err
 	}