ttx service: create TxAuditor from the TMSID (#1267)

Signed-off-by: Angelo De Caro <adc@zurich.ibm.com>

Author: adecaro

token/sdk/dig/sdk.go

@@ -53,6 +53,7 @@ import (
 	"github.com/hyperledger-labs/fabric-token-sdk/token/services/tokens"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/services/ttx"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/services/ttx/dep"
+	auditor2 "github.com/hyperledger-labs/fabric-token-sdk/token/services/ttx/dep/auditor"
 	wrapper2 "github.com/hyperledger-labs/fabric-token-sdk/token/services/ttx/dep/wrapper"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/services/ttxdb"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/services/walletdb"
@@ -174,6 +175,7 @@ func (p *SDK) Install() error {
 
 		// ttx service
 		p.Container().Provide(wrapper2.NewTokenManagementServiceProvider, dig.As(new(dep.TokenManagementServiceProvider))),
+		p.Container().Provide(wrapper2.NewAuditServiceProvider, dig.As(new(auditor2.ServiceProvider))),
 		p.Container().Provide(wrapper2.NewNetworkProvider, dig.As(new(dep.NetworkProvider))),
 		p.Container().Provide(wrapper2.NewNetworkIdentityProvider),
 		p.Container().Provide(digutils.Identity[*wrapper2.NetworkIdentityProvider](), dig.As(new(dep.NetworkIdentityProvider))),
@@ -225,6 +227,7 @@ func (p *SDK) Install() error {
 		digutils.Register[dep.NetworkProvider](p.Container()),
 		digutils.Register[*wrapper2.StorageProvider](p.Container()),
 		digutils.Register[*wrapper2.NetworkIdentityProvider](p.Container()),
+		digutils.Register[auditor2.ServiceProvider](p.Container()),
 	)
 	if err != nil {
 		return errors.WithMessagef(err, "failed setting backward comaptibility with SP")

token/services/auditdb/store.go

@@ -45,7 +45,7 @@ func NewStoreServiceManager(cp db.ConfigService, drivers multiplexed.Driver) Sto
 	return db.NewStoreServiceManager(cp, "auditdb.persistence", drivers.NewAuditTransaction, newStoreService)
 }
 
-func GetByTMSId(sp token.ServiceProvider, tmsID token.TMSID) (*StoreService, error) {
+func GetByTMSID(sp token.ServiceProvider, tmsID token.TMSID) (*StoreService, error) {
 	s, err := sp.GetService(managerType)
 	if err != nil {
 		return nil, errors.Wrapf(err, "failed to get manager service")

token/services/auditor/auditor.go

@@ -61,8 +61,8 @@ type CheckService interface {
 
 // Service is the interface for the auditor service
 type Service struct {
-	networkProvider NetworkProvider
 	tmsID           token.TMSID
+	networkProvider NetworkProvider
 	auditDB         *auditdb.StoreService
 	tokenDB         *tokens.Service
 	tmsProvider     dep.TokenManagementServiceProvider

token/services/auditor/manager.go

@@ -151,8 +151,3 @@ func GetByTMSID(sp token.ServiceProvider, tmsID token.TMSID) *Service {
 	}
 	return auditor
 }
-
-// New returns the Service instance for the passed auditor wallet
-func New(sp token.ServiceProvider, w *token.AuditorWallet) *Service {
-	return Get(sp, w)
-}

token/services/ttx/auditor.go

@@ -19,80 +19,80 @@ import (
 	"github.com/hyperledger-labs/fabric-token-sdk/token/services/auditor"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/services/db/driver"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/services/tokens"
-	"github.com/hyperledger-labs/fabric-token-sdk/token/services/ttxdb"
+	dauditor "github.com/hyperledger-labs/fabric-token-sdk/token/services/ttx/dep/auditor"
+	"github.com/hyperledger-labs/fabric-token-sdk/token/services/ttx/dep/db"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/services/utils"
 	session2 "github.com/hyperledger-labs/fabric-token-sdk/token/services/utils/json/session"
 	view3 "github.com/hyperledger-labs/fabric-token-sdk/token/services/utils/view"
 )
 
-type TxAuditor struct {
-	w                       *token.AuditorWallet
-	auditor                 *auditor.Service
-	auditDB                 *auditdb.StoreService
-	transactionInfoProvider *TransactionInfoProvider
+// Auditor wraps the functionalities of the auditor service and the audit db for the ttx service
+type Auditor struct {
+	dauditor.Service
+	dauditor.StoreService
 }
 
-func NewAuditor(sp token.ServiceProvider, w *token.AuditorWallet) (*TxAuditor, error) {
-	backend := auditor.New(sp, w)
-	auditDB, err := auditdb.GetByTMSId(sp, w.TMS().ID())
+// NewAuditorFromTMSID returns a new Auditor for the given TMS ID
+func NewAuditorFromTMSID(sp token.ServiceProvider, tmsID token.TMSID) (*Auditor, error) {
+	auditServiceProvider, err := dauditor.GetServiceProvider(sp)
 	if err != nil {
-		return nil, err
+		return nil, errors.Join(ErrProvider, err)
 	}
-	ttxDB, err := ttxdb.GetByTMSId(sp, w.TMS().ID())
+	auditService, auditStoreService, err := auditServiceProvider.AuditorService(tmsID)
 	if err != nil {
-		return nil, err
+		return nil, errors.Join(ErrProvider, err)
 	}
-	return NewTxAuditor(w, backend, auditDB, ttxDB), nil
+	return &Auditor{
+		Service:      auditService,
+		StoreService: auditStoreService,
+	}, nil
 }
 
-func NewTxAuditor(w *token.AuditorWallet, backend *auditor.Service, auditDB *auditdb.StoreService, ttxDB *ttxdb.StoreService) *TxAuditor {
-	return &TxAuditor{
-		w:                       w,
-		auditor:                 backend,
-		auditDB:                 auditDB,
-		transactionInfoProvider: newTransactionInfoProvider(w.TMS(), ttxDB),
-	}
+// NewAuditor returns a new Auditor for the given wallet.
+// This constructor uses NewAuditorFromTMSID with the wallet's TMSID.
+func NewAuditor(sp token.ServiceProvider, w *token.AuditorWallet) (*Auditor, error) {
+	return NewAuditorFromTMSID(sp, w.TMS().ID())
 }
 
-func (a *TxAuditor) Validate(tx *Transaction) error {
-	return a.auditor.Validate(tx.Context, tx.TokenRequest)
+func (a *Auditor) Validate(tx *Transaction) error {
+	return a.Service.Validate(tx.Context, tx.TokenRequest)
 }
 
-func (a *TxAuditor) Audit(ctx context.Context, tx *Transaction) (*token.InputStream, *token.OutputStream, error) {
-	return a.auditor.Audit(ctx, tx)
+func (a *Auditor) Audit(ctx context.Context, tx *Transaction) (*token.InputStream, *token.OutputStream, error) {
+	return a.Service.Audit(ctx, tx)
 }
 
 // Release unlocks the passed enrollment IDs.
-func (a *TxAuditor) Release(ctx context.Context, tx *Transaction) {
-	a.auditor.Release(ctx, tx)
+func (a *Auditor) Release(ctx context.Context, tx *Transaction) {
+	a.Service.Release(ctx, tx)
 }
 
 // Transactions returns an iterator of transaction records filtered by the given params.
-func (a *TxAuditor) Transactions(ctx context.Context, params QueryTransactionsParams, pagination Pagination) (*PageTransactionsIterator, error) {
-	return a.auditDB.Transactions(ctx, params, pagination)
+func (a *Auditor) Transactions(ctx context.Context, params db.QueryTransactionsParams, pagination db.Pagination) (*db.PageTransactionsIterator, error) {
+	return a.StoreService.Transactions(ctx, params, pagination)
 }
 
 // NewPaymentsFilter returns a programmable filter over the payments sent or received by enrollment IDs.
-func (a *TxAuditor) NewPaymentsFilter() *auditdb.PaymentsFilter {
-	return a.auditDB.NewPaymentsFilter()
+func (a *Auditor) NewPaymentsFilter() *auditdb.PaymentsFilter {
+	return a.StoreService.NewPaymentsFilter()
 }
 
 // NewHoldingsFilter returns a programmable filter over the holdings owned by enrollment IDs.
-func (a *TxAuditor) NewHoldingsFilter() *auditdb.HoldingsFilter {
-	return a.auditDB.NewHoldingsFilter()
+func (a *Auditor) NewHoldingsFilter() *auditdb.HoldingsFilter {
+	return a.StoreService.NewHoldingsFilter()
 }
 
 // SetStatus sets the status of the audit records with the passed transaction id to the passed status
-func (a *TxAuditor) SetStatus(ctx context.Context, txID string, status driver.TxStatus, message string) error {
-	return a.auditDB.SetStatus(ctx, txID, status, message)
+func (a *Auditor) SetStatus(ctx context.Context, txID string, status driver.TxStatus, message string) error {
+	return a.StoreService.SetStatus(ctx, txID, status, message)
 }
 
-func (a *TxAuditor) GetTokenRequest(ctx context.Context, txID string) ([]byte, error) {
-	return a.auditor.GetTokenRequest(ctx, txID)
+func (a *Auditor) GetTokenRequest(ctx context.Context, txID string) ([]byte, error) {
+	return a.Service.GetTokenRequest(ctx, txID)
 }
 
-func (a *TxAuditor) Check(ctx context.Context) ([]string, error) {
-	return a.auditor.Check(ctx)
+func (a *Auditor) Check(ctx context.Context) ([]string, error) {
+	return a.Service.Check(ctx)
 }
 
 type RegisterAuditorView struct {
@@ -271,7 +271,7 @@ func NewAuditApproveView(w *token.AuditorWallet, tx *Transaction) *AuditApproveV
 
 func (a *AuditApproveView) Call(context view.Context) (interface{}, error) {
 	// Append audit records
-	if err := auditor.New(context, a.w).Append(context.Context(), a.tx); err != nil {
+	if err := auditor.Get(context, a.w).Append(context.Context(), a.tx); err != nil {
 		return nil, errors.Wrapf(err, "failed appending audit records for transaction %s", a.tx.ID())
 	}
 

token/services/ttx/auditor_test.go

@@ -0,0 +1,53 @@
+/*
+Copyright IBM Corp. All Rights Reserved.
+
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package ttx_test
+
+import (
+	"testing"
+
+	"github.com/hyperledger-labs/fabric-smart-client/pkg/utils/errors"
+	"github.com/hyperledger-labs/fabric-token-sdk/token"
+	"github.com/hyperledger-labs/fabric-token-sdk/token/services/ttx"
+	mock2 "github.com/hyperledger-labs/fabric-token-sdk/token/services/ttx/dep/auditor/mock"
+	"github.com/hyperledger-labs/fabric-token-sdk/token/services/ttx/dep/mock"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestNewAuditorFromTMSID(t *testing.T) {
+	ctx := &mock.Context{}
+	tmsID := token.TMSID{
+		Network:   "a_network",
+		Channel:   "a_channel",
+		Namespace: "a_namespace",
+	}
+
+	// provider failer
+	ctx.GetServiceReturns(nil, errors.New("service provider error"))
+	_, err := ttx.NewAuditorFromTMSID(ctx, tmsID)
+	require.Error(t, err)
+	assert.ErrorIs(t, err, ttx.ErrProvider)
+	assert.Contains(t, err.Error(), "service provider error")
+
+	// register provider
+	auditServiceProvider := &mock2.AuditServiceProvider{}
+	auditServiceProvider.AuditorServiceReturns(nil, nil, errors.New("auditor service error"))
+	ctx.GetServiceReturns(auditServiceProvider, nil)
+	_, err = ttx.NewAuditorFromTMSID(ctx, tmsID)
+	require.Error(t, err)
+	assert.ErrorIs(t, err, ttx.ErrProvider)
+	assert.Contains(t, err.Error(), "auditor service error")
+
+	auditService := &mock2.AuditService{}
+	auditStoreService := &mock2.AuditStoreService{}
+	auditServiceProvider.AuditorServiceReturns(auditService, auditStoreService, nil)
+	auditor, err := ttx.NewAuditorFromTMSID(ctx, tmsID)
+	require.NoError(t, err)
+	assert.NotNil(t, auditor)
+	assert.Equal(t, auditService, auditor.Service)
+	assert.Equal(t, auditStoreService, auditor.StoreService)
+}

token/services/ttx/db.go

@@ -10,27 +10,28 @@ import (
 	"context"
 
 	"github.com/hyperledger-labs/fabric-smart-client/pkg/utils/errors"
-	driver2 "github.com/hyperledger-labs/fabric-smart-client/platform/common/driver"
 	"github.com/hyperledger-labs/fabric-smart-client/platform/view/services/tracing"
 	"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/services/db/driver"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/services/tokens"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/services/ttx/dep"
+	"github.com/hyperledger-labs/fabric-token-sdk/token/services/ttx/dep/db"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/services/ttx/finality"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/services/ttxdb"
 	"go.opentelemetry.io/otel/trace"
 )
 
-const txIdLabel tracing.LabelName = "tx_id"
-
-type QueryTransactionsParams = ttxdb.QueryTransactionsParams
-
-type Pagination = driver2.Pagination
-
-type TransactionRecord = driver.TransactionRecord
+type (
+	// TransactionRecord is a more finer-grained version of a movement record.
+	// Given a Token Transaction, for each token action in the Token Request,
+	// a transaction record is created for each unique enrollment ID found in the outputs.
+	// The transaction record contains the total amount of the token type that was transferred to/from that enrollment ID
+	// in that action.
+	TransactionRecord = db.TransactionRecord
+)
 
-type PageTransactionsIterator = driver2.PageIterator[*TransactionRecord]
+const txIdLabel tracing.LabelName = "tx_id"
 
 type CheckService interface {
 	Check(ctx context.Context) ([]string, error)

token/services/ttx/dep/auditor/auditor.go

@@ -0,0 +1,64 @@
+/*
+Copyright IBM Corp. All Rights Reserved.
+
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package auditor
+
+import (
+	"context"
+	"reflect"
+
+	"github.com/hyperledger-labs/fabric-token-sdk/token"
+	"github.com/hyperledger-labs/fabric-token-sdk/token/driver"
+	"github.com/hyperledger-labs/fabric-token-sdk/token/services/auditdb"
+	"github.com/hyperledger-labs/fabric-token-sdk/token/services/auditor"
+	"github.com/hyperledger-labs/fabric-token-sdk/token/services/ttx/dep/db"
+)
+
+var (
+	serviceProviderType = reflect.TypeOf((*ServiceProvider)(nil))
+)
+
+//go:generate counterfeiter -o mock/service.go -fake-name AuditService . Service
+
+// Service models the auditor service
+type Service interface {
+	Validate(ctx context.Context, request *token.Request) error
+	Audit(ctx context.Context, tx auditor.Transaction) (*token.InputStream, *token.OutputStream, error)
+	Release(ctx context.Context, tx auditor.Transaction)
+	GetTokenRequest(ctx context.Context, id string) ([]byte, error)
+	Check(ctx context.Context) ([]string, error)
+}
+
+//go:generate counterfeiter -o mock/store_service.go -fake-name AuditStoreService . StoreService
+
+// StoreService models the audit storage service
+type StoreService interface {
+	Transactions(ctx context.Context, params db.QueryTransactionsParams, pagination db.Pagination) (*db.PageTransactionsIterator, error)
+	NewPaymentsFilter() *auditdb.PaymentsFilter
+	NewHoldingsFilter() *auditdb.HoldingsFilter
+	SetStatus(ctx context.Context, id string, status driver.TxStatus, message string) error
+}
+
+//go:generate counterfeiter -o mock/service_provider.go -fake-name AuditServiceProvider . ServiceProvider
+
+// ServiceProvider provides instances of ServiceProvider.
+type ServiceProvider interface {
+	// AuditorService return the auditor service and store service for the given tms id
+	AuditorService(tmsID token.TMSID) (Service, StoreService, error)
+}
+
+// GetServiceProvider retrieves the ServiceProvider from the given ServiceProvider.
+func GetServiceProvider(sp token.ServiceProvider) (ServiceProvider, error) {
+	s, err := sp.GetService(serviceProviderType)
+	if err != nil {
+		return nil, err
+	}
+	nip, ok := s.(ServiceProvider)
+	if !ok {
+		panic("implementation error, type must be ServiceProvider")
+	}
+	return nip, nil
+}