fix(ttx): bind before send on recipient views; remove unused isMeCache

Responder flows now call endpoint.Bind before session.Send so a local bind
failure does not leave the peer with RecipientData we never wired locally.

identity.Provider: drop isMeCache/no-cache bookkeeping (always a no-op in
practice). AreMe uses signer cache and storage only; skipping a real cache
avoids incorrect entries for single-use identities (e.g. Idemix nyms).
RegisterRecipientIdentity and RollbackPartialRecipientRegistration on Provider
are documented no-ops for in-memory marks; the wallet rollback hook remains for
other IdentityProvider implementations.

RespondExchangeRecipientIdentitiesView passes TokenMetadataAuditInfo through
RegisterRecipientIdentity for the initiator RecipientData carried in the
exchange request.

Update TTX service diagrams to match ordering.

Signed-off-by: SuyashAlphaC <suyashagrawal862@gmail.com>

Author: SuyashAlphaC

docs/services/ttx.md

@@ -100,21 +100,21 @@ sequenceDiagram
     end
 
     rect rgba(255, 245, 238, 0.5)
-        Note over R: Phase 2 - Responder decision
+        Note over R: Phase 2 - Responder decision and reply
         alt RecipientRequest.RecipientData != nil
             R->>R: Verify wallet contains RecipientData.Identity
-            R-->>I: RecipientData (echo path)
         else RecipientRequest.RecipientData == nil
             R->>R: Generate RecipientData from wallet
-            R-->>I: RecipientData (fresh data path)
         end
+        R->>R: endpoint.Bind(context.Me, RecipientData.Identity)
+        Note over R,I: Bind before send so local resolver wiring fails before the peer receives RecipientData
+        R-->>I: RecipientData (echo or fresh data path)
     end
 
     rect rgba(240, 255, 240, 0.45)
-        Note over I,R: Phase 3 - Local registration and bindings
+        Note over I,R: Phase 3 - Initiator registration and bindings
         I->>I: RegisterRecipientIdentity(RecipientData)
         I->>I: endpoint.Bind(requested FSC identity, RecipientData.Identity)
-        R->>R: endpoint.Bind(context.Me, RecipientData.Identity)
     end
 
     rect rgba(245, 245, 245, 0.55)
@@ -146,14 +146,16 @@ sequenceDiagram
         Note over R: Phase 2 - Responder processing
         R->>R: RegisterRecipientIdentity(request.RecipientData)
         R->>R: GetRecipientData(responder wallet)
+        R->>R: endpoint.Bind(context.Me, responder RecipientData.Identity)
+        R->>R: endpoint.Bind(session caller, request.RecipientData.Identity)
+        Note over R,I: Binds before send so resolver wiring fails before the initiator receives our RecipientData
         R-->>I: RecipientData(responder)
     end
 
     rect rgba(240, 255, 240, 0.45)
-        Note over I,R: Phase 3 - Local registration and bindings
+        Note over I,R: Phase 3 - Initiator registration and bindings
         I->>I: RegisterRecipientIdentity(remote RecipientData)
         I->>I: endpoint.Bind(other FSC identity, remote RecipientData.Identity)
-        R->>R: endpoint.Bind(session caller, request.RecipientData.Identity)
     end
 
     Note over I,R: Full RecipientData on wire today (responder sends local wallet RecipientData)

token/services/identity/provider.go

@@ -9,15 +9,13 @@ package identity
 import (
 	"context"
 	"runtime/debug"
-	"slices"
 
 	"github.com/hyperledger-labs/fabric-smart-client/pkg/utils/errors"
 	"github.com/hyperledger-labs/fabric-smart-client/platform/common/utils/cache/secondcache"
 	"github.com/hyperledger-labs/fabric-smart-client/platform/common/utils/collections"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/driver"
 	idriver "github.com/hyperledger-labs/fabric-token-sdk/token/services/identity/driver"
 	"github.com/hyperledger-labs/fabric-token-sdk/token/services/logging"
-	cache2 "github.com/hyperledger-labs/fabric-token-sdk/token/services/utils/cache"
 	"go.uber.org/zap/zapcore"
 )
 
@@ -87,8 +85,7 @@ type Provider struct {
 	storage                 Storage
 	deserializer            Deserializer
 
-	isMeCache cache[bool]
-	signers   cache[*SignerEntry]
+	signers cache[*SignerEntry]
 }
 
 // NewProvider returns a new instance of Provider
