@bsv/wallet-toolbox-mobile 2.4.1 → 2.4.3

package/out/src/WalletPermissionsManager.js

@@ -91,11 +91,28 @@ 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;
     groupedPermissionFlowTail = new Map();
     pactEstablishedCache = new Map();
+    /**
+     * Parsed BEEF bundles keyed by the raw BEEF array of a `listOutputs`
+     * result, so token scans parse each bundle once instead of once per output.
+     * `null` records a bundle that failed to parse. WeakMap-keyed so entries
+     * are released with their results.
+     */
+    parsedBeefCache = new WeakMap();
+    /** Counts token-field decrypts so long scans can periodically yield. */
+    tokenFieldDecryptCount = 0;
     /** How long a cached permission remains valid (5 minutes). */
     static CACHE_TTL_MS = 5 * 60 * 1000;
     /** Window during which freshly granted permissions are auto-allowed (except spending). */
@@ -382,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);
         }
     }
     /**
@@ -417,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);
     }
@@ -664,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);
@@ -704,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) {
@@ -753,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, 
@@ -807,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);
@@ -1016,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) => {
@@ -1571,7 +1613,45 @@ class WalletPermissionsManager {
         }, this.adminOriginator);
         return ciphertext;
     }
+    /**
+     * Extracts a transaction from a `listOutputs` result's BEEF bundle, parsing
+     * the bundle only once per result. Calling
+     * `Transaction.fromBEEF(result.BEEF, txid)` per output re-parses the entire
+     * bundle every time — O(n²) in the number of outputs — which can block the
+     * caller's thread (in browser wallets, the UI) for seconds on large
+     * permission baskets.
+     */
+    transactionFromResultBeef(result, txid) {
+        const beef = result.BEEF;
+        if (beef != null) {
+            let parsed = this.parsedBeefCache.get(beef);
+            if (parsed === undefined) {
+                try {
+                    parsed = sdk_1.Beef.fromBinary(beef);
+                }
+                catch {
+                    parsed = null;
+                }
+                this.parsedBeefCache.set(beef, parsed);
+            }
+            // findAtomicTransaction (not findTxid().tx) matches fromBEEF exactly:
+            // it attaches merkle paths and sourceTransaction ancestry, which token
+            // consumers rely on when re-serializing via tx.toBEEF().
+            const tx = parsed?.findAtomicTransaction(txid);
+            if (tx != null)
+                return tx;
+        }
+        // Preserve the original behavior (including throwing) for bundles the
+        // fast path can't serve.
+        return sdk_1.Transaction.fromBEEF(beef ?? [], txid);
+    }
     async decryptPermissionTokenField(ciphertext) {
+        // Field decrypts run in tight loops over every token in a basket; yield a
+        // macrotask periodically so large scans don't starve the caller's event
+        // loop (in browser wallets, that means blocking rendering and input).
+        if (++this.tokenFieldDecryptCount % 8 === 0) {
+            await new Promise(resolve => setTimeout(resolve, 0));
+        }
         try {
             const { plaintext } = await this.underlying.decrypt({
                 ciphertext,
@@ -1715,7 +1795,7 @@ class WalletPermissionsManager {
             }, this.adminOriginator);
             for (const out of result.outputs) {
                 const [txid, outputIndex] = this.parseOutpoint(out.outpoint);
-                const tx = sdk_1.Transaction.fromBEEF(result.BEEF, txid);
+                const tx = this.transactionFromResultBeef(result, txid);
                 const dec = sdk_1.PushDrop.decode(tx.outputs[outputIndex].lockingScript);
                 if (dec?.fields == null || dec.fields.length < 6)
                     continue;
@@ -1774,7 +1854,7 @@ class WalletPermissionsManager {
                 if (seen.has(out.outpoint))
                     continue;
                 const [txid, vout] = this.parseOutpoint(out.outpoint);
-                const tx = sdk_1.Transaction.fromBEEF(result.BEEF, txid);
+                const tx = this.transactionFromResultBeef(result, txid);
                 const dec = sdk_1.PushDrop.decode(tx.outputs[vout].lockingScript);
                 if (dec?.fields == null || dec.fields.length < 6)
                     continue;
@@ -1818,7 +1898,7 @@ class WalletPermissionsManager {
             }, this.adminOriginator);
             for (const out of result.outputs) {
                 const [txid, outputIndex] = this.parseOutpoint(out.outpoint);
-                const tx = sdk_1.Transaction.fromBEEF(result.BEEF, txid);
+                const tx = this.transactionFromResultBeef(result, txid);
                 const dec = sdk_1.PushDrop.decode(tx.outputs[outputIndex].lockingScript);
                 if (!dec?.fields || dec.fields.length < 3)
                     continue;
@@ -1858,7 +1938,7 @@ class WalletPermissionsManager {
             }, this.adminOriginator);
             for (const out of result.outputs) {
                 const [txid, outputIndex] = this.parseOutpoint(out.outpoint);
-                const tx = sdk_1.Transaction.fromBEEF(result.BEEF, txid);
+                const tx = this.transactionFromResultBeef(result, txid);
                 const dec = sdk_1.PushDrop.decode(tx.outputs[outputIndex].lockingScript);
                 if (!dec?.fields || dec.fields.length < 6)
                     continue;
@@ -1909,7 +1989,7 @@ class WalletPermissionsManager {
             }, this.adminOriginator);
             for (const out of result.outputs) {
                 const [txid, outputIndexStr] = out.outpoint.split('.');
-                const tx = sdk_1.Transaction.fromBEEF(result.BEEF, txid);
+                const tx = this.transactionFromResultBeef(result, txid);
                 const dec = sdk_1.PushDrop.decode(tx.outputs[Number(outputIndexStr)].lockingScript);
                 if (!dec?.fields || dec.fields.length < 2)
                     continue;
@@ -2366,7 +2446,7 @@ class WalletPermissionsManager {
             if (seen.has(out.outpoint))
                 continue;
             const [txid, outputIndex] = this.parseOutpoint(out.outpoint);
-            const tx = sdk_1.Transaction.fromBEEF(result.BEEF, txid);
+            const tx = this.transactionFromResultBeef(result, txid);
             const dec = sdk_1.PushDrop.decode(tx.outputs[outputIndex].lockingScript);
             if (!dec?.fields || dec.fields.length < 6)
                 continue;
@@ -2434,7 +2514,7 @@ class WalletPermissionsManager {
                 if (seen.has(out.outpoint))
                     continue;
                 const [txid, outputIndex] = this.parseOutpoint(out.outpoint);
-                const tx = sdk_1.Transaction.fromBEEF(result.BEEF, txid);
+                const tx = this.transactionFromResultBeef(result, txid);
                 const dec = sdk_1.PushDrop.decode(tx.outputs[outputIndex].lockingScript);
                 if (!dec?.fields || dec.fields.length < 3)
                     continue;
@@ -2497,7 +2577,7 @@ class WalletPermissionsManager {
         const tokens = [];
         for (const out of result.outputs) {
             const [txid, outputIndexStr] = out.outpoint.split('.');
-            const tx = sdk_1.Transaction.fromBEEF(result.BEEF, txid);
+            const tx = this.transactionFromResultBeef(result, txid);
             const dec = sdk_1.PushDrop.decode(tx.outputs[Number(outputIndexStr)].lockingScript);
             if (!dec?.fields || dec.fields.length < 2)
                 continue;
@@ -2568,7 +2648,7 @@ class WalletPermissionsManager {
             if (seen.has(out.outpoint))
                 continue;
             const [txid, outputIndex] = this.parseOutpoint(out.outpoint);
-            const tx = sdk_1.Transaction.fromBEEF(result.BEEF, txid);
+            const tx = this.transactionFromResultBeef(result, txid);
             const dec = sdk_1.PushDrop.decode(tx.outputs[outputIndex].lockingScript);
             if (!dec?.fields || dec.fields.length < 6)
                 continue;
@@ -3506,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.