fixup! Register optional dig dependency

Signed-off-by: Alexandros Filios <[email protected]>

Author: alexandrosfilios

Diff for: platform/fabric/fns.go

@@ -23,9 +23,6 @@ var (
 	logger                     = logging.MustGetLogger("fabric-sdk")
 )
 
-const DefaultNetwork = ""
-const DefaultChannel = ""
-
 // NetworkService models a Fabric Network
 type NetworkService struct {
 	subscriber events.Subscriber
@@ -189,7 +186,7 @@ func GetFabricNetworkService(sp view2.ServiceProvider, id string) (*NetworkServi
 
 // GetDefaultFNS returns the default Fabric Network Service
 func GetDefaultFNS(sp view2.ServiceProvider) (*NetworkService, error) {
-	return GetFabricNetworkService(sp, DefaultNetwork)
+	return GetFabricNetworkService(sp, "")
 }
 
 // GetDefaultChannel returns the default channel of the default fns

Diff for: platform/fabric/services/state/helpers.go

@@ -21,29 +21,34 @@ func GetVaultService(ctx view2.ServiceProvider) (VaultService, error) {
 	return s.(VaultService), nil
 }
 
-func GetVault(ctx view2.ServiceProvider, opts ...ServiceOption) (Vault, error) {
-	opt, err := CompileServiceOptions(opts...)
-	if err != nil {
-		return nil, err
-	}
+func GetVault(ctx view2.ServiceProvider) (Vault, error) {
 	vs, err := GetVaultService(ctx)
 	if err != nil {
 		return nil, err
 	}
-	if len(opt.Network) > 0 && len(opt.Channel) > 0 {
-		return vs.Vault(opt.Network, opt.Channel)
-	}
-	fns, err := fabric.GetFabricNetworkService(ctx, opt.Network)
+	fsc, ch, err := fabric.GetDefaultChannel(ctx)
 	if err != nil {
 		return nil, err
 	}
-	ch, err := fns.Channel(opt.Channel)
+	ws, err := vs.Vault(fsc.Name(), ch.Name())
 	if err != nil {
 		return nil, err
 	}
-	return vs.Vault(fns.Name(), ch.Name())
+	return ws, nil
 }
 
 func GetVaultForChannel(ctx view2.ServiceProvider, channel string) (Vault, error) {
-	return GetVault(ctx, WithChannel(channel))
+	vs, err := GetVaultService(ctx)
+	if err != nil {
+		return nil, err
+	}
+	fns, err := fabric.GetDefaultFNS(ctx)
+	if err != nil {
+		return nil, err
+	}
+	ws, err := vs.Vault(fns.Name(), channel)
+	if err != nil {
+		return nil, err
+	}
+	return ws, nil
 }

Diff for: platform/fabric/services/state/recipients.go

@@ -10,10 +10,8 @@ import (
 	"encoding/json"
 	"time"
 
-	"github.com/hyperledger-labs/fabric-smart-client/platform/common/utils"
 	"github.com/hyperledger-labs/fabric-smart-client/platform/fabric"
 	view2 "github.com/hyperledger-labs/fabric-smart-client/platform/view"
-	"github.com/hyperledger-labs/fabric-smart-client/platform/view/driver"
 	session2 "github.com/hyperledger-labs/fabric-smart-client/platform/view/services/session"
 	"github.com/hyperledger-labs/fabric-smart-client/platform/view/view"
 	"github.com/pkg/errors"
@@ -200,9 +198,6 @@ type ExchangeRecipientIdentitiesView struct {
 	Network       string
 	IdentityLabel string
 	Other         view.Identity
-
-	fnsProvider *fabric.NetworkServiceProvider
-	binder      driver.EndpointService
 }
 
 // ExchangeRecipientIdentities runs the ExchangeRecipientIdentitiesView against the passed receiver.
@@ -216,9 +211,6 @@ func ExchangeRecipientIdentities(context view.Context, recipient view.Identity,
 		Network:       opt.Network,
 		Other:         recipient,
 		IdentityLabel: opt.Identity,
-
-		fnsProvider: utils.MustGet(fabric.GetNetworkServiceProvider(context)),
-		binder:      driver.GetEndpointService(context),
 	})
 	if err != nil {
 		return nil, nil, err
@@ -233,7 +225,7 @@ func (f *ExchangeRecipientIdentitiesView) Call(context view.Context) (interface{
 		return nil, err
 	}
 
-	fns, err := f.fnsProvider.FabricNetworkService(f.Network)
+	fns, err := fabric.GetFabricNetworkService(context, f.Network)
 	if err != nil {
 		return nil, err
 	}
@@ -278,58 +270,25 @@ func (f *ExchangeRecipientIdentitiesView) Call(context view.Context) (interface{
 
 	// Update the Endpoint Resolver
 	logger.Debugf("bind [%s] to other [%s]", recipientData.Identity, f.Other)
-	err = f.binder.Bind(f.Other, recipientData.Identity)
+	resolver := view2.GetEndpointService(context)
+	err = resolver.Bind(f.Other, recipientData.Identity)
 	if err != nil {
 		return nil, err
 	}
 
 	logger.Debugf("bind me [%s] to [%s]", me, context.Me())
-	err = f.binder.Bind(context.Me(), me)
+	err = resolver.Bind(context.Me(), me)
 	if err != nil {
 		return nil, err
 	}
 
 	return []view.Identity{me, recipientData.Identity}, nil
 }
 
-type ExchangeRecipientIdentitiesViewFactory struct {
-	fnsProvider *fabric.NetworkServiceProvider
-	binder      driver.EndpointService
-}
-
-func NewExchangeRecipientIdentitiesViewFactory(
-	fnsProvider *fabric.NetworkServiceProvider,
-	binder driver.EndpointService,
-) *ExchangeRecipientIdentitiesViewFactory {
-	return &ExchangeRecipientIdentitiesViewFactory{
-		fnsProvider: fnsProvider,
-		binder:      binder,
-	}
-
-}
-
-func (f *ExchangeRecipientIdentitiesViewFactory) New(recipient view.Identity, opts ...ServiceOption) (view.View, error) {
-	opt, err := CompileServiceOptions(opts...)
-	if err != nil {
-		return nil, errors.Wrapf(err, "failed to compile service options")
-	}
-	return &ExchangeRecipientIdentitiesView{
-		Network:       opt.Network,
-		Other:         recipient,
-		IdentityLabel: opt.Identity,
-
-		fnsProvider: f.fnsProvider,
-		binder:      f.binder,
-	}, nil
-}
-
 // RespondExchangeRecipientIdentitiesView models the view of the responder of an exchange of recipient identities.
 type RespondExchangeRecipientIdentitiesView struct {
 	Network       string
 	IdentityLabel string
-
-	fnsProvider *fabric.NetworkServiceProvider
-	binder      driver.EndpointService
 }
 
 // RespondExchangeRecipientIdentities runs the RespondExchangeRecipientIdentitiesView
@@ -341,9 +300,6 @@ func RespondExchangeRecipientIdentities(context view.Context, opts ...ServiceOpt
 	ids, err := context.RunView(&RespondExchangeRecipientIdentitiesView{
 		Network:       opt.Network,
 		IdentityLabel: opt.Identity,
-
-		fnsProvider: utils.MustGet(fabric.GetNetworkServiceProvider(context)),
-		binder:      driver.GetEndpointService(context),
 	})
 	if err != nil {
 		return nil, nil, err
@@ -364,7 +320,7 @@ func (s *RespondExchangeRecipientIdentitiesView) Call(context view.Context) (int
 		return nil, err
 	}
 
-	fns, err := s.fnsProvider.FabricNetworkService(s.Network)
+	fns, err := fabric.GetFabricNetworkService(context, s.Network)
 	if err != nil {
 		return nil, err
 	}
@@ -396,43 +352,15 @@ func (s *RespondExchangeRecipientIdentitiesView) Call(context view.Context) (int
 	}
 
 	// Update the Endpoint Resolver
-	err = s.binder.Bind(context.Me(), me)
+	resolver := view2.GetEndpointService(context)
+	err = resolver.Bind(context.Me(), me)
 	if err != nil {
 		return nil, err
 	}
-	err = s.binder.Bind(session.Info().Caller, other)
+	err = resolver.Bind(session.Info().Caller, other)
 	if err != nil {
 		return nil, err
 	}
 
 	return []view.Identity{me, other}, nil
 }
-
-type RespondExchangeRecipientIdentitiesViewFactory struct {
-	fnsProvider *fabric.NetworkServiceProvider
-	binder      driver.EndpointService
-}
-
-func NewRespondExchangeRecipientIdentitiesViewFactory(
-	fnsProvider *fabric.NetworkServiceProvider,
-	binder driver.EndpointService,
-) *RespondExchangeRecipientIdentitiesViewFactory {
-	return &RespondExchangeRecipientIdentitiesViewFactory{
-		fnsProvider: fnsProvider,
-		binder:      binder,
-	}
-}
-
-func (f *RespondExchangeRecipientIdentitiesViewFactory) New(opts ...ServiceOption) (*RespondExchangeRecipientIdentitiesView, error) {
-	opt, err := CompileServiceOptions(opts...)
-	if err != nil {
-		return nil, errors.Wrapf(err, "failed to compile service options")
-	}
-	return &RespondExchangeRecipientIdentitiesView{
-		Network:       opt.Network,
-		IdentityLabel: opt.Identity,
-
-		fnsProvider: f.fnsProvider,
-		binder:      f.binder,
-	}, nil
-}

Diff for: platform/fabric/services/state/transaction.go

@@ -62,7 +62,7 @@ func NewAnonymousTransaction(context view.Context) (*Transaction, error) {
 // NewAnonymousTransaction returns a new instance of a state-based transaction that embeds a single namespace and is signed
 // by an anonymous identity
 func newAnonymousTransaction(fnsProvider *fabric.NetworkServiceProvider, context view.Context) (*Transaction, error) {
-	fns, err := fnsProvider.FabricNetworkService(fabric.DefaultNetwork)
+	fns, err := fnsProvider.FabricNetworkService("")
 	if err != nil {
 		return nil, err
 	}

Diff for: platform/view/core/manager/context.go

@@ -24,6 +24,18 @@ import (
 	"go.uber.org/zap/zapcore"
 )
 
+type sigService interface {
+	// IsMe returns true if a signer was ever registered for the passed identity
+	IsMe(identity view.Identity) bool
+}
+
+type identityProvider interface {
+	// DefaultIdentity returns the default identity known by this provider
+	DefaultIdentity() view.Identity
+	// Identity returns the identity bound to the passed label
+	Identity(label string) view.Identity
+}
+
 type ctx struct {
 	context        context.Context
 	sp             driver.ServiceProvider
@@ -40,8 +52,8 @@ type ctx struct {
 	sessions           map[string]view.Session
 	errorCallbackFuncs []func()
 
-	identityProvider driver.IdentityProvider
-	sigService       driver.SigService
+	identityProvider identityProvider
+	sigService       sigService
 	tracer           trace.Tracer
 }
 
@@ -55,7 +67,7 @@ func (ctx *ctx) StartSpanFrom(c context.Context, name string, opts ...trace.Span
 	return ctx.tracer.Start(c, name, opts...)
 }
 
-func NewContextForInitiator(contextID string, context context.Context, sp driver.ServiceProvider, sessionFactory SessionFactory, resolver driver.EndpointService, identityProvider driver.IdentityProvider, sigService driver.SigService, party view.Identity, initiator view.View, tracer trace.Tracer) (*ctx, error) {
+func NewContextForInitiator(contextID string, context context.Context, sp driver.ServiceProvider, sessionFactory SessionFactory, resolver driver.EndpointService, identityProvider identityProvider, sigService sigService, party view.Identity, initiator view.View, tracer trace.Tracer) (*ctx, error) {
 	if len(contextID) == 0 {
 		contextID = GenerateUUID()
 	}
@@ -68,7 +80,7 @@ func NewContextForInitiator(contextID string, context context.Context, sp driver
 	return ctx, nil
 }
 
-func NewContext(context context.Context, sp driver.ServiceProvider, contextID string, sessionFactory SessionFactory, resolver driver.EndpointService, identityProvider driver.IdentityProvider, sigService driver.SigService, party view.Identity, session view.Session, caller view.Identity, tracer trace.Tracer) (*ctx, error) {
+func NewContext(context context.Context, sp driver.ServiceProvider, contextID string, sessionFactory SessionFactory, resolver driver.EndpointService, identityProvider identityProvider, sigService sigService, party view.Identity, session view.Session, caller view.Identity, tracer trace.Tracer) (*ctx, error) {
 	ctx := &ctx{
 		context:        context,
 		id:             contextID,

Diff for: platform/view/core/manager/manager.go

@@ -37,8 +37,8 @@ type manager struct {
 
 	commLayer        CommLayer
 	endpointService  driver.EndpointService
-	identityProvider driver.IdentityProvider
-	sigService       driver.SigService
+	identityProvider identityProvider
+	sigService       sigService
 
 	ctx context.Context