@bopen-io/wallet-toolbox 2.6.2-brc153.5 → 2.14.5

package/out/src/WalletPermissionsManager.js

@@ -1,8 +1,94 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WalletPermissionsManager = void 0;
+const validationHelpers_1 = require("@bsv/sdk/wallet/validationHelpers");
 const sdk_1 = require("@bsv/sdk");
+const utils_1 = require("@bsv/sdk/primitives/utils");
 const brc114ActionTimeLabels_1 = require("./utility/brc114ActionTimeLabels");
+const brc177NoSendExpiry_1 = require("./utility/brc177NoSendExpiry");
+const exactActionSpend_1 = require("./utility/exactActionSpend");
+const WERR_errors_1 = require("./sdk/WERR_errors");
+// Imported from the leaf module directly (not generateChange.ts, which
+// transitively imports StorageProvider.ts and the full signer/create-action
+// module graph) to avoid an unrelated circular-import edge from this file.
+const maxPossibleSatoshis_1 = require("./storage/methods/maxPossibleSatoshis");
+const MAX_PERMISSION_TOKEN_FIELD_BYTES = 1024 * 1024;
+const MAX_PERMISSION_TOKEN_PAYLOAD_BYTES = 4 * 1024 * 1024;
+const MAX_PERMISSION_TOKEN_LIST_FIELDS = 256;
+const MAX_MONEY_SATOSHIS = 21e14;
+function parseCanonicalPermissionInteger(value, label, maximum = Number.MAX_SAFE_INTEGER) {
+    if (!/^(?:0|[1-9]\d*)$/.test(value))
+        throw new Error(`${label} is not a canonical non-negative integer.`);
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed) || parsed > maximum) {
+        throw new Error(`${label} is outside the supported range.`);
+    }
+    return parsed;
+}
+function parsePermissionBoolean(value, label) {
+    if (value !== 'true' && value !== 'false')
+        throw new Error(`${label} must be true or false.`);
+    return value === 'true';
+}
+function parsePermissionCertificateFields(value) {
+    const parsed = JSON.parse(value);
+    if (!Array.isArray(parsed) || parsed.length > MAX_PERMISSION_TOKEN_LIST_FIELDS) {
+        throw new Error('Permission certificate fields must be a bounded array.');
+    }
+    const fields = [];
+    const seen = new Set();
+    for (const field of parsed) {
+        if (typeof field !== 'string' ||
+            field.length === 0 ||
+            new TextEncoder().encode(field).length >= 50 ||
+            seen.has(field)) {
+            throw new Error('Permission certificate fields are invalid.');
+        }
+        seen.add(field);
+        fields.push(field);
+    }
+    return fields;
+}
+function brc177PreflightSatoshis(args) {
+    const outputs = args.outputs ?? [];
+    let total = 0;
+    for (const output of outputs) {
+        if (typeof output.satoshis !== 'number' || !Number.isSafeInteger(output.satoshis) || output.satoshis < 0) {
+            throw new Error('BRC-177 outputs must contain valid satoshi amounts');
+        }
+        // A sendMax output is requested with the `maxPossibleSatoshis` sentinel
+        // (see storage/methods/generateChange); its real cost is unknowable until
+        // storage funds the transaction, so it cannot contribute a meaningful
+        // amount to this pre-funding estimate. The real amount is still gated by
+        // the post-funding spend check in createAction (computeNetSpend) once it
+        // is known.
+        if (output.satoshis === maxPossibleSatoshis_1.maxPossibleSatoshis)
+            continue;
+        total += output.satoshis;
+        if (!Number.isSafeInteger(total))
+            throw new Error('BRC-177 output amount exceeds the safely supported range');
+    }
+    // Even an action funded entirely by caller-supplied inputs incurs a wallet
+    // prefunding fee. Require a spending grant before that fee can be broadcast.
+    return Math.max(1, total);
+}
+function validateBrc177CreateActionShape(args) {
+    const request = args;
+    if (!Array.isArray(request.outputs) || request.outputs.length === 0) {
+        throw new Error('BRC-177 protected actions require at least one output');
+    }
+    if (request.options?.noSend !== true)
+        throw new Error('BRC-177 protected actions require noSend');
+    if ((request.options.sendWith?.length ?? 0) > 0) {
+        throw new Error('BRC-177 protected actions cannot use sendWith');
+    }
+    if ((request.options.noSendChange?.length ?? 0) > 0) {
+        throw new Error('BRC-177 protected actions cannot supply noSendChange');
+    }
+    if (request.options.returnTXIDOnly === true) {
+        throw new Error('BRC-177 protected actions cannot use returnTXIDOnly');
+    }
+}
 // Security invariant: only the configured admin originator bypasses permission
 // prompts. Admin-reserved protocols, baskets, and labels are rejected for all
 // other originators; counterparty bypasses require an explicit configuration
