@bsv/wallet-toolbox-mobile 2.4.2 → 2.4.4

package/out/src/WalletPermissionsManager.js

@@ -91,6 +91,14 @@ class WalletPermissionsManager {
     /** Cache recently confirmed permissions to avoid repeated lookups. */
     permissionCache = new Map();
     recentGrants = new Map();
+    /**
+     * Token mints currently being written on-chain, keyed by permission cache
+     * key. A granted permission is only cached once its token finishes minting
+     * (network seconds); ensures arriving in that window await the in-flight
+     * mint instead of re-prompting the user for a permission they just granted.
+     * Stored promises never reject.
+     */
+    mintsInFlight = new Map();
     manifestCache = new Map();
     manifestFetchInProgress = new Map();
     static MANIFEST_CACHE_TTL_MS = 5 * 60 * 1000;
@@ -391,26 +399,45 @@ class WalletPermissionsManager {
         }
         this.activeRequests.delete(params.requestID);
         // 3) If `ephemeral !== true`, we create or renew an on-chain token
-        if (!params.ephemeral) {
-            const request = matching.request;
-            if (request.renewal) {
-                // renewal => spend the old token, produce a new one
-                await this.renewPermissionOnChain(request.previousToken, request, params.expiry || 0, // default: never expires
-                params.amount);
-            }
-            else {
-                // brand-new permission token
-                await this.createPermissionOnChain(request, params.expiry || 0, // default: never expires
-                params.amount);
-            }
-        }
         // Only cache non-ephemeral permissions
         // Ephemeral permissions should not be cached as they are one-time authorizations
         if (!params.ephemeral) {
+            const request = matching.request;
             const expiry = params.expiry || 0; // default: never expires
-            const key = this.buildRequestKey(matching.request);
+            const key = this.buildRequestKey(request);
+            // Several first-contact prompts for the same permission can stack up
+            // before any token exists (e.g. one per usage type). Granting them all
+            // should yield ONE token: if an identical non-renewal grant just minted
+            // (or is minting), don't mint a duplicate. Spending authorizations are
+            // excluded — their tokens carry amounts, so every grant is honored.
+            let skipDuplicateMint = !request.renewal &&
+                request.type !== 'spending' &&
+                (this.isPermissionCached(key) || this.isRecentlyGranted(key) || this.mintsInFlight.has(key));
+            if (skipDuplicateMint) {
+                const inFlight = this.mintsInFlight.get(key);
+                if (inFlight != null) {
+                    await inFlight;
+                    // The awaited mint may have failed; only skip if it landed.
+                    skipDuplicateMint = this.isPermissionCached(key) || this.isRecentlyGranted(key);
+                }
+            }
+            if (!skipDuplicateMint) {
+                const mint = request.renewal
+                    ? this.renewPermissionOnChain(request.previousToken, request, expiry, params.amount)
+                    : this.createPermissionOnChain(request, expiry, params.amount);
+                // Publish the in-flight mint so concurrent ensures for the same
+                // permission wait for it instead of re-prompting (stored promise
+                // never rejects; failures still propagate to this caller below).
+                this.mintsInFlight.set(key, mint.then(() => { }, () => { }));
+                try {
+                    await mint;
+                }
+                finally {
+                    this.mintsInFlight.delete(key);
+                }
+            }
             this.cachePermission(key, expiry);
-            this.markRecentGrant(matching.request);
+            this.markRecentGrant(request);
         }
     }
     /**
@@ -426,8 +453,12 @@ class WalletPermissionsManager {
             throw new Error('Request ID not found.');
         }
         // 2) Reject all matching requests, deleting the entry
+        // Denials carry the canonical machine-readable code so applications can
+        // distinguish user denial from other failures (matches denyActiveRequest).
+        const err = new Error('Permission denied.');
+        err.code = 'ERR_PERMISSION_DENIED';
         for (const x of matching.pending) {
-            x.reject(new Error('Permission denied.'));
+            x.reject(err);
         }
         this.activeRequests.delete(requestID);
     }
@@ -673,7 +704,7 @@ class WalletPermissionsManager {
         if (!privileged && this.isWhitelistedCounterpartyProtocol(counterparty, protocolID))
             return true;
         const cacheKey = this.buildRequestKey({ type: 'protocol', originator, privileged, protocolID, counterparty });
-        if (this.isPermissionCached(cacheKey) || this.isRecentlyGranted(cacheKey))
+        if (await this.hasRecentOrPendingGrant(cacheKey))
             return true;
         // 4) Attempt to find a valid token in the internal basket
         const token = await this.findProtocolToken(originator, privileged, protocolID, counterparty, /* includeExpired= */ true, lookupValues);
