perf(benchmark): add benchmarks and documentation for fabtoken

Signed-off-by: Shashank <yshashank959@gmail.com>

fix(multisig,boolpolicy): verify spend tx matches approved SpendRequest (#1691)

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

fsc v0.11.0 (#1702)

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

feat(ttx): add versioned envelope for interactive protocol messages (#1700)

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

fix(recovery): unblock queue head by marking NotFound orphans Deleted after grace period (#1708)

Signed-off-by: Evan <evanyan@sign.global>

fix: cachedFetcher.update() no longer blocks token reads during DB refresh (#1535)

Signed-off-by: Nitesh <nitesh@example.com>
Signed-off-by: Nitesh Kumar <niteshkumar121411@gmail.com>
Signed-off-by: NETIZEN-11 <kumarnitesh979875@gmail.com>

perf(bulletproof): optimize IPA prover with batched MSMs (#1719)

Signed-off-by: Ankit Basu <ankitbasu14@gmail.com>

replace mutex with context aware semaphore (#1616)

Signed-off-by: Hayim.Shaul@ibm.com <hayimsha@fhe3.haifa.ibm.com>

refactor(recovery): return RecoveryClaim from ClaimPendingTransactions (#1715)

Signed-off-by: Evan <evanyan@sign.global>

Adding ZKP Benchmarking to test overhead of FSC nodes on TPS

Signed-off-by: Effi-S <effi.szt@gmail.com>
Signed-off-by: AKRAM@il.ibm.com <akram@akramb.vpc.cloud9.ibm.com>

Fix #1635: Prevent audit lock starvation via defer pattern

- Enhanced Audit() documentation requiring immediate defer Release()
- Fixed integration test callers with proper error handling
- Added unit tests for lock acquisition error handling
- Leverages existing semaphore.Weighted for context-aware acquisition (PR #1616)
- Ensures locks always released via defer, preventing DoS attacks

Signed-off-by: AKRAM@il.ibm.com <akram@akramb.vpc.cloud9.ibm.com>

Author: Rozerxshashank

integration/token/fungible/views/auditor.go

@@ -57,9 +57,11 @@ func (a *AuditView) Call(context view.Context) (interface{}, error) {
 	// extract inputs and outputs
 	logger.Debugf("AuditView: audit [%s]", tx.ID())
 	inputs, outputs, err := auditor.Audit(context.Context(), tx)
-	assert.NoError(err, "failed retrieving inputs and outputs")
-	logger.Debugf("AuditView: audit done [%s]", tx.ID())
+	if err != nil {
+		return nil, errors.Wrapf(err, "failed retrieving inputs and outputs")
+	}
 	defer auditor.Release(context.Context(), tx)
+	logger.Debugf("AuditView: audit done [%s]", tx.ID())
 
 	logger.Debugf("AuditView: [%s] get query executor... ", tx.ID())
 

integration/token/interop/views/auditor.go

@@ -11,6 +11,7 @@ import (
 	"math/big"
 	"time"
 
+	"github.com/hyperledger-labs/fabric-smart-client/pkg/utils/errors"
 	"github.com/hyperledger-labs/fabric-smart-client/platform/common/utils/assert"
 	"github.com/hyperledger-labs/fabric-smart-client/platform/view/view"
 	"github.com/hyperledger-labs/fabric-token-sdk/token"
@@ -40,7 +41,9 @@ func (a *AuditView) Call(context view.Context) (interface{}, error) {
 
 	// extract inputs and outputs
 	inputs, outputs, err := auditor.Audit(context.Context(), tx)
-	assert.NoError(err, "failed retrieving inputs and outputs")
+	if err != nil {
+		return nil, errors.Wrapf(err, "failed retrieving inputs and outputs")
+	}
 	defer auditor.Release(context.Context(), tx)
 
 	// For example, all payments of an amount less than or equal to payment limit is valid

token/services/auditor/auditor.go

@@ -111,8 +111,22 @@ func (a *Service) Validate(ctx context.Context, request *token.Request) error {
 }
 
 // Audit extracts the list of inputs and outputs from the passed transaction.
-// In addition, the Audit locks the enrollment named ids.
-// Release must be invoked in case
+// In addition, Audit acquires locks on the enrollment IDs involved in the transaction.
+// The caller MUST call Release() to unlock these enrollment IDs after processing.
+//
+// IMPORTANT: The defer Release() statement MUST be placed immediately after checking
+// the error returned by Audit(). This ensures locks are released even if subsequent
+// operations fail. Example:
+//
+//	inputs, outputs, err := auditor.Audit(ctx, tx)
+//	if err != nil {
+//	    return errors.Wrap(err, "audit failed")
+//	}
+//	defer auditor.Release(ctx, tx)
+//
+// Note: The semaphore-based locking mechanism handles context cancellation during
+// lock acquisition (see PR #1616), ensuring proper cleanup in case of timeouts or
+// cancellations.
 func (a *Service) Audit(ctx context.Context, tx Transaction) (*token.InputStream, *token.OutputStream, error) {
 	start := time.Now()
 	logger.DebugfContext(ctx, "audit transaction [%s]....", tx.ID())

token/services/auditor/auditor_test.go

@@ -309,6 +309,63 @@ func TestService_Audit_Success(t *testing.T) {
 	assert.NotNil(t, outputs)
 }
 
+// TestService_Audit_LockAcquisitionFailure verifies that when AcquireLocks() fails
+// due to context cancellation, the error is properly returned and no locks are held.
+func TestService_Audit_LockAcquisitionFailure(t *testing.T) {
+	// Create a StoreService with real lock mechanism
+	storeService := newTestStoreService(t, newFakeStore())
+
+	// First, acquire locks directly on enrollment IDs to simulate lock contention
+	ctx := context.Background()
+	err := storeService.AcquireLocks(ctx, "blocking-anchor", "test-eid-1", "test-eid-2")
+	require.NoError(t, err)
+	defer storeService.ReleaseLocks(ctx, "blocking-anchor")
+
+	// Now try to acquire the same locks with a cancelled context
+	cancelledCtx, cancel := context.WithCancel(context.Background())
+	cancel() // Cancel immediately to simulate timeout/cancellation
+
+	err = storeService.AcquireLocks(cancelledCtx, "tx-lock-fail", "test-eid-1", "test-eid-2")
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "context canceled")
+
+	// Verify no locks are held for the failed transaction by checking the anchor is not stored
+	storeService.ReleaseLocks(ctx, "tx-lock-fail") // Should be a no-op since locks weren't acquired
+}
+
+// TestService_Audit_ContextCancellationDuringAcquisition verifies that when context
+// is cancelled or times out during lock acquisition, the semaphore automatically rolls
+// back acquired locks and returns an error, allowing subsequent acquisitions to succeed.
+func TestService_Audit_ContextCancellationDuringAcquisition(t *testing.T) {
+	// Create a StoreService with real lock mechanism
+	storeService := newTestStoreService(t, newFakeStore())
+
+	// Acquire locks to create contention
+	ctx := context.Background()
+	err := storeService.AcquireLocks(ctx, "blocking-anchor", "test-eid-1", "test-eid-2")
+	require.NoError(t, err)
+
+	// Create a context with a very short timeout
+	timeoutCtx, cancel := context.WithTimeout(context.Background(), 1)
+	defer cancel()
+
+	// This should fail due to context timeout while waiting for locks
+	err = storeService.AcquireLocks(timeoutCtx, "tx-ctx-cancel", "test-eid-1", "test-eid-2")
+	require.Error(t, err)
+	assert.True(t, errors.Is(err, context.DeadlineExceeded) || errors.Is(err, context.Canceled),
+		"expected context cancellation error, got: %v", err)
+
+	// Release the blocking locks
+	storeService.ReleaseLocks(ctx, "blocking-anchor")
+
+	// Verify the semaphore automatically rolled back by attempting acquisition with fresh context
+	err = storeService.AcquireLocks(context.Background(), "tx-after-cancel", "test-eid-1", "test-eid-2")
+	require.NoError(t, err)
+
+	// Clean up
+	storeService.ReleaseLocks(ctx, "tx-after-cancel")
+}
+
 func TestService_Audit_DBCleanSuccess(t *testing.T) {
 	fakeStore := newFakeStore()
 	fakeStore.GetStatusReturns(0, "", errors.New("db status err"))

token/services/ttx/auditor.go

@@ -59,6 +59,22 @@ func (a *Auditor) Validate(tx *Transaction) error {
 	return a.Service.Validate(tx.Context, tx.TokenRequest)
 }
 
+// Audit extracts the list of inputs and outputs from the passed transaction.
+// In addition, Audit acquires locks on the enrollment IDs involved in the transaction.
+// The caller MUST call Release() to unlock these enrollment IDs after processing.
+//
+// IMPORTANT: The defer Release() statement MUST be placed immediately after checking
+// the error returned by Audit(). This ensures locks are released even if subsequent
+// operations fail. Example:
+//
+//	inputs, outputs, err := auditor.Audit(ctx, tx)
+//	if err != nil {
+//	    return errors.Wrap(err, "audit failed")
+//	}
+//	defer auditor.Release(ctx, tx)
+//
+// Note: The semaphore-based locking mechanism handles context cancellation during
+// lock acquisition, ensuring proper cleanup in case of timeouts or cancellations.
 func (a *Auditor) Audit(ctx context.Context, tx *Transaction) (*token.InputStream, *token.OutputStream, error) {
 	return a.Service.Audit(ctx, tx)
 }