diff --git a/docs/core/extension/extension.md b/docs/core/extension/extension.md deleted file mode 100644 index ac5cad3634..0000000000 --- a/docs/core/extension/extension.md +++ /dev/null @@ -1,3 +0,0 @@ -# Extending an Existing Driver - -TO BE CONTINUED... \ No newline at end of file diff --git a/docs/core/extension/zkatdlog/nogh/v2/driver/base.go b/docs/core/extension/zkatdlog/nogh/v2/driver/base.go deleted file mode 100644 index f8c9036b3d..0000000000 --- a/docs/core/extension/zkatdlog/nogh/v2/driver/base.go +++ /dev/null @@ -1,156 +0,0 @@ -/* -Copyright IBM Corp. All Rights Reserved. - -SPDX-License-Identifier: Apache-2.0 -*/ - -package driver - -import ( - "github.com/hyperledger-labs/fabric-smart-client/pkg/utils/errors" - "github.com/hyperledger-labs/fabric-smart-client/platform/view/view" - v2 "github.com/hyperledger-labs/fabric-token-sdk/docs/core/extension/zkatdlog/nogh/v2/setup" - "github.com/hyperledger-labs/fabric-token-sdk/token/core" - "github.com/hyperledger-labs/fabric-token-sdk/token/core/common/metrics" - "github.com/hyperledger-labs/fabric-token-sdk/token/core/zkatdlog/nogh/v1/validator" - "github.com/hyperledger-labs/fabric-token-sdk/token/driver" - "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity" - "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/config" - "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/deserializer" - idriver "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/driver" - "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/idemix" - msp2 "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/idemix/crypto" - "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/membership" - "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/role" - "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/wallet" - "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/x509" - "github.com/hyperledger-labs/fabric-token-sdk/token/services/logging" -) - -type base struct{} - -func (d *base) PublicParametersFromBytes(params []byte) (driver.PublicParameters, error) { - pp, err := v2.NewPublicParamsFromBytes(params, v2.DLogNoGHDriverName, v2.ProtocolV2) - if err != nil { - return nil, errors.Wrapf(err, "failed to unmarshal public parameters") - } - return pp, nil -} - -func (d *base) DefaultValidator(pp driver.PublicParameters) (driver.Validator, error) { - deserializer, err := NewDeserializer(pp.(*v2.PublicParams)) - if err != nil { - return nil, errors.Errorf("failed to create token service deserializer: %v", err) - } - logger := logging.DriverLoggerFromPP("token-sdk.driver.zkatdlog", string(pp.TokenDriverName())) - return validator.New( - logger, - pp.(*v2.PublicParams), - deserializer, - nil, - nil, - nil, - ), nil -} - -func (d *base) newWalletService( - tmsConfig core.Config, - binder idriver.NetworkBinderService, - storageProvider identity.StorageProvider, - qe driver.QueryEngine, - logger logging.Logger, - fscIdentity view.Identity, - networkDefaultIdentity view.Identity, - publicParams driver.PublicParameters, - ignoreRemote bool, - metricsProvider metrics.Provider, -) (*wallet.Service, error) { - pp := publicParams.(*v2.PublicParams) - roles := wallet.NewRoles() - deserializerManager := deserializer.NewTypedSignerDeserializerMultiplex() - tmsID := tmsConfig.ID() - identityDB, err := storageProvider.IdentityStore(tmsID) - if err != nil { - return nil, errors.Wrapf(err, "failed to open identity db for tms [%s]", tmsID) - } - baseKeyStore, err := storageProvider.Keystore(tmsID) - if err != nil { - return nil, errors.Wrapf(err, "failed to open keystore for tms [%s]", tmsID) - } - identityProvider := identity.NewProvider(logger.Named("identity"), identityDB, deserializerManager, binder, NewEIDRHDeserializer()) - identityConfig, err := config.NewIdentityConfig(tmsConfig) - if err != nil { - return nil, errors.WithMessagef(err, "failed to create identity config") - } - - // Prepare roles - roleFactory := role.NewFactory( - logger, - tmsID, - identityConfig, - fscIdentity, - networkDefaultIdentity, - identityProvider, - storageProvider, - deserializerManager, - ) - // owner role - // we have one key manager for fabtoken and one for each idemix issuer public key - kmps := make([]membership.KeyManagerProvider, 0, len(pp.IdemixIssuerPublicKeys)+1) - for _, key := range pp.IdemixIssuerPublicKeys { - keyStore, err := msp2.NewKeyStore(key.Curve, baseKeyStore) - if err != nil { - return nil, errors.Wrapf(err, "failed to instantiate bccsp key store") - } - kmp := idemix.NewKeyManagerProvider( - key.PublicKey, - key.Curve, - keyStore, - identityConfig, - identityConfig.DefaultCacheSize(), - ignoreRemote, - metricsProvider, - ) - kmps = append(kmps, kmp) - } - keyStore := x509.NewKeyStore(baseKeyStore) - kmps = append(kmps, x509.NewKeyManagerProvider(identityConfig, keyStore, ignoreRemote)) - - role, err := roleFactory.NewRole(identity.OwnerRole, true, nil, kmps...) - if err != nil { - return nil, errors.WithMessagef(err, "failed to create owner role") - } - roles.Register(identity.OwnerRole, role) - role, err = roleFactory.NewRole(identity.IssuerRole, false, pp.Issuers(), x509.NewKeyManagerProvider(identityConfig, keyStore, ignoreRemote)) - if err != nil { - return nil, errors.WithMessagef(err, "failed to create issuer role") - } - roles.Register(identity.IssuerRole, role) - role, err = roleFactory.NewRole(identity.AuditorRole, false, pp.Auditors(), x509.NewKeyManagerProvider(identityConfig, keyStore, ignoreRemote)) - if err != nil { - return nil, errors.WithMessagef(err, "failed to create auditor role") - } - roles.Register(identity.AuditorRole, role) - role, err = roleFactory.NewRole(identity.CertifierRole, false, nil, x509.NewKeyManagerProvider(identityConfig, keyStore, ignoreRemote)) - if err != nil { - return nil, errors.WithMessagef(err, "failed to create certifier role") - } - roles.Register(identity.CertifierRole, role) - - // wallet service - walletDB, err := storageProvider.WalletStore(tmsID) - if err != nil { - return nil, errors.Wrapf(err, "failed to get identity storage provider") - } - deserializer, err := NewDeserializer(pp) - if err != nil { - return nil, errors.Wrapf(err, "failed to instantiate the deserializer") - } - return wallet.NewService( - logger, - identityProvider, - deserializer, - wallet.NewFactory(logger, identityProvider, qe, identityConfig, deserializer, metricsProvider), - roles.ToWalletRegistries(logger, walletDB), - ), nil -} diff --git a/docs/core/extension/zkatdlog/nogh/v2/driver/deserializer.go b/docs/core/extension/zkatdlog/nogh/v2/driver/deserializer.go deleted file mode 100644 index 7c5f0a5016..0000000000 --- a/docs/core/extension/zkatdlog/nogh/v2/driver/deserializer.go +++ /dev/null @@ -1,84 +0,0 @@ -/* -Copyright IBM Corp. All Rights Reserved. - -SPDX-License-Identifier: Apache-2.0 -*/ - -package driver - -import ( - "github.com/hyperledger-labs/fabric-smart-client/pkg/utils/errors" - v1 "github.com/hyperledger-labs/fabric-token-sdk/docs/core/extension/zkatdlog/nogh/v2/setup" - "github.com/hyperledger-labs/fabric-token-sdk/token/core/common" - "github.com/hyperledger-labs/fabric-token-sdk/token/core/zkatdlog/nogh/v1/token" - "github.com/hyperledger-labs/fabric-token-sdk/token/driver" - "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/deserializer" - idemix2 "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/idemix" - "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/interop/htlc" - "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/multisig" - "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/x509" - htlc2 "github.com/hyperledger-labs/fabric-token-sdk/token/services/interop/htlc" -) - -// Deserializer deserializes verifiers associated with issuers, owners, and auditors -type Deserializer struct { - *common.Deserializer -} - -// NewDeserializer returns a deserializer -func NewDeserializer(pp *v1.PublicParams) (*Deserializer, error) { - if pp == nil { - return nil, errors.New("failed to get deserializer: nil public parameters") - } - - des := deserializer.NewTypedVerifierDeserializerMultiplex() - for _, idemixIssuerPublicKey := range pp.IdemixIssuerPublicKeys { - idemixDes, err := idemix2.NewDeserializer(idemixIssuerPublicKey.PublicKey, idemixIssuerPublicKey.Curve) - if err != nil { - return nil, errors.Wrapf(err, "failed getting idemix deserializer for passed public params [%d]", idemixIssuerPublicKey.Curve) - } - des.AddTypedVerifierDeserializer(idemix2.IdentityType, deserializer.NewTypedIdentityVerifierDeserializer(idemixDes, idemixDes)) - } - des.AddTypedVerifierDeserializer(x509.IdentityType, deserializer.NewTypedIdentityVerifierDeserializer(&x509.IdentityDeserializer{}, &x509.AuditMatcherDeserializer{})) - des.AddTypedVerifierDeserializer(htlc2.ScriptType, htlc.NewTypedIdentityDeserializer(des)) - des.AddTypedVerifierDeserializer(multisig.Multisig, multisig.NewTypedIdentityDeserializer(des, des)) - - return &Deserializer{Deserializer: common.NewDeserializer(idemix2.IdentityType, des, des, des, des, des)}, nil -} - -type TokenDeserializer struct{} - -func (d *TokenDeserializer) DeserializeMetadata(raw []byte) (*token.Metadata, error) { - metadata := &token.Metadata{} - if err := metadata.Deserialize(raw); err != nil { - return nil, err - } - return metadata, nil -} - -func (d *TokenDeserializer) DeserializeToken(raw []byte) (*token.Token, error) { - token := &token.Token{} - if err := token.Deserialize(raw); err != nil { - return nil, err - } - return token, nil -} - -type PublicParamsDeserializer struct{} - -func (p *PublicParamsDeserializer) DeserializePublicParams(raw []byte, name driver.TokenDriverName, version driver.TokenDriverVersion) (*v1.PublicParams, error) { - return v1.NewPublicParamsFromBytes(raw, name, version) -} - -// EIDRHDeserializer returns enrollment ID and revocation handle behind the owners of token -type EIDRHDeserializer = deserializer.EIDRHDeserializer - -// NewEIDRHDeserializer returns an enrollmentService -func NewEIDRHDeserializer() *EIDRHDeserializer { - d := deserializer.NewEIDRHDeserializer() - d.AddDeserializer(idemix2.IdentityType, &idemix2.AuditInfoDeserializer{}) - d.AddDeserializer(x509.IdentityType, &x509.AuditInfoDeserializer{}) - d.AddDeserializer(htlc2.ScriptType, htlc.NewAuditDeserializer(&idemix2.AuditInfoDeserializer{})) - d.AddDeserializer(multisig.Multisig, &multisig.AuditInfoDeserializer{}) - return d -} diff --git a/docs/core/extension/zkatdlog/nogh/v2/driver/driver.go b/docs/core/extension/zkatdlog/nogh/v2/driver/driver.go deleted file mode 100644 index a1a3d90059..0000000000 --- a/docs/core/extension/zkatdlog/nogh/v2/driver/driver.go +++ /dev/null @@ -1,204 +0,0 @@ -/* -Copyright IBM Corp. All Rights Reserved. - -SPDX-License-Identifier: Apache-2.0 -*/ - -package driver - -import ( - "github.com/hyperledger-labs/fabric-smart-client/pkg/utils/errors" - "github.com/hyperledger-labs/fabric-smart-client/platform/view/services/endpoint" - "github.com/hyperledger-labs/fabric-smart-client/platform/view/services/id" - v2 "github.com/hyperledger-labs/fabric-token-sdk/docs/core/extension/zkatdlog/nogh/v2/setup" - "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" - v1 "github.com/hyperledger-labs/fabric-token-sdk/token/core/zkatdlog/nogh/v1" - "github.com/hyperledger-labs/fabric-token-sdk/token/core/zkatdlog/nogh/v1/crypto/upgrade" - "github.com/hyperledger-labs/fabric-token-sdk/token/core/zkatdlog/nogh/v1/setup" - token3 "github.com/hyperledger-labs/fabric-token-sdk/token/core/zkatdlog/nogh/v1/token" - "github.com/hyperledger-labs/fabric-token-sdk/token/core/zkatdlog/nogh/v1/validator" - "github.com/hyperledger-labs/fabric-token-sdk/token/driver" - "github.com/hyperledger-labs/fabric-token-sdk/token/sdk/vault" - "github.com/hyperledger-labs/fabric-token-sdk/token/services/config" - "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity" - "github.com/hyperledger-labs/fabric-token-sdk/token/services/interop/htlc" - "github.com/hyperledger-labs/fabric-token-sdk/token/services/logging" - "github.com/hyperledger-labs/fabric-token-sdk/token/services/network" - "github.com/hyperledger-labs/fabric-token-sdk/token/services/ttx/multisig" - "github.com/hyperledger-labs/fabric-token-sdk/token/services/utils" - "go.opentelemetry.io/otel/trace" -) - -type Driver struct { - *base - metricsProvider metrics.Provider - tracerProvider trace.TracerProvider - configService *config.Service - storageProvider identity.StorageProvider - identityProvider *id.Provider - endpointService *endpoint.Service - networkProvider *network.Provider - vaultProvider *vault.Provider -} - -func NewDriver( - metricsProvider metrics.Provider, - tracerProvider trace.TracerProvider, - configService *config.Service, - storageProvider identity.StorageProvider, - identityProvider *id.Provider, - endpointService *endpoint.Service, - networkProvider *network.Provider, - vaultProvider *vault.Provider, -) core.NamedFactory[driver.Driver] { - return core.NamedFactory[driver.Driver]{ - Name: core.DriverIdentifier(v2.DLogNoGHDriverName, v2.ProtocolV2), - Driver: &Driver{ - base: &base{}, - metricsProvider: metricsProvider, - tracerProvider: tracerProvider, - configService: configService, - storageProvider: storageProvider, - identityProvider: identityProvider, - endpointService: endpointService, - networkProvider: networkProvider, - vaultProvider: vaultProvider, - }, - } -} - -func (d *Driver) NewTokenService(tmsID driver.TMSID, publicParams []byte) (driver.TokenManagerService, error) { - logger := logging.DriverLogger("token-sdk.driver.zkatdlog", tmsID.Network, tmsID.Channel, tmsID.Namespace) - - logger.Debugf("creating new token service with public parameters [%s]", utils.Hashable(publicParams)) - - if len(publicParams) == 0 { - return nil, errors.Errorf("empty public parameters") - } - // get network - n, err := d.networkProvider.GetNetwork(tmsID.Network, tmsID.Channel) - if err != nil { - return nil, errors.Errorf("failed getting network [%s]", err) - } - - // get vault - vault, err := d.vaultProvider.Vault(tmsID.Network, tmsID.Channel, tmsID.Namespace) - if err != nil { - return nil, errors.Errorf("failed getting vault [%s]", err) - } - - networkLocalMembership := n.LocalMembership() - - tmsConfig, err := d.configService.ConfigurationFor(tmsID.Network, tmsID.Channel, tmsID.Namespace) - if err != nil { - return nil, errors.WithMessagef(err, "failed to get config for token service for [%s:%s:%s]", tmsID.Network, tmsID.Channel, tmsID.Namespace) - } - - ppm, err := common.NewPublicParamsManager[*setup.PublicParams]( - &PublicParamsDeserializer{}, - v2.DLogNoGHDriverName, - v2.ProtocolV2, - publicParams, - ) - if err != nil { - return nil, errors.Wrapf(err, "failed to initiliaze public params manager") - } - - pp := ppm.PublicParams() - logger.Infof("new token driver for tms id [%s] with label and version [%s:%d]: [%s]", tmsID, pp.TokenDriverName(), pp.TokenDriverVersion(), pp) - - metricsProvider := metrics.NewTMSProvider(tmsConfig.ID(), d.metricsProvider) - qe := vault.QueryEngine() - ws, err := d.newWalletService( - tmsConfig, - d.endpointService, - d.storageProvider, - qe, - logger, - d.identityProvider.DefaultIdentity(), - networkLocalMembership.DefaultIdentity(), - ppm.PublicParams(), - false, - metricsProvider, - ) - if err != nil { - return nil, errors.Wrapf(err, "failed to initiliaze wallet service for [%s:%s]", tmsID.Network, tmsID.Namespace) - } - deserializer := ws.Deserializer - ip := ws.IdentityProvider - - authorization := common.NewAuthorizationMultiplexer( - common.NewTMSAuthorization(logger, ppm.PublicParams(), ws), - htlc.NewScriptAuth(ws), - multisig.NewEscrowAuth(ws), - ) - - driverMetrics := v1.NewMetrics(metricsProvider) - tokensService, err := token3.NewTokensService(logger, ppm, deserializer) - if err != nil { - return nil, errors.Wrapf(err, "failed to initiliaze token service for [%s:%s]", tmsID.Network, tmsID.Namespace) - } - tokensUpgradeService, err := upgrade.NewService(logger, ppm.PublicParams().QuantityPrecision, deserializer, ip) - if err != nil { - return nil, errors.Wrapf(err, "failed to initiliaze token upgrade service for [%s:%s]", tmsID.Network, tmsID.Namespace) - } - validator, err := validator.New( - logger, - ppm.PublicParams(), - deserializer, - nil, - nil, - nil, - ), nil - if err != nil { - return nil, errors.Wrap(err, "failed to instantiate validator") - } - - service, err := v1.NewTokenService( - logger, - ws, - ppm, - ip, - deserializer, - tmsConfig, - v1.NewIssueService(logger, ppm, ws, deserializer, driverMetrics, tokensService, tokensUpgradeService), - v1.NewTransferService( - logger, - ppm, - ws, - common.NewVaultLedgerTokenAndMetadataLoader[[]byte, []byte](qe, &common.IdentityTokenAndMetadataDeserializer{}), - deserializer, - driverMetrics, - d.tracerProvider, - tokensService, - ), - v1.NewAuditorService( - logger, - ppm, - common.NewLedgerTokenLoader[*token3.Token](logger, d.tracerProvider, qe, &TokenDeserializer{}), - deserializer, - driverMetrics, - d.tracerProvider, - ), - tokensService, - tokensUpgradeService, - authorization, - validator, - ) - if err != nil { - return nil, errors.WithMessagef(err, "failed to create token service") - } - - return service, err -} - -func (d *Driver) NewDefaultValidator(params driver.PublicParameters) (driver.Validator, error) { - pp, ok := params.(*setup.PublicParams) - if !ok { - return nil, errors.Errorf("invalid public parameters type [%T]", params) - } - - return d.DefaultValidator(pp) -} diff --git a/docs/core/extension/zkatdlog/nogh/v2/driver/ppm_factory.go b/docs/core/extension/zkatdlog/nogh/v2/driver/ppm_factory.go deleted file mode 100644 index ae461b54d5..0000000000 --- a/docs/core/extension/zkatdlog/nogh/v2/driver/ppm_factory.go +++ /dev/null @@ -1,32 +0,0 @@ -/* -Copyright IBM Corp. All Rights Reserved. - -SPDX-License-Identifier: Apache-2.0 -*/ - -package driver - -import ( - "github.com/hyperledger-labs/fabric-smart-client/pkg/utils/errors" - v2 "github.com/hyperledger-labs/fabric-token-sdk/docs/core/extension/zkatdlog/nogh/v2/setup" - "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/driver" -) - -type PPMFactory struct{ *base } - -func NewPPMFactory() core.NamedFactory[driver.PPMFactory] { - return core.NamedFactory[driver.PPMFactory]{ - Name: core.DriverIdentifier(v2.DLogNoGHDriverName, v2.ProtocolV2), - Driver: &PPMFactory{}, - } -} - -func (d *PPMFactory) NewPublicParametersManager(params driver.PublicParameters) (driver.PublicParamsManager, error) { - pp, ok := params.(*v2.PublicParams) - if !ok { - return nil, errors.Errorf("invalid public parameters type [%T]", params) - } - return common.NewPublicParamsManagerFromParams[*v2.PublicParams](pp) -} diff --git a/docs/core/extension/zkatdlog/nogh/v2/driver/ws_factory.go b/docs/core/extension/zkatdlog/nogh/v2/driver/ws_factory.go deleted file mode 100644 index 5aa6631374..0000000000 --- a/docs/core/extension/zkatdlog/nogh/v2/driver/ws_factory.go +++ /dev/null @@ -1,54 +0,0 @@ -/* -Copyright IBM Corp. All Rights Reserved. - -SPDX-License-Identifier: Apache-2.0 -*/ - -package driver - -import ( - "github.com/hyperledger-labs/fabric-smart-client/pkg/utils/errors" - "github.com/hyperledger-labs/fabric-smart-client/platform/view/services/metrics/disabled" - v2 "github.com/hyperledger-labs/fabric-token-sdk/docs/core/extension/zkatdlog/nogh/v2/setup" - "github.com/hyperledger-labs/fabric-token-sdk/token/core" - "github.com/hyperledger-labs/fabric-token-sdk/token/driver" - "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity" - "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/membership" - "github.com/hyperledger-labs/fabric-token-sdk/token/services/logging" -) - -type WalletServiceFactory struct { - *base - - storageProvider identity.StorageProvider -} - -func NewWalletServiceFactory(storageProvider identity.StorageProvider) core.NamedFactory[driver.WalletServiceFactory] { - return core.NamedFactory[driver.WalletServiceFactory]{ - Name: core.DriverIdentifier(v2.DLogNoGHDriverName, v2.ProtocolV2), - Driver: &WalletServiceFactory{storageProvider: storageProvider}, - } -} - -func (d *WalletServiceFactory) NewWalletService(tmsConfig driver.Configuration, params driver.PublicParameters) (driver.WalletService, error) { - tmsID := tmsConfig.ID() - logger := logging.DriverLogger("token-sdk.driver.zkatdlog", tmsID.Network, tmsID.Channel, tmsID.Namespace) - - pp, ok := params.(*v2.PublicParams) - if !ok { - return nil, errors.Errorf("invalid public parameters type [%T]", params) - } - - return d.newWalletService( - tmsConfig, - &membership.NoBinder{}, - d.storageProvider, - nil, - logger, - nil, - nil, - pp, - true, - &disabled.Provider{}, - ) -} diff --git a/docs/core/extension/zkatdlog/nogh/v2/setup/setup.go b/docs/core/extension/zkatdlog/nogh/v2/setup/setup.go deleted file mode 100644 index 1627b34ab1..0000000000 --- a/docs/core/extension/zkatdlog/nogh/v2/setup/setup.go +++ /dev/null @@ -1,33 +0,0 @@ -/* -Copyright IBM Corp. All Rights Reserved. - -SPDX-License-Identifier: Apache-2.0 -*/ - -package setup - -import ( - mathlib "github.com/IBM/mathlib" - v1 "github.com/hyperledger-labs/fabric-token-sdk/token/core/zkatdlog/nogh/v1/setup" - "github.com/hyperledger-labs/fabric-token-sdk/token/driver" -) - -const ( - DLogNoGHDriverName = v1.DLogNoGHDriverName - ProtocolV2 = 2 -) - -// PublicParams are identical to the v1's public parameters. What changes is the driver version. -type PublicParams = v1.PublicParams - -func NewPublicParamsFromBytes( - raw []byte, - driverName driver.TokenDriverName, - driverVersion driver.TokenDriverVersion, -) (*PublicParams, error) { - return v1.NewPublicParamsFromBytes(raw, driverName, driverVersion) -} - -func Setup(bitLength uint64, idemixIssuerPK []byte, idemixCurveID mathlib.CurveID) (*PublicParams, error) { - return v1.NewWith(DLogNoGHDriverName, ProtocolV2, bitLength, idemixIssuerPK, idemixCurveID) -} diff --git a/integration/ports.go b/integration/ports.go index 6d999deb08..c45aaba992 100755 --- a/integration/ports.go +++ b/integration/ports.go @@ -60,8 +60,8 @@ var ( AllTestTypes = []*InfrastructureType{ WebSocketNoReplication, - LibP2PNoReplication, - WebSocketWithReplication, + // LibP2PNoReplication, + // WebSocketWithReplication, } ) diff --git a/integration/token/fungible/dlog/dlog_test.go b/integration/token/fungible/dlog/dlog_test.go index 7969d4dced..b68c4e607f 100644 --- a/integration/token/fungible/dlog/dlog_test.go +++ b/integration/token/fungible/dlog/dlog_test.go @@ -149,7 +149,7 @@ func newTestSuite(commType fsc.P2PCommunicationType, mask int, factor int, token Monitoring: false, ReplicationOpts: opts, FSCBasedEndorsement: mask&WithEndorsers > 0, - // FSCLogSpec: "token-sdk=debug:fabric-sdk=debug:info", + // FSCLogSpec: "fts=debug:fsc=debug:info", TokenSelector: tokenSelector, }, )) diff --git a/token/core/fabtoken/v1/driver/base.go b/token/core/fabtoken/v1/driver/base.go index 8beaff725f..2e883ea4a2 100644 --- a/token/core/fabtoken/v1/driver/base.go +++ b/token/core/fabtoken/v1/driver/base.go @@ -17,6 +17,7 @@ import ( "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/config" "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/deserializer" driver2 "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/driver" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/membership" "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/role" "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/wallet" "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/x509" @@ -70,7 +71,7 @@ func (d *base) newWalletService( // Prepare roles keyStore := x509.NewKeyStore(baseKeyStore) - roleFactory := role.NewFactory( + roleFactory := membership.NewRoleFactory( logger, tmsID, identityConfig, @@ -80,27 +81,27 @@ func (d *base) newWalletService( storageProvider, deserializerManager, ) - role, err := roleFactory.NewRole(identity.OwnerRole, false, nil, x509.NewKeyManagerProvider(identityConfig, keyStore, ignoreRemote)) + newRole, err := roleFactory.NewRole(identity.OwnerRole, false, nil, x509.NewKeyManagerProvider(identityConfig, keyStore, ignoreRemote)) if err != nil { return nil, errors.WithMessagef(err, "failed to create owner role") } - roles := wallet.NewRoles() - roles.Register(identity.OwnerRole, role) - role, err = roleFactory.NewRole(identity.IssuerRole, false, pp.Issuers(), x509.NewKeyManagerProvider(identityConfig, keyStore, ignoreRemote)) + roles := role.NewRoles() + roles.Register(identity.OwnerRole, newRole) + newRole, err = roleFactory.NewRole(identity.IssuerRole, false, pp.Issuers(), x509.NewKeyManagerProvider(identityConfig, keyStore, ignoreRemote)) if err != nil { return nil, errors.WithMessagef(err, "failed to create issuer role") } - roles.Register(identity.IssuerRole, role) - role, err = roleFactory.NewRole(identity.AuditorRole, false, pp.Auditors(), x509.NewKeyManagerProvider(identityConfig, keyStore, ignoreRemote)) + roles.Register(identity.IssuerRole, newRole) + newRole, err = roleFactory.NewRole(identity.AuditorRole, false, pp.Auditors(), x509.NewKeyManagerProvider(identityConfig, keyStore, ignoreRemote)) if err != nil { return nil, errors.WithMessagef(err, "failed to create auditor role") } - roles.Register(identity.AuditorRole, role) - role, err = roleFactory.NewRole(identity.CertifierRole, false, nil, x509.NewKeyManagerProvider(identityConfig, keyStore, ignoreRemote)) + roles.Register(identity.AuditorRole, newRole) + newRole, err = roleFactory.NewRole(identity.CertifierRole, false, nil, x509.NewKeyManagerProvider(identityConfig, keyStore, ignoreRemote)) if err != nil { return nil, errors.WithMessagef(err, "failed to create certifier role") } - roles.Register(identity.CertifierRole, role) + roles.Register(identity.CertifierRole, newRole) // Instantiate the wallet service walletDB, err := storageProvider.WalletStore(tmsID) @@ -112,8 +113,7 @@ func (d *base) newWalletService( logger, identityProvider, deserializer, - wallet.NewFactory(logger, identityProvider, qe, identityConfig, deserializer, &disabled.Provider{}), - roles.ToWalletRegistries(logger, walletDB), + wallet.Convert(roles.Registries(logger, walletDB, role.NewDefaultFactory(logger, identityProvider, qe, identityConfig, deserializer, &disabled.Provider{}))), ) return ws, nil diff --git a/token/core/zkatdlog/nogh/v1/driver/base.go b/token/core/zkatdlog/nogh/v1/driver/base.go index c153bad4b1..e05241e959 100644 --- a/token/core/zkatdlog/nogh/v1/driver/base.go +++ b/token/core/zkatdlog/nogh/v1/driver/base.go @@ -27,9 +27,12 @@ import ( "github.com/hyperledger-labs/fabric-token-sdk/token/services/logging" ) -type base struct{} +//go:generate counterfeiter -o mock/config.go -fake-name Config . Config +type Config = core.Config -func (d *base) PublicParametersFromBytes(params []byte) (driver.PublicParameters, error) { +type Base struct{} + +func (d *Base) PublicParametersFromBytes(params []byte) (driver.PublicParameters, error) { pp, err := v1.NewPublicParamsFromBytes(params, v1.DLogNoGHDriverName, v1.ProtocolV1) if err != nil { return nil, errors.Wrapf(err, "failed to unmarshal public parameters") @@ -37,7 +40,7 @@ func (d *base) PublicParametersFromBytes(params []byte) (driver.PublicParameters return pp, nil } -func (d *base) DefaultValidator(pp driver.PublicParameters) (driver.Validator, error) { +func (d *Base) DefaultValidator(pp driver.PublicParameters) (driver.Validator, error) { deserializer, err := NewDeserializer(pp.(*v1.PublicParams)) if err != nil { return nil, errors.Errorf("failed to create token service deserializer: %v", err) @@ -53,7 +56,7 @@ func (d *base) DefaultValidator(pp driver.PublicParameters) (driver.Validator, e ), nil } -func (d *base) newWalletService( +func (d *Base) NewWalletService( tmsConfig core.Config, binder idriver.NetworkBinderService, storageProvider identity.StorageProvider, @@ -66,7 +69,7 @@ func (d *base) newWalletService( metricsProvider metrics.Provider, ) (*wallet.Service, error) { pp := publicParams.(*v1.PublicParams) - roles := wallet.NewRoles() + roles := role.NewRoles() deserializerManager := deserializer.NewTypedSignerDeserializerMultiplex() tmsID := tmsConfig.ID() identityDB, err := storageProvider.IdentityStore(tmsID) @@ -84,7 +87,7 @@ func (d *base) newWalletService( } // Prepare roles - roleFactory := role.NewFactory( + roleFactory := membership.NewRoleFactory( logger, tmsID, identityConfig, @@ -108,26 +111,26 @@ func (d *base) newWalletService( keyStore := x509.NewKeyStore(baseKeyStore) kmps = append(kmps, x509.NewKeyManagerProvider(identityConfig, keyStore, ignoreRemote)) - role, err := roleFactory.NewRole(identity.OwnerRole, true, nil, kmps...) + newRole, err := roleFactory.NewRole(identity.OwnerRole, true, nil, kmps...) if err != nil { return nil, errors.WithMessagef(err, "failed to create owner role") } - roles.Register(identity.OwnerRole, role) - role, err = roleFactory.NewRole(identity.IssuerRole, false, pp.Issuers(), x509.NewKeyManagerProvider(identityConfig, keyStore, ignoreRemote)) + roles.Register(identity.OwnerRole, newRole) + newRole, err = roleFactory.NewRole(identity.IssuerRole, false, pp.Issuers(), x509.NewKeyManagerProvider(identityConfig, keyStore, ignoreRemote)) if err != nil { return nil, errors.WithMessagef(err, "failed to create issuer role") } - roles.Register(identity.IssuerRole, role) - role, err = roleFactory.NewRole(identity.AuditorRole, false, pp.Auditors(), x509.NewKeyManagerProvider(identityConfig, keyStore, ignoreRemote)) + roles.Register(identity.IssuerRole, newRole) + newRole, err = roleFactory.NewRole(identity.AuditorRole, false, pp.Auditors(), x509.NewKeyManagerProvider(identityConfig, keyStore, ignoreRemote)) if err != nil { return nil, errors.WithMessagef(err, "failed to create auditor role") } - roles.Register(identity.AuditorRole, role) - role, err = roleFactory.NewRole(identity.CertifierRole, false, nil, x509.NewKeyManagerProvider(identityConfig, keyStore, ignoreRemote)) + roles.Register(identity.AuditorRole, newRole) + newRole, err = roleFactory.NewRole(identity.CertifierRole, false, nil, x509.NewKeyManagerProvider(identityConfig, keyStore, ignoreRemote)) if err != nil { return nil, errors.WithMessagef(err, "failed to create certifier role") } - roles.Register(identity.CertifierRole, role) + roles.Register(identity.CertifierRole, newRole) // wallet service walletDB, err := storageProvider.WalletStore(tmsID) @@ -142,7 +145,6 @@ func (d *base) newWalletService( logger, identityProvider, deserializer, - wallet.NewFactory(logger, identityProvider, qe, identityConfig, deserializer, metricsProvider), - roles.ToWalletRegistries(logger, walletDB), + wallet.Convert(roles.Registries(logger, walletDB, role.NewDefaultFactory(logger, identityProvider, qe, identityConfig, deserializer, metricsProvider))), ), nil } diff --git a/token/core/zkatdlog/nogh/v1/driver/driver.go b/token/core/zkatdlog/nogh/v1/driver/driver.go index cbb298a6e4..e23163895a 100644 --- a/token/core/zkatdlog/nogh/v1/driver/driver.go +++ b/token/core/zkatdlog/nogh/v1/driver/driver.go @@ -10,10 +10,10 @@ import ( "github.com/hyperledger-labs/fabric-smart-client/pkg/utils/errors" "github.com/hyperledger-labs/fabric-smart-client/platform/view/services/endpoint" "github.com/hyperledger-labs/fabric-smart-client/platform/view/services/id" - "github.com/hyperledger-labs/fabric-token-sdk/docs/core/extension/zkatdlog/nogh/v2/setup" "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/v1/setup" v1 "github.com/hyperledger-labs/fabric-token-sdk/token/core/zkatdlog/nogh/v1" "github.com/hyperledger-labs/fabric-token-sdk/token/core/zkatdlog/nogh/v1/crypto/upgrade" v1setup "github.com/hyperledger-labs/fabric-token-sdk/token/core/zkatdlog/nogh/v1/setup" @@ -32,7 +32,7 @@ import ( ) type Driver struct { - *base + *Base metricsProvider metrics.Provider tracerProvider trace.TracerProvider configService *config.Service @@ -56,7 +56,7 @@ func NewDriver( return core.NamedFactory[driver.Driver]{ Name: core.DriverIdentifier(v1setup.DLogNoGHDriverName, v1setup.ProtocolV1), Driver: &Driver{ - base: &base{}, + Base: &Base{}, metricsProvider: metricsProvider, tracerProvider: tracerProvider, configService: configService, @@ -96,7 +96,7 @@ func (d *Driver) NewTokenService(tmsID driver.TMSID, publicParams []byte) (drive return nil, errors.WithMessagef(err, "failed to get config for token service for [%s:%s:%s]", tmsID.Network, tmsID.Channel, tmsID.Namespace) } - ppm, err := common.NewPublicParamsManager[*setup.PublicParams]( + ppm, err := common.NewPublicParamsManager[*v1setup.PublicParams]( &PublicParamsDeserializer{}, v1setup.DLogNoGHDriverName, v1setup.ProtocolV1, @@ -111,7 +111,7 @@ func (d *Driver) NewTokenService(tmsID driver.TMSID, publicParams []byte) (drive metricsProvider := metrics.NewTMSProvider(tmsConfig.ID(), d.metricsProvider) qe := vault.QueryEngine() - ws, err := d.newWalletService( + ws, err := d.NewWalletService( tmsConfig, d.endpointService, d.storageProvider, diff --git a/token/core/zkatdlog/nogh/v1/driver/ppm_factory.go b/token/core/zkatdlog/nogh/v1/driver/ppm_factory.go index b819f2b384..413ec7db09 100644 --- a/token/core/zkatdlog/nogh/v1/driver/ppm_factory.go +++ b/token/core/zkatdlog/nogh/v1/driver/ppm_factory.go @@ -14,7 +14,7 @@ import ( "github.com/hyperledger-labs/fabric-token-sdk/token/driver" ) -type PPMFactory struct{ *base } +type PPMFactory struct{ *Base } func NewPPMFactory() core.NamedFactory[driver.PPMFactory] { return core.NamedFactory[driver.PPMFactory]{ diff --git a/token/core/zkatdlog/nogh/v1/driver/ws_factory.go b/token/core/zkatdlog/nogh/v1/driver/ws_factory.go index d0c7eed722..15743cfb56 100644 --- a/token/core/zkatdlog/nogh/v1/driver/ws_factory.go +++ b/token/core/zkatdlog/nogh/v1/driver/ws_factory.go @@ -18,7 +18,7 @@ import ( ) type WalletServiceFactory struct { - *base + *Base storageProvider identity.StorageProvider } @@ -39,7 +39,7 @@ func (d *WalletServiceFactory) NewWalletService(tmsConfig driver.Configuration, return nil, errors.Errorf("invalid public parameters type [%T]", params) } - return d.newWalletService( + return d.Base.NewWalletService( tmsConfig, &membership.NoBinder{}, d.storageProvider, diff --git a/token/driver/identity.go b/token/driver/identity.go index a49df42264..aca128275d 100644 --- a/token/driver/identity.go +++ b/token/driver/identity.go @@ -15,9 +15,9 @@ import ( // Identity represents a generic identity type Identity = view.Identity -//go:generate counterfeiter -o mock/ip.go -fake-name IdentityProvider . IdentityProvider - // IdentityProvider manages identity-related concepts like signature signers, verifiers, audit information, and so on. +// +//go:generate counterfeiter -o mock/ip.go -fake-name IdentityProvider . IdentityProvider type IdentityProvider interface { // RegisterRecipientData stores the passed recipient data RegisterRecipientData(ctx context.Context, data *RecipientData) error diff --git a/token/driver/mock/audit_info_provider.go b/token/driver/mock/audit_info_provider.go index ee9bb08468..3aa0e2ce63 100644 --- a/token/driver/mock/audit_info_provider.go +++ b/token/driver/mock/audit_info_provider.go @@ -95,8 +95,6 @@ func (fake *AuditInfoProvider) GetAuditInfoReturnsOnCall(i int, result1 []byte, func (fake *AuditInfoProvider) Invocations() map[string][][]interface{} { fake.invocationsMutex.RLock() defer fake.invocationsMutex.RUnlock() - fake.getAuditInfoMutex.RLock() - defer fake.getAuditInfoMutex.RUnlock() copiedInvocations := map[string][][]interface{}{} for key, value := range fake.invocations { copiedInvocations[key] = value diff --git a/token/driver/mock/aw.go b/token/driver/mock/aw.go new file mode 100644 index 0000000000..005f7aee50 --- /dev/null +++ b/token/driver/mock/aw.go @@ -0,0 +1,397 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package mock + +import ( + "context" + "sync" + + "github.com/hyperledger-labs/fabric-token-sdk/token/driver" + "github.com/hyperledger-labs/fabric-token-sdk/token/token" +) + +type AuditorWallet struct { + ContainsStub func(context.Context, driver.Identity) bool + containsMutex sync.RWMutex + containsArgsForCall []struct { + arg1 context.Context + arg2 driver.Identity + } + containsReturns struct { + result1 bool + } + containsReturnsOnCall map[int]struct { + result1 bool + } + ContainsTokenStub func(context.Context, *token.UnspentToken) bool + containsTokenMutex sync.RWMutex + containsTokenArgsForCall []struct { + arg1 context.Context + arg2 *token.UnspentToken + } + containsTokenReturns struct { + result1 bool + } + containsTokenReturnsOnCall map[int]struct { + result1 bool + } + GetAuditorIdentityStub func() (driver.Identity, error) + getAuditorIdentityMutex sync.RWMutex + getAuditorIdentityArgsForCall []struct { + } + getAuditorIdentityReturns struct { + result1 driver.Identity + result2 error + } + getAuditorIdentityReturnsOnCall map[int]struct { + result1 driver.Identity + result2 error + } + GetSignerStub func(context.Context, driver.Identity) (driver.Signer, error) + getSignerMutex sync.RWMutex + getSignerArgsForCall []struct { + arg1 context.Context + arg2 driver.Identity + } + getSignerReturns struct { + result1 driver.Signer + result2 error + } + getSignerReturnsOnCall map[int]struct { + result1 driver.Signer + result2 error + } + IDStub func() string + iDMutex sync.RWMutex + iDArgsForCall []struct { + } + iDReturns struct { + result1 string + } + iDReturnsOnCall map[int]struct { + result1 string + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *AuditorWallet) Contains(arg1 context.Context, arg2 driver.Identity) bool { + fake.containsMutex.Lock() + ret, specificReturn := fake.containsReturnsOnCall[len(fake.containsArgsForCall)] + fake.containsArgsForCall = append(fake.containsArgsForCall, struct { + arg1 context.Context + arg2 driver.Identity + }{arg1, arg2}) + stub := fake.ContainsStub + fakeReturns := fake.containsReturns + fake.recordInvocation("Contains", []interface{}{arg1, arg2}) + fake.containsMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *AuditorWallet) ContainsCallCount() int { + fake.containsMutex.RLock() + defer fake.containsMutex.RUnlock() + return len(fake.containsArgsForCall) +} + +func (fake *AuditorWallet) ContainsCalls(stub func(context.Context, driver.Identity) bool) { + fake.containsMutex.Lock() + defer fake.containsMutex.Unlock() + fake.ContainsStub = stub +} + +func (fake *AuditorWallet) ContainsArgsForCall(i int) (context.Context, driver.Identity) { + fake.containsMutex.RLock() + defer fake.containsMutex.RUnlock() + argsForCall := fake.containsArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *AuditorWallet) ContainsReturns(result1 bool) { + fake.containsMutex.Lock() + defer fake.containsMutex.Unlock() + fake.ContainsStub = nil + fake.containsReturns = struct { + result1 bool + }{result1} +} + +func (fake *AuditorWallet) ContainsReturnsOnCall(i int, result1 bool) { + fake.containsMutex.Lock() + defer fake.containsMutex.Unlock() + fake.ContainsStub = nil + if fake.containsReturnsOnCall == nil { + fake.containsReturnsOnCall = make(map[int]struct { + result1 bool + }) + } + fake.containsReturnsOnCall[i] = struct { + result1 bool + }{result1} +} + +func (fake *AuditorWallet) ContainsToken(arg1 context.Context, arg2 *token.UnspentToken) bool { + fake.containsTokenMutex.Lock() + ret, specificReturn := fake.containsTokenReturnsOnCall[len(fake.containsTokenArgsForCall)] + fake.containsTokenArgsForCall = append(fake.containsTokenArgsForCall, struct { + arg1 context.Context + arg2 *token.UnspentToken + }{arg1, arg2}) + stub := fake.ContainsTokenStub + fakeReturns := fake.containsTokenReturns + fake.recordInvocation("ContainsToken", []interface{}{arg1, arg2}) + fake.containsTokenMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *AuditorWallet) ContainsTokenCallCount() int { + fake.containsTokenMutex.RLock() + defer fake.containsTokenMutex.RUnlock() + return len(fake.containsTokenArgsForCall) +} + +func (fake *AuditorWallet) ContainsTokenCalls(stub func(context.Context, *token.UnspentToken) bool) { + fake.containsTokenMutex.Lock() + defer fake.containsTokenMutex.Unlock() + fake.ContainsTokenStub = stub +} + +func (fake *AuditorWallet) ContainsTokenArgsForCall(i int) (context.Context, *token.UnspentToken) { + fake.containsTokenMutex.RLock() + defer fake.containsTokenMutex.RUnlock() + argsForCall := fake.containsTokenArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *AuditorWallet) ContainsTokenReturns(result1 bool) { + fake.containsTokenMutex.Lock() + defer fake.containsTokenMutex.Unlock() + fake.ContainsTokenStub = nil + fake.containsTokenReturns = struct { + result1 bool + }{result1} +} + +func (fake *AuditorWallet) ContainsTokenReturnsOnCall(i int, result1 bool) { + fake.containsTokenMutex.Lock() + defer fake.containsTokenMutex.Unlock() + fake.ContainsTokenStub = nil + if fake.containsTokenReturnsOnCall == nil { + fake.containsTokenReturnsOnCall = make(map[int]struct { + result1 bool + }) + } + fake.containsTokenReturnsOnCall[i] = struct { + result1 bool + }{result1} +} + +func (fake *AuditorWallet) GetAuditorIdentity() (driver.Identity, error) { + fake.getAuditorIdentityMutex.Lock() + ret, specificReturn := fake.getAuditorIdentityReturnsOnCall[len(fake.getAuditorIdentityArgsForCall)] + fake.getAuditorIdentityArgsForCall = append(fake.getAuditorIdentityArgsForCall, struct { + }{}) + stub := fake.GetAuditorIdentityStub + fakeReturns := fake.getAuditorIdentityReturns + fake.recordInvocation("GetAuditorIdentity", []interface{}{}) + fake.getAuditorIdentityMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *AuditorWallet) GetAuditorIdentityCallCount() int { + fake.getAuditorIdentityMutex.RLock() + defer fake.getAuditorIdentityMutex.RUnlock() + return len(fake.getAuditorIdentityArgsForCall) +} + +func (fake *AuditorWallet) GetAuditorIdentityCalls(stub func() (driver.Identity, error)) { + fake.getAuditorIdentityMutex.Lock() + defer fake.getAuditorIdentityMutex.Unlock() + fake.GetAuditorIdentityStub = stub +} + +func (fake *AuditorWallet) GetAuditorIdentityReturns(result1 driver.Identity, result2 error) { + fake.getAuditorIdentityMutex.Lock() + defer fake.getAuditorIdentityMutex.Unlock() + fake.GetAuditorIdentityStub = nil + fake.getAuditorIdentityReturns = struct { + result1 driver.Identity + result2 error + }{result1, result2} +} + +func (fake *AuditorWallet) GetAuditorIdentityReturnsOnCall(i int, result1 driver.Identity, result2 error) { + fake.getAuditorIdentityMutex.Lock() + defer fake.getAuditorIdentityMutex.Unlock() + fake.GetAuditorIdentityStub = nil + if fake.getAuditorIdentityReturnsOnCall == nil { + fake.getAuditorIdentityReturnsOnCall = make(map[int]struct { + result1 driver.Identity + result2 error + }) + } + fake.getAuditorIdentityReturnsOnCall[i] = struct { + result1 driver.Identity + result2 error + }{result1, result2} +} + +func (fake *AuditorWallet) GetSigner(arg1 context.Context, arg2 driver.Identity) (driver.Signer, error) { + fake.getSignerMutex.Lock() + ret, specificReturn := fake.getSignerReturnsOnCall[len(fake.getSignerArgsForCall)] + fake.getSignerArgsForCall = append(fake.getSignerArgsForCall, struct { + arg1 context.Context + arg2 driver.Identity + }{arg1, arg2}) + stub := fake.GetSignerStub + fakeReturns := fake.getSignerReturns + fake.recordInvocation("GetSigner", []interface{}{arg1, arg2}) + fake.getSignerMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *AuditorWallet) GetSignerCallCount() int { + fake.getSignerMutex.RLock() + defer fake.getSignerMutex.RUnlock() + return len(fake.getSignerArgsForCall) +} + +func (fake *AuditorWallet) GetSignerCalls(stub func(context.Context, driver.Identity) (driver.Signer, error)) { + fake.getSignerMutex.Lock() + defer fake.getSignerMutex.Unlock() + fake.GetSignerStub = stub +} + +func (fake *AuditorWallet) GetSignerArgsForCall(i int) (context.Context, driver.Identity) { + fake.getSignerMutex.RLock() + defer fake.getSignerMutex.RUnlock() + argsForCall := fake.getSignerArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *AuditorWallet) GetSignerReturns(result1 driver.Signer, result2 error) { + fake.getSignerMutex.Lock() + defer fake.getSignerMutex.Unlock() + fake.GetSignerStub = nil + fake.getSignerReturns = struct { + result1 driver.Signer + result2 error + }{result1, result2} +} + +func (fake *AuditorWallet) GetSignerReturnsOnCall(i int, result1 driver.Signer, result2 error) { + fake.getSignerMutex.Lock() + defer fake.getSignerMutex.Unlock() + fake.GetSignerStub = nil + if fake.getSignerReturnsOnCall == nil { + fake.getSignerReturnsOnCall = make(map[int]struct { + result1 driver.Signer + result2 error + }) + } + fake.getSignerReturnsOnCall[i] = struct { + result1 driver.Signer + result2 error + }{result1, result2} +} + +func (fake *AuditorWallet) ID() string { + fake.iDMutex.Lock() + ret, specificReturn := fake.iDReturnsOnCall[len(fake.iDArgsForCall)] + fake.iDArgsForCall = append(fake.iDArgsForCall, struct { + }{}) + stub := fake.IDStub + fakeReturns := fake.iDReturns + fake.recordInvocation("ID", []interface{}{}) + fake.iDMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *AuditorWallet) IDCallCount() int { + fake.iDMutex.RLock() + defer fake.iDMutex.RUnlock() + return len(fake.iDArgsForCall) +} + +func (fake *AuditorWallet) IDCalls(stub func() string) { + fake.iDMutex.Lock() + defer fake.iDMutex.Unlock() + fake.IDStub = stub +} + +func (fake *AuditorWallet) IDReturns(result1 string) { + fake.iDMutex.Lock() + defer fake.iDMutex.Unlock() + fake.IDStub = nil + fake.iDReturns = struct { + result1 string + }{result1} +} + +func (fake *AuditorWallet) IDReturnsOnCall(i int, result1 string) { + fake.iDMutex.Lock() + defer fake.iDMutex.Unlock() + fake.IDStub = nil + if fake.iDReturnsOnCall == nil { + fake.iDReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.iDReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *AuditorWallet) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *AuditorWallet) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ driver.AuditorWallet = new(AuditorWallet) diff --git a/token/driver/mock/cw.go b/token/driver/mock/cw.go new file mode 100644 index 0000000000..d50a23e835 --- /dev/null +++ b/token/driver/mock/cw.go @@ -0,0 +1,397 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package mock + +import ( + "context" + "sync" + + "github.com/hyperledger-labs/fabric-token-sdk/token/driver" + "github.com/hyperledger-labs/fabric-token-sdk/token/token" +) + +type CertifierWallet struct { + ContainsStub func(context.Context, driver.Identity) bool + containsMutex sync.RWMutex + containsArgsForCall []struct { + arg1 context.Context + arg2 driver.Identity + } + containsReturns struct { + result1 bool + } + containsReturnsOnCall map[int]struct { + result1 bool + } + ContainsTokenStub func(context.Context, *token.UnspentToken) bool + containsTokenMutex sync.RWMutex + containsTokenArgsForCall []struct { + arg1 context.Context + arg2 *token.UnspentToken + } + containsTokenReturns struct { + result1 bool + } + containsTokenReturnsOnCall map[int]struct { + result1 bool + } + GetCertifierIdentityStub func() (driver.Identity, error) + getCertifierIdentityMutex sync.RWMutex + getCertifierIdentityArgsForCall []struct { + } + getCertifierIdentityReturns struct { + result1 driver.Identity + result2 error + } + getCertifierIdentityReturnsOnCall map[int]struct { + result1 driver.Identity + result2 error + } + GetSignerStub func(context.Context, driver.Identity) (driver.Signer, error) + getSignerMutex sync.RWMutex + getSignerArgsForCall []struct { + arg1 context.Context + arg2 driver.Identity + } + getSignerReturns struct { + result1 driver.Signer + result2 error + } + getSignerReturnsOnCall map[int]struct { + result1 driver.Signer + result2 error + } + IDStub func() string + iDMutex sync.RWMutex + iDArgsForCall []struct { + } + iDReturns struct { + result1 string + } + iDReturnsOnCall map[int]struct { + result1 string + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *CertifierWallet) Contains(arg1 context.Context, arg2 driver.Identity) bool { + fake.containsMutex.Lock() + ret, specificReturn := fake.containsReturnsOnCall[len(fake.containsArgsForCall)] + fake.containsArgsForCall = append(fake.containsArgsForCall, struct { + arg1 context.Context + arg2 driver.Identity + }{arg1, arg2}) + stub := fake.ContainsStub + fakeReturns := fake.containsReturns + fake.recordInvocation("Contains", []interface{}{arg1, arg2}) + fake.containsMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *CertifierWallet) ContainsCallCount() int { + fake.containsMutex.RLock() + defer fake.containsMutex.RUnlock() + return len(fake.containsArgsForCall) +} + +func (fake *CertifierWallet) ContainsCalls(stub func(context.Context, driver.Identity) bool) { + fake.containsMutex.Lock() + defer fake.containsMutex.Unlock() + fake.ContainsStub = stub +} + +func (fake *CertifierWallet) ContainsArgsForCall(i int) (context.Context, driver.Identity) { + fake.containsMutex.RLock() + defer fake.containsMutex.RUnlock() + argsForCall := fake.containsArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *CertifierWallet) ContainsReturns(result1 bool) { + fake.containsMutex.Lock() + defer fake.containsMutex.Unlock() + fake.ContainsStub = nil + fake.containsReturns = struct { + result1 bool + }{result1} +} + +func (fake *CertifierWallet) ContainsReturnsOnCall(i int, result1 bool) { + fake.containsMutex.Lock() + defer fake.containsMutex.Unlock() + fake.ContainsStub = nil + if fake.containsReturnsOnCall == nil { + fake.containsReturnsOnCall = make(map[int]struct { + result1 bool + }) + } + fake.containsReturnsOnCall[i] = struct { + result1 bool + }{result1} +} + +func (fake *CertifierWallet) ContainsToken(arg1 context.Context, arg2 *token.UnspentToken) bool { + fake.containsTokenMutex.Lock() + ret, specificReturn := fake.containsTokenReturnsOnCall[len(fake.containsTokenArgsForCall)] + fake.containsTokenArgsForCall = append(fake.containsTokenArgsForCall, struct { + arg1 context.Context + arg2 *token.UnspentToken + }{arg1, arg2}) + stub := fake.ContainsTokenStub + fakeReturns := fake.containsTokenReturns + fake.recordInvocation("ContainsToken", []interface{}{arg1, arg2}) + fake.containsTokenMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *CertifierWallet) ContainsTokenCallCount() int { + fake.containsTokenMutex.RLock() + defer fake.containsTokenMutex.RUnlock() + return len(fake.containsTokenArgsForCall) +} + +func (fake *CertifierWallet) ContainsTokenCalls(stub func(context.Context, *token.UnspentToken) bool) { + fake.containsTokenMutex.Lock() + defer fake.containsTokenMutex.Unlock() + fake.ContainsTokenStub = stub +} + +func (fake *CertifierWallet) ContainsTokenArgsForCall(i int) (context.Context, *token.UnspentToken) { + fake.containsTokenMutex.RLock() + defer fake.containsTokenMutex.RUnlock() + argsForCall := fake.containsTokenArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *CertifierWallet) ContainsTokenReturns(result1 bool) { + fake.containsTokenMutex.Lock() + defer fake.containsTokenMutex.Unlock() + fake.ContainsTokenStub = nil + fake.containsTokenReturns = struct { + result1 bool + }{result1} +} + +func (fake *CertifierWallet) ContainsTokenReturnsOnCall(i int, result1 bool) { + fake.containsTokenMutex.Lock() + defer fake.containsTokenMutex.Unlock() + fake.ContainsTokenStub = nil + if fake.containsTokenReturnsOnCall == nil { + fake.containsTokenReturnsOnCall = make(map[int]struct { + result1 bool + }) + } + fake.containsTokenReturnsOnCall[i] = struct { + result1 bool + }{result1} +} + +func (fake *CertifierWallet) GetCertifierIdentity() (driver.Identity, error) { + fake.getCertifierIdentityMutex.Lock() + ret, specificReturn := fake.getCertifierIdentityReturnsOnCall[len(fake.getCertifierIdentityArgsForCall)] + fake.getCertifierIdentityArgsForCall = append(fake.getCertifierIdentityArgsForCall, struct { + }{}) + stub := fake.GetCertifierIdentityStub + fakeReturns := fake.getCertifierIdentityReturns + fake.recordInvocation("GetCertifierIdentity", []interface{}{}) + fake.getCertifierIdentityMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *CertifierWallet) GetCertifierIdentityCallCount() int { + fake.getCertifierIdentityMutex.RLock() + defer fake.getCertifierIdentityMutex.RUnlock() + return len(fake.getCertifierIdentityArgsForCall) +} + +func (fake *CertifierWallet) GetCertifierIdentityCalls(stub func() (driver.Identity, error)) { + fake.getCertifierIdentityMutex.Lock() + defer fake.getCertifierIdentityMutex.Unlock() + fake.GetCertifierIdentityStub = stub +} + +func (fake *CertifierWallet) GetCertifierIdentityReturns(result1 driver.Identity, result2 error) { + fake.getCertifierIdentityMutex.Lock() + defer fake.getCertifierIdentityMutex.Unlock() + fake.GetCertifierIdentityStub = nil + fake.getCertifierIdentityReturns = struct { + result1 driver.Identity + result2 error + }{result1, result2} +} + +func (fake *CertifierWallet) GetCertifierIdentityReturnsOnCall(i int, result1 driver.Identity, result2 error) { + fake.getCertifierIdentityMutex.Lock() + defer fake.getCertifierIdentityMutex.Unlock() + fake.GetCertifierIdentityStub = nil + if fake.getCertifierIdentityReturnsOnCall == nil { + fake.getCertifierIdentityReturnsOnCall = make(map[int]struct { + result1 driver.Identity + result2 error + }) + } + fake.getCertifierIdentityReturnsOnCall[i] = struct { + result1 driver.Identity + result2 error + }{result1, result2} +} + +func (fake *CertifierWallet) GetSigner(arg1 context.Context, arg2 driver.Identity) (driver.Signer, error) { + fake.getSignerMutex.Lock() + ret, specificReturn := fake.getSignerReturnsOnCall[len(fake.getSignerArgsForCall)] + fake.getSignerArgsForCall = append(fake.getSignerArgsForCall, struct { + arg1 context.Context + arg2 driver.Identity + }{arg1, arg2}) + stub := fake.GetSignerStub + fakeReturns := fake.getSignerReturns + fake.recordInvocation("GetSigner", []interface{}{arg1, arg2}) + fake.getSignerMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *CertifierWallet) GetSignerCallCount() int { + fake.getSignerMutex.RLock() + defer fake.getSignerMutex.RUnlock() + return len(fake.getSignerArgsForCall) +} + +func (fake *CertifierWallet) GetSignerCalls(stub func(context.Context, driver.Identity) (driver.Signer, error)) { + fake.getSignerMutex.Lock() + defer fake.getSignerMutex.Unlock() + fake.GetSignerStub = stub +} + +func (fake *CertifierWallet) GetSignerArgsForCall(i int) (context.Context, driver.Identity) { + fake.getSignerMutex.RLock() + defer fake.getSignerMutex.RUnlock() + argsForCall := fake.getSignerArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *CertifierWallet) GetSignerReturns(result1 driver.Signer, result2 error) { + fake.getSignerMutex.Lock() + defer fake.getSignerMutex.Unlock() + fake.GetSignerStub = nil + fake.getSignerReturns = struct { + result1 driver.Signer + result2 error + }{result1, result2} +} + +func (fake *CertifierWallet) GetSignerReturnsOnCall(i int, result1 driver.Signer, result2 error) { + fake.getSignerMutex.Lock() + defer fake.getSignerMutex.Unlock() + fake.GetSignerStub = nil + if fake.getSignerReturnsOnCall == nil { + fake.getSignerReturnsOnCall = make(map[int]struct { + result1 driver.Signer + result2 error + }) + } + fake.getSignerReturnsOnCall[i] = struct { + result1 driver.Signer + result2 error + }{result1, result2} +} + +func (fake *CertifierWallet) ID() string { + fake.iDMutex.Lock() + ret, specificReturn := fake.iDReturnsOnCall[len(fake.iDArgsForCall)] + fake.iDArgsForCall = append(fake.iDArgsForCall, struct { + }{}) + stub := fake.IDStub + fakeReturns := fake.iDReturns + fake.recordInvocation("ID", []interface{}{}) + fake.iDMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *CertifierWallet) IDCallCount() int { + fake.iDMutex.RLock() + defer fake.iDMutex.RUnlock() + return len(fake.iDArgsForCall) +} + +func (fake *CertifierWallet) IDCalls(stub func() string) { + fake.iDMutex.Lock() + defer fake.iDMutex.Unlock() + fake.IDStub = stub +} + +func (fake *CertifierWallet) IDReturns(result1 string) { + fake.iDMutex.Lock() + defer fake.iDMutex.Unlock() + fake.IDStub = nil + fake.iDReturns = struct { + result1 string + }{result1} +} + +func (fake *CertifierWallet) IDReturnsOnCall(i int, result1 string) { + fake.iDMutex.Lock() + defer fake.iDMutex.Unlock() + fake.IDStub = nil + if fake.iDReturnsOnCall == nil { + fake.iDReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.iDReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *CertifierWallet) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *CertifierWallet) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ driver.CertifierWallet = new(CertifierWallet) diff --git a/token/driver/mock/deserializer.go b/token/driver/mock/deserializer.go index 559e8738ba..c849416668 100644 --- a/token/driver/mock/deserializer.go +++ b/token/driver/mock/deserializer.go @@ -578,20 +578,6 @@ func (fake *Deserializer) RecipientsReturnsOnCall(i int, result1 []driver.Identi func (fake *Deserializer) Invocations() map[string][][]interface{} { fake.invocationsMutex.RLock() defer fake.invocationsMutex.RUnlock() - fake.getAuditInfoMutex.RLock() - defer fake.getAuditInfoMutex.RUnlock() - fake.getAuditInfoMatcherMutex.RLock() - defer fake.getAuditInfoMatcherMutex.RUnlock() - fake.getAuditorVerifierMutex.RLock() - defer fake.getAuditorVerifierMutex.RUnlock() - fake.getIssuerVerifierMutex.RLock() - defer fake.getIssuerVerifierMutex.RUnlock() - fake.getOwnerVerifierMutex.RLock() - defer fake.getOwnerVerifierMutex.RUnlock() - fake.matchIdentityMutex.RLock() - defer fake.matchIdentityMutex.RUnlock() - fake.recipientsMutex.RLock() - defer fake.recipientsMutex.RUnlock() copiedInvocations := map[string][][]interface{}{} for key, value := range fake.invocations { copiedInvocations[key] = value diff --git a/token/driver/mock/iw.go b/token/driver/mock/iw.go new file mode 100644 index 0000000000..18b3ce2134 --- /dev/null +++ b/token/driver/mock/iw.go @@ -0,0 +1,485 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package mock + +import ( + "context" + "sync" + + "github.com/hyperledger-labs/fabric-token-sdk/token/driver" + "github.com/hyperledger-labs/fabric-token-sdk/token/token" +) + +type IssuerWallet struct { + ContainsStub func(context.Context, driver.Identity) bool + containsMutex sync.RWMutex + containsArgsForCall []struct { + arg1 context.Context + arg2 driver.Identity + } + containsReturns struct { + result1 bool + } + containsReturnsOnCall map[int]struct { + result1 bool + } + ContainsTokenStub func(context.Context, *token.UnspentToken) bool + containsTokenMutex sync.RWMutex + containsTokenArgsForCall []struct { + arg1 context.Context + arg2 *token.UnspentToken + } + containsTokenReturns struct { + result1 bool + } + containsTokenReturnsOnCall map[int]struct { + result1 bool + } + GetIssuerIdentityStub func(token.Type) (driver.Identity, error) + getIssuerIdentityMutex sync.RWMutex + getIssuerIdentityArgsForCall []struct { + arg1 token.Type + } + getIssuerIdentityReturns struct { + result1 driver.Identity + result2 error + } + getIssuerIdentityReturnsOnCall map[int]struct { + result1 driver.Identity + result2 error + } + GetSignerStub func(context.Context, driver.Identity) (driver.Signer, error) + getSignerMutex sync.RWMutex + getSignerArgsForCall []struct { + arg1 context.Context + arg2 driver.Identity + } + getSignerReturns struct { + result1 driver.Signer + result2 error + } + getSignerReturnsOnCall map[int]struct { + result1 driver.Signer + result2 error + } + HistoryTokensStub func(context.Context, *driver.ListTokensOptions) (*token.IssuedTokens, error) + historyTokensMutex sync.RWMutex + historyTokensArgsForCall []struct { + arg1 context.Context + arg2 *driver.ListTokensOptions + } + historyTokensReturns struct { + result1 *token.IssuedTokens + result2 error + } + historyTokensReturnsOnCall map[int]struct { + result1 *token.IssuedTokens + result2 error + } + IDStub func() string + iDMutex sync.RWMutex + iDArgsForCall []struct { + } + iDReturns struct { + result1 string + } + iDReturnsOnCall map[int]struct { + result1 string + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *IssuerWallet) Contains(arg1 context.Context, arg2 driver.Identity) bool { + fake.containsMutex.Lock() + ret, specificReturn := fake.containsReturnsOnCall[len(fake.containsArgsForCall)] + fake.containsArgsForCall = append(fake.containsArgsForCall, struct { + arg1 context.Context + arg2 driver.Identity + }{arg1, arg2}) + stub := fake.ContainsStub + fakeReturns := fake.containsReturns + fake.recordInvocation("Contains", []interface{}{arg1, arg2}) + fake.containsMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *IssuerWallet) ContainsCallCount() int { + fake.containsMutex.RLock() + defer fake.containsMutex.RUnlock() + return len(fake.containsArgsForCall) +} + +func (fake *IssuerWallet) ContainsCalls(stub func(context.Context, driver.Identity) bool) { + fake.containsMutex.Lock() + defer fake.containsMutex.Unlock() + fake.ContainsStub = stub +} + +func (fake *IssuerWallet) ContainsArgsForCall(i int) (context.Context, driver.Identity) { + fake.containsMutex.RLock() + defer fake.containsMutex.RUnlock() + argsForCall := fake.containsArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *IssuerWallet) ContainsReturns(result1 bool) { + fake.containsMutex.Lock() + defer fake.containsMutex.Unlock() + fake.ContainsStub = nil + fake.containsReturns = struct { + result1 bool + }{result1} +} + +func (fake *IssuerWallet) ContainsReturnsOnCall(i int, result1 bool) { + fake.containsMutex.Lock() + defer fake.containsMutex.Unlock() + fake.ContainsStub = nil + if fake.containsReturnsOnCall == nil { + fake.containsReturnsOnCall = make(map[int]struct { + result1 bool + }) + } + fake.containsReturnsOnCall[i] = struct { + result1 bool + }{result1} +} + +func (fake *IssuerWallet) ContainsToken(arg1 context.Context, arg2 *token.UnspentToken) bool { + fake.containsTokenMutex.Lock() + ret, specificReturn := fake.containsTokenReturnsOnCall[len(fake.containsTokenArgsForCall)] + fake.containsTokenArgsForCall = append(fake.containsTokenArgsForCall, struct { + arg1 context.Context + arg2 *token.UnspentToken + }{arg1, arg2}) + stub := fake.ContainsTokenStub + fakeReturns := fake.containsTokenReturns + fake.recordInvocation("ContainsToken", []interface{}{arg1, arg2}) + fake.containsTokenMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *IssuerWallet) ContainsTokenCallCount() int { + fake.containsTokenMutex.RLock() + defer fake.containsTokenMutex.RUnlock() + return len(fake.containsTokenArgsForCall) +} + +func (fake *IssuerWallet) ContainsTokenCalls(stub func(context.Context, *token.UnspentToken) bool) { + fake.containsTokenMutex.Lock() + defer fake.containsTokenMutex.Unlock() + fake.ContainsTokenStub = stub +} + +func (fake *IssuerWallet) ContainsTokenArgsForCall(i int) (context.Context, *token.UnspentToken) { + fake.containsTokenMutex.RLock() + defer fake.containsTokenMutex.RUnlock() + argsForCall := fake.containsTokenArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *IssuerWallet) ContainsTokenReturns(result1 bool) { + fake.containsTokenMutex.Lock() + defer fake.containsTokenMutex.Unlock() + fake.ContainsTokenStub = nil + fake.containsTokenReturns = struct { + result1 bool + }{result1} +} + +func (fake *IssuerWallet) ContainsTokenReturnsOnCall(i int, result1 bool) { + fake.containsTokenMutex.Lock() + defer fake.containsTokenMutex.Unlock() + fake.ContainsTokenStub = nil + if fake.containsTokenReturnsOnCall == nil { + fake.containsTokenReturnsOnCall = make(map[int]struct { + result1 bool + }) + } + fake.containsTokenReturnsOnCall[i] = struct { + result1 bool + }{result1} +} + +func (fake *IssuerWallet) GetIssuerIdentity(arg1 token.Type) (driver.Identity, error) { + fake.getIssuerIdentityMutex.Lock() + ret, specificReturn := fake.getIssuerIdentityReturnsOnCall[len(fake.getIssuerIdentityArgsForCall)] + fake.getIssuerIdentityArgsForCall = append(fake.getIssuerIdentityArgsForCall, struct { + arg1 token.Type + }{arg1}) + stub := fake.GetIssuerIdentityStub + fakeReturns := fake.getIssuerIdentityReturns + fake.recordInvocation("GetIssuerIdentity", []interface{}{arg1}) + fake.getIssuerIdentityMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *IssuerWallet) GetIssuerIdentityCallCount() int { + fake.getIssuerIdentityMutex.RLock() + defer fake.getIssuerIdentityMutex.RUnlock() + return len(fake.getIssuerIdentityArgsForCall) +} + +func (fake *IssuerWallet) GetIssuerIdentityCalls(stub func(token.Type) (driver.Identity, error)) { + fake.getIssuerIdentityMutex.Lock() + defer fake.getIssuerIdentityMutex.Unlock() + fake.GetIssuerIdentityStub = stub +} + +func (fake *IssuerWallet) GetIssuerIdentityArgsForCall(i int) token.Type { + fake.getIssuerIdentityMutex.RLock() + defer fake.getIssuerIdentityMutex.RUnlock() + argsForCall := fake.getIssuerIdentityArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *IssuerWallet) GetIssuerIdentityReturns(result1 driver.Identity, result2 error) { + fake.getIssuerIdentityMutex.Lock() + defer fake.getIssuerIdentityMutex.Unlock() + fake.GetIssuerIdentityStub = nil + fake.getIssuerIdentityReturns = struct { + result1 driver.Identity + result2 error + }{result1, result2} +} + +func (fake *IssuerWallet) GetIssuerIdentityReturnsOnCall(i int, result1 driver.Identity, result2 error) { + fake.getIssuerIdentityMutex.Lock() + defer fake.getIssuerIdentityMutex.Unlock() + fake.GetIssuerIdentityStub = nil + if fake.getIssuerIdentityReturnsOnCall == nil { + fake.getIssuerIdentityReturnsOnCall = make(map[int]struct { + result1 driver.Identity + result2 error + }) + } + fake.getIssuerIdentityReturnsOnCall[i] = struct { + result1 driver.Identity + result2 error + }{result1, result2} +} + +func (fake *IssuerWallet) GetSigner(arg1 context.Context, arg2 driver.Identity) (driver.Signer, error) { + fake.getSignerMutex.Lock() + ret, specificReturn := fake.getSignerReturnsOnCall[len(fake.getSignerArgsForCall)] + fake.getSignerArgsForCall = append(fake.getSignerArgsForCall, struct { + arg1 context.Context + arg2 driver.Identity + }{arg1, arg2}) + stub := fake.GetSignerStub + fakeReturns := fake.getSignerReturns + fake.recordInvocation("GetSigner", []interface{}{arg1, arg2}) + fake.getSignerMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *IssuerWallet) GetSignerCallCount() int { + fake.getSignerMutex.RLock() + defer fake.getSignerMutex.RUnlock() + return len(fake.getSignerArgsForCall) +} + +func (fake *IssuerWallet) GetSignerCalls(stub func(context.Context, driver.Identity) (driver.Signer, error)) { + fake.getSignerMutex.Lock() + defer fake.getSignerMutex.Unlock() + fake.GetSignerStub = stub +} + +func (fake *IssuerWallet) GetSignerArgsForCall(i int) (context.Context, driver.Identity) { + fake.getSignerMutex.RLock() + defer fake.getSignerMutex.RUnlock() + argsForCall := fake.getSignerArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *IssuerWallet) GetSignerReturns(result1 driver.Signer, result2 error) { + fake.getSignerMutex.Lock() + defer fake.getSignerMutex.Unlock() + fake.GetSignerStub = nil + fake.getSignerReturns = struct { + result1 driver.Signer + result2 error + }{result1, result2} +} + +func (fake *IssuerWallet) GetSignerReturnsOnCall(i int, result1 driver.Signer, result2 error) { + fake.getSignerMutex.Lock() + defer fake.getSignerMutex.Unlock() + fake.GetSignerStub = nil + if fake.getSignerReturnsOnCall == nil { + fake.getSignerReturnsOnCall = make(map[int]struct { + result1 driver.Signer + result2 error + }) + } + fake.getSignerReturnsOnCall[i] = struct { + result1 driver.Signer + result2 error + }{result1, result2} +} + +func (fake *IssuerWallet) HistoryTokens(arg1 context.Context, arg2 *driver.ListTokensOptions) (*token.IssuedTokens, error) { + fake.historyTokensMutex.Lock() + ret, specificReturn := fake.historyTokensReturnsOnCall[len(fake.historyTokensArgsForCall)] + fake.historyTokensArgsForCall = append(fake.historyTokensArgsForCall, struct { + arg1 context.Context + arg2 *driver.ListTokensOptions + }{arg1, arg2}) + stub := fake.HistoryTokensStub + fakeReturns := fake.historyTokensReturns + fake.recordInvocation("HistoryTokens", []interface{}{arg1, arg2}) + fake.historyTokensMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *IssuerWallet) HistoryTokensCallCount() int { + fake.historyTokensMutex.RLock() + defer fake.historyTokensMutex.RUnlock() + return len(fake.historyTokensArgsForCall) +} + +func (fake *IssuerWallet) HistoryTokensCalls(stub func(context.Context, *driver.ListTokensOptions) (*token.IssuedTokens, error)) { + fake.historyTokensMutex.Lock() + defer fake.historyTokensMutex.Unlock() + fake.HistoryTokensStub = stub +} + +func (fake *IssuerWallet) HistoryTokensArgsForCall(i int) (context.Context, *driver.ListTokensOptions) { + fake.historyTokensMutex.RLock() + defer fake.historyTokensMutex.RUnlock() + argsForCall := fake.historyTokensArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *IssuerWallet) HistoryTokensReturns(result1 *token.IssuedTokens, result2 error) { + fake.historyTokensMutex.Lock() + defer fake.historyTokensMutex.Unlock() + fake.HistoryTokensStub = nil + fake.historyTokensReturns = struct { + result1 *token.IssuedTokens + result2 error + }{result1, result2} +} + +func (fake *IssuerWallet) HistoryTokensReturnsOnCall(i int, result1 *token.IssuedTokens, result2 error) { + fake.historyTokensMutex.Lock() + defer fake.historyTokensMutex.Unlock() + fake.HistoryTokensStub = nil + if fake.historyTokensReturnsOnCall == nil { + fake.historyTokensReturnsOnCall = make(map[int]struct { + result1 *token.IssuedTokens + result2 error + }) + } + fake.historyTokensReturnsOnCall[i] = struct { + result1 *token.IssuedTokens + result2 error + }{result1, result2} +} + +func (fake *IssuerWallet) ID() string { + fake.iDMutex.Lock() + ret, specificReturn := fake.iDReturnsOnCall[len(fake.iDArgsForCall)] + fake.iDArgsForCall = append(fake.iDArgsForCall, struct { + }{}) + stub := fake.IDStub + fakeReturns := fake.iDReturns + fake.recordInvocation("ID", []interface{}{}) + fake.iDMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *IssuerWallet) IDCallCount() int { + fake.iDMutex.RLock() + defer fake.iDMutex.RUnlock() + return len(fake.iDArgsForCall) +} + +func (fake *IssuerWallet) IDCalls(stub func() string) { + fake.iDMutex.Lock() + defer fake.iDMutex.Unlock() + fake.IDStub = stub +} + +func (fake *IssuerWallet) IDReturns(result1 string) { + fake.iDMutex.Lock() + defer fake.iDMutex.Unlock() + fake.IDStub = nil + fake.iDReturns = struct { + result1 string + }{result1} +} + +func (fake *IssuerWallet) IDReturnsOnCall(i int, result1 string) { + fake.iDMutex.Lock() + defer fake.iDMutex.Unlock() + fake.IDStub = nil + if fake.iDReturnsOnCall == nil { + fake.iDReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.iDReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *IssuerWallet) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *IssuerWallet) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ driver.IssuerWallet = new(IssuerWallet) diff --git a/token/driver/mock/ow.go b/token/driver/mock/ow.go new file mode 100644 index 0000000000..ee5f65b195 --- /dev/null +++ b/token/driver/mock/ow.go @@ -0,0 +1,1149 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package mock + +import ( + "context" + "sync" + + "github.com/hyperledger-labs/fabric-token-sdk/token/driver" + "github.com/hyperledger-labs/fabric-token-sdk/token/token" +) + +type OwnerWallet struct { + BalanceStub func(context.Context, *driver.ListTokensOptions) (uint64, error) + balanceMutex sync.RWMutex + balanceArgsForCall []struct { + arg1 context.Context + arg2 *driver.ListTokensOptions + } + balanceReturns struct { + result1 uint64 + result2 error + } + balanceReturnsOnCall map[int]struct { + result1 uint64 + result2 error + } + ContainsStub func(context.Context, driver.Identity) bool + containsMutex sync.RWMutex + containsArgsForCall []struct { + arg1 context.Context + arg2 driver.Identity + } + containsReturns struct { + result1 bool + } + containsReturnsOnCall map[int]struct { + result1 bool + } + ContainsTokenStub func(context.Context, *token.UnspentToken) bool + containsTokenMutex sync.RWMutex + containsTokenArgsForCall []struct { + arg1 context.Context + arg2 *token.UnspentToken + } + containsTokenReturns struct { + result1 bool + } + containsTokenReturnsOnCall map[int]struct { + result1 bool + } + EnrollmentIDStub func() string + enrollmentIDMutex sync.RWMutex + enrollmentIDArgsForCall []struct { + } + enrollmentIDReturns struct { + result1 string + } + enrollmentIDReturnsOnCall map[int]struct { + result1 string + } + GetAuditInfoStub func(context.Context, driver.Identity) ([]byte, error) + getAuditInfoMutex sync.RWMutex + getAuditInfoArgsForCall []struct { + arg1 context.Context + arg2 driver.Identity + } + getAuditInfoReturns struct { + result1 []byte + result2 error + } + getAuditInfoReturnsOnCall map[int]struct { + result1 []byte + result2 error + } + GetRecipientDataStub func(context.Context) (*driver.RecipientData, error) + getRecipientDataMutex sync.RWMutex + getRecipientDataArgsForCall []struct { + arg1 context.Context + } + getRecipientDataReturns struct { + result1 *driver.RecipientData + result2 error + } + getRecipientDataReturnsOnCall map[int]struct { + result1 *driver.RecipientData + result2 error + } + GetRecipientIdentityStub func(context.Context) (driver.Identity, error) + getRecipientIdentityMutex sync.RWMutex + getRecipientIdentityArgsForCall []struct { + arg1 context.Context + } + getRecipientIdentityReturns struct { + result1 driver.Identity + result2 error + } + getRecipientIdentityReturnsOnCall map[int]struct { + result1 driver.Identity + result2 error + } + GetSignerStub func(context.Context, driver.Identity) (driver.Signer, error) + getSignerMutex sync.RWMutex + getSignerArgsForCall []struct { + arg1 context.Context + arg2 driver.Identity + } + getSignerReturns struct { + result1 driver.Signer + result2 error + } + getSignerReturnsOnCall map[int]struct { + result1 driver.Signer + result2 error + } + GetTokenMetadataStub func(driver.Identity) ([]byte, error) + getTokenMetadataMutex sync.RWMutex + getTokenMetadataArgsForCall []struct { + arg1 driver.Identity + } + getTokenMetadataReturns struct { + result1 []byte + result2 error + } + getTokenMetadataReturnsOnCall map[int]struct { + result1 []byte + result2 error + } + GetTokenMetadataAuditInfoStub func(driver.Identity) ([]byte, error) + getTokenMetadataAuditInfoMutex sync.RWMutex + getTokenMetadataAuditInfoArgsForCall []struct { + arg1 driver.Identity + } + getTokenMetadataAuditInfoReturns struct { + result1 []byte + result2 error + } + getTokenMetadataAuditInfoReturnsOnCall map[int]struct { + result1 []byte + result2 error + } + IDStub func() string + iDMutex sync.RWMutex + iDArgsForCall []struct { + } + iDReturns struct { + result1 string + } + iDReturnsOnCall map[int]struct { + result1 string + } + ListTokensStub func(*driver.ListTokensOptions) (*token.UnspentTokens, error) + listTokensMutex sync.RWMutex + listTokensArgsForCall []struct { + arg1 *driver.ListTokensOptions + } + listTokensReturns struct { + result1 *token.UnspentTokens + result2 error + } + listTokensReturnsOnCall map[int]struct { + result1 *token.UnspentTokens + result2 error + } + ListTokensIteratorStub func(*driver.ListTokensOptions) (driver.UnspentTokensIterator, error) + listTokensIteratorMutex sync.RWMutex + listTokensIteratorArgsForCall []struct { + arg1 *driver.ListTokensOptions + } + listTokensIteratorReturns struct { + result1 driver.UnspentTokensIterator + result2 error + } + listTokensIteratorReturnsOnCall map[int]struct { + result1 driver.UnspentTokensIterator + result2 error + } + RegisterRecipientStub func(context.Context, *driver.RecipientData) error + registerRecipientMutex sync.RWMutex + registerRecipientArgsForCall []struct { + arg1 context.Context + arg2 *driver.RecipientData + } + registerRecipientReturns struct { + result1 error + } + registerRecipientReturnsOnCall map[int]struct { + result1 error + } + RemoteStub func() bool + remoteMutex sync.RWMutex + remoteArgsForCall []struct { + } + remoteReturns struct { + result1 bool + } + remoteReturnsOnCall map[int]struct { + result1 bool + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *OwnerWallet) Balance(arg1 context.Context, arg2 *driver.ListTokensOptions) (uint64, error) { + fake.balanceMutex.Lock() + ret, specificReturn := fake.balanceReturnsOnCall[len(fake.balanceArgsForCall)] + fake.balanceArgsForCall = append(fake.balanceArgsForCall, struct { + arg1 context.Context + arg2 *driver.ListTokensOptions + }{arg1, arg2}) + stub := fake.BalanceStub + fakeReturns := fake.balanceReturns + fake.recordInvocation("Balance", []interface{}{arg1, arg2}) + fake.balanceMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *OwnerWallet) BalanceCallCount() int { + fake.balanceMutex.RLock() + defer fake.balanceMutex.RUnlock() + return len(fake.balanceArgsForCall) +} + +func (fake *OwnerWallet) BalanceCalls(stub func(context.Context, *driver.ListTokensOptions) (uint64, error)) { + fake.balanceMutex.Lock() + defer fake.balanceMutex.Unlock() + fake.BalanceStub = stub +} + +func (fake *OwnerWallet) BalanceArgsForCall(i int) (context.Context, *driver.ListTokensOptions) { + fake.balanceMutex.RLock() + defer fake.balanceMutex.RUnlock() + argsForCall := fake.balanceArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *OwnerWallet) BalanceReturns(result1 uint64, result2 error) { + fake.balanceMutex.Lock() + defer fake.balanceMutex.Unlock() + fake.BalanceStub = nil + fake.balanceReturns = struct { + result1 uint64 + result2 error + }{result1, result2} +} + +func (fake *OwnerWallet) BalanceReturnsOnCall(i int, result1 uint64, result2 error) { + fake.balanceMutex.Lock() + defer fake.balanceMutex.Unlock() + fake.BalanceStub = nil + if fake.balanceReturnsOnCall == nil { + fake.balanceReturnsOnCall = make(map[int]struct { + result1 uint64 + result2 error + }) + } + fake.balanceReturnsOnCall[i] = struct { + result1 uint64 + result2 error + }{result1, result2} +} + +func (fake *OwnerWallet) Contains(arg1 context.Context, arg2 driver.Identity) bool { + fake.containsMutex.Lock() + ret, specificReturn := fake.containsReturnsOnCall[len(fake.containsArgsForCall)] + fake.containsArgsForCall = append(fake.containsArgsForCall, struct { + arg1 context.Context + arg2 driver.Identity + }{arg1, arg2}) + stub := fake.ContainsStub + fakeReturns := fake.containsReturns + fake.recordInvocation("Contains", []interface{}{arg1, arg2}) + fake.containsMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *OwnerWallet) ContainsCallCount() int { + fake.containsMutex.RLock() + defer fake.containsMutex.RUnlock() + return len(fake.containsArgsForCall) +} + +func (fake *OwnerWallet) ContainsCalls(stub func(context.Context, driver.Identity) bool) { + fake.containsMutex.Lock() + defer fake.containsMutex.Unlock() + fake.ContainsStub = stub +} + +func (fake *OwnerWallet) ContainsArgsForCall(i int) (context.Context, driver.Identity) { + fake.containsMutex.RLock() + defer fake.containsMutex.RUnlock() + argsForCall := fake.containsArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *OwnerWallet) ContainsReturns(result1 bool) { + fake.containsMutex.Lock() + defer fake.containsMutex.Unlock() + fake.ContainsStub = nil + fake.containsReturns = struct { + result1 bool + }{result1} +} + +func (fake *OwnerWallet) ContainsReturnsOnCall(i int, result1 bool) { + fake.containsMutex.Lock() + defer fake.containsMutex.Unlock() + fake.ContainsStub = nil + if fake.containsReturnsOnCall == nil { + fake.containsReturnsOnCall = make(map[int]struct { + result1 bool + }) + } + fake.containsReturnsOnCall[i] = struct { + result1 bool + }{result1} +} + +func (fake *OwnerWallet) ContainsToken(arg1 context.Context, arg2 *token.UnspentToken) bool { + fake.containsTokenMutex.Lock() + ret, specificReturn := fake.containsTokenReturnsOnCall[len(fake.containsTokenArgsForCall)] + fake.containsTokenArgsForCall = append(fake.containsTokenArgsForCall, struct { + arg1 context.Context + arg2 *token.UnspentToken + }{arg1, arg2}) + stub := fake.ContainsTokenStub + fakeReturns := fake.containsTokenReturns + fake.recordInvocation("ContainsToken", []interface{}{arg1, arg2}) + fake.containsTokenMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *OwnerWallet) ContainsTokenCallCount() int { + fake.containsTokenMutex.RLock() + defer fake.containsTokenMutex.RUnlock() + return len(fake.containsTokenArgsForCall) +} + +func (fake *OwnerWallet) ContainsTokenCalls(stub func(context.Context, *token.UnspentToken) bool) { + fake.containsTokenMutex.Lock() + defer fake.containsTokenMutex.Unlock() + fake.ContainsTokenStub = stub +} + +func (fake *OwnerWallet) ContainsTokenArgsForCall(i int) (context.Context, *token.UnspentToken) { + fake.containsTokenMutex.RLock() + defer fake.containsTokenMutex.RUnlock() + argsForCall := fake.containsTokenArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *OwnerWallet) ContainsTokenReturns(result1 bool) { + fake.containsTokenMutex.Lock() + defer fake.containsTokenMutex.Unlock() + fake.ContainsTokenStub = nil + fake.containsTokenReturns = struct { + result1 bool + }{result1} +} + +func (fake *OwnerWallet) ContainsTokenReturnsOnCall(i int, result1 bool) { + fake.containsTokenMutex.Lock() + defer fake.containsTokenMutex.Unlock() + fake.ContainsTokenStub = nil + if fake.containsTokenReturnsOnCall == nil { + fake.containsTokenReturnsOnCall = make(map[int]struct { + result1 bool + }) + } + fake.containsTokenReturnsOnCall[i] = struct { + result1 bool + }{result1} +} + +func (fake *OwnerWallet) EnrollmentID() string { + fake.enrollmentIDMutex.Lock() + ret, specificReturn := fake.enrollmentIDReturnsOnCall[len(fake.enrollmentIDArgsForCall)] + fake.enrollmentIDArgsForCall = append(fake.enrollmentIDArgsForCall, struct { + }{}) + stub := fake.EnrollmentIDStub + fakeReturns := fake.enrollmentIDReturns + fake.recordInvocation("EnrollmentID", []interface{}{}) + fake.enrollmentIDMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *OwnerWallet) EnrollmentIDCallCount() int { + fake.enrollmentIDMutex.RLock() + defer fake.enrollmentIDMutex.RUnlock() + return len(fake.enrollmentIDArgsForCall) +} + +func (fake *OwnerWallet) EnrollmentIDCalls(stub func() string) { + fake.enrollmentIDMutex.Lock() + defer fake.enrollmentIDMutex.Unlock() + fake.EnrollmentIDStub = stub +} + +func (fake *OwnerWallet) EnrollmentIDReturns(result1 string) { + fake.enrollmentIDMutex.Lock() + defer fake.enrollmentIDMutex.Unlock() + fake.EnrollmentIDStub = nil + fake.enrollmentIDReturns = struct { + result1 string + }{result1} +} + +func (fake *OwnerWallet) EnrollmentIDReturnsOnCall(i int, result1 string) { + fake.enrollmentIDMutex.Lock() + defer fake.enrollmentIDMutex.Unlock() + fake.EnrollmentIDStub = nil + if fake.enrollmentIDReturnsOnCall == nil { + fake.enrollmentIDReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.enrollmentIDReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *OwnerWallet) GetAuditInfo(arg1 context.Context, arg2 driver.Identity) ([]byte, error) { + fake.getAuditInfoMutex.Lock() + ret, specificReturn := fake.getAuditInfoReturnsOnCall[len(fake.getAuditInfoArgsForCall)] + fake.getAuditInfoArgsForCall = append(fake.getAuditInfoArgsForCall, struct { + arg1 context.Context + arg2 driver.Identity + }{arg1, arg2}) + stub := fake.GetAuditInfoStub + fakeReturns := fake.getAuditInfoReturns + fake.recordInvocation("GetAuditInfo", []interface{}{arg1, arg2}) + fake.getAuditInfoMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *OwnerWallet) GetAuditInfoCallCount() int { + fake.getAuditInfoMutex.RLock() + defer fake.getAuditInfoMutex.RUnlock() + return len(fake.getAuditInfoArgsForCall) +} + +func (fake *OwnerWallet) GetAuditInfoCalls(stub func(context.Context, driver.Identity) ([]byte, error)) { + fake.getAuditInfoMutex.Lock() + defer fake.getAuditInfoMutex.Unlock() + fake.GetAuditInfoStub = stub +} + +func (fake *OwnerWallet) GetAuditInfoArgsForCall(i int) (context.Context, driver.Identity) { + fake.getAuditInfoMutex.RLock() + defer fake.getAuditInfoMutex.RUnlock() + argsForCall := fake.getAuditInfoArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *OwnerWallet) GetAuditInfoReturns(result1 []byte, result2 error) { + fake.getAuditInfoMutex.Lock() + defer fake.getAuditInfoMutex.Unlock() + fake.GetAuditInfoStub = nil + fake.getAuditInfoReturns = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *OwnerWallet) GetAuditInfoReturnsOnCall(i int, result1 []byte, result2 error) { + fake.getAuditInfoMutex.Lock() + defer fake.getAuditInfoMutex.Unlock() + fake.GetAuditInfoStub = nil + if fake.getAuditInfoReturnsOnCall == nil { + fake.getAuditInfoReturnsOnCall = make(map[int]struct { + result1 []byte + result2 error + }) + } + fake.getAuditInfoReturnsOnCall[i] = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *OwnerWallet) GetRecipientData(arg1 context.Context) (*driver.RecipientData, error) { + fake.getRecipientDataMutex.Lock() + ret, specificReturn := fake.getRecipientDataReturnsOnCall[len(fake.getRecipientDataArgsForCall)] + fake.getRecipientDataArgsForCall = append(fake.getRecipientDataArgsForCall, struct { + arg1 context.Context + }{arg1}) + stub := fake.GetRecipientDataStub + fakeReturns := fake.getRecipientDataReturns + fake.recordInvocation("GetRecipientData", []interface{}{arg1}) + fake.getRecipientDataMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *OwnerWallet) GetRecipientDataCallCount() int { + fake.getRecipientDataMutex.RLock() + defer fake.getRecipientDataMutex.RUnlock() + return len(fake.getRecipientDataArgsForCall) +} + +func (fake *OwnerWallet) GetRecipientDataCalls(stub func(context.Context) (*driver.RecipientData, error)) { + fake.getRecipientDataMutex.Lock() + defer fake.getRecipientDataMutex.Unlock() + fake.GetRecipientDataStub = stub +} + +func (fake *OwnerWallet) GetRecipientDataArgsForCall(i int) context.Context { + fake.getRecipientDataMutex.RLock() + defer fake.getRecipientDataMutex.RUnlock() + argsForCall := fake.getRecipientDataArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *OwnerWallet) GetRecipientDataReturns(result1 *driver.RecipientData, result2 error) { + fake.getRecipientDataMutex.Lock() + defer fake.getRecipientDataMutex.Unlock() + fake.GetRecipientDataStub = nil + fake.getRecipientDataReturns = struct { + result1 *driver.RecipientData + result2 error + }{result1, result2} +} + +func (fake *OwnerWallet) GetRecipientDataReturnsOnCall(i int, result1 *driver.RecipientData, result2 error) { + fake.getRecipientDataMutex.Lock() + defer fake.getRecipientDataMutex.Unlock() + fake.GetRecipientDataStub = nil + if fake.getRecipientDataReturnsOnCall == nil { + fake.getRecipientDataReturnsOnCall = make(map[int]struct { + result1 *driver.RecipientData + result2 error + }) + } + fake.getRecipientDataReturnsOnCall[i] = struct { + result1 *driver.RecipientData + result2 error + }{result1, result2} +} + +func (fake *OwnerWallet) GetRecipientIdentity(arg1 context.Context) (driver.Identity, error) { + fake.getRecipientIdentityMutex.Lock() + ret, specificReturn := fake.getRecipientIdentityReturnsOnCall[len(fake.getRecipientIdentityArgsForCall)] + fake.getRecipientIdentityArgsForCall = append(fake.getRecipientIdentityArgsForCall, struct { + arg1 context.Context + }{arg1}) + stub := fake.GetRecipientIdentityStub + fakeReturns := fake.getRecipientIdentityReturns + fake.recordInvocation("GetRecipientIdentity", []interface{}{arg1}) + fake.getRecipientIdentityMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *OwnerWallet) GetRecipientIdentityCallCount() int { + fake.getRecipientIdentityMutex.RLock() + defer fake.getRecipientIdentityMutex.RUnlock() + return len(fake.getRecipientIdentityArgsForCall) +} + +func (fake *OwnerWallet) GetRecipientIdentityCalls(stub func(context.Context) (driver.Identity, error)) { + fake.getRecipientIdentityMutex.Lock() + defer fake.getRecipientIdentityMutex.Unlock() + fake.GetRecipientIdentityStub = stub +} + +func (fake *OwnerWallet) GetRecipientIdentityArgsForCall(i int) context.Context { + fake.getRecipientIdentityMutex.RLock() + defer fake.getRecipientIdentityMutex.RUnlock() + argsForCall := fake.getRecipientIdentityArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *OwnerWallet) GetRecipientIdentityReturns(result1 driver.Identity, result2 error) { + fake.getRecipientIdentityMutex.Lock() + defer fake.getRecipientIdentityMutex.Unlock() + fake.GetRecipientIdentityStub = nil + fake.getRecipientIdentityReturns = struct { + result1 driver.Identity + result2 error + }{result1, result2} +} + +func (fake *OwnerWallet) GetRecipientIdentityReturnsOnCall(i int, result1 driver.Identity, result2 error) { + fake.getRecipientIdentityMutex.Lock() + defer fake.getRecipientIdentityMutex.Unlock() + fake.GetRecipientIdentityStub = nil + if fake.getRecipientIdentityReturnsOnCall == nil { + fake.getRecipientIdentityReturnsOnCall = make(map[int]struct { + result1 driver.Identity + result2 error + }) + } + fake.getRecipientIdentityReturnsOnCall[i] = struct { + result1 driver.Identity + result2 error + }{result1, result2} +} + +func (fake *OwnerWallet) GetSigner(arg1 context.Context, arg2 driver.Identity) (driver.Signer, error) { + fake.getSignerMutex.Lock() + ret, specificReturn := fake.getSignerReturnsOnCall[len(fake.getSignerArgsForCall)] + fake.getSignerArgsForCall = append(fake.getSignerArgsForCall, struct { + arg1 context.Context + arg2 driver.Identity + }{arg1, arg2}) + stub := fake.GetSignerStub + fakeReturns := fake.getSignerReturns + fake.recordInvocation("GetSigner", []interface{}{arg1, arg2}) + fake.getSignerMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *OwnerWallet) GetSignerCallCount() int { + fake.getSignerMutex.RLock() + defer fake.getSignerMutex.RUnlock() + return len(fake.getSignerArgsForCall) +} + +func (fake *OwnerWallet) GetSignerCalls(stub func(context.Context, driver.Identity) (driver.Signer, error)) { + fake.getSignerMutex.Lock() + defer fake.getSignerMutex.Unlock() + fake.GetSignerStub = stub +} + +func (fake *OwnerWallet) GetSignerArgsForCall(i int) (context.Context, driver.Identity) { + fake.getSignerMutex.RLock() + defer fake.getSignerMutex.RUnlock() + argsForCall := fake.getSignerArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *OwnerWallet) GetSignerReturns(result1 driver.Signer, result2 error) { + fake.getSignerMutex.Lock() + defer fake.getSignerMutex.Unlock() + fake.GetSignerStub = nil + fake.getSignerReturns = struct { + result1 driver.Signer + result2 error + }{result1, result2} +} + +func (fake *OwnerWallet) GetSignerReturnsOnCall(i int, result1 driver.Signer, result2 error) { + fake.getSignerMutex.Lock() + defer fake.getSignerMutex.Unlock() + fake.GetSignerStub = nil + if fake.getSignerReturnsOnCall == nil { + fake.getSignerReturnsOnCall = make(map[int]struct { + result1 driver.Signer + result2 error + }) + } + fake.getSignerReturnsOnCall[i] = struct { + result1 driver.Signer + result2 error + }{result1, result2} +} + +func (fake *OwnerWallet) GetTokenMetadata(arg1 driver.Identity) ([]byte, error) { + fake.getTokenMetadataMutex.Lock() + ret, specificReturn := fake.getTokenMetadataReturnsOnCall[len(fake.getTokenMetadataArgsForCall)] + fake.getTokenMetadataArgsForCall = append(fake.getTokenMetadataArgsForCall, struct { + arg1 driver.Identity + }{arg1}) + stub := fake.GetTokenMetadataStub + fakeReturns := fake.getTokenMetadataReturns + fake.recordInvocation("GetTokenMetadata", []interface{}{arg1}) + fake.getTokenMetadataMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *OwnerWallet) GetTokenMetadataCallCount() int { + fake.getTokenMetadataMutex.RLock() + defer fake.getTokenMetadataMutex.RUnlock() + return len(fake.getTokenMetadataArgsForCall) +} + +func (fake *OwnerWallet) GetTokenMetadataCalls(stub func(driver.Identity) ([]byte, error)) { + fake.getTokenMetadataMutex.Lock() + defer fake.getTokenMetadataMutex.Unlock() + fake.GetTokenMetadataStub = stub +} + +func (fake *OwnerWallet) GetTokenMetadataArgsForCall(i int) driver.Identity { + fake.getTokenMetadataMutex.RLock() + defer fake.getTokenMetadataMutex.RUnlock() + argsForCall := fake.getTokenMetadataArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *OwnerWallet) GetTokenMetadataReturns(result1 []byte, result2 error) { + fake.getTokenMetadataMutex.Lock() + defer fake.getTokenMetadataMutex.Unlock() + fake.GetTokenMetadataStub = nil + fake.getTokenMetadataReturns = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *OwnerWallet) GetTokenMetadataReturnsOnCall(i int, result1 []byte, result2 error) { + fake.getTokenMetadataMutex.Lock() + defer fake.getTokenMetadataMutex.Unlock() + fake.GetTokenMetadataStub = nil + if fake.getTokenMetadataReturnsOnCall == nil { + fake.getTokenMetadataReturnsOnCall = make(map[int]struct { + result1 []byte + result2 error + }) + } + fake.getTokenMetadataReturnsOnCall[i] = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *OwnerWallet) GetTokenMetadataAuditInfo(arg1 driver.Identity) ([]byte, error) { + fake.getTokenMetadataAuditInfoMutex.Lock() + ret, specificReturn := fake.getTokenMetadataAuditInfoReturnsOnCall[len(fake.getTokenMetadataAuditInfoArgsForCall)] + fake.getTokenMetadataAuditInfoArgsForCall = append(fake.getTokenMetadataAuditInfoArgsForCall, struct { + arg1 driver.Identity + }{arg1}) + stub := fake.GetTokenMetadataAuditInfoStub + fakeReturns := fake.getTokenMetadataAuditInfoReturns + fake.recordInvocation("GetTokenMetadataAuditInfo", []interface{}{arg1}) + fake.getTokenMetadataAuditInfoMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *OwnerWallet) GetTokenMetadataAuditInfoCallCount() int { + fake.getTokenMetadataAuditInfoMutex.RLock() + defer fake.getTokenMetadataAuditInfoMutex.RUnlock() + return len(fake.getTokenMetadataAuditInfoArgsForCall) +} + +func (fake *OwnerWallet) GetTokenMetadataAuditInfoCalls(stub func(driver.Identity) ([]byte, error)) { + fake.getTokenMetadataAuditInfoMutex.Lock() + defer fake.getTokenMetadataAuditInfoMutex.Unlock() + fake.GetTokenMetadataAuditInfoStub = stub +} + +func (fake *OwnerWallet) GetTokenMetadataAuditInfoArgsForCall(i int) driver.Identity { + fake.getTokenMetadataAuditInfoMutex.RLock() + defer fake.getTokenMetadataAuditInfoMutex.RUnlock() + argsForCall := fake.getTokenMetadataAuditInfoArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *OwnerWallet) GetTokenMetadataAuditInfoReturns(result1 []byte, result2 error) { + fake.getTokenMetadataAuditInfoMutex.Lock() + defer fake.getTokenMetadataAuditInfoMutex.Unlock() + fake.GetTokenMetadataAuditInfoStub = nil + fake.getTokenMetadataAuditInfoReturns = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *OwnerWallet) GetTokenMetadataAuditInfoReturnsOnCall(i int, result1 []byte, result2 error) { + fake.getTokenMetadataAuditInfoMutex.Lock() + defer fake.getTokenMetadataAuditInfoMutex.Unlock() + fake.GetTokenMetadataAuditInfoStub = nil + if fake.getTokenMetadataAuditInfoReturnsOnCall == nil { + fake.getTokenMetadataAuditInfoReturnsOnCall = make(map[int]struct { + result1 []byte + result2 error + }) + } + fake.getTokenMetadataAuditInfoReturnsOnCall[i] = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *OwnerWallet) ID() string { + fake.iDMutex.Lock() + ret, specificReturn := fake.iDReturnsOnCall[len(fake.iDArgsForCall)] + fake.iDArgsForCall = append(fake.iDArgsForCall, struct { + }{}) + stub := fake.IDStub + fakeReturns := fake.iDReturns + fake.recordInvocation("ID", []interface{}{}) + fake.iDMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *OwnerWallet) IDCallCount() int { + fake.iDMutex.RLock() + defer fake.iDMutex.RUnlock() + return len(fake.iDArgsForCall) +} + +func (fake *OwnerWallet) IDCalls(stub func() string) { + fake.iDMutex.Lock() + defer fake.iDMutex.Unlock() + fake.IDStub = stub +} + +func (fake *OwnerWallet) IDReturns(result1 string) { + fake.iDMutex.Lock() + defer fake.iDMutex.Unlock() + fake.IDStub = nil + fake.iDReturns = struct { + result1 string + }{result1} +} + +func (fake *OwnerWallet) IDReturnsOnCall(i int, result1 string) { + fake.iDMutex.Lock() + defer fake.iDMutex.Unlock() + fake.IDStub = nil + if fake.iDReturnsOnCall == nil { + fake.iDReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.iDReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *OwnerWallet) ListTokens(arg1 *driver.ListTokensOptions) (*token.UnspentTokens, error) { + fake.listTokensMutex.Lock() + ret, specificReturn := fake.listTokensReturnsOnCall[len(fake.listTokensArgsForCall)] + fake.listTokensArgsForCall = append(fake.listTokensArgsForCall, struct { + arg1 *driver.ListTokensOptions + }{arg1}) + stub := fake.ListTokensStub + fakeReturns := fake.listTokensReturns + fake.recordInvocation("ListTokens", []interface{}{arg1}) + fake.listTokensMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *OwnerWallet) ListTokensCallCount() int { + fake.listTokensMutex.RLock() + defer fake.listTokensMutex.RUnlock() + return len(fake.listTokensArgsForCall) +} + +func (fake *OwnerWallet) ListTokensCalls(stub func(*driver.ListTokensOptions) (*token.UnspentTokens, error)) { + fake.listTokensMutex.Lock() + defer fake.listTokensMutex.Unlock() + fake.ListTokensStub = stub +} + +func (fake *OwnerWallet) ListTokensArgsForCall(i int) *driver.ListTokensOptions { + fake.listTokensMutex.RLock() + defer fake.listTokensMutex.RUnlock() + argsForCall := fake.listTokensArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *OwnerWallet) ListTokensReturns(result1 *token.UnspentTokens, result2 error) { + fake.listTokensMutex.Lock() + defer fake.listTokensMutex.Unlock() + fake.ListTokensStub = nil + fake.listTokensReturns = struct { + result1 *token.UnspentTokens + result2 error + }{result1, result2} +} + +func (fake *OwnerWallet) ListTokensReturnsOnCall(i int, result1 *token.UnspentTokens, result2 error) { + fake.listTokensMutex.Lock() + defer fake.listTokensMutex.Unlock() + fake.ListTokensStub = nil + if fake.listTokensReturnsOnCall == nil { + fake.listTokensReturnsOnCall = make(map[int]struct { + result1 *token.UnspentTokens + result2 error + }) + } + fake.listTokensReturnsOnCall[i] = struct { + result1 *token.UnspentTokens + result2 error + }{result1, result2} +} + +func (fake *OwnerWallet) ListTokensIterator(arg1 *driver.ListTokensOptions) (driver.UnspentTokensIterator, error) { + fake.listTokensIteratorMutex.Lock() + ret, specificReturn := fake.listTokensIteratorReturnsOnCall[len(fake.listTokensIteratorArgsForCall)] + fake.listTokensIteratorArgsForCall = append(fake.listTokensIteratorArgsForCall, struct { + arg1 *driver.ListTokensOptions + }{arg1}) + stub := fake.ListTokensIteratorStub + fakeReturns := fake.listTokensIteratorReturns + fake.recordInvocation("ListTokensIterator", []interface{}{arg1}) + fake.listTokensIteratorMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *OwnerWallet) ListTokensIteratorCallCount() int { + fake.listTokensIteratorMutex.RLock() + defer fake.listTokensIteratorMutex.RUnlock() + return len(fake.listTokensIteratorArgsForCall) +} + +func (fake *OwnerWallet) ListTokensIteratorCalls(stub func(*driver.ListTokensOptions) (driver.UnspentTokensIterator, error)) { + fake.listTokensIteratorMutex.Lock() + defer fake.listTokensIteratorMutex.Unlock() + fake.ListTokensIteratorStub = stub +} + +func (fake *OwnerWallet) ListTokensIteratorArgsForCall(i int) *driver.ListTokensOptions { + fake.listTokensIteratorMutex.RLock() + defer fake.listTokensIteratorMutex.RUnlock() + argsForCall := fake.listTokensIteratorArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *OwnerWallet) ListTokensIteratorReturns(result1 driver.UnspentTokensIterator, result2 error) { + fake.listTokensIteratorMutex.Lock() + defer fake.listTokensIteratorMutex.Unlock() + fake.ListTokensIteratorStub = nil + fake.listTokensIteratorReturns = struct { + result1 driver.UnspentTokensIterator + result2 error + }{result1, result2} +} + +func (fake *OwnerWallet) ListTokensIteratorReturnsOnCall(i int, result1 driver.UnspentTokensIterator, result2 error) { + fake.listTokensIteratorMutex.Lock() + defer fake.listTokensIteratorMutex.Unlock() + fake.ListTokensIteratorStub = nil + if fake.listTokensIteratorReturnsOnCall == nil { + fake.listTokensIteratorReturnsOnCall = make(map[int]struct { + result1 driver.UnspentTokensIterator + result2 error + }) + } + fake.listTokensIteratorReturnsOnCall[i] = struct { + result1 driver.UnspentTokensIterator + result2 error + }{result1, result2} +} + +func (fake *OwnerWallet) RegisterRecipient(arg1 context.Context, arg2 *driver.RecipientData) error { + fake.registerRecipientMutex.Lock() + ret, specificReturn := fake.registerRecipientReturnsOnCall[len(fake.registerRecipientArgsForCall)] + fake.registerRecipientArgsForCall = append(fake.registerRecipientArgsForCall, struct { + arg1 context.Context + arg2 *driver.RecipientData + }{arg1, arg2}) + stub := fake.RegisterRecipientStub + fakeReturns := fake.registerRecipientReturns + fake.recordInvocation("RegisterRecipient", []interface{}{arg1, arg2}) + fake.registerRecipientMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *OwnerWallet) RegisterRecipientCallCount() int { + fake.registerRecipientMutex.RLock() + defer fake.registerRecipientMutex.RUnlock() + return len(fake.registerRecipientArgsForCall) +} + +func (fake *OwnerWallet) RegisterRecipientCalls(stub func(context.Context, *driver.RecipientData) error) { + fake.registerRecipientMutex.Lock() + defer fake.registerRecipientMutex.Unlock() + fake.RegisterRecipientStub = stub +} + +func (fake *OwnerWallet) RegisterRecipientArgsForCall(i int) (context.Context, *driver.RecipientData) { + fake.registerRecipientMutex.RLock() + defer fake.registerRecipientMutex.RUnlock() + argsForCall := fake.registerRecipientArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *OwnerWallet) RegisterRecipientReturns(result1 error) { + fake.registerRecipientMutex.Lock() + defer fake.registerRecipientMutex.Unlock() + fake.RegisterRecipientStub = nil + fake.registerRecipientReturns = struct { + result1 error + }{result1} +} + +func (fake *OwnerWallet) RegisterRecipientReturnsOnCall(i int, result1 error) { + fake.registerRecipientMutex.Lock() + defer fake.registerRecipientMutex.Unlock() + fake.RegisterRecipientStub = nil + if fake.registerRecipientReturnsOnCall == nil { + fake.registerRecipientReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.registerRecipientReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *OwnerWallet) Remote() bool { + fake.remoteMutex.Lock() + ret, specificReturn := fake.remoteReturnsOnCall[len(fake.remoteArgsForCall)] + fake.remoteArgsForCall = append(fake.remoteArgsForCall, struct { + }{}) + stub := fake.RemoteStub + fakeReturns := fake.remoteReturns + fake.recordInvocation("Remote", []interface{}{}) + fake.remoteMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *OwnerWallet) RemoteCallCount() int { + fake.remoteMutex.RLock() + defer fake.remoteMutex.RUnlock() + return len(fake.remoteArgsForCall) +} + +func (fake *OwnerWallet) RemoteCalls(stub func() bool) { + fake.remoteMutex.Lock() + defer fake.remoteMutex.Unlock() + fake.RemoteStub = stub +} + +func (fake *OwnerWallet) RemoteReturns(result1 bool) { + fake.remoteMutex.Lock() + defer fake.remoteMutex.Unlock() + fake.RemoteStub = nil + fake.remoteReturns = struct { + result1 bool + }{result1} +} + +func (fake *OwnerWallet) RemoteReturnsOnCall(i int, result1 bool) { + fake.remoteMutex.Lock() + defer fake.remoteMutex.Unlock() + fake.RemoteStub = nil + if fake.remoteReturnsOnCall == nil { + fake.remoteReturnsOnCall = make(map[int]struct { + result1 bool + }) + } + fake.remoteReturnsOnCall[i] = struct { + result1 bool + }{result1} +} + +func (fake *OwnerWallet) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *OwnerWallet) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ driver.OwnerWallet = new(OwnerWallet) diff --git a/token/driver/mock/qe.go b/token/driver/mock/qe.go index 3b3d892005..b5f5178136 100644 --- a/token/driver/mock/qe.go +++ b/token/driver/mock/qe.go @@ -1307,38 +1307,6 @@ func (fake *QueryEngine) WhoDeletedTokensReturnsOnCall(i int, result1 []string, func (fake *QueryEngine) Invocations() map[string][][]interface{} { fake.invocationsMutex.RLock() defer fake.invocationsMutex.RUnlock() - fake.balanceMutex.RLock() - defer fake.balanceMutex.RUnlock() - fake.getStatusMutex.RLock() - defer fake.getStatusMutex.RUnlock() - fake.getTokenMetadataMutex.RLock() - defer fake.getTokenMetadataMutex.RUnlock() - fake.getTokenOutputsMutex.RLock() - defer fake.getTokenOutputsMutex.RUnlock() - fake.getTokenOutputsAndMetaMutex.RLock() - defer fake.getTokenOutputsAndMetaMutex.RUnlock() - fake.getTokensMutex.RLock() - defer fake.getTokensMutex.RUnlock() - fake.isMineMutex.RLock() - defer fake.isMineMutex.RUnlock() - fake.isPendingMutex.RLock() - defer fake.isPendingMutex.RUnlock() - fake.listAuditTokensMutex.RLock() - defer fake.listAuditTokensMutex.RUnlock() - fake.listHistoryIssuedTokensMutex.RLock() - defer fake.listHistoryIssuedTokensMutex.RUnlock() - fake.listUnspentTokensMutex.RLock() - defer fake.listUnspentTokensMutex.RUnlock() - fake.publicParamsMutex.RLock() - defer fake.publicParamsMutex.RUnlock() - fake.unspentLedgerTokensIteratorByMutex.RLock() - defer fake.unspentLedgerTokensIteratorByMutex.RUnlock() - fake.unspentTokensIteratorMutex.RLock() - defer fake.unspentTokensIteratorMutex.RUnlock() - fake.unspentTokensIteratorByMutex.RLock() - defer fake.unspentTokensIteratorByMutex.RUnlock() - fake.whoDeletedTokensMutex.RLock() - defer fake.whoDeletedTokensMutex.RUnlock() copiedInvocations := map[string][][]interface{}{} for key, value := range fake.invocations { copiedInvocations[key] = value diff --git a/token/driver/mock/uti.go b/token/driver/mock/uti.go index 18bb3f4791..e132b6c7da 100644 --- a/token/driver/mock/uti.go +++ b/token/driver/mock/uti.go @@ -112,10 +112,6 @@ func (fake *UnspentTokensIterator) NextReturnsOnCall(i int, result1 *token.Unspe func (fake *UnspentTokensIterator) Invocations() map[string][][]interface{} { fake.invocationsMutex.RLock() defer fake.invocationsMutex.RUnlock() - fake.closeMutex.RLock() - defer fake.closeMutex.RUnlock() - fake.nextMutex.RLock() - defer fake.nextMutex.RUnlock() copiedInvocations := map[string][][]interface{}{} for key, value := range fake.invocations { copiedInvocations[key] = value diff --git a/token/driver/mock/w.go b/token/driver/mock/w.go new file mode 100644 index 0000000000..35a43d09c8 --- /dev/null +++ b/token/driver/mock/w.go @@ -0,0 +1,329 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package mock + +import ( + "context" + "sync" + + "github.com/hyperledger-labs/fabric-token-sdk/token/driver" + "github.com/hyperledger-labs/fabric-token-sdk/token/token" +) + +type Wallet struct { + ContainsStub func(context.Context, driver.Identity) bool + containsMutex sync.RWMutex + containsArgsForCall []struct { + arg1 context.Context + arg2 driver.Identity + } + containsReturns struct { + result1 bool + } + containsReturnsOnCall map[int]struct { + result1 bool + } + ContainsTokenStub func(context.Context, *token.UnspentToken) bool + containsTokenMutex sync.RWMutex + containsTokenArgsForCall []struct { + arg1 context.Context + arg2 *token.UnspentToken + } + containsTokenReturns struct { + result1 bool + } + containsTokenReturnsOnCall map[int]struct { + result1 bool + } + GetSignerStub func(context.Context, driver.Identity) (driver.Signer, error) + getSignerMutex sync.RWMutex + getSignerArgsForCall []struct { + arg1 context.Context + arg2 driver.Identity + } + getSignerReturns struct { + result1 driver.Signer + result2 error + } + getSignerReturnsOnCall map[int]struct { + result1 driver.Signer + result2 error + } + IDStub func() string + iDMutex sync.RWMutex + iDArgsForCall []struct { + } + iDReturns struct { + result1 string + } + iDReturnsOnCall map[int]struct { + result1 string + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *Wallet) Contains(arg1 context.Context, arg2 driver.Identity) bool { + fake.containsMutex.Lock() + ret, specificReturn := fake.containsReturnsOnCall[len(fake.containsArgsForCall)] + fake.containsArgsForCall = append(fake.containsArgsForCall, struct { + arg1 context.Context + arg2 driver.Identity + }{arg1, arg2}) + stub := fake.ContainsStub + fakeReturns := fake.containsReturns + fake.recordInvocation("Contains", []interface{}{arg1, arg2}) + fake.containsMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *Wallet) ContainsCallCount() int { + fake.containsMutex.RLock() + defer fake.containsMutex.RUnlock() + return len(fake.containsArgsForCall) +} + +func (fake *Wallet) ContainsCalls(stub func(context.Context, driver.Identity) bool) { + fake.containsMutex.Lock() + defer fake.containsMutex.Unlock() + fake.ContainsStub = stub +} + +func (fake *Wallet) ContainsArgsForCall(i int) (context.Context, driver.Identity) { + fake.containsMutex.RLock() + defer fake.containsMutex.RUnlock() + argsForCall := fake.containsArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *Wallet) ContainsReturns(result1 bool) { + fake.containsMutex.Lock() + defer fake.containsMutex.Unlock() + fake.ContainsStub = nil + fake.containsReturns = struct { + result1 bool + }{result1} +} + +func (fake *Wallet) ContainsReturnsOnCall(i int, result1 bool) { + fake.containsMutex.Lock() + defer fake.containsMutex.Unlock() + fake.ContainsStub = nil + if fake.containsReturnsOnCall == nil { + fake.containsReturnsOnCall = make(map[int]struct { + result1 bool + }) + } + fake.containsReturnsOnCall[i] = struct { + result1 bool + }{result1} +} + +func (fake *Wallet) ContainsToken(arg1 context.Context, arg2 *token.UnspentToken) bool { + fake.containsTokenMutex.Lock() + ret, specificReturn := fake.containsTokenReturnsOnCall[len(fake.containsTokenArgsForCall)] + fake.containsTokenArgsForCall = append(fake.containsTokenArgsForCall, struct { + arg1 context.Context + arg2 *token.UnspentToken + }{arg1, arg2}) + stub := fake.ContainsTokenStub + fakeReturns := fake.containsTokenReturns + fake.recordInvocation("ContainsToken", []interface{}{arg1, arg2}) + fake.containsTokenMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *Wallet) ContainsTokenCallCount() int { + fake.containsTokenMutex.RLock() + defer fake.containsTokenMutex.RUnlock() + return len(fake.containsTokenArgsForCall) +} + +func (fake *Wallet) ContainsTokenCalls(stub func(context.Context, *token.UnspentToken) bool) { + fake.containsTokenMutex.Lock() + defer fake.containsTokenMutex.Unlock() + fake.ContainsTokenStub = stub +} + +func (fake *Wallet) ContainsTokenArgsForCall(i int) (context.Context, *token.UnspentToken) { + fake.containsTokenMutex.RLock() + defer fake.containsTokenMutex.RUnlock() + argsForCall := fake.containsTokenArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *Wallet) ContainsTokenReturns(result1 bool) { + fake.containsTokenMutex.Lock() + defer fake.containsTokenMutex.Unlock() + fake.ContainsTokenStub = nil + fake.containsTokenReturns = struct { + result1 bool + }{result1} +} + +func (fake *Wallet) ContainsTokenReturnsOnCall(i int, result1 bool) { + fake.containsTokenMutex.Lock() + defer fake.containsTokenMutex.Unlock() + fake.ContainsTokenStub = nil + if fake.containsTokenReturnsOnCall == nil { + fake.containsTokenReturnsOnCall = make(map[int]struct { + result1 bool + }) + } + fake.containsTokenReturnsOnCall[i] = struct { + result1 bool + }{result1} +} + +func (fake *Wallet) GetSigner(arg1 context.Context, arg2 driver.Identity) (driver.Signer, error) { + fake.getSignerMutex.Lock() + ret, specificReturn := fake.getSignerReturnsOnCall[len(fake.getSignerArgsForCall)] + fake.getSignerArgsForCall = append(fake.getSignerArgsForCall, struct { + arg1 context.Context + arg2 driver.Identity + }{arg1, arg2}) + stub := fake.GetSignerStub + fakeReturns := fake.getSignerReturns + fake.recordInvocation("GetSigner", []interface{}{arg1, arg2}) + fake.getSignerMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *Wallet) GetSignerCallCount() int { + fake.getSignerMutex.RLock() + defer fake.getSignerMutex.RUnlock() + return len(fake.getSignerArgsForCall) +} + +func (fake *Wallet) GetSignerCalls(stub func(context.Context, driver.Identity) (driver.Signer, error)) { + fake.getSignerMutex.Lock() + defer fake.getSignerMutex.Unlock() + fake.GetSignerStub = stub +} + +func (fake *Wallet) GetSignerArgsForCall(i int) (context.Context, driver.Identity) { + fake.getSignerMutex.RLock() + defer fake.getSignerMutex.RUnlock() + argsForCall := fake.getSignerArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *Wallet) GetSignerReturns(result1 driver.Signer, result2 error) { + fake.getSignerMutex.Lock() + defer fake.getSignerMutex.Unlock() + fake.GetSignerStub = nil + fake.getSignerReturns = struct { + result1 driver.Signer + result2 error + }{result1, result2} +} + +func (fake *Wallet) GetSignerReturnsOnCall(i int, result1 driver.Signer, result2 error) { + fake.getSignerMutex.Lock() + defer fake.getSignerMutex.Unlock() + fake.GetSignerStub = nil + if fake.getSignerReturnsOnCall == nil { + fake.getSignerReturnsOnCall = make(map[int]struct { + result1 driver.Signer + result2 error + }) + } + fake.getSignerReturnsOnCall[i] = struct { + result1 driver.Signer + result2 error + }{result1, result2} +} + +func (fake *Wallet) ID() string { + fake.iDMutex.Lock() + ret, specificReturn := fake.iDReturnsOnCall[len(fake.iDArgsForCall)] + fake.iDArgsForCall = append(fake.iDArgsForCall, struct { + }{}) + stub := fake.IDStub + fakeReturns := fake.iDReturns + fake.recordInvocation("ID", []interface{}{}) + fake.iDMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *Wallet) IDCallCount() int { + fake.iDMutex.RLock() + defer fake.iDMutex.RUnlock() + return len(fake.iDArgsForCall) +} + +func (fake *Wallet) IDCalls(stub func() string) { + fake.iDMutex.Lock() + defer fake.iDMutex.Unlock() + fake.IDStub = stub +} + +func (fake *Wallet) IDReturns(result1 string) { + fake.iDMutex.Lock() + defer fake.iDMutex.Unlock() + fake.IDStub = nil + fake.iDReturns = struct { + result1 string + }{result1} +} + +func (fake *Wallet) IDReturnsOnCall(i int, result1 string) { + fake.iDMutex.Lock() + defer fake.iDMutex.Unlock() + fake.IDStub = nil + if fake.iDReturnsOnCall == nil { + fake.iDReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.iDReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *Wallet) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *Wallet) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ driver.Wallet = new(Wallet) diff --git a/token/driver/mock/ws.go b/token/driver/mock/ws.go index be41a9766b..173aa20fef 100644 --- a/token/driver/mock/ws.go +++ b/token/driver/mock/ws.go @@ -1125,34 +1125,6 @@ func (fake *WalletService) WalletReturnsOnCall(i int, result1 driver.Wallet) { func (fake *WalletService) Invocations() map[string][][]interface{} { fake.invocationsMutex.RLock() defer fake.invocationsMutex.RUnlock() - fake.auditorWalletMutex.RLock() - defer fake.auditorWalletMutex.RUnlock() - fake.certifierWalletMutex.RLock() - defer fake.certifierWalletMutex.RUnlock() - fake.getAuditInfoMutex.RLock() - defer fake.getAuditInfoMutex.RUnlock() - fake.getEIDAndRHMutex.RLock() - defer fake.getEIDAndRHMutex.RUnlock() - fake.getEnrollmentIDMutex.RLock() - defer fake.getEnrollmentIDMutex.RUnlock() - fake.getRevocationHandleMutex.RLock() - defer fake.getRevocationHandleMutex.RUnlock() - fake.issuerWalletMutex.RLock() - defer fake.issuerWalletMutex.RUnlock() - fake.ownerWalletMutex.RLock() - defer fake.ownerWalletMutex.RUnlock() - fake.ownerWalletIDsMutex.RLock() - defer fake.ownerWalletIDsMutex.RUnlock() - fake.registerIssuerIdentityMutex.RLock() - defer fake.registerIssuerIdentityMutex.RUnlock() - fake.registerOwnerIdentityMutex.RLock() - defer fake.registerOwnerIdentityMutex.RUnlock() - fake.registerRecipientIdentityMutex.RLock() - defer fake.registerRecipientIdentityMutex.RUnlock() - fake.spendIDsMutex.RLock() - defer fake.spendIDsMutex.RUnlock() - fake.walletMutex.RLock() - defer fake.walletMutex.RUnlock() copiedInvocations := map[string][][]interface{}{} for key, value := range fake.invocations { copiedInvocations[key] = value diff --git a/token/driver/vault.go b/token/driver/vault.go index f0daa22b5d..ba996c54fc 100644 --- a/token/driver/vault.go +++ b/token/driver/vault.go @@ -32,7 +32,6 @@ const ( ) //go:generate counterfeiter -o mock/uti.go -fake-name UnspentTokensIterator . UnspentTokensIterator - type UnspentTokensIterator = iterators.Iterator[*token.UnspentToken] type SpendableTokensIterator = iterators.Iterator[*token.UnspentTokenInWallet] @@ -56,7 +55,6 @@ type CertificationStorage interface { } //go:generate counterfeiter -o mock/qe.go -fake-name QueryEngine . QueryEngine - type QueryEngine interface { // IsPending returns true if the transaction the passed id refers to is still pending, false otherwise IsPending(ctx context.Context, id *token.ID) (bool, error) diff --git a/token/driver/wallet.go b/token/driver/wallet.go index 29dffdd997..9f82448343 100644 --- a/token/driver/wallet.go +++ b/token/driver/wallet.go @@ -33,6 +33,8 @@ type ListTokensOptions struct { } // Wallet models a generic wallet +// +//go:generate counterfeiter -o mock/w.go -fake-name Wallet . Wallet type Wallet interface { // ID returns the ID of this wallet ID() string @@ -48,6 +50,8 @@ type Wallet interface { } // OwnerWallet models the wallet of a token recipient. +// +//go:generate counterfeiter -o mock/ow.go -fake-name OwnerWallet . OwnerWallet type OwnerWallet interface { Wallet @@ -91,6 +95,8 @@ type OwnerWallet interface { } // IssuerWallet models the wallet of an issuer +// +//go:generate counterfeiter -o mock/iw.go -fake-name IssuerWallet . IssuerWallet type IssuerWallet interface { Wallet @@ -103,6 +109,8 @@ type IssuerWallet interface { } // AuditorWallet models the wallet of an auditor +// +//go:generate counterfeiter -o mock/aw.go -fake-name AuditorWallet . AuditorWallet type AuditorWallet interface { Wallet @@ -112,6 +120,8 @@ type AuditorWallet interface { } // CertifierWallet models the wallet of a certifier +// +//go:generate counterfeiter -o mock/cw.go -fake-name CertifierWallet . CertifierWallet type CertifierWallet interface { Wallet diff --git a/token/services/db/sql/common/tokens.go b/token/services/db/sql/common/tokens.go index db81fcda9d..6412b7ae00 100644 --- a/token/services/db/sql/common/tokens.go +++ b/token/services/db/sql/common/tokens.go @@ -1021,6 +1021,7 @@ func (t *TokenTransaction) StoreToken(ctx context.Context, tr driver.TokenRecord } if len(owners) == 0 { + logger.Debugf("no additional owner reference apart [%s]", tr.OwnerWalletID) return nil } diff --git a/token/services/identity/driver/common.go b/token/services/identity/driver/common.go index b861bf8495..fb210886e8 100644 --- a/token/services/identity/driver/common.go +++ b/token/services/identity/driver/common.go @@ -12,6 +12,7 @@ import ( "github.com/hyperledger-labs/fabric-token-sdk/token/driver" ) +//go:generate counterfeiter -o mock/nbs.go -fake-name NetworkBinderService . NetworkBinderService type NetworkBinderService interface { Bind(ctx context.Context, longTerm driver.Identity, ephemeral ...driver.Identity) error } diff --git a/token/services/identity/driver/identity.go b/token/services/identity/driver/identity.go index f0dca0fc94..fe4a03775c 100644 --- a/token/services/identity/driver/identity.go +++ b/token/services/identity/driver/identity.go @@ -30,6 +30,7 @@ type IdentityConfigurationIterator = iterators.Iterator[*IdentityConfiguration] type WalletID = string +//go:generate counterfeiter -o mock/wss.go -fake-name WalletStoreService . WalletStoreService type WalletStoreService interface { // GetWalletID fetches a walletID that is bound to the identity passed GetWalletID(ctx context.Context, identity token.Identity, roleID int) (WalletID, error) diff --git a/token/services/identity/driver/mock/nbs.go b/token/services/identity/driver/mock/nbs.go new file mode 100644 index 0000000000..0b2e141987 --- /dev/null +++ b/token/services/identity/driver/mock/nbs.go @@ -0,0 +1,115 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package mock + +import ( + "context" + "sync" + + drivera "github.com/hyperledger-labs/fabric-token-sdk/token/driver" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/driver" +) + +type NetworkBinderService struct { + BindStub func(context.Context, drivera.Identity, ...drivera.Identity) error + bindMutex sync.RWMutex + bindArgsForCall []struct { + arg1 context.Context + arg2 drivera.Identity + arg3 []drivera.Identity + } + bindReturns struct { + result1 error + } + bindReturnsOnCall map[int]struct { + result1 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *NetworkBinderService) Bind(arg1 context.Context, arg2 drivera.Identity, arg3 ...drivera.Identity) error { + fake.bindMutex.Lock() + ret, specificReturn := fake.bindReturnsOnCall[len(fake.bindArgsForCall)] + fake.bindArgsForCall = append(fake.bindArgsForCall, struct { + arg1 context.Context + arg2 drivera.Identity + arg3 []drivera.Identity + }{arg1, arg2, arg3}) + stub := fake.BindStub + fakeReturns := fake.bindReturns + fake.recordInvocation("Bind", []interface{}{arg1, arg2, arg3}) + fake.bindMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *NetworkBinderService) BindCallCount() int { + fake.bindMutex.RLock() + defer fake.bindMutex.RUnlock() + return len(fake.bindArgsForCall) +} + +func (fake *NetworkBinderService) BindCalls(stub func(context.Context, drivera.Identity, ...drivera.Identity) error) { + fake.bindMutex.Lock() + defer fake.bindMutex.Unlock() + fake.BindStub = stub +} + +func (fake *NetworkBinderService) BindArgsForCall(i int) (context.Context, drivera.Identity, []drivera.Identity) { + fake.bindMutex.RLock() + defer fake.bindMutex.RUnlock() + argsForCall := fake.bindArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *NetworkBinderService) BindReturns(result1 error) { + fake.bindMutex.Lock() + defer fake.bindMutex.Unlock() + fake.BindStub = nil + fake.bindReturns = struct { + result1 error + }{result1} +} + +func (fake *NetworkBinderService) BindReturnsOnCall(i int, result1 error) { + fake.bindMutex.Lock() + defer fake.bindMutex.Unlock() + fake.BindStub = nil + if fake.bindReturnsOnCall == nil { + fake.bindReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.bindReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *NetworkBinderService) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *NetworkBinderService) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ driver.NetworkBinderService = new(NetworkBinderService) diff --git a/token/services/identity/driver/mock/role.go b/token/services/identity/driver/mock/role.go new file mode 100644 index 0000000000..d05e477a5b --- /dev/null +++ b/token/services/identity/driver/mock/role.go @@ -0,0 +1,406 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package mock + +import ( + "context" + "sync" + + "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/driver" +) + +type Role struct { + GetIdentityInfoStub func(context.Context, string) (driver.IdentityInfo, error) + getIdentityInfoMutex sync.RWMutex + getIdentityInfoArgsForCall []struct { + arg1 context.Context + arg2 string + } + getIdentityInfoReturns struct { + result1 driver.IdentityInfo + result2 error + } + getIdentityInfoReturnsOnCall map[int]struct { + result1 driver.IdentityInfo + result2 error + } + IDStub func() driver.IdentityRoleType + iDMutex sync.RWMutex + iDArgsForCall []struct { + } + iDReturns struct { + result1 driver.IdentityRoleType + } + iDReturnsOnCall map[int]struct { + result1 driver.IdentityRoleType + } + IdentityIDsStub func() ([]string, error) + identityIDsMutex sync.RWMutex + identityIDsArgsForCall []struct { + } + identityIDsReturns struct { + result1 []string + result2 error + } + identityIDsReturnsOnCall map[int]struct { + result1 []string + result2 error + } + MapToIdentityStub func(context.Context, driver.WalletLookupID) (driver.Identity, string, error) + mapToIdentityMutex sync.RWMutex + mapToIdentityArgsForCall []struct { + arg1 context.Context + arg2 driver.WalletLookupID + } + mapToIdentityReturns struct { + result1 driver.Identity + result2 string + result3 error + } + mapToIdentityReturnsOnCall map[int]struct { + result1 driver.Identity + result2 string + result3 error + } + RegisterIdentityStub func(context.Context, driver.IdentityConfiguration) error + registerIdentityMutex sync.RWMutex + registerIdentityArgsForCall []struct { + arg1 context.Context + arg2 driver.IdentityConfiguration + } + registerIdentityReturns struct { + result1 error + } + registerIdentityReturnsOnCall map[int]struct { + result1 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *Role) GetIdentityInfo(arg1 context.Context, arg2 string) (driver.IdentityInfo, error) { + fake.getIdentityInfoMutex.Lock() + ret, specificReturn := fake.getIdentityInfoReturnsOnCall[len(fake.getIdentityInfoArgsForCall)] + fake.getIdentityInfoArgsForCall = append(fake.getIdentityInfoArgsForCall, struct { + arg1 context.Context + arg2 string + }{arg1, arg2}) + stub := fake.GetIdentityInfoStub + fakeReturns := fake.getIdentityInfoReturns + fake.recordInvocation("GetIdentityInfo", []interface{}{arg1, arg2}) + fake.getIdentityInfoMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *Role) GetIdentityInfoCallCount() int { + fake.getIdentityInfoMutex.RLock() + defer fake.getIdentityInfoMutex.RUnlock() + return len(fake.getIdentityInfoArgsForCall) +} + +func (fake *Role) GetIdentityInfoCalls(stub func(context.Context, string) (driver.IdentityInfo, error)) { + fake.getIdentityInfoMutex.Lock() + defer fake.getIdentityInfoMutex.Unlock() + fake.GetIdentityInfoStub = stub +} + +func (fake *Role) GetIdentityInfoArgsForCall(i int) (context.Context, string) { + fake.getIdentityInfoMutex.RLock() + defer fake.getIdentityInfoMutex.RUnlock() + argsForCall := fake.getIdentityInfoArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *Role) GetIdentityInfoReturns(result1 driver.IdentityInfo, result2 error) { + fake.getIdentityInfoMutex.Lock() + defer fake.getIdentityInfoMutex.Unlock() + fake.GetIdentityInfoStub = nil + fake.getIdentityInfoReturns = struct { + result1 driver.IdentityInfo + result2 error + }{result1, result2} +} + +func (fake *Role) GetIdentityInfoReturnsOnCall(i int, result1 driver.IdentityInfo, result2 error) { + fake.getIdentityInfoMutex.Lock() + defer fake.getIdentityInfoMutex.Unlock() + fake.GetIdentityInfoStub = nil + if fake.getIdentityInfoReturnsOnCall == nil { + fake.getIdentityInfoReturnsOnCall = make(map[int]struct { + result1 driver.IdentityInfo + result2 error + }) + } + fake.getIdentityInfoReturnsOnCall[i] = struct { + result1 driver.IdentityInfo + result2 error + }{result1, result2} +} + +func (fake *Role) ID() driver.IdentityRoleType { + fake.iDMutex.Lock() + ret, specificReturn := fake.iDReturnsOnCall[len(fake.iDArgsForCall)] + fake.iDArgsForCall = append(fake.iDArgsForCall, struct { + }{}) + stub := fake.IDStub + fakeReturns := fake.iDReturns + fake.recordInvocation("ID", []interface{}{}) + fake.iDMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *Role) IDCallCount() int { + fake.iDMutex.RLock() + defer fake.iDMutex.RUnlock() + return len(fake.iDArgsForCall) +} + +func (fake *Role) IDCalls(stub func() driver.IdentityRoleType) { + fake.iDMutex.Lock() + defer fake.iDMutex.Unlock() + fake.IDStub = stub +} + +func (fake *Role) IDReturns(result1 driver.IdentityRoleType) { + fake.iDMutex.Lock() + defer fake.iDMutex.Unlock() + fake.IDStub = nil + fake.iDReturns = struct { + result1 driver.IdentityRoleType + }{result1} +} + +func (fake *Role) IDReturnsOnCall(i int, result1 driver.IdentityRoleType) { + fake.iDMutex.Lock() + defer fake.iDMutex.Unlock() + fake.IDStub = nil + if fake.iDReturnsOnCall == nil { + fake.iDReturnsOnCall = make(map[int]struct { + result1 driver.IdentityRoleType + }) + } + fake.iDReturnsOnCall[i] = struct { + result1 driver.IdentityRoleType + }{result1} +} + +func (fake *Role) IdentityIDs() ([]string, error) { + fake.identityIDsMutex.Lock() + ret, specificReturn := fake.identityIDsReturnsOnCall[len(fake.identityIDsArgsForCall)] + fake.identityIDsArgsForCall = append(fake.identityIDsArgsForCall, struct { + }{}) + stub := fake.IdentityIDsStub + fakeReturns := fake.identityIDsReturns + fake.recordInvocation("IdentityIDs", []interface{}{}) + fake.identityIDsMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *Role) IdentityIDsCallCount() int { + fake.identityIDsMutex.RLock() + defer fake.identityIDsMutex.RUnlock() + return len(fake.identityIDsArgsForCall) +} + +func (fake *Role) IdentityIDsCalls(stub func() ([]string, error)) { + fake.identityIDsMutex.Lock() + defer fake.identityIDsMutex.Unlock() + fake.IdentityIDsStub = stub +} + +func (fake *Role) IdentityIDsReturns(result1 []string, result2 error) { + fake.identityIDsMutex.Lock() + defer fake.identityIDsMutex.Unlock() + fake.IdentityIDsStub = nil + fake.identityIDsReturns = struct { + result1 []string + result2 error + }{result1, result2} +} + +func (fake *Role) IdentityIDsReturnsOnCall(i int, result1 []string, result2 error) { + fake.identityIDsMutex.Lock() + defer fake.identityIDsMutex.Unlock() + fake.IdentityIDsStub = nil + if fake.identityIDsReturnsOnCall == nil { + fake.identityIDsReturnsOnCall = make(map[int]struct { + result1 []string + result2 error + }) + } + fake.identityIDsReturnsOnCall[i] = struct { + result1 []string + result2 error + }{result1, result2} +} + +func (fake *Role) MapToIdentity(arg1 context.Context, arg2 driver.WalletLookupID) (driver.Identity, string, error) { + fake.mapToIdentityMutex.Lock() + ret, specificReturn := fake.mapToIdentityReturnsOnCall[len(fake.mapToIdentityArgsForCall)] + fake.mapToIdentityArgsForCall = append(fake.mapToIdentityArgsForCall, struct { + arg1 context.Context + arg2 driver.WalletLookupID + }{arg1, arg2}) + stub := fake.MapToIdentityStub + fakeReturns := fake.mapToIdentityReturns + fake.recordInvocation("MapToIdentity", []interface{}{arg1, arg2}) + fake.mapToIdentityMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2, ret.result3 + } + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 +} + +func (fake *Role) MapToIdentityCallCount() int { + fake.mapToIdentityMutex.RLock() + defer fake.mapToIdentityMutex.RUnlock() + return len(fake.mapToIdentityArgsForCall) +} + +func (fake *Role) MapToIdentityCalls(stub func(context.Context, driver.WalletLookupID) (driver.Identity, string, error)) { + fake.mapToIdentityMutex.Lock() + defer fake.mapToIdentityMutex.Unlock() + fake.MapToIdentityStub = stub +} + +func (fake *Role) MapToIdentityArgsForCall(i int) (context.Context, driver.WalletLookupID) { + fake.mapToIdentityMutex.RLock() + defer fake.mapToIdentityMutex.RUnlock() + argsForCall := fake.mapToIdentityArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *Role) MapToIdentityReturns(result1 driver.Identity, result2 string, result3 error) { + fake.mapToIdentityMutex.Lock() + defer fake.mapToIdentityMutex.Unlock() + fake.MapToIdentityStub = nil + fake.mapToIdentityReturns = struct { + result1 driver.Identity + result2 string + result3 error + }{result1, result2, result3} +} + +func (fake *Role) MapToIdentityReturnsOnCall(i int, result1 driver.Identity, result2 string, result3 error) { + fake.mapToIdentityMutex.Lock() + defer fake.mapToIdentityMutex.Unlock() + fake.MapToIdentityStub = nil + if fake.mapToIdentityReturnsOnCall == nil { + fake.mapToIdentityReturnsOnCall = make(map[int]struct { + result1 driver.Identity + result2 string + result3 error + }) + } + fake.mapToIdentityReturnsOnCall[i] = struct { + result1 driver.Identity + result2 string + result3 error + }{result1, result2, result3} +} + +func (fake *Role) RegisterIdentity(arg1 context.Context, arg2 driver.IdentityConfiguration) error { + fake.registerIdentityMutex.Lock() + ret, specificReturn := fake.registerIdentityReturnsOnCall[len(fake.registerIdentityArgsForCall)] + fake.registerIdentityArgsForCall = append(fake.registerIdentityArgsForCall, struct { + arg1 context.Context + arg2 driver.IdentityConfiguration + }{arg1, arg2}) + stub := fake.RegisterIdentityStub + fakeReturns := fake.registerIdentityReturns + fake.recordInvocation("RegisterIdentity", []interface{}{arg1, arg2}) + fake.registerIdentityMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *Role) RegisterIdentityCallCount() int { + fake.registerIdentityMutex.RLock() + defer fake.registerIdentityMutex.RUnlock() + return len(fake.registerIdentityArgsForCall) +} + +func (fake *Role) RegisterIdentityCalls(stub func(context.Context, driver.IdentityConfiguration) error) { + fake.registerIdentityMutex.Lock() + defer fake.registerIdentityMutex.Unlock() + fake.RegisterIdentityStub = stub +} + +func (fake *Role) RegisterIdentityArgsForCall(i int) (context.Context, driver.IdentityConfiguration) { + fake.registerIdentityMutex.RLock() + defer fake.registerIdentityMutex.RUnlock() + argsForCall := fake.registerIdentityArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *Role) RegisterIdentityReturns(result1 error) { + fake.registerIdentityMutex.Lock() + defer fake.registerIdentityMutex.Unlock() + fake.RegisterIdentityStub = nil + fake.registerIdentityReturns = struct { + result1 error + }{result1} +} + +func (fake *Role) RegisterIdentityReturnsOnCall(i int, result1 error) { + fake.registerIdentityMutex.Lock() + defer fake.registerIdentityMutex.Unlock() + fake.RegisterIdentityStub = nil + if fake.registerIdentityReturnsOnCall == nil { + fake.registerIdentityReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.registerIdentityReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *Role) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *Role) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ driver.Role = new(Role) diff --git a/token/services/identity/driver/mock/sp.go b/token/services/identity/driver/mock/sp.go new file mode 100644 index 0000000000..8949327037 --- /dev/null +++ b/token/services/identity/driver/mock/sp.go @@ -0,0 +1,269 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package mock + +import ( + "sync" + + "github.com/hyperledger-labs/fabric-token-sdk/token" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/driver" +) + +type StorageProvider struct { + IdentityStoreStub func(token.TMSID) (driver.IdentityStoreService, error) + identityStoreMutex sync.RWMutex + identityStoreArgsForCall []struct { + arg1 token.TMSID + } + identityStoreReturns struct { + result1 driver.IdentityStoreService + result2 error + } + identityStoreReturnsOnCall map[int]struct { + result1 driver.IdentityStoreService + result2 error + } + KeystoreStub func(token.TMSID) (driver.Keystore, error) + keystoreMutex sync.RWMutex + keystoreArgsForCall []struct { + arg1 token.TMSID + } + keystoreReturns struct { + result1 driver.Keystore + result2 error + } + keystoreReturnsOnCall map[int]struct { + result1 driver.Keystore + result2 error + } + WalletStoreStub func(token.TMSID) (driver.WalletStoreService, error) + walletStoreMutex sync.RWMutex + walletStoreArgsForCall []struct { + arg1 token.TMSID + } + walletStoreReturns struct { + result1 driver.WalletStoreService + result2 error + } + walletStoreReturnsOnCall map[int]struct { + result1 driver.WalletStoreService + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *StorageProvider) IdentityStore(arg1 token.TMSID) (driver.IdentityStoreService, error) { + fake.identityStoreMutex.Lock() + ret, specificReturn := fake.identityStoreReturnsOnCall[len(fake.identityStoreArgsForCall)] + fake.identityStoreArgsForCall = append(fake.identityStoreArgsForCall, struct { + arg1 token.TMSID + }{arg1}) + stub := fake.IdentityStoreStub + fakeReturns := fake.identityStoreReturns + fake.recordInvocation("IdentityStore", []interface{}{arg1}) + fake.identityStoreMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *StorageProvider) IdentityStoreCallCount() int { + fake.identityStoreMutex.RLock() + defer fake.identityStoreMutex.RUnlock() + return len(fake.identityStoreArgsForCall) +} + +func (fake *StorageProvider) IdentityStoreCalls(stub func(token.TMSID) (driver.IdentityStoreService, error)) { + fake.identityStoreMutex.Lock() + defer fake.identityStoreMutex.Unlock() + fake.IdentityStoreStub = stub +} + +func (fake *StorageProvider) IdentityStoreArgsForCall(i int) token.TMSID { + fake.identityStoreMutex.RLock() + defer fake.identityStoreMutex.RUnlock() + argsForCall := fake.identityStoreArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *StorageProvider) IdentityStoreReturns(result1 driver.IdentityStoreService, result2 error) { + fake.identityStoreMutex.Lock() + defer fake.identityStoreMutex.Unlock() + fake.IdentityStoreStub = nil + fake.identityStoreReturns = struct { + result1 driver.IdentityStoreService + result2 error + }{result1, result2} +} + +func (fake *StorageProvider) IdentityStoreReturnsOnCall(i int, result1 driver.IdentityStoreService, result2 error) { + fake.identityStoreMutex.Lock() + defer fake.identityStoreMutex.Unlock() + fake.IdentityStoreStub = nil + if fake.identityStoreReturnsOnCall == nil { + fake.identityStoreReturnsOnCall = make(map[int]struct { + result1 driver.IdentityStoreService + result2 error + }) + } + fake.identityStoreReturnsOnCall[i] = struct { + result1 driver.IdentityStoreService + result2 error + }{result1, result2} +} + +func (fake *StorageProvider) Keystore(arg1 token.TMSID) (driver.Keystore, error) { + fake.keystoreMutex.Lock() + ret, specificReturn := fake.keystoreReturnsOnCall[len(fake.keystoreArgsForCall)] + fake.keystoreArgsForCall = append(fake.keystoreArgsForCall, struct { + arg1 token.TMSID + }{arg1}) + stub := fake.KeystoreStub + fakeReturns := fake.keystoreReturns + fake.recordInvocation("Keystore", []interface{}{arg1}) + fake.keystoreMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *StorageProvider) KeystoreCallCount() int { + fake.keystoreMutex.RLock() + defer fake.keystoreMutex.RUnlock() + return len(fake.keystoreArgsForCall) +} + +func (fake *StorageProvider) KeystoreCalls(stub func(token.TMSID) (driver.Keystore, error)) { + fake.keystoreMutex.Lock() + defer fake.keystoreMutex.Unlock() + fake.KeystoreStub = stub +} + +func (fake *StorageProvider) KeystoreArgsForCall(i int) token.TMSID { + fake.keystoreMutex.RLock() + defer fake.keystoreMutex.RUnlock() + argsForCall := fake.keystoreArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *StorageProvider) KeystoreReturns(result1 driver.Keystore, result2 error) { + fake.keystoreMutex.Lock() + defer fake.keystoreMutex.Unlock() + fake.KeystoreStub = nil + fake.keystoreReturns = struct { + result1 driver.Keystore + result2 error + }{result1, result2} +} + +func (fake *StorageProvider) KeystoreReturnsOnCall(i int, result1 driver.Keystore, result2 error) { + fake.keystoreMutex.Lock() + defer fake.keystoreMutex.Unlock() + fake.KeystoreStub = nil + if fake.keystoreReturnsOnCall == nil { + fake.keystoreReturnsOnCall = make(map[int]struct { + result1 driver.Keystore + result2 error + }) + } + fake.keystoreReturnsOnCall[i] = struct { + result1 driver.Keystore + result2 error + }{result1, result2} +} + +func (fake *StorageProvider) WalletStore(arg1 token.TMSID) (driver.WalletStoreService, error) { + fake.walletStoreMutex.Lock() + ret, specificReturn := fake.walletStoreReturnsOnCall[len(fake.walletStoreArgsForCall)] + fake.walletStoreArgsForCall = append(fake.walletStoreArgsForCall, struct { + arg1 token.TMSID + }{arg1}) + stub := fake.WalletStoreStub + fakeReturns := fake.walletStoreReturns + fake.recordInvocation("WalletStore", []interface{}{arg1}) + fake.walletStoreMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *StorageProvider) WalletStoreCallCount() int { + fake.walletStoreMutex.RLock() + defer fake.walletStoreMutex.RUnlock() + return len(fake.walletStoreArgsForCall) +} + +func (fake *StorageProvider) WalletStoreCalls(stub func(token.TMSID) (driver.WalletStoreService, error)) { + fake.walletStoreMutex.Lock() + defer fake.walletStoreMutex.Unlock() + fake.WalletStoreStub = stub +} + +func (fake *StorageProvider) WalletStoreArgsForCall(i int) token.TMSID { + fake.walletStoreMutex.RLock() + defer fake.walletStoreMutex.RUnlock() + argsForCall := fake.walletStoreArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *StorageProvider) WalletStoreReturns(result1 driver.WalletStoreService, result2 error) { + fake.walletStoreMutex.Lock() + defer fake.walletStoreMutex.Unlock() + fake.WalletStoreStub = nil + fake.walletStoreReturns = struct { + result1 driver.WalletStoreService + result2 error + }{result1, result2} +} + +func (fake *StorageProvider) WalletStoreReturnsOnCall(i int, result1 driver.WalletStoreService, result2 error) { + fake.walletStoreMutex.Lock() + defer fake.walletStoreMutex.Unlock() + fake.WalletStoreStub = nil + if fake.walletStoreReturnsOnCall == nil { + fake.walletStoreReturnsOnCall = make(map[int]struct { + result1 driver.WalletStoreService + result2 error + }) + } + fake.walletStoreReturnsOnCall[i] = struct { + result1 driver.WalletStoreService + result2 error + }{result1, result2} +} + +func (fake *StorageProvider) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *StorageProvider) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ driver.StorageProvider = new(StorageProvider) diff --git a/token/services/identity/driver/mock/wss.go b/token/services/identity/driver/mock/wss.go new file mode 100644 index 0000000000..6847e9a945 --- /dev/null +++ b/token/services/identity/driver/mock/wss.go @@ -0,0 +1,510 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package mock + +import ( + "context" + "sync" + + "github.com/hyperledger-labs/fabric-token-sdk/token" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/driver" +) + +type WalletStoreService struct { + CloseStub func() error + closeMutex sync.RWMutex + closeArgsForCall []struct { + } + closeReturns struct { + result1 error + } + closeReturnsOnCall map[int]struct { + result1 error + } + GetWalletIDStub func(context.Context, token.Identity, int) (driver.WalletID, error) + getWalletIDMutex sync.RWMutex + getWalletIDArgsForCall []struct { + arg1 context.Context + arg2 token.Identity + arg3 int + } + getWalletIDReturns struct { + result1 driver.WalletID + result2 error + } + getWalletIDReturnsOnCall map[int]struct { + result1 driver.WalletID + result2 error + } + GetWalletIDsStub func(context.Context, int) ([]driver.WalletID, error) + getWalletIDsMutex sync.RWMutex + getWalletIDsArgsForCall []struct { + arg1 context.Context + arg2 int + } + getWalletIDsReturns struct { + result1 []driver.WalletID + result2 error + } + getWalletIDsReturnsOnCall map[int]struct { + result1 []driver.WalletID + result2 error + } + IdentityExistsStub func(context.Context, token.Identity, driver.WalletID, int) bool + identityExistsMutex sync.RWMutex + identityExistsArgsForCall []struct { + arg1 context.Context + arg2 token.Identity + arg3 driver.WalletID + arg4 int + } + identityExistsReturns struct { + result1 bool + } + identityExistsReturnsOnCall map[int]struct { + result1 bool + } + LoadMetaStub func(context.Context, token.Identity, driver.WalletID, int) ([]byte, error) + loadMetaMutex sync.RWMutex + loadMetaArgsForCall []struct { + arg1 context.Context + arg2 token.Identity + arg3 driver.WalletID + arg4 int + } + loadMetaReturns struct { + result1 []byte + result2 error + } + loadMetaReturnsOnCall map[int]struct { + result1 []byte + result2 error + } + StoreIdentityStub func(context.Context, token.Identity, string, driver.WalletID, int, []byte) error + storeIdentityMutex sync.RWMutex + storeIdentityArgsForCall []struct { + arg1 context.Context + arg2 token.Identity + arg3 string + arg4 driver.WalletID + arg5 int + arg6 []byte + } + storeIdentityReturns struct { + result1 error + } + storeIdentityReturnsOnCall map[int]struct { + result1 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *WalletStoreService) Close() error { + fake.closeMutex.Lock() + ret, specificReturn := fake.closeReturnsOnCall[len(fake.closeArgsForCall)] + fake.closeArgsForCall = append(fake.closeArgsForCall, struct { + }{}) + stub := fake.CloseStub + fakeReturns := fake.closeReturns + fake.recordInvocation("Close", []interface{}{}) + fake.closeMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *WalletStoreService) CloseCallCount() int { + fake.closeMutex.RLock() + defer fake.closeMutex.RUnlock() + return len(fake.closeArgsForCall) +} + +func (fake *WalletStoreService) CloseCalls(stub func() error) { + fake.closeMutex.Lock() + defer fake.closeMutex.Unlock() + fake.CloseStub = stub +} + +func (fake *WalletStoreService) CloseReturns(result1 error) { + fake.closeMutex.Lock() + defer fake.closeMutex.Unlock() + fake.CloseStub = nil + fake.closeReturns = struct { + result1 error + }{result1} +} + +func (fake *WalletStoreService) CloseReturnsOnCall(i int, result1 error) { + fake.closeMutex.Lock() + defer fake.closeMutex.Unlock() + fake.CloseStub = nil + if fake.closeReturnsOnCall == nil { + fake.closeReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.closeReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *WalletStoreService) GetWalletID(arg1 context.Context, arg2 token.Identity, arg3 int) (driver.WalletID, error) { + fake.getWalletIDMutex.Lock() + ret, specificReturn := fake.getWalletIDReturnsOnCall[len(fake.getWalletIDArgsForCall)] + fake.getWalletIDArgsForCall = append(fake.getWalletIDArgsForCall, struct { + arg1 context.Context + arg2 token.Identity + arg3 int + }{arg1, arg2, arg3}) + stub := fake.GetWalletIDStub + fakeReturns := fake.getWalletIDReturns + fake.recordInvocation("GetWalletID", []interface{}{arg1, arg2, arg3}) + fake.getWalletIDMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *WalletStoreService) GetWalletIDCallCount() int { + fake.getWalletIDMutex.RLock() + defer fake.getWalletIDMutex.RUnlock() + return len(fake.getWalletIDArgsForCall) +} + +func (fake *WalletStoreService) GetWalletIDCalls(stub func(context.Context, token.Identity, int) (driver.WalletID, error)) { + fake.getWalletIDMutex.Lock() + defer fake.getWalletIDMutex.Unlock() + fake.GetWalletIDStub = stub +} + +func (fake *WalletStoreService) GetWalletIDArgsForCall(i int) (context.Context, token.Identity, int) { + fake.getWalletIDMutex.RLock() + defer fake.getWalletIDMutex.RUnlock() + argsForCall := fake.getWalletIDArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *WalletStoreService) GetWalletIDReturns(result1 driver.WalletID, result2 error) { + fake.getWalletIDMutex.Lock() + defer fake.getWalletIDMutex.Unlock() + fake.GetWalletIDStub = nil + fake.getWalletIDReturns = struct { + result1 driver.WalletID + result2 error + }{result1, result2} +} + +func (fake *WalletStoreService) GetWalletIDReturnsOnCall(i int, result1 driver.WalletID, result2 error) { + fake.getWalletIDMutex.Lock() + defer fake.getWalletIDMutex.Unlock() + fake.GetWalletIDStub = nil + if fake.getWalletIDReturnsOnCall == nil { + fake.getWalletIDReturnsOnCall = make(map[int]struct { + result1 driver.WalletID + result2 error + }) + } + fake.getWalletIDReturnsOnCall[i] = struct { + result1 driver.WalletID + result2 error + }{result1, result2} +} + +func (fake *WalletStoreService) GetWalletIDs(arg1 context.Context, arg2 int) ([]driver.WalletID, error) { + fake.getWalletIDsMutex.Lock() + ret, specificReturn := fake.getWalletIDsReturnsOnCall[len(fake.getWalletIDsArgsForCall)] + fake.getWalletIDsArgsForCall = append(fake.getWalletIDsArgsForCall, struct { + arg1 context.Context + arg2 int + }{arg1, arg2}) + stub := fake.GetWalletIDsStub + fakeReturns := fake.getWalletIDsReturns + fake.recordInvocation("GetWalletIDs", []interface{}{arg1, arg2}) + fake.getWalletIDsMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *WalletStoreService) GetWalletIDsCallCount() int { + fake.getWalletIDsMutex.RLock() + defer fake.getWalletIDsMutex.RUnlock() + return len(fake.getWalletIDsArgsForCall) +} + +func (fake *WalletStoreService) GetWalletIDsCalls(stub func(context.Context, int) ([]driver.WalletID, error)) { + fake.getWalletIDsMutex.Lock() + defer fake.getWalletIDsMutex.Unlock() + fake.GetWalletIDsStub = stub +} + +func (fake *WalletStoreService) GetWalletIDsArgsForCall(i int) (context.Context, int) { + fake.getWalletIDsMutex.RLock() + defer fake.getWalletIDsMutex.RUnlock() + argsForCall := fake.getWalletIDsArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *WalletStoreService) GetWalletIDsReturns(result1 []driver.WalletID, result2 error) { + fake.getWalletIDsMutex.Lock() + defer fake.getWalletIDsMutex.Unlock() + fake.GetWalletIDsStub = nil + fake.getWalletIDsReturns = struct { + result1 []driver.WalletID + result2 error + }{result1, result2} +} + +func (fake *WalletStoreService) GetWalletIDsReturnsOnCall(i int, result1 []driver.WalletID, result2 error) { + fake.getWalletIDsMutex.Lock() + defer fake.getWalletIDsMutex.Unlock() + fake.GetWalletIDsStub = nil + if fake.getWalletIDsReturnsOnCall == nil { + fake.getWalletIDsReturnsOnCall = make(map[int]struct { + result1 []driver.WalletID + result2 error + }) + } + fake.getWalletIDsReturnsOnCall[i] = struct { + result1 []driver.WalletID + result2 error + }{result1, result2} +} + +func (fake *WalletStoreService) IdentityExists(arg1 context.Context, arg2 token.Identity, arg3 driver.WalletID, arg4 int) bool { + fake.identityExistsMutex.Lock() + ret, specificReturn := fake.identityExistsReturnsOnCall[len(fake.identityExistsArgsForCall)] + fake.identityExistsArgsForCall = append(fake.identityExistsArgsForCall, struct { + arg1 context.Context + arg2 token.Identity + arg3 driver.WalletID + arg4 int + }{arg1, arg2, arg3, arg4}) + stub := fake.IdentityExistsStub + fakeReturns := fake.identityExistsReturns + fake.recordInvocation("IdentityExists", []interface{}{arg1, arg2, arg3, arg4}) + fake.identityExistsMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3, arg4) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *WalletStoreService) IdentityExistsCallCount() int { + fake.identityExistsMutex.RLock() + defer fake.identityExistsMutex.RUnlock() + return len(fake.identityExistsArgsForCall) +} + +func (fake *WalletStoreService) IdentityExistsCalls(stub func(context.Context, token.Identity, driver.WalletID, int) bool) { + fake.identityExistsMutex.Lock() + defer fake.identityExistsMutex.Unlock() + fake.IdentityExistsStub = stub +} + +func (fake *WalletStoreService) IdentityExistsArgsForCall(i int) (context.Context, token.Identity, driver.WalletID, int) { + fake.identityExistsMutex.RLock() + defer fake.identityExistsMutex.RUnlock() + argsForCall := fake.identityExistsArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 +} + +func (fake *WalletStoreService) IdentityExistsReturns(result1 bool) { + fake.identityExistsMutex.Lock() + defer fake.identityExistsMutex.Unlock() + fake.IdentityExistsStub = nil + fake.identityExistsReturns = struct { + result1 bool + }{result1} +} + +func (fake *WalletStoreService) IdentityExistsReturnsOnCall(i int, result1 bool) { + fake.identityExistsMutex.Lock() + defer fake.identityExistsMutex.Unlock() + fake.IdentityExistsStub = nil + if fake.identityExistsReturnsOnCall == nil { + fake.identityExistsReturnsOnCall = make(map[int]struct { + result1 bool + }) + } + fake.identityExistsReturnsOnCall[i] = struct { + result1 bool + }{result1} +} + +func (fake *WalletStoreService) LoadMeta(arg1 context.Context, arg2 token.Identity, arg3 driver.WalletID, arg4 int) ([]byte, error) { + fake.loadMetaMutex.Lock() + ret, specificReturn := fake.loadMetaReturnsOnCall[len(fake.loadMetaArgsForCall)] + fake.loadMetaArgsForCall = append(fake.loadMetaArgsForCall, struct { + arg1 context.Context + arg2 token.Identity + arg3 driver.WalletID + arg4 int + }{arg1, arg2, arg3, arg4}) + stub := fake.LoadMetaStub + fakeReturns := fake.loadMetaReturns + fake.recordInvocation("LoadMeta", []interface{}{arg1, arg2, arg3, arg4}) + fake.loadMetaMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3, arg4) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *WalletStoreService) LoadMetaCallCount() int { + fake.loadMetaMutex.RLock() + defer fake.loadMetaMutex.RUnlock() + return len(fake.loadMetaArgsForCall) +} + +func (fake *WalletStoreService) LoadMetaCalls(stub func(context.Context, token.Identity, driver.WalletID, int) ([]byte, error)) { + fake.loadMetaMutex.Lock() + defer fake.loadMetaMutex.Unlock() + fake.LoadMetaStub = stub +} + +func (fake *WalletStoreService) LoadMetaArgsForCall(i int) (context.Context, token.Identity, driver.WalletID, int) { + fake.loadMetaMutex.RLock() + defer fake.loadMetaMutex.RUnlock() + argsForCall := fake.loadMetaArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 +} + +func (fake *WalletStoreService) LoadMetaReturns(result1 []byte, result2 error) { + fake.loadMetaMutex.Lock() + defer fake.loadMetaMutex.Unlock() + fake.LoadMetaStub = nil + fake.loadMetaReturns = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *WalletStoreService) LoadMetaReturnsOnCall(i int, result1 []byte, result2 error) { + fake.loadMetaMutex.Lock() + defer fake.loadMetaMutex.Unlock() + fake.LoadMetaStub = nil + if fake.loadMetaReturnsOnCall == nil { + fake.loadMetaReturnsOnCall = make(map[int]struct { + result1 []byte + result2 error + }) + } + fake.loadMetaReturnsOnCall[i] = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *WalletStoreService) StoreIdentity(arg1 context.Context, arg2 token.Identity, arg3 string, arg4 driver.WalletID, arg5 int, arg6 []byte) error { + var arg6Copy []byte + if arg6 != nil { + arg6Copy = make([]byte, len(arg6)) + copy(arg6Copy, arg6) + } + fake.storeIdentityMutex.Lock() + ret, specificReturn := fake.storeIdentityReturnsOnCall[len(fake.storeIdentityArgsForCall)] + fake.storeIdentityArgsForCall = append(fake.storeIdentityArgsForCall, struct { + arg1 context.Context + arg2 token.Identity + arg3 string + arg4 driver.WalletID + arg5 int + arg6 []byte + }{arg1, arg2, arg3, arg4, arg5, arg6Copy}) + stub := fake.StoreIdentityStub + fakeReturns := fake.storeIdentityReturns + fake.recordInvocation("StoreIdentity", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6Copy}) + fake.storeIdentityMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5, arg6) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *WalletStoreService) StoreIdentityCallCount() int { + fake.storeIdentityMutex.RLock() + defer fake.storeIdentityMutex.RUnlock() + return len(fake.storeIdentityArgsForCall) +} + +func (fake *WalletStoreService) StoreIdentityCalls(stub func(context.Context, token.Identity, string, driver.WalletID, int, []byte) error) { + fake.storeIdentityMutex.Lock() + defer fake.storeIdentityMutex.Unlock() + fake.StoreIdentityStub = stub +} + +func (fake *WalletStoreService) StoreIdentityArgsForCall(i int) (context.Context, token.Identity, string, driver.WalletID, int, []byte) { + fake.storeIdentityMutex.RLock() + defer fake.storeIdentityMutex.RUnlock() + argsForCall := fake.storeIdentityArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6 +} + +func (fake *WalletStoreService) StoreIdentityReturns(result1 error) { + fake.storeIdentityMutex.Lock() + defer fake.storeIdentityMutex.Unlock() + fake.StoreIdentityStub = nil + fake.storeIdentityReturns = struct { + result1 error + }{result1} +} + +func (fake *WalletStoreService) StoreIdentityReturnsOnCall(i int, result1 error) { + fake.storeIdentityMutex.Lock() + defer fake.storeIdentityMutex.Unlock() + fake.StoreIdentityStub = nil + if fake.storeIdentityReturnsOnCall == nil { + fake.storeIdentityReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.storeIdentityReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *WalletStoreService) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *WalletStoreService) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ driver.WalletStoreService = new(WalletStoreService) diff --git a/token/services/identity/driver/role.go b/token/services/identity/driver/role.go index b465a91a3d..b4b1b15292 100644 --- a/token/services/identity/driver/role.go +++ b/token/services/identity/driver/role.go @@ -63,6 +63,8 @@ type ( // Role is a container of long-term identities. // A long-term identity is then used to construct a wallet. +// +//go:generate counterfeiter -o mock/role.go -fake-name Role . Role type Role interface { // ID returns the identifier of this role ID() IdentityRoleType diff --git a/token/services/identity/driver/storage.go b/token/services/identity/driver/storage.go index 628e5595ca..fde913b25c 100644 --- a/token/services/identity/driver/storage.go +++ b/token/services/identity/driver/storage.go @@ -15,6 +15,7 @@ type Keystore interface { Get(id string, state interface{}) error } +//go:generate counterfeiter -o mock/sp.go -fake-name StorageProvider . StorageProvider type StorageProvider interface { WalletStore(tmsID token.TMSID) (WalletStoreService, error) IdentityStore(tmsID token.TMSID) (IdentityStoreService, error) diff --git a/token/services/identity/membership/lm.go b/token/services/identity/membership/lm.go index d5dc3385bb..f84179c386 100644 --- a/token/services/identity/membership/lm.go +++ b/token/services/identity/membership/lm.go @@ -8,16 +8,16 @@ package membership import ( "context" - "errors" "os" "path/filepath" "slices" "sync" - errors2 "github.com/hyperledger-labs/fabric-smart-client/pkg/utils/errors" + "github.com/hyperledger-labs/fabric-smart-client/pkg/utils/errors" "github.com/hyperledger-labs/fabric-smart-client/platform/common/utils/collections" "github.com/hyperledger-labs/fabric-smart-client/platform/view/view" - "github.com/hyperledger-labs/fabric-token-sdk/token/driver" + "github.com/hyperledger-labs/fabric-token-sdk/token" + tdriver "github.com/hyperledger-labs/fabric-token-sdk/token/driver" "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity" idriver "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/driver" "github.com/hyperledger-labs/fabric-token-sdk/token/services/logging" @@ -26,17 +26,80 @@ import ( ) const ( + // MaxPriority is used to set a very high priority for identities that match + // target identities. Smaller numeric values mean higher priority. MaxPriority = -1 // smaller numbers, higher priority ) var logger = logging.MustGetLogger() +// IdentityConfiguration is an alias to the driver-level identity configuration +// structure. LocalMembership expects identity configuration data in this shape. +type IdentityConfiguration = tdriver.IdentityConfiguration + +// Config models the part of idriver.Config that LocalMembership needs. +// It is used to translate configured filesystem paths into runtime paths. +// +//go:generate counterfeiter -o mock/config.go -fake-name Config . Config +type Config interface { + // TranslatePath converts a configured path (may contain ~ or env vars) + // into an absolute path usable by the runtime. + TranslatePath(path string) string +} + +// SignerDeserializerManager models the part of idriver.SignerDeserializerManager +// that LocalMembership interacts with. LocalMembership registers typed +// signer-deserializers for key managers so that signatures can be deserialized +// later on when processing tokens. +// +//go:generate counterfeiter -o mock/sdm.go -fake-name SignerDeserializerManager . SignerDeserializerManager +type SignerDeserializerManager interface { + AddTypedSignerDeserializer(typ idriver.IdentityType, d idriver.TypedSignerDeserializer) +} + +// IdentityStoreService models the part of idriver.IdentityStoreService that +// LocalMembership needs. It provides a persistent place to record which +// identity configurations have been registered so they can be reloaded later. +// +//go:generate counterfeiter -o mock/iss.go -fake-name IdentityStoreService . IdentityStoreService +type IdentityStoreService interface { + // AddConfiguration stores an identity configuration and the path to the + // credentials relevant to this identity. The context may carry caller info. + AddConfiguration(ctx context.Context, wp idriver.IdentityConfiguration) error + // ConfigurationExists returns true if a configuration with the given id, + // type and URL already exists in the store. + ConfigurationExists(ctx context.Context, id, typ, url string) (bool, error) + // IteratorConfigurations returns an iterator over all configurations of + // a given type stored in the persistent store. + IteratorConfigurations(ctx context.Context, configurationType string) (idriver.IdentityConfigurationIterator, error) +} + +// IdentityProvider is an alias for the driver-level identity provider used to +// register identity descriptors, bind identities and resolve whether an +// identity belongs to this node (IsMe). +// +//go:generate counterfeiter -o mock/ip.go -fake-name IdentityProvider . IdentityProvider +type IdentityProvider = idriver.IdentityProvider + +// KeyManagerProvider is responsible for producing a KeyManager for a given +// IdentityConfiguration. Multiple providers can be registered; the first one +// that succeeds is used for that identity. +// +//go:generate counterfeiter -o mock/kmp.go -fake-name KeyManagerProvider . KeyManagerProvider type KeyManagerProvider interface { - Get(ctx context.Context, identityConfig *driver.IdentityConfiguration) (KeyManager, error) + Get(ctx context.Context, identityConfig *IdentityConfiguration) (KeyManager, error) } +// KeyManager encapsulates operations over a key material source (local or +// remote). LocalMembership uses KeyManager to deserialize signers, obtain an +// enrollment ID, check whether the key manager is remote/anonymous, and to +// fetch the identity descriptor (Identity + AuditInfo) used for binding and +// registration. +// +//go:generate counterfeiter -o mock/km.go -fake-name KeyManager . KeyManager type KeyManager interface { - idriver.Deserializer + DeserializeVerifier(ctx context.Context, raw []byte) (tdriver.Verifier, error) + DeserializeSigner(ctx context.Context, raw []byte) (tdriver.Signer, error) EnrollmentID() string IsRemote() bool Anonymous() bool @@ -44,12 +107,17 @@ type KeyManager interface { Identity(ctx context.Context, auditInfo []byte) (*idriver.IdentityDescriptor, error) } +// LocalIdentityWithPriority pairs a loaded LocalIdentity with a priority +// value. Priorities are used when multiple identities share the same name to +// select which identity should be preferred. type LocalIdentityWithPriority struct { Identity *LocalIdentity Priority int } -// PriorityComparison gives higher priority to smaller numbers +// PriorityComparison compares two LocalIdentityWithPriority values. It gives +// precedence to smaller integer values (i.e. lower numeric value == higher +// priority). var PriorityComparison = func(a, b LocalIdentityWithPriority) int { if a.Priority < b.Priority { return -1 @@ -59,33 +127,59 @@ var PriorityComparison = func(a, b LocalIdentityWithPriority) int { return 0 } +// LocalMembership manages the set of long-term identities that this process +// can act as (or on behalf of). It supports loading identities from +// configuration files and from a persistent identity store, registering new +// identities, and looking up identity information used by the token +// processing stack. +// +// Concurrency: read/write access to the in-memory indices is guarded by +// `localIdentitiesMutex`. +// +// The main responsibilities are: +// - Load identities from configuration and persistent store +// - Register an identity configuration and persist it to the store +// - Provide IdentityInfo wrappers that fetch token.Identity instances on-demand +// - Maintain mappings by identity name and by concrete identity string +// - Register typed signer deserializers from the KeyManager with the global manager type LocalMembership struct { - config idriver.Config - defaultNetworkIdentity driver.Identity - deserializerManager idriver.SignerDeserializerManager - identityDB idriver.IdentityStoreService + logger logging.Logger + config Config + defaultNetworkIdentity token.Identity + deserializerManager SignerDeserializerManager + identityDB IdentityStoreService KeyManagerProviders []KeyManagerProvider IdentityType string - IdentityProvider idriver.IdentityProvider - logger logging.Logger + IdentityProvider IdentityProvider localIdentitiesMutex sync.RWMutex localIdentities []*LocalIdentity localIdentitiesByName map[string][]LocalIdentityWithPriority localIdentitiesByIdentity map[string]*LocalIdentity - targetIdentities []view.Identity - DefaultAnonymous bool + targetIdentities []view.Identity // optional list of identities to prefer + anonymous bool // when true, only anonymous identities are considered selectable by default } +// NewLocalMembership creates a new LocalMembership instance. +// Parameters: +// - logger: logger scoped to the identity type +// - config: configuration provider used to translate paths +// - defaultNetworkIdentity: the root network identity to bind other identities to +// - deserializerManager: manager where typed signer deserializers are registered +// - identityDB: persistent store for identity configurations +// - identityType: the identity type string used to wrap loaded identities +// - defaultAnonymous: whether identities should be loaded as anonymous by default +// - identityProvider: provider used to register and bind identities +// - keyManagerProviders: list of key manager providers to try when loading an identity func NewLocalMembership( logger logging.Logger, - config idriver.Config, - defaultNetworkIdentity driver.Identity, - deserializerManager idriver.SignerDeserializerManager, - identityDB idriver.IdentityStoreService, + config Config, + defaultNetworkIdentity token.Identity, + deserializerManager SignerDeserializerManager, + identityDB IdentityStoreService, identityType string, defaultAnonymous bool, - identityProvider idriver.IdentityProvider, + identityProvider IdentityProvider, keyManagerProviders ...KeyManagerProvider, ) *LocalMembership { return &LocalMembership{ @@ -98,20 +192,26 @@ func NewLocalMembership( localIdentitiesByIdentity: map[string]*LocalIdentity{}, IdentityType: identityType, KeyManagerProviders: keyManagerProviders, - DefaultAnonymous: defaultAnonymous, + anonymous: defaultAnonymous, IdentityProvider: identityProvider, } } -func (l *LocalMembership) DefaultNetworkIdentity() driver.Identity { +// DefaultNetworkIdentity returns the root network identity used when binding loaded identities. +func (l *LocalMembership) DefaultNetworkIdentity() token.Identity { return l.defaultNetworkIdentity } -func (l *LocalMembership) IsMe(ctx context.Context, id driver.Identity) bool { +// IsMe reports whether the given identity belongs to this local membership set. +// It delegates to the configured IdentityProvider to determine membership. +func (l *LocalMembership) IsMe(ctx context.Context, id token.Identity) bool { return l.IdentityProvider.IsMe(ctx, id) } -func (l *LocalMembership) GetIdentifier(ctx context.Context, id driver.Identity) (string, error) { +// GetIdentifier returns the configured identifier (label) for the provided token.Identity. +// The method tries both the raw bytes and the string representation of the identity +// when looking up the in-memory mapping. +func (l *LocalMembership) GetIdentifier(ctx context.Context, id token.Identity) (string, error) { l.localIdentitiesMutex.RLock() defer l.localIdentitiesMutex.RUnlock() @@ -128,9 +228,12 @@ func (l *LocalMembership) GetIdentifier(ctx context.Context, id driver.Identity) } return r.Name, nil } - return "", errors2.Errorf("identifier not found for id [%s]", id) + return "", errors.Errorf("identifier not found for id [%s]", id) } +// GetDefaultIdentifier returns the name of the default identity currently loaded. +// It honors the LocalMembership anonymous flag and only returns an identity +// selectable under the current anonymity mode. func (l *LocalMembership) GetDefaultIdentifier() string { l.localIdentitiesMutex.RLock() defer l.localIdentitiesMutex.RUnlock() @@ -138,6 +241,10 @@ func (l *LocalMembership) GetDefaultIdentifier() string { return l.getDefaultIdentifier() } +// GetIdentityInfo looks up identity information for a given label and produces an IdentityInfo +// that can be used to fetch a token.Identity on demand. The auditInfo bytes are passed to the +// underlying key manager when requesting the identity. The returned IdentityInfo will lazily +// fetch or compute the actual token.Identity when needed. func (l *LocalMembership) GetIdentityInfo(ctx context.Context, label string, auditInfo []byte) (idriver.IdentityInfo, error) { l.localIdentitiesMutex.RLock() defer l.localIdentitiesMutex.RUnlock() @@ -145,31 +252,39 @@ func (l *LocalMembership) GetIdentityInfo(ctx context.Context, label string, aud l.logger.DebugfContext(ctx, "get identity info by label [%s][%s]", logging.Printable(label), utils.Hashable(label)) localIdentity := l.getLocalIdentity(ctx, label) if localIdentity == nil { - return nil, errors2.Errorf("local identity not found for label [%s][%v]", utils.Hashable(label), l.localIdentitiesByName) + return nil, errors.Errorf("local identity not found for label [%s][%v]", utils.Hashable(label), l.localIdentitiesByName) } - return NewIdentityInfo(localIdentity, func(ctx context.Context) (driver.Identity, []byte, error) { + return NewIdentityInfo(localIdentity, func(ctx context.Context) (token.Identity, []byte, error) { return localIdentity.GetIdentity(ctx, auditInfo) }), nil } -func (l *LocalMembership) RegisterIdentity(ctx context.Context, idConfig driver.IdentityConfiguration) error { +// RegisterIdentity registers a new identity configuration into the LocalMembership and +// persists it into the identity store if it is successfully added. The function +// acquires a write lock while modifying internal maps/lists. +func (l *LocalMembership) RegisterIdentity(ctx context.Context, idConfig IdentityConfiguration) error { l.localIdentitiesMutex.Lock() defer l.localIdentitiesMutex.Unlock() return l.registerIdentityConfiguration(ctx, &idConfig, l.getDefaultIdentifier() == "") } +// IDs returns the list of identity names currently loaded in the LocalMembership. func (l *LocalMembership) IDs() ([]string, error) { l.localIdentitiesMutex.RLock() defer l.localIdentitiesMutex.RUnlock() set := collections.NewSet[string]() - for _, identity := range l.localIdentities { - set.Add(identity.Name) + for _, li := range l.localIdentities { + set.Add(li.Name) } return set.ToSlice(), nil } +// Load initializes LocalMembership from a list of configured identities and optional target +// identities (to give higher priority to the matching ones). It also loads any identities found +// in the persistent identity store. The function will log errors for identities that fail to +// register but will try to continue loading the remaining entries. func (l *LocalMembership) Load(ctx context.Context, identities []*idriver.ConfiguredIdentity, targets []view.Identity) error { l.localIdentitiesMutex.Lock() defer l.localIdentitiesMutex.Unlock() @@ -184,22 +299,22 @@ func (l *LocalMembership) Load(ctx context.Context, identities []*idriver.Config // prepare all identity configurations identityConfigurations, defaults, err := l.toIdentityConfiguration(identities) if err != nil { - return errors2.Wrap(err, "failed to prepare identity configurations") + return errors.Wrap(err, "failed to prepare identity configurations") } storedIdentityConfigurations, err := l.storedIdentityConfigurations(ctx) if err != nil { - return errors2.Wrap(err, "failed to load stored identity configurations") + return errors.Wrap(err, "failed to load stored identity configurations") } // merge identityConfigurations and storedIdentityConfigurations // filter out stored configuration that are already in identityConfigurations - var filtered []driver.IdentityConfiguration + var filtered []IdentityConfiguration if len(storedIdentityConfigurations) != 0 { for _, stored := range storedIdentityConfigurations { found := false // if stored is in identityConfigurations, skip it - for _, identityConfiguration := range identityConfigurations { - if stored.ID == identityConfiguration.ID && stored.URL == identityConfiguration.URL { + for _, ic := range identityConfigurations { + if stored.ID == ic.ID && stored.URL == ic.URL { // we don't need this configuration found = true } @@ -249,50 +364,54 @@ func (l *LocalMembership) Load(ctx context.Context, identities []*idriver.Config return nil } +// getDefaultIdentifier returns the name of the current default identity (may return empty string). func (l *LocalMembership) getDefaultIdentifier() string { - for _, identity := range l.localIdentities { - if l.DefaultAnonymous && !identity.Anonymous { + for _, li := range l.localIdentities { + // if we are in anonymous mode skip non-anonymous identities + if l.anonymous && !li.Anonymous { continue } - if identity.Default { - return identity.Name + if li.Default { + return li.Name } } return "" } +// firstDefaultIdentifier returns the first identity that can be used as default under the current +// anonymity setting (or nil if none exists). func (l *LocalMembership) firstDefaultIdentifier() *LocalIdentity { - for _, identity := range l.localIdentities { - if l.DefaultAnonymous && !identity.Anonymous { + for _, li := range l.localIdentities { + if l.anonymous && !li.Anonymous { continue } - return identity + return li } return nil } -func (l *LocalMembership) toIdentityConfiguration(identities []*idriver.ConfiguredIdentity) ([]driver.IdentityConfiguration, []bool, error) { - ics := make([]driver.IdentityConfiguration, len(identities)) +func (l *LocalMembership) toIdentityConfiguration(identities []*idriver.ConfiguredIdentity) ([]IdentityConfiguration, []bool, error) { + ics := make([]IdentityConfiguration, len(identities)) defaults := make([]bool, len(identities)) - for i, identity := range identities { - optsRaw, err := yaml.Marshal(identity.Opts) + for i, ci := range identities { + optsRaw, err := yaml.Marshal(ci.Opts) if err != nil { - return nil, nil, errors2.WithMessagef(err, "failed to marshal identity options") + return nil, nil, errors.WithMessagef(err, "failed to marshal identity options") } - ics[i] = driver.IdentityConfiguration{ - ID: identity.ID, - URL: identity.Path, + ics[i] = IdentityConfiguration{ + ID: ci.ID, + URL: ci.Path, Type: l.IdentityType, Config: optsRaw, Raw: nil, } - defaults[i] = identity.Default + defaults[i] = ci.Default } return ics, defaults, nil } -func (l *LocalMembership) registerLocalIdentity(ctx context.Context, identityConfig *driver.IdentityConfiguration, defaultIdentity bool) error { +func (l *LocalMembership) registerLocalIdentity(ctx context.Context, identityConfig *IdentityConfiguration, defaultIdentity bool) error { var errs []error var keyManager KeyManager var priority int @@ -308,7 +427,7 @@ func (l *LocalMembership) registerLocalIdentity(ctx context.Context, identityCon errs = append(errs, err) } if keyManager == nil { - return errors2.Wrapf( + return errors.Wrapf( errors.Join(errs...), "failed to get a key manager for the passed identity config for [%s:%s]", identityConfig.ID, @@ -318,7 +437,7 @@ func (l *LocalMembership) registerLocalIdentity(ctx context.Context, identityCon l.logger.DebugfContext(ctx, "append local identity for [%s]", identityConfig.ID) if err := l.addLocalIdentity(ctx, identityConfig, keyManager, defaultIdentity, priority); err != nil { - return errors2.Wrapf(err, "failed to add local identity for [%s]", identityConfig.ID) + return errors.Wrapf(err, "failed to add local identity for [%s]", identityConfig.ID) } if exists, _ := l.identityDB.ConfigurationExists(ctx, identityConfig.ID, l.IdentityType, identityConfig.URL); !exists { @@ -333,20 +452,20 @@ func (l *LocalMembership) registerLocalIdentity(ctx context.Context, identityCon return nil } -func (l *LocalMembership) registerIdentityConfiguration(ctx context.Context, identity *driver.IdentityConfiguration, defaultIdentity bool) error { +func (l *LocalMembership) registerIdentityConfiguration(ctx context.Context, identity *IdentityConfiguration, defaultIdentity bool) error { // Try to register the local identity identity.URL = l.config.TranslatePath(identity.URL) if err := l.registerLocalIdentity(ctx, identity, defaultIdentity); err != nil { l.logger.Warnf("failed to load local identity at [%s]:[%s]", identity.URL, err) // Does path correspond to a folder containing multiple identities? if err := l.registerLocalIdentities(ctx, identity); err != nil { - return errors2.WithMessagef(err, "failed to register local identity") + return errors.WithMessagef(err, "failed to register local identity") } } return nil } -func (l *LocalMembership) registerLocalIdentities(ctx context.Context, configuration *driver.IdentityConfiguration) error { +func (l *LocalMembership) registerLocalIdentities(ctx context.Context, configuration *IdentityConfiguration) error { entries, err := os.ReadDir(configuration.URL) if err != nil { l.logger.Warnf("failed reading from [%s]: [%s]", configuration.URL, err) @@ -359,7 +478,7 @@ func (l *LocalMembership) registerLocalIdentities(ctx context.Context, configura continue } id := entry.Name() - if err := l.registerLocalIdentity(ctx, &driver.IdentityConfiguration{ + if err := l.registerLocalIdentity(ctx, &IdentityConfiguration{ ID: id, URL: filepath.Join(configuration.URL, id), Config: configuration.Config, @@ -371,14 +490,14 @@ func (l *LocalMembership) registerLocalIdentities(ctx context.Context, configura found++ } if found == 0 { - return errors2.Errorf("no valid identities found in [%s], errs [%v]", configuration.URL, errs) + return errors.Errorf("no valid identities found in [%s], errs [%v]", configuration.URL, errs) } return nil } -func (l *LocalMembership) addLocalIdentity(ctx context.Context, config *driver.IdentityConfiguration, keyManager KeyManager, defaultID bool, priority int) error { +func (l *LocalMembership) addLocalIdentity(ctx context.Context, config *IdentityConfiguration, keyManager KeyManager, defaultID bool, priority int) error { var getIdentity GetIdentityFunc - var identity driver.Identity + var resolvedIdentity token.Identity typedIdentityInfo := &TypedIdentityInfo{ GetIdentity: keyManager.Identity, @@ -388,16 +507,20 @@ func (l *LocalMembership) addLocalIdentity(ctx context.Context, config *driver.I IdentityProvider: l.IdentityProvider, } if keyManager.Anonymous() { + // For anonymous key managers we keep the provider function so the identity + // can be obtained later with arbitrary audit info. getIdentity = typedIdentityInfo.Get } else { + // For non-anonymous key managers we eagerly fetch the identity and audit + // info now and cache it to avoid repeated remote calls. var auditInfo []byte var err error - identity, auditInfo, err = typedIdentityInfo.Get(ctx, nil) + resolvedIdentity, auditInfo, err = typedIdentityInfo.Get(ctx, nil) if err != nil { - return errors2.WithMessagef(err, "failed to get identity") + return errors.WithMessagef(err, "failed to get identity") } - getIdentity = func(context.Context, []byte) (driver.Identity, []byte, error) { - return identity, auditInfo, nil + getIdentity = func(context.Context, []byte) (token.Identity, []byte, error) { + return resolvedIdentity, auditInfo, nil } } @@ -405,13 +528,13 @@ func (l *LocalMembership) addLocalIdentity(ctx context.Context, config *driver.I name := config.ID if keyManager.Anonymous() || len(l.targetIdentities) == 0 { l.logger.Debugf("no target identity check needed, skip it") - } else if found := slices.ContainsFunc(l.targetIdentities, identity.Equal); !found { + } else if found := slices.ContainsFunc(l.targetIdentities, resolvedIdentity.Equal); !found { // the identity is not in the target identities, we should give it a lower priority l.logger.Debugf("identity [%s:%s] not in target identities", name, config.URL) } else { // give it high priority priority = MaxPriority - l.logger.Debugf("identity [%s:%s][%s] in target identities", name, config.URL, identity) + l.logger.Debugf("identity [%s:%s][%s] in target identities", name, config.URL, resolvedIdentity) } eID := keyManager.EnrollmentID() @@ -443,10 +566,10 @@ func (l *LocalMembership) addLocalIdentity(ctx context.Context, config *driver.I // if the keyManager is not anonymous if !keyManager.Anonymous() { - l.logger.Debugf("adding identity mapping for [%s]", identity) - l.localIdentitiesByIdentity[identity.String()] = localIdentity - if err := l.IdentityProvider.Bind(ctx, l.defaultNetworkIdentity, identity); err != nil { - return errors2.WithMessagef(err, "cannot bind identity for [%s,%s]", identity, eID) + l.logger.Debugf("adding identity mapping for [%s]", resolvedIdentity) + l.localIdentitiesByIdentity[resolvedIdentity.String()] = localIdentity + if err := l.IdentityProvider.Bind(ctx, l.defaultNetworkIdentity, resolvedIdentity); err != nil { + return errors.WithMessagef(err, "cannot bind identity for [%s,%s]", resolvedIdentity, eID) } } @@ -461,9 +584,9 @@ func (l *LocalMembership) getLocalIdentity(ctx context.Context, label string) *L l.logger.DebugfContext(ctx, "get local identity by name found with label [%s]", utils.Hashable(label)) return identities[0].Identity } - identity, ok := l.localIdentitiesByIdentity[label] + mapped, ok := l.localIdentitiesByIdentity[label] if ok { - return identity + return mapped } l.logger.DebugfContext(ctx, "local identity not found for label [%s][%v]", utils.Hashable(label), l.localIdentitiesByName) @@ -473,27 +596,35 @@ func (l *LocalMembership) getLocalIdentity(ctx context.Context, label string) *L func (l *LocalMembership) storedIdentityConfigurations(ctx context.Context) ([]idriver.IdentityConfiguration, error) { it, err := l.identityDB.IteratorConfigurations(ctx, l.IdentityType) if err != nil { - return nil, errors2.WithMessagef(err, "failed to get registered identities from kvs") + return nil, errors.WithMessagef(err, "failed to get registered identities from kvs") } return collections.ReadAll[idriver.IdentityConfiguration](it) } +// TypedIdentityInfo is a helper that knows how to materialize a typed identity +// (optionally wrapping the underlying identity with an identity type) and +// register/bind the identity descriptor with the identity provider. +// +// The Get method returns the token.Identity to use and any audit info bytes. type TypedIdentityInfo struct { + // GetIdentity fetches the identity descriptor (identity + audit info) from + // the KeyManager. It accepts auditInfo bytes that may be used by remote + // key managers to produce a specific identity variant. GetIdentity func(context.Context, []byte) (*idriver.IdentityDescriptor, error) IdentityType identity.Type EnrollmentID string - RootIdentity driver.Identity + RootIdentity token.Identity IdentityProvider idriver.IdentityProvider } -func (i *TypedIdentityInfo) Get(ctx context.Context, auditInfo []byte) (driver.Identity, []byte, error) { +func (i *TypedIdentityInfo) Get(ctx context.Context, auditInfo []byte) (token.Identity, []byte, error) { // get the identity logger.DebugfContext(ctx, "fetch identity") identityDescriptor, err := i.GetIdentity(ctx, auditInfo) if err != nil { - return nil, nil, errors2.Wrapf(err, "failed to get root identity for [%s]", i.EnrollmentID) + return nil, nil, errors.Wrapf(err, "failed to get root identity for [%s]", i.EnrollmentID) } id := identityDescriptor.Identity ai := identityDescriptor.AuditInfo @@ -503,27 +634,30 @@ func (i *TypedIdentityInfo) Get(ctx context.Context, auditInfo []byte) (driver.I logger.DebugfContext(ctx, "wrap and bind as [%s]", i.IdentityType) typedIdentity, err = identity.WrapWithType(i.IdentityType, id) if err != nil { - return nil, nil, errors2.Wrapf(err, "failed to wrap identity [%s]", i.IdentityType) + return nil, nil, errors.Wrapf(err, "failed to wrap identity [%s]", i.IdentityType) } } // register the audit info logger.DebugfContext(ctx, "register identity descriptor") if err := i.IdentityProvider.RegisterIdentityDescriptor(ctx, identityDescriptor, typedIdentity); err != nil { - return nil, nil, errors2.Wrapf(err, "failed to register identity descriptor for [%s][%s]", id, typedIdentity) + return nil, nil, errors.Wrapf(err, "failed to register identity descriptor for [%s][%s]", id, typedIdentity) } logger.DebugfContext(ctx, "bind to root identity") if err := i.IdentityProvider.Bind(ctx, i.RootIdentity, id, typedIdentity); err != nil { - return nil, nil, errors2.Wrapf(err, "failed to bind identity [%s] to [%s]", id, i.RootIdentity) + return nil, nil, errors.Wrapf(err, "failed to bind identity [%s] to [%s]", id, i.RootIdentity) } return typedIdentity, ai, nil } +// TypedSignerDeserializer adapts a KeyManager so it can be used where the +// driver expects an idriver.TypedSignerDeserializer. It forwards DeserializeSigner +// calls to the underlying KeyManager implementation. type TypedSignerDeserializer struct { KeyManager } -func (t *TypedSignerDeserializer) DeserializeSigner(ctx context.Context, typ identity.Type, raw []byte) (driver.Signer, error) { +func (t *TypedSignerDeserializer) DeserializeSigner(ctx context.Context, _ identity.Type, raw []byte) (tdriver.Signer, error) { return t.KeyManager.DeserializeSigner(ctx, raw) } diff --git a/token/services/identity/role/factory.go b/token/services/identity/membership/roles.go similarity index 81% rename from token/services/identity/role/factory.go rename to token/services/identity/membership/roles.go index b73c2a6aea..9ccea6c1d7 100644 --- a/token/services/identity/role/factory.go +++ b/token/services/identity/membership/roles.go @@ -4,7 +4,7 @@ Copyright IBM Corp. All Rights Reserved. SPDX-License-Identifier: Apache-2.0 */ -package role +package membership import ( "context" @@ -14,7 +14,7 @@ import ( "github.com/hyperledger-labs/fabric-token-sdk/token" "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity" "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/driver" - "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/membership" + role2 "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/role" "github.com/hyperledger-labs/fabric-token-sdk/token/services/logging" ) @@ -29,8 +29,8 @@ type StorageProvider interface { IdentityStore(tmsID token.TMSID) (driver.IdentityStoreService, error) } -// Factory is the factory for creating wallets, idemix and x509 -type Factory struct { +// RoleFactory is the factory for creating wallets, idemix and x509 +type RoleFactory struct { Logger logging.Logger TMSID token.TMSID Config driver.Config @@ -41,8 +41,8 @@ type Factory struct { DeserializerManager driver.SignerDeserializerManager } -// NewFactory creates a new Factory -func NewFactory( +// NewRoleFactory creates a new RoleFactory +func NewRoleFactory( logger logging.Logger, TMSID token.TMSID, config driver.Config, @@ -51,8 +51,8 @@ func NewFactory( identityProvider driver.IdentityProvider, storageProvider StorageProvider, deserializerManager driver.SignerDeserializerManager, -) *Factory { - return &Factory{ +) *RoleFactory { + return &RoleFactory{ Logger: logger, TMSID: TMSID, Config: config, @@ -64,12 +64,12 @@ func NewFactory( } } -func (f *Factory) NewRole(role identity.RoleType, defaultAnon bool, targets []driver.Identity, kmps ...membership.KeyManagerProvider) (identity.Role, error) { +func (f *RoleFactory) NewRole(role identity.RoleType, defaultAnon bool, targets []driver.Identity, kmps ...KeyManagerProvider) (identity.Role, error) { identityDB, err := f.StorageProvider.IdentityStore(f.TMSID) if err != nil { return nil, errors.Wrapf(err, "failed to get wallet path storage") } - lm := membership.NewLocalMembership( + lm := NewLocalMembership( f.Logger.Named(fmt.Sprintf("membership.role.%s", identity.RoleToString(role))), f.Config, f.NetworkDefaultIdentity, @@ -87,5 +87,5 @@ func (f *Factory) NewRole(role identity.RoleType, defaultAnon bool, targets []dr if err := lm.Load(context.Background(), identities, targets); err != nil { return nil, errors.WithMessagef(err, "failed to load identities") } - return NewRole(f.Logger, role, f.TMSID.Network, f.FSCIdentity, lm), nil + return role2.NewRole(f.Logger, role, f.TMSID.Network, f.FSCIdentity, lm), nil } diff --git a/token/services/identity/wallet/cache.go b/token/services/identity/role/cache.go similarity index 99% rename from token/services/identity/wallet/cache.go rename to token/services/identity/role/cache.go index 37ed7fa61d..306160bc5b 100644 --- a/token/services/identity/wallet/cache.go +++ b/token/services/identity/role/cache.go @@ -4,7 +4,7 @@ Copyright IBM Corp. All Rights Reserved. SPDX-License-Identifier: Apache-2.0 */ -package wallet +package role import ( "context" diff --git a/token/services/identity/wallet/metrics.go b/token/services/identity/role/metrics.go similarity index 97% rename from token/services/identity/wallet/metrics.go rename to token/services/identity/role/metrics.go index a58db39c74..5eb0994f28 100644 --- a/token/services/identity/wallet/metrics.go +++ b/token/services/identity/role/metrics.go @@ -4,7 +4,7 @@ Copyright IBM Corp. All Rights Reserved. SPDX-License-Identifier: Apache-2.0 */ -package wallet +package role import ( "github.com/hyperledger-labs/fabric-smart-client/platform/view/services/metrics" diff --git a/token/services/identity/role/mock/deserializer.go b/token/services/identity/role/mock/deserializer.go new file mode 100644 index 0000000000..662520775f --- /dev/null +++ b/token/services/identity/role/mock/deserializer.go @@ -0,0 +1,601 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package mock + +import ( + "context" + "sync" + + "github.com/hyperledger-labs/fabric-token-sdk/token/driver" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/role" +) + +type Deserializer struct { + GetAuditInfoStub func(context.Context, driver.Identity, driver.AuditInfoProvider) ([]byte, error) + getAuditInfoMutex sync.RWMutex + getAuditInfoArgsForCall []struct { + arg1 context.Context + arg2 driver.Identity + arg3 driver.AuditInfoProvider + } + getAuditInfoReturns struct { + result1 []byte + result2 error + } + getAuditInfoReturnsOnCall map[int]struct { + result1 []byte + result2 error + } + GetAuditInfoMatcherStub func(context.Context, driver.Identity, []byte) (driver.Matcher, error) + getAuditInfoMatcherMutex sync.RWMutex + getAuditInfoMatcherArgsForCall []struct { + arg1 context.Context + arg2 driver.Identity + arg3 []byte + } + getAuditInfoMatcherReturns struct { + result1 driver.Matcher + result2 error + } + getAuditInfoMatcherReturnsOnCall map[int]struct { + result1 driver.Matcher + result2 error + } + GetAuditorVerifierStub func(context.Context, driver.Identity) (driver.Verifier, error) + getAuditorVerifierMutex sync.RWMutex + getAuditorVerifierArgsForCall []struct { + arg1 context.Context + arg2 driver.Identity + } + getAuditorVerifierReturns struct { + result1 driver.Verifier + result2 error + } + getAuditorVerifierReturnsOnCall map[int]struct { + result1 driver.Verifier + result2 error + } + GetIssuerVerifierStub func(context.Context, driver.Identity) (driver.Verifier, error) + getIssuerVerifierMutex sync.RWMutex + getIssuerVerifierArgsForCall []struct { + arg1 context.Context + arg2 driver.Identity + } + getIssuerVerifierReturns struct { + result1 driver.Verifier + result2 error + } + getIssuerVerifierReturnsOnCall map[int]struct { + result1 driver.Verifier + result2 error + } + GetOwnerVerifierStub func(context.Context, driver.Identity) (driver.Verifier, error) + getOwnerVerifierMutex sync.RWMutex + getOwnerVerifierArgsForCall []struct { + arg1 context.Context + arg2 driver.Identity + } + getOwnerVerifierReturns struct { + result1 driver.Verifier + result2 error + } + getOwnerVerifierReturnsOnCall map[int]struct { + result1 driver.Verifier + result2 error + } + MatchIdentityStub func(context.Context, driver.Identity, []byte) error + matchIdentityMutex sync.RWMutex + matchIdentityArgsForCall []struct { + arg1 context.Context + arg2 driver.Identity + arg3 []byte + } + matchIdentityReturns struct { + result1 error + } + matchIdentityReturnsOnCall map[int]struct { + result1 error + } + RecipientsStub func(driver.Identity) ([]driver.Identity, error) + recipientsMutex sync.RWMutex + recipientsArgsForCall []struct { + arg1 driver.Identity + } + recipientsReturns struct { + result1 []driver.Identity + result2 error + } + recipientsReturnsOnCall map[int]struct { + result1 []driver.Identity + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *Deserializer) GetAuditInfo(arg1 context.Context, arg2 driver.Identity, arg3 driver.AuditInfoProvider) ([]byte, error) { + fake.getAuditInfoMutex.Lock() + ret, specificReturn := fake.getAuditInfoReturnsOnCall[len(fake.getAuditInfoArgsForCall)] + fake.getAuditInfoArgsForCall = append(fake.getAuditInfoArgsForCall, struct { + arg1 context.Context + arg2 driver.Identity + arg3 driver.AuditInfoProvider + }{arg1, arg2, arg3}) + stub := fake.GetAuditInfoStub + fakeReturns := fake.getAuditInfoReturns + fake.recordInvocation("GetAuditInfo", []interface{}{arg1, arg2, arg3}) + fake.getAuditInfoMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *Deserializer) GetAuditInfoCallCount() int { + fake.getAuditInfoMutex.RLock() + defer fake.getAuditInfoMutex.RUnlock() + return len(fake.getAuditInfoArgsForCall) +} + +func (fake *Deserializer) GetAuditInfoCalls(stub func(context.Context, driver.Identity, driver.AuditInfoProvider) ([]byte, error)) { + fake.getAuditInfoMutex.Lock() + defer fake.getAuditInfoMutex.Unlock() + fake.GetAuditInfoStub = stub +} + +func (fake *Deserializer) GetAuditInfoArgsForCall(i int) (context.Context, driver.Identity, driver.AuditInfoProvider) { + fake.getAuditInfoMutex.RLock() + defer fake.getAuditInfoMutex.RUnlock() + argsForCall := fake.getAuditInfoArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *Deserializer) GetAuditInfoReturns(result1 []byte, result2 error) { + fake.getAuditInfoMutex.Lock() + defer fake.getAuditInfoMutex.Unlock() + fake.GetAuditInfoStub = nil + fake.getAuditInfoReturns = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *Deserializer) GetAuditInfoReturnsOnCall(i int, result1 []byte, result2 error) { + fake.getAuditInfoMutex.Lock() + defer fake.getAuditInfoMutex.Unlock() + fake.GetAuditInfoStub = nil + if fake.getAuditInfoReturnsOnCall == nil { + fake.getAuditInfoReturnsOnCall = make(map[int]struct { + result1 []byte + result2 error + }) + } + fake.getAuditInfoReturnsOnCall[i] = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *Deserializer) GetAuditInfoMatcher(arg1 context.Context, arg2 driver.Identity, arg3 []byte) (driver.Matcher, error) { + var arg3Copy []byte + if arg3 != nil { + arg3Copy = make([]byte, len(arg3)) + copy(arg3Copy, arg3) + } + fake.getAuditInfoMatcherMutex.Lock() + ret, specificReturn := fake.getAuditInfoMatcherReturnsOnCall[len(fake.getAuditInfoMatcherArgsForCall)] + fake.getAuditInfoMatcherArgsForCall = append(fake.getAuditInfoMatcherArgsForCall, struct { + arg1 context.Context + arg2 driver.Identity + arg3 []byte + }{arg1, arg2, arg3Copy}) + stub := fake.GetAuditInfoMatcherStub + fakeReturns := fake.getAuditInfoMatcherReturns + fake.recordInvocation("GetAuditInfoMatcher", []interface{}{arg1, arg2, arg3Copy}) + fake.getAuditInfoMatcherMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *Deserializer) GetAuditInfoMatcherCallCount() int { + fake.getAuditInfoMatcherMutex.RLock() + defer fake.getAuditInfoMatcherMutex.RUnlock() + return len(fake.getAuditInfoMatcherArgsForCall) +} + +func (fake *Deserializer) GetAuditInfoMatcherCalls(stub func(context.Context, driver.Identity, []byte) (driver.Matcher, error)) { + fake.getAuditInfoMatcherMutex.Lock() + defer fake.getAuditInfoMatcherMutex.Unlock() + fake.GetAuditInfoMatcherStub = stub +} + +func (fake *Deserializer) GetAuditInfoMatcherArgsForCall(i int) (context.Context, driver.Identity, []byte) { + fake.getAuditInfoMatcherMutex.RLock() + defer fake.getAuditInfoMatcherMutex.RUnlock() + argsForCall := fake.getAuditInfoMatcherArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *Deserializer) GetAuditInfoMatcherReturns(result1 driver.Matcher, result2 error) { + fake.getAuditInfoMatcherMutex.Lock() + defer fake.getAuditInfoMatcherMutex.Unlock() + fake.GetAuditInfoMatcherStub = nil + fake.getAuditInfoMatcherReturns = struct { + result1 driver.Matcher + result2 error + }{result1, result2} +} + +func (fake *Deserializer) GetAuditInfoMatcherReturnsOnCall(i int, result1 driver.Matcher, result2 error) { + fake.getAuditInfoMatcherMutex.Lock() + defer fake.getAuditInfoMatcherMutex.Unlock() + fake.GetAuditInfoMatcherStub = nil + if fake.getAuditInfoMatcherReturnsOnCall == nil { + fake.getAuditInfoMatcherReturnsOnCall = make(map[int]struct { + result1 driver.Matcher + result2 error + }) + } + fake.getAuditInfoMatcherReturnsOnCall[i] = struct { + result1 driver.Matcher + result2 error + }{result1, result2} +} + +func (fake *Deserializer) GetAuditorVerifier(arg1 context.Context, arg2 driver.Identity) (driver.Verifier, error) { + fake.getAuditorVerifierMutex.Lock() + ret, specificReturn := fake.getAuditorVerifierReturnsOnCall[len(fake.getAuditorVerifierArgsForCall)] + fake.getAuditorVerifierArgsForCall = append(fake.getAuditorVerifierArgsForCall, struct { + arg1 context.Context + arg2 driver.Identity + }{arg1, arg2}) + stub := fake.GetAuditorVerifierStub + fakeReturns := fake.getAuditorVerifierReturns + fake.recordInvocation("GetAuditorVerifier", []interface{}{arg1, arg2}) + fake.getAuditorVerifierMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *Deserializer) GetAuditorVerifierCallCount() int { + fake.getAuditorVerifierMutex.RLock() + defer fake.getAuditorVerifierMutex.RUnlock() + return len(fake.getAuditorVerifierArgsForCall) +} + +func (fake *Deserializer) GetAuditorVerifierCalls(stub func(context.Context, driver.Identity) (driver.Verifier, error)) { + fake.getAuditorVerifierMutex.Lock() + defer fake.getAuditorVerifierMutex.Unlock() + fake.GetAuditorVerifierStub = stub +} + +func (fake *Deserializer) GetAuditorVerifierArgsForCall(i int) (context.Context, driver.Identity) { + fake.getAuditorVerifierMutex.RLock() + defer fake.getAuditorVerifierMutex.RUnlock() + argsForCall := fake.getAuditorVerifierArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *Deserializer) GetAuditorVerifierReturns(result1 driver.Verifier, result2 error) { + fake.getAuditorVerifierMutex.Lock() + defer fake.getAuditorVerifierMutex.Unlock() + fake.GetAuditorVerifierStub = nil + fake.getAuditorVerifierReturns = struct { + result1 driver.Verifier + result2 error + }{result1, result2} +} + +func (fake *Deserializer) GetAuditorVerifierReturnsOnCall(i int, result1 driver.Verifier, result2 error) { + fake.getAuditorVerifierMutex.Lock() + defer fake.getAuditorVerifierMutex.Unlock() + fake.GetAuditorVerifierStub = nil + if fake.getAuditorVerifierReturnsOnCall == nil { + fake.getAuditorVerifierReturnsOnCall = make(map[int]struct { + result1 driver.Verifier + result2 error + }) + } + fake.getAuditorVerifierReturnsOnCall[i] = struct { + result1 driver.Verifier + result2 error + }{result1, result2} +} + +func (fake *Deserializer) GetIssuerVerifier(arg1 context.Context, arg2 driver.Identity) (driver.Verifier, error) { + fake.getIssuerVerifierMutex.Lock() + ret, specificReturn := fake.getIssuerVerifierReturnsOnCall[len(fake.getIssuerVerifierArgsForCall)] + fake.getIssuerVerifierArgsForCall = append(fake.getIssuerVerifierArgsForCall, struct { + arg1 context.Context + arg2 driver.Identity + }{arg1, arg2}) + stub := fake.GetIssuerVerifierStub + fakeReturns := fake.getIssuerVerifierReturns + fake.recordInvocation("GetIssuerVerifier", []interface{}{arg1, arg2}) + fake.getIssuerVerifierMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *Deserializer) GetIssuerVerifierCallCount() int { + fake.getIssuerVerifierMutex.RLock() + defer fake.getIssuerVerifierMutex.RUnlock() + return len(fake.getIssuerVerifierArgsForCall) +} + +func (fake *Deserializer) GetIssuerVerifierCalls(stub func(context.Context, driver.Identity) (driver.Verifier, error)) { + fake.getIssuerVerifierMutex.Lock() + defer fake.getIssuerVerifierMutex.Unlock() + fake.GetIssuerVerifierStub = stub +} + +func (fake *Deserializer) GetIssuerVerifierArgsForCall(i int) (context.Context, driver.Identity) { + fake.getIssuerVerifierMutex.RLock() + defer fake.getIssuerVerifierMutex.RUnlock() + argsForCall := fake.getIssuerVerifierArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *Deserializer) GetIssuerVerifierReturns(result1 driver.Verifier, result2 error) { + fake.getIssuerVerifierMutex.Lock() + defer fake.getIssuerVerifierMutex.Unlock() + fake.GetIssuerVerifierStub = nil + fake.getIssuerVerifierReturns = struct { + result1 driver.Verifier + result2 error + }{result1, result2} +} + +func (fake *Deserializer) GetIssuerVerifierReturnsOnCall(i int, result1 driver.Verifier, result2 error) { + fake.getIssuerVerifierMutex.Lock() + defer fake.getIssuerVerifierMutex.Unlock() + fake.GetIssuerVerifierStub = nil + if fake.getIssuerVerifierReturnsOnCall == nil { + fake.getIssuerVerifierReturnsOnCall = make(map[int]struct { + result1 driver.Verifier + result2 error + }) + } + fake.getIssuerVerifierReturnsOnCall[i] = struct { + result1 driver.Verifier + result2 error + }{result1, result2} +} + +func (fake *Deserializer) GetOwnerVerifier(arg1 context.Context, arg2 driver.Identity) (driver.Verifier, error) { + fake.getOwnerVerifierMutex.Lock() + ret, specificReturn := fake.getOwnerVerifierReturnsOnCall[len(fake.getOwnerVerifierArgsForCall)] + fake.getOwnerVerifierArgsForCall = append(fake.getOwnerVerifierArgsForCall, struct { + arg1 context.Context + arg2 driver.Identity + }{arg1, arg2}) + stub := fake.GetOwnerVerifierStub + fakeReturns := fake.getOwnerVerifierReturns + fake.recordInvocation("GetOwnerVerifier", []interface{}{arg1, arg2}) + fake.getOwnerVerifierMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *Deserializer) GetOwnerVerifierCallCount() int { + fake.getOwnerVerifierMutex.RLock() + defer fake.getOwnerVerifierMutex.RUnlock() + return len(fake.getOwnerVerifierArgsForCall) +} + +func (fake *Deserializer) GetOwnerVerifierCalls(stub func(context.Context, driver.Identity) (driver.Verifier, error)) { + fake.getOwnerVerifierMutex.Lock() + defer fake.getOwnerVerifierMutex.Unlock() + fake.GetOwnerVerifierStub = stub +} + +func (fake *Deserializer) GetOwnerVerifierArgsForCall(i int) (context.Context, driver.Identity) { + fake.getOwnerVerifierMutex.RLock() + defer fake.getOwnerVerifierMutex.RUnlock() + argsForCall := fake.getOwnerVerifierArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *Deserializer) GetOwnerVerifierReturns(result1 driver.Verifier, result2 error) { + fake.getOwnerVerifierMutex.Lock() + defer fake.getOwnerVerifierMutex.Unlock() + fake.GetOwnerVerifierStub = nil + fake.getOwnerVerifierReturns = struct { + result1 driver.Verifier + result2 error + }{result1, result2} +} + +func (fake *Deserializer) GetOwnerVerifierReturnsOnCall(i int, result1 driver.Verifier, result2 error) { + fake.getOwnerVerifierMutex.Lock() + defer fake.getOwnerVerifierMutex.Unlock() + fake.GetOwnerVerifierStub = nil + if fake.getOwnerVerifierReturnsOnCall == nil { + fake.getOwnerVerifierReturnsOnCall = make(map[int]struct { + result1 driver.Verifier + result2 error + }) + } + fake.getOwnerVerifierReturnsOnCall[i] = struct { + result1 driver.Verifier + result2 error + }{result1, result2} +} + +func (fake *Deserializer) MatchIdentity(arg1 context.Context, arg2 driver.Identity, arg3 []byte) error { + var arg3Copy []byte + if arg3 != nil { + arg3Copy = make([]byte, len(arg3)) + copy(arg3Copy, arg3) + } + fake.matchIdentityMutex.Lock() + ret, specificReturn := fake.matchIdentityReturnsOnCall[len(fake.matchIdentityArgsForCall)] + fake.matchIdentityArgsForCall = append(fake.matchIdentityArgsForCall, struct { + arg1 context.Context + arg2 driver.Identity + arg3 []byte + }{arg1, arg2, arg3Copy}) + stub := fake.MatchIdentityStub + fakeReturns := fake.matchIdentityReturns + fake.recordInvocation("MatchIdentity", []interface{}{arg1, arg2, arg3Copy}) + fake.matchIdentityMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *Deserializer) MatchIdentityCallCount() int { + fake.matchIdentityMutex.RLock() + defer fake.matchIdentityMutex.RUnlock() + return len(fake.matchIdentityArgsForCall) +} + +func (fake *Deserializer) MatchIdentityCalls(stub func(context.Context, driver.Identity, []byte) error) { + fake.matchIdentityMutex.Lock() + defer fake.matchIdentityMutex.Unlock() + fake.MatchIdentityStub = stub +} + +func (fake *Deserializer) MatchIdentityArgsForCall(i int) (context.Context, driver.Identity, []byte) { + fake.matchIdentityMutex.RLock() + defer fake.matchIdentityMutex.RUnlock() + argsForCall := fake.matchIdentityArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *Deserializer) MatchIdentityReturns(result1 error) { + fake.matchIdentityMutex.Lock() + defer fake.matchIdentityMutex.Unlock() + fake.MatchIdentityStub = nil + fake.matchIdentityReturns = struct { + result1 error + }{result1} +} + +func (fake *Deserializer) MatchIdentityReturnsOnCall(i int, result1 error) { + fake.matchIdentityMutex.Lock() + defer fake.matchIdentityMutex.Unlock() + fake.MatchIdentityStub = nil + if fake.matchIdentityReturnsOnCall == nil { + fake.matchIdentityReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.matchIdentityReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *Deserializer) Recipients(arg1 driver.Identity) ([]driver.Identity, error) { + fake.recipientsMutex.Lock() + ret, specificReturn := fake.recipientsReturnsOnCall[len(fake.recipientsArgsForCall)] + fake.recipientsArgsForCall = append(fake.recipientsArgsForCall, struct { + arg1 driver.Identity + }{arg1}) + stub := fake.RecipientsStub + fakeReturns := fake.recipientsReturns + fake.recordInvocation("Recipients", []interface{}{arg1}) + fake.recipientsMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *Deserializer) RecipientsCallCount() int { + fake.recipientsMutex.RLock() + defer fake.recipientsMutex.RUnlock() + return len(fake.recipientsArgsForCall) +} + +func (fake *Deserializer) RecipientsCalls(stub func(driver.Identity) ([]driver.Identity, error)) { + fake.recipientsMutex.Lock() + defer fake.recipientsMutex.Unlock() + fake.RecipientsStub = stub +} + +func (fake *Deserializer) RecipientsArgsForCall(i int) driver.Identity { + fake.recipientsMutex.RLock() + defer fake.recipientsMutex.RUnlock() + argsForCall := fake.recipientsArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *Deserializer) RecipientsReturns(result1 []driver.Identity, result2 error) { + fake.recipientsMutex.Lock() + defer fake.recipientsMutex.Unlock() + fake.RecipientsStub = nil + fake.recipientsReturns = struct { + result1 []driver.Identity + result2 error + }{result1, result2} +} + +func (fake *Deserializer) RecipientsReturnsOnCall(i int, result1 []driver.Identity, result2 error) { + fake.recipientsMutex.Lock() + defer fake.recipientsMutex.Unlock() + fake.RecipientsStub = nil + if fake.recipientsReturnsOnCall == nil { + fake.recipientsReturnsOnCall = make(map[int]struct { + result1 []driver.Identity + result2 error + }) + } + fake.recipientsReturnsOnCall[i] = struct { + result1 []driver.Identity + result2 error + }{result1, result2} +} + +func (fake *Deserializer) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *Deserializer) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ role.Deserializer = new(Deserializer) diff --git a/token/services/identity/role/mock/ip.go b/token/services/identity/role/mock/ip.go new file mode 100644 index 0000000000..f9f102cb3b --- /dev/null +++ b/token/services/identity/role/mock/ip.go @@ -0,0 +1,995 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package mock + +import ( + "context" + "sync" + + "github.com/hyperledger-labs/fabric-token-sdk/token/driver" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/role" +) + +type IdentityProvider struct { + AreMeStub func(context.Context, ...driver.Identity) []string + areMeMutex sync.RWMutex + areMeArgsForCall []struct { + arg1 context.Context + arg2 []driver.Identity + } + areMeReturns struct { + result1 []string + } + areMeReturnsOnCall map[int]struct { + result1 []string + } + BindStub func(context.Context, driver.Identity, ...driver.Identity) error + bindMutex sync.RWMutex + bindArgsForCall []struct { + arg1 context.Context + arg2 driver.Identity + arg3 []driver.Identity + } + bindReturns struct { + result1 error + } + bindReturnsOnCall map[int]struct { + result1 error + } + GetAuditInfoStub func(context.Context, driver.Identity) ([]byte, error) + getAuditInfoMutex sync.RWMutex + getAuditInfoArgsForCall []struct { + arg1 context.Context + arg2 driver.Identity + } + getAuditInfoReturns struct { + result1 []byte + result2 error + } + getAuditInfoReturnsOnCall map[int]struct { + result1 []byte + result2 error + } + GetEIDAndRHStub func(context.Context, driver.Identity, []byte) (string, string, error) + getEIDAndRHMutex sync.RWMutex + getEIDAndRHArgsForCall []struct { + arg1 context.Context + arg2 driver.Identity + arg3 []byte + } + getEIDAndRHReturns struct { + result1 string + result2 string + result3 error + } + getEIDAndRHReturnsOnCall map[int]struct { + result1 string + result2 string + result3 error + } + GetEnrollmentIDStub func(context.Context, driver.Identity, []byte) (string, error) + getEnrollmentIDMutex sync.RWMutex + getEnrollmentIDArgsForCall []struct { + arg1 context.Context + arg2 driver.Identity + arg3 []byte + } + getEnrollmentIDReturns struct { + result1 string + result2 error + } + getEnrollmentIDReturnsOnCall map[int]struct { + result1 string + result2 error + } + GetRevocationHandlerStub func(context.Context, driver.Identity, []byte) (string, error) + getRevocationHandlerMutex sync.RWMutex + getRevocationHandlerArgsForCall []struct { + arg1 context.Context + arg2 driver.Identity + arg3 []byte + } + getRevocationHandlerReturns struct { + result1 string + result2 error + } + getRevocationHandlerReturnsOnCall map[int]struct { + result1 string + result2 error + } + GetSignerStub func(context.Context, driver.Identity) (driver.Signer, error) + getSignerMutex sync.RWMutex + getSignerArgsForCall []struct { + arg1 context.Context + arg2 driver.Identity + } + getSignerReturns struct { + result1 driver.Signer + result2 error + } + getSignerReturnsOnCall map[int]struct { + result1 driver.Signer + result2 error + } + IsMeStub func(context.Context, driver.Identity) bool + isMeMutex sync.RWMutex + isMeArgsForCall []struct { + arg1 context.Context + arg2 driver.Identity + } + isMeReturns struct { + result1 bool + } + isMeReturnsOnCall map[int]struct { + result1 bool + } + RegisterRecipientDataStub func(context.Context, *driver.RecipientData) error + registerRecipientDataMutex sync.RWMutex + registerRecipientDataArgsForCall []struct { + arg1 context.Context + arg2 *driver.RecipientData + } + registerRecipientDataReturns struct { + result1 error + } + registerRecipientDataReturnsOnCall map[int]struct { + result1 error + } + RegisterRecipientIdentityStub func(context.Context, driver.Identity) error + registerRecipientIdentityMutex sync.RWMutex + registerRecipientIdentityArgsForCall []struct { + arg1 context.Context + arg2 driver.Identity + } + registerRecipientIdentityReturns struct { + result1 error + } + registerRecipientIdentityReturnsOnCall map[int]struct { + result1 error + } + RegisterSignerStub func(context.Context, driver.Identity, driver.Signer, driver.Verifier, []byte, bool) error + registerSignerMutex sync.RWMutex + registerSignerArgsForCall []struct { + arg1 context.Context + arg2 driver.Identity + arg3 driver.Signer + arg4 driver.Verifier + arg5 []byte + arg6 bool + } + registerSignerReturns struct { + result1 error + } + registerSignerReturnsOnCall map[int]struct { + result1 error + } + RegisterVerifierStub func(context.Context, driver.Identity, driver.Verifier) error + registerVerifierMutex sync.RWMutex + registerVerifierArgsForCall []struct { + arg1 context.Context + arg2 driver.Identity + arg3 driver.Verifier + } + registerVerifierReturns struct { + result1 error + } + registerVerifierReturnsOnCall map[int]struct { + result1 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *IdentityProvider) AreMe(arg1 context.Context, arg2 ...driver.Identity) []string { + fake.areMeMutex.Lock() + ret, specificReturn := fake.areMeReturnsOnCall[len(fake.areMeArgsForCall)] + fake.areMeArgsForCall = append(fake.areMeArgsForCall, struct { + arg1 context.Context + arg2 []driver.Identity + }{arg1, arg2}) + stub := fake.AreMeStub + fakeReturns := fake.areMeReturns + fake.recordInvocation("AreMe", []interface{}{arg1, arg2}) + fake.areMeMutex.Unlock() + if stub != nil { + return stub(arg1, arg2...) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *IdentityProvider) AreMeCallCount() int { + fake.areMeMutex.RLock() + defer fake.areMeMutex.RUnlock() + return len(fake.areMeArgsForCall) +} + +func (fake *IdentityProvider) AreMeCalls(stub func(context.Context, ...driver.Identity) []string) { + fake.areMeMutex.Lock() + defer fake.areMeMutex.Unlock() + fake.AreMeStub = stub +} + +func (fake *IdentityProvider) AreMeArgsForCall(i int) (context.Context, []driver.Identity) { + fake.areMeMutex.RLock() + defer fake.areMeMutex.RUnlock() + argsForCall := fake.areMeArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *IdentityProvider) AreMeReturns(result1 []string) { + fake.areMeMutex.Lock() + defer fake.areMeMutex.Unlock() + fake.AreMeStub = nil + fake.areMeReturns = struct { + result1 []string + }{result1} +} + +func (fake *IdentityProvider) AreMeReturnsOnCall(i int, result1 []string) { + fake.areMeMutex.Lock() + defer fake.areMeMutex.Unlock() + fake.AreMeStub = nil + if fake.areMeReturnsOnCall == nil { + fake.areMeReturnsOnCall = make(map[int]struct { + result1 []string + }) + } + fake.areMeReturnsOnCall[i] = struct { + result1 []string + }{result1} +} + +func (fake *IdentityProvider) Bind(arg1 context.Context, arg2 driver.Identity, arg3 ...driver.Identity) error { + fake.bindMutex.Lock() + ret, specificReturn := fake.bindReturnsOnCall[len(fake.bindArgsForCall)] + fake.bindArgsForCall = append(fake.bindArgsForCall, struct { + arg1 context.Context + arg2 driver.Identity + arg3 []driver.Identity + }{arg1, arg2, arg3}) + stub := fake.BindStub + fakeReturns := fake.bindReturns + fake.recordInvocation("Bind", []interface{}{arg1, arg2, arg3}) + fake.bindMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3...) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *IdentityProvider) BindCallCount() int { + fake.bindMutex.RLock() + defer fake.bindMutex.RUnlock() + return len(fake.bindArgsForCall) +} + +func (fake *IdentityProvider) BindCalls(stub func(context.Context, driver.Identity, ...driver.Identity) error) { + fake.bindMutex.Lock() + defer fake.bindMutex.Unlock() + fake.BindStub = stub +} + +func (fake *IdentityProvider) BindArgsForCall(i int) (context.Context, driver.Identity, []driver.Identity) { + fake.bindMutex.RLock() + defer fake.bindMutex.RUnlock() + argsForCall := fake.bindArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *IdentityProvider) BindReturns(result1 error) { + fake.bindMutex.Lock() + defer fake.bindMutex.Unlock() + fake.BindStub = nil + fake.bindReturns = struct { + result1 error + }{result1} +} + +func (fake *IdentityProvider) BindReturnsOnCall(i int, result1 error) { + fake.bindMutex.Lock() + defer fake.bindMutex.Unlock() + fake.BindStub = nil + if fake.bindReturnsOnCall == nil { + fake.bindReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.bindReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *IdentityProvider) GetAuditInfo(arg1 context.Context, arg2 driver.Identity) ([]byte, error) { + fake.getAuditInfoMutex.Lock() + ret, specificReturn := fake.getAuditInfoReturnsOnCall[len(fake.getAuditInfoArgsForCall)] + fake.getAuditInfoArgsForCall = append(fake.getAuditInfoArgsForCall, struct { + arg1 context.Context + arg2 driver.Identity + }{arg1, arg2}) + stub := fake.GetAuditInfoStub + fakeReturns := fake.getAuditInfoReturns + fake.recordInvocation("GetAuditInfo", []interface{}{arg1, arg2}) + fake.getAuditInfoMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *IdentityProvider) GetAuditInfoCallCount() int { + fake.getAuditInfoMutex.RLock() + defer fake.getAuditInfoMutex.RUnlock() + return len(fake.getAuditInfoArgsForCall) +} + +func (fake *IdentityProvider) GetAuditInfoCalls(stub func(context.Context, driver.Identity) ([]byte, error)) { + fake.getAuditInfoMutex.Lock() + defer fake.getAuditInfoMutex.Unlock() + fake.GetAuditInfoStub = stub +} + +func (fake *IdentityProvider) GetAuditInfoArgsForCall(i int) (context.Context, driver.Identity) { + fake.getAuditInfoMutex.RLock() + defer fake.getAuditInfoMutex.RUnlock() + argsForCall := fake.getAuditInfoArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *IdentityProvider) GetAuditInfoReturns(result1 []byte, result2 error) { + fake.getAuditInfoMutex.Lock() + defer fake.getAuditInfoMutex.Unlock() + fake.GetAuditInfoStub = nil + fake.getAuditInfoReturns = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *IdentityProvider) GetAuditInfoReturnsOnCall(i int, result1 []byte, result2 error) { + fake.getAuditInfoMutex.Lock() + defer fake.getAuditInfoMutex.Unlock() + fake.GetAuditInfoStub = nil + if fake.getAuditInfoReturnsOnCall == nil { + fake.getAuditInfoReturnsOnCall = make(map[int]struct { + result1 []byte + result2 error + }) + } + fake.getAuditInfoReturnsOnCall[i] = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *IdentityProvider) GetEIDAndRH(arg1 context.Context, arg2 driver.Identity, arg3 []byte) (string, string, error) { + var arg3Copy []byte + if arg3 != nil { + arg3Copy = make([]byte, len(arg3)) + copy(arg3Copy, arg3) + } + fake.getEIDAndRHMutex.Lock() + ret, specificReturn := fake.getEIDAndRHReturnsOnCall[len(fake.getEIDAndRHArgsForCall)] + fake.getEIDAndRHArgsForCall = append(fake.getEIDAndRHArgsForCall, struct { + arg1 context.Context + arg2 driver.Identity + arg3 []byte + }{arg1, arg2, arg3Copy}) + stub := fake.GetEIDAndRHStub + fakeReturns := fake.getEIDAndRHReturns + fake.recordInvocation("GetEIDAndRH", []interface{}{arg1, arg2, arg3Copy}) + fake.getEIDAndRHMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1, ret.result2, ret.result3 + } + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 +} + +func (fake *IdentityProvider) GetEIDAndRHCallCount() int { + fake.getEIDAndRHMutex.RLock() + defer fake.getEIDAndRHMutex.RUnlock() + return len(fake.getEIDAndRHArgsForCall) +} + +func (fake *IdentityProvider) GetEIDAndRHCalls(stub func(context.Context, driver.Identity, []byte) (string, string, error)) { + fake.getEIDAndRHMutex.Lock() + defer fake.getEIDAndRHMutex.Unlock() + fake.GetEIDAndRHStub = stub +} + +func (fake *IdentityProvider) GetEIDAndRHArgsForCall(i int) (context.Context, driver.Identity, []byte) { + fake.getEIDAndRHMutex.RLock() + defer fake.getEIDAndRHMutex.RUnlock() + argsForCall := fake.getEIDAndRHArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *IdentityProvider) GetEIDAndRHReturns(result1 string, result2 string, result3 error) { + fake.getEIDAndRHMutex.Lock() + defer fake.getEIDAndRHMutex.Unlock() + fake.GetEIDAndRHStub = nil + fake.getEIDAndRHReturns = struct { + result1 string + result2 string + result3 error + }{result1, result2, result3} +} + +func (fake *IdentityProvider) GetEIDAndRHReturnsOnCall(i int, result1 string, result2 string, result3 error) { + fake.getEIDAndRHMutex.Lock() + defer fake.getEIDAndRHMutex.Unlock() + fake.GetEIDAndRHStub = nil + if fake.getEIDAndRHReturnsOnCall == nil { + fake.getEIDAndRHReturnsOnCall = make(map[int]struct { + result1 string + result2 string + result3 error + }) + } + fake.getEIDAndRHReturnsOnCall[i] = struct { + result1 string + result2 string + result3 error + }{result1, result2, result3} +} + +func (fake *IdentityProvider) GetEnrollmentID(arg1 context.Context, arg2 driver.Identity, arg3 []byte) (string, error) { + var arg3Copy []byte + if arg3 != nil { + arg3Copy = make([]byte, len(arg3)) + copy(arg3Copy, arg3) + } + fake.getEnrollmentIDMutex.Lock() + ret, specificReturn := fake.getEnrollmentIDReturnsOnCall[len(fake.getEnrollmentIDArgsForCall)] + fake.getEnrollmentIDArgsForCall = append(fake.getEnrollmentIDArgsForCall, struct { + arg1 context.Context + arg2 driver.Identity + arg3 []byte + }{arg1, arg2, arg3Copy}) + stub := fake.GetEnrollmentIDStub + fakeReturns := fake.getEnrollmentIDReturns + fake.recordInvocation("GetEnrollmentID", []interface{}{arg1, arg2, arg3Copy}) + fake.getEnrollmentIDMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *IdentityProvider) GetEnrollmentIDCallCount() int { + fake.getEnrollmentIDMutex.RLock() + defer fake.getEnrollmentIDMutex.RUnlock() + return len(fake.getEnrollmentIDArgsForCall) +} + +func (fake *IdentityProvider) GetEnrollmentIDCalls(stub func(context.Context, driver.Identity, []byte) (string, error)) { + fake.getEnrollmentIDMutex.Lock() + defer fake.getEnrollmentIDMutex.Unlock() + fake.GetEnrollmentIDStub = stub +} + +func (fake *IdentityProvider) GetEnrollmentIDArgsForCall(i int) (context.Context, driver.Identity, []byte) { + fake.getEnrollmentIDMutex.RLock() + defer fake.getEnrollmentIDMutex.RUnlock() + argsForCall := fake.getEnrollmentIDArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *IdentityProvider) GetEnrollmentIDReturns(result1 string, result2 error) { + fake.getEnrollmentIDMutex.Lock() + defer fake.getEnrollmentIDMutex.Unlock() + fake.GetEnrollmentIDStub = nil + fake.getEnrollmentIDReturns = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *IdentityProvider) GetEnrollmentIDReturnsOnCall(i int, result1 string, result2 error) { + fake.getEnrollmentIDMutex.Lock() + defer fake.getEnrollmentIDMutex.Unlock() + fake.GetEnrollmentIDStub = nil + if fake.getEnrollmentIDReturnsOnCall == nil { + fake.getEnrollmentIDReturnsOnCall = make(map[int]struct { + result1 string + result2 error + }) + } + fake.getEnrollmentIDReturnsOnCall[i] = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *IdentityProvider) GetRevocationHandler(arg1 context.Context, arg2 driver.Identity, arg3 []byte) (string, error) { + var arg3Copy []byte + if arg3 != nil { + arg3Copy = make([]byte, len(arg3)) + copy(arg3Copy, arg3) + } + fake.getRevocationHandlerMutex.Lock() + ret, specificReturn := fake.getRevocationHandlerReturnsOnCall[len(fake.getRevocationHandlerArgsForCall)] + fake.getRevocationHandlerArgsForCall = append(fake.getRevocationHandlerArgsForCall, struct { + arg1 context.Context + arg2 driver.Identity + arg3 []byte + }{arg1, arg2, arg3Copy}) + stub := fake.GetRevocationHandlerStub + fakeReturns := fake.getRevocationHandlerReturns + fake.recordInvocation("GetRevocationHandler", []interface{}{arg1, arg2, arg3Copy}) + fake.getRevocationHandlerMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *IdentityProvider) GetRevocationHandlerCallCount() int { + fake.getRevocationHandlerMutex.RLock() + defer fake.getRevocationHandlerMutex.RUnlock() + return len(fake.getRevocationHandlerArgsForCall) +} + +func (fake *IdentityProvider) GetRevocationHandlerCalls(stub func(context.Context, driver.Identity, []byte) (string, error)) { + fake.getRevocationHandlerMutex.Lock() + defer fake.getRevocationHandlerMutex.Unlock() + fake.GetRevocationHandlerStub = stub +} + +func (fake *IdentityProvider) GetRevocationHandlerArgsForCall(i int) (context.Context, driver.Identity, []byte) { + fake.getRevocationHandlerMutex.RLock() + defer fake.getRevocationHandlerMutex.RUnlock() + argsForCall := fake.getRevocationHandlerArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *IdentityProvider) GetRevocationHandlerReturns(result1 string, result2 error) { + fake.getRevocationHandlerMutex.Lock() + defer fake.getRevocationHandlerMutex.Unlock() + fake.GetRevocationHandlerStub = nil + fake.getRevocationHandlerReturns = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *IdentityProvider) GetRevocationHandlerReturnsOnCall(i int, result1 string, result2 error) { + fake.getRevocationHandlerMutex.Lock() + defer fake.getRevocationHandlerMutex.Unlock() + fake.GetRevocationHandlerStub = nil + if fake.getRevocationHandlerReturnsOnCall == nil { + fake.getRevocationHandlerReturnsOnCall = make(map[int]struct { + result1 string + result2 error + }) + } + fake.getRevocationHandlerReturnsOnCall[i] = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *IdentityProvider) GetSigner(arg1 context.Context, arg2 driver.Identity) (driver.Signer, error) { + fake.getSignerMutex.Lock() + ret, specificReturn := fake.getSignerReturnsOnCall[len(fake.getSignerArgsForCall)] + fake.getSignerArgsForCall = append(fake.getSignerArgsForCall, struct { + arg1 context.Context + arg2 driver.Identity + }{arg1, arg2}) + stub := fake.GetSignerStub + fakeReturns := fake.getSignerReturns + fake.recordInvocation("GetSigner", []interface{}{arg1, arg2}) + fake.getSignerMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *IdentityProvider) GetSignerCallCount() int { + fake.getSignerMutex.RLock() + defer fake.getSignerMutex.RUnlock() + return len(fake.getSignerArgsForCall) +} + +func (fake *IdentityProvider) GetSignerCalls(stub func(context.Context, driver.Identity) (driver.Signer, error)) { + fake.getSignerMutex.Lock() + defer fake.getSignerMutex.Unlock() + fake.GetSignerStub = stub +} + +func (fake *IdentityProvider) GetSignerArgsForCall(i int) (context.Context, driver.Identity) { + fake.getSignerMutex.RLock() + defer fake.getSignerMutex.RUnlock() + argsForCall := fake.getSignerArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *IdentityProvider) GetSignerReturns(result1 driver.Signer, result2 error) { + fake.getSignerMutex.Lock() + defer fake.getSignerMutex.Unlock() + fake.GetSignerStub = nil + fake.getSignerReturns = struct { + result1 driver.Signer + result2 error + }{result1, result2} +} + +func (fake *IdentityProvider) GetSignerReturnsOnCall(i int, result1 driver.Signer, result2 error) { + fake.getSignerMutex.Lock() + defer fake.getSignerMutex.Unlock() + fake.GetSignerStub = nil + if fake.getSignerReturnsOnCall == nil { + fake.getSignerReturnsOnCall = make(map[int]struct { + result1 driver.Signer + result2 error + }) + } + fake.getSignerReturnsOnCall[i] = struct { + result1 driver.Signer + result2 error + }{result1, result2} +} + +func (fake *IdentityProvider) IsMe(arg1 context.Context, arg2 driver.Identity) bool { + fake.isMeMutex.Lock() + ret, specificReturn := fake.isMeReturnsOnCall[len(fake.isMeArgsForCall)] + fake.isMeArgsForCall = append(fake.isMeArgsForCall, struct { + arg1 context.Context + arg2 driver.Identity + }{arg1, arg2}) + stub := fake.IsMeStub + fakeReturns := fake.isMeReturns + fake.recordInvocation("IsMe", []interface{}{arg1, arg2}) + fake.isMeMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *IdentityProvider) IsMeCallCount() int { + fake.isMeMutex.RLock() + defer fake.isMeMutex.RUnlock() + return len(fake.isMeArgsForCall) +} + +func (fake *IdentityProvider) IsMeCalls(stub func(context.Context, driver.Identity) bool) { + fake.isMeMutex.Lock() + defer fake.isMeMutex.Unlock() + fake.IsMeStub = stub +} + +func (fake *IdentityProvider) IsMeArgsForCall(i int) (context.Context, driver.Identity) { + fake.isMeMutex.RLock() + defer fake.isMeMutex.RUnlock() + argsForCall := fake.isMeArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *IdentityProvider) IsMeReturns(result1 bool) { + fake.isMeMutex.Lock() + defer fake.isMeMutex.Unlock() + fake.IsMeStub = nil + fake.isMeReturns = struct { + result1 bool + }{result1} +} + +func (fake *IdentityProvider) IsMeReturnsOnCall(i int, result1 bool) { + fake.isMeMutex.Lock() + defer fake.isMeMutex.Unlock() + fake.IsMeStub = nil + if fake.isMeReturnsOnCall == nil { + fake.isMeReturnsOnCall = make(map[int]struct { + result1 bool + }) + } + fake.isMeReturnsOnCall[i] = struct { + result1 bool + }{result1} +} + +func (fake *IdentityProvider) RegisterRecipientData(arg1 context.Context, arg2 *driver.RecipientData) error { + fake.registerRecipientDataMutex.Lock() + ret, specificReturn := fake.registerRecipientDataReturnsOnCall[len(fake.registerRecipientDataArgsForCall)] + fake.registerRecipientDataArgsForCall = append(fake.registerRecipientDataArgsForCall, struct { + arg1 context.Context + arg2 *driver.RecipientData + }{arg1, arg2}) + stub := fake.RegisterRecipientDataStub + fakeReturns := fake.registerRecipientDataReturns + fake.recordInvocation("RegisterRecipientData", []interface{}{arg1, arg2}) + fake.registerRecipientDataMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *IdentityProvider) RegisterRecipientDataCallCount() int { + fake.registerRecipientDataMutex.RLock() + defer fake.registerRecipientDataMutex.RUnlock() + return len(fake.registerRecipientDataArgsForCall) +} + +func (fake *IdentityProvider) RegisterRecipientDataCalls(stub func(context.Context, *driver.RecipientData) error) { + fake.registerRecipientDataMutex.Lock() + defer fake.registerRecipientDataMutex.Unlock() + fake.RegisterRecipientDataStub = stub +} + +func (fake *IdentityProvider) RegisterRecipientDataArgsForCall(i int) (context.Context, *driver.RecipientData) { + fake.registerRecipientDataMutex.RLock() + defer fake.registerRecipientDataMutex.RUnlock() + argsForCall := fake.registerRecipientDataArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *IdentityProvider) RegisterRecipientDataReturns(result1 error) { + fake.registerRecipientDataMutex.Lock() + defer fake.registerRecipientDataMutex.Unlock() + fake.RegisterRecipientDataStub = nil + fake.registerRecipientDataReturns = struct { + result1 error + }{result1} +} + +func (fake *IdentityProvider) RegisterRecipientDataReturnsOnCall(i int, result1 error) { + fake.registerRecipientDataMutex.Lock() + defer fake.registerRecipientDataMutex.Unlock() + fake.RegisterRecipientDataStub = nil + if fake.registerRecipientDataReturnsOnCall == nil { + fake.registerRecipientDataReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.registerRecipientDataReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *IdentityProvider) RegisterRecipientIdentity(arg1 context.Context, arg2 driver.Identity) error { + fake.registerRecipientIdentityMutex.Lock() + ret, specificReturn := fake.registerRecipientIdentityReturnsOnCall[len(fake.registerRecipientIdentityArgsForCall)] + fake.registerRecipientIdentityArgsForCall = append(fake.registerRecipientIdentityArgsForCall, struct { + arg1 context.Context + arg2 driver.Identity + }{arg1, arg2}) + stub := fake.RegisterRecipientIdentityStub + fakeReturns := fake.registerRecipientIdentityReturns + fake.recordInvocation("RegisterRecipientIdentity", []interface{}{arg1, arg2}) + fake.registerRecipientIdentityMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *IdentityProvider) RegisterRecipientIdentityCallCount() int { + fake.registerRecipientIdentityMutex.RLock() + defer fake.registerRecipientIdentityMutex.RUnlock() + return len(fake.registerRecipientIdentityArgsForCall) +} + +func (fake *IdentityProvider) RegisterRecipientIdentityCalls(stub func(context.Context, driver.Identity) error) { + fake.registerRecipientIdentityMutex.Lock() + defer fake.registerRecipientIdentityMutex.Unlock() + fake.RegisterRecipientIdentityStub = stub +} + +func (fake *IdentityProvider) RegisterRecipientIdentityArgsForCall(i int) (context.Context, driver.Identity) { + fake.registerRecipientIdentityMutex.RLock() + defer fake.registerRecipientIdentityMutex.RUnlock() + argsForCall := fake.registerRecipientIdentityArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *IdentityProvider) RegisterRecipientIdentityReturns(result1 error) { + fake.registerRecipientIdentityMutex.Lock() + defer fake.registerRecipientIdentityMutex.Unlock() + fake.RegisterRecipientIdentityStub = nil + fake.registerRecipientIdentityReturns = struct { + result1 error + }{result1} +} + +func (fake *IdentityProvider) RegisterRecipientIdentityReturnsOnCall(i int, result1 error) { + fake.registerRecipientIdentityMutex.Lock() + defer fake.registerRecipientIdentityMutex.Unlock() + fake.RegisterRecipientIdentityStub = nil + if fake.registerRecipientIdentityReturnsOnCall == nil { + fake.registerRecipientIdentityReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.registerRecipientIdentityReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *IdentityProvider) RegisterSigner(arg1 context.Context, arg2 driver.Identity, arg3 driver.Signer, arg4 driver.Verifier, arg5 []byte, arg6 bool) error { + var arg5Copy []byte + if arg5 != nil { + arg5Copy = make([]byte, len(arg5)) + copy(arg5Copy, arg5) + } + fake.registerSignerMutex.Lock() + ret, specificReturn := fake.registerSignerReturnsOnCall[len(fake.registerSignerArgsForCall)] + fake.registerSignerArgsForCall = append(fake.registerSignerArgsForCall, struct { + arg1 context.Context + arg2 driver.Identity + arg3 driver.Signer + arg4 driver.Verifier + arg5 []byte + arg6 bool + }{arg1, arg2, arg3, arg4, arg5Copy, arg6}) + stub := fake.RegisterSignerStub + fakeReturns := fake.registerSignerReturns + fake.recordInvocation("RegisterSigner", []interface{}{arg1, arg2, arg3, arg4, arg5Copy, arg6}) + fake.registerSignerMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5, arg6) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *IdentityProvider) RegisterSignerCallCount() int { + fake.registerSignerMutex.RLock() + defer fake.registerSignerMutex.RUnlock() + return len(fake.registerSignerArgsForCall) +} + +func (fake *IdentityProvider) RegisterSignerCalls(stub func(context.Context, driver.Identity, driver.Signer, driver.Verifier, []byte, bool) error) { + fake.registerSignerMutex.Lock() + defer fake.registerSignerMutex.Unlock() + fake.RegisterSignerStub = stub +} + +func (fake *IdentityProvider) RegisterSignerArgsForCall(i int) (context.Context, driver.Identity, driver.Signer, driver.Verifier, []byte, bool) { + fake.registerSignerMutex.RLock() + defer fake.registerSignerMutex.RUnlock() + argsForCall := fake.registerSignerArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6 +} + +func (fake *IdentityProvider) RegisterSignerReturns(result1 error) { + fake.registerSignerMutex.Lock() + defer fake.registerSignerMutex.Unlock() + fake.RegisterSignerStub = nil + fake.registerSignerReturns = struct { + result1 error + }{result1} +} + +func (fake *IdentityProvider) RegisterSignerReturnsOnCall(i int, result1 error) { + fake.registerSignerMutex.Lock() + defer fake.registerSignerMutex.Unlock() + fake.RegisterSignerStub = nil + if fake.registerSignerReturnsOnCall == nil { + fake.registerSignerReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.registerSignerReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *IdentityProvider) RegisterVerifier(arg1 context.Context, arg2 driver.Identity, arg3 driver.Verifier) error { + fake.registerVerifierMutex.Lock() + ret, specificReturn := fake.registerVerifierReturnsOnCall[len(fake.registerVerifierArgsForCall)] + fake.registerVerifierArgsForCall = append(fake.registerVerifierArgsForCall, struct { + arg1 context.Context + arg2 driver.Identity + arg3 driver.Verifier + }{arg1, arg2, arg3}) + stub := fake.RegisterVerifierStub + fakeReturns := fake.registerVerifierReturns + fake.recordInvocation("RegisterVerifier", []interface{}{arg1, arg2, arg3}) + fake.registerVerifierMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *IdentityProvider) RegisterVerifierCallCount() int { + fake.registerVerifierMutex.RLock() + defer fake.registerVerifierMutex.RUnlock() + return len(fake.registerVerifierArgsForCall) +} + +func (fake *IdentityProvider) RegisterVerifierCalls(stub func(context.Context, driver.Identity, driver.Verifier) error) { + fake.registerVerifierMutex.Lock() + defer fake.registerVerifierMutex.Unlock() + fake.RegisterVerifierStub = stub +} + +func (fake *IdentityProvider) RegisterVerifierArgsForCall(i int) (context.Context, driver.Identity, driver.Verifier) { + fake.registerVerifierMutex.RLock() + defer fake.registerVerifierMutex.RUnlock() + argsForCall := fake.registerVerifierArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *IdentityProvider) RegisterVerifierReturns(result1 error) { + fake.registerVerifierMutex.Lock() + defer fake.registerVerifierMutex.Unlock() + fake.RegisterVerifierStub = nil + fake.registerVerifierReturns = struct { + result1 error + }{result1} +} + +func (fake *IdentityProvider) RegisterVerifierReturnsOnCall(i int, result1 error) { + fake.registerVerifierMutex.Lock() + defer fake.registerVerifierMutex.Unlock() + fake.RegisterVerifierStub = nil + if fake.registerVerifierReturnsOnCall == nil { + fake.registerVerifierReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.registerVerifierReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *IdentityProvider) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *IdentityProvider) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ role.IdentityProvider = new(IdentityProvider) diff --git a/token/services/identity/role/mock/itv.go b/token/services/identity/role/mock/itv.go new file mode 100644 index 0000000000..5b5bc9ab54 --- /dev/null +++ b/token/services/identity/role/mock/itv.go @@ -0,0 +1,116 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package mock + +import ( + "context" + "sync" + + "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/role" + "github.com/hyperledger-labs/fabric-token-sdk/token/token" +) + +type IssuerTokenVault struct { + ListHistoryIssuedTokensStub func(context.Context) (*token.IssuedTokens, error) + listHistoryIssuedTokensMutex sync.RWMutex + listHistoryIssuedTokensArgsForCall []struct { + arg1 context.Context + } + listHistoryIssuedTokensReturns struct { + result1 *token.IssuedTokens + result2 error + } + listHistoryIssuedTokensReturnsOnCall map[int]struct { + result1 *token.IssuedTokens + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *IssuerTokenVault) ListHistoryIssuedTokens(arg1 context.Context) (*token.IssuedTokens, error) { + fake.listHistoryIssuedTokensMutex.Lock() + ret, specificReturn := fake.listHistoryIssuedTokensReturnsOnCall[len(fake.listHistoryIssuedTokensArgsForCall)] + fake.listHistoryIssuedTokensArgsForCall = append(fake.listHistoryIssuedTokensArgsForCall, struct { + arg1 context.Context + }{arg1}) + stub := fake.ListHistoryIssuedTokensStub + fakeReturns := fake.listHistoryIssuedTokensReturns + fake.recordInvocation("ListHistoryIssuedTokens", []interface{}{arg1}) + fake.listHistoryIssuedTokensMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *IssuerTokenVault) ListHistoryIssuedTokensCallCount() int { + fake.listHistoryIssuedTokensMutex.RLock() + defer fake.listHistoryIssuedTokensMutex.RUnlock() + return len(fake.listHistoryIssuedTokensArgsForCall) +} + +func (fake *IssuerTokenVault) ListHistoryIssuedTokensCalls(stub func(context.Context) (*token.IssuedTokens, error)) { + fake.listHistoryIssuedTokensMutex.Lock() + defer fake.listHistoryIssuedTokensMutex.Unlock() + fake.ListHistoryIssuedTokensStub = stub +} + +func (fake *IssuerTokenVault) ListHistoryIssuedTokensArgsForCall(i int) context.Context { + fake.listHistoryIssuedTokensMutex.RLock() + defer fake.listHistoryIssuedTokensMutex.RUnlock() + argsForCall := fake.listHistoryIssuedTokensArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *IssuerTokenVault) ListHistoryIssuedTokensReturns(result1 *token.IssuedTokens, result2 error) { + fake.listHistoryIssuedTokensMutex.Lock() + defer fake.listHistoryIssuedTokensMutex.Unlock() + fake.ListHistoryIssuedTokensStub = nil + fake.listHistoryIssuedTokensReturns = struct { + result1 *token.IssuedTokens + result2 error + }{result1, result2} +} + +func (fake *IssuerTokenVault) ListHistoryIssuedTokensReturnsOnCall(i int, result1 *token.IssuedTokens, result2 error) { + fake.listHistoryIssuedTokensMutex.Lock() + defer fake.listHistoryIssuedTokensMutex.Unlock() + fake.ListHistoryIssuedTokensStub = nil + if fake.listHistoryIssuedTokensReturnsOnCall == nil { + fake.listHistoryIssuedTokensReturnsOnCall = make(map[int]struct { + result1 *token.IssuedTokens + result2 error + }) + } + fake.listHistoryIssuedTokensReturnsOnCall[i] = struct { + result1 *token.IssuedTokens + result2 error + }{result1, result2} +} + +func (fake *IssuerTokenVault) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *IssuerTokenVault) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ role.IssuerTokenVault = new(IssuerTokenVault) diff --git a/token/services/identity/role/mock/lm.go b/token/services/identity/role/mock/lm.go new file mode 100644 index 0000000000..b1e21d43f1 --- /dev/null +++ b/token/services/identity/role/mock/lm.go @@ -0,0 +1,547 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package mock + +import ( + "context" + "sync" + + "github.com/hyperledger-labs/fabric-token-sdk/token/driver" + drivera "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/driver" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/role" +) + +type LocalMembership struct { + DefaultNetworkIdentityStub func() driver.Identity + defaultNetworkIdentityMutex sync.RWMutex + defaultNetworkIdentityArgsForCall []struct { + } + defaultNetworkIdentityReturns struct { + result1 driver.Identity + } + defaultNetworkIdentityReturnsOnCall map[int]struct { + result1 driver.Identity + } + GetDefaultIdentifierStub func() string + getDefaultIdentifierMutex sync.RWMutex + getDefaultIdentifierArgsForCall []struct { + } + getDefaultIdentifierReturns struct { + result1 string + } + getDefaultIdentifierReturnsOnCall map[int]struct { + result1 string + } + GetIdentifierStub func(context.Context, driver.Identity) (string, error) + getIdentifierMutex sync.RWMutex + getIdentifierArgsForCall []struct { + arg1 context.Context + arg2 driver.Identity + } + getIdentifierReturns struct { + result1 string + result2 error + } + getIdentifierReturnsOnCall map[int]struct { + result1 string + result2 error + } + GetIdentityInfoStub func(context.Context, string, []byte) (drivera.IdentityInfo, error) + getIdentityInfoMutex sync.RWMutex + getIdentityInfoArgsForCall []struct { + arg1 context.Context + arg2 string + arg3 []byte + } + getIdentityInfoReturns struct { + result1 drivera.IdentityInfo + result2 error + } + getIdentityInfoReturnsOnCall map[int]struct { + result1 drivera.IdentityInfo + result2 error + } + IDsStub func() ([]string, error) + iDsMutex sync.RWMutex + iDsArgsForCall []struct { + } + iDsReturns struct { + result1 []string + result2 error + } + iDsReturnsOnCall map[int]struct { + result1 []string + result2 error + } + IsMeStub func(context.Context, driver.Identity) bool + isMeMutex sync.RWMutex + isMeArgsForCall []struct { + arg1 context.Context + arg2 driver.Identity + } + isMeReturns struct { + result1 bool + } + isMeReturnsOnCall map[int]struct { + result1 bool + } + RegisterIdentityStub func(context.Context, driver.IdentityConfiguration) error + registerIdentityMutex sync.RWMutex + registerIdentityArgsForCall []struct { + arg1 context.Context + arg2 driver.IdentityConfiguration + } + registerIdentityReturns struct { + result1 error + } + registerIdentityReturnsOnCall map[int]struct { + result1 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *LocalMembership) DefaultNetworkIdentity() driver.Identity { + fake.defaultNetworkIdentityMutex.Lock() + ret, specificReturn := fake.defaultNetworkIdentityReturnsOnCall[len(fake.defaultNetworkIdentityArgsForCall)] + fake.defaultNetworkIdentityArgsForCall = append(fake.defaultNetworkIdentityArgsForCall, struct { + }{}) + stub := fake.DefaultNetworkIdentityStub + fakeReturns := fake.defaultNetworkIdentityReturns + fake.recordInvocation("DefaultNetworkIdentity", []interface{}{}) + fake.defaultNetworkIdentityMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *LocalMembership) DefaultNetworkIdentityCallCount() int { + fake.defaultNetworkIdentityMutex.RLock() + defer fake.defaultNetworkIdentityMutex.RUnlock() + return len(fake.defaultNetworkIdentityArgsForCall) +} + +func (fake *LocalMembership) DefaultNetworkIdentityCalls(stub func() driver.Identity) { + fake.defaultNetworkIdentityMutex.Lock() + defer fake.defaultNetworkIdentityMutex.Unlock() + fake.DefaultNetworkIdentityStub = stub +} + +func (fake *LocalMembership) DefaultNetworkIdentityReturns(result1 driver.Identity) { + fake.defaultNetworkIdentityMutex.Lock() + defer fake.defaultNetworkIdentityMutex.Unlock() + fake.DefaultNetworkIdentityStub = nil + fake.defaultNetworkIdentityReturns = struct { + result1 driver.Identity + }{result1} +} + +func (fake *LocalMembership) DefaultNetworkIdentityReturnsOnCall(i int, result1 driver.Identity) { + fake.defaultNetworkIdentityMutex.Lock() + defer fake.defaultNetworkIdentityMutex.Unlock() + fake.DefaultNetworkIdentityStub = nil + if fake.defaultNetworkIdentityReturnsOnCall == nil { + fake.defaultNetworkIdentityReturnsOnCall = make(map[int]struct { + result1 driver.Identity + }) + } + fake.defaultNetworkIdentityReturnsOnCall[i] = struct { + result1 driver.Identity + }{result1} +} + +func (fake *LocalMembership) GetDefaultIdentifier() string { + fake.getDefaultIdentifierMutex.Lock() + ret, specificReturn := fake.getDefaultIdentifierReturnsOnCall[len(fake.getDefaultIdentifierArgsForCall)] + fake.getDefaultIdentifierArgsForCall = append(fake.getDefaultIdentifierArgsForCall, struct { + }{}) + stub := fake.GetDefaultIdentifierStub + fakeReturns := fake.getDefaultIdentifierReturns + fake.recordInvocation("GetDefaultIdentifier", []interface{}{}) + fake.getDefaultIdentifierMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *LocalMembership) GetDefaultIdentifierCallCount() int { + fake.getDefaultIdentifierMutex.RLock() + defer fake.getDefaultIdentifierMutex.RUnlock() + return len(fake.getDefaultIdentifierArgsForCall) +} + +func (fake *LocalMembership) GetDefaultIdentifierCalls(stub func() string) { + fake.getDefaultIdentifierMutex.Lock() + defer fake.getDefaultIdentifierMutex.Unlock() + fake.GetDefaultIdentifierStub = stub +} + +func (fake *LocalMembership) GetDefaultIdentifierReturns(result1 string) { + fake.getDefaultIdentifierMutex.Lock() + defer fake.getDefaultIdentifierMutex.Unlock() + fake.GetDefaultIdentifierStub = nil + fake.getDefaultIdentifierReturns = struct { + result1 string + }{result1} +} + +func (fake *LocalMembership) GetDefaultIdentifierReturnsOnCall(i int, result1 string) { + fake.getDefaultIdentifierMutex.Lock() + defer fake.getDefaultIdentifierMutex.Unlock() + fake.GetDefaultIdentifierStub = nil + if fake.getDefaultIdentifierReturnsOnCall == nil { + fake.getDefaultIdentifierReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.getDefaultIdentifierReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *LocalMembership) GetIdentifier(arg1 context.Context, arg2 driver.Identity) (string, error) { + fake.getIdentifierMutex.Lock() + ret, specificReturn := fake.getIdentifierReturnsOnCall[len(fake.getIdentifierArgsForCall)] + fake.getIdentifierArgsForCall = append(fake.getIdentifierArgsForCall, struct { + arg1 context.Context + arg2 driver.Identity + }{arg1, arg2}) + stub := fake.GetIdentifierStub + fakeReturns := fake.getIdentifierReturns + fake.recordInvocation("GetIdentifier", []interface{}{arg1, arg2}) + fake.getIdentifierMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *LocalMembership) GetIdentifierCallCount() int { + fake.getIdentifierMutex.RLock() + defer fake.getIdentifierMutex.RUnlock() + return len(fake.getIdentifierArgsForCall) +} + +func (fake *LocalMembership) GetIdentifierCalls(stub func(context.Context, driver.Identity) (string, error)) { + fake.getIdentifierMutex.Lock() + defer fake.getIdentifierMutex.Unlock() + fake.GetIdentifierStub = stub +} + +func (fake *LocalMembership) GetIdentifierArgsForCall(i int) (context.Context, driver.Identity) { + fake.getIdentifierMutex.RLock() + defer fake.getIdentifierMutex.RUnlock() + argsForCall := fake.getIdentifierArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *LocalMembership) GetIdentifierReturns(result1 string, result2 error) { + fake.getIdentifierMutex.Lock() + defer fake.getIdentifierMutex.Unlock() + fake.GetIdentifierStub = nil + fake.getIdentifierReturns = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *LocalMembership) GetIdentifierReturnsOnCall(i int, result1 string, result2 error) { + fake.getIdentifierMutex.Lock() + defer fake.getIdentifierMutex.Unlock() + fake.GetIdentifierStub = nil + if fake.getIdentifierReturnsOnCall == nil { + fake.getIdentifierReturnsOnCall = make(map[int]struct { + result1 string + result2 error + }) + } + fake.getIdentifierReturnsOnCall[i] = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *LocalMembership) GetIdentityInfo(arg1 context.Context, arg2 string, arg3 []byte) (drivera.IdentityInfo, error) { + var arg3Copy []byte + if arg3 != nil { + arg3Copy = make([]byte, len(arg3)) + copy(arg3Copy, arg3) + } + fake.getIdentityInfoMutex.Lock() + ret, specificReturn := fake.getIdentityInfoReturnsOnCall[len(fake.getIdentityInfoArgsForCall)] + fake.getIdentityInfoArgsForCall = append(fake.getIdentityInfoArgsForCall, struct { + arg1 context.Context + arg2 string + arg3 []byte + }{arg1, arg2, arg3Copy}) + stub := fake.GetIdentityInfoStub + fakeReturns := fake.getIdentityInfoReturns + fake.recordInvocation("GetIdentityInfo", []interface{}{arg1, arg2, arg3Copy}) + fake.getIdentityInfoMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *LocalMembership) GetIdentityInfoCallCount() int { + fake.getIdentityInfoMutex.RLock() + defer fake.getIdentityInfoMutex.RUnlock() + return len(fake.getIdentityInfoArgsForCall) +} + +func (fake *LocalMembership) GetIdentityInfoCalls(stub func(context.Context, string, []byte) (drivera.IdentityInfo, error)) { + fake.getIdentityInfoMutex.Lock() + defer fake.getIdentityInfoMutex.Unlock() + fake.GetIdentityInfoStub = stub +} + +func (fake *LocalMembership) GetIdentityInfoArgsForCall(i int) (context.Context, string, []byte) { + fake.getIdentityInfoMutex.RLock() + defer fake.getIdentityInfoMutex.RUnlock() + argsForCall := fake.getIdentityInfoArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *LocalMembership) GetIdentityInfoReturns(result1 drivera.IdentityInfo, result2 error) { + fake.getIdentityInfoMutex.Lock() + defer fake.getIdentityInfoMutex.Unlock() + fake.GetIdentityInfoStub = nil + fake.getIdentityInfoReturns = struct { + result1 drivera.IdentityInfo + result2 error + }{result1, result2} +} + +func (fake *LocalMembership) GetIdentityInfoReturnsOnCall(i int, result1 drivera.IdentityInfo, result2 error) { + fake.getIdentityInfoMutex.Lock() + defer fake.getIdentityInfoMutex.Unlock() + fake.GetIdentityInfoStub = nil + if fake.getIdentityInfoReturnsOnCall == nil { + fake.getIdentityInfoReturnsOnCall = make(map[int]struct { + result1 drivera.IdentityInfo + result2 error + }) + } + fake.getIdentityInfoReturnsOnCall[i] = struct { + result1 drivera.IdentityInfo + result2 error + }{result1, result2} +} + +func (fake *LocalMembership) IDs() ([]string, error) { + fake.iDsMutex.Lock() + ret, specificReturn := fake.iDsReturnsOnCall[len(fake.iDsArgsForCall)] + fake.iDsArgsForCall = append(fake.iDsArgsForCall, struct { + }{}) + stub := fake.IDsStub + fakeReturns := fake.iDsReturns + fake.recordInvocation("IDs", []interface{}{}) + fake.iDsMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *LocalMembership) IDsCallCount() int { + fake.iDsMutex.RLock() + defer fake.iDsMutex.RUnlock() + return len(fake.iDsArgsForCall) +} + +func (fake *LocalMembership) IDsCalls(stub func() ([]string, error)) { + fake.iDsMutex.Lock() + defer fake.iDsMutex.Unlock() + fake.IDsStub = stub +} + +func (fake *LocalMembership) IDsReturns(result1 []string, result2 error) { + fake.iDsMutex.Lock() + defer fake.iDsMutex.Unlock() + fake.IDsStub = nil + fake.iDsReturns = struct { + result1 []string + result2 error + }{result1, result2} +} + +func (fake *LocalMembership) IDsReturnsOnCall(i int, result1 []string, result2 error) { + fake.iDsMutex.Lock() + defer fake.iDsMutex.Unlock() + fake.IDsStub = nil + if fake.iDsReturnsOnCall == nil { + fake.iDsReturnsOnCall = make(map[int]struct { + result1 []string + result2 error + }) + } + fake.iDsReturnsOnCall[i] = struct { + result1 []string + result2 error + }{result1, result2} +} + +func (fake *LocalMembership) IsMe(arg1 context.Context, arg2 driver.Identity) bool { + fake.isMeMutex.Lock() + ret, specificReturn := fake.isMeReturnsOnCall[len(fake.isMeArgsForCall)] + fake.isMeArgsForCall = append(fake.isMeArgsForCall, struct { + arg1 context.Context + arg2 driver.Identity + }{arg1, arg2}) + stub := fake.IsMeStub + fakeReturns := fake.isMeReturns + fake.recordInvocation("IsMe", []interface{}{arg1, arg2}) + fake.isMeMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *LocalMembership) IsMeCallCount() int { + fake.isMeMutex.RLock() + defer fake.isMeMutex.RUnlock() + return len(fake.isMeArgsForCall) +} + +func (fake *LocalMembership) IsMeCalls(stub func(context.Context, driver.Identity) bool) { + fake.isMeMutex.Lock() + defer fake.isMeMutex.Unlock() + fake.IsMeStub = stub +} + +func (fake *LocalMembership) IsMeArgsForCall(i int) (context.Context, driver.Identity) { + fake.isMeMutex.RLock() + defer fake.isMeMutex.RUnlock() + argsForCall := fake.isMeArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *LocalMembership) IsMeReturns(result1 bool) { + fake.isMeMutex.Lock() + defer fake.isMeMutex.Unlock() + fake.IsMeStub = nil + fake.isMeReturns = struct { + result1 bool + }{result1} +} + +func (fake *LocalMembership) IsMeReturnsOnCall(i int, result1 bool) { + fake.isMeMutex.Lock() + defer fake.isMeMutex.Unlock() + fake.IsMeStub = nil + if fake.isMeReturnsOnCall == nil { + fake.isMeReturnsOnCall = make(map[int]struct { + result1 bool + }) + } + fake.isMeReturnsOnCall[i] = struct { + result1 bool + }{result1} +} + +func (fake *LocalMembership) RegisterIdentity(arg1 context.Context, arg2 driver.IdentityConfiguration) error { + fake.registerIdentityMutex.Lock() + ret, specificReturn := fake.registerIdentityReturnsOnCall[len(fake.registerIdentityArgsForCall)] + fake.registerIdentityArgsForCall = append(fake.registerIdentityArgsForCall, struct { + arg1 context.Context + arg2 driver.IdentityConfiguration + }{arg1, arg2}) + stub := fake.RegisterIdentityStub + fakeReturns := fake.registerIdentityReturns + fake.recordInvocation("RegisterIdentity", []interface{}{arg1, arg2}) + fake.registerIdentityMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *LocalMembership) RegisterIdentityCallCount() int { + fake.registerIdentityMutex.RLock() + defer fake.registerIdentityMutex.RUnlock() + return len(fake.registerIdentityArgsForCall) +} + +func (fake *LocalMembership) RegisterIdentityCalls(stub func(context.Context, driver.IdentityConfiguration) error) { + fake.registerIdentityMutex.Lock() + defer fake.registerIdentityMutex.Unlock() + fake.RegisterIdentityStub = stub +} + +func (fake *LocalMembership) RegisterIdentityArgsForCall(i int) (context.Context, driver.IdentityConfiguration) { + fake.registerIdentityMutex.RLock() + defer fake.registerIdentityMutex.RUnlock() + argsForCall := fake.registerIdentityArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *LocalMembership) RegisterIdentityReturns(result1 error) { + fake.registerIdentityMutex.Lock() + defer fake.registerIdentityMutex.Unlock() + fake.RegisterIdentityStub = nil + fake.registerIdentityReturns = struct { + result1 error + }{result1} +} + +func (fake *LocalMembership) RegisterIdentityReturnsOnCall(i int, result1 error) { + fake.registerIdentityMutex.Lock() + defer fake.registerIdentityMutex.Unlock() + fake.RegisterIdentityStub = nil + if fake.registerIdentityReturnsOnCall == nil { + fake.registerIdentityReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.registerIdentityReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *LocalMembership) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *LocalMembership) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ role.LocalMembership = new(LocalMembership) diff --git a/token/services/identity/role/mock/otv.go b/token/services/identity/role/mock/otv.go new file mode 100644 index 0000000000..e20e9b436c --- /dev/null +++ b/token/services/identity/role/mock/otv.go @@ -0,0 +1,202 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package mock + +import ( + "context" + "sync" + + "github.com/hyperledger-labs/fabric-token-sdk/token/driver" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/role" + "github.com/hyperledger-labs/fabric-token-sdk/token/token" +) + +type OwnerTokenVault struct { + BalanceStub func(context.Context, string, token.Type) (uint64, error) + balanceMutex sync.RWMutex + balanceArgsForCall []struct { + arg1 context.Context + arg2 string + arg3 token.Type + } + balanceReturns struct { + result1 uint64 + result2 error + } + balanceReturnsOnCall map[int]struct { + result1 uint64 + result2 error + } + UnspentTokensIteratorByStub func(context.Context, string, token.Type) (driver.UnspentTokensIterator, error) + unspentTokensIteratorByMutex sync.RWMutex + unspentTokensIteratorByArgsForCall []struct { + arg1 context.Context + arg2 string + arg3 token.Type + } + unspentTokensIteratorByReturns struct { + result1 driver.UnspentTokensIterator + result2 error + } + unspentTokensIteratorByReturnsOnCall map[int]struct { + result1 driver.UnspentTokensIterator + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *OwnerTokenVault) Balance(arg1 context.Context, arg2 string, arg3 token.Type) (uint64, error) { + fake.balanceMutex.Lock() + ret, specificReturn := fake.balanceReturnsOnCall[len(fake.balanceArgsForCall)] + fake.balanceArgsForCall = append(fake.balanceArgsForCall, struct { + arg1 context.Context + arg2 string + arg3 token.Type + }{arg1, arg2, arg3}) + stub := fake.BalanceStub + fakeReturns := fake.balanceReturns + fake.recordInvocation("Balance", []interface{}{arg1, arg2, arg3}) + fake.balanceMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *OwnerTokenVault) BalanceCallCount() int { + fake.balanceMutex.RLock() + defer fake.balanceMutex.RUnlock() + return len(fake.balanceArgsForCall) +} + +func (fake *OwnerTokenVault) BalanceCalls(stub func(context.Context, string, token.Type) (uint64, error)) { + fake.balanceMutex.Lock() + defer fake.balanceMutex.Unlock() + fake.BalanceStub = stub +} + +func (fake *OwnerTokenVault) BalanceArgsForCall(i int) (context.Context, string, token.Type) { + fake.balanceMutex.RLock() + defer fake.balanceMutex.RUnlock() + argsForCall := fake.balanceArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *OwnerTokenVault) BalanceReturns(result1 uint64, result2 error) { + fake.balanceMutex.Lock() + defer fake.balanceMutex.Unlock() + fake.BalanceStub = nil + fake.balanceReturns = struct { + result1 uint64 + result2 error + }{result1, result2} +} + +func (fake *OwnerTokenVault) BalanceReturnsOnCall(i int, result1 uint64, result2 error) { + fake.balanceMutex.Lock() + defer fake.balanceMutex.Unlock() + fake.BalanceStub = nil + if fake.balanceReturnsOnCall == nil { + fake.balanceReturnsOnCall = make(map[int]struct { + result1 uint64 + result2 error + }) + } + fake.balanceReturnsOnCall[i] = struct { + result1 uint64 + result2 error + }{result1, result2} +} + +func (fake *OwnerTokenVault) UnspentTokensIteratorBy(arg1 context.Context, arg2 string, arg3 token.Type) (driver.UnspentTokensIterator, error) { + fake.unspentTokensIteratorByMutex.Lock() + ret, specificReturn := fake.unspentTokensIteratorByReturnsOnCall[len(fake.unspentTokensIteratorByArgsForCall)] + fake.unspentTokensIteratorByArgsForCall = append(fake.unspentTokensIteratorByArgsForCall, struct { + arg1 context.Context + arg2 string + arg3 token.Type + }{arg1, arg2, arg3}) + stub := fake.UnspentTokensIteratorByStub + fakeReturns := fake.unspentTokensIteratorByReturns + fake.recordInvocation("UnspentTokensIteratorBy", []interface{}{arg1, arg2, arg3}) + fake.unspentTokensIteratorByMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *OwnerTokenVault) UnspentTokensIteratorByCallCount() int { + fake.unspentTokensIteratorByMutex.RLock() + defer fake.unspentTokensIteratorByMutex.RUnlock() + return len(fake.unspentTokensIteratorByArgsForCall) +} + +func (fake *OwnerTokenVault) UnspentTokensIteratorByCalls(stub func(context.Context, string, token.Type) (driver.UnspentTokensIterator, error)) { + fake.unspentTokensIteratorByMutex.Lock() + defer fake.unspentTokensIteratorByMutex.Unlock() + fake.UnspentTokensIteratorByStub = stub +} + +func (fake *OwnerTokenVault) UnspentTokensIteratorByArgsForCall(i int) (context.Context, string, token.Type) { + fake.unspentTokensIteratorByMutex.RLock() + defer fake.unspentTokensIteratorByMutex.RUnlock() + argsForCall := fake.unspentTokensIteratorByArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *OwnerTokenVault) UnspentTokensIteratorByReturns(result1 driver.UnspentTokensIterator, result2 error) { + fake.unspentTokensIteratorByMutex.Lock() + defer fake.unspentTokensIteratorByMutex.Unlock() + fake.UnspentTokensIteratorByStub = nil + fake.unspentTokensIteratorByReturns = struct { + result1 driver.UnspentTokensIterator + result2 error + }{result1, result2} +} + +func (fake *OwnerTokenVault) UnspentTokensIteratorByReturnsOnCall(i int, result1 driver.UnspentTokensIterator, result2 error) { + fake.unspentTokensIteratorByMutex.Lock() + defer fake.unspentTokensIteratorByMutex.Unlock() + fake.UnspentTokensIteratorByStub = nil + if fake.unspentTokensIteratorByReturnsOnCall == nil { + fake.unspentTokensIteratorByReturnsOnCall = make(map[int]struct { + result1 driver.UnspentTokensIterator + result2 error + }) + } + fake.unspentTokensIteratorByReturnsOnCall[i] = struct { + result1 driver.UnspentTokensIterator + result2 error + }{result1, result2} +} + +func (fake *OwnerTokenVault) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *OwnerTokenVault) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ role.OwnerTokenVault = new(OwnerTokenVault) diff --git a/token/services/identity/role/mock/registry.go b/token/services/identity/role/mock/registry.go new file mode 100644 index 0000000000..4600f1dd08 --- /dev/null +++ b/token/services/identity/role/mock/registry.go @@ -0,0 +1,590 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package mock + +import ( + "context" + "sync" + + "github.com/hyperledger-labs/fabric-token-sdk/token/driver" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/role" +) + +type Registry struct { + BindIdentityStub func(context.Context, driver.Identity, string, string, any) error + bindIdentityMutex sync.RWMutex + bindIdentityArgsForCall []struct { + arg1 context.Context + arg2 driver.Identity + arg3 string + arg4 string + arg5 any + } + bindIdentityReturns struct { + result1 error + } + bindIdentityReturnsOnCall map[int]struct { + result1 error + } + ContainsIdentityStub func(context.Context, driver.Identity, string) bool + containsIdentityMutex sync.RWMutex + containsIdentityArgsForCall []struct { + arg1 context.Context + arg2 driver.Identity + arg3 string + } + containsIdentityReturns struct { + result1 bool + } + containsIdentityReturnsOnCall map[int]struct { + result1 bool + } + GetIdentityMetadataStub func(context.Context, driver.Identity, string, any) error + getIdentityMetadataMutex sync.RWMutex + getIdentityMetadataArgsForCall []struct { + arg1 context.Context + arg2 driver.Identity + arg3 string + arg4 any + } + getIdentityMetadataReturns struct { + result1 error + } + getIdentityMetadataReturnsOnCall map[int]struct { + result1 error + } + LookupStub func(context.Context, driver.WalletLookupID) (driver.Wallet, identity.Info, string, error) + lookupMutex sync.RWMutex + lookupArgsForCall []struct { + arg1 context.Context + arg2 driver.WalletLookupID + } + lookupReturns struct { + result1 driver.Wallet + result2 identity.Info + result3 string + result4 error + } + lookupReturnsOnCall map[int]struct { + result1 driver.Wallet + result2 identity.Info + result3 string + result4 error + } + RegisterIdentityStub func(context.Context, driver.IdentityConfiguration) error + registerIdentityMutex sync.RWMutex + registerIdentityArgsForCall []struct { + arg1 context.Context + arg2 driver.IdentityConfiguration + } + registerIdentityReturns struct { + result1 error + } + registerIdentityReturnsOnCall map[int]struct { + result1 error + } + RegisterWalletStub func(context.Context, string, driver.Wallet) error + registerWalletMutex sync.RWMutex + registerWalletArgsForCall []struct { + arg1 context.Context + arg2 string + arg3 driver.Wallet + } + registerWalletReturns struct { + result1 error + } + registerWalletReturnsOnCall map[int]struct { + result1 error + } + WalletIDsStub func(context.Context) ([]string, error) + walletIDsMutex sync.RWMutex + walletIDsArgsForCall []struct { + arg1 context.Context + } + walletIDsReturns struct { + result1 []string + result2 error + } + walletIDsReturnsOnCall map[int]struct { + result1 []string + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *Registry) BindIdentity(arg1 context.Context, arg2 driver.Identity, arg3 string, arg4 string, arg5 any) error { + fake.bindIdentityMutex.Lock() + ret, specificReturn := fake.bindIdentityReturnsOnCall[len(fake.bindIdentityArgsForCall)] + fake.bindIdentityArgsForCall = append(fake.bindIdentityArgsForCall, struct { + arg1 context.Context + arg2 driver.Identity + arg3 string + arg4 string + arg5 any + }{arg1, arg2, arg3, arg4, arg5}) + stub := fake.BindIdentityStub + fakeReturns := fake.bindIdentityReturns + fake.recordInvocation("BindIdentity", []interface{}{arg1, arg2, arg3, arg4, arg5}) + fake.bindIdentityMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *Registry) BindIdentityCallCount() int { + fake.bindIdentityMutex.RLock() + defer fake.bindIdentityMutex.RUnlock() + return len(fake.bindIdentityArgsForCall) +} + +func (fake *Registry) BindIdentityCalls(stub func(context.Context, driver.Identity, string, string, any) error) { + fake.bindIdentityMutex.Lock() + defer fake.bindIdentityMutex.Unlock() + fake.BindIdentityStub = stub +} + +func (fake *Registry) BindIdentityArgsForCall(i int) (context.Context, driver.Identity, string, string, any) { + fake.bindIdentityMutex.RLock() + defer fake.bindIdentityMutex.RUnlock() + argsForCall := fake.bindIdentityArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5 +} + +func (fake *Registry) BindIdentityReturns(result1 error) { + fake.bindIdentityMutex.Lock() + defer fake.bindIdentityMutex.Unlock() + fake.BindIdentityStub = nil + fake.bindIdentityReturns = struct { + result1 error + }{result1} +} + +func (fake *Registry) BindIdentityReturnsOnCall(i int, result1 error) { + fake.bindIdentityMutex.Lock() + defer fake.bindIdentityMutex.Unlock() + fake.BindIdentityStub = nil + if fake.bindIdentityReturnsOnCall == nil { + fake.bindIdentityReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.bindIdentityReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *Registry) ContainsIdentity(arg1 context.Context, arg2 driver.Identity, arg3 string) bool { + fake.containsIdentityMutex.Lock() + ret, specificReturn := fake.containsIdentityReturnsOnCall[len(fake.containsIdentityArgsForCall)] + fake.containsIdentityArgsForCall = append(fake.containsIdentityArgsForCall, struct { + arg1 context.Context + arg2 driver.Identity + arg3 string + }{arg1, arg2, arg3}) + stub := fake.ContainsIdentityStub + fakeReturns := fake.containsIdentityReturns + fake.recordInvocation("ContainsIdentity", []interface{}{arg1, arg2, arg3}) + fake.containsIdentityMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *Registry) ContainsIdentityCallCount() int { + fake.containsIdentityMutex.RLock() + defer fake.containsIdentityMutex.RUnlock() + return len(fake.containsIdentityArgsForCall) +} + +func (fake *Registry) ContainsIdentityCalls(stub func(context.Context, driver.Identity, string) bool) { + fake.containsIdentityMutex.Lock() + defer fake.containsIdentityMutex.Unlock() + fake.ContainsIdentityStub = stub +} + +func (fake *Registry) ContainsIdentityArgsForCall(i int) (context.Context, driver.Identity, string) { + fake.containsIdentityMutex.RLock() + defer fake.containsIdentityMutex.RUnlock() + argsForCall := fake.containsIdentityArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *Registry) ContainsIdentityReturns(result1 bool) { + fake.containsIdentityMutex.Lock() + defer fake.containsIdentityMutex.Unlock() + fake.ContainsIdentityStub = nil + fake.containsIdentityReturns = struct { + result1 bool + }{result1} +} + +func (fake *Registry) ContainsIdentityReturnsOnCall(i int, result1 bool) { + fake.containsIdentityMutex.Lock() + defer fake.containsIdentityMutex.Unlock() + fake.ContainsIdentityStub = nil + if fake.containsIdentityReturnsOnCall == nil { + fake.containsIdentityReturnsOnCall = make(map[int]struct { + result1 bool + }) + } + fake.containsIdentityReturnsOnCall[i] = struct { + result1 bool + }{result1} +} + +func (fake *Registry) GetIdentityMetadata(arg1 context.Context, arg2 driver.Identity, arg3 string, arg4 any) error { + fake.getIdentityMetadataMutex.Lock() + ret, specificReturn := fake.getIdentityMetadataReturnsOnCall[len(fake.getIdentityMetadataArgsForCall)] + fake.getIdentityMetadataArgsForCall = append(fake.getIdentityMetadataArgsForCall, struct { + arg1 context.Context + arg2 driver.Identity + arg3 string + arg4 any + }{arg1, arg2, arg3, arg4}) + stub := fake.GetIdentityMetadataStub + fakeReturns := fake.getIdentityMetadataReturns + fake.recordInvocation("GetIdentityMetadata", []interface{}{arg1, arg2, arg3, arg4}) + fake.getIdentityMetadataMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3, arg4) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *Registry) GetIdentityMetadataCallCount() int { + fake.getIdentityMetadataMutex.RLock() + defer fake.getIdentityMetadataMutex.RUnlock() + return len(fake.getIdentityMetadataArgsForCall) +} + +func (fake *Registry) GetIdentityMetadataCalls(stub func(context.Context, driver.Identity, string, any) error) { + fake.getIdentityMetadataMutex.Lock() + defer fake.getIdentityMetadataMutex.Unlock() + fake.GetIdentityMetadataStub = stub +} + +func (fake *Registry) GetIdentityMetadataArgsForCall(i int) (context.Context, driver.Identity, string, any) { + fake.getIdentityMetadataMutex.RLock() + defer fake.getIdentityMetadataMutex.RUnlock() + argsForCall := fake.getIdentityMetadataArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 +} + +func (fake *Registry) GetIdentityMetadataReturns(result1 error) { + fake.getIdentityMetadataMutex.Lock() + defer fake.getIdentityMetadataMutex.Unlock() + fake.GetIdentityMetadataStub = nil + fake.getIdentityMetadataReturns = struct { + result1 error + }{result1} +} + +func (fake *Registry) GetIdentityMetadataReturnsOnCall(i int, result1 error) { + fake.getIdentityMetadataMutex.Lock() + defer fake.getIdentityMetadataMutex.Unlock() + fake.GetIdentityMetadataStub = nil + if fake.getIdentityMetadataReturnsOnCall == nil { + fake.getIdentityMetadataReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.getIdentityMetadataReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *Registry) Lookup(arg1 context.Context, arg2 driver.WalletLookupID) (driver.Wallet, identity.Info, string, error) { + fake.lookupMutex.Lock() + ret, specificReturn := fake.lookupReturnsOnCall[len(fake.lookupArgsForCall)] + fake.lookupArgsForCall = append(fake.lookupArgsForCall, struct { + arg1 context.Context + arg2 driver.WalletLookupID + }{arg1, arg2}) + stub := fake.LookupStub + fakeReturns := fake.lookupReturns + fake.recordInvocation("Lookup", []interface{}{arg1, arg2}) + fake.lookupMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2, ret.result3, ret.result4 + } + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3, fakeReturns.result4 +} + +func (fake *Registry) LookupCallCount() int { + fake.lookupMutex.RLock() + defer fake.lookupMutex.RUnlock() + return len(fake.lookupArgsForCall) +} + +func (fake *Registry) LookupCalls(stub func(context.Context, driver.WalletLookupID) (driver.Wallet, identity.Info, string, error)) { + fake.lookupMutex.Lock() + defer fake.lookupMutex.Unlock() + fake.LookupStub = stub +} + +func (fake *Registry) LookupArgsForCall(i int) (context.Context, driver.WalletLookupID) { + fake.lookupMutex.RLock() + defer fake.lookupMutex.RUnlock() + argsForCall := fake.lookupArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *Registry) LookupReturns(result1 driver.Wallet, result2 identity.Info, result3 string, result4 error) { + fake.lookupMutex.Lock() + defer fake.lookupMutex.Unlock() + fake.LookupStub = nil + fake.lookupReturns = struct { + result1 driver.Wallet + result2 identity.Info + result3 string + result4 error + }{result1, result2, result3, result4} +} + +func (fake *Registry) LookupReturnsOnCall(i int, result1 driver.Wallet, result2 identity.Info, result3 string, result4 error) { + fake.lookupMutex.Lock() + defer fake.lookupMutex.Unlock() + fake.LookupStub = nil + if fake.lookupReturnsOnCall == nil { + fake.lookupReturnsOnCall = make(map[int]struct { + result1 driver.Wallet + result2 identity.Info + result3 string + result4 error + }) + } + fake.lookupReturnsOnCall[i] = struct { + result1 driver.Wallet + result2 identity.Info + result3 string + result4 error + }{result1, result2, result3, result4} +} + +func (fake *Registry) RegisterIdentity(arg1 context.Context, arg2 driver.IdentityConfiguration) error { + fake.registerIdentityMutex.Lock() + ret, specificReturn := fake.registerIdentityReturnsOnCall[len(fake.registerIdentityArgsForCall)] + fake.registerIdentityArgsForCall = append(fake.registerIdentityArgsForCall, struct { + arg1 context.Context + arg2 driver.IdentityConfiguration + }{arg1, arg2}) + stub := fake.RegisterIdentityStub + fakeReturns := fake.registerIdentityReturns + fake.recordInvocation("RegisterIdentity", []interface{}{arg1, arg2}) + fake.registerIdentityMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *Registry) RegisterIdentityCallCount() int { + fake.registerIdentityMutex.RLock() + defer fake.registerIdentityMutex.RUnlock() + return len(fake.registerIdentityArgsForCall) +} + +func (fake *Registry) RegisterIdentityCalls(stub func(context.Context, driver.IdentityConfiguration) error) { + fake.registerIdentityMutex.Lock() + defer fake.registerIdentityMutex.Unlock() + fake.RegisterIdentityStub = stub +} + +func (fake *Registry) RegisterIdentityArgsForCall(i int) (context.Context, driver.IdentityConfiguration) { + fake.registerIdentityMutex.RLock() + defer fake.registerIdentityMutex.RUnlock() + argsForCall := fake.registerIdentityArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *Registry) RegisterIdentityReturns(result1 error) { + fake.registerIdentityMutex.Lock() + defer fake.registerIdentityMutex.Unlock() + fake.RegisterIdentityStub = nil + fake.registerIdentityReturns = struct { + result1 error + }{result1} +} + +func (fake *Registry) RegisterIdentityReturnsOnCall(i int, result1 error) { + fake.registerIdentityMutex.Lock() + defer fake.registerIdentityMutex.Unlock() + fake.RegisterIdentityStub = nil + if fake.registerIdentityReturnsOnCall == nil { + fake.registerIdentityReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.registerIdentityReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *Registry) RegisterWallet(arg1 context.Context, arg2 string, arg3 driver.Wallet) error { + fake.registerWalletMutex.Lock() + ret, specificReturn := fake.registerWalletReturnsOnCall[len(fake.registerWalletArgsForCall)] + fake.registerWalletArgsForCall = append(fake.registerWalletArgsForCall, struct { + arg1 context.Context + arg2 string + arg3 driver.Wallet + }{arg1, arg2, arg3}) + stub := fake.RegisterWalletStub + fakeReturns := fake.registerWalletReturns + fake.recordInvocation("RegisterWallet", []interface{}{arg1, arg2, arg3}) + fake.registerWalletMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *Registry) RegisterWalletCallCount() int { + fake.registerWalletMutex.RLock() + defer fake.registerWalletMutex.RUnlock() + return len(fake.registerWalletArgsForCall) +} + +func (fake *Registry) RegisterWalletCalls(stub func(context.Context, string, driver.Wallet) error) { + fake.registerWalletMutex.Lock() + defer fake.registerWalletMutex.Unlock() + fake.RegisterWalletStub = stub +} + +func (fake *Registry) RegisterWalletArgsForCall(i int) (context.Context, string, driver.Wallet) { + fake.registerWalletMutex.RLock() + defer fake.registerWalletMutex.RUnlock() + argsForCall := fake.registerWalletArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *Registry) RegisterWalletReturns(result1 error) { + fake.registerWalletMutex.Lock() + defer fake.registerWalletMutex.Unlock() + fake.RegisterWalletStub = nil + fake.registerWalletReturns = struct { + result1 error + }{result1} +} + +func (fake *Registry) RegisterWalletReturnsOnCall(i int, result1 error) { + fake.registerWalletMutex.Lock() + defer fake.registerWalletMutex.Unlock() + fake.RegisterWalletStub = nil + if fake.registerWalletReturnsOnCall == nil { + fake.registerWalletReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.registerWalletReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *Registry) WalletIDs(arg1 context.Context) ([]string, error) { + fake.walletIDsMutex.Lock() + ret, specificReturn := fake.walletIDsReturnsOnCall[len(fake.walletIDsArgsForCall)] + fake.walletIDsArgsForCall = append(fake.walletIDsArgsForCall, struct { + arg1 context.Context + }{arg1}) + stub := fake.WalletIDsStub + fakeReturns := fake.walletIDsReturns + fake.recordInvocation("WalletIDs", []interface{}{arg1}) + fake.walletIDsMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *Registry) WalletIDsCallCount() int { + fake.walletIDsMutex.RLock() + defer fake.walletIDsMutex.RUnlock() + return len(fake.walletIDsArgsForCall) +} + +func (fake *Registry) WalletIDsCalls(stub func(context.Context) ([]string, error)) { + fake.walletIDsMutex.Lock() + defer fake.walletIDsMutex.Unlock() + fake.WalletIDsStub = stub +} + +func (fake *Registry) WalletIDsArgsForCall(i int) context.Context { + fake.walletIDsMutex.RLock() + defer fake.walletIDsMutex.RUnlock() + argsForCall := fake.walletIDsArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *Registry) WalletIDsReturns(result1 []string, result2 error) { + fake.walletIDsMutex.Lock() + defer fake.walletIDsMutex.Unlock() + fake.WalletIDsStub = nil + fake.walletIDsReturns = struct { + result1 []string + result2 error + }{result1, result2} +} + +func (fake *Registry) WalletIDsReturnsOnCall(i int, result1 []string, result2 error) { + fake.walletIDsMutex.Lock() + defer fake.walletIDsMutex.Unlock() + fake.WalletIDsStub = nil + if fake.walletIDsReturnsOnCall == nil { + fake.walletIDsReturnsOnCall = make(map[int]struct { + result1 []string + result2 error + }) + } + fake.walletIDsReturnsOnCall[i] = struct { + result1 []string + result2 error + }{result1, result2} +} + +func (fake *Registry) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *Registry) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ role.Registry = new(Registry) diff --git a/token/services/identity/role/mock/signer.go b/token/services/identity/role/mock/signer.go new file mode 100644 index 0000000000..14fc7f7a8d --- /dev/null +++ b/token/services/identity/role/mock/signer.go @@ -0,0 +1,119 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package mock + +import ( + "sync" + + "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/role" +) + +type Signer struct { + SignStub func([]byte) ([]byte, error) + signMutex sync.RWMutex + signArgsForCall []struct { + arg1 []byte + } + signReturns struct { + result1 []byte + result2 error + } + signReturnsOnCall map[int]struct { + result1 []byte + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *Signer) Sign(arg1 []byte) ([]byte, error) { + var arg1Copy []byte + if arg1 != nil { + arg1Copy = make([]byte, len(arg1)) + copy(arg1Copy, arg1) + } + fake.signMutex.Lock() + ret, specificReturn := fake.signReturnsOnCall[len(fake.signArgsForCall)] + fake.signArgsForCall = append(fake.signArgsForCall, struct { + arg1 []byte + }{arg1Copy}) + stub := fake.SignStub + fakeReturns := fake.signReturns + fake.recordInvocation("Sign", []interface{}{arg1Copy}) + fake.signMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *Signer) SignCallCount() int { + fake.signMutex.RLock() + defer fake.signMutex.RUnlock() + return len(fake.signArgsForCall) +} + +func (fake *Signer) SignCalls(stub func([]byte) ([]byte, error)) { + fake.signMutex.Lock() + defer fake.signMutex.Unlock() + fake.SignStub = stub +} + +func (fake *Signer) SignArgsForCall(i int) []byte { + fake.signMutex.RLock() + defer fake.signMutex.RUnlock() + argsForCall := fake.signArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *Signer) SignReturns(result1 []byte, result2 error) { + fake.signMutex.Lock() + defer fake.signMutex.Unlock() + fake.SignStub = nil + fake.signReturns = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *Signer) SignReturnsOnCall(i int, result1 []byte, result2 error) { + fake.signMutex.Lock() + defer fake.signMutex.Unlock() + fake.SignStub = nil + if fake.signReturnsOnCall == nil { + fake.signReturnsOnCall = make(map[int]struct { + result1 []byte + result2 error + }) + } + fake.signReturnsOnCall[i] = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *Signer) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *Signer) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ role.Signer = new(Signer) diff --git a/token/services/identity/role/mock/tv.go b/token/services/identity/role/mock/tv.go new file mode 100644 index 0000000000..71272c81fb --- /dev/null +++ b/token/services/identity/role/mock/tv.go @@ -0,0 +1,279 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package mock + +import ( + "context" + "sync" + + "github.com/hyperledger-labs/fabric-token-sdk/token/driver" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/role" + "github.com/hyperledger-labs/fabric-token-sdk/token/token" +) + +type TokenVault struct { + BalanceStub func(context.Context, string, token.Type) (uint64, error) + balanceMutex sync.RWMutex + balanceArgsForCall []struct { + arg1 context.Context + arg2 string + arg3 token.Type + } + balanceReturns struct { + result1 uint64 + result2 error + } + balanceReturnsOnCall map[int]struct { + result1 uint64 + result2 error + } + ListHistoryIssuedTokensStub func(context.Context) (*token.IssuedTokens, error) + listHistoryIssuedTokensMutex sync.RWMutex + listHistoryIssuedTokensArgsForCall []struct { + arg1 context.Context + } + listHistoryIssuedTokensReturns struct { + result1 *token.IssuedTokens + result2 error + } + listHistoryIssuedTokensReturnsOnCall map[int]struct { + result1 *token.IssuedTokens + result2 error + } + UnspentTokensIteratorByStub func(context.Context, string, token.Type) (driver.UnspentTokensIterator, error) + unspentTokensIteratorByMutex sync.RWMutex + unspentTokensIteratorByArgsForCall []struct { + arg1 context.Context + arg2 string + arg3 token.Type + } + unspentTokensIteratorByReturns struct { + result1 driver.UnspentTokensIterator + result2 error + } + unspentTokensIteratorByReturnsOnCall map[int]struct { + result1 driver.UnspentTokensIterator + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *TokenVault) Balance(arg1 context.Context, arg2 string, arg3 token.Type) (uint64, error) { + fake.balanceMutex.Lock() + ret, specificReturn := fake.balanceReturnsOnCall[len(fake.balanceArgsForCall)] + fake.balanceArgsForCall = append(fake.balanceArgsForCall, struct { + arg1 context.Context + arg2 string + arg3 token.Type + }{arg1, arg2, arg3}) + stub := fake.BalanceStub + fakeReturns := fake.balanceReturns + fake.recordInvocation("Balance", []interface{}{arg1, arg2, arg3}) + fake.balanceMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *TokenVault) BalanceCallCount() int { + fake.balanceMutex.RLock() + defer fake.balanceMutex.RUnlock() + return len(fake.balanceArgsForCall) +} + +func (fake *TokenVault) BalanceCalls(stub func(context.Context, string, token.Type) (uint64, error)) { + fake.balanceMutex.Lock() + defer fake.balanceMutex.Unlock() + fake.BalanceStub = stub +} + +func (fake *TokenVault) BalanceArgsForCall(i int) (context.Context, string, token.Type) { + fake.balanceMutex.RLock() + defer fake.balanceMutex.RUnlock() + argsForCall := fake.balanceArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *TokenVault) BalanceReturns(result1 uint64, result2 error) { + fake.balanceMutex.Lock() + defer fake.balanceMutex.Unlock() + fake.BalanceStub = nil + fake.balanceReturns = struct { + result1 uint64 + result2 error + }{result1, result2} +} + +func (fake *TokenVault) BalanceReturnsOnCall(i int, result1 uint64, result2 error) { + fake.balanceMutex.Lock() + defer fake.balanceMutex.Unlock() + fake.BalanceStub = nil + if fake.balanceReturnsOnCall == nil { + fake.balanceReturnsOnCall = make(map[int]struct { + result1 uint64 + result2 error + }) + } + fake.balanceReturnsOnCall[i] = struct { + result1 uint64 + result2 error + }{result1, result2} +} + +func (fake *TokenVault) ListHistoryIssuedTokens(arg1 context.Context) (*token.IssuedTokens, error) { + fake.listHistoryIssuedTokensMutex.Lock() + ret, specificReturn := fake.listHistoryIssuedTokensReturnsOnCall[len(fake.listHistoryIssuedTokensArgsForCall)] + fake.listHistoryIssuedTokensArgsForCall = append(fake.listHistoryIssuedTokensArgsForCall, struct { + arg1 context.Context + }{arg1}) + stub := fake.ListHistoryIssuedTokensStub + fakeReturns := fake.listHistoryIssuedTokensReturns + fake.recordInvocation("ListHistoryIssuedTokens", []interface{}{arg1}) + fake.listHistoryIssuedTokensMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *TokenVault) ListHistoryIssuedTokensCallCount() int { + fake.listHistoryIssuedTokensMutex.RLock() + defer fake.listHistoryIssuedTokensMutex.RUnlock() + return len(fake.listHistoryIssuedTokensArgsForCall) +} + +func (fake *TokenVault) ListHistoryIssuedTokensCalls(stub func(context.Context) (*token.IssuedTokens, error)) { + fake.listHistoryIssuedTokensMutex.Lock() + defer fake.listHistoryIssuedTokensMutex.Unlock() + fake.ListHistoryIssuedTokensStub = stub +} + +func (fake *TokenVault) ListHistoryIssuedTokensArgsForCall(i int) context.Context { + fake.listHistoryIssuedTokensMutex.RLock() + defer fake.listHistoryIssuedTokensMutex.RUnlock() + argsForCall := fake.listHistoryIssuedTokensArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *TokenVault) ListHistoryIssuedTokensReturns(result1 *token.IssuedTokens, result2 error) { + fake.listHistoryIssuedTokensMutex.Lock() + defer fake.listHistoryIssuedTokensMutex.Unlock() + fake.ListHistoryIssuedTokensStub = nil + fake.listHistoryIssuedTokensReturns = struct { + result1 *token.IssuedTokens + result2 error + }{result1, result2} +} + +func (fake *TokenVault) ListHistoryIssuedTokensReturnsOnCall(i int, result1 *token.IssuedTokens, result2 error) { + fake.listHistoryIssuedTokensMutex.Lock() + defer fake.listHistoryIssuedTokensMutex.Unlock() + fake.ListHistoryIssuedTokensStub = nil + if fake.listHistoryIssuedTokensReturnsOnCall == nil { + fake.listHistoryIssuedTokensReturnsOnCall = make(map[int]struct { + result1 *token.IssuedTokens + result2 error + }) + } + fake.listHistoryIssuedTokensReturnsOnCall[i] = struct { + result1 *token.IssuedTokens + result2 error + }{result1, result2} +} + +func (fake *TokenVault) UnspentTokensIteratorBy(arg1 context.Context, arg2 string, arg3 token.Type) (driver.UnspentTokensIterator, error) { + fake.unspentTokensIteratorByMutex.Lock() + ret, specificReturn := fake.unspentTokensIteratorByReturnsOnCall[len(fake.unspentTokensIteratorByArgsForCall)] + fake.unspentTokensIteratorByArgsForCall = append(fake.unspentTokensIteratorByArgsForCall, struct { + arg1 context.Context + arg2 string + arg3 token.Type + }{arg1, arg2, arg3}) + stub := fake.UnspentTokensIteratorByStub + fakeReturns := fake.unspentTokensIteratorByReturns + fake.recordInvocation("UnspentTokensIteratorBy", []interface{}{arg1, arg2, arg3}) + fake.unspentTokensIteratorByMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *TokenVault) UnspentTokensIteratorByCallCount() int { + fake.unspentTokensIteratorByMutex.RLock() + defer fake.unspentTokensIteratorByMutex.RUnlock() + return len(fake.unspentTokensIteratorByArgsForCall) +} + +func (fake *TokenVault) UnspentTokensIteratorByCalls(stub func(context.Context, string, token.Type) (driver.UnspentTokensIterator, error)) { + fake.unspentTokensIteratorByMutex.Lock() + defer fake.unspentTokensIteratorByMutex.Unlock() + fake.UnspentTokensIteratorByStub = stub +} + +func (fake *TokenVault) UnspentTokensIteratorByArgsForCall(i int) (context.Context, string, token.Type) { + fake.unspentTokensIteratorByMutex.RLock() + defer fake.unspentTokensIteratorByMutex.RUnlock() + argsForCall := fake.unspentTokensIteratorByArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *TokenVault) UnspentTokensIteratorByReturns(result1 driver.UnspentTokensIterator, result2 error) { + fake.unspentTokensIteratorByMutex.Lock() + defer fake.unspentTokensIteratorByMutex.Unlock() + fake.UnspentTokensIteratorByStub = nil + fake.unspentTokensIteratorByReturns = struct { + result1 driver.UnspentTokensIterator + result2 error + }{result1, result2} +} + +func (fake *TokenVault) UnspentTokensIteratorByReturnsOnCall(i int, result1 driver.UnspentTokensIterator, result2 error) { + fake.unspentTokensIteratorByMutex.Lock() + defer fake.unspentTokensIteratorByMutex.Unlock() + fake.UnspentTokensIteratorByStub = nil + if fake.unspentTokensIteratorByReturnsOnCall == nil { + fake.unspentTokensIteratorByReturnsOnCall = make(map[int]struct { + result1 driver.UnspentTokensIterator + result2 error + }) + } + fake.unspentTokensIteratorByReturnsOnCall[i] = struct { + result1 driver.UnspentTokensIterator + result2 error + }{result1, result2} +} + +func (fake *TokenVault) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *TokenVault) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ role.TokenVault = new(TokenVault) diff --git a/token/services/identity/role/mock/uti.go b/token/services/identity/role/mock/uti.go new file mode 100644 index 0000000000..299cca1f6c --- /dev/null +++ b/token/services/identity/role/mock/uti.go @@ -0,0 +1,134 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package mock + +import ( + "sync" + + "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/role" + "github.com/hyperledger-labs/fabric-token-sdk/token/token" +) + +type UnspentTokensIterator struct { + CloseStub func() + closeMutex sync.RWMutex + closeArgsForCall []struct { + } + NextStub func() (*token.UnspentToken, error) + nextMutex sync.RWMutex + nextArgsForCall []struct { + } + nextReturns struct { + result1 *token.UnspentToken + result2 error + } + nextReturnsOnCall map[int]struct { + result1 *token.UnspentToken + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *UnspentTokensIterator) Close() { + fake.closeMutex.Lock() + fake.closeArgsForCall = append(fake.closeArgsForCall, struct { + }{}) + stub := fake.CloseStub + fake.recordInvocation("Close", []interface{}{}) + fake.closeMutex.Unlock() + if stub != nil { + fake.CloseStub() + } +} + +func (fake *UnspentTokensIterator) CloseCallCount() int { + fake.closeMutex.RLock() + defer fake.closeMutex.RUnlock() + return len(fake.closeArgsForCall) +} + +func (fake *UnspentTokensIterator) CloseCalls(stub func()) { + fake.closeMutex.Lock() + defer fake.closeMutex.Unlock() + fake.CloseStub = stub +} + +func (fake *UnspentTokensIterator) Next() (*token.UnspentToken, error) { + fake.nextMutex.Lock() + ret, specificReturn := fake.nextReturnsOnCall[len(fake.nextArgsForCall)] + fake.nextArgsForCall = append(fake.nextArgsForCall, struct { + }{}) + stub := fake.NextStub + fakeReturns := fake.nextReturns + fake.recordInvocation("Next", []interface{}{}) + fake.nextMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *UnspentTokensIterator) NextCallCount() int { + fake.nextMutex.RLock() + defer fake.nextMutex.RUnlock() + return len(fake.nextArgsForCall) +} + +func (fake *UnspentTokensIterator) NextCalls(stub func() (*token.UnspentToken, error)) { + fake.nextMutex.Lock() + defer fake.nextMutex.Unlock() + fake.NextStub = stub +} + +func (fake *UnspentTokensIterator) NextReturns(result1 *token.UnspentToken, result2 error) { + fake.nextMutex.Lock() + defer fake.nextMutex.Unlock() + fake.NextStub = nil + fake.nextReturns = struct { + result1 *token.UnspentToken + result2 error + }{result1, result2} +} + +func (fake *UnspentTokensIterator) NextReturnsOnCall(i int, result1 *token.UnspentToken, result2 error) { + fake.nextMutex.Lock() + defer fake.nextMutex.Unlock() + fake.NextStub = nil + if fake.nextReturnsOnCall == nil { + fake.nextReturnsOnCall = make(map[int]struct { + result1 *token.UnspentToken + result2 error + }) + } + fake.nextReturnsOnCall[i] = struct { + result1 *token.UnspentToken + result2 error + }{result1, result2} +} + +func (fake *UnspentTokensIterator) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *UnspentTokensIterator) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ role.UnspentTokensIterator = new(UnspentTokensIterator) diff --git a/token/services/identity/role/mock/wc.go b/token/services/identity/role/mock/wc.go new file mode 100644 index 0000000000..dc573063bf --- /dev/null +++ b/token/services/identity/role/mock/wc.go @@ -0,0 +1,109 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package mock + +import ( + "sync" + + "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/role" +) + +type WalletsConfiguration struct { + CacheSizeForOwnerIDStub func(string) int + cacheSizeForOwnerIDMutex sync.RWMutex + cacheSizeForOwnerIDArgsForCall []struct { + arg1 string + } + cacheSizeForOwnerIDReturns struct { + result1 int + } + cacheSizeForOwnerIDReturnsOnCall map[int]struct { + result1 int + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *WalletsConfiguration) CacheSizeForOwnerID(arg1 string) int { + fake.cacheSizeForOwnerIDMutex.Lock() + ret, specificReturn := fake.cacheSizeForOwnerIDReturnsOnCall[len(fake.cacheSizeForOwnerIDArgsForCall)] + fake.cacheSizeForOwnerIDArgsForCall = append(fake.cacheSizeForOwnerIDArgsForCall, struct { + arg1 string + }{arg1}) + stub := fake.CacheSizeForOwnerIDStub + fakeReturns := fake.cacheSizeForOwnerIDReturns + fake.recordInvocation("CacheSizeForOwnerID", []interface{}{arg1}) + fake.cacheSizeForOwnerIDMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *WalletsConfiguration) CacheSizeForOwnerIDCallCount() int { + fake.cacheSizeForOwnerIDMutex.RLock() + defer fake.cacheSizeForOwnerIDMutex.RUnlock() + return len(fake.cacheSizeForOwnerIDArgsForCall) +} + +func (fake *WalletsConfiguration) CacheSizeForOwnerIDCalls(stub func(string) int) { + fake.cacheSizeForOwnerIDMutex.Lock() + defer fake.cacheSizeForOwnerIDMutex.Unlock() + fake.CacheSizeForOwnerIDStub = stub +} + +func (fake *WalletsConfiguration) CacheSizeForOwnerIDArgsForCall(i int) string { + fake.cacheSizeForOwnerIDMutex.RLock() + defer fake.cacheSizeForOwnerIDMutex.RUnlock() + argsForCall := fake.cacheSizeForOwnerIDArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *WalletsConfiguration) CacheSizeForOwnerIDReturns(result1 int) { + fake.cacheSizeForOwnerIDMutex.Lock() + defer fake.cacheSizeForOwnerIDMutex.Unlock() + fake.CacheSizeForOwnerIDStub = nil + fake.cacheSizeForOwnerIDReturns = struct { + result1 int + }{result1} +} + +func (fake *WalletsConfiguration) CacheSizeForOwnerIDReturnsOnCall(i int, result1 int) { + fake.cacheSizeForOwnerIDMutex.Lock() + defer fake.cacheSizeForOwnerIDMutex.Unlock() + fake.CacheSizeForOwnerIDStub = nil + if fake.cacheSizeForOwnerIDReturnsOnCall == nil { + fake.cacheSizeForOwnerIDReturnsOnCall = make(map[int]struct { + result1 int + }) + } + fake.cacheSizeForOwnerIDReturnsOnCall[i] = struct { + result1 int + }{result1} +} + +func (fake *WalletsConfiguration) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *WalletsConfiguration) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ role.WalletsConfiguration = new(WalletsConfiguration) diff --git a/token/services/identity/role/mock/wf.go b/token/services/identity/role/mock/wf.go new file mode 100644 index 0000000000..97a6a9a4e9 --- /dev/null +++ b/token/services/identity/role/mock/wf.go @@ -0,0 +1,125 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package mock + +import ( + "context" + "sync" + + "github.com/hyperledger-labs/fabric-token-sdk/token/driver" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/role" +) + +type WalletFactory struct { + NewWalletStub func(context.Context, string, identity.RoleType, role.Registry, identity.Info) (driver.Wallet, error) + newWalletMutex sync.RWMutex + newWalletArgsForCall []struct { + arg1 context.Context + arg2 string + arg3 identity.RoleType + arg4 role.Registry + arg5 identity.Info + } + newWalletReturns struct { + result1 driver.Wallet + result2 error + } + newWalletReturnsOnCall map[int]struct { + result1 driver.Wallet + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *WalletFactory) NewWallet(arg1 context.Context, arg2 string, arg3 identity.RoleType, arg4 role.Registry, arg5 identity.Info) (driver.Wallet, error) { + fake.newWalletMutex.Lock() + ret, specificReturn := fake.newWalletReturnsOnCall[len(fake.newWalletArgsForCall)] + fake.newWalletArgsForCall = append(fake.newWalletArgsForCall, struct { + arg1 context.Context + arg2 string + arg3 identity.RoleType + arg4 role.Registry + arg5 identity.Info + }{arg1, arg2, arg3, arg4, arg5}) + stub := fake.NewWalletStub + fakeReturns := fake.newWalletReturns + fake.recordInvocation("NewWallet", []interface{}{arg1, arg2, arg3, arg4, arg5}) + fake.newWalletMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *WalletFactory) NewWalletCallCount() int { + fake.newWalletMutex.RLock() + defer fake.newWalletMutex.RUnlock() + return len(fake.newWalletArgsForCall) +} + +func (fake *WalletFactory) NewWalletCalls(stub func(context.Context, string, identity.RoleType, role.Registry, identity.Info) (driver.Wallet, error)) { + fake.newWalletMutex.Lock() + defer fake.newWalletMutex.Unlock() + fake.NewWalletStub = stub +} + +func (fake *WalletFactory) NewWalletArgsForCall(i int) (context.Context, string, identity.RoleType, role.Registry, identity.Info) { + fake.newWalletMutex.RLock() + defer fake.newWalletMutex.RUnlock() + argsForCall := fake.newWalletArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5 +} + +func (fake *WalletFactory) NewWalletReturns(result1 driver.Wallet, result2 error) { + fake.newWalletMutex.Lock() + defer fake.newWalletMutex.Unlock() + fake.NewWalletStub = nil + fake.newWalletReturns = struct { + result1 driver.Wallet + result2 error + }{result1, result2} +} + +func (fake *WalletFactory) NewWalletReturnsOnCall(i int, result1 driver.Wallet, result2 error) { + fake.newWalletMutex.Lock() + defer fake.newWalletMutex.Unlock() + fake.NewWalletStub = nil + if fake.newWalletReturnsOnCall == nil { + fake.newWalletReturnsOnCall = make(map[int]struct { + result1 driver.Wallet + result2 error + }) + } + fake.newWalletReturnsOnCall[i] = struct { + result1 driver.Wallet + result2 error + }{result1, result2} +} + +func (fake *WalletFactory) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *WalletFactory) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ role.WalletFactory = new(WalletFactory) diff --git a/token/services/identity/wallet/db/registry.go b/token/services/identity/role/registry.go similarity index 63% rename from token/services/identity/wallet/db/registry.go rename to token/services/identity/role/registry.go index bf886b343e..eac4c4ebdd 100644 --- a/token/services/identity/wallet/db/registry.go +++ b/token/services/identity/role/registry.go @@ -4,11 +4,12 @@ Copyright IBM Corp. All Rights Reserved. SPDX-License-Identifier: Apache-2.0 */ -package db +package role import ( "context" "encoding/json" + "sync" "github.com/hyperledger-labs/fabric-smart-client/pkg/utils/errors" "github.com/hyperledger-labs/fabric-token-sdk/token/driver" @@ -17,24 +18,40 @@ import ( "github.com/hyperledger-labs/fabric-token-sdk/token/services/logging" ) +//go:generate counterfeiter -o mock/wf.go -fake-name WalletFactory . WalletFactory +type WalletFactory interface { + NewWallet(ctx context.Context, id string, role identity.RoleType, wr Registry, info identity.Info) (driver.Wallet, error) +} + // WalletRegistry manages wallets whose long-term identities have a given role. +// +// Concurrency and invariants: +// - The Wallets map MUST only be accessed while holding WalletMu. Use +// WalletMu.RLock()/RUnlock() for short read-only access and WalletMu.Lock()/Unlock() +// for modifications. Methods in this file follow the pattern of taking short +// RLocks for map reads and never holding locks while calling out to external +// services (identity provider, storage, wallet factory) to avoid blocking and +// potential deadlocks. type WalletRegistry struct { Logger logging.Logger Role identity.Role Storage idriver.WalletStoreService - Wallets map[string]driver.Wallet + WalletFactory WalletFactory + WalletMu sync.RWMutex + Wallets map[string]driver.Wallet } // NewWalletRegistry returns a new registry for the passed parameters. // A registry is bound to a given role, and it is persistent. // Long-term identities are provided by the passed identity provider -func NewWalletRegistry(logger logging.Logger, role identity.Role, storage idriver.WalletStoreService) *WalletRegistry { +func NewWalletRegistry(logger logging.Logger, role identity.Role, storage idriver.WalletStoreService, walletFactory WalletFactory) *WalletRegistry { return &WalletRegistry{ - Logger: logger, - Role: role, - Storage: storage, - Wallets: map[string]driver.Wallet{}, + Logger: logger, + Role: role, + Storage: storage, + WalletFactory: walletFactory, + Wallets: map[string]driver.Wallet{}, } } @@ -46,11 +63,18 @@ func (r *WalletRegistry) RegisterIdentity(ctx context.Context, config driver.Ide // Lookup searches the wallet corresponding to the passed id. // If a wallet is found, Lookup returns the wallet and its identifier. // If no wallet is found, Lookup returns the identity info and a potential wallet identifier for the passed id, if anything is found +// +// The lookup strategy is multi-step: +// 1. Ask the role provider to MapToIdentity (identity, walletID). If that errors, fall back to toViewIdentity/GetWalletID. +// 2. Check the in-memory cache (r.Wallets) for wallet entries. Map reads are protected by WalletMu.RLock for a short duration. +// 3. If cache misses, try to resolve identity -> wallet id using storage/role and finally call role.GetIdentityInfo for any discovered wallet identifiers. +// +// Note: Lookup only takes short RLocks for map reads and does not hold the lock while calling external services. func (r *WalletRegistry) Lookup(ctx context.Context, id driver.WalletLookupID) (driver.Wallet, idriver.IdentityInfo, string, error) { r.Logger.DebugfContext(ctx, "lookup wallet by [%T]", id) var walletIdentifiers []string - identity, walletID, err := r.Role.MapToIdentity(ctx, id) + ident, walletID, err := r.Role.MapToIdentity(ctx, id) if err != nil { r.Logger.Errorf("failed to map wallet [%T] to identity [%s], use a fallback strategy", id, err) fail := true @@ -64,7 +88,7 @@ func (r *WalletRegistry) Lookup(ctx context.Context, id driver.WalletLookupID) ( r.Logger.DebugfContext(ctx, "lookup failed, there is a wallet for identity [%s]: [%s]", passedIdentity, wID) // we got a hit walletID = wID - identity = passedIdentity + ident = passedIdentity fail = false } } @@ -72,9 +96,12 @@ func (r *WalletRegistry) Lookup(ctx context.Context, id driver.WalletLookupID) ( return nil, nil, "", errors.WithMessagef(err, "failed to lookup wallet [%s]", id) } } - r.Logger.DebugfContext(ctx, "looked-up identifier [%s:%s]", identity, logging.Prefix(walletID)) + r.Logger.DebugfContext(ctx, "looked-up identifier [%s:%s]", ident, logging.Prefix(walletID)) wID := walletID + // Short RLock while reading from the map cache. Do not hold while calling external services. + r.WalletMu.RLock() walletEntry, ok := r.Wallets[wID] + r.WalletMu.RUnlock() if ok { return walletEntry, nil, wID, nil } @@ -89,7 +116,9 @@ func (r *WalletRegistry) Lookup(ctx context.Context, id driver.WalletLookupID) ( if err == nil && len(passedWalletID) != 0 { r.Logger.DebugfContext(ctx, "no wallet found, there is a wallet for identity [%s]: [%s]", passedIdentity, passedWalletID) // we got a hit + r.WalletMu.RLock() walletEntry, ok = r.Wallets[passedWalletID] + r.WalletMu.RUnlock() if ok { return walletEntry, nil, passedWalletID, nil } @@ -99,13 +128,15 @@ func (r *WalletRegistry) Lookup(ctx context.Context, id driver.WalletLookupID) ( } r.Logger.DebugfContext(ctx, "no wallet found for [%s] at [%s]", passedIdentity, logging.Prefix(wID)) - if len(identity) != 0 { - identityWID, err := r.GetWalletID(ctx, identity) - r.Logger.DebugfContext(ctx, "wallet for identity [%s] -> [%s:%s]", identity, identityWID, err) + if len(ident) != 0 { + identityWID, err := r.GetWalletID(ctx, ident) + r.Logger.DebugfContext(ctx, "wallet for identity [%s] -> [%s:%s]", ident, identityWID, err) if err == nil && len(identityWID) != 0 { + r.WalletMu.RLock() w, ok := r.Wallets[identityWID] + r.WalletMu.RUnlock() if ok { - r.Logger.DebugfContext(ctx, "found wallet [%s:%s:%s:%s]", identity, walletID, w.ID(), identityWID) + r.Logger.DebugfContext(ctx, "found wallet [%s:%s:%s:%s]", ident, walletID, w.ID(), identityWID) return w, nil, identityWID, nil } } @@ -135,6 +166,9 @@ func (r *WalletRegistry) Lookup(ctx context.Context, id driver.WalletLookupID) ( // RegisterWallet binds the passed wallet to the passed id func (r *WalletRegistry) RegisterWallet(ctx context.Context, id string, w driver.Wallet) error { r.Logger.DebugfContext(ctx, "register wallet [%s]", id) + // Protect writes to the Wallets map + r.WalletMu.Lock() + defer r.WalletMu.Unlock() r.Wallets[id] = w return nil } @@ -202,6 +236,57 @@ func (r *WalletRegistry) GetWalletID(ctx context.Context, identity driver.Identi return wID, nil } +func (r *WalletRegistry) WalletByID(ctx context.Context, role identity.RoleType, id driver.WalletLookupID) (driver.Wallet, error) { + r.Logger.DebugfContext(ctx, "role [%d] lookup wallet by [%T]", role, id) + defer r.Logger.DebugfContext(ctx, "role [%d] lookup wallet by [%T] done", role, id) + + r.Logger.DebugfContext(ctx, "is it in cache?") + + // First, do a fast-path check of the cache without taking a long lock. + v, ok := id.(string) + if ok { + r.Logger.DebugfContext(ctx, "role [%d] lookup wallet by string [%s]", role, v) + r.WalletMu.RLock() + w := r.Wallets[v] + r.WalletMu.RUnlock() + if w != nil { + r.Logger.DebugfContext(ctx, "role [%d] lookup wallet by string [%s], found.", role, v) + return w, nil + } + } + + // Not in cache: do the lookup to get identity info and wallet id (no locks held across external calls) + // Lookup itself takes short RLocks for map reads. We call Lookup without holding + // the global mutex to avoid blocking other operations while doing external lookups. + w, idInfo, wID, err := r.Lookup(ctx, id) + if err != nil { + r.Logger.DebugfContext(ctx, "failed with error [%+v]", err) + return nil, errors.WithMessagef(err, "failed to lookup identity for owner wallet [%T]", id) + } + if w != nil { + r.Logger.DebugfContext(ctx, "yes [%s:%s]", w.ID(), wID) + return w, nil + } + r.Logger.DebugfContext(ctx, "no") + + // Register the newly created wallet but check if another goroutine already created it. + r.WalletMu.Lock() + defer r.WalletMu.Unlock() + if existing, ok := r.Wallets[wID]; ok { + // Another goroutine created and registered the wallet in the meantime; prefer it. + return existing, nil + } + // Create the wallet without holding the registry lock (avoid holding locks while calling external code). + r.Logger.DebugfContext(ctx, "create wallet [%s]", wID) + newWallet, err := r.WalletFactory.NewWallet(ctx, wID, role, r, idInfo) + if err != nil { + return nil, err + } + r.Logger.DebugfContext(ctx, "register wallet [%s:%s] with label [%s]", newWallet.ID(), wID, wID) + r.Wallets[wID] = newWallet + return newWallet, nil +} + func toViewIdentity(id driver.WalletLookupID) (driver.Identity, bool) { switch v := id.(type) { case driver.Identity: diff --git a/token/services/identity/role/registry_test.go b/token/services/identity/role/registry_test.go new file mode 100644 index 0000000000..a20292725e --- /dev/null +++ b/token/services/identity/role/registry_test.go @@ -0,0 +1,264 @@ +/* +Copyright IBM Corp. All Rights Reserved. + +SPDX-License-Identifier: Apache-2.0 +*/ + +package role_test + +import ( + "context" + "encoding/json" + "errors" + "sync" + "testing" + "time" + + "github.com/hyperledger-labs/fabric-token-sdk/token/driver" + mock2 "github.com/hyperledger-labs/fabric-token-sdk/token/driver/mock" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity" + imock "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/driver/mock" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/role" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/role/mock" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/logging" + "github.com/stretchr/testify/require" +) + +// helper to create a registry with fakes +func newRegistryWithFakes() (*role.WalletRegistry, *imock.WalletStoreService, *imock.Role, *mock.WalletFactory) { + storage := &imock.WalletStoreService{} + r := &imock.Role{} + wf := &mock.WalletFactory{} + reg := role.NewWalletRegistry(logging.MustGetLogger("role_test"), r, storage, wf) + // ensure a non-nil logger to avoid panics in methods that log + return reg, storage, r, wf +} + +// --- tests --- + +func TestRegisterWallet_AddsToCache(t *testing.T) { + reg, _, _, _ := newRegistryWithFakes() + ctx := t.Context() + w := &mock2.Wallet{} + w.IDReturns("w1") + require.NoError(t, reg.RegisterWallet(ctx, "w1", w)) + + reg.WalletMu.RLock() + defer reg.WalletMu.RUnlock() + req, ok := reg.Wallets["w1"] + require.True(t, ok) + require.Equal(t, "w1", req.ID()) +} + +func TestLookup_ReturnsCachedWalletByWalletID(t *testing.T) { + reg, _, role, _ := newRegistryWithFakes() + ctx := t.Context() + w := &mock2.Wallet{} + w.IDReturns("cached") + reg.WalletMu.Lock() + reg.Wallets["w1"] = w + reg.WalletMu.Unlock() + + role.MapToIdentityReturns([]byte("id1"), "w1", nil) + + wallet, idInfo, wID, err := reg.Lookup(ctx, []byte("id1")) + require.NoError(t, err) + require.Equal(t, "w1", wID) + require.Nil(t, idInfo) + require.Equal(t, "cached", wallet.ID()) +} + +func TestLookup_FallbackToViewIdentityFound(t *testing.T) { + reg, storage, role, _ := newRegistryWithFakes() + ctx := t.Context() + w := &mock2.Wallet{} + w.IDReturns("cached2") + reg.WalletMu.Lock() + reg.Wallets["w2"] = w + reg.WalletMu.Unlock() + + role.MapToIdentityReturns(nil, "", errors.New("no mapping")) + // GetWalletID should return the wallet id for the passed identity + storage.GetWalletIDReturns("w2", nil) + + wallet, idInfo, wID, err := reg.Lookup(ctx, []byte("id2")) + require.NoError(t, err) + require.Equal(t, "w2", wID) + require.Nil(t, idInfo) + require.Equal(t, "cached2", wallet.ID()) +} + +func TestLookup_ReturnsIdentityInfoWhenWalletMissing(t *testing.T) { + reg, _, role, _ := newRegistryWithFakes() + ctx := t.Context() + + role.MapToIdentityReturns([]byte("id3"), "w3", nil) + role.GetIdentityInfoReturns(&mockIdentityInfo{id: "id3"}, nil) + + wallet, idInfo, wID, err := reg.Lookup(ctx, []byte("id3")) + require.NoError(t, err) + require.Nil(t, wallet) + require.NotNil(t, idInfo) + require.Equal(t, "w3", wID) +} + +func TestLookup_NoWalletInfo_Error(t *testing.T) { + reg, _, role, _ := newRegistryWithFakes() + ctx := t.Context() + + role.MapToIdentityReturns(nil, "", errors.New("not found")) + // no view identity and no storage mapping -> error expected + _, _, _, err := reg.Lookup(ctx, struct{ X int }{1}) + require.Error(t, err) +} + +func TestBindIdentityAndContainsAndMetadataAndGetWalletID(t *testing.T) { + reg, storage, _, _ := newRegistryWithFakes() + ctx := t.Context() + + storage.StoreIdentityReturns(nil) + require.NoError(t, reg.BindIdentity(ctx, []byte("id"), "e", "w", map[string]string{"a": "b"})) + // ContainsIdentity delegates + storage.IdentityExistsReturns(true) + require.True(t, reg.ContainsIdentity(ctx, []byte("id"), "w")) + + // GetIdentityMetadata + meta := map[string]string{} + raw, _ := json.Marshal(map[string]string{"k": "v"}) + storage.LoadMetaReturns(raw, nil) + require.NoError(t, reg.GetIdentityMetadata(ctx, []byte("id"), "w", &meta)) + require.Equal(t, "v", meta["k"]) + + // GetWalletID when storage returns value + storage.GetWalletIDReturns("w", nil) + wid, err := reg.GetWalletID(ctx, []byte("id")) + require.NoError(t, err) + require.Equal(t, "w", wid) + + // GetWalletID when storage returns error -> suppressed to empty string + storage.GetWalletIDReturns("", errors.New("boom")) + wid2, err2 := reg.GetWalletID(ctx, []byte("id")) + require.NoError(t, err2) + require.Empty(t, wid2) +} + +func TestWalletIDs_MergesRoleAndStorage(t *testing.T) { + reg, storage, role, _ := newRegistryWithFakes() + role.IdentityIDsReturns([]string{"r1"}, nil) + storage.GetWalletIDsReturns([]string{"s1", "r1"}, nil) + + ids, err := reg.WalletIDs(t.Context()) + require.NoError(t, err) + // must contain both unique ids + require.Contains(t, ids, "r1") + require.Contains(t, ids, "s1") +} + +func TestWalletByID_CreatesWalletUsingFactory(t *testing.T) { + reg, _, role, wf := newRegistryWithFakes() + ctx := t.Context() + // make Lookup return an idInfo and wallet id + role.MapToIdentityReturns([]byte("id4"), "w4", nil) + role.GetIdentityInfoReturns(&mockIdentityInfo{id: "id4"}, nil) + created := &mock2.Wallet{} + created.IDReturns("w4") + wf.NewWalletReturns(created, nil) + + w, err := reg.WalletByID(ctx, 0, []byte("id4")) + require.NoError(t, err) + require.Equal(t, 1, wf.NewWalletCallCount()) + require.Equal(t, "w4", w.ID()) + + w, err = reg.WalletByID(ctx, 0, "id4") + require.NoError(t, err) + require.Equal(t, 1, wf.NewWalletCallCount()) + require.Equal(t, "w4", w.ID()) + + w, err = reg.WalletByID(ctx, 0, "w4") + require.NoError(t, err) + require.Equal(t, 1, wf.NewWalletCallCount()) + require.Equal(t, "w4", w.ID()) +} + +func TestWalletByID_CreatesWalletUsingFactory2(t *testing.T) { + reg, _, role, wf := newRegistryWithFakes() + ctx := t.Context() + // make Lookup return an idInfo and wallet id + role.MapToIdentityReturns([]byte("id4"), "w4", nil) + role.GetIdentityInfoReturns(&mockIdentityInfo{id: "id4"}, nil) + created := &mock2.Wallet{} + created.IDReturns("w4") + wf.NewWalletReturns(created, nil) + + w, err := reg.WalletByID(ctx, 0, "w4") + require.NoError(t, err) + require.Equal(t, 1, wf.NewWalletCallCount()) + require.Equal(t, "w4", w.ID()) + + w, err = reg.WalletByID(ctx, 0, "id4") + require.NoError(t, err) + require.Equal(t, 1, wf.NewWalletCallCount()) + require.Equal(t, "w4", w.ID()) + + w, err = reg.WalletByID(ctx, 0, "w4") + require.NoError(t, err) + require.Equal(t, 1, wf.NewWalletCallCount()) + require.Equal(t, "w4", w.ID()) +} + +func TestWalletByID_ConcurrentCreation(t *testing.T) { + reg, _, r, wf := newRegistryWithFakes() + ctx := t.Context() + r.MapToIdentityReturns([]byte("idc"), "wc", nil) + r.GetIdentityInfoReturns(&mockIdentityInfo{id: "idc"}, nil) + + // make NewWallet block until allowed to proceed to simulate concurrent callers + start := make(chan struct{}) + created := &mock2.Wallet{} + created.IDReturns("wc") + wf.NewWalletStub = func(ctx context.Context, id string, role identity.RoleType, wr role.Registry, info identity.Info) (driver.Wallet, error) { + <-start + return created, nil + } + + var wg sync.WaitGroup + res := make([]driver.Wallet, 5) + errs := make([]error, 5) + for i := 0; i < 5; i++ { + wg.Add(1) + go func(i int) { + defer wg.Done() + w, err := reg.WalletByID(ctx, 0, []byte("idc")) + res[i] = w + errs[i] = err + }(i) + } + + // let goroutines start and block inside NewWallet + time.Sleep(50 * time.Millisecond) + close(start) + wg.Wait() + + for i := 0; i < 5; i++ { + require.NoError(t, errs[i]) + require.Equal(t, "wc", res[i].ID()) + } + + // ensure only one was actually registered in the map + reg.WalletMu.RLock() + defer reg.WalletMu.RUnlock() + count := 0 + for k := range reg.Wallets { + if k == "wc" { + count++ + } + } + require.Equal(t, 1, count) +} + +func TestLookup_WithUnknownType_Error(t *testing.T) { + reg, _, r, _ := newRegistryWithFakes() + r.MapToIdentityReturns(nil, "", errors.New("fail")) + _, _, _, err := reg.Lookup(t.Context(), struct{ X int }{1}) + require.Error(t, err) +} diff --git a/token/services/identity/role/role.go b/token/services/identity/role/role.go index 2a274ebf20..9e3020852a 100644 --- a/token/services/identity/role/role.go +++ b/token/services/identity/role/role.go @@ -18,7 +18,14 @@ import ( "github.com/hyperledger-labs/fabric-token-sdk/token/services/utils" ) -type localMembership interface { +// LocalMembership abstracts the local identity/membership service used by a Role. +// The Role relies on this interface to lookup identities, identifiers and to +// register identities. The concrete implementation is provided by the local +// membership/identity provider and a counterfeiter-generated fake exists under +// `mock` for unit tests. +// +//go:generate counterfeiter -o mock/lm.go -fake-name LocalMembership . LocalMembership +type LocalMembership interface { DefaultNetworkIdentity() driver.Identity IsMe(ctx context.Context, id driver.Identity) bool GetIdentityInfo(ctx context.Context, label string, auditInfo []byte) (idriver.IdentityInfo, error) @@ -28,16 +35,26 @@ type localMembership interface { IDs() ([]string, error) } -// Role models a role whose identities are anonymous +// Role models a role whose identities are anonymous. +// A Role delegates identity resolution to the LocalMembership implementation. +// It exposes mapping helpers that accept either a string identifier, a driver.Identity +// or raw []byte and returns either a long-term identity (driver.Identity) and/or +// an identifier string used by the token subsystem. type Role struct { logger logging.Logger roleID identity.RoleType networkID string - localMembership localMembership + localMembership LocalMembership nodeIdentity driver.Identity } -func NewRole(logger logging.Logger, roleID identity.RoleType, networkID string, nodeIdentity driver.Identity, localMembership localMembership) *Role { +func NewRole( + logger logging.Logger, + roleID identity.RoleType, + networkID string, + nodeIdentity driver.Identity, + localMembership LocalMembership, +) *Role { return &Role{ logger: logger, roleID: roleID, @@ -47,11 +64,14 @@ func NewRole(logger logging.Logger, roleID identity.RoleType, networkID string, } } +// ID returns the role identifier (RoleType) for this Role instance. func (r *Role) ID() identity.RoleType { return r.roleID } -// GetIdentityInfo returns the identity information for the given identity identifier +// GetIdentityInfo returns the identity information for the given identity identifier. +// It simply forwards the call to the LocalMembership and annotates any returned +// error with the network context for easier diagnosis. func (r *Role) GetIdentityInfo(ctx context.Context, id string) (idriver.IdentityInfo, error) { r.logger.DebugfContext(ctx, "[%s] getting info for [%s]", r.networkID, logging.Printable(id)) @@ -62,29 +82,41 @@ func (r *Role) GetIdentityInfo(ctx context.Context, id string) (idriver.Identity return info, nil } -// RegisterIdentity registers the given identity +// RegisterIdentity registers the given identity via the LocalMembership service. func (r *Role) RegisterIdentity(ctx context.Context, config driver.IdentityConfiguration) error { return r.localMembership.RegisterIdentity(ctx, config) } +// IdentityIDs returns the identifiers known to this Role (delegates to LocalMembership.IDs). func (r *Role) IdentityIDs() ([]string, error) { return r.localMembership.IDs() } -// MapToIdentity returns the identity for the given argument +// MapToIdentity returns the identity for the given WalletLookupID argument. +// The WalletLookupID can be a string (label), []byte or driver.Identity. The +// method dispatches to helper functions that implement the mapping logic. func (r *Role) MapToIdentity(ctx context.Context, v driver.WalletLookupID) (driver.Identity, string, error) { switch vv := v.(type) { case driver.Identity: return r.mapIdentityToID(ctx, vv) case []byte: + // []byte identities are treated as driver.Identity (cast) by the mapper return r.mapIdentityToID(ctx, vv) case string: return r.mapStringToID(ctx, vv) default: + // For unsupported types return a descriptive error. The stack is appended + // to help debugging callers that may accidentally pass incorrect types. return nil, "", errors.Errorf("identifier not recognised, expected []byte or driver.Identity, got [%T], [%s]", v, string(debug.Stack())) } } +// mapStringToID implements the resolution logic when the caller provides a string +// label. The resolution order is deliberately chosen: +// 1. Ask LocalMembership for an identifier associated to the label +// 2. Handle empty label and default-identity aliases (default identifier, default network identity, node identity) +// 3. If the label corresponds to a local member (IsMe), try to fetch its identifier; if not available return the identity +// 4. Fallback: return the string label as identifier func (r *Role) mapStringToID(ctx context.Context, v string) (driver.Identity, string, error) { defaultNetworkIdentity := r.localMembership.DefaultNetworkIdentity() defaultIdentifier := r.localMembership.GetDefaultIdentifier() @@ -138,6 +170,11 @@ func (r *Role) mapStringToID(ctx context.Context, v string) (driver.Identity, st return nil, label, nil } +// mapIdentityToID implements the resolution logic when the caller provides a +// driver.Identity (or []byte cast to driver.Identity). It checks for empty +// identities, equality with the default network or node identity, local membership +// (IsMe) and finally tries to resolve the identifier by querying the +// LocalMembership for IdentityInfo or Identifier. func (r *Role) mapIdentityToID(ctx context.Context, v driver.Identity) (driver.Identity, string, error) { defaultNetworkIdentity := r.localMembership.DefaultNetworkIdentity() defaultIdentifier := r.localMembership.GetDefaultIdentifier() diff --git a/token/services/identity/role/role_test.go b/token/services/identity/role/role_test.go new file mode 100644 index 0000000000..b785b14c20 --- /dev/null +++ b/token/services/identity/role/role_test.go @@ -0,0 +1,264 @@ +/* +Copyright IBM Corp. All Rights Reserved. + +SPDX-License-Identifier: Apache-2.0 +*/ +package role_test + +import ( + "context" + "errors" + "testing" + + "github.com/hyperledger-labs/fabric-token-sdk/token/driver" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity" + idriver "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/driver" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/role" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/role/mock" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/logging" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func setup(t *testing.T) (context.Context, *role.Role, *mock.LocalMembership) { + t.Helper() + ctx := t.Context() + logger := logging.MustGetLogger("role_test") + m := &mock.LocalMembership{} + // default values for network identity and identifiers + m.DefaultNetworkIdentityReturns(driver.Identity("defaultNet")) + m.GetDefaultIdentifierReturns("defaultID") + + r := role.NewRole(logger, identity.IssuerRole, "net1", driver.Identity("nodeID"), m) + return ctx, r, m +} + +func TestRole_ID_returns_roleID(t *testing.T) { + _, r, _ := setup(t) + require.EqualValues(t, identity.IssuerRole, r.ID()) +} + +func TestRole_GetIdentityInfo_success_and_error(t *testing.T) { + ctx, r, m := setup(t) + info := &mockIdentityInfo{id: "info1"} + m.GetIdentityInfoReturns(info, nil) + + got, err := r.GetIdentityInfo(ctx, "label") + require.NoError(t, err) + require.Equal(t, info, got) + + // error path + m.GetIdentityInfoReturns(nil, errors.New("not found")) + _, err = r.GetIdentityInfo(ctx, "label") + require.Error(t, err) +} + +func TestRole_RegisterIdentity_and_IdentityIDs(t *testing.T) { + ctx, r, m := setup(t) + m.RegisterIdentityReturns(nil) + err := r.RegisterIdentity(ctx, driver.IdentityConfiguration{}) + require.NoError(t, err) + + m.RegisterIdentityReturns(errors.New("bad")) + err = r.RegisterIdentity(ctx, driver.IdentityConfiguration{}) + require.Error(t, err) + + // IdentityIDs + m.IDsReturns([]string{"a", "b"}, nil) + ids, err := r.IdentityIDs() + require.NoError(t, err) + require.ElementsMatch(t, []string{"a", "b"}, ids) + + m.IDsReturns(nil, errors.New("fail")) + _, err = r.IdentityIDs() + require.Error(t, err) +} + +func TestRole_MapToIdentity_unsupported_type(t *testing.T) { + ctx, r, _ := setup(t) + _, _, err := r.MapToIdentity(ctx, 123) + require.Error(t, err) + assert.Contains(t, err.Error(), "identifier not recognised") +} + +func TestRole_MapToIdentity_mapStringToID_branches(t *testing.T) { + ctx, r, m := setup(t) + // Use stubs to control GetIdentifier and IsMe behaviour based on input + m.GetIdentifierCalls(func(ctx context.Context, id driver.Identity) (string, error) { + s := string(id) + switch s { + case "label": + return "id123", nil + case "member": + return "idMe", nil + case "member2": + return "", errors.New("no") + default: + return "", errors.New("no") + } + }) + m.IsMeCalls(func(ctx context.Context, id driver.Identity) bool { + s := string(id) + return s == "member" || s == "member2" + }) + + // If GetIdentifier succeeds immediately + id, ident, err := r.MapToIdentity(ctx, "label") + require.NoError(t, err) + require.Nil(t, id) + require.Equal(t, "id123", ident) + + // empty label -> default identifier + m.GetDefaultIdentifierReturns("def") + id, ident, err = r.MapToIdentity(ctx, "") + require.NoError(t, err) + require.Nil(t, id) + require.Equal(t, "def", ident) + + // passed default identifier + m.GetDefaultIdentifierReturns("def") + id, ident, err = r.MapToIdentity(ctx, "def") + require.NoError(t, err) + require.Nil(t, id) + require.Equal(t, "def", ident) + + // passed default network identity unique id + m.DefaultNetworkIdentityReturns(driver.Identity("uniq")) + m.GetDefaultIdentifierReturns("def") + id, ident, err = r.MapToIdentity(ctx, "uniq") + require.NoError(t, err) + require.Nil(t, id) + require.Equal(t, "def", ident) + + // passed default network identity as string + m.DefaultNetworkIdentityReturns(driver.Identity("netstr")) + m.GetDefaultIdentifierReturns("def") + id, ident, err = r.MapToIdentity(ctx, string(driver.Identity("netstr"))) + require.NoError(t, err) + require.Nil(t, id) + require.Equal(t, "def", ident) + + // passed node identity equal + m.GetDefaultIdentifierReturns("def") + id, ident, err = r.MapToIdentity(ctx, string(driver.Identity("nodeID"))) + require.NoError(t, err) + require.Nil(t, id) + require.Equal(t, "def", ident) + + // is local member and GetIdentifier succeeds + id, ident, err = r.MapToIdentity(ctx, "member") + require.NoError(t, err) + require.Nil(t, id) + require.Equal(t, "idMe", ident) + + // is local member and GetIdentifier fails -> return identity + id, ident, err = r.MapToIdentity(ctx, "member2") + require.NoError(t, err) + require.Equal(t, driver.Identity("member2"), id) + require.Equal(t, "", ident) + + // fallback: return label as identifier + // make IsMe return false for unknown + m.IsMeCalls(func(ctx context.Context, id driver.Identity) bool { return false }) + id, ident, err = r.MapToIdentity(ctx, "unknown") + require.NoError(t, err) + require.Nil(t, id) + require.Equal(t, "unknown", ident) +} + +func TestRole_MapToIdentity_mapIdentityToID_branches(t *testing.T) { + ctx, r, m := setup(t) + // Use stubs for IsMe, GetIdentifier and GetIdentityInfo + m.IsMeCalls(func(ctx context.Context, id driver.Identity) bool { + s := string(id) + return s == "me" || s == "me2" + }) + m.GetIdentifierCalls(func(ctx context.Context, id driver.Identity) (string, error) { + s := string(id) + switch s { + case "me": + return "idMe", nil + case "me2": + return "", errors.New("no") + case "labelFallback": + return "idFallback", nil + default: + return "", errors.New("no") + } + }) + m.GetIdentityInfoCalls(func(ctx context.Context, label string, auditInfo []byte) (idriver.IdentityInfo, error) { + switch label { + case "labelInfo": + return &mockIdentityInfo{id: "infoID"}, nil + default: + return nil, errors.New("no") + } + }) + + // identity is none -> default + m.GetDefaultIdentifierReturns("def") + id, ident, err := r.MapToIdentity(ctx, driver.Identity("")) + require.NoError(t, err) + require.Nil(t, id) + require.Equal(t, "def", ident) + + // identity equals default network identity + m.DefaultNetworkIdentityReturns(driver.Identity("n1")) + m.GetDefaultIdentifierReturns("def") + id, ident, err = r.MapToIdentity(ctx, driver.Identity("n1")) + require.NoError(t, err) + require.Nil(t, id) + require.Equal(t, "def", ident) + + // identity string equals default identifier + m.GetDefaultIdentifierReturns("def") + id, ident, err = r.MapToIdentity(ctx, driver.Identity("def")) + require.NoError(t, err) + require.Nil(t, id) + require.Equal(t, "def", ident) + + // identity equals nodeIdentity + m.GetDefaultIdentifierReturns("def") + id, ident, err = r.MapToIdentity(ctx, driver.Identity("nodeID")) + require.NoError(t, err) + require.Nil(t, id) + require.Equal(t, "def", ident) + + // is me and GetIdentifier succeeds + idVal := driver.Identity("me") + id, ident, err = r.MapToIdentity(ctx, idVal) + require.NoError(t, err) + require.Equal(t, idVal, id) + require.Equal(t, "idMe", ident) + + // is me and GetIdentifier fails -> return identity + idVal2 := driver.Identity("me2") + id, ident, err = r.MapToIdentity(ctx, idVal2) + require.NoError(t, err) + require.Equal(t, idVal2, id) + require.Equal(t, "", ident) + + // lookup identity as label via GetIdentityInfo succeeds + id, ident, err = r.MapToIdentity(ctx, driver.Identity("labelInfo")) + require.NoError(t, err) + require.Nil(t, id) + require.Equal(t, "infoID", ident) + + // GetIdentityInfo fails, GetIdentifier succeeds + id, ident, err = r.MapToIdentity(ctx, driver.Identity("labelFallback")) + require.NoError(t, err) + require.Nil(t, id) + require.Equal(t, "idFallback", ident) + + // both fail -> return string(id) + id, ident, err = r.MapToIdentity(ctx, driver.Identity("labelNo")) + require.NoError(t, err) + require.Nil(t, id) + require.Equal(t, "labelNo", ident) + + // []byte path: should behave like driver.Identity + id, ident, err = r.MapToIdentity(ctx, []byte("labelNo")) + require.NoError(t, err) + require.Nil(t, id) + require.Equal(t, "labelNo", ident) +} diff --git a/token/services/identity/wallet/roles.go b/token/services/identity/role/roles.go similarity index 68% rename from token/services/identity/wallet/roles.go rename to token/services/identity/role/roles.go index fd1f0dd2a9..0d9f01ea86 100644 --- a/token/services/identity/wallet/roles.go +++ b/token/services/identity/role/roles.go @@ -4,7 +4,7 @@ Copyright IBM Corp. All Rights Reserved. SPDX-License-Identifier: Apache-2.0 */ -package wallet +package role import ( "fmt" @@ -12,7 +12,6 @@ import ( "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity" "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/driver" - db2 "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/wallet/db" "github.com/hyperledger-labs/fabric-token-sdk/token/services/logging" ) @@ -29,14 +28,19 @@ func (m Roles) Register(usage identity.RoleType, role identity.Role) { m[usage] = role } -func (m Roles) ToWalletRegistries(logger logging.Logger, db driver.WalletStoreService) map[identity.RoleType]Registry { - res := make(map[identity.RoleType]Registry, len(m)) +func (m Roles) Registries(logger logging.Logger, storage driver.WalletStoreService, walletFactory WalletFactory) map[identity.RoleType]*WalletRegistry { + res := make(map[identity.RoleType]*WalletRegistry, len(m)) for roleType, role := range m { roleAsString, ok := identity.RoleTypeStrings[roleType] if !ok { roleAsString = strconv.Itoa(int(roleType)) } - res[roleType] = db2.NewWalletRegistry(logger.Named(fmt.Sprintf("identity.%s-wallet-registry", roleAsString)), role, db) + res[roleType] = NewWalletRegistry( + logger.Named(fmt.Sprintf("identity.%s-wallet-registry", roleAsString)), + role, + storage, + walletFactory, + ) } return res } diff --git a/token/services/identity/role/wallets.go b/token/services/identity/role/wallets.go new file mode 100644 index 0000000000..7f0071eb58 --- /dev/null +++ b/token/services/identity/role/wallets.go @@ -0,0 +1,528 @@ +/* +Copyright IBM Corp. All Rights Reserved. + +SPDX-License-Identifier: Apache-2.0 +*/ + +package role + +import ( + "context" + + "github.com/hyperledger-labs/fabric-smart-client/pkg/utils/errors" + "github.com/hyperledger-labs/fabric-smart-client/platform/common/utils/collections/iterators" + "github.com/hyperledger-labs/fabric-token-sdk/token/core/common/metrics" + "github.com/hyperledger-labs/fabric-token-sdk/token/driver" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/wallet" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/logging" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/utils" + "github.com/hyperledger-labs/fabric-token-sdk/token/token" +) + +// UnspentTokensIterator defines an iterator over unspent tokens +// +//go:generate counterfeiter -o mock/uti.go -fake-name UnspentTokensIterator . UnspentTokensIterator +type UnspentTokensIterator = driver.UnspentTokensIterator + +// OwnerTokenVault provides the minimal token-vault operations needed by owner +// wallets: the ability to iterate unspent tokens for a given owner (by id) +// and to query the balance for a specific token type. Implementations are +// expected to return an UnspentTokensIterator that can be consumed by the +// wallet logic. +// +//go:generate counterfeiter -o mock/otv.go -fake-name OwnerTokenVault . OwnerTokenVault +type OwnerTokenVault interface { + UnspentTokensIteratorBy(ctx context.Context, id string, tokenType token.Type) (UnspentTokensIterator, error) + Balance(ctx context.Context, id string, tokenType token.Type) (uint64, error) +} + +// IdentityProvider is a type alias for IdentityProvider. It exposes +// identity-related operations that wallets need (signers, verifiers, audit +// info, registry operations, etc.). Using a type alias keeps the code shorter +// while preserving the underlying interface contract. +// +//go:generate counterfeiter -o mock/ip.go -fake-name IdentityProvider . IdentityProvider +type IdentityProvider = driver.IdentityProvider + +// Signer is an interface which wraps the Sign method. +// +//go:generate counterfeiter -o mock/signer.go -fake-name Signer . Signer +type Signer = driver.Signer + +// Identity represents a generic identity. +// It is modeled as a byte slice. +type Identity = driver.Identity + +// AuditorWallet represents a wallet that holds a single auditor identity. +// Auditor wallets are used to perform audit-related operations and to +// validate whether a given identity belongs to the auditor. +type AuditorWallet struct { + WalletID string + + Identity Identity + Signer Signer +} + +// NewAuditorWallet creates a new AuditorWallet bound to a single auditor +// identity. The wallet uses the provided IdentityProvider to obtain signers +// and audit information for the auditor identity. +func NewAuditorWallet(walletID string, identity Identity, signer Signer) *AuditorWallet { + return &AuditorWallet{ + WalletID: walletID, + Identity: identity, + Signer: signer, + } +} + +// ID returns the wallet identifier. +func (w *AuditorWallet) ID() string { + return w.WalletID +} + +// Contains reports whether the given identity belongs to this auditor +// wallet. The context is accepted for API consistency and future use. +func (w *AuditorWallet) Contains(ctx context.Context, identity Identity) bool { + return w.Identity.Equal(identity) +} + +// ContainsToken returns true if the supplied unspent token is owned by the +// auditor identity associated with this wallet. +func (w *AuditorWallet) ContainsToken(ctx context.Context, token *token.UnspentToken) bool { + return w.Contains(ctx, token.Owner) +} + +// GetAuditorIdentity returns the underlying auditor identity for this +// wallet. It never fails in the current implementation. +func (w *AuditorWallet) GetAuditorIdentity() (Identity, error) { + return w.Identity, nil +} + +// GetSigner returns a signer for the given identity if the identity belongs +// to this wallet; otherwise it returns an error. +func (w *AuditorWallet) GetSigner(ctx context.Context, identity Identity) (Signer, error) { + if !w.Contains(ctx, identity) { + return nil, errors.Errorf("identity [%s] does not belong to this wallet [%s]", identity, w.ID()) + } + return w.Signer, nil +} + +// IssuerTokenVault provides a minimal view of a vault used by issuer +// wallets: the ability to list history of issued tokens. This is different +// from the owner vault in that it exposes issued token history instead of +// unspent token queries. +// +//go:generate counterfeiter -o mock/itv.go -fake-name IssuerTokenVault . IssuerTokenVault +type IssuerTokenVault interface { + ListHistoryIssuedTokens(context.Context) (*token.IssuedTokens, error) +} + +// IssuerWallet represents a wallet that manages a single issuer identity. +// Issuer wallets can enumerate tokens that were issued by the wallet's +// identity and obtain signers to sign issuance transactions. +type IssuerWallet struct { + Logger logging.Logger + TokenVault IssuerTokenVault + WalletID string + Identity Identity + Signer Signer +} + +// NewIssuerWallet constructs an IssuerWallet bound to the given issuer +// identity and backed by the provided token vault and identity provider. +func NewIssuerWallet( + logger logging.Logger, + tokenVault IssuerTokenVault, + id string, + identity Identity, + signer Signer, +) *IssuerWallet { + return &IssuerWallet{ + Logger: logger, + TokenVault: tokenVault, + WalletID: id, + Identity: identity, + Signer: signer, + } +} + +// ID returns the issuer wallet identifier. +func (w *IssuerWallet) ID() string { + return w.WalletID +} + +// Contains reports whether the given identity belongs to this issuer +// wallet. The context parameter is provided for API compatibility. +func (w *IssuerWallet) Contains(_ context.Context, identity Identity) bool { + return w.Identity.Equal(identity) +} + +// ContainsToken returns true if the provided token is issued to an identity +// managed by this issuer wallet. +func (w *IssuerWallet) ContainsToken(ctx context.Context, token *token.UnspentToken) bool { + return w.Contains(ctx, token.Owner) +} + +// GetIssuerIdentity returns the issuer identity for the requested token +// type. In this simple wallet the issuer identity does not vary by token +// type and is returned directly. +func (w *IssuerWallet) GetIssuerIdentity(tokenType token.Type) (Identity, error) { + return w.Identity, nil +} + +// GetSigner returns a signer for the given identity if it belongs to this +// issuer wallet; otherwise an error is returned. +func (w *IssuerWallet) GetSigner(ctx context.Context, identity Identity) (Signer, error) { + if !w.Contains(ctx, identity) { + return nil, errors.Errorf("failed getting signer, the passed identity [%s] does not belong to this wallet [%s]", identity, w.ID()) + } + return w.Signer, nil +} + +// HistoryTokens returns the history of tokens issued by this wallet that +// match the provided listing options. It filters by token type and verifies +// that tokens belong to this wallet's issuer identity. +func (w *IssuerWallet) HistoryTokens(ctx context.Context, opts *driver.ListTokensOptions) (*token.IssuedTokens, error) { + w.Logger.DebugfContext(ctx, "issuer wallet [%s]: history tokens, type [%d]", w.ID(), opts.TokenType) + source, err := w.TokenVault.ListHistoryIssuedTokens(ctx) + if err != nil { + return nil, errors.Wrap(err, "token selection failed") + } + + unspentTokens := &token.IssuedTokens{} + for _, t := range source.Tokens { + if len(opts.TokenType) != 0 && t.Type != opts.TokenType { + w.Logger.DebugfContext(ctx, "issuer wallet [%s]: discarding token of type [%s]!=[%s]", w.ID(), t.Type, opts.TokenType) + continue + } + + if !w.Contains(ctx, t.Issuer) { + w.Logger.DebugfContext(ctx, "issuer wallet [%s]: discarding token, issuer does not belong to wallet", w.ID()) + continue + } + + w.Logger.DebugfContext(ctx, "issuer wallet [%s]: adding token of type [%s], quantity [%s]", w.ID(), t.Type, t.Quantity) + unspentTokens.Tokens = append(unspentTokens.Tokens, t) + } + w.Logger.DebugfContext(ctx, "issuer wallet [%s]: history tokens done, found [%d] issued tokens", w.ID(), len(unspentTokens.Tokens)) + + return unspentTokens, nil +} + +// CertifierWallet represents a wallet bounded to a single certifier +// identity. It provides access to a signer and exposes whether a given +// identity is the certifier for this wallet. +type CertifierWallet struct { + WalletID string + Identity Identity + Signer Signer +} + +// NewCertifierWallet creates a new CertifierWallet for the provided +// certifier identity. +func NewCertifierWallet(walletID string, identity Identity, signer Signer) *CertifierWallet { + return &CertifierWallet{ + WalletID: walletID, + Identity: identity, + Signer: signer, + } +} + +// ID returns the certifier wallet identifier. +func (w *CertifierWallet) ID() string { + return w.WalletID +} + +// Contains reports whether the given identity belongs to the certifier +// identity for this wallet. +func (w *CertifierWallet) Contains(ctx context.Context, identity Identity) bool { + return w.Identity.Equal(identity) +} + +// ContainsToken returns true if the token is owned by the certifier +// identity associated with this wallet. +func (w *CertifierWallet) ContainsToken(ctx context.Context, token *token.UnspentToken) bool { + return w.Contains(ctx, token.Owner) +} + +// GetCertifierIdentity returns the certifier identity this wallet manages. +func (w *CertifierWallet) GetCertifierIdentity() (Identity, error) { + return w.Identity, nil +} + +// GetSigner returns a signer for the certifier identity if it belongs to +// this wallet. Returns an error otherwise. +func (w *CertifierWallet) GetSigner(ctx context.Context, identity Identity) (Signer, error) { + if !w.Contains(ctx, identity) { + return nil, errors.Errorf("identity does not belong to this AnonymousOwnerWallet [%s]", identity) + } + return w.Signer, nil +} + +// LongTermOwnerWallet is the representation of a wallet that holds a +// long-term owner identity (potentially a real, non-pseudonymous identity). +// It provides methods to list tokens, check balances, and obtain recipient +// data and signers. The wallet binds to an identity.Info which can produce +// pseudonyms or other identities when required. +type LongTermOwnerWallet struct { + IdentityProvider IdentityProvider + TokenVault OwnerTokenVault + WalletID string + OwnerIdentityInfo identity.Info + OwnerIdentity Identity + OwnerAuditInfo []byte +} + +// NewLongTermOwnerWallet constructs a LongTermOwnerWallet by resolving the +// provided identity.Info into an actual Identity and its audit info. +func NewLongTermOwnerWallet(ctx context.Context, IdentityProvider IdentityProvider, TokenVault OwnerTokenVault, id string, identityInfo identity.Info) (*LongTermOwnerWallet, error) { + identity, auditInfo, err := identityInfo.Get(ctx) + if err != nil { + return nil, errors.Wrap(err, "failed to get identity info") + } + + return &LongTermOwnerWallet{ + IdentityProvider: IdentityProvider, + TokenVault: TokenVault, + WalletID: id, + OwnerIdentityInfo: identityInfo, + OwnerIdentity: identity, + OwnerAuditInfo: auditInfo, + }, nil +} + +// ID returns the wallet identifier for the long-term owner wallet. +func (w *LongTermOwnerWallet) ID() string { + return w.WalletID +} + +// Contains reports whether the provided identity is the long-term owner +// identity bound to this wallet. +func (w *LongTermOwnerWallet) Contains(ctx context.Context, identity Identity) bool { + return w.OwnerIdentity.Equal(identity) +} + +// ContainsToken returns true if the token is owned by the long-term owner +// identity managed by this wallet. +func (w *LongTermOwnerWallet) ContainsToken(ctx context.Context, token *token.UnspentToken) bool { + return w.Contains(ctx, token.Owner) +} + +// GetRecipientIdentity returns the owner identity used as a recipient in +// transfer operations. +func (w *LongTermOwnerWallet) GetRecipientIdentity(context.Context) (Identity, error) { + return w.OwnerIdentity, nil +} + +// GetRecipientData returns the recipient data (identity + audit info) +// associated with the long-term owner identity. +func (w *LongTermOwnerWallet) GetRecipientData(context.Context) (*driver.RecipientData, error) { + return &driver.RecipientData{ + Identity: w.OwnerIdentity, + AuditInfo: w.OwnerAuditInfo, + }, nil +} + +// GetAuditInfo delegates to the identity provider to fetch audit info for +// the supplied identity. +func (w *LongTermOwnerWallet) GetAuditInfo(ctx context.Context, id Identity) ([]byte, error) { + return w.IdentityProvider.GetAuditInfo(ctx, id) +} + +// GetTokenMetadata returns associated token metadata for the given owner +// identity. Not implemented in the current wallet and returns nil. +func (w *LongTermOwnerWallet) GetTokenMetadata(id Identity) ([]byte, error) { + return nil, nil +} + +// GetTokenMetadataAuditInfo returns audit info for token metadata. Not +// implemented in the current wallet and returns nil. +func (w *LongTermOwnerWallet) GetTokenMetadataAuditInfo(id Identity) ([]byte, error) { + return nil, nil +} + +// GetSigner returns a signer for the provided identity if it belongs to +// this long-term owner wallet; otherwise an error is returned. +func (w *LongTermOwnerWallet) GetSigner(ctx context.Context, identity Identity) (Signer, error) { + if !w.Contains(ctx, identity) { + return nil, errors.Errorf("identity [%s] does not belong to this wallet [%s]", identity, w.ID()) + } + return w.IdentityProvider.GetSigner(ctx, identity) +} + +// ListTokens returns all unspent tokens for the wallet matching the +// provided listing options. +func (w *LongTermOwnerWallet) ListTokens(opts *driver.ListTokensOptions) (*token.UnspentTokens, error) { + it, err := w.TokenVault.UnspentTokensIteratorBy(opts.Context, w.WalletID, opts.TokenType) + if err != nil { + return nil, errors.Wrap(err, "token selection failed") + } + tokens, err := iterators.ReadAllPointers(it) + if err != nil { + return nil, err + } + return &token.UnspentTokens{Tokens: tokens}, nil +} + +// Balance returns the on-chain balance for the wallet for the given token +// type in the listing options. +func (w *LongTermOwnerWallet) Balance(ctx context.Context, opts *driver.ListTokensOptions) (uint64, error) { + balance, err := w.TokenVault.Balance(ctx, w.WalletID, opts.TokenType) + if err != nil { + return 0, errors.Wrap(err, "token selection failed") + } + return balance, nil +} + +// ListTokensIterator returns an iterator to scan unspent tokens instead of +// materializing them in memory. +func (w *LongTermOwnerWallet) ListTokensIterator(opts *driver.ListTokensOptions) (driver.UnspentTokensIterator, error) { + it, err := w.TokenVault.UnspentTokensIteratorBy(opts.Context, w.WalletID, opts.TokenType) + if err != nil { + return nil, errors.Wrap(err, "token selection failed") + } + return it, nil +} + +// EnrollmentID returns the enrollment id associated with the underlying +// identity info. +func (w *LongTermOwnerWallet) EnrollmentID() string { + return w.OwnerIdentityInfo.EnrollmentID() +} + +// RegisterRecipient registers recipient data (identity + audit info). +// The long-term owner wallet currently has a no-op implementation here +// and returns nil. The TODO indicates where custom logic would be added. +func (w *LongTermOwnerWallet) RegisterRecipient(ctx context.Context, data *driver.RecipientData) error { + // TODO: if identity is equal to the one this wallet is bound to, then we are good. Otherwise return an error + return nil +} + +// Remote reports whether the underlying identity info is remote. +func (w *LongTermOwnerWallet) Remote() bool { + return w.OwnerIdentityInfo.Remote() +} + +// AnonymousOwnerWallet represents an owner wallet that uses ephemeral +// pseudonyms for privacy. It embeds a LongTermOwnerWallet for shared +// functionality and adds a cache and registry interactions to produce and +// manage anonymous recipient identities. +type AnonymousOwnerWallet struct { + *LongTermOwnerWallet + Logger logging.Logger + Deserializer Deserializer + WalletRegistry Registry + IdentityCache *RecipientDataCache +} + +// NewAnonymousOwnerWallet creates an AnonymousOwnerWallet. It initializes +// a RecipientDataCache (used to cache pseudonyms/recipient data) and stores +// references to the identity provider, vault, deserializer and wallet +// registry used to validate and register pseudonyms. +func NewAnonymousOwnerWallet( + logger logging.Logger, + IdentityProvider IdentityProvider, + TokenVault OwnerTokenVault, + Deserializer Deserializer, + walletRegistry Registry, + id string, + identityInfo identity.Info, + cacheSize int, + metricsProvider metrics.Provider, +) (*AnonymousOwnerWallet, error) { + w := &AnonymousOwnerWallet{ + LongTermOwnerWallet: &LongTermOwnerWallet{ + IdentityProvider: IdentityProvider, + TokenVault: TokenVault, + WalletID: id, + OwnerIdentityInfo: identityInfo, + }, + Logger: logger, + WalletRegistry: walletRegistry, + Deserializer: Deserializer, + } + w.IdentityCache = NewRecipientDataCache(logger, w.getRecipientIdentity, cacheSize, NewMetrics(metricsProvider)) + logger.Debugf("added wallet cache for id %s with cache of size %d", id+"@"+identityInfo.EnrollmentID(), cacheSize) + return w, nil +} + +// Contains reports whether the provided identity is bound to this anonymous +// owner wallet according to the wallet registry. +func (w *AnonymousOwnerWallet) Contains(ctx context.Context, identity Identity) bool { + return w.WalletRegistry.ContainsIdentity(ctx, identity, w.WalletID) +} + +// ContainsToken returns true if the token is owned by an identity bound to +// this anonymous owner wallet. +func (w *AnonymousOwnerWallet) ContainsToken(ctx context.Context, token *token.UnspentToken) bool { + return w.Contains(ctx, token.Owner) +} + +// GetRecipientIdentity returns the current recipient identity (pseudonym) +// from the cache, creating a new one if necessary. +func (w *AnonymousOwnerWallet) GetRecipientIdentity(ctx context.Context) (Identity, error) { + rd, err := w.IdentityCache.RecipientData(ctx) + if err != nil { + return nil, errors.Wrap(err, "failed to get recipient data") + } + return rd.Identity, nil +} + +// GetRecipientData returns recipient data (identity + audit info) from the +// identity cache. +func (w *AnonymousOwnerWallet) GetRecipientData(ctx context.Context) (*driver.RecipientData, error) { + return w.IdentityCache.RecipientData(ctx) +} + +// RegisterRecipient validates and registers the provided recipient data +// (verifier and audit info) into the identity provider and wallet registry. +func (w *AnonymousOwnerWallet) RegisterRecipient(ctx context.Context, data *driver.RecipientData) error { + if data == nil { + return errors.Wrapf(wallet.ErrNilRecipientData, "invalid recipient data") + } + w.Logger.DebugfContext(ctx, "register recipient identity [%s] with audit info [%s]", data.Identity, utils.Hashable(data.AuditInfo)) + + // recognize identity and register it + // match identity and audit info + err := w.Deserializer.MatchIdentity(ctx, data.Identity, data.AuditInfo) + if err != nil { + return errors.Wrapf(err, "failed to match identity to audit infor for [%s]:[%s]", data.Identity, utils.Hashable(data.AuditInfo)) + } + // register recipient data + if err := w.IdentityProvider.RegisterRecipientData(ctx, data); err != nil { + return errors.Wrapf(err, "failed registering audit info for owner [%s]", data.Identity) + } + // bind to enrollment id and wallet id + if err := w.WalletRegistry.BindIdentity(ctx, data.Identity, w.EnrollmentID(), w.WalletID, nil); err != nil { + return errors.WithMessagef(err, "failed storing recipient identity in wallet [%s]", w.WalletID) + } + return nil +} + +// getRecipientIdentity generates a fresh pseudonym and registers it with +// the wallet registry, returning the resulting RecipientData. +func (w *AnonymousOwnerWallet) getRecipientIdentity(ctx context.Context) (*driver.RecipientData, error) { + // Get a new pseudonym + pseudonym, auditInfo, err := w.OwnerIdentityInfo.Get(ctx) + if err != nil { + return nil, errors.WithMessagef(err, "failed getting recipient identity from wallet [%s:%s]", w.ID(), w.OwnerIdentityInfo.EnrollmentID()) + } + + // Register the pseudonym + if err := w.WalletRegistry.BindIdentity(ctx, pseudonym, w.OwnerIdentityInfo.EnrollmentID(), w.WalletID, nil); err != nil { + return nil, errors.WithMessagef(err, "failed storing recipient identity in wallet [%s]", w.ID()) + } + return &driver.RecipientData{ + Identity: pseudonym, + AuditInfo: auditInfo, + }, nil +} + +// GetSigner returns a signer for the provided identity if it is bound to +// this anonymous owner wallet; otherwise an error is returned. +func (w *AnonymousOwnerWallet) GetSigner(ctx context.Context, identity Identity) (Signer, error) { + if !w.Contains(ctx, identity) { + return nil, errors.Errorf("identity [%s] does not belong to this wallet [%s]", identity, w.ID()) + } + return w.IdentityProvider.GetSigner(ctx, identity) +} diff --git a/token/services/identity/role/wallets_test.go b/token/services/identity/role/wallets_test.go new file mode 100644 index 0000000000..72bae743ef --- /dev/null +++ b/token/services/identity/role/wallets_test.go @@ -0,0 +1,339 @@ +/* +Copyright IBM Corp. All Rights Reserved. + +SPDX-License-Identifier: Apache-2.0 +*/ + +package role_test + +import ( + "errors" + "testing" + + "github.com/hyperledger-labs/fabric-smart-client/platform/view/services/metrics/disabled" + "github.com/hyperledger-labs/fabric-token-sdk/token/driver" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/role" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/role/mock" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/logging" + "github.com/hyperledger-labs/fabric-token-sdk/token/token" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestAuditorWallet(t *testing.T) { + t.Run("Creation and Basics", func(t *testing.T) { + signer := &mock.Signer{} + id := driver.Identity("auditorIdentity") + w := role.NewAuditorWallet("w1", id, signer) + + require.NotNil(t, w) + assert.Equal(t, "w1", w.ID()) + + // Identity check + gotID, err := w.GetAuditorIdentity() + require.NoError(t, err) + assert.Equal(t, id, gotID) + + // Contains + assert.True(t, w.Contains(t.Context(), id)) + assert.False(t, w.Contains(t.Context(), driver.Identity("other"))) + + // ContainsToken + assert.True(t, w.ContainsToken(t.Context(), &token.UnspentToken{Owner: id})) + assert.False(t, w.ContainsToken(t.Context(), &token.UnspentToken{Owner: driver.Identity("other")})) + + // GetSigner + s, err := w.GetSigner(t.Context(), id) + require.NoError(t, err) + assert.Equal(t, signer, s) + + _, err = w.GetSigner(t.Context(), driver.Identity("other")) + require.Error(t, err) + }) +} + +func TestCertifierWallet(t *testing.T) { + t.Run("Creation and Basics", func(t *testing.T) { + signer := &mock.Signer{} + id := driver.Identity("certifierIdentity") + w := role.NewCertifierWallet("w1", id, signer) + + require.NotNil(t, w) + assert.Equal(t, "w1", w.ID()) + + // Identity check + gotID, err := w.GetCertifierIdentity() + require.NoError(t, err) + assert.Equal(t, id, gotID) + + // Contains + assert.True(t, w.Contains(t.Context(), id)) + assert.False(t, w.Contains(t.Context(), driver.Identity("other"))) + + // ContainsToken + assert.True(t, w.ContainsToken(t.Context(), &token.UnspentToken{Owner: id})) + assert.False(t, w.ContainsToken(t.Context(), &token.UnspentToken{Owner: driver.Identity("other")})) + + // GetSigner + s, err := w.GetSigner(t.Context(), id) + require.NoError(t, err) + assert.Equal(t, signer, s) + + _, err = w.GetSigner(t.Context(), driver.Identity("other")) + require.Error(t, err) + }) +} + +func TestIssuerWallet(t *testing.T) { + setup := func() (*role.IssuerWallet, *mock.IssuerTokenVault, *mock.Signer) { + tv := &mock.IssuerTokenVault{} + signer := &mock.Signer{} + logger := logging.MustGetLogger("test") + id := driver.Identity("issuerIdentity") + w := role.NewIssuerWallet(logger, tv, "w1", id, signer) + return w, tv, signer + } + + t.Run("Creation and Basics", func(t *testing.T) { + w, _, signer := setup() + id := driver.Identity("issuerIdentity") + + require.NotNil(t, w) + assert.Equal(t, "w1", w.ID()) + + // Identity check + gotID, err := w.GetIssuerIdentity(token.Type("ANY")) + require.NoError(t, err) + assert.Equal(t, id, gotID) + + // Contains + assert.True(t, w.Contains(t.Context(), id)) + assert.False(t, w.Contains(t.Context(), driver.Identity("other"))) + + // ContainsToken + assert.True(t, w.ContainsToken(t.Context(), &token.UnspentToken{Owner: id})) + assert.False(t, w.ContainsToken(t.Context(), &token.UnspentToken{Owner: driver.Identity("other")})) + + // GetSigner + s, err := w.GetSigner(t.Context(), id) + require.NoError(t, err) + assert.Equal(t, signer, s) + + _, err = w.GetSigner(t.Context(), driver.Identity("other")) + require.Error(t, err) + }) + + t.Run("HistoryTokens", func(t *testing.T) { + w, tv, _ := setup() + id := driver.Identity("issuerIdentity") + + // Prepare mock data + tokens := &token.IssuedTokens{ + Tokens: []*token.IssuedToken{ + {Type: "T1", Quantity: "10", Issuer: id}, + {Type: "T2", Quantity: "20", Issuer: id}, + {Type: "T1", Quantity: "30", Issuer: driver.Identity("other")}, + }, + } + tv.ListHistoryIssuedTokensReturns(tokens, nil) + + // Case 1: All types + res, err := w.HistoryTokens(t.Context(), &driver.ListTokensOptions{}) + require.NoError(t, err) + assert.Len(t, res.Tokens, 2) + + // Case 2: Filter by type + res, err = w.HistoryTokens(t.Context(), &driver.ListTokensOptions{TokenType: "T1"}) + require.NoError(t, err) + assert.Len(t, res.Tokens, 1) + assert.Equal(t, token.Type("T1"), res.Tokens[0].Type) + + // Case 3: Error from vault + tv.ListHistoryIssuedTokensReturns(nil, errors.New("vault error")) + _, err = w.HistoryTokens(t.Context(), &driver.ListTokensOptions{}) + require.Error(t, err) + }) +} + +func TestLongTermOwnerWallet(t *testing.T) { + setup := func(t *testing.T) (*role.LongTermOwnerWallet, *mock.IdentityProvider, *mock.OwnerTokenVault) { + t.Helper() + ip := &mock.IdentityProvider{} + tv := &mock.OwnerTokenVault{} + info := &mockIdentityInfo{id: "ownerIdentity"} + + w, err := role.NewLongTermOwnerWallet(t.Context(), ip, tv, "w1", info) + require.NoError(t, err) + return w, ip, tv + } + + t.Run("Creation and Basics", func(t *testing.T) { + w, _, _ := setup(t) + id := driver.Identity("ownerIdentity") + + require.NotNil(t, w) + assert.Equal(t, "w1", w.ID()) + + assert.True(t, w.Contains(t.Context(), id)) + assert.False(t, w.Contains(t.Context(), driver.Identity("other"))) + + assert.True(t, w.ContainsToken(t.Context(), &token.UnspentToken{Owner: id})) + + recipient, err := w.GetRecipientIdentity(t.Context()) + require.NoError(t, err) + assert.Equal(t, id, recipient) + + data, err := w.GetRecipientData(t.Context()) + require.NoError(t, err) + assert.Equal(t, id, data.Identity) + assert.Equal(t, []byte("audit-info"), data.AuditInfo) // mockIdentityInfo returns nil audit info + }) + + t.Run("ListTokens and Balance", func(t *testing.T) { + w, _, tv := setup(t) + + // Setup mock iterator + it := &mock.UnspentTokensIterator{} + // We can't easily fake the Next calls logic with simple Returns unless we use Callbacks or careful Returns. + // For simplicity, let's use ReturnsOnCall if counterfeiter supports simpler behavior, or stub it. + // Counterfeiter Stub allows full function replacement. + + tokensList := []*token.UnspentToken{ + {Id: token.ID{TxId: "tx1", Index: 0}, Type: "T1", Quantity: "10"}, + {Id: token.ID{TxId: "tx2", Index: 0}, Type: "T1", Quantity: "20"}, + } + + idx := 0 + it.NextStub = func() (*token.UnspentToken, error) { + if idx >= len(tokensList) { + return nil, nil + } + t := tokensList[idx] + idx++ + return t, nil + } + + tv.UnspentTokensIteratorByReturns(it, nil) + tv.BalanceReturns(30, nil) + + // ListTokens + tokens, err := w.ListTokens(&driver.ListTokensOptions{Context: t.Context(), TokenType: "T1"}) + require.NoError(t, err) + assert.Len(t, tokens.Tokens, 2) + + // ListTokensIterator + tv.UnspentTokensIteratorByReturns(it, nil) + itRet, err := w.ListTokensIterator(&driver.ListTokensOptions{Context: t.Context()}) + require.NoError(t, err) + assert.Equal(t, it, itRet) + + // Balance + bal, err := w.Balance(t.Context(), &driver.ListTokensOptions{Context: t.Context()}) + require.NoError(t, err) + assert.Equal(t, uint64(30), bal) + }) + + t.Run("GetSigner", func(t *testing.T) { + w, ip, _ := setup(t) + signer := &mock.Signer{} + ip.GetSignerReturns(signer, nil) + + s, err := w.GetSigner(t.Context(), driver.Identity("ownerIdentity")) + require.NoError(t, err) + assert.Equal(t, signer, s) + + _, err = w.GetSigner(t.Context(), driver.Identity("other")) + require.Error(t, err) + }) +} + +func TestAnonymousOwnerWallet(t *testing.T) { + setup := func(t *testing.T) (*role.AnonymousOwnerWallet, *mock.IdentityProvider, *mock.OwnerTokenVault, *mock.Registry, *mock.Deserializer) { + t.Helper() + ip := &mock.IdentityProvider{} + tv := &mock.OwnerTokenVault{} + info := &mockIdentityInfo{id: "ownerIdentity"} + reg := &mock.Registry{} + des := &mock.Deserializer{} + logger := logging.MustGetLogger("test") + + // Create wallet + w, err := role.NewAnonymousOwnerWallet(logger, ip, tv, des, reg, "w1", info, 10, &disabled.Provider{}) + require.NoError(t, err) + return w, ip, tv, reg, des + } + + t.Run("Creation and Basics", func(t *testing.T) { + w, _, _, reg, _ := setup(t) + + assert.NotNil(t, w) + assert.Equal(t, "w1", w.ID()) + + // Contains delegates to registry + reg.ContainsIdentityReturns(true) + assert.True(t, w.Contains(t.Context(), driver.Identity("someID"))) + + reg.ContainsIdentityReturns(false) + assert.False(t, w.Contains(t.Context(), driver.Identity("other"))) + }) + + t.Run("GetRecipientIdentity", func(t *testing.T) { + w, _, _, _, _ := setup(t) + + // First call should generate new identity and register it + id, err := w.GetRecipientIdentity(t.Context()) + require.NoError(t, err) + assert.Equal(t, driver.Identity("ownerIdentity"), id) + }) + + t.Run("RegisterRecipient", func(t *testing.T) { + w, ip, _, reg, des := setup(t) + + data := &driver.RecipientData{ + Identity: driver.Identity("newIdentity"), + AuditInfo: []byte("audit"), + } + + // Case 1: Success + // Deserialize OwnerVerifier defaults to nil, error nil => success verification + des.MatchIdentityReturns(nil) + ip.RegisterRecipientDataReturns(nil) + reg.BindIdentityReturns(nil) + + err := w.RegisterRecipient(t.Context(), data) + require.NoError(t, err) + + // Case 2: MatchIdentity failure + des.MatchIdentityReturns(errors.New("match error")) + err = w.RegisterRecipient(t.Context(), data) + require.Error(t, err) + assert.Contains(t, err.Error(), "failed to match identity") + des.MatchIdentityReturns(nil) + + // Case 3: RegisterRecipientData failure + ip.RegisterRecipientDataReturns(errors.New("reg recipient data error")) + err = w.RegisterRecipient(t.Context(), data) + require.Error(t, err) + ip.RegisterRecipientDataReturns(nil) + + // Case 4: BindIdentity failure + reg.BindIdentityReturns(errors.New("bind error")) + err = w.RegisterRecipient(t.Context(), data) + require.Error(t, err) + }) + + t.Run("GetSigner", func(t *testing.T) { + w, ip, _, reg, _ := setup(t) + signer := &mock.Signer{} + ip.GetSignerReturns(signer, nil) + + reg.ContainsIdentityReturns(true) + s, err := w.GetSigner(t.Context(), driver.Identity("someID")) + require.NoError(t, err) + assert.Equal(t, signer, s) + + reg.ContainsIdentityReturns(false) + _, err = w.GetSigner(t.Context(), driver.Identity("other")) + require.Error(t, err) + }) +} diff --git a/token/services/identity/wallet/factory.go b/token/services/identity/role/wfactory.go similarity index 64% rename from token/services/identity/wallet/factory.go rename to token/services/identity/role/wfactory.go index a6b156079a..6fa8798daf 100644 --- a/token/services/identity/wallet/factory.go +++ b/token/services/identity/role/wfactory.go @@ -4,7 +4,7 @@ Copyright IBM Corp. All Rights Reserved. SPDX-License-Identifier: Apache-2.0 */ -package wallet +package role import ( "context" @@ -17,35 +17,52 @@ import ( "github.com/hyperledger-labs/fabric-token-sdk/token/token" ) +//go:generate counterfeiter -o mock/tv.go -fake-name TokenVault . TokenVault type TokenVault interface { - IsPending(ctx context.Context, id *token.ID) (bool, error) UnspentTokensIteratorBy(ctx context.Context, id string, tokenType token.Type) (driver.UnspentTokensIterator, error) ListHistoryIssuedTokens(ctx context.Context) (*token.IssuedTokens, error) Balance(ctx context.Context, id string, tokenType token.Type) (uint64, error) } +//go:generate counterfeiter -o mock/wc.go -fake-name WalletsConfiguration . WalletsConfiguration type WalletsConfiguration interface { CacheSizeForOwnerID(id string) int } -type Factory struct { +//go:generate counterfeiter -o mock/registry.go -fake-name Registry . Registry +type Registry interface { + WalletIDs(ctx context.Context) ([]string, error) + RegisterIdentity(ctx context.Context, config driver.IdentityConfiguration) error + Lookup(ctx context.Context, id driver.WalletLookupID) (driver.Wallet, identity.Info, string, error) + RegisterWallet(ctx context.Context, id string, wallet driver.Wallet) error + BindIdentity(ctx context.Context, identity driver.Identity, eID string, wID string, meta any) error + ContainsIdentity(ctx context.Context, i driver.Identity, id string) bool + GetIdentityMetadata(ctx context.Context, identity driver.Identity, wID string, meta any) error +} + +//go:generate counterfeiter -o mock/deserializer.go -fake-name Deserializer . Deserializer +type Deserializer = driver.Deserializer + +// DefaultFactory creates wallets for the default role. +type DefaultFactory struct { Logger logging.Logger - IdentityProvider driver.IdentityProvider + IdentityProvider IdentityProvider TokenVault TokenVault WalletsConfiguration WalletsConfiguration - Deserializer driver.Deserializer + Deserializer Deserializer MetricsProvider metrics.Provider } -func NewFactory( +// NewDefaultFactory creates a new DefaultFactory. +func NewDefaultFactory( logger logging.Logger, identityProvider driver.IdentityProvider, tokenVault TokenVault, walletsConfiguration WalletsConfiguration, - deserializer driver.Deserializer, + deserializer Deserializer, metricsProvider metrics.Provider, -) *Factory { - return &Factory{ +) *DefaultFactory { + return &DefaultFactory{ Logger: logger, IdentityProvider: identityProvider, TokenVault: tokenVault, @@ -55,7 +72,7 @@ func NewFactory( } } -func (w *Factory) NewWallet(ctx context.Context, id string, role identity.RoleType, wr Registry, info identity.Info) (driver.Wallet, error) { +func (w *DefaultFactory) NewWallet(ctx context.Context, id string, role identity.RoleType, wr Registry, info identity.Info) (driver.Wallet, error) { switch role { case identity.OwnerRole: if info.Anonymous() { @@ -95,7 +112,12 @@ func (w *Factory) NewWallet(ctx context.Context, id string, role identity.RoleTy if err != nil { return nil, errors.WithMessagef(err, "failed to get issuer wallet identity for [%s]", id) } - newWallet := NewIssuerWallet(w.Logger, w.IdentityProvider, w.TokenVault, id, idInfoIdentity) + signer, err := w.IdentityProvider.GetSigner(ctx, idInfoIdentity) + if err != nil { + return nil, errors.WithMessagef(err, "failed to get issuer signer [%s]", id) + } + + newWallet := NewIssuerWallet(w.Logger, w.TokenVault, id, idInfoIdentity, signer) if err := wr.BindIdentity(ctx, idInfoIdentity, info.EnrollmentID(), id, nil); err != nil { return nil, errors.WithMessagef(err, "programming error, failed to register recipient identity [%s]", id) } @@ -107,7 +129,12 @@ func (w *Factory) NewWallet(ctx context.Context, id string, role identity.RoleTy if err != nil { return nil, errors.WithMessagef(err, "failed to get auditor wallet identity for [%s]", id) } - newWallet := NewAuditorWallet(w.IdentityProvider, id, idInfoIdentity) + signer, err := w.IdentityProvider.GetSigner(ctx, idInfoIdentity) + if err != nil { + return nil, errors.WithMessagef(err, "failed to get auditor signer [%s]", id) + } + + newWallet := NewAuditorWallet(id, idInfoIdentity, signer) if err := wr.BindIdentity(ctx, idInfoIdentity, info.EnrollmentID(), id, nil); err != nil { return nil, errors.WithMessagef(err, "programming error, failed to register recipient identity [%s]", id) } diff --git a/token/services/identity/role/wfactory_test.go b/token/services/identity/role/wfactory_test.go new file mode 100644 index 0000000000..f3332fa24c --- /dev/null +++ b/token/services/identity/role/wfactory_test.go @@ -0,0 +1,210 @@ +/* +Copyright IBM Corp. All Rights Reserved. + +SPDX-License-Identifier: Apache-2.0 +*/ + +package role_test + +import ( + "context" + "errors" + "testing" + + "github.com/hyperledger-labs/fabric-smart-client/platform/view/services/metrics/disabled" + "github.com/hyperledger-labs/fabric-token-sdk/token/driver" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/role" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/role/mock" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/logging" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestDefaultFactory(t *testing.T) { + setup := func(t *testing.T) (*role.DefaultFactory, *mock.IdentityProvider, *mock.TokenVault, *mock.WalletsConfiguration, *mock.Deserializer, *mock.Registry) { + t.Helper() + ip := &mock.IdentityProvider{} + tv := &mock.TokenVault{} + wc := &mock.WalletsConfiguration{} + des := &mock.Deserializer{} + reg := &mock.Registry{} + logger := logging.MustGetLogger("test") + + f := role.NewDefaultFactory(logger, ip, tv, wc, des, &disabled.Provider{}) + require.NotNil(t, f) + return f, ip, tv, wc, des, reg + } + + t.Run("Owner Wallet - Anonymous", func(t *testing.T) { + f, _, _, wc, _, reg := setup(t) + id := "owner-wallet-anon" + info := &mockIdentityInfo{id: id, anonymous: true} + + wc.CacheSizeForOwnerIDReturns(5) + reg.ContainsIdentityReturns(true) // For NewAnonymousOwnerWallet check + + w, err := f.NewWallet(t.Context(), id, identity.OwnerRole, reg, info) + require.NoError(t, err) + require.NotNil(t, w) + assert.Equal(t, id, w.ID()) + // Is AnonymousOwnerWallet? Hard to check type directly without export, but behavior confirms it. + }) + + t.Run("Owner Wallet - LongTerm", func(t *testing.T) { + f, _, _, _, _, reg := setup(t) + id := "owner-wallet-lt" + info := &mockIdentityInfo{id: id, anonymous: false} + + w, err := f.NewWallet(t.Context(), id, identity.OwnerRole, reg, info) + require.NoError(t, err) + require.NotNil(t, w) + assert.Equal(t, id, w.ID()) + }) + + t.Run("Issuer Wallet", func(t *testing.T) { + f, ip, _, _, _, reg := setup(t) + id := "issuer-wallet" + info := &mockIdentityInfo{id: "issuer-id", anonymous: false} + + signer := &mock.Signer{} + ip.GetSignerReturns(signer, nil) + + w, err := f.NewWallet(t.Context(), id, identity.IssuerRole, reg, info) + require.NoError(t, err) + require.NotNil(t, w) + assert.Equal(t, id, w.ID()) + + // Verify bindings + assert.Equal(t, 1, reg.BindIdentityCallCount()) + _, _, eid, wid, _ := reg.BindIdentityArgsForCall(0) + assert.Equal(t, info.EnrollmentID(), eid) + assert.Equal(t, id, wid) + }) + + t.Run("Issuer Wallet - Failures", func(t *testing.T) { + f, ip, _, _, _, reg := setup(t) + id := "issuer-wallet-fail" + + // Case 1: Info Get fails + infoErr := &mockIdentityInfo{err: errors.New("info error")} + _, err := f.NewWallet(t.Context(), id, identity.IssuerRole, reg, infoErr) + require.Error(t, err) + assert.Contains(t, err.Error(), "failed to get issuer wallet identity") + + // Case 2: GetSigner fails + info := &mockIdentityInfo{id: "issuer-id"} + ip.GetSignerReturns(nil, errors.New("signer error")) + _, err = f.NewWallet(t.Context(), id, identity.IssuerRole, reg, info) + require.Error(t, err) + assert.Contains(t, err.Error(), "failed to get issuer signer") + + // Case 3: BindIdentity fails + ip.GetSignerReturns(&mock.Signer{}, nil) + reg.BindIdentityReturns(errors.New("bind error")) + _, err = f.NewWallet(t.Context(), id, identity.IssuerRole, reg, info) + require.Error(t, err) + assert.Contains(t, err.Error(), "failed to register recipient identity") + }) + + t.Run("Auditor Wallet", func(t *testing.T) { + f, ip, _, _, _, reg := setup(t) + id := "auditor-wallet" + info := &mockIdentityInfo{id: "auditor-id"} + + signer := &mock.Signer{} + ip.GetSignerReturns(signer, nil) + + w, err := f.NewWallet(t.Context(), id, identity.AuditorRole, reg, info) + require.NoError(t, err) + require.NotNil(t, w) + assert.Equal(t, id, w.ID()) + + // Verify bindings + assert.Equal(t, 1, reg.BindIdentityCallCount()) + }) + + t.Run("Auditor Wallet - Failures", func(t *testing.T) { + f, ip, _, _, _, reg := setup(t) + id := "auditor-wallet-fail" + + // Case 1: Info Get fails + infoErr := &mockIdentityInfo{err: errors.New("info error")} + _, err := f.NewWallet(t.Context(), id, identity.AuditorRole, reg, infoErr) + require.Error(t, err) + assert.Contains(t, err.Error(), "failed to get auditor wallet identity") + + // Case 2: GetSigner fails + info := &mockIdentityInfo{id: "auditor-id"} + ip.GetSignerReturns(nil, errors.New("signer error")) + _, err = f.NewWallet(t.Context(), id, identity.AuditorRole, reg, info) + require.Error(t, err) + assert.Contains(t, err.Error(), "failed to get auditor signer") + + // Case 3: BindIdentity fails + ip.GetSignerReturns(&mock.Signer{}, nil) + reg.BindIdentityReturns(errors.New("bind error")) + _, err = f.NewWallet(t.Context(), id, identity.AuditorRole, reg, info) + require.Error(t, err) + assert.Contains(t, err.Error(), "failed to register recipient identity") + }) + + t.Run("Certifier Wallet - Unsupported", func(t *testing.T) { + f, _, _, _, _, reg := setup(t) + id := "certifier-wallet" + info := &mockIdentityInfo{id: "cert-id"} + + _, err := f.NewWallet(t.Context(), id, identity.CertifierRole, reg, info) + require.Error(t, err) + assert.Contains(t, err.Error(), "certifiers are not supported") + }) + + t.Run("Unknown Role - Unsupported", func(t *testing.T) { + f, _, _, _, _, reg := setup(t) + id := "unknown-wallet" + info := &mockIdentityInfo{id: "unk-id"} + + _, err := f.NewWallet(t.Context(), id, identity.RoleType(999), reg, info) + require.Error(t, err) + assert.Contains(t, err.Error(), "role [999] not supported") + }) +} + +// mockIdentityInfo is a helper to mock identity.Info +type mockIdentityInfo struct { + id string + eid string + anonymous bool + remote bool + err error +} + +func (f *mockIdentityInfo) ID() string { + return f.id +} + +func (f *mockIdentityInfo) EnrollmentID() string { + if f.eid == "" { + return "enrollment-id" + } + return f.eid +} + +func (f *mockIdentityInfo) Type() string { + return "msp" +} + +func (f *mockIdentityInfo) Get(context.Context) (driver.Identity, []byte, error) { + if f.err != nil { + return nil, nil, f.err + } + return driver.Identity(f.id), []byte("audit-info"), nil +} + +func (f *mockIdentityInfo) Anonymous() bool { + return f.anonymous +} + +func (f *mockIdentityInfo) Remote() bool { + return f.remote +} diff --git a/token/services/identity/wallet/db/registry_test.go b/token/services/identity/wallet/db/registry_test.go deleted file mode 100644 index 7e5c5886ea..0000000000 --- a/token/services/identity/wallet/db/registry_test.go +++ /dev/null @@ -1,77 +0,0 @@ -/* -Copyright IBM Corp. All Rights Reserved. - -SPDX-License-Identifier: Apache-2.0 -*/ - -package db_test - -import ( - "context" - "testing" - - "github.com/hyperledger-labs/fabric-smart-client/platform/view/services/storage/driver/common/mock" - _ "github.com/hyperledger-labs/fabric-smart-client/platform/view/services/storage/driver/memory" - "github.com/hyperledger-labs/fabric-token-sdk/token" - "github.com/hyperledger-labs/fabric-token-sdk/token/driver" - idriver "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/driver" - kvs2 "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/storage/kvs" - "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/wallet/db" - "github.com/hyperledger-labs/fabric-token-sdk/token/services/logging" - "github.com/stretchr/testify/assert" -) - -func TestGetWallet(t *testing.T) { - cp := &mock.ConfigProvider{} - ctx := t.Context() - cp.IsSetReturns(false) - kvsStorage, err := kvs2.NewInMemory() - assert.NoError(t, err) - - alice := driver.Identity("alice") - meta := "meta" - wr := db.NewWalletRegistry( - &logging.MockLogger{}, - &fakeRole{}, - kvs2.NewWalletStore(kvsStorage, token.TMSID{Network: "testnetwork", Channel: "testchannel", Namespace: "tns"}), - ) - assert.NoError(t, wr.RegisterWallet(ctx, "hello", nil)) - assert.NoError(t, wr.BindIdentity(ctx, alice, "alice", "hello", meta)) - wID, err := wr.GetWalletID(ctx, alice) - assert.NoError(t, err) - assert.Equal(t, "hello", wID) - var meta2 string - assert.NoError(t, wr.GetIdentityMetadata(ctx, alice, "hello", &meta2)) - assert.Equal(t, meta, meta2) -} - -type fakeRole struct{} - -func (f *fakeRole) ID() idriver.IdentityRoleType { - return 0 -} - -func (f *fakeRole) MapToIdentity(ctx context.Context, v driver.WalletLookupID) (driver.Identity, string, error) { - // TODO implement me - panic("implement me") -} - -func (f *fakeRole) GetIdentityInfo(ctx context.Context, id string) (idriver.IdentityInfo, error) { - // TODO implement me - panic("implement me") -} - -func (f *fakeRole) RegisterIdentity(ctx context.Context, config driver.IdentityConfiguration) error { - // TODO implement me - panic("implement me") -} - -func (f *fakeRole) IdentityIDs() ([]string, error) { - // TODO implement me - panic("implement me") -} - -func (f *fakeRole) Load(pp driver.PublicParameters) error { - // TODO implement me - panic("implement me") -} diff --git a/token/services/identity/wallet/mock/registry.go b/token/services/identity/wallet/mock/registry.go new file mode 100644 index 0000000000..0e2873d9e0 --- /dev/null +++ b/token/services/identity/wallet/mock/registry.go @@ -0,0 +1,272 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package mock + +import ( + "context" + "sync" + + "github.com/hyperledger-labs/fabric-token-sdk/token/driver" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/wallet" +) + +type Registry struct { + RegisterIdentityStub func(context.Context, driver.IdentityConfiguration) error + registerIdentityMutex sync.RWMutex + registerIdentityArgsForCall []struct { + arg1 context.Context + arg2 driver.IdentityConfiguration + } + registerIdentityReturns struct { + result1 error + } + registerIdentityReturnsOnCall map[int]struct { + result1 error + } + WalletByIDStub func(context.Context, identity.RoleType, driver.WalletLookupID) (driver.Wallet, error) + walletByIDMutex sync.RWMutex + walletByIDArgsForCall []struct { + arg1 context.Context + arg2 identity.RoleType + arg3 driver.WalletLookupID + } + walletByIDReturns struct { + result1 driver.Wallet + result2 error + } + walletByIDReturnsOnCall map[int]struct { + result1 driver.Wallet + result2 error + } + WalletIDsStub func(context.Context) ([]string, error) + walletIDsMutex sync.RWMutex + walletIDsArgsForCall []struct { + arg1 context.Context + } + walletIDsReturns struct { + result1 []string + result2 error + } + walletIDsReturnsOnCall map[int]struct { + result1 []string + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *Registry) RegisterIdentity(arg1 context.Context, arg2 driver.IdentityConfiguration) error { + fake.registerIdentityMutex.Lock() + ret, specificReturn := fake.registerIdentityReturnsOnCall[len(fake.registerIdentityArgsForCall)] + fake.registerIdentityArgsForCall = append(fake.registerIdentityArgsForCall, struct { + arg1 context.Context + arg2 driver.IdentityConfiguration + }{arg1, arg2}) + stub := fake.RegisterIdentityStub + fakeReturns := fake.registerIdentityReturns + fake.recordInvocation("RegisterIdentity", []interface{}{arg1, arg2}) + fake.registerIdentityMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *Registry) RegisterIdentityCallCount() int { + fake.registerIdentityMutex.RLock() + defer fake.registerIdentityMutex.RUnlock() + return len(fake.registerIdentityArgsForCall) +} + +func (fake *Registry) RegisterIdentityCalls(stub func(context.Context, driver.IdentityConfiguration) error) { + fake.registerIdentityMutex.Lock() + defer fake.registerIdentityMutex.Unlock() + fake.RegisterIdentityStub = stub +} + +func (fake *Registry) RegisterIdentityArgsForCall(i int) (context.Context, driver.IdentityConfiguration) { + fake.registerIdentityMutex.RLock() + defer fake.registerIdentityMutex.RUnlock() + argsForCall := fake.registerIdentityArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *Registry) RegisterIdentityReturns(result1 error) { + fake.registerIdentityMutex.Lock() + defer fake.registerIdentityMutex.Unlock() + fake.RegisterIdentityStub = nil + fake.registerIdentityReturns = struct { + result1 error + }{result1} +} + +func (fake *Registry) RegisterIdentityReturnsOnCall(i int, result1 error) { + fake.registerIdentityMutex.Lock() + defer fake.registerIdentityMutex.Unlock() + fake.RegisterIdentityStub = nil + if fake.registerIdentityReturnsOnCall == nil { + fake.registerIdentityReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.registerIdentityReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *Registry) WalletByID(arg1 context.Context, arg2 identity.RoleType, arg3 driver.WalletLookupID) (driver.Wallet, error) { + fake.walletByIDMutex.Lock() + ret, specificReturn := fake.walletByIDReturnsOnCall[len(fake.walletByIDArgsForCall)] + fake.walletByIDArgsForCall = append(fake.walletByIDArgsForCall, struct { + arg1 context.Context + arg2 identity.RoleType + arg3 driver.WalletLookupID + }{arg1, arg2, arg3}) + stub := fake.WalletByIDStub + fakeReturns := fake.walletByIDReturns + fake.recordInvocation("WalletByID", []interface{}{arg1, arg2, arg3}) + fake.walletByIDMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *Registry) WalletByIDCallCount() int { + fake.walletByIDMutex.RLock() + defer fake.walletByIDMutex.RUnlock() + return len(fake.walletByIDArgsForCall) +} + +func (fake *Registry) WalletByIDCalls(stub func(context.Context, identity.RoleType, driver.WalletLookupID) (driver.Wallet, error)) { + fake.walletByIDMutex.Lock() + defer fake.walletByIDMutex.Unlock() + fake.WalletByIDStub = stub +} + +func (fake *Registry) WalletByIDArgsForCall(i int) (context.Context, identity.RoleType, driver.WalletLookupID) { + fake.walletByIDMutex.RLock() + defer fake.walletByIDMutex.RUnlock() + argsForCall := fake.walletByIDArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *Registry) WalletByIDReturns(result1 driver.Wallet, result2 error) { + fake.walletByIDMutex.Lock() + defer fake.walletByIDMutex.Unlock() + fake.WalletByIDStub = nil + fake.walletByIDReturns = struct { + result1 driver.Wallet + result2 error + }{result1, result2} +} + +func (fake *Registry) WalletByIDReturnsOnCall(i int, result1 driver.Wallet, result2 error) { + fake.walletByIDMutex.Lock() + defer fake.walletByIDMutex.Unlock() + fake.WalletByIDStub = nil + if fake.walletByIDReturnsOnCall == nil { + fake.walletByIDReturnsOnCall = make(map[int]struct { + result1 driver.Wallet + result2 error + }) + } + fake.walletByIDReturnsOnCall[i] = struct { + result1 driver.Wallet + result2 error + }{result1, result2} +} + +func (fake *Registry) WalletIDs(arg1 context.Context) ([]string, error) { + fake.walletIDsMutex.Lock() + ret, specificReturn := fake.walletIDsReturnsOnCall[len(fake.walletIDsArgsForCall)] + fake.walletIDsArgsForCall = append(fake.walletIDsArgsForCall, struct { + arg1 context.Context + }{arg1}) + stub := fake.WalletIDsStub + fakeReturns := fake.walletIDsReturns + fake.recordInvocation("WalletIDs", []interface{}{arg1}) + fake.walletIDsMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *Registry) WalletIDsCallCount() int { + fake.walletIDsMutex.RLock() + defer fake.walletIDsMutex.RUnlock() + return len(fake.walletIDsArgsForCall) +} + +func (fake *Registry) WalletIDsCalls(stub func(context.Context) ([]string, error)) { + fake.walletIDsMutex.Lock() + defer fake.walletIDsMutex.Unlock() + fake.WalletIDsStub = stub +} + +func (fake *Registry) WalletIDsArgsForCall(i int) context.Context { + fake.walletIDsMutex.RLock() + defer fake.walletIDsMutex.RUnlock() + argsForCall := fake.walletIDsArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *Registry) WalletIDsReturns(result1 []string, result2 error) { + fake.walletIDsMutex.Lock() + defer fake.walletIDsMutex.Unlock() + fake.WalletIDsStub = nil + fake.walletIDsReturns = struct { + result1 []string + result2 error + }{result1, result2} +} + +func (fake *Registry) WalletIDsReturnsOnCall(i int, result1 []string, result2 error) { + fake.walletIDsMutex.Lock() + defer fake.walletIDsMutex.Unlock() + fake.WalletIDsStub = nil + if fake.walletIDsReturnsOnCall == nil { + fake.walletIDsReturnsOnCall = make(map[int]struct { + result1 []string + result2 error + }) + } + fake.walletIDsReturnsOnCall[i] = struct { + result1 []string + result2 error + }{result1, result2} +} + +func (fake *Registry) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *Registry) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ wallet.Registry = new(Registry) diff --git a/token/services/identity/wallet/service.go b/token/services/identity/wallet/service.go index d15d13e312..a86b47ad78 100644 --- a/token/services/identity/wallet/service.go +++ b/token/services/identity/wallet/service.go @@ -8,7 +8,6 @@ package wallet import ( "context" - "sync" "github.com/hyperledger-labs/fabric-smart-client/pkg/utils/errors" "github.com/hyperledger-labs/fabric-token-sdk/token/driver" @@ -19,84 +18,82 @@ import ( ) var ( + // ErrNilRecipientData is returned when a nil RecipientData is passed to RegisterRecipientIdentity ErrNilRecipientData = errors.New("nil recipient data") ) +// Registry models an external registry that holds wallets for a given role. +// It is used by the wallet service to lookup and register identities and wallets. +// +//go:generate counterfeiter -o mock/registry.go -fake-name Registry . Registry type Registry interface { WalletIDs(ctx context.Context) ([]string, error) RegisterIdentity(ctx context.Context, config driver.IdentityConfiguration) error - Lookup(ctx context.Context, id driver.WalletLookupID) (driver.Wallet, identity.Info, string, error) - RegisterWallet(ctx context.Context, id string, wallet driver.Wallet) error - BindIdentity(ctx context.Context, identity driver.Identity, eID string, wID string, meta any) error - ContainsIdentity(ctx context.Context, i driver.Identity, id string) bool - GetIdentityMetadata(ctx context.Context, identity driver.Identity, wID string, meta any) error -} - -type walletFactory interface { - NewWallet(ctx context.Context, id string, role identity.RoleType, wr Registry, info identity.Info) (driver.Wallet, error) -} - -type RegistryEntry struct { - Registry Registry - Mutex *sync.RWMutex + WalletByID(ctx context.Context, role identity.RoleType, id driver.WalletLookupID) (driver.Wallet, error) } +// Service exposes wallet-related helper operations used by the token management layer. +// It delegates identity operations to the configured IdentityProvider and uses +// registries for role-specific wallet lookups and registrations. type Service struct { Logger logging.Logger IdentityProvider driver.IdentityProvider Deserializer driver.Deserializer - - WalletFactory walletFactory - Registries map[identity.RoleType]*RegistryEntry + Registries map[identity.RoleType]Registry } +// NewService creates a new wallet Service. func NewService( logger logging.Logger, identityProvider driver.IdentityProvider, deserializer driver.Deserializer, - walletFactory walletFactory, - walletRegistries map[identity.RoleType]Registry, + registries map[identity.RoleType]Registry, ) *Service { - registries := map[identity.RoleType]*RegistryEntry{} - for roleType, registry := range walletRegistries { - registries[roleType] = &RegistryEntry{ - Registry: registry, - Mutex: &sync.RWMutex{}, - } - } return &Service{ Logger: logger, IdentityProvider: identityProvider, Deserializer: deserializer, - WalletFactory: walletFactory, Registries: registries, } } +// RegisterOwnerIdentity registers a long-term owner identity using the owner registry. func (s *Service) RegisterOwnerIdentity(ctx context.Context, config driver.IdentityConfiguration) error { - return s.Registries[identity.OwnerRole].Registry.RegisterIdentity(ctx, config) + return s.Registries[identity.OwnerRole].RegisterIdentity(ctx, config) } +// RegisterIssuerIdentity registers a long-term issuer identity using the issuer registry. func (s *Service) RegisterIssuerIdentity(ctx context.Context, config driver.IdentityConfiguration) error { - return s.Registries[identity.IssuerRole].Registry.RegisterIdentity(ctx, config) + return s.Registries[identity.IssuerRole].RegisterIdentity(ctx, config) } +// GetAuditInfo retrieves audit information for the given identity using the configured IdentityProvider. func (s *Service) GetAuditInfo(ctx context.Context, id driver.Identity) ([]byte, error) { return s.IdentityProvider.GetAuditInfo(ctx, id) } +// GetEnrollmentID extracts the enrollment id from the passed audit information using the IdentityProvider. func (s *Service) GetEnrollmentID(ctx context.Context, identity driver.Identity, auditInfo []byte) (string, error) { return s.IdentityProvider.GetEnrollmentID(ctx, identity, auditInfo) } +// GetRevocationHandle extracts the revocation handle from the passed audit information using the IdentityProvider. func (s *Service) GetRevocationHandle(ctx context.Context, identity driver.Identity, auditInfo []byte) (string, error) { return s.IdentityProvider.GetRevocationHandler(ctx, identity, auditInfo) } +// GetEIDAndRH returns both enrollment ID and revocation handle from audit info via the IdentityProvider. func (s *Service) GetEIDAndRH(ctx context.Context, identity driver.Identity, auditInfo []byte) (string, string, error) { return s.IdentityProvider.GetEIDAndRH(ctx, identity, auditInfo) } +// RegisterRecipientIdentity registers the passed identity as a third-party recipient identity. +// The function performs these steps: +// - validate the input +// - ask the IdentityProvider to register the recipient identity +// - match the identity against the provided audit info using the Deserializer +// - obtain the owner verifier and register it with the IdentityProvider +// - store the recipient data via the IdentityProvider func (s *Service) RegisterRecipientIdentity(ctx context.Context, data *driver.RecipientData) error { if data == nil { return errors.Wrapf(ErrNilRecipientData, "invalid recipient data") @@ -130,6 +127,8 @@ func (s *Service) RegisterRecipientIdentity(ctx context.Context, data *driver.Re return nil } +// Wallet returns a wallet bound to the passed identity. It tries to resolve an owner wallet first +// and then an issuer wallet. It returns nil if no wallet is found. func (s *Service) Wallet(ctx context.Context, identity driver.Identity) driver.Wallet { w, _ := s.OwnerWallet(ctx, identity) if w != nil { @@ -142,92 +141,69 @@ func (s *Service) Wallet(ctx context.Context, identity driver.Identity) driver.W return nil } +// OwnerWalletIDs returns the list of owner wallet identifiers from the owner registry. func (s *Service) OwnerWalletIDs(ctx context.Context) ([]string, error) { - return s.Registries[identity.OwnerRole].Registry.WalletIDs(ctx) + return s.Registries[identity.OwnerRole].WalletIDs(ctx) } +// OwnerWallet returns the OwnerWallet instance bound to the passed lookup id. func (s *Service) OwnerWallet(ctx context.Context, id driver.WalletLookupID) (driver.OwnerWallet, error) { - w, err := s.walletByID(ctx, identity.OwnerRole, id) + w, err := s.Registries[identity.OwnerRole].WalletByID(ctx, identity.OwnerRole, id) if err != nil { return nil, err } return w.(driver.OwnerWallet), nil } +// IssuerWallet returns the IssuerWallet instance bound to the passed lookup id. func (s *Service) IssuerWallet(ctx context.Context, id driver.WalletLookupID) (driver.IssuerWallet, error) { - w, err := s.walletByID(ctx, identity.IssuerRole, id) + w, err := s.Registries[identity.IssuerRole].WalletByID(ctx, identity.IssuerRole, id) if err != nil { return nil, err } return w.(driver.IssuerWallet), nil } +// AuditorWallet returns the AuditorWallet instance bound to the passed lookup id. func (s *Service) AuditorWallet(ctx context.Context, id driver.WalletLookupID) (driver.AuditorWallet, error) { - w, err := s.walletByID(ctx, identity.AuditorRole, id) + w, err := s.Registries[identity.AuditorRole].WalletByID(ctx, identity.AuditorRole, id) if err != nil { return nil, err } return w.(driver.AuditorWallet), nil } +// CertifierWallet returns the CertifierWallet instance bound to the passed lookup id. func (s *Service) CertifierWallet(ctx context.Context, id driver.WalletLookupID) (driver.CertifierWallet, error) { - w, err := s.walletByID(ctx, identity.CertifierRole, id) + w, err := s.Registries[identity.CertifierRole].WalletByID(ctx, identity.CertifierRole, id) if err != nil { return nil, err } return w.(driver.CertifierWallet), nil } -// SpendIDs returns the spend ids for the passed token ids +// SpendIDs returns the spend ids for the passed token ids. +// The current implementation converts token.ID into its string representation. func (s *Service) SpendIDs(ids ...*token.ID) ([]string, error) { - return nil, nil -} - -func (s *Service) walletByID(ctx context.Context, role identity.RoleType, id driver.WalletLookupID) (driver.Wallet, error) { - logger.DebugfContext(ctx, "role [%d] lookup wallet by [%T]", role, id) - defer logger.DebugfContext(ctx, "role [%d] lookup wallet by [%T] done", role, id) - - entry := s.Registries[role] - registry := entry.Registry - mutex := entry.Mutex - - logger.DebugfContext(ctx, "is it in cache?") - - mutex.RLock() - w, _, _, err := registry.Lookup(ctx, id) - if err != nil { - mutex.RUnlock() - logger.DebugfContext(ctx, "failed") - return nil, errors.WithMessagef(err, "failed to lookup identity for owner wallet [%T]", id) - } - if w != nil { - mutex.RUnlock() - logger.DebugfContext(ctx, "yes") - return w, nil - } - mutex.RUnlock() - logger.DebugfContext(ctx, "no") - - mutex.Lock() - defer mutex.Unlock() - - logger.DebugfContext(ctx, "is it in cache before creating") - w, idInfo, wID, err := registry.Lookup(ctx, id) - if err != nil { - return nil, errors.WithMessagef(err, "failed to lookup identity for owner wallet [%T]", id) - } - if w != nil { - return w, nil + if len(ids) == 0 { + return []string{}, nil + } + res := make([]string, 0, len(ids)) + for _, id := range ids { + if id == nil { + // skip nil ids + continue + } + res = append(res, id.String()) } + return res, nil +} - // create the wallet - logger.DebugfContext(ctx, "create wallet") - newWallet, err := s.WalletFactory.NewWallet(ctx, wID, role, registry, idInfo) - if err != nil { - return nil, err - } - if err := registry.RegisterWallet(ctx, wID, newWallet); err != nil { - return nil, err +// Convert converts a map of concrete registries into a map of the Registry interface type. +func Convert[T Registry](s map[identity.RoleType]T) map[identity.RoleType]Registry { + res := make(map[identity.RoleType]Registry, len(s)) + for role, v := range s { + res[role] = v } - return newWallet, nil + return res } diff --git a/token/services/identity/wallet/service_test.go b/token/services/identity/wallet/service_test.go new file mode 100644 index 0000000000..96e04a339a --- /dev/null +++ b/token/services/identity/wallet/service_test.go @@ -0,0 +1,211 @@ +/* +Copyright IBM Corp. All Rights Reserved. + +SPDX-License-Identifier: Apache-2.0 +*/ + +package wallet_test + +import ( + "context" + "errors" + "testing" + + "github.com/hyperledger-labs/fabric-token-sdk/token/driver" + dmock "github.com/hyperledger-labs/fabric-token-sdk/token/driver/mock" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/wallet" + wmock "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/wallet/mock" + "github.com/hyperledger-labs/fabric-token-sdk/token/services/logging" + "github.com/hyperledger-labs/fabric-token-sdk/token/token" + "github.com/stretchr/testify/require" +) + +func TestNewServiceFields(t *testing.T) { + ip := &dmock.IdentityProvider{} + d := &dmock.Deserializer{} + r := map[identity.RoleType]wallet.Registry{} + logger := &logging.MockLogger{} + s := wallet.NewService(logger, ip, d, r) + require.NotNil(t, s) + require.Equal(t, ip, s.IdentityProvider) + require.Equal(t, d, s.Deserializer) + require.Equal(t, r, s.Registries) +} + +func TestRegisterIdentityDelegation(t *testing.T) { + ctx := t.Context() + reg := &wmock.Registry{} + called := false + reg.RegisterIdentityCalls(func(context.Context, driver.IdentityConfiguration) error { + called = true + return nil + }) + s := wallet.NewService(&logging.MockLogger{}, &dmock.IdentityProvider{}, &dmock.Deserializer{}, map[identity.RoleType]wallet.Registry{identity.OwnerRole: reg, identity.IssuerRole: reg}) + require.NoError(t, s.RegisterOwnerIdentity(ctx, driver.IdentityConfiguration{})) + require.True(t, called) + + // test error propagation + errReg := &wmock.Registry{} + errReg.RegisterIdentityReturns(errors.New("boom")) + s2 := wallet.NewService(&logging.MockLogger{}, &dmock.IdentityProvider{}, &dmock.Deserializer{}, map[identity.RoleType]wallet.Registry{identity.OwnerRole: errReg}) + reqErr := s2.RegisterOwnerIdentity(ctx, driver.IdentityConfiguration{}) + require.Error(t, reqErr) +} + +func TestGettersForwarding(t *testing.T) { + ctx := t.Context() + ip := &dmock.IdentityProvider{} + ip.GetAuditInfoReturns([]byte("ai"), nil) + ip.GetEnrollmentIDReturnsOnCall(0, "eid", nil) + ip.GetRevocationHandlerReturnsOnCall(0, "rh", nil) + ip.GetEIDAndRHReturnsOnCall(0, "eid2", "rh2", nil) + + s := wallet.NewService(&logging.MockLogger{}, ip, &dmock.Deserializer{}, nil) + a, err := s.GetAuditInfo(ctx, driver.Identity("id")) + require.NoError(t, err) + require.Equal(t, []byte("ai"), a) + eid, err := s.GetEnrollmentID(ctx, driver.Identity("id"), []byte("ai")) + require.NoError(t, err) + require.Equal(t, "eid", eid) + rh, err := s.GetRevocationHandle(ctx, driver.Identity("id"), []byte("ai")) + require.NoError(t, err) + require.Equal(t, "rh", rh) + eid2, rh2, err := s.GetEIDAndRH(ctx, driver.Identity("id"), []byte("ai")) + require.NoError(t, err) + require.Equal(t, "eid2", eid2) + require.Equal(t, "rh2", rh2) +} + +func TestRegisterRecipientIdentityFailuresAndSuccess(t *testing.T) { + ctx := t.Context() + ip := &dmock.IdentityProvider{} + d := &dmock.Deserializer{} + regSvc := wallet.NewService(&logging.MockLogger{}, ip, d, nil) + + // nil data + err := regSvc.RegisterRecipientIdentity(ctx, nil) + require.Error(t, err) + + // RegisterRecipientIdentity fails + ip.RegisterRecipientIdentityReturns(errors.New("rri")) + err = regSvc.RegisterRecipientIdentity(ctx, &driver.RecipientData{Identity: driver.Identity("id")}) + require.Error(t, err) + ip.RegisterRecipientIdentityReturns(nil) + + // MatchIdentity fails + d.MatchIdentityReturns(errors.New("mismatch")) + err = regSvc.RegisterRecipientIdentity(ctx, &driver.RecipientData{Identity: driver.Identity("id"), AuditInfo: []byte("ai")}) + require.Error(t, err) + d.MatchIdentityReturns(nil) + + // GetOwnerVerifier fails + d.GetOwnerVerifierReturns(nil, errors.New("gver")) + err = regSvc.RegisterRecipientIdentity(ctx, &driver.RecipientData{Identity: driver.Identity("id"), AuditInfo: []byte("ai")}) + require.Error(t, err) + d.GetOwnerVerifierReturns(&dmock.Verifier{}, nil) + + // RegisterVerifier fails + ip.RegisterVerifierReturns(errors.New("rver")) + err = regSvc.RegisterRecipientIdentity(ctx, &driver.RecipientData{Identity: driver.Identity("id"), AuditInfo: []byte("ai")}) + require.Error(t, err) + ip.RegisterVerifierReturns(nil) + + // RegisterRecipientData fails + ip.RegisterRecipientDataReturns(errors.New("rrd")) + err = regSvc.RegisterRecipientIdentity(ctx, &driver.RecipientData{Identity: driver.Identity("id"), AuditInfo: []byte("ai")}) + require.Error(t, err) + ip.RegisterRecipientDataReturns(nil) + + // success + ip.RegisterRecipientIdentityCalls(func(context.Context, driver.Identity) error { return nil }) + d.MatchIdentityCalls(func(context.Context, driver.Identity, []byte) error { return nil }) + d.GetOwnerVerifierCalls(func(context.Context, driver.Identity) (driver.Verifier, error) { return &dmock.Verifier{}, nil }) + ip.RegisterVerifierCalls(func(context.Context, driver.Identity, driver.Verifier) error { return nil }) + ip.RegisterRecipientDataCalls(func(context.Context, *driver.RecipientData) error { return nil }) + + err = regSvc.RegisterRecipientIdentity(ctx, &driver.RecipientData{Identity: driver.Identity("id"), AuditInfo: []byte("ai")}) + require.NoError(t, err) +} + +func TestWalletAndLookupFunctions(t *testing.T) { + ctx := t.Context() + ownerReg := &wmock.Registry{} + issuerReg := &wmock.Registry{} + auditorReg := &wmock.Registry{} + certifierReg := &wmock.Registry{} + s := wallet.NewService( + &logging.MockLogger{}, + &dmock.IdentityProvider{}, + &dmock.Deserializer{}, + map[identity.RoleType]wallet.Registry{ + identity.OwnerRole: ownerReg, + identity.IssuerRole: issuerReg, + identity.AuditorRole: auditorReg, + identity.CertifierRole: certifierReg, + }, + ) + + // OwnerWalletIDs + ownerReg.WalletIDsReturns([]string{"w1", "w2"}, nil) + ids, err := s.OwnerWalletIDs(ctx) + require.NoError(t, err) + require.Equal(t, []string{"w1", "w2"}, ids) + + // OwnerWallet successful cast + ow := &dmock.OwnerWallet{} + ownerReg.WalletByIDReturns(ow, nil) + resOw, err := s.OwnerWallet(ctx, driver.WalletLookupID("id")) + require.NoError(t, err) + require.Equal(t, ow, resOw) + + // IssuerWallet successful cast + iw := &dmock.IssuerWallet{} + issuerReg.WalletByIDReturns(iw, nil) + resIw, err := s.IssuerWallet(ctx, driver.WalletLookupID("id")) + require.NoError(t, err) + require.Equal(t, iw, resIw) + + // AuditorWallet cast + aw := &dmock.AuditorWallet{} + auditorReg.WalletByIDReturns(aw, nil) + resAw, err := s.AuditorWallet(ctx, driver.WalletLookupID("id")) + require.NoError(t, err) + require.Equal(t, aw, resAw) + + // CertifierWallet cast + cw := &dmock.CertifierWallet{} + certifierReg.WalletByIDReturns(cw, nil) + resCw, err := s.CertifierWallet(ctx, driver.WalletLookupID("id")) + require.NoError(t, err) + require.Equal(t, cw, resCw) + + // Wallet prefers owner + ownerReg.WalletByIDReturns(ow, nil) + issuerReg.WalletByIDReturns(iw, nil) + w := s.Wallet(ctx, driver.Identity("id")) + require.Equal(t, driver.Wallet(ow), w) +} + +func TestSpendIDsAndConvert(t *testing.T) { + s := wallet.NewService(&logging.MockLogger{}, &dmock.IdentityProvider{}, &dmock.Deserializer{}, nil) + // SpendIDs empty + res, err := s.SpendIDs() + require.NoError(t, err) + require.Empty(t, res) + + // SpendIDs with nil elements + id1 := &token.ID{TxId: "tx1", Index: 1} + res, err = s.SpendIDs(nil, id1, nil) + require.NoError(t, err) + require.Equal(t, []string{"[tx1:1]"}, res) + + // Convert map + in := map[identity.RoleType]*wmock.Registry{identity.OwnerRole: {}} + out := wallet.Convert[*wmock.Registry](in) + require.Len(t, out, 1) + _, ok := out[identity.OwnerRole] + require.True(t, ok) + // ensure input not mutated + require.NotNil(t, in) +} diff --git a/token/services/identity/wallet/wallets.go b/token/services/identity/wallet/wallets.go deleted file mode 100644 index 24ec5fb963..0000000000 --- a/token/services/identity/wallet/wallets.go +++ /dev/null @@ -1,388 +0,0 @@ -/* -Copyright IBM Corp. All Rights Reserved. - -SPDX-License-Identifier: Apache-2.0 -*/ - -package wallet - -import ( - "context" - - "github.com/hyperledger-labs/fabric-smart-client/pkg/utils/errors" - "github.com/hyperledger-labs/fabric-smart-client/platform/common/utils/collections/iterators" - "github.com/hyperledger-labs/fabric-token-sdk/token/core/common/metrics" - "github.com/hyperledger-labs/fabric-token-sdk/token/driver" - "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity" - "github.com/hyperledger-labs/fabric-token-sdk/token/services/logging" - "github.com/hyperledger-labs/fabric-token-sdk/token/services/utils" - "github.com/hyperledger-labs/fabric-token-sdk/token/token" -) - -type OwnerTokenVault interface { - UnspentTokensIteratorBy(ctx context.Context, id string, tokenType token.Type) (driver.UnspentTokensIterator, error) - Balance(ctx context.Context, id string, tokenType token.Type) (uint64, error) -} - -type AuditorWallet struct { - IdentityProvider driver.IdentityProvider - WalletID string - AuditorIdentity driver.Identity -} - -func NewAuditorWallet(IdentityProvider driver.IdentityProvider, id string, identity driver.Identity) *AuditorWallet { - return &AuditorWallet{ - IdentityProvider: IdentityProvider, - WalletID: id, - AuditorIdentity: identity, - } -} - -func (w *AuditorWallet) ID() string { - return w.WalletID -} - -func (w *AuditorWallet) Contains(ctx context.Context, identity driver.Identity) bool { - return w.AuditorIdentity.Equal(identity) -} - -func (w *AuditorWallet) ContainsToken(ctx context.Context, token *token.UnspentToken) bool { - return w.Contains(ctx, token.Owner) -} - -func (w *AuditorWallet) GetAuditorIdentity() (driver.Identity, error) { - return w.AuditorIdentity, nil -} - -func (w *AuditorWallet) GetSigner(ctx context.Context, identity driver.Identity) (driver.Signer, error) { - if !w.Contains(ctx, identity) { - return nil, errors.Errorf("identity [%s] does not belong to this wallet [%s]", identity, w.ID()) - } - return w.IdentityProvider.GetSigner(ctx, identity) -} - -type IssuerTokenVault interface { - ListHistoryIssuedTokens(context.Context) (*token.IssuedTokens, error) -} - -type IssuerWallet struct { - Logger logging.Logger - IdentityProvider driver.IdentityProvider - TokenVault IssuerTokenVault - WalletID string - IssuerIdentity driver.Identity -} - -func NewIssuerWallet(Logger logging.Logger, IdentityProvider driver.IdentityProvider, TokenVault IssuerTokenVault, id string, identity driver.Identity) *IssuerWallet { - return &IssuerWallet{ - Logger: Logger, - IdentityProvider: IdentityProvider, - TokenVault: TokenVault, - WalletID: id, - IssuerIdentity: identity, - } -} - -func (w *IssuerWallet) ID() string { - return w.WalletID -} - -func (w *IssuerWallet) Contains(ctx context.Context, identity driver.Identity) bool { - return w.IssuerIdentity.Equal(identity) -} - -func (w *IssuerWallet) ContainsToken(ctx context.Context, token *token.UnspentToken) bool { - return w.Contains(ctx, token.Owner) -} - -func (w *IssuerWallet) GetIssuerIdentity(tokenType token.Type) (driver.Identity, error) { - return w.IssuerIdentity, nil -} - -func (w *IssuerWallet) GetSigner(ctx context.Context, identity driver.Identity) (driver.Signer, error) { - if !w.Contains(ctx, identity) { - return nil, errors.Errorf("failed getting signer, the passed identity [%s] does not belong to this wallet [%s]", identity, w.ID()) - } - return w.IdentityProvider.GetSigner(ctx, identity) -} - -func (w *IssuerWallet) HistoryTokens(ctx context.Context, opts *driver.ListTokensOptions) (*token.IssuedTokens, error) { - w.Logger.DebugfContext(ctx, "issuer wallet [%s]: history tokens, type [%d]", w.ID(), opts.TokenType) - source, err := w.TokenVault.ListHistoryIssuedTokens(ctx) - if err != nil { - return nil, errors.Wrap(err, "token selection failed") - } - - unspentTokens := &token.IssuedTokens{} - for _, t := range source.Tokens { - if len(opts.TokenType) != 0 && t.Type != opts.TokenType { - w.Logger.DebugfContext(ctx, "issuer wallet [%s]: discarding token of type [%s]!=[%s]", w.ID(), t.Type, opts.TokenType) - continue - } - - if !w.Contains(ctx, t.Issuer) { - w.Logger.DebugfContext(ctx, "issuer wallet [%s]: discarding token, issuer does not belong to wallet", w.ID()) - continue - } - - w.Logger.DebugfContext(ctx, "issuer wallet [%s]: adding token of type [%s], quantity [%s]", w.ID(), t.Type, t.Quantity) - unspentTokens.Tokens = append(unspentTokens.Tokens, t) - } - w.Logger.DebugfContext(ctx, "issuer wallet [%s]: history tokens done, found [%d] issued tokens", w.ID(), len(unspentTokens.Tokens)) - - return unspentTokens, nil -} - -type CertifierWallet struct { - IdentityProvider driver.IdentityProvider - WalletID string - CertifierIdentity driver.Identity -} - -func NewCertifierWallet(IdentityProvider driver.IdentityProvider, id string, identity driver.Identity) *CertifierWallet { - return &CertifierWallet{ - IdentityProvider: IdentityProvider, - WalletID: id, - CertifierIdentity: identity, - } -} - -func (w *CertifierWallet) ID() string { - return w.WalletID -} - -func (w *CertifierWallet) Contains(ctx context.Context, identity driver.Identity) bool { - return w.CertifierIdentity.Equal(identity) -} - -func (w *CertifierWallet) ContainsToken(ctx context.Context, token *token.UnspentToken) bool { - return w.Contains(ctx, token.Owner) -} - -func (w *CertifierWallet) GetCertifierIdentity() (driver.Identity, error) { - return w.CertifierIdentity, nil -} - -func (w *CertifierWallet) GetSigner(ctx context.Context, identity driver.Identity) (driver.Signer, error) { - if !w.Contains(ctx, identity) { - return nil, errors.Errorf("identity does not belong to this AnonymousOwnerWallet [%s]", identity) - } - return w.IdentityProvider.GetSigner(ctx, identity) -} - -type LongTermOwnerWallet struct { - IdentityProvider driver.IdentityProvider - TokenVault OwnerTokenVault - WalletID string - OwnerIdentityInfo identity.Info - OwnerIdentity driver.Identity - OwnerAuditInfo []byte -} - -func NewLongTermOwnerWallet(ctx context.Context, IdentityProvider driver.IdentityProvider, TokenVault OwnerTokenVault, id string, identityInfo identity.Info) (*LongTermOwnerWallet, error) { - identity, auditInfo, err := identityInfo.Get(ctx) - if err != nil { - return nil, errors.Wrap(err, "failed to get identity info") - } - - return &LongTermOwnerWallet{ - IdentityProvider: IdentityProvider, - TokenVault: TokenVault, - WalletID: id, - OwnerIdentityInfo: identityInfo, - OwnerIdentity: identity, - OwnerAuditInfo: auditInfo, - }, nil -} - -func (w *LongTermOwnerWallet) ID() string { - return w.WalletID -} - -func (w *LongTermOwnerWallet) Contains(ctx context.Context, identity driver.Identity) bool { - return w.OwnerIdentity.Equal(identity) -} - -func (w *LongTermOwnerWallet) ContainsToken(ctx context.Context, token *token.UnspentToken) bool { - return w.Contains(ctx, token.Owner) -} - -func (w *LongTermOwnerWallet) GetRecipientIdentity(context.Context) (driver.Identity, error) { - return w.OwnerIdentity, nil -} - -func (w *LongTermOwnerWallet) GetRecipientData(context.Context) (*driver.RecipientData, error) { - return &driver.RecipientData{ - Identity: w.OwnerIdentity, - AuditInfo: w.OwnerAuditInfo, - }, nil -} - -func (w *LongTermOwnerWallet) GetAuditInfo(ctx context.Context, id driver.Identity) ([]byte, error) { - return w.IdentityProvider.GetAuditInfo(ctx, id) -} - -func (w *LongTermOwnerWallet) GetTokenMetadata(id driver.Identity) ([]byte, error) { - return nil, nil -} - -func (w *LongTermOwnerWallet) GetTokenMetadataAuditInfo(id driver.Identity) ([]byte, error) { - return nil, nil -} - -func (w *LongTermOwnerWallet) GetSigner(ctx context.Context, identity driver.Identity) (driver.Signer, error) { - if !w.Contains(ctx, identity) { - return nil, errors.Errorf("identity [%s] does not belong to this wallet [%s]", identity, w.ID()) - } - return w.IdentityProvider.GetSigner(ctx, identity) -} - -func (w *LongTermOwnerWallet) ListTokens(opts *driver.ListTokensOptions) (*token.UnspentTokens, error) { - it, err := w.TokenVault.UnspentTokensIteratorBy(opts.Context, w.WalletID, opts.TokenType) - if err != nil { - return nil, errors.Wrap(err, "token selection failed") - } - tokens, err := iterators.ReadAllPointers(it) - if err != nil { - return nil, err - } - return &token.UnspentTokens{Tokens: tokens}, nil -} - -func (w *LongTermOwnerWallet) Balance(ctx context.Context, opts *driver.ListTokensOptions) (uint64, error) { - balance, err := w.TokenVault.Balance(ctx, w.WalletID, opts.TokenType) - if err != nil { - return 0, errors.Wrap(err, "token selection failed") - } - return balance, nil -} - -func (w *LongTermOwnerWallet) ListTokensIterator(opts *driver.ListTokensOptions) (driver.UnspentTokensIterator, error) { - it, err := w.TokenVault.UnspentTokensIteratorBy(opts.Context, w.WalletID, opts.TokenType) - if err != nil { - return nil, errors.Wrap(err, "token selection failed") - } - return it, nil -} - -func (w *LongTermOwnerWallet) EnrollmentID() string { - return w.OwnerIdentityInfo.EnrollmentID() -} - -func (w *LongTermOwnerWallet) RegisterRecipient(ctx context.Context, data *driver.RecipientData) error { - // TODO: if identity is equal to the one this wallet is bound to, then we are good. Otherwise return an error - return nil -} - -func (w *LongTermOwnerWallet) Remote() bool { - return w.OwnerIdentityInfo.Remote() -} - -type AnonymousOwnerWallet struct { - *LongTermOwnerWallet - Logger logging.Logger - Deserializer driver.Deserializer - WalletRegistry Registry - IdentityCache *RecipientDataCache -} - -func NewAnonymousOwnerWallet( - logger logging.Logger, - IdentityProvider driver.IdentityProvider, - TokenVault OwnerTokenVault, - Deserializer driver.Deserializer, - walletRegistry Registry, - id string, - identityInfo identity.Info, - cacheSize int, - metricsProvider metrics.Provider, -) (*AnonymousOwnerWallet, error) { - w := &AnonymousOwnerWallet{ - LongTermOwnerWallet: &LongTermOwnerWallet{ - IdentityProvider: IdentityProvider, - TokenVault: TokenVault, - WalletID: id, - OwnerIdentityInfo: identityInfo, - }, - Logger: logger, - WalletRegistry: walletRegistry, - Deserializer: Deserializer, - } - w.IdentityCache = NewRecipientDataCache(logger, w.getRecipientIdentity, cacheSize, NewMetrics(metricsProvider)) - logger.Debugf("added wallet cache for id %s with cache of size %d", id+"@"+identityInfo.EnrollmentID(), cacheSize) - return w, nil -} - -func (w *AnonymousOwnerWallet) Contains(ctx context.Context, identity driver.Identity) bool { - return w.WalletRegistry.ContainsIdentity(ctx, identity, w.WalletID) -} - -// ContainsToken returns true if the passed token is owned by this wallet -func (w *AnonymousOwnerWallet) ContainsToken(ctx context.Context, token *token.UnspentToken) bool { - return w.Contains(ctx, token.Owner) -} - -func (w *AnonymousOwnerWallet) GetRecipientIdentity(ctx context.Context) (driver.Identity, error) { - rd, err := w.IdentityCache.RecipientData(ctx) - if err != nil { - return nil, errors.Wrap(err, "failed to get recipient data") - } - return rd.Identity, nil -} - -func (w *AnonymousOwnerWallet) GetRecipientData(ctx context.Context) (*driver.RecipientData, error) { - return w.IdentityCache.RecipientData(ctx) -} - -func (w *AnonymousOwnerWallet) RegisterRecipient(ctx context.Context, data *driver.RecipientData) error { - if data == nil { - return errors.Wrapf(ErrNilRecipientData, "invalid recipient data") - } - w.Logger.DebugfContext(ctx, "register recipient identity [%s] with audit info [%s]", data.Identity, utils.Hashable(data.AuditInfo)) - - // recognize identity and register it - // match identity and audit info - err := w.Deserializer.MatchIdentity(ctx, data.Identity, data.AuditInfo) - if err != nil { - return errors.Wrapf(err, "failed to match identity to audit infor for [%s]:[%s]", data.Identity, utils.Hashable(data.AuditInfo)) - } - // register verifier and audit info - v, err := w.Deserializer.GetOwnerVerifier(ctx, data.Identity) - if err != nil { - return errors.Wrapf(err, "failed getting verifier for owner [%s]", data.Identity) - } - if err := w.IdentityProvider.RegisterVerifier(ctx, data.Identity, v); err != nil { - return errors.Wrapf(err, "failed registering verifier for owner [%s]", data.Identity) - } - if err := w.IdentityProvider.RegisterRecipientData(ctx, data); err != nil { - return errors.Wrapf(err, "failed registering audit info for owner [%s]", data.Identity) - } - if err := w.WalletRegistry.BindIdentity(ctx, data.Identity, w.EnrollmentID(), w.WalletID, nil); err != nil { - return errors.WithMessagef(err, "failed storing recipient identity in wallet [%s]", w.WalletID) - } - return nil -} - -func (w *AnonymousOwnerWallet) getRecipientIdentity(ctx context.Context) (*driver.RecipientData, error) { - // Get a new pseudonym - pseudonym, auditInfo, err := w.OwnerIdentityInfo.Get(ctx) - if err != nil { - return nil, errors.WithMessagef(err, "failed getting recipient identity from wallet [%s:%s]", w.ID(), w.OwnerIdentityInfo.EnrollmentID()) - } - - // Register the pseudonym - if err := w.WalletRegistry.BindIdentity(ctx, pseudonym, w.OwnerIdentityInfo.EnrollmentID(), w.WalletID, nil); err != nil { - return nil, errors.WithMessagef(err, "failed storing recipient identity in wallet [%s]", w.ID()) - } - return &driver.RecipientData{ - Identity: pseudonym, - AuditInfo: auditInfo, - }, nil -} - -func (w *AnonymousOwnerWallet) GetSigner(ctx context.Context, identity driver.Identity) (driver.Signer, error) { - if !w.Contains(ctx, identity) { - return nil, errors.Errorf("identity [%s] does not belong to this wallet [%s]", identity, w.ID()) - } - return w.IdentityProvider.GetSigner(ctx, identity) -} diff --git a/token/services/logging/logger.go b/token/services/logging/logger.go index d865660641..7249665aa8 100644 --- a/token/services/logging/logger.go +++ b/token/services/logging/logger.go @@ -29,7 +29,7 @@ func GetLogger(params ...string) (Logger, error) { } func DriverLogger(prefix string, networkID string, channel string, namespace string) Logger { - return logging.MustGetLogger(loggerName(prefix, networkID, channel, namespace)) + return MustGetLogger(loggerName(prefix, networkID, channel, namespace)) } func DeriveDriverLogger(logger Logger, prefix string, networkID string, channel string, namespace string) Logger { @@ -37,7 +37,7 @@ func DeriveDriverLogger(logger Logger, prefix string, networkID string, channel } func DriverLoggerFromPP(prefix string, id string) Logger { - return logging.MustGetLogger(loggerName(prefix, id)) + return MustGetLogger(loggerName(prefix, id)) } func isEmptyString(s string) bool { return len(s) == 0 }