@@ -713,7 +744,7 @@ class WalletPermissionsManager {
         if (!this.isBasketUsageRequired(usageType))
             return true;
         const cacheKey = this.buildRequestKey({ type: 'basket', originator, basket });
-        if (this.isPermissionCached(cacheKey) || this.isRecentlyGranted(cacheKey))
+        if (await this.hasRecentOrPendingGrant(cacheKey))
             return true;
         const token = await this.findBasketToken(originator, basket, true, lookupValues);
         if (token == null) {
@@ -762,10 +793,7 @@ class WalletPermissionsManager {
             privileged,
             certificate: { verifier, certType, fields }
         });
-        if (this.isPermissionCached(cacheKey)) {
-            return true;
-        }
-        if (this.isRecentlyGranted(cacheKey)) {
+        if (await this.hasRecentOrPendingGrant(cacheKey)) {
             return true;
         }
         const token = await this.findCertificateToken(originator, privileged, verifier, certType, fields, 
@@ -816,7 +844,10 @@ class WalletPermissionsManager {
             return true;
         }
         const cacheKey = this.buildRequestKey({ type: 'spending', originator, spending: { satoshis } });
-        if (this.isPermissionCached(cacheKey)) {
+        // Spending keys are amount-scoped. The recent-grant window this adds sits
+        // inside the pre-existing permissionCache window grantPermission already
+        // wrote for spending, so accounting exposure is unchanged.
+        if (await this.hasRecentOrPendingGrant(cacheKey)) {
             return true;
         }
         const token = await this.findSpendingToken(originator, lookupValues);
@@ -1025,11 +1056,13 @@ class WalletPermissionsManager {
             (async () => {
                 if (groupPermissions.spendingAuthorization == null)
                     return undefined;
-                const hasAuth = await this.hasSpendingAuthorization({
-                    originator,
-                    satoshis: groupPermissions.spendingAuthorization.amount
-                });
-                return hasAuth ? undefined : groupPermissions.spendingAuthorization;
+                // A standing authorization is a grant regardless of how much of the
+                // monthly allowance has been used — exhaustion is handled by renewal
+                // at spend time. Checking remaining headroom here re-requests (and,
+                // if approved, re-mints) spending after any monthly usage.
+                const { normalized, lookupValues } = this.prepareOriginator(originator);
+                const token = await this.findSpendingToken(normalized, lookupValues);
+                return token != null ? undefined : groupPermissions.spendingAuthorization;
             })(),
             (async () => {
                 const protocolChecks = await Promise.all((groupPermissions.protocolPermissions || []).map(async (p) => {
@@ -3553,6 +3586,21 @@ class WalletPermissionsManager {
             return true;
         return false;
     }
+    /**
+     * Whether the permission is satisfied without consulting on-chain tokens:
+     * cached, recently granted, or — when the user just granted it and its
+     * token is still minting — after the in-flight mint settles. Spares the
+     * user a duplicate prompt for a grant they already made moments ago.
+     */
+    async hasRecentOrPendingGrant(cacheKey) {
+        if (this.isPermissionCached(cacheKey) || this.isRecentlyGranted(cacheKey))
+            return true;
+        const inFlight = this.mintsInFlight.get(cacheKey);
+        if (inFlight == null)
+            return false;
+        await inFlight;
+        return this.isPermissionCached(cacheKey) || this.isRecentlyGranted(cacheKey);
+    }
     /**
      * Returns true if we have a cached record that the permission identified by
      * `key` is valid and unexpired.