@@ -61,6 +147,16 @@ const BASKET_MAP = {
  *  - Token revocation or renewal uses standard BRC-100 flows: we build a transaction that consumes
  *    the old token UTXO and outputs a new one (or none, if fully revoked).
  */
+/**
+ * Signing changes the txid, so change outpoints the signable createAction
+ * result named (by the unsigned txid) are moved onto the signed transaction.
+ * Signing never reorders outputs, so each vout stays the same.
+ */
+function noSendChangeOnSignedTransaction(noSendChange, signedTxid) {
+    if (noSendChange === undefined || signedTxid === undefined)
+        return noSendChange;
+    return noSendChange.map(outpoint => `${signedTxid}.${outpoint.slice(outpoint.lastIndexOf('.') + 1)}`);
+}
 class WalletPermissionsManager {
     /** A reference to the BRC-100 wallet instance. */
     underlying;
@@ -92,6 +188,23 @@ class WalletPermissionsManager {
     /** Cache recently confirmed permissions to avoid repeated lookups. */
     permissionCache = new Map();
     recentGrants = new Map();
+    /** Originator binding for partial actions issued through this manager. */
+    pendingActionOriginators = new Map();
+    /** Exact authorized transaction template for each pending action. */
+    pendingActionTemplates = new Map();
+    /** References that failed authorization and could not be conclusively aborted. */
+    blockedActionReferences = new Set();
+    /** Pending references whose action was created with `noSend`. */
+    pendingNoSendReferences = new Set();
+    /**
+     * Originator binding for signed no-send actions, keyed by lowercase txid.
+     * Signing drops the pending reference, so without this a non-admin caller
+     * could not release the action it created.
+     */
+    noSendActions = new Map();
+    /** Reference a caller signed a no-send action under, to that action's txid key. */
+    noSendActionReferences = new Map();
+    permissionTokenLockingKeyPromise;
     /**
      * Token mints currently being written on-chain, keyed by permission cache
      * key. A granted permission is only cached once its token finishes minting
@@ -100,9 +213,18 @@ class WalletPermissionsManager {
      * Stored promises never reject.
      */
     mintsInFlight = new Map();
+    /**
+     * Monotonic nonce used to keep spending prompts one-to-one with the wallet
+     * operations they authorize. Unlike capability permissions, spending
+     * requests must never share a pending approval merely because their amounts
+     * happen to match.
+     */
+    spendingRequestSequence = 0;
     manifestCache = new Map();
     manifestFetchInProgress = new Map();
     static MANIFEST_CACHE_TTL_MS = 5 * 60 * 1000;
+    static MANIFEST_MAX_BYTES = 256 * 1024;
+    static MANIFEST_TIMEOUT_MS = 10_000;
     groupedPermissionFlowTail = new Map();
     pactEstablishedCache = new Map();
     /**
@@ -118,11 +240,6 @@ class WalletPermissionsManager {
     static CACHE_TTL_MS = 5 * 60 * 1000;
     /** Window during which freshly granted permissions are auto-allowed (except spending). */
     static RECENT_GRANT_COVER_MS = 15 * 1000;
-    /** Default ports used when normalizing originator values. */
-    static DEFAULT_PORTS = {
-        'http:': '80',
-        'https:': '443'
-    };
     /**
      * Configuration that determines whether to skip or apply various checks and encryption.
      */
@@ -162,7 +279,41 @@ class WalletPermissionsManager {
             seekGroupedPermission: true,
             differentiatePrivilegedOperations: true,
             whitelistedCounterparties: {},
-            ...config // override with user-specified config
+            ...config,
+            permissionModules: {
+                ...config.permissionModules,
+                // BRC-177 is a built-in reserved BRC-111 module in every Toolbox wallet.
+                nosend: {
+                    onRequest: async (req) => {
+                        const labels = req.args.labels;
+                        (0, brc177NoSendExpiry_1.parseBrc177NoSendExpiryLabels)(labels);
+                        if (req.method !== 'createAction' && req.method !== 'listActions') {
+                            throw new Error('BRC-177 noSend expiry labels are only valid for createAction and listActions');
+                        }
+                        if (req.method === 'createAction')
+                            validateBrc177CreateActionShape(req.args);
+                        // Prefunding has a real miner fee, so authorize use of this
+                        // module before the underlying wallet can broadcast it. This is
+                        // deliberately separate from the later amount-specific spend
+                        // authorization for the protected transaction.
+                        await this.ensureLabelAccess({
+                            originator: req.originator,
+                            label: 'BRC-177 noSend expiry',
+                            reason: req.method,
+                            usageType: req.method === 'createAction' ? 'apply' : 'list'
+                        });
+                        if (req.method === 'createAction') {
+                            await this.ensureSpendingAuthorization({
+                                originator: req.originator,
+                                satoshis: brc177PreflightSatoshis(req.args),
+                                reason: 'BRC-177 protected action prefunding'
+                            });
+                        }
+                        return { args: req.args };
+                    },
+                    onResponse: async (res) => res
+                }
+            }
         };
     }
     /* ---------------------------------------------------------------------
@@ -189,12 +340,19 @@ class WalletPermissionsManager {
         if (module == null) {
             throw new Error(`Unsupported P-module scheme: p ${schemeID}`);
         }
+        const request = { method, args, originator };
+        if (module.handleRequest != null) {
+            let nextCalled = false;
+            return (await module.handleRequest(request, async (transformedArgs) => {
+                if (nextCalled) {
+                    throw new Error(`P-module p ${schemeID} called its underlying wallet operation more than once`);
+                }
+                nextCalled = true;
+                return await underlyingCall(transformedArgs, originator);
+            }));
+        }
         // Transform request with module
-        const transformedReq = await module.onRequest({
-            method,
-            args,
-            originator
-        });
+        const transformedReq = await module.onRequest(request);
         // Call underlying method with transformed request
         const results = await underlyingCall(transformedReq.args, originator);
         // Transform response with module
@@ -393,6 +551,43 @@ class WalletPermissionsManager {
     /* ---------------------------------------------------------------------
      *  2) PERMISSION (GRANT / DENY) METHODS
      * --------------------------------------------------------------------- */
+    async grantPersistentPermission(request, expiry, amount) {
+        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, amount)
+                : this.createPermissionOnChain(request, expiry, 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);
+            }
+        }
+        if (request.type !== 'spending')
+            this.cachePermission(key, expiry);
+        this.markRecentGrant(request);
+    }
     /**
      * Grants a previously requested permission.
      * This method:
@@ -413,47 +608,10 @@ class WalletPermissionsManager {
             x.resolve(true);
         }
         this.activeRequests.delete(params.requestID);
-        // 3) If `ephemeral !== true`, we create or renew an on-chain token
-        // 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(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(request);
-        }
+        // 3) Ephemeral permissions are one-time authorizations and never persist.
+        if (params.ephemeral)
+            return;
+        await this.grantPersistentPermission(matching.request, params.expiry || 0, params.amount);
     }
     /**
      * Denies a previously requested permission.
@@ -552,27 +710,18 @@ class WalletPermissionsManager {
                     expiry
                 });
             }
-            const created = await this.createPermissionTokensBestEffort(toCreate);
-            const renewed = await this.renewPermissionTokensBestEffort(toRenew);
-            for (const req of [...created, ...renewed]) {
-                this.markRecentGrant(req);
-            }
-            // Success - resolve all pending promises for this request
-            for (const p of matching.pending) {
-                p.resolve(true);
-            }
+            // A user-visible grouped grant is atomic from the caller's perspective:
+            // never resolve the waiting wallet call if one of the requested tokens
+            // failed to persist. The best-effort helpers intentionally suppress
+            // singleton failures and are therefore only suitable for maintenance
+            // operations where a partial result is explicitly returned.
+            await this.persistPermissionGrant(toCreate, toRenew);
+            this.settleActiveGrant(params.requestID, matching, 'resolve', true);
         }
         catch (error) {
-            // Failure - reject all pending promises so callers don't hang forever
-            for (const p of matching.pending) {
-                p.reject(error);
-            }
+            this.settleActiveGrant(params.requestID, matching, 'reject', error);
             throw error;
         }
-        finally {
-            // Always clean up the request entry
-            this.activeRequests.delete(params.requestID);
-        }
     }
     /**
      * Denies a previously requested grouped permission.
@@ -608,6 +757,17 @@ class WalletPermissionsManager {
         }
         this.activeRequests.delete(requestID);
     }
+    settleActiveGrant(requestID, matching, method, value) {
+        for (const pending of matching.pending)
+            pending[method](value);
+        this.activeRequests.delete(requestID);
+    }
+    async persistPermissionGrant(toCreate, toRenew) {
+        const created = await this.createPermissionTokensBestEffort(toCreate, true);
+        const renewed = await this.renewPermissionTokensBestEffort(toRenew, true);
+        for (const request of [...created, ...renewed])
+            this.markRecentGrant(request);
+    }
     async denyGroupedPermission(requestID) {
         this.denyActiveRequest(requestID);
     }
@@ -675,15 +835,14 @@ class WalletPermissionsManager {
                 toRenew.push({ oldToken: token, request, expiry });
             }
         }
-        const created = await this.createPermissionTokensBestEffort(toCreate);
-        const renewed = await this.renewPermissionTokensBestEffort(toRenew);
-        for (const req of [...created, ...renewed]) {
-            this.markRecentGrant(req);
+        try {
+            await this.persistPermissionGrant(toCreate, toRenew);
+            this.settleActiveGrant(params.requestID, matching, 'resolve', true);
         }
-        for (const p of matching.pending) {
-            p.resolve(true);
+        catch (error) {
+            this.settleActiveGrant(params.requestID, matching, 'reject', error);
+            throw error;
         }
-        this.activeRequests.delete(params.requestID);
     }
     async denyCounterpartyPermission(requestID) {
         this.denyActiveRequest(requestID);
@@ -879,19 +1038,11 @@ class WalletPermissionsManager {
             // We skip spending permission entirely
             return true;
         }
-        const cacheKey = this.buildRequestKey({ type: 'spending', originator, spending: { satoshis } });
-        // 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);
         if (token?.authorizedAmount) {
             // Check how much has been spent so far
             const spentSoFar = await this.querySpentSince(token);
             if (spentSoFar + satoshis <= token.authorizedAmount) {
-                this.cachePermission(cacheKey, token.expiry);
                 return true;
             }
             else {
@@ -1046,11 +1197,22 @@ class WalletPermissionsManager {
             return await inProgress;
         }
         const fetchPromise = (async () => {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), WalletPermissionsManager.MANIFEST_TIMEOUT_MS);
             try {
-                const proto = originator.startsWith('localhost:') ? 'http' : 'https';
-                const response = await fetch(`${proto}://${originator}/manifest.json`);
+                const localDevelopment = originator === 'localhost' || originator.startsWith('localhost:');
+                const proto = localDevelopment ? 'http' : 'https';
+                const expectedOrigin = `${proto}://${originator}`;
+                // Localhost HTTP is an explicit development compatibility path. Every
+                // public origin uses resolved-address validation and a DNS-pinned
+                // connection so a manifest hostname cannot rebind to a private host.
+                const manifestFetch = localDevelopment ? globalThis.fetch : (0, sdk_1.createPublicHTTPSFetch)(expectedOrigin);
+                const response = await manifestFetch(`${expectedOrigin}/manifest.json`, {
+                    redirect: 'error',
+                    signal: controller.signal
+                });
                 if (response.ok) {
-                    const manifest = await response.json();
+                    const manifest = await this.readBoundedManifest(response);
                     const namespace = manifest?.metanet || manifest?.babbage;
                     const groupPermissions = namespace?.groupPermissions || null;
                     const counterpartyPermissionsDeclared = this.validateCounterpartyPermissions(namespace?.counterpartyPermissions);
@@ -1065,6 +1227,9 @@ class WalletPermissionsManager {
             catch {
                 // Manifest fetch or parse failed — fall through to return null/null defaults below
             }
+            finally {
+                clearTimeout(timeout);
+            }
             const result = { groupPermissions: null, counterpartyPermissions: null };
             this.manifestCache.set(originator, { ...result, fetchedAt: Date.now() });
             return result;
@@ -1077,6 +1242,49 @@ class WalletPermissionsManager {
             this.manifestFetchInProgress.delete(originator);
         }
     }
+    async readBoundedManifest(response) {
+        const declaredLength = response.headers?.get('content-length');
+        if (declaredLength != null) {
+            const parsedLength = Number(declaredLength);
+            if (!Number.isSafeInteger(parsedLength) ||
+                parsedLength < 0 ||
+                parsedLength > WalletPermissionsManager.MANIFEST_MAX_BYTES) {
+                throw new Error('Manifest response exceeds the configured size limit.');
+            }
+        }
+        if (response.body == null) {
+            // Test and embedded fetch implementations may expose only json(). Bound
+            // their parsed representation before accepting it.
+            const parsed = await response.json();
+            if (new TextEncoder().encode(JSON.stringify(parsed)).length > WalletPermissionsManager.MANIFEST_MAX_BYTES) {
+                throw new Error('Manifest response exceeds the configured size limit.');
+            }
+            return parsed;
+        }
+        const reader = response.body.getReader();
+        const chunks = [];
+        let total = 0;
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            if (value == null)
+                continue;
+            total += value.byteLength;
+            if (total > WalletPermissionsManager.MANIFEST_MAX_BYTES) {
+                await reader.cancel();
+                throw new Error('Manifest response exceeds the configured size limit.');
+            }
+            chunks.push(value);
+        }
+        const bytes = new Uint8Array(total);
+        let offset = 0;
+        for (const chunk of chunks) {
+            bytes.set(chunk, offset);
+            offset += chunk.byteLength;
+        }
+        return JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
+    }
     async fetchManifestGroupPermissions(originator) {
         const { groupPermissions } = await this.fetchManifestPermissions(originator);
         return groupPermissions;
@@ -1669,7 +1877,7 @@ class WalletPermissionsManager {
     ];
     /** We always use `keyID="1"` and `counterparty="self"` for these encryption ops. */
     async encryptPermissionTokenField(plaintext) {
-        const data = typeof plaintext === 'string' ? sdk_1.Utils.toArray(plaintext, 'utf8') : plaintext;
+        const data = typeof plaintext === 'string' ? (0, utils_1.toArray)(plaintext, 'utf8') : plaintext;
         const { ciphertext } = await this.underlying.encrypt({
             plaintext: data,
             protocolID: WalletPermissionsManager.PERM_TOKEN_ENCRYPTION_PROTOCOL,
@@ -1691,7 +1899,7 @@ class WalletPermissionsManager {
             let parsed = this.parsedBeefCache.get(beef);
             if (parsed === undefined) {
                 try {
-                    parsed = sdk_1.Beef.fromBinary(beef);
+                    parsed = sdk_1.Beef.fromBinaryStrict(beef);
                 }
                 catch {
                     parsed = null;
@@ -1709,6 +1917,60 @@ class WalletPermissionsManager {
         // fast path can't serve.
         return sdk_1.Transaction.fromBEEF(beef ?? [], txid);
     }
+    async permissionTokenLockingKey() {
+        const pending = this.permissionTokenLockingKeyPromise ??
+            this.underlying
+                .getPublicKey({
+                protocolID: WalletPermissionsManager.PERM_TOKEN_ENCRYPTION_PROTOCOL,
+                keyID: '1',
+                counterparty: 'self',
+                forSelf: true
+            }, this.adminOriginator)
+                .then(({ publicKey }) => {
+                if (typeof publicKey !== 'string' || !/^(?:02|03)[0-9a-f]{64}$/i.test(publicKey)) {
+                    throw new Error('Wallet returned an invalid permission-token locking key.');
+                }
+                return publicKey.toLowerCase();
+            });
+        this.permissionTokenLockingKeyPromise = pending;
+        try {
+            return await pending;
+        }
+        catch (error) {
+            if (this.permissionTokenLockingKeyPromise === pending)
+                this.permissionTokenLockingKeyPromise = undefined;
+            throw error;
+        }
+    }
+    async authenticatedPermissionTokenSource(result, output, dataFieldCount) {
+        try {
+            const [txid, outputIndex] = this.parseOutpoint(output.outpoint);
+            const tx = this.transactionFromResultBeef(result, txid);
+            if (tx.id('hex').toLowerCase() !== txid)
+                throw new Error('Permission token transaction ID mismatch.');
+            const txOutput = tx.outputs[outputIndex];
+            if (txOutput == null || txOutput.satoshis !== 1 || output.satoshis !== 1) {
+                throw new Error('Permission token source output is invalid.');
+            }
+            const decoded = (0, sdk_1.decodeCanonicalPushDrop)(txOutput.lockingScript, {
+                fieldCount: dataFieldCount + 1,
+                maximumFieldBytes: MAX_PERMISSION_TOKEN_FIELD_BYTES,
+                maximumPayloadBytes: MAX_PERMISSION_TOKEN_PAYLOAD_BYTES
+            });
+            if (decoded.lockingPublicKey.toString().toLowerCase() !== (await this.permissionTokenLockingKey())) {
+                throw new Error('Permission token is not controlled by this wallet.');
+            }
+            const fields = decoded.fields.slice(0, -1);
+            const signature = sdk_1.Signature.fromDER(decoded.fields.at(-1));
+            if (!signature.verify(fields.flat(), decoded.lockingPublicKey)) {
+                throw new Error('Permission token field signature is invalid.');
+            }
+            return { tx, txid, outputIndex, fields };
+        }
+        catch {
+            return undefined;
+        }
+    }
     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
@@ -1729,6 +1991,9 @@ class WalletPermissionsManager {
             return ciphertext;
         }
     }
+    async decryptPermissionTokenText(ciphertext) {
+        return (0, utils_1.toUTF8Strict)(await this.decryptPermissionTokenField(ciphertext));
+    }
     /**
      * Encrypts wallet metadata if configured to do so, otherwise returns the original plaintext for storage.
      * @param plaintext The metadata to encrypt if configured to do so
@@ -1739,11 +2004,11 @@ class WalletPermissionsManager {
             return plaintext;
         }
         const { ciphertext } = await this.underlying.encrypt({
-            plaintext: sdk_1.Utils.toArray(plaintext, 'utf8'),
+            plaintext: (0, utils_1.toArray)(plaintext, 'utf8'),
             protocolID: WalletPermissionsManager.METADATA_ENCRYPTION_PROTOCOL,
             keyID: '1'
         }, this.adminOriginator);
-        return sdk_1.Utils.toBase64(ciphertext);
+        return (0, utils_1.toBase64)(ciphertext);
     }
     /**
      * Attempts to decrypt metadata. if decryption fails, assumes the value is already plaintext and returns it.
@@ -1753,11 +2018,11 @@ class WalletPermissionsManager {
     async maybeDecryptMetadata(ciphertext) {
         try {
             const { plaintext } = await this.underlying.decrypt({
-                ciphertext: sdk_1.Utils.toArray(ciphertext, 'base64'),
+                ciphertext: (0, utils_1.toArray)(ciphertext, 'base64'),
                 protocolID: WalletPermissionsManager.METADATA_ENCRYPTION_PROTOCOL,
                 keyID: '1'
             }, this.adminOriginator);
-            return sdk_1.Utils.toUTF8(plaintext);
+            return (0, utils_1.toUTF8)(plaintext);
         }
         catch {
             // Decryption failed (e.g. wrong key, unencrypted legacy value) — return original string unchanged
@@ -1771,32 +2036,33 @@ class WalletPermissionsManager {
     }
     /** Decrypts the standard 6 fields from a protocol (DPACP) PushDrop script. */
     async decryptProtocolTokenFields(fields) {
-        const domainDecoded = sdk_1.Utils.toUTF8(await this.decryptPermissionTokenField(fields[0]));
-        const expiryDecoded = Number.parseInt(sdk_1.Utils.toUTF8(await this.decryptPermissionTokenField(fields[1])), 10);
-        const privDecoded = sdk_1.Utils.toUTF8(await this.decryptPermissionTokenField(fields[2])) === 'true';
-        const secLevelDecoded = Number.parseInt(sdk_1.Utils.toUTF8(await this.decryptPermissionTokenField(fields[3])), 10);
-        const protoNameDecoded = sdk_1.Utils.toUTF8(await this.decryptPermissionTokenField(fields[4]));
-        const cptyDecoded = sdk_1.Utils.toUTF8(await this.decryptPermissionTokenField(fields[5]));
+        const domainDecoded = await this.decryptPermissionTokenText(fields[0]);
+        const expiryDecoded = parseCanonicalPermissionInteger(await this.decryptPermissionTokenText(fields[1]), 'Permission expiry');
+        const privDecoded = parsePermissionBoolean(await this.decryptPermissionTokenText(fields[2]), 'Permission privileged flag');
+        const securityLevel = parseCanonicalPermissionInteger(await this.decryptPermissionTokenText(fields[3]), 'Permission security level', 2);
+        const secLevelDecoded = securityLevel;
+        const protoNameDecoded = await this.decryptPermissionTokenText(fields[4]);
+        const cptyDecoded = await this.decryptPermissionTokenText(fields[5]);
         return { domainDecoded, expiryDecoded, privDecoded, secLevelDecoded, protoNameDecoded, cptyDecoded };
     }
     protocolTokenTags(originator, privileged, securityLevel, protocolName, counterparty) {
         const tags = [
-            `originator ${originator}`,
             `privileged ${!!privileged}`,
             `protocolName ${protocolName}`,
             `protocolSecurityLevel ${securityLevel}`
         ];
+        if (originator !== undefined)
+            tags.unshift(`originator ${originator}`);
         if (securityLevel === 2)
             tags.push(`counterparty ${counterparty}`);
         return tags;
     }
     async parseProtocolTokenOutput(result, output, expected) {
-        const [txid, outputIndex] = this.parseOutpoint(output.outpoint);
-        const tx = this.transactionFromResultBeef(result, txid);
-        const decoded = sdk_1.PushDrop.decode(tx.outputs[outputIndex].lockingScript);
-        if (decoded?.fields == null || decoded.fields.length < 6)
+        const source = await this.authenticatedPermissionTokenSource(result, output, 6);
+        if (source == null)
             return undefined;
-        const fields = await this.decryptProtocolTokenFields(decoded.fields);
+        const { tx, txid, outputIndex } = source;
+        const fields = await this.decryptProtocolTokenFields(source.fields);
         if (this.normalizeOriginator(fields.domainDecoded) !== expected.originator)
             return undefined;
         const matches = fields.privDecoded === !!expected.privileged &&
@@ -1821,16 +2087,15 @@ class WalletPermissionsManager {
         };
     }
     async parseBasketTokenOutput(result, output, originator, basket) {
-        const [txid, outputIndex] = this.parseOutpoint(output.outpoint);
-        const tx = this.transactionFromResultBeef(result, txid);
-        const decoded = sdk_1.PushDrop.decode(tx.outputs[outputIndex].lockingScript);
-        if (decoded?.fields == null || decoded.fields.length < 3)
+        const source = await this.authenticatedPermissionTokenSource(result, output, 3);
+        if (source == null)
             return undefined;
-        const domainDecoded = sdk_1.Utils.toUTF8(await this.decryptPermissionTokenField(decoded.fields[0]));
+        const { tx, txid, outputIndex, fields } = source;
+        const domainDecoded = await this.decryptPermissionTokenText(fields[0]);
         if (this.normalizeOriginator(domainDecoded) !== originator)
             return undefined;
-        const expiryDecoded = Number.parseInt(sdk_1.Utils.toUTF8(await this.decryptPermissionTokenField(decoded.fields[1])), 10);
-        const basketDecoded = sdk_1.Utils.toUTF8(await this.decryptPermissionTokenField(decoded.fields[2]));
+        const expiryDecoded = parseCanonicalPermissionInteger(await this.decryptPermissionTokenText(fields[1]), 'Permission expiry');
+        const basketDecoded = await this.decryptPermissionTokenText(fields[2]);
         if (basketDecoded !== basket)
             return undefined;
         return {
@@ -1846,20 +2111,19 @@ class WalletPermissionsManager {
         };
     }
     async parseCertificateTokenOutput(result, output, expected) {
-        const [txid, outputIndex] = this.parseOutpoint(output.outpoint);
-        const tx = this.transactionFromResultBeef(result, txid);
-        const decoded = sdk_1.PushDrop.decode(tx.outputs[outputIndex].lockingScript);
-        if (decoded?.fields == null || decoded.fields.length < 6)
+        const source = await this.authenticatedPermissionTokenSource(result, output, 6);
+        if (source == null)
             return undefined;
-        const [domainRaw, expiryRaw, privRaw, typeRaw, fieldsRaw, verifierRaw] = decoded.fields;
-        const domainDecoded = sdk_1.Utils.toUTF8(await this.decryptPermissionTokenField(domainRaw));
+        const { tx, txid, outputIndex } = source;
+        const [domainRaw, expiryRaw, privRaw, typeRaw, fieldsRaw, verifierRaw] = source.fields;
+        const domainDecoded = await this.decryptPermissionTokenText(domainRaw);
         if (this.normalizeOriginator(domainDecoded) !== expected.originator)
             return undefined;
-        const expiryDecoded = Number.parseInt(sdk_1.Utils.toUTF8(await this.decryptPermissionTokenField(expiryRaw)), 10);
-        const privileged = sdk_1.Utils.toUTF8(await this.decryptPermissionTokenField(privRaw)) === 'true';
-        const certType = sdk_1.Utils.toUTF8(await this.decryptPermissionTokenField(typeRaw));
-        const verifier = sdk_1.Utils.toUTF8(await this.decryptPermissionTokenField(verifierRaw));
-        const allFields = JSON.parse(sdk_1.Utils.toUTF8(await this.decryptPermissionTokenField(fieldsRaw)));
+        const expiryDecoded = parseCanonicalPermissionInteger(await this.decryptPermissionTokenText(expiryRaw), 'Permission expiry');
+        const privileged = parsePermissionBoolean(await this.decryptPermissionTokenText(privRaw), 'Permission privileged flag');
+        const certType = await this.decryptPermissionTokenText(typeRaw);
+        const verifier = await this.decryptPermissionTokenText(verifierRaw);
+        const allFields = parsePermissionCertificateFields(await this.decryptPermissionTokenText(fieldsRaw));
         const metadataMatches = privileged === !!expected.privileged && certType === expected.certType && verifier === expected.verifier;
         if (!metadataMatches)
             return undefined;
@@ -1883,61 +2147,14 @@ class WalletPermissionsManager {
     }
     /** Parses outpoint string "txid.vout" into [txid, outputIndex]. */
     parseOutpoint(outpoint) {
-        const [txid, indexStr] = outpoint.split('.');
-        return [txid, Number.parseInt(indexStr, 10)];
-    }
-    /** Normalizes a txid string to lowercase. */
-    normalizeTxid(txid) {
-        return (txid ?? '').toLowerCase();
-    }
-    /** Reverses a 32-byte hex txid (for endian normalization). */
-    reverseHexTxid(txid) {
-        const hex = this.normalizeTxid(txid);
-        if (!/^[0-9a-f]{64}$/.test(hex))
-            return hex;
-        const bytes = hex.match(/../g);
-        return bytes != null ? bytes.reverse().join('') : hex;
-    }
-    /**
-     * Returns true when an outpoint string (e.g. "txid.vout" or "txid:vout") refers to `token`.
-     */
-    tokenMatchesOutpointString(outpoint, token) {
-        const dot = outpoint.lastIndexOf('.');
-        const colon = outpoint.lastIndexOf(':');
-        const sep = Math.max(dot, colon);
-        if (sep === -1)
-            return false;
-        const txidPart = outpoint.slice(0, sep);
-        const vout = Number(outpoint.slice(sep + 1));
-        if (!Number.isFinite(vout))
-            return false;
-        return this.normalizeTxid(txidPart) === this.normalizeTxid(token.txid) && vout === token.outputIndex;
-    }
-    /**
-     * Finds the index of the tx input that spends the given permission token.
-     * Handles multiple potential field names for TXID and vout.
-     */
-    findInputIndexForToken(tx, token) {
-        return tx.inputs.findIndex((input) => {
-            const txidCandidate = input?.sourceTXID ??
-                input?.sourceTxid ??
-                input?.sourceTxId ??
-                input?.prevTxId ??
-                input?.prevTxid ??
-                input?.prevTXID ??
-                input?.txid ??
-                input?.txID;
-            const voutCandidate = input?.sourceOutputIndex ?? input?.sourceOutput ?? input?.outputIndex ?? input?.vout ?? input?.prevOutIndex;
-            if (typeof txidCandidate === 'string' && typeof voutCandidate === 'number') {
-                const cand = this.normalizeTxid(txidCandidate);
-                if (cand === this.normalizeTxid(token.txid) && voutCandidate === token.outputIndex)
-                    return true;
-                if (cand === this.reverseHexTxid(token.txid) && voutCandidate === token.outputIndex)
-                    return true;
-            }
-            const outpointCandidate = input?.outpoint ?? input?.sourceOutpoint ?? input?.prevOutpoint;
-            return typeof outpointCandidate === 'string' && this.tokenMatchesOutpointString(outpointCandidate, token);
-        });
+        const match = /^([0-9a-f]{64})\.(0|[1-9]\d*)$/i.exec(outpoint);
+        if (match == null)
+            throw new Error('Permission token outpoint is invalid.');
+        const outputIndex = Number(match[2]);
+        if (!Number.isSafeInteger(outputIndex) || outputIndex > 0xffffffff) {
+            throw new Error('Permission token outpoint is invalid.');
+        }
+        return [match[1].toLowerCase(), outputIndex];
     }
     /** Looks for a DPACP permission token matching origin/domain, privileged, protocol, cpty. */
     async findProtocolToken(originator, privileged, protocolID, counterparty, includeExpired, originatorLookupValues) {
@@ -1948,7 +2165,8 @@ class WalletPermissionsManager {
                 basket: BASKET_MAP.protocol,
                 tags: this.protocolTokenTags(originTag, privileged, secLevel, protoName, counterparty),
                 tagQueryMode: 'all',
-                include: 'entire transactions'
+                include: 'entire transactions',
+                limit: 10000
             }, this.adminOriginator);
             for (const out of result.outputs) {
                 const token = await this.parseProtocolTokenOutput(result, out, {
@@ -1978,7 +2196,8 @@ class WalletPermissionsManager {
                 basket: BASKET_MAP.protocol,
                 tags: this.protocolTokenTags(originTag, privileged, secLevel, protoName, counterparty),
                 tagQueryMode: 'all',
-                include: 'entire transactions'
+                include: 'entire transactions',
+                limit: 10000
             }, this.adminOriginator);
             for (const out of result.outputs) {
                 if (seen.has(out.outpoint))
@@ -2004,9 +2223,10 @@ class WalletPermissionsManager {
         for (const originTag of originsToTry) {
             const result = await this.underlying.listOutputs({
                 basket: BASKET_MAP.basket,
-                tags: [`originator ${originTag}`, `basket ${basket}`],
+                tags: [originTag === undefined ? undefined : `originator ${originTag}`, `basket ${basket}`].filter((tag) => tag !== undefined),
                 tagQueryMode: 'all',
-                include: 'entire transactions'
+                include: 'entire transactions',
+                limit: 10000
             }, this.adminOriginator);
             for (const out of result.outputs) {
                 const token = await this.parseBasketTokenOutput(result, out, originator, basket);
@@ -2025,9 +2245,15 @@ class WalletPermissionsManager {
         for (const originTag of originsToTry) {
             const result = await this.underlying.listOutputs({
                 basket: BASKET_MAP.certificate,
-                tags: [`originator ${originTag}`, `privileged ${!!privileged}`, `type ${certType}`, `verifier ${verifier}`],
+                tags: [
+                    originTag === undefined ? undefined : `originator ${originTag}`,
+                    `privileged ${!!privileged}`,
+                    `type ${certType}`,
+                    `verifier ${verifier}`
+                ].filter((tag) => tag !== undefined),
                 tagQueryMode: 'all',
-                include: 'entire transactions'
+                include: 'entire transactions',
+                limit: 10000
             }, this.adminOriginator);
             for (const out of result.outputs) {
                 const token = await this.parseCertificateTokenOutput(result, out, {
@@ -2052,29 +2278,28 @@ class WalletPermissionsManager {
         for (const originTag of originsToTry) {
             const result = await this.underlying.listOutputs({
                 basket: BASKET_MAP.spending,
-                tags: [`originator ${originTag}`],
+                tags: originTag === undefined ? [] : [`originator ${originTag}`],
                 tagQueryMode: 'all',
-                include: 'entire transactions'
+                include: 'entire transactions',
+                limit: 10000
             }, this.adminOriginator);
             for (const out of result.outputs) {
-                const [txid, outputIndexStr] = out.outpoint.split('.');
-                const tx = this.transactionFromResultBeef(result, txid);
-                const dec = sdk_1.PushDrop.decode(tx.outputs[Number(outputIndexStr)].lockingScript);
-                if (!dec?.fields || dec.fields.length < 2)
+                const source = await this.authenticatedPermissionTokenSource(result, out, 2);
+                if (source == null)
                     continue;
-                const domainRaw = dec.fields[0];
-                const amtRaw = dec.fields[1];
-                const domainDecoded = sdk_1.Utils.toUTF8(await this.decryptPermissionTokenField(domainRaw));
+                const { tx, txid, outputIndex, fields } = source;
+                const domainRaw = fields[0];
+                const amtRaw = fields[1];
+                const domainDecoded = await this.decryptPermissionTokenText(domainRaw);
                 const normalizedDomain = this.normalizeOriginator(domainDecoded);
                 if (normalizedDomain !== originator)
                     continue;
-                const amtDecodedStr = sdk_1.Utils.toUTF8(await this.decryptPermissionTokenField(amtRaw));
-                const authorizedAmount = Number.parseInt(amtDecodedStr, 10);
+                const authorizedAmount = parseCanonicalPermissionInteger(await this.decryptPermissionTokenText(amtRaw), 'Permission spending amount', MAX_MONEY_SATOSHIS);
                 return {
                     tx: tx.toBEEF(),
-                    txid: out.outpoint.split('.')[0],
-                    outputIndex: Number.parseInt(out.outpoint.split('.')[1], 10),
-                    outputScript: tx.outputs[Number(outputIndexStr)].lockingScript.toHex(),
+                    txid,
+                    outputIndex,
+                    outputScript: tx.outputs[outputIndex].lockingScript.toHex(),
                     satoshis: out.satoshis,
                     originator,
                     rawOriginator: domainDecoded,
@@ -2103,11 +2328,23 @@ class WalletPermissionsManager {
         const labelOrigins = this.buildOriginatorLookupValues(token.rawOriginator, token.originator);
         let total = 0;
         for (const labelOrigin of labelOrigins) {
-            const { actions } = await this.underlying.listActions({
-                labels: [`admin originator ${labelOrigin}`, `admin month ${this.getCurrentMonthYearUTC()}`],
-                labelQueryMode: 'all'
-            }, this.adminOriginator);
-            total += actions.reduce((a, e) => a - e.satoshis, 0);
+            let offset = 0;
+            let totalActions = 0;
+            do {
+                const result = await this.underlying.listActions({
+                    labels: [`admin originator ${labelOrigin}`, `admin month ${this.getCurrentMonthYearUTC()}`],
+                    labelQueryMode: 'all',
+                    limit: 10000,
+                    offset
+                }, this.adminOriginator);
+                total += result.actions.reduce((a, e) => a - e.satoshis, 0);
+                offset += result.actions.length;
+                totalActions = result.totalActions;
+                // A provider that reports more results but returns an empty page must
+                // not trap the wallet in an infinite accounting loop.
+                if (result.actions.length === 0)
+                    break;
+            } while (offset < totalActions);
         }
         return total;
     }
@@ -2138,7 +2375,7 @@ class WalletPermissionsManager {
         const tags = this.buildTagsForRequest(r);
         // Build a transaction with exactly one output, no explicit inputs since the wallet
         // can internally fund it from its balance.
-        await this.createAction({
+        await this.completePermissionTokenAction({
             description: `Grant ${r.type} permission`,
             outputs: [
                 {
@@ -2150,9 +2387,12 @@ class WalletPermissionsManager {
                 }
             ],
             options: {
+                // Permission persistence must not inherit network-broadcast latency.
+                // The managed-change planner keeps the queued output available as a
+                // last-resort funding source for the resumed request.
                 acceptDelayedBroadcast: true
             }
-        }, this.adminOriginator);
+        });
     }
     async mapWithConcurrency(items, concurrency, fn) {
         if (items.length === 0)
@@ -2170,13 +2410,13 @@ class WalletPermissionsManager {
         await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, async () => await worker()));
         return results;
     }
-    async runBestEffortBatches(items, chunkSize, runChunk) {
+    async runBestEffortBatches(items, chunkSize, runChunk, strict = false) {
         if (items.length === 0)
             return [];
         const out = [];
         for (let i = 0; i < items.length; i += chunkSize) {
             const chunk = items.slice(i, i + chunkSize);
-            out.push(...(await this.runBestEffortChunk(chunk, runChunk)));
+            out.push(...(strict ? await runChunk(chunk) : await this.runBestEffortChunk(chunk, runChunk)));
         }
         return out;
     }
@@ -2184,9 +2424,8 @@ class WalletPermissionsManager {
         try {
             return await runChunk(chunk);
         }
-        catch (e) {
+        catch {
             if (chunk.length <= 1) {
-                console.error('Permission batch failed:', e);
                 return [];
             }
             const mid = Math.ceil(chunk.length / 2);
@@ -2216,27 +2455,27 @@ class WalletPermissionsManager {
             }
         };
     }
-    async createPermissionTokensBestEffort(items) {
+    async createPermissionTokensBestEffort(items, strict = false) {
         const CHUNK = 25;
         return await this.runBestEffortBatches(items, CHUNK, async (chunk) => {
             const built = await this.mapWithConcurrency(chunk, 8, async (c) => await this.buildPermissionOutput(c.request, c.expiry, c.amount));
-            await this.createAction({
+            await this.completePermissionTokenAction({
                 description: `Grant ${built.length} permissions`,
                 outputs: built.map(b => b.output),
                 options: { acceptDelayedBroadcast: true }
-            }, this.adminOriginator);
+            });
             return built.map(b => b.request);
-        });
+        }, strict);
     }
-    async renewPermissionTokensBestEffort(items) {
+    async renewPermissionTokensBestEffort(items, strict = false) {
         const CHUNK = 15;
         return await this.runBestEffortBatches(items, CHUNK, async (chunk) => {
             const built = await this.mapWithConcurrency(chunk, 8, async (c) => await this.buildPermissionOutput(c.request, c.expiry, c.amount));
             const inputBeef = new sdk_1.Beef();
             for (const c of chunk) {
-                inputBeef.mergeBeef(sdk_1.Beef.fromBinary(c.oldToken.tx));
+                inputBeef.mergeBeef(sdk_1.Beef.fromBinaryStrict(c.oldToken.tx));
             }
-            const { signableTransaction } = await this.createAction({
+            await this.completePermissionTokenAction({
                 description: `Renew ${chunk.length} permissions`,
                 inputBEEF: inputBeef.toBinary(),
                 inputs: chunk.map((c, i) => ({
@@ -2250,27 +2489,22 @@ class WalletPermissionsManager {
                     randomizeOutputs: false,
                     signAndProcess: false
                 }
-            }, this.adminOriginator);
-            if (!signableTransaction?.reference || !signableTransaction.tx) {
-                throw new Error('Failed to create signable transaction');
-            }
-            const partialTx = sdk_1.Transaction.fromAtomicBEEF(signableTransaction.tx);
-            const pushdrop = new sdk_1.PushDrop(this.underlying);
-            const spends = {};
-            for (let i = 0; i < chunk.length; i++) {
-                const token = chunk[i].oldToken;
-                const unlocker = pushdrop.unlock(WalletPermissionsManager.PERM_TOKEN_ENCRYPTION_PROTOCOL, '1', 'self', 'all', false, 1, sdk_1.LockingScript.fromHex(token.outputScript));
-                const unlockingScript = await unlocker.sign(partialTx, i);
-                spends[i] = { unlockingScript: unlockingScript.toHex() };
-            }
-            const { txid } = await this.underlying.signAction({
-                reference: signableTransaction.reference,
-                spends
-            });
-            if (!txid)
-                throw new Error('Failed to finalize renewal transaction');
+            }, chunk.map(item => item.oldToken));
             return built.map(b => b.request);
-        });
+        }, strict);
+    }
+    permissionTokenInputSigners(tokens) {
+        const inputSigners = Object.create(null);
+        const pushdrop = new sdk_1.PushDrop(this.underlying);
+        for (const token of tokens) {
+            const outpoint = `${token.txid}.${token.outputIndex}`;
+            const unlocker = pushdrop.unlock(WalletPermissionsManager.PERM_TOKEN_ENCRYPTION_PROTOCOL, '1', 'self', 'all', false, 1, sdk_1.LockingScript.fromHex(token.outputScript));
+            inputSigners[outpoint] = async (transaction, inputIndex) => await unlocker.sign(transaction, inputIndex);
+        }
+        return inputSigners;
+    }
+    async completePermissionTokenAction(args, tokens = []) {
+        return await (0, sdk_1.completeBoundAction)(this, args, { inputSigners: this.permissionTokenInputSigners(tokens) }, this.adminOriginator);
     }
     async coalescePermissionTokens(oldTokens, newScript, opts) {
         if (!oldTokens?.length)
@@ -2281,9 +2515,9 @@ class WalletPermissionsManager {
         // Merge all input token BEEFs into a single BEEF structure
         const inputBeef = new sdk_1.Beef();
         for (const token of oldTokens) {
-            inputBeef.mergeBeef(sdk_1.Beef.fromBinary(token.tx));
+            inputBeef.mergeBeef(sdk_1.Beef.fromBinaryStrict(token.tx));
         }
-        const { signableTransaction } = await this.createAction({
+        const transaction = await this.completePermissionTokenAction({
             description: opts?.description ?? `Coalesce ${oldTokens.length} permission tokens`,
             inputBEEF: inputBeef.toBinary(),
             inputs: oldTokens.map((t, i) => ({
@@ -2305,29 +2539,8 @@ class WalletPermissionsManager {
                 randomizeOutputs: false,
                 signAndProcess: false
             }
-        }, this.adminOriginator);
-        if (!signableTransaction?.reference || !signableTransaction.tx) {
-            throw new Error('Failed to create signable transaction');
-        }
-        // 2) Sign each input - each token needs its own unlocker with the correct locking script
-        const partialTx = sdk_1.Transaction.fromAtomicBEEF(signableTransaction.tx);
-        const pushdrop = new sdk_1.PushDrop(this.underlying);
-        const spends = {};
-        for (let i = 0; i < oldTokens.length; i++) {
-            const token = oldTokens[i];
-            // Each token requires its own unlocker with the specific locking script
-            const unlocker = pushdrop.unlock(WalletPermissionsManager.PERM_TOKEN_ENCRYPTION_PROTOCOL, '1', 'self', 'all', false, 1, sdk_1.LockingScript.fromHex(token.outputScript));
-            const unlockingScript = await unlocker.sign(partialTx, i);
-            spends[i] = { unlockingScript: unlockingScript.toHex() };
-        }
-        // 3) Finalize the action
-        const { txid } = await this.underlying.signAction({
-            reference: signableTransaction.reference,
-            spends
-        });
-        if (!txid)
-            throw new Error('Failed to finalize coalescing transaction');
-        return txid;
+        }, oldTokens);
+        return transaction.id('hex');
     }
     /**
      * Renews a permission token by spending the old token as input and creating a new token output.
@@ -2360,7 +2573,7 @@ class WalletPermissionsManager {
             // 3) For BRC-100, we do a "createAction" with a partial input referencing oldToken
             //    plus a single new output. We'll hydrate the template, then signAction for the wallet to finalize.
             const oldOutpoint = `${oldToken.txid}.${oldToken.outputIndex}`;
-            const { signableTransaction } = await this.createAction({
+            await this.completePermissionTokenAction({
                 description: `Renew ${r.type} permission`,
                 inputBEEF: oldToken.tx,
                 inputs: [
@@ -2382,18 +2595,7 @@ class WalletPermissionsManager {
                 options: {
                     acceptDelayedBroadcast: true
                 }
-            }, this.adminOriginator);
-            const tx = sdk_1.Transaction.fromBEEF(signableTransaction.tx);
-            const unlocker = new sdk_1.PushDrop(this.underlying).unlock(WalletPermissionsManager.PERM_TOKEN_ENCRYPTION_PROTOCOL, '1', 'self', 'all', false, 1, sdk_1.LockingScript.fromHex(oldToken.outputScript));
-            const unlockingScript = await unlocker.sign(tx, 0);
-            await this.underlying.signAction({
-                reference: signableTransaction.reference,
-                spends: {
-                    0: {
-                        unlockingScript: unlockingScript.toHex()
-                    }
-                }
-            });
+            }, [oldToken]);
         }
     }
     /**
@@ -2494,7 +2696,10 @@ class WalletPermissionsManager {
             const result = await this.underlying.listOutputs({ basket: BASKET_MAP.protocol, tags, tagQueryMode: 'all', include: 'entire transactions', limit: 10000 }, this.adminOriginator);
             await this.collectProtocolTokens(result, originFilter, seen, tokens);
         }
-        return tokens;
+        return tokens.filter(token => (privileged === undefined || token.privileged === privileged) &&
+            (protocolName === undefined || token.protocol === protocolName) &&
+            (protocolSecurityLevel === undefined || token.securityLevel === protocolSecurityLevel) &&
+            (counterparty === undefined || token.counterparty === counterparty));
     }
     /** Builds the base tag array for protocol permission listing. */
     buildProtocolFilterTags({ privileged, protocolName, protocolSecurityLevel, counterparty }) {
@@ -2514,12 +2719,11 @@ class WalletPermissionsManager {
         for (const out of result.outputs) {
             if (seen.has(out.outpoint))
                 continue;
-            const [txid, outputIndex] = this.parseOutpoint(out.outpoint);
-            const tx = this.transactionFromResultBeef(result, txid);
-            const dec = sdk_1.PushDrop.decode(tx.outputs[outputIndex].lockingScript);
-            if (!dec?.fields || dec.fields.length < 6)
+            const source = await this.authenticatedPermissionTokenSource(result, out, 6);
+            if (source == null)
                 continue;
-            const f = await this.decryptProtocolTokenFields(dec.fields);
+            const { tx, txid, outputIndex } = source;
+            const f = await this.decryptProtocolTokenFields(source.fields);
             const normalizedDomain = this.normalizeOriginator(f.domainDecoded);
             if (originFilter != null && normalizedDomain !== originFilter.normalized)
                 continue;
@@ -2588,25 +2792,24 @@ class WalletPermissionsManager {
             }, this.adminOriginator);
             await this.collectBasketTokens(result, originFilter, seen, tokens);
         }
-        return tokens;
+        return params.basket == null ? tokens : tokens.filter(token => token.basketName === params.basket);
     }
     /** Decodes and appends basket permission tokens from a listOutputs result. */
     async collectBasketTokens(result, originFilter, seen, tokens) {
         for (const out of result.outputs) {
             if (seen.has(out.outpoint))
                 continue;
-            const [txid, outputIndex] = this.parseOutpoint(out.outpoint);
-            const tx = this.transactionFromResultBeef(result, txid);
-            const dec = sdk_1.PushDrop.decode(tx.outputs[outputIndex].lockingScript);
-            if (!dec?.fields || dec.fields.length < 3)
+            const source = await this.authenticatedPermissionTokenSource(result, out, 3);
+            if (source == null)
                 continue;
-            const [domainRaw, expiryRaw, basketRaw] = dec.fields;
-            const domainDecoded = sdk_1.Utils.toUTF8(await this.decryptPermissionTokenField(domainRaw));
+            const { tx, txid, outputIndex } = source;
+            const [domainRaw, expiryRaw, basketRaw] = source.fields;
+            const domainDecoded = await this.decryptPermissionTokenText(domainRaw);
             const normalizedDomain = this.normalizeOriginator(domainDecoded);
             if (originFilter != null && normalizedDomain !== originFilter.normalized)
                 continue;
-            const expiryDecoded = Number.parseInt(sdk_1.Utils.toUTF8(await this.decryptPermissionTokenField(expiryRaw)), 10);
-            const basketDecoded = sdk_1.Utils.toUTF8(await this.decryptPermissionTokenField(basketRaw));
+            const expiryDecoded = parseCanonicalPermissionInteger(await this.decryptPermissionTokenText(expiryRaw), 'Permission expiry');
+            const basketDecoded = await this.decryptPermissionTokenText(basketRaw);
             seen.add(out.outpoint);
             tokens.push({
                 tx: tx.toBEEF(),
@@ -2656,27 +2859,28 @@ class WalletPermissionsManager {
         }, this.adminOriginator);
         const tokens = [];
         for (const out of result.outputs) {
-            const [txid, outputIndexStr] = out.outpoint.split('.');
-            const tx = this.transactionFromResultBeef(result, txid);
-            const dec = sdk_1.PushDrop.decode(tx.outputs[Number(outputIndexStr)].lockingScript);
-            if (!dec?.fields || dec.fields.length < 2)
+            const source = await this.authenticatedPermissionTokenSource(result, out, 2);
+            if (source == null)
                 continue;
-            const [domainRaw, amtRaw] = dec.fields;
-            const domainDecoded = sdk_1.Utils.toUTF8(await this.decryptPermissionTokenField(domainRaw));
-            const amtDecodedStr = sdk_1.Utils.toUTF8(await this.decryptPermissionTokenField(amtRaw));
-            const authorizedAmount = Number.parseInt(amtDecodedStr, 10);
+            const { tx, txid, outputIndex, fields } = source;
+            const [domainRaw, amtRaw] = fields;
+            const domainDecoded = await this.decryptPermissionTokenText(domainRaw);
+            const authorizedAmount = parseCanonicalPermissionInteger(await this.decryptPermissionTokenText(amtRaw), 'Permission spending amount', MAX_MONEY_SATOSHIS);
             tokens.push({
                 tx: tx.toBEEF(),
-                txid: out.outpoint.split('.')[0],
-                outputIndex: Number.parseInt(out.outpoint.split('.')[1], 10),
+                txid,
+                outputIndex,
                 satoshis: out.satoshis,
-                outputScript: tx.outputs[Number(outputIndexStr)].lockingScript.toHex(),
+                outputScript: tx.outputs[outputIndex].lockingScript.toHex(),
                 originator: domainDecoded,
                 authorizedAmount,
                 expiry: 0
             });
         }
-        return tokens;
+        if (params.originator == null)
+            return tokens;
+        const normalizedOriginator = this.prepareOriginator(params.originator).normalized;
+        return tokens.filter(token => this.normalizeOriginator(token.originator) === normalizedOriginator);
     }
     /**
      * Returns `true` if the originator already holds a valid spending authorization token
@@ -2720,28 +2924,29 @@ class WalletPermissionsManager {
             const result = await this.underlying.listOutputs({ basket: BASKET_MAP.certificate, tags, tagQueryMode: 'all', include: 'entire transactions', limit: 10000 }, this.adminOriginator);
             await this.collectCertificateTokens(result, originFilter, seen, tokens);
         }
-        return tokens;
+        return tokens.filter(token => (params.privileged === undefined || token.privileged === params.privileged) &&
+            (params.certType === undefined || token.certType === params.certType) &&
+            (params.verifier === undefined || token.verifier === params.verifier));
     }
     /** Decodes and appends certificate permission tokens from a listOutputs result. */
     async collectCertificateTokens(result, originFilter, seen, tokens) {
         for (const out of result.outputs) {
             if (seen.has(out.outpoint))
                 continue;
-            const [txid, outputIndex] = this.parseOutpoint(out.outpoint);
-            const tx = this.transactionFromResultBeef(result, txid);
-            const dec = sdk_1.PushDrop.decode(tx.outputs[outputIndex].lockingScript);
-            if (!dec?.fields || dec.fields.length < 6)
+            const source = await this.authenticatedPermissionTokenSource(result, out, 6);
+            if (source == null)
                 continue;
-            const [domainRaw, expiryRaw, privRaw, typeRaw, fieldsRaw, verifierRaw] = dec.fields;
-            const domainDecoded = sdk_1.Utils.toUTF8(await this.decryptPermissionTokenField(domainRaw));
+            const { tx, txid, outputIndex } = source;
+            const [domainRaw, expiryRaw, privRaw, typeRaw, fieldsRaw, verifierRaw] = source.fields;
+            const domainDecoded = await this.decryptPermissionTokenText(domainRaw);
             const normalizedDomain = this.normalizeOriginator(domainDecoded);
             if (originFilter != null && normalizedDomain !== originFilter.normalized)
                 continue;
-            const expiryDecoded = Number.parseInt(sdk_1.Utils.toUTF8(await this.decryptPermissionTokenField(expiryRaw)), 10);
-            const privDecoded = sdk_1.Utils.toUTF8(await this.decryptPermissionTokenField(privRaw)) === 'true';
-            const typeDecoded = sdk_1.Utils.toUTF8(await this.decryptPermissionTokenField(typeRaw));
-            const verifierDec = sdk_1.Utils.toUTF8(await this.decryptPermissionTokenField(verifierRaw));
-            const allFields = JSON.parse(sdk_1.Utils.toUTF8(await this.decryptPermissionTokenField(fieldsRaw)));
+            const expiryDecoded = parseCanonicalPermissionInteger(await this.decryptPermissionTokenText(expiryRaw), 'Permission expiry');
+            const privDecoded = parsePermissionBoolean(await this.decryptPermissionTokenText(privRaw), 'Permission privileged flag');
+            const typeDecoded = await this.decryptPermissionTokenText(typeRaw);
+            const verifierDec = await this.decryptPermissionTokenText(verifierRaw);
+            const allFields = parsePermissionCertificateFields(await this.decryptPermissionTokenText(fieldsRaw));
             seen.add(out.outpoint);
             tokens.push({
                 tx: tx.toBEEF(),
@@ -2824,9 +3029,9 @@ class WalletPermissionsManager {
             return;
         const inputBeef = new sdk_1.Beef();
         for (const token of oldTokens) {
-            inputBeef.mergeBeef(sdk_1.Beef.fromBinary(token.tx));
+            inputBeef.mergeBeef(sdk_1.Beef.fromBinaryStrict(token.tx));
         }
-        const { signableTransaction } = await this.createAction({
+        await this.completePermissionTokenAction({
             description: `Revoke ${oldTokens.length} permissions`,
             inputBEEF: inputBeef.toBinary(),
             inputs: oldTokens.map((t, i) => ({
@@ -2839,37 +3044,7 @@ class WalletPermissionsManager {
                 randomizeOutputs: false,
                 signAndProcess: false
             }
-        }, this.adminOriginator);
-        if (!signableTransaction?.reference || !signableTransaction.tx) {
-            throw new Error('Failed to create signable transaction');
-        }
-        const tx = sdk_1.Transaction.fromAtomicBEEF(signableTransaction.tx);
-        const inputsToSign = oldTokens.map(token => {
-            let permInputIndex = this.findInputIndexForToken(tx, token);
-            if (permInputIndex === -1 && tx.inputs.length === 1) {
-                permInputIndex = 0;
-            }
-            if (permInputIndex === -1) {
-                throw new Error('Unable to locate permission token input for revocation.');
-            }
-            return { token, permInputIndex };
-        });
-        const pushdrop = new sdk_1.PushDrop(this.underlying);
-        const spends = {};
-        const signed = await this.mapWithConcurrency(inputsToSign, 8, async ({ token, permInputIndex }) => {
-            const unlocker = pushdrop.unlock(WalletPermissionsManager.PERM_TOKEN_ENCRYPTION_PROTOCOL, '1', 'self', 'all', false, 1, sdk_1.LockingScript.fromHex(token.outputScript));
-            const unlockingScript = await unlocker.sign(tx, permInputIndex);
-            return { permInputIndex, unlockingScriptHex: unlockingScript.toHex() };
-        });
-        for (const s of signed) {
-            spends[s.permInputIndex] = { unlockingScript: s.unlockingScriptHex };
-        }
-        const { txid } = await this.underlying.signAction({
-            reference: signableTransaction.reference,
-            spends
-        });
-        if (!txid)
-            throw new Error('Failed to finalize revoke transaction');
+        }, oldTokens);
     }
     /**
      * Revokes a permission token by spending it with no replacement output.
@@ -2877,7 +3052,7 @@ class WalletPermissionsManager {
      */
     async revokePermission(oldToken) {
         const oldOutpoint = `${oldToken.txid}.${oldToken.outputIndex}`;
-        const { signableTransaction } = await this.createAction({
+        await this.completePermissionTokenAction({
             description: 'Revoke permission',
             inputBEEF: oldToken.tx,
             inputs: [
@@ -2890,30 +3065,13 @@ class WalletPermissionsManager {
             options: {
                 acceptDelayedBroadcast: true
             }
-        }, this.adminOriginator);
-        const tx = sdk_1.Transaction.fromBEEF(signableTransaction.tx);
-        let permInputIndex = this.findInputIndexForToken(tx, oldToken);
-        if (permInputIndex === -1 && tx.inputs.length === 1) {
-            permInputIndex = 0;
-        }
-        if (permInputIndex === -1) {
-            throw new Error('Unable to locate permission token input for revocation.');
-        }
-        const unlocker = new sdk_1.PushDrop(this.underlying).unlock(WalletPermissionsManager.PERM_TOKEN_ENCRYPTION_PROTOCOL, '1', 'self', 'all', false, 1, sdk_1.LockingScript.fromHex(oldToken.outputScript));
-        const unlockingScript = await unlocker.sign(tx, permInputIndex);
-        await this.underlying.signAction({
-            reference: signableTransaction.reference,
-            spends: {
-                [permInputIndex]: {
-                    unlockingScript: unlockingScript.toHex()
-                }
-            }
-        });
+        }, [oldToken]);
     }
     /* ---------------------------------------------------------------------
      *  7) BRC-100 WALLET INTERFACE FORWARDING WITH PERMISSION CHECKS
      * --------------------------------------------------------------------- */
     async createAction(args, originator) {
+        const vargs = (0, validationHelpers_1.validateCreateActionArgs)(args);
         // 1) Identify unique P-modules involved (one per schemeID) from both baskets and labels
         const pModulesByScheme = new Map();
         const nonPBaskets = this.collectNonPBaskets(args.outputs, pModulesByScheme);
@@ -2947,13 +3105,24 @@ class WalletPermissionsManager {
             options: modifiedOptions,
             labels: [...(args.labels || []), `admin originator ${originator}`, `admin month ${this.getCurrentMonthYearUTC()}`]
         };
-        let createResult = await this.callCreateActionWithPModules(finalArgs, pModulesByScheme, originator);
+        let createResult;
+        try {
+            createResult = await this.callCreateActionWithPModules(finalArgs, pModulesByScheme, originator);
+        }
+        catch (error) {
+            this.forgetSentNoSendActionsInError(error);
+            throw error;
+        }
+        this.forgetSentNoSendActions(createResult.sendWithResults);
         if (createResult.signableTransaction == null)
             return createResult;
-        // 7) Parse the signable tx to determine net spend, then gate on spending authorization.
-        const tx = sdk_1.Transaction.fromAtomicBEEF(createResult.signableTransaction.tx);
+        // 7) Bind the action reference before parsing any storage-provided transaction
+        // data. This ensures malformed BEEF is still aborted and cannot leave an
+        // untracked action that may later be signed under another originator.
         const reference = createResult.signableTransaction.reference;
-        // 7a) SECURITY (GHSA-36f9-7rg5-cpf8) defense-in-depth: confirm every
+        this.bindPendingAction(reference, originator, vargs.isNoSend);
+        // 7a) Parse the signable tx to determine net spend, then gate on spending
+        // authorization. SECURITY (GHSA-36f9-7rg5-cpf8) defense-in-depth: confirm every
         // caller-requested output actually appears in the transaction we are about to
         // authorize and sign. The locking scripts in the signable transaction
         // originate from storage; a malicious or compromised remote storage provider
@@ -2962,34 +3131,66 @@ class WalletPermissionsManager {
         // recipient. The signer (buildSignableTransaction) rejects this at the
         // source; this is an independent check at the permissions layer.
         try {
-            this.verifyRequestedOutputsPresent(tx, args);
-        }
-        catch (err) {
-            await this.underlying.abortAction({ reference });
-            throw err;
-        }
-        const { netSpent, lineItems } = this.computeNetSpend(tx, args, originalInputDescriptions, originalOutputDescriptions);
-        // 8) If netSpent > 0, require spending authorization. Abort if denied.
-        if (netSpent > 0) {
-            try {
+            const tx = sdk_1.Transaction.fromAtomicBEEF(createResult.signableTransaction.tx);
+            const resolvedOutputSatoshis = this.verifyRequestedOutputsPresent(tx, args);
+            let { netSpent, lineItems } = this.computeNetSpend(tx, args, originalInputDescriptions, originalOutputDescriptions, resolvedOutputSatoshis);
+            const exactWalletSpend = (0, exactActionSpend_1.getExactActionSpend)(createResult);
+            if (exactWalletSpend !== undefined) {
+                if (!Number.isSafeInteger(exactWalletSpend) ||
+                    exactWalletSpend < -MAX_MONEY_SATOSHIS ||
+                    exactWalletSpend > MAX_MONEY_SATOSHIS ||
+                    exactWalletSpend < netSpent) {
+                    throw new Error('Wallet signer returned an invalid exact action-spend amount.');
+                }
+                const serviceCharge = exactWalletSpend - netSpent;
+                if (serviceCharge > 0) {
+                    lineItems = [...lineItems, { type: 'output', satoshis: serviceCharge, description: 'Storage service charge' }];
+                }
+                netSpent = exactWalletSpend;
+            }
+            // 8) If netSpent > 0, require spending authorization. Abort if denied.
+            if (netSpent > 0) {
                 await this.ensureSpendingAuthorization({
                     originator: originator,
                     satoshis: netSpent,
                     lineItems,
-                    reason: originalDescription
+                    reason: originalDescription,
+                    allowRecentGrant: (0, brc177NoSendExpiry_1.parseBrc177NoSendExpiryLabels)(args.labels) == null
                 });
             }
-            catch (err) {
-                await this.underlying.abortAction({ reference });
-                throw err;
-            }
+            this.pendingActionTemplates.set(reference, tx);
+        }
+        catch (err) {
+            await this.blockAndAbortAction(reference);
+            throw err;
         }
         // 9) Finalize or return the signable transaction based on whether more signatures are needed.
-        const vargs = sdk_1.Validation.validateCreateActionArgs(args);
         if (vargs.isSignAction)
             return createResult;
-        const signResult = await this.underlying.signAction({ reference, spends: {}, options: args.options }, originator);
-        return { ...createResult, ...signResult, signableTransaction: undefined };
+        try {
+            const signResult = await this.underlying.signAction({
+                reference,
+                spends: {},
+                options: { ...args.options, returnTXIDOnly: false }
+            }, originator);
+            this.assertAuthorizedSignResult(reference, {}, signResult);
+            this.clearPendingAction(reference);
+            if (vargs.isNoSend && signResult.txid != null) {
+                this.recordNoSendAction(signResult.txid, originator);
+            }
+            this.forgetSentNoSendActions(signResult.sendWithResults);
+            return {
+                ...createResult,
+                ...signResult,
+                noSendChange: noSendChangeOnSignedTransaction(createResult.noSendChange, signResult.txid),
+                signableTransaction: undefined
+            };
+        }
+        catch (error) {
+            this.forgetSentNoSendActionsInError(error);
+            await this.blockAndAbortAction(reference);
+            throw error;
+        }
     }
     /** Scans outputs to split P-scheme baskets from regular baskets; registers P-modules as a side effect. */
     collectNonPBaskets(outputs, pModulesByScheme) {
@@ -3049,8 +3250,6 @@ class WalletPermissionsManager {
     }
     /** Calls underlying createAction, chaining P-module request/response transforms when needed. */
     async callCreateActionWithPModules(finalArgs, pModulesByScheme, originator) {
-        if (pModulesByScheme.size === 0)
-            return await this.underlying.createAction(finalArgs, originator);
         const pModules = Array.from(pModulesByScheme.values());
         let transformedArgs = finalArgs;
         for (const module of pModules) {
@@ -3062,10 +3261,17 @@ class WalletPermissionsManager {
             transformedArgs = transformed.args;
         }
         let createResult = await this.underlying.createAction(transformedArgs, originator);
+        const exactWalletSpend = (0, exactActionSpend_1.getExactActionSpend)(createResult);
         for (let i = pModules.length - 1; i >= 0; i--) {
             createResult = await pModules[i].onResponse(createResult, { method: 'createAction', originator: originator });
         }
-        return createResult;
+        // Older local wallets may still attach the legacy symbol. Consume it for
+        // authorization, but never return it across a public BRC-100 boundary.
+        const { [exactActionSpend_1.exactActionSpendSymbol]: _legacySpend, ...publicResult } = createResult;
+        if (exactWalletSpend !== undefined) {
+            (0, exactActionSpend_1.setExactActionSpend)(publicResult, exactWalletSpend);
+        }
+        return publicResult;
     }
     /**
      * Computes the net satoshis the originator is spending in a createAction call,
@@ -3088,12 +3294,30 @@ class WalletPermissionsManager {
      * randomized by default, and a caller may legitimately request the same
      * script+amount more than once.
      *
+     * A sendMax output is requested with the `maxPossibleSatoshis` sentinel
+     * (see storage/methods/generateChange); storage's funding step rewrites it
+     * to the actual funded amount before returning the signable transaction, so
+     * it can never be matched by amount. Fixed-amount outputs are matched first,
+     * as an exact (script, satoshis) multiset exactly as before; any
+     * sentinel-valued requested output is then matched by locking script alone
+     * against whatever the fixed-amount pass left unused. Matching the sentinel
+     * only after fixed-amount outputs are claimed keeps a fixed output that
+     * happens to share the sentinel's locking script from being mis-paired with
+     * it. `generateChange` permits at most one `maxPossibleSatoshis` output per
+     * call; more than one sentinel-valued request is simply matched
+     * independently, first-fit, in requested order.
+     *
+     * @returns the resolved actual satoshis for each requested output index
+     * (identical to the request for a fixed-amount output; the real funded
+     * amount for a sendMax sentinel), so callers can bill the real amount
+     * instead of the sentinel.
      * @throws Error if any caller-requested output is absent from the transaction.
      */
     verifyRequestedOutputsPresent(tx, args) {
         const requested = args.outputs || [];
+        const resolved = new Map();
         if (requested.length === 0)
-            return;
+            return resolved;
         // All transaction outputs as (script hex, satoshis); each may satisfy at
         // most one requested output.
         const available = tx.outputs.map(o => ({
@@ -3101,27 +3325,53 @@ class WalletPermissionsManager {
             satoshis: o.satoshis,
             used: false
         }));
+        const sentinelIndexes = [];
+        // Pass 1: every fixed-amount request must match an exact (script, satoshis) pair.
         for (let i = 0; i < requested.length; i++) {
-            const wantScript = (requested[i].lockingScript ?? '').toLowerCase();
             const wantSats = requested[i].satoshis;
+            if (wantSats === maxPossibleSatoshis_1.maxPossibleSatoshis) {
+                sentinelIndexes.push(i);
+                continue;
+            }
+            const wantScript = (requested[i].lockingScript ?? '').toLowerCase();
             const match = available.find(a => !a.used && a.script === wantScript && a.satoshis === wantSats);
             if (match == null) {
                 throw new Error(`The transaction returned for signing does not contain caller-requested output ${i} ` +
                     `(locking script and amount). The recipient may have been substituted by storage.`);
             }
             match.used = true;
+            resolved.set(i, (0, validationHelpers_1.validateSatoshis)(match.satoshis, `signable transaction output ${i} satoshis`));
         }
+        // Pass 2: match each sendMax sentinel request by locking script only,
+        // against whatever pass 1 left unused.
+        for (const i of sentinelIndexes) {
+            const wantScript = (requested[i].lockingScript ?? '').toLowerCase();
+            const match = available.find(a => !a.used && a.script === wantScript);
+            if (match == null) {
+                throw new Error(`The transaction returned for signing does not contain caller-requested output ${i} ` +
+                    `(locking script and amount). The recipient may have been substituted by storage.`);
+            }
+            match.used = true;
+            resolved.set(i, (0, validationHelpers_1.validateSatoshis)(match.satoshis, `signable transaction output ${i} satoshis`));
+        }
+        return resolved;
     }
-    computeNetSpend(tx, args, originalInputDescriptions, originalOutputDescriptions) {
+    computeNetSpend(tx, args, originalInputDescriptions, originalOutputDescriptions, resolvedOutputSatoshis) {
         const lineItems = [];
         // Sum originator-provided inputs:
         let totalInputSatoshis = 0;
         for (const input of tx.inputs) {
-            const outpoint = `${input.sourceTXID}.${input.sourceOutputIndex}`;
+            const outpoint = this.inputOutpointForBinding(input);
             const matchingIndex = (args.inputs || []).findIndex(i => i.outpoint === outpoint);
             if (matchingIndex !== -1) {
-                const satoshis = input.sourceTransaction.outputs[input.sourceOutputIndex].satoshis;
-                totalInputSatoshis += satoshis;
+                if (input.sourceTransaction == null) {
+                    throw new Error('Caller-provided action input is missing its authenticated source transaction.');
+                }
+                const sourceOutput = input.sourceTransaction.outputs[input.sourceOutputIndex];
+                if (sourceOutput == null)
+                    throw new Error('Caller-provided action input source output is missing.');
+                const satoshis = (0, validationHelpers_1.validateSatoshis)(sourceOutput.satoshis, 'caller input satoshis');
+                totalInputSatoshis = this.checkedSatoshiTotal(totalInputSatoshis, satoshis, 'caller input total');
                 lineItems.push({
                     type: 'input',
                     description: originalInputDescriptions[matchingIndex] || 'No input description provided',
@@ -3129,31 +3379,228 @@ class WalletPermissionsManager {
                 });
             }
         }
-        // Sum originator-requested outputs:
-        const totalOutputSatoshis = (args.outputs || []).reduce((acc, out) => acc + out.satoshis, 0);
+        // Sum originator-requested outputs. A sendMax output's requested satoshis
+        // is the `maxPossibleSatoshis` sentinel, not its real cost; bill the
+        // actual funded amount that verifyRequestedOutputsPresent already resolved
+        // against the signable transaction instead of re-deriving it here (an
+        // independent re-lookup by script could mis-pair a fixed output that
+        // shares the sentinel's locking script).
+        let totalOutputSatoshis = 0;
         for (const outIndex in args.outputs || []) {
-            const out = args.outputs[outIndex];
+            const index = Number(outIndex);
+            const resolvedSatoshis = resolvedOutputSatoshis.get(index);
+            if (resolvedSatoshis == null) {
+                throw new Error(`Internal error: requested output ${index} was not resolved against the signable transaction.`);
+            }
+            const satoshis = (0, validationHelpers_1.validateSatoshis)(resolvedSatoshis, 'requested output satoshis');
+            totalOutputSatoshis = this.checkedSatoshiTotal(totalOutputSatoshis, satoshis, 'requested output total');
             lineItems.push({
                 type: 'output',
-                satoshis: out.satoshis,
-                description: originalOutputDescriptions[outIndex] || 'No output description provided'
+                satoshis,
+                description: originalOutputDescriptions[index] || 'No output description provided'
             });
         }
         // Add an entry for the transaction fee:
-        const fee = tx.getFee();
+        const fee = (0, validationHelpers_1.validateSatoshis)(tx.getFee(), 'network fee');
         lineItems.push({ type: 'fee', satoshis: fee, description: 'Network fee' });
         /**
          * Net spend = total foreign outflows minus total foreign inflows plus fee.
          * Domestic wallet inputs/change outputs are not counted — they are internal.
          */
-        const netSpent = totalOutputSatoshis + fee - totalInputSatoshis;
+        const grossSpent = this.checkedSatoshiTotal(totalOutputSatoshis, fee, 'gross action spend');
+        const netSpent = grossSpent - totalInputSatoshis;
+        if (!Number.isSafeInteger(netSpent) || netSpent < -MAX_MONEY_SATOSHIS || netSpent > MAX_MONEY_SATOSHIS) {
+            throw new Error('Net action spend is outside the supported monetary range.');
+        }
         return { netSpent, lineItems };
     }
+    checkedSatoshiTotal(left, right, label) {
+        const total = left + right;
+        if (!Number.isSafeInteger(total) || total < 0 || total > MAX_MONEY_SATOSHIS) {
+            throw new Error(`${label} is outside the supported monetary range.`);
+        }
+        return total;
+    }
+    inputOutpointForBinding(input) {
+        const embeddedTxid = input.sourceTransaction?.id('hex');
+        const explicitTxid = input.sourceTXID?.toLowerCase();
+        if (explicitTxid != null && embeddedTxid != null && explicitTxid !== embeddedTxid) {
+            throw new Error('Wallet action input source transaction is inconsistent.');
+        }
+        const txid = explicitTxid ?? embeddedTxid;
+        if (txid == null || !/^[0-9a-f]{64}$/.test(txid)) {
+            throw new Error('Wallet action input transaction ID is invalid.');
+        }
+        if (!Number.isSafeInteger(input.sourceOutputIndex) ||
+            input.sourceOutputIndex < 0 ||
+            input.sourceOutputIndex > 0xffffffff) {
+            throw new Error('Wallet action input output index is invalid.');
+        }
+        return `${txid}.${input.sourceOutputIndex}`;
+    }
+    /** Binds a wallet's final result to the exact template that passed authorization. */
+    assertAuthorizedSignResult(reference, spends, result) {
+        const authorized = this.pendingActionTemplates.get(reference);
+        if (authorized == null)
+            throw new Error('The authorized action template is unavailable.');
+        if (result.tx == null)
+            throw new Error('Wallet finalization omitted transaction data required for binding.');
+        const finalized = sdk_1.Transaction.fromAtomicBEEF(result.tx);
+        if (finalized.version !== authorized.version ||
+            finalized.lockTime !== authorized.lockTime ||
+            finalized.inputs.length !== authorized.inputs.length ||
+            finalized.outputs.length !== authorized.outputs.length) {
+            throw new Error('Wallet finalization substituted the authorized transaction template.');
+        }
+        for (let index = 0; index < authorized.inputs.length; index++) {
+            if (this.inputOutpointForBinding(finalized.inputs[index]) !==
+                this.inputOutpointForBinding(authorized.inputs[index]) ||
+                (finalized.inputs[index].sequence ?? 0xffffffff) !== (authorized.inputs[index].sequence ?? 0xffffffff)) {
+                throw new Error('Wallet finalization substituted an authorized transaction input.');
+            }
+            const authorizedScript = authorized.inputs[index].unlockingScript?.toHex() ?? '';
+            if (authorizedScript !== '' && finalized.inputs[index].unlockingScript?.toHex() !== authorizedScript) {
+                throw new Error('Wallet finalization substituted an existing unlocking script.');
+            }
+        }
+        for (let index = 0; index < authorized.outputs.length; index++) {
+            if (finalized.outputs[index].satoshis !== authorized.outputs[index].satoshis ||
+                finalized.outputs[index].lockingScript.toHex() !== authorized.outputs[index].lockingScript.toHex()) {
+                throw new Error('Wallet finalization substituted an authorized transaction output.');
+            }
+        }
+        for (const [indexText, spend] of Object.entries(spends ?? {})) {
+            if (!/^(0|[1-9]\d*)$/.test(indexText))
+                throw new Error('Signed input index is invalid.');
+            const index = Number(indexText);
+            if (!Number.isSafeInteger(index) || finalized.inputs[index] == null) {
+                throw new Error('Signed input index is invalid.');
+            }
+            if (typeof spend?.unlockingScript !== 'string' ||
+                !/^(?:[0-9a-f]{2})*$/i.test(spend.unlockingScript) ||
+                finalized.inputs[index].unlockingScript?.toHex().toLowerCase() !== spend.unlockingScript.toLowerCase()) {
+                throw new Error('Wallet finalization substituted an authorized unlocking script.');
+            }
+        }
+        const finalizedTxid = finalized.id('hex');
+        if (result.txid != null && result.txid.toLowerCase() !== finalizedTxid) {
+            throw new Error('Wallet finalization transaction ID does not match its transaction data.');
+        }
+    }
+    async blockAndAbortAction(reference) {
+        this.blockedActionReferences.add(reference);
+        const result = await this.underlying.abortAction({ reference });
+        if (result.aborted === true)
+            this.clearPendingAction(reference);
+    }
+    assertPendingActionOriginator(reference, originator, allowBlocked) {
+        if (!allowBlocked && this.blockedActionReferences.has(reference)) {
+            throw new WERR_errors_1.WERR_UNAUTHORIZED('This action was blocked after a failed authorization check.');
+        }
+        const expected = this.pendingActionOriginators.get(reference);
+        if (expected == null) {
+            throw new WERR_errors_1.WERR_UNAUTHORIZED('The action reference was not issued by this permissions manager.');
+        }
+        if (expected !== (originator ?? '')) {
+            throw new WERR_errors_1.WERR_UNAUTHORIZED('The action reference belongs to a different originator.');
+        }
+    }
+    bindPendingAction(reference, originator, noSend) {
+        if (this.pendingActionOriginators.has(reference)) {
+            throw new WERR_errors_1.WERR_UNAUTHORIZED('The action reference is already pending.');
+        }
+        this.pendingActionOriginators.set(reference, originator ?? '');
+        if (noSend)
+            this.pendingNoSendReferences.add(reference);
+    }
+    clearPendingAction(reference) {
+        this.pendingActionOriginators.delete(reference);
+        this.pendingActionTemplates.delete(reference);
+        this.blockedActionReferences.delete(reference);
+        this.pendingNoSendReferences.delete(reference);
+    }
+    /** Lets the originator that created a signed no-send action, and only it, abort it. */
+    recordNoSendAction(txid, originator, reference) {
+        const key = txid.toLowerCase();
+        const references = this.noSendActions.get(key)?.references ?? new Set();
+        this.noSendActions.set(key, { originator: originator ?? '', references });
+        if (reference !== undefined) {
+            references.add(reference);
+            this.noSendActionReferences.set(reference, key);
+        }
+    }
+    forgetNoSendAction(key) {
+        const action = this.noSendActions.get(key);
+        if (action == null)
+            return;
+        for (const reference of action.references) {
+            if (this.noSendActionReferences.get(reference) === key)
+                this.noSendActionReferences.delete(reference);
+        }
+        this.noSendActions.delete(key);
+    }
+    /** Positive broadcast/queue results retire ownership; failures remain retryable. */
+    forgetSentNoSendActions(results) {
+        for (const result of results ?? []) {
+            if (result.status === 'sending' || result.status === 'unproven') {
+                this.forgetNoSendAction(result.txid.toLowerCase());
+            }
+        }
+    }
+    forgetSentNoSendActionsInError(error) {
+        // Undelayed mixed batches report successful members alongside failures in
+        // this error. Preserve the error and every member without positive evidence.
+        if (error instanceof WERR_errors_1.WERR_REVIEW_ACTIONS || error instanceof sdk_1.WERR_REVIEW_ACTIONS) {
+            this.forgetSentNoSendActions(error.sendWithResults);
+        }
+    }
     async signAction(...args) {
-        return await this.underlying.signAction(...args);
+        const [requestArgs, originator] = args;
+        this.assertPendingActionOriginator(requestArgs.reference, originator, false);
+        // The wallet takes noSend from signAction's options, else from createAction's.
+        const noSend = (requestArgs.options?.noSend ?? this.pendingNoSendReferences.has(requestArgs.reference)) === true;
+        try {
+            const result = await this.underlying.signAction({
+                ...requestArgs,
+                options: { ...requestArgs.options, returnTXIDOnly: false }
+            }, originator);
+            this.assertAuthorizedSignResult(requestArgs.reference, requestArgs.spends, result);
+            this.clearPendingAction(requestArgs.reference);
+            if (noSend && result.txid != null) {
+                this.recordNoSendAction(result.txid, originator, requestArgs.reference);
+            }
+            this.forgetSentNoSendActions(result.sendWithResults);
+            return result;
+        }
+        catch (error) {
+            this.forgetSentNoSendActionsInError(error);
+            await this.blockAndAbortAction(requestArgs.reference);
+            throw error;
+        }
     }
     async abortAction(...args) {
-        return await this.underlying.abortAction(...args);
+        const [requestArgs, originator] = args;
+        // Pending references live in memory only. The admin may abort any of the
+        // wallet's actions, including signed noSend actions and earlier sessions'.
+        // A signed no-send action is found by the reference it was signed under or by its txid.
+        const noSendKey = typeof requestArgs.reference === 'string'
+            ? (this.noSendActionReferences.get(requestArgs.reference) ?? requestArgs.reference.toLowerCase())
+            : '';
+        const noSendOriginator = this.noSendActions.get(noSendKey)?.originator;
+        if (originator === undefined || !this.isAdminOriginator(originator)) {
+            if (noSendOriginator === undefined) {
+                this.assertPendingActionOriginator(requestArgs.reference, originator, true);
+            }
+            else if (noSendOriginator !== (originator ?? '')) {
+                throw new WERR_errors_1.WERR_UNAUTHORIZED('The action reference belongs to a different originator.');
+            }
+        }
+        const result = await this.underlying.abortAction(...args);
+        if (result.aborted === true) {
+            this.clearPendingAction(requestArgs.reference);
+            this.forgetNoSendAction(noSendKey);
+        }
+        return result;
     }
     async listActions(...args) {
         const [requestArgs, originator] = args;
@@ -3568,6 +4015,8 @@ class WalletPermissionsManager {
                 usageType: 'generic'
             });
         }
+        // The underlying wallet may satisfy this with a caller-installed local trust anchor or the
+        // certificate overlay. This permission gate authorizes resolution, not external certification.
         return await this.underlying.discoverByIdentityKey(...args);
     }
     async discoverByAttributes(...args) {
@@ -3582,6 +4031,8 @@ class WalletPermissionsManager {
                 usageType: 'generic'
             });
         }
+        // The underlying wallet may satisfy this with a caller-installed local trust anchor or the
+        // certificate overlay. This permission gate authorizes resolution, not external certification.
         return await this.underlying.discoverByAttributes(...args);
     }
     async isAuthenticated(...args) {
@@ -3768,7 +4219,11 @@ class WalletPermissionsManager {
         }
         return true;
     }
-    /** Normalizes and canonicalizes originator domains (e.g., lowercase + drop default ports). */
+    /**
+     * Normalizes originator domains to their lowercase hostname. BRC-100
+     * permission authority is hostname-scoped, so every port shares the same
+     * grants and admin status.
+     */
     normalizeOriginator(originator) {
         if (!originator)
             return '';
@@ -3786,12 +4241,7 @@ class WalletPermissionsManager {
             const hostname = url.hostname.toLowerCase();
             const needsBrackets = hostname.includes(':');
             const baseHost = needsBrackets ? `[${hostname}]` : hostname;
-            const port = url.port;
-            const defaultPort = WalletPermissionsManager.DEFAULT_PORTS[url.protocol];
-            if (port && defaultPort && port === defaultPort) {
-                return baseHost;
-            }
-            return port ? `${baseHost}:${port}` : baseHost;
+            return baseHost;
         }
         catch {
             // Fall back to a conservative lowercase trim if URL parsing fails.
@@ -3822,8 +4272,37 @@ class WalletPermissionsManager {
         if (!trimmed) {
             throw new Error('Originator is required for permission checks.');
         }
+        if (/^[a-zA-Z][a-zA-Z\d+\-.]*:\/\//.test(trimmed)) {
+            throw new Error('Originator must be a domain name with an optional port, without a URL scheme.');
+        }
+        let parsed;
+        try {
+            parsed = new URL(`https://${trimmed}`);
+        }
+        catch {
+            throw new Error('Originator must be a valid domain name with an optional port.');
+        }
+        if (parsed.username !== '' ||
+            parsed.password !== '' ||
+            parsed.pathname !== '/' ||
+            parsed.search !== '' ||
+            parsed.hash !== '') {
+            throw new Error('Originator must not contain credentials, a path, query parameters, or a fragment.');
+        }
+        const hostname = parsed.hostname.toLowerCase();
+        if (hostname.includes(':') || /^\d+(?:\.\d+){3}$/u.test(hostname)) {
+            throw new Error('IP address originators are not permitted.');
+        }
+        if (hostname !== 'localhost' &&
+            !hostname.split('.').every(label => /^[a-z\d](?:[a-z\d-]{0,61}[a-z\d])?$/u.test(label))) {
+            throw new Error('Originator must be a valid DNS hostname.');
+        }
         const normalized = this.normalizeOriginator(trimmed) || trimmed.toLowerCase();
-        const lookupValues = Array.from(new Set([trimmed, normalized])).filter(Boolean);
+        // Search both current canonical tags and exact legacy tags first. The
+        // untagged bounded fallback lets a grant minted for another port on this
+        // hostname remain usable; decoded token fields are still authenticated and
+        // compared to `normalized` before acceptance.
+        const lookupValues = Array.from(new Set([trimmed, normalized, undefined]));
         return { normalized, lookupValues };
     }
     /**
@@ -3859,6 +4338,10 @@ class WalletPermissionsManager {
     }
     buildActiveRequestKey(r) {
         const base = this.buildRequestKey(r);
+        if (r.type === 'spending') {
+            this.spendingRequestSequence += 1;
+            return `${base}:request:${this.spendingRequestSequence}`;
+        }
         if (r.type === 'protocol' || r.type === 'basket' || r.type === 'certificate') {
             return `${base}:${r.usageType ?? ''}`;
         }