@bsv/wallet-toolbox 2.13.0 → 2.13.2

package/out/src/WalletPermissionsManager.js

@@ -1,9 +1,50 @@
 "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");
+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;
@@ -125,6 +166,13 @@ 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();
+    permissionTokenLockingKeyPromise;
     /**
      * Token mints currently being written on-chain, keyed by permission cache
      * key. A granted permission is only cached once its token finishes minting
@@ -143,6 +191,8 @@ class WalletPermissionsManager {
     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();
     /**
@@ -158,11 +208,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.
      */
@@ -1120,11 +1165,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);
@@ -1139,6 +1195,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;
@@ -1151,6 +1210,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;
@@ -1743,7 +1845,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,
@@ -1765,7 +1867,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;
@@ -1783,6 +1885,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
@@ -1803,6 +1959,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
@@ -1813,11 +1972,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.
@@ -1827,11 +1986,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
@@ -1845,32 +2004,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 &&
@@ -1895,16 +2055,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 {
@@ -1920,20 +2079,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;
@@ -1957,61 +2115,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) {
@@ -2022,7 +2133,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, {
@@ -2052,7 +2164,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))
@@ -2078,9 +2191,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);
@@ -2099,9 +2213,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, {
@@ -2126,29 +2246,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,
@@ -2224,7 +2343,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: [
                 {
@@ -2241,7 +2360,7 @@ class WalletPermissionsManager {
                 // last-resort funding source for the resumed request.
                 acceptDelayedBroadcast: true
             }
-        }, this.adminOriginator);
+        });
     }
     async mapWithConcurrency(items, concurrency, fn) {
         if (items.length === 0)
@@ -2273,9 +2392,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);
@@ -2309,11 +2427,11 @@ class WalletPermissionsManager {
         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);
     }
@@ -2323,9 +2441,9 @@ class WalletPermissionsManager {
             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) => ({
@@ -2339,28 +2457,23 @@ 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)
             throw new Error('No permission tokens to coalesce');
@@ -2370,9 +2483,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) => ({
@@ -2394,29 +2507,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.
@@ -2449,7 +2541,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: [
@@ -2471,18 +2563,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]);
         }
     }
     /**
@@ -2583,7 +2664,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 }) {
@@ -2603,12 +2687,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;
@@ -2677,25 +2760,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(),
@@ -2745,27 +2827,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
@@ -2809,28 +2892,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(),
@@ -2913,9 +2997,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) => ({
@@ -2928,37 +3012,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.
@@ -2966,7 +3020,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: [
@@ -2979,30 +3033,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);
@@ -3039,10 +3076,16 @@ class WalletPermissionsManager {
         let createResult = await this.callCreateActionWithPModules(finalArgs, pModulesByScheme, originator);
         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
+        if (this.pendingActionOriginators.has(reference)) {
+            throw new WERR_errors_1.WERR_UNAUTHORIZED('The action reference is already pending.');
+        }
+        this.pendingActionOriginators.set(reference, originator ?? '');
+        // 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
@@ -3051,16 +3094,25 @@ class WalletPermissionsManager {
         // recipient. The signer (buildSignableTransaction) rejects this at the
         // source; this is an independent check at the permissions layer.
         try {
+            const tx = sdk_1.Transaction.fromAtomicBEEF(createResult.signableTransaction.tx);
             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 {
+            let { netSpent, lineItems } = this.computeNetSpend(tx, args, originalInputDescriptions, originalOutputDescriptions);
+            const exactWalletSpend = createResult[exactActionSpend_1.exactActionSpendSymbol];
+            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,
@@ -3069,17 +3121,29 @@ class WalletPermissionsManager {
                     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);
+            return { ...createResult, ...signResult, signableTransaction: undefined };
+        }
+        catch (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) {
@@ -3152,9 +3216,14 @@ class WalletPermissionsManager {
             transformedArgs = transformed.args;
         }
         let createResult = await this.underlying.createAction(transformedArgs, originator);
+        const exactWalletSpend = createResult[exactActionSpend_1.exactActionSpendSymbol];
         for (let i = pModules.length - 1; i >= 0; i--) {
             createResult = await pModules[i].onResponse(createResult, { method: 'createAction', originator: originator });
         }
+        if (exactWalletSpend !== undefined) {
+            ;
+            createResult[exactActionSpend_1.exactActionSpendSymbol] = exactWalletSpend;
+        }
         return createResult;
     }
     /**
@@ -3207,11 +3276,17 @@ class WalletPermissionsManager {
         // 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',
@@ -3220,30 +3295,151 @@ class WalletPermissionsManager {
             }
         }
         // Sum originator-requested outputs:
-        const totalOutputSatoshis = (args.outputs || []).reduce((acc, out) => acc + out.satoshis, 0);
+        let totalOutputSatoshis = 0;
         for (const outIndex in args.outputs || []) {
             const out = args.outputs[outIndex];
+            const satoshis = (0, validationHelpers_1.validateSatoshis)(out.satoshis, 'requested output satoshis');
+            totalOutputSatoshis = this.checkedSatoshiTotal(totalOutputSatoshis, satoshis, 'requested output total');
             lineItems.push({
                 type: 'output',
-                satoshis: out.satoshis,
+                satoshis,
                 description: originalOutputDescriptions[outIndex] || '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.');
+        }
+    }
+    clearPendingAction(reference) {
+        this.pendingActionOriginators.delete(reference);
+        this.pendingActionTemplates.delete(reference);
+        this.blockedActionReferences.delete(reference);
+    }
     async signAction(...args) {
-        return await this.underlying.signAction(...args);
+        const [requestArgs, originator] = args;
+        this.assertPendingActionOriginator(requestArgs.reference, originator, false);
+        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);
+            return result;
+        }
+        catch (error) {
+            await this.blockAndAbortAction(requestArgs.reference);
+            throw error;
+        }
     }
     async abortAction(...args) {
-        return await this.underlying.abortAction(...args);
+        const [requestArgs, originator] = args;
+        this.assertPendingActionOriginator(requestArgs.reference, originator, true);
+        const result = await this.underlying.abortAction(...args);
+        if (result.aborted === true)
+            this.clearPendingAction(requestArgs.reference);
+        return result;
     }
     async listActions(...args) {
         const [requestArgs, originator] = args;
@@ -3658,6 +3854,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) {
@@ -3672,6 +3870,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) {
@@ -3858,7 +4058,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 '';
@@ -3876,12 +4080,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.
@@ -3912,8 +4111,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 };
     }
     /**