@@ -105,7 +102,6 @@ func NewProvider(
 		enrollmentIDUnmarshaler: enrollmentIDUnmarshaler,
 		deserializer:            deserializer,
 		storage:                 storage,
-		isMeCache:               cache2.NewNoCache[bool](),
 		signers:                 secondcache.NewTyped[*SignerEntry](50),
 	}
 }
@@ -132,32 +128,13 @@ func (p *Provider) RegisterSigner(ctx context.Context, identity driver.Identity,
 }
 
 // AreMe returns the hashes of the passed identities that have a signer registered before.
-// First a local cache is checked, if not found the configured storag is queried.
+// Each identity is resolved via the signer cache and configured storage.
+// There is no secondary "is me" cache: a real cache would need careful handling for
+// single-use identities (for example Idemix nyms) and is intentionally omitted here.
 func (p *Provider) AreMe(ctx context.Context, identities ...driver.Identity) []string {
 	p.Logger.DebugfContext(ctx, "identity [%s] is me?", identities)
 
-	result := make([]string, 0)
-	notFound := make([]driver.Identity, 0)
-
-	for _, id := range identities {
-		uniqueID := id.UniqueID()
-		if isMe, ok := p.isMeCache.Get(uniqueID); !ok {
-			notFound = append(notFound, id)
-		} else if isMe {
-			result = append(result, uniqueID)
-		}
-	}
-	if len(notFound) == 0 {
-		return result
-	}
-
-	found := p.areMe(ctx, notFound...)
-	for _, id := range notFound {
-		uniqueID := id.UniqueID()
-		p.isMeCache.Add(uniqueID, slices.Contains(found, uniqueID))
-	}
-
-	return append(result, found...)
+	return p.areMe(ctx, identities...)
 }
 
 // IsMe returns true if a signer was ever registered for the passed identity
@@ -177,16 +154,11 @@ func (p *Provider) GetAuditInfo(ctx context.Context, identity driver.Identity) (
 // If a signer is not found in cache,
 // this provider tries to construct an instance of driver.Signer that produces valid signatures under that identity.
 func (p *Provider) GetSigner(ctx context.Context, identity driver.Identity) (driver.Signer, error) {
-	found := false
 	idHash := identity.UniqueID()
-	defer func() {
-		p.isMeCache.Add(idHash, found)
-	}()
 	signer, err := p.getSigner(ctx, identity, idHash)
 	if err != nil {
 		return nil, errors.Wrapf(err, "failed to get signer for identity [%s], it is neither register nor deserialazable", identity.String())
 	}
-	found = true
 
 	return signer, nil
 }
@@ -221,19 +193,19 @@ func (p *Provider) Bind(ctx context.Context, longTerm driver.Identity, ephemeral
 	return nil
 }
 
-// RegisterRecipientIdentity register the passed identity as a third-party recipient identity.
+// RegisterRecipientIdentity registers the passed identity as a third-party recipient identity.
+// The wallet layer performs matching and persistence; this provider records nothing here.
 func (p *Provider) RegisterRecipientIdentity(ctx context.Context, id driver.Identity) error {
 	p.Logger.DebugfContext(ctx, "Registering identity [%s]", id)
-	p.isMeCache.Add(id.UniqueID(), false)
 
 	return nil
 }
 
-// RollbackPartialRecipientRegistration clears in-memory marks written by
-// RegisterRecipientIdentity when RegisterRecipientData did not complete.
+// RollbackPartialRecipientRegistration implements RecipientRegistrationRollback.
+// This provider does not keep partial recipient-registration marks in memory;
+// the hook remains for other IdentityProvider implementations.
 func (p *Provider) RollbackPartialRecipientRegistration(ctx context.Context, id driver.Identity) {
-	p.Logger.DebugfContext(ctx, "rolling back partial recipient registration for identity [%s]", id)
-	p.isMeCache.Delete(id.UniqueID())
+	p.Logger.DebugfContext(ctx, "rollback partial recipient registration for identity [%s] (no-op for this provider)", id)
 }
 
 // RegisterIdentityDescriptor stores the given identity descriptor in the configured storage.
@@ -360,9 +332,6 @@ func (p *Provider) updateCaches(descriptor *idriver.IdentityDescriptor, alias dr
 
 	// signers
 	if descriptor.Signer != nil {
-		// if the signer is set, this means that id belongs to this node
-		p.isMeCache.Add(id, true)
-
 		entry := &SignerEntry{Signer: descriptor.Signer}
 		if p.Logger.IsEnabledFor(zapcore.DebugLevel) {
 			entry.DebugStack = debug.Stack()

token/services/ttx/recipients.go

@@ -359,21 +359,21 @@ func (s *RespondRequestRecipientIdentityView) Call(context view.Context) (interf
 		recipientIdentity = recipientData.Identity
 	}
 
-	// Step 3: send the public key back to the invoker
-	logger.DebugfContext(context.Context(), "Send recipient identity response to %s", session.Info().Caller)
-	if err := session.Send(recipientData); err != nil {
-		return nil, errors.Wrapf(err, "failed to send recipient data")
-	}
-
-	// Update the Endpoint Resolver
+	// Update the endpoint resolver before sending so a local bind failure does not
+	// leave the peer with a RecipientData we never successfully wired locally.
 	resolver := endpoint.GetService(context)
 	logger.DebugfContext(context.Context(), "bind me [%s] to [%s]", context.Me(), recipientData)
 
-	err = resolver.Bind(context.Context(), context.Me(), recipientIdentity)
-	if err != nil {
+	if err := resolver.Bind(context.Context(), context.Me(), recipientIdentity); err != nil {
 		return nil, errors.Wrapf(err, "failed to bind me to recipient identity")
 	}
 
+	// Step 3: send the public key back to the invoker
+	logger.DebugfContext(context.Context(), "Send recipient identity response to %s", session.Info().Caller)
+	if err := session.Send(recipientData); err != nil {
+		return nil, errors.Wrapf(err, "failed to send recipient data")
+	}
+
 	if err := s.handleMultisig(context, session.Session(), tms, recipientRequest, recipientIdentity); err != nil {
 		return nil, errors.Wrapf(err, "failed to handle multisig")
 	}
@@ -462,7 +462,7 @@ func (s *RespondRequestRecipientIdentityView) handleMultisig(
 	for i, node := range multisigRecipientData.Nodes {
 		err = resolver.Bind(context.Context(), node, multisigRecipientData.Recipients[i])
 		if err != nil {
-			return errors.Wrapf(err, "failed to bind me to recipient identity")
+			return errors.Wrapf(err, "failed to bind node identity to recipient identity")
 		}
 	}
 
@@ -602,7 +602,10 @@ func (s *RespondExchangeRecipientIdentitiesView) Call(context view.Context) (int
 	}
 	other := request.RecipientData.Identity
 	if err := ts.WalletManager().RegisterRecipientIdentity(context.Context(), &RecipientData{
-		Identity: other, AuditInfo: request.RecipientData.AuditInfo, TokenMetadata: request.RecipientData.TokenMetadata,
+		Identity:               other,
+		AuditInfo:              request.RecipientData.AuditInfo,
+		TokenMetadata:          request.RecipientData.TokenMetadata,
+		TokenMetadataAuditInfo: request.RecipientData.TokenMetadataAuditInfo,
 	}); err != nil {
 		return nil, err
 	}
@@ -622,21 +625,20 @@ func (s *RespondExchangeRecipientIdentitiesView) Call(context view.Context) (int
 		return nil, errors.WithMessagef(err, "failed getting recipient data, wallet [%s]", w.ID())
 	}
 
-	if err := session.Send(recipientData); err != nil {
-		return nil, errors.WithMessagef(err, "failed sending recipient data, wallet [%s]", w.ID())
-	}
-
-	// Update the Endpoint Resolver
+	// Bind locally before sending so a bind failure does not leave the initiator
+	// with our RecipientData while this node never finished resolver wiring.
 	resolver := endpoint.GetService(context)
-	err = resolver.Bind(context.Context(), context.Me(), recipientData.Identity)
-	if err != nil {
+	if err := resolver.Bind(context.Context(), context.Me(), recipientData.Identity); err != nil {
 		return nil, errors.WithMessagef(err, "failed binding recipient data, wallet [%s]", w.ID())
 	}
-	err = resolver.Bind(context.Context(), session.Info().Caller, other)
-	if err != nil {
+	if err := resolver.Bind(context.Context(), session.Info().Caller, other); err != nil {
 		return nil, errors.WithMessagef(err, "failed binding recipient data, wallet [%s]", w.ID())
 	}
 
+	if err := session.Send(recipientData); err != nil {
+		return nil, errors.WithMessagef(err, "failed sending recipient data, wallet [%s]", w.ID())
+	}
+
 	return []token.Identity{recipientData.Identity, other}, nil
 }