@1sat/permission-module 0.0.50 → 0.0.51

package/dist/enrichIntent.js

@@ -7,8 +7,8 @@
  * before dispatching to permission modules — so we can't read them.
  * What's left:
  *
- *   - `args.labels`            — unencrypted; carries our `'p 1sat input <basket> <id>'`
- *                                / `'p 1sat output <basket> <id>'` lookup keys
+ *   - `args.labels`            — unencrypted; carries our `'p <scheme> input <key>'`
+ *                                lookup keys
  *   - `args.outputs[i].lockingScript` — decode P2PKH for recipient address
  *   - `args.outputs[i].satoshis`
  *
@@ -18,10 +18,15 @@
  * committed to the final tx). The dApp can't lie about what the user
  * is being asked to approve.
  */
-import { BAP_BASKET, BSOCIAL_BASKET, BSV21_AUTH_BASKET, BSV21_BASKET, LOCK_BASKET, ORDFS_HOST, OPNS_BASKET, ORDINALS_BASKET, P1SAT_BASKET_PREFIX, P1SAT_INPUT_LABEL_PREFIX, SIGMA_BASKET, parseIntentLabel, } from '@1sat/types';
-import { Lock, OrdLock, outpointFromBytes } from '@1sat/templates';
+import { BAP_BASKET, BSOCIAL_BASKET, BSV21_BASKET, LOCK_BASKET, ORDFS_HOST, OPNS_BASKET, ORDINALS_BASKET, SIGMA_BASKET, formatOrdinalOutpoint, parseInputAssetLabels, } from '@1sat/types';
+import { BSV21, Inscription, Lock, OrdLock, outpointFromBytes, Sigma, } from '@1sat/templates';
 import { parseAddress } from '@1sat/wallet';
 import { LockingScript, PushDrop, Script, Utils } from '@bsv/sdk';
+/** Same protocol WPM uses for description/CI encryption. */
+const METADATA_ENCRYPTION_PROTOCOL = [
+    2,
+    'admin metadata encryption',
+];
 /**
  * Presentation fields on an OpNS bind: field 0 is the identity key and the
  * last is the signature, so field 1 is the display name and field 2 the
@@ -52,7 +57,6 @@ function decodeOpnsProfile(script) {
 const ASSET_BASKETS = [
     ORDINALS_BASKET,
     BSV21_BASKET,
-    BSV21_AUTH_BASKET,
     LOCK_BASKET,
     OPNS_BASKET,
     BSOCIAL_BASKET,
@@ -67,19 +71,27 @@ export async function enrichIntent(wallet, args, opts = {}) {
         ? (origin) => ordfs.getContentUrl?.(origin)
         : undefined;
     const labels = args.labels ?? [];
-    const p1satIntent = parseIntentLabel(labels);
-    const inputRefs = parseAssetLabels(labels, P1SAT_INPUT_LABEL_PREFIX);
+    const inputRefs = parseInputAssetLabels(labels);
     const inputs = (await Promise.all(inputRefs.map((ref) => lookupAsset(wallet, ref.basket, ref.id)))).filter((a) => a !== null);
-    const outputs = (args.outputs ?? []).map((out, i) => decodeOutput(out, i, chain));
-    const kind = detectKind(inputs, outputs, p1satIntent);
-    const summary = buildSummary(kind, inputs, outputs, p1satIntent);
-    const trust = initialTrust(p1satIntent);
+    const outputs = await Promise.all((args.outputs ?? []).map(async (out, i) => {
+        const decoded = decodeOutput(out, i, chain);
+        if (decoded.customInstructions) {
+            decoded.customInstructions = await maybeDecryptCustomInstructions(wallet, decoded.customInstructions);
+        }
+        return decoded;
+    }));
+    const kind = detectKind(inputs, outputs);
+    const summary = buildSummary(kind, inputs, outputs);
+    const trust = initialTrust(kind);
     const fee = extractIndexerFee(args, outputs);
+    const ordinalEdges = buildOrdinalEdges(inputs, outputs);
+    const legs = buildLegs(inputs, outputs, ordinalEdges);
     return {
         kind,
-        p1satIntent,
         inputs,
         outputs,
+        legs,
+        ordinalEdges,
         labels,
         summary,
         contentUrlForOrigin: (origin) => getContentUrl?.(origin) ?? contentUrlFromOrigin(ORDFS_HOST, origin),
@@ -96,14 +108,11 @@ export async function enrichIntent(wallet, args, opts = {}) {
  * meaningless or a lie, and outputs are dApp-authored besides. Nothing
  * persisted may influence the badge.
  *
- * Every purchase therefore starts `unverified`; `verifyIntent` upgrades it if
- * and when a service positively answers.
+ * Purchases and BSV21 transfers start `unverified`; `verifyIntent` upgrades
+ * them when the overlay positively answers (token active + inputs valid).
  */
-function initialTrust(p1satIntent) {
-    const isPurchase = p1satIntent === 'ordinal.purchase' ||
-        p1satIntent === 'opns.purchase' ||
-        p1satIntent === 'bsv21.purchase';
-    if (!isPurchase)
+function initialTrust(kind) {
+    if (kind !== 'purchase' && kind !== 'token-transfer')
         return undefined;
     return { state: 'unverified' };
 }
@@ -143,26 +152,43 @@ function extractIndexerFee(args, outputs) {
         : `${feeSats.toLocaleString()} sats overlay fee`;
     return { indexerFeeSats: feeSats, indexerFeeNote: note };
 }
-function parseAssetLabels(labels, prefix) {
-    const refs = [];
-    for (const label of labels) {
-        if (!label.startsWith(prefix))
-            continue;
-        const payload = label.slice(prefix.length).trim();
-        const sep = payload.indexOf(' ');
-        if (sep <= 0)
-            continue;
-        const suffix = payload.slice(0, sep);
-        const id = payload.slice(sep + 1).trim();
-        if (!suffix || !id)
-            continue;
-        refs.push({ basket: `${P1SAT_BASKET_PREFIX}${suffix}`, id });
-    }
-    return refs;
-}
 // ---------------------------------------------------------------------------
 // Asset lookup — indexed `listOutputs` query by `id:<id>` tag.
 // ---------------------------------------------------------------------------
+/**
+ * WPM may encrypt customInstructions before storage / before module onRequest.
+ * Base-wallet listOutputs returns ciphertext. Never mutate plaintext:
+ *  1. If it already parses as JSON → return as-is (base-wallet writes).
+ *  2. Else try decrypt; on failure return original unchanged.
+ */
+async function maybeDecryptCustomInstructions(wallet, value) {
+    if (!value)
+        return undefined;
+    // Fast path: plaintext JSON (or anything that is already valid JSON).
+    try {
+        JSON.parse(value);
+        return value;
+    }
+    catch {
+        // not JSON — may be WPM base64 ciphertext
+    }
+    try {
+        const { plaintext } = await wallet.decrypt({
+            ciphertext: Utils.toArray(value, 'base64'),
+            protocolID: METADATA_ENCRYPTION_PROTOCOL,
+            keyID: '1',
+            counterparty: 'self',
+        });
+        const text = Utils.toUTF8(plaintext);
+        // Only accept decrypt if result is usable JSON — avoids "decrypting"
+        // random strings into garbage we then treat as CI.
+        JSON.parse(text);
+        return text;
+    }
+    catch {
+        return value;
+    }
+}
 async function lookupAsset(wallet, basket, id) {
     // Only query baskets the module knows about — guards against malicious
     // labels pointing at unrelated baskets.
@@ -180,13 +206,15 @@ async function lookupAsset(wallet, basket, id) {
         const match = result.outputs[0];
         if (!match)
             return null;
+        const rawCi = match.customInstructions;
+        const customInstructions = await maybeDecryptCustomInstructions(wallet, rawCi);
         return {
             basket,
             id,
             outpoint: match.outpoint,
             satoshis: match.satoshis,
             tags: match.tags ?? [],
-            customInstructions: match.customInstructions,
+            customInstructions,
         };
     }
     catch {
@@ -202,6 +230,9 @@ function decodeOutput(out, index, chain) {
         satoshis: out.satoshis ?? 0,
         basket: out.basket,
         tags: out.tags ?? [],
+        template: 'unrecognized',
+        customInstructions: out.customInstructions,
+        ...(out.lockingScript ? { lockingScript: out.lockingScript } : {}),
     };
     if (!out.lockingScript)
         return enriched;
@@ -212,32 +243,511 @@ function decodeOutput(out, index, chain) {
     catch {
         return enriched;
     }
-    const ordLock = OrdLock.decode(script, chain === 'mainnet');
+    const classified = classifyScript(script, chain, out.basket);
+    Object.assign(enriched, classified);
+    Object.assign(enriched, inscriptionPreviewFromScript(script));
+    if (out.basket === OPNS_BASKET || classified.template === 'pushdrop') {
+        Object.assign(enriched, decodeOpnsProfile(script));
+    }
+    // Tag fallbacks when script didn't carry sym/id (self-kept rows).
+    if (!enriched.tokenId) {
+        const tid = tagValue(enriched.tags, 'bsv21');
+        if (tid && tid !== 'deploy')
+            enriched.tokenId = tid;
+    }
+    if (!enriched.tokenAmt) {
+        const amt = tagValue(enriched.tags, 'amt');
+        if (amt)
+            enriched.tokenAmt = amt;
+    }
+    if (!enriched.tokenSym) {
+        const sym = displayFieldFrom('sym', enriched.tags, enriched.customInstructions);
+        if (sym)
+            enriched.tokenSym = sym;
+    }
+    if (enriched.tags.includes('fee:overlay') ||
+        enriched.tags.some((t) => t.startsWith('indexer-fee'))) {
+        enriched.isIndexerFee = true;
+    }
+    return enriched;
+}
+function classifyScript(script, chain, basket) {
+    const main = chain === 'mainnet';
+    const ordLock = OrdLock.decode(script, main);
     if (ordLock) {
-        enriched.listingPriceSats = Number(ordLock.price);
-        enriched.listingSeller = ordLock.seller;
+        return {
+            template: 'ordlock',
+            listingPriceSats: Number(ordLock.price),
+            listingSeller: ordLock.seller,
+        };
     }
-    const lock = Lock.decode(script, chain === 'mainnet');
+    const lock = Lock.decode(script, main);
     if (lock) {
-        enriched.lockUntilHeight = lock.until;
+        return {
+            template: 'lock',
+            lockUntilHeight: lock.until,
+        };
     }
-    if (out.basket === OPNS_BASKET) {
-        Object.assign(enriched, decodeOpnsProfile(script));
+    const bsv21 = BSV21.decode(script);
+    if (bsv21) {
+        const d = bsv21.tokenData;
+        // amt is the BSV21 inscription amount (base units), never satoshis.
+        const tokenAmt = d.amt != null && String(d.amt).length > 0 ? String(d.amt) : undefined;
+        return {
+            template: 'bsv21',
+            ...(d.id ? { tokenId: d.id } : {}),
+            ...(tokenAmt ? { tokenAmt } : {}),
+            ...(d.sym ? { tokenSym: d.sym } : {}),
+            ...(d.op ? { tokenOp: d.op } : {}),
+            ...p2pkhRecipient(script, chain),
+        };
     }
-    const recipient = parseAddress(script, 0, chain);
-    if (recipient) {
-        enriched.recipient = recipient;
-        return enriched;
+    if (scriptContainsAscii(script, 'SIGMA') || Sigma.countInstances(script) > 0) {
+        const sealPending = hasZeroedSigmaSig(script);
+        return {
+            template: 'sigma',
+            sealKind: 'sigma',
+            ...(sealPending ? { sealPending: true } : {}),
+            ...p2pkhRecipient(script, chain),
+        };
+    }
+    try {
+        const fields = PushDrop.decode(LockingScript.fromHex(script.toHex())).fields;
+        if (fields.length >= 2) {
+            const last = fields[fields.length - 1];
+            const sealPending = !!last?.length && last.every((b) => b === 0);
+            return {
+                template: 'pushdrop',
+                ...(sealPending
+                    ? { sealPending: true, sealKind: 'pushdrop' }
+                    : {}),
+            };
+        }
+    }
+    catch {
+        // not PushDrop
+    }
+    const recipient = p2pkhRecipient(script, chain);
+    if (recipient.recipient) {
+        return { template: 'p2pkh', ...recipient };
     }
-    // Inscription envelope or other suffix-bearing scripts — try parsing
-    // P2PKH after OP_ENDIF.
+    return { template: basket ? 'unrecognized' : 'unrecognized' };
+}
+const PREVIEW_TEXT_MAX = 800;
+function inscriptionPreviewFromScript(script) {
+    const insc = Inscription.decode(script);
+    if (!insc?.file)
+        return {};
+    const type = insc.file.type.split(';')[0]?.trim() || '';
+    const bytes = Array.from(insc.file.content);
+    if (bytes.length === 0) {
+        return type ? { inscriptionType: type } : {};
+    }
+    const lower = type.toLowerCase();
+    if (lower.startsWith('image/')) {
+        return {
+            inscriptionType: type,
+            inscriptionDataUrl: `data:${type};base64,${Utils.toBase64(bytes)}`,
+        };
+    }
+    try {
+        let text = Utils.toUTF8(bytes);
+        if (lower.includes('json')) {
+            try {
+                text = JSON.stringify(JSON.parse(text), null, 2);
+            }
+            catch {
+                // keep raw
+            }
+        }
+        return {
+            inscriptionType: type,
+            inscriptionText: text.slice(0, PREVIEW_TEXT_MAX),
+        };
+    }
+    catch {
+        return type ? { inscriptionType: type } : {};
+    }
+}
+function p2pkhRecipient(script, chain) {
+    const recipient = parseAddress(script, 0, chain);
+    if (recipient)
+        return { recipient };
     const endifIndex = script.chunks.findIndex((c) => c.op === 0x68);
     if (endifIndex > 0) {
         const after = parseAddress(script, endifIndex + 1, chain);
         if (after)
-            enriched.recipient = after;
+            return { recipient: after };
     }
-    return enriched;
+    return {};
+}
+function scriptContainsAscii(script, ascii) {
+    const needle = Utils.toArray(ascii);
+    const hay = script.toBinary();
+    if (hay.length < needle.length)
+        return false;
+    outer: for (let i = 0; i <= hay.length - needle.length; i++) {
+        for (let j = 0; j < needle.length; j++) {
+            if (hay[i + j] !== needle[j])
+                continue outer;
+        }
+        return true;
+    }
+    return false;
+}
+/**
+ * True when a SIGMA tape's signature push is still the zero placeholder.
+ * Parses the real tape (`SIGMA · algo · address · sig · vin`) via
+ * {@link Sigma.parseFromScript} — not a raw zero-run hunt after the marker
+ * (BSM + address sit between SIGMA and the sig field).
+ */
+function hasZeroedSigmaSig(script) {
+    try {
+        const sigs = Sigma.parseFromScript(script);
+        for (const s of sigs) {
+            const bytes = Utils.toArray(s.signature, 'base64');
+            if (bytes.length > 0 && bytes.every((b) => b === 0))
+                return true;
+        }
+    }
+    catch {
+        // unparseable tape
+    }
+    return false;
+}
+/** Prefer case-preserving CI name over lowercased `name:` tags. */
+function displayNameFrom(tags, customInstructions, scriptName) {
+    if (scriptName)
+        return scriptName;
+    if (customInstructions) {
+        try {
+            const n = JSON.parse(customInstructions).name;
+            if (typeof n === 'string' && n.trim())
+                return n.trim();
+        }
+        catch {
+            // ignore
+        }
+    }
+    return tagValue(tags, 'name');
+}
+/**
+ * Case-preserving field from customInstructions (BRC-100 lowercases tags).
+ * Falls back to the matching tag when CI is missing.
+ */
+function displayFieldFrom(field, tags, customInstructions) {
+    if (customInstructions) {
+        try {
+            const v = JSON.parse(customInstructions)[field];
+            if (typeof v === 'string' && v.trim())
+                return v.trim();
+        }
+        catch {
+            // ignore
+        }
+    }
+    return tagValue(tags, field);
+}
+function isCollectableBasket(basket) {
+    return (basket === ORDINALS_BASKET ||
+        basket === OPNS_BASKET ||
+        // plain-name future + legacy
+        basket === '1sat' ||
+        !!basket?.includes('ordinal') ||
+        !!basket?.includes('opns'));
+}
+/**
+ * Pair collectable spends with their next tip/listing (BRC-303 shapes).
+ */
+function buildOrdinalEdges(inputs, outputs) {
+    const edges = [];
+    const usedOut = new Set();
+    const takeOut = (pred) => {
+        const hit = outputs.find((o) => !usedOut.has(o.index) && pred(o));
+        if (hit)
+            usedOut.add(hit.index);
+        return hit;
+    };
+    const collectableIns = inputs.filter((i) => isCollectableBasket(i.basket) || hasListingTags(i.tags));
+    const usedIn = new Set();
+    for (const inp of collectableIns) {
+        usedIn.add(inp.id);
+        const name = displayNameFrom(inp.tags, inp.customInstructions);
+        const origin = tagValue(inp.tags, 'origin');
+        const spend = {
+            basket: inp.basket,
+            id: inp.id,
+            outpoint: inp.outpoint,
+            satoshis: inp.satoshis,
+            tags: inp.tags,
+            ...(name ? { name } : {}),
+            ...(origin ? { origin } : {}),
+            isListing: hasListingTags(inp.tags),
+        };
+        if (hasListingTags(inp.tags)) {
+            // cancel: listing in → held collectable out (not ordlock)
+            const create = takeOut((o) => isCollectableBasket(o.basket) &&
+                o.template !== 'ordlock' &&
+                o.satoshis === 1);
+            edges.push(edge('cancel-listing', spend, create, name ? `Cancel listing of “${name}”` : 'Cancel listing', 'Return collectable from marketplace lock'));
+            continue;
+        }
+        const listOut = takeOut((o) => o.template === 'ordlock' && o.satoshis === 1);
+        if (listOut) {
+            const price = listOut.listingPriceSats;
+            edges.push(edge('list', spend, listOut, name ? `List “${name}”` : 'List collectable', price != null
+                ? `List for ${price} sats`
+                : 'List on marketplace lock'));
+            continue;
+        }
+        // OpNS register / unregister.
+        const isOpnsSpend = inp.basket === OPNS_BASKET ||
+            !!inp.basket?.includes('opns') ||
+            inp.tags.some((t) => t.startsWith('opns:') || t === 'opns');
+        if (isOpnsSpend) {
+            const registerOut = takeOut((o) => o.template === 'pushdrop' &&
+                (o.sealPending ||
+                    o.tags.includes('opns:published') ||
+                    o.basket === OPNS_BASKET ||
+                    !!o.basket?.includes('opns')));
+            if (registerOut) {
+                // Domain is the owned OpNS name; profile is presentation only.
+                const domain = name;
+                edges.push(edge('register', spend, registerOut, domain ? `Publish “${domain}”` : 'Publish OpNS name', registerOut.sealPending
+                    ? 'Sign PushDrop identity bind'
+                    : 'OpNS identity bind'));
+                continue;
+            }
+            // Unpublish: was bound → plain P2PKH keep in OPNS basket (drops bind).
+            // Self-P2PKH still decodes a recipient address — basket + dropped
+            // published tag is what distinguishes this from an external send.
+            const wasPublished = inp.tags.includes('opns:published');
+            if (wasPublished) {
+                const unregOut = takeOut((o) => o.satoshis === 1 &&
+                    o.template === 'p2pkh' &&
+                    (o.basket === OPNS_BASKET || !!o.basket?.includes('opns')) &&
+                    !o.tags.includes('opns:published'));
+                if (unregOut) {
+                    edges.push(edge('unregister', spend, 
+                    // Don't surface self-P2PKH address as a "To".
+                    { ...unregOut, recipient: undefined }, name ? `Unpublish “${name}”` : 'Unpublish OpNS name', 'Remove identity bind'));
+                    continue;
+                }
+            }
+        }
+        const next = takeOut((o) => (isCollectableBasket(o.basket) || o.satoshis === 1) &&
+            o.template !== 'ordlock');
+        if (!next) {
+            edges.push(edge('burn', spend, undefined, name ? `Burn “${name}”` : 'Burn collectable', 'No collectable output — tip ends'));
+            continue;
+        }
+        // transfer: external only when the collectable leaves the wallet basket
+        const external = Boolean(next.recipient) && !next.basket;
+        edges.push(edge('transfer', spend, external ? next : { ...next, recipient: undefined }, name
+            ? external
+                ? `Send “${name}”`
+                : `Move “${name}”`
+            : external
+                ? 'Send collectable'
+                : 'Move collectable', external && next.recipient
+            ? `To ${truncate(next.recipient, 18)}`
+            : 'Move collectable'));
+    }
+    // purchase / inscribe: collectable outs with no matching wallet spend
+    for (const out of outputs) {
+        if (usedOut.has(out.index))
+            continue;
+        if (!isCollectableBasket(out.basket) && out.template !== 'ordlock') {
+            // 1-sat sigma/inscribe without basket still counts
+            if (!(out.satoshis === 1 && (out.template === 'sigma' || out.sealPending))) {
+                continue;
+            }
+        }
+        if (out.template === 'ordlock')
+            continue;
+        const name = displayNameFrom(out.tags, out.customInstructions, out.opnsProfileName);
+        const origin = tagValue(out.tags, 'origin');
+        const hasSellerPay = outputs.some((o) => !o.basket && o.recipient && o.satoshis > 1);
+        const bareOrigin = out.tags.includes('origin');
+        if (hasSellerPay && collectableIns.length === 0) {
+            usedOut.add(out.index);
+            edges.push(edge('purchase', undefined, out, name ? `Buy “${name}”` : 'Buy collectable', 'Receive collectable from marketplace'));
+            continue;
+        }
+        if (collectableIns.length === 0 || bareOrigin || out.template === 'sigma') {
+            usedOut.add(out.index);
+            edges.push(edge('inscribe', undefined, out, name ? `Inscribe “${name}”` : 'Create inscription', out.sealPending
+                ? 'New origin (signature seal pending)'
+                : 'New collectable output'));
+        }
+    }
+    return edges;
+}
+function edge(operation, spend, create, title, summary) {
+    const name = displayNameFrom(create?.tags, create?.customInstructions, create?.opnsProfileName) ?? spend?.name;
+    const origin = tagValue(create?.tags, 'origin') ?? spend?.origin;
+    const contentType = contentTypeFromTags(create?.tags ?? spend?.tags);
+    return {
+        operation,
+        title,
+        summary,
+        ...(spend ? { spend } : {}),
+        ...(create
+            ? {
+                create: {
+                    index: create.index,
+                    satoshis: create.satoshis,
+                    basket: create.basket,
+                    tags: create.tags,
+                    template: create.template,
+                    sealPending: create.sealPending,
+                    sealKind: create.sealKind,
+                    recipient: create.recipient,
+                    listingPriceSats: create.listingPriceSats,
+                    listingSeller: create.listingSeller,
+                    opnsProfileName: create.opnsProfileName,
+                    opnsAvatarOrigin: create.opnsAvatarOrigin,
+                    ...(name ? { name } : {}),
+                    ...(origin ? { origin } : {}),
+                    ...(contentType || create.inscriptionType
+                        ? {
+                            contentType: create.inscriptionType ?? contentType,
+                        }
+                        : {}),
+                    ...(create.inscriptionText
+                        ? { inscriptionText: create.inscriptionText }
+                        : {}),
+                    ...(create.inscriptionDataUrl
+                        ? { inscriptionDataUrl: create.inscriptionDataUrl }
+                        : {}),
+                },
+            }
+            : {}),
+    };
+}
+/** Prefer specific MIME (`image/png`) over bare category (`image`). */
+function contentTypeFromTags(tags) {
+    if (!tags?.length)
+        return undefined;
+    const types = tags
+        .filter((t) => t.startsWith('type:'))
+        .map((t) => t.slice(5));
+    if (!types.length)
+        return undefined;
+    const specific = types.find((t) => t.includes('/'));
+    return specific ?? types[types.length - 1];
+}
+function buildLegs(inputs, outputs, ordinalEdges) {
+    const edgeOutIdx = new Set(ordinalEdges
+        .map((e) => e.create?.index)
+        .filter((i) => i != null));
+    const edgeInIds = new Set(ordinalEdges.map((e) => e.spend?.id).filter((id) => !!id));
+    const legs = [];
+    for (const [i, inp] of inputs.entries()) {
+        const name = displayNameFrom(inp.tags, inp.customInstructions);
+        const origin = tagValue(inp.tags, 'origin');
+        const listing = hasListingTags(inp.tags);
+        const inOrdinalEdge = edgeInIds.has(inp.id);
+        const tokenId = tagValue(inp.tags, 'bsv21');
+        const tokenAmt = tagValue(inp.tags, 'amt');
+        // sym/name-like fields: CI preserves case; tags are lowercased by BRC-100.
+        const tokenSym = displayFieldFrom('sym', inp.tags, inp.customInstructions);
+        legs.push({
+            side: 'input',
+            index: i,
+            satoshis: inp.satoshis,
+            template: listing
+                ? 'ordlock'
+                : tokenId || inp.basket === BSV21_BASKET
+                    ? 'bsv21'
+                    : 'unrecognized',
+            label: legLabelInput(inp, name, listing),
+            basket: inp.basket,
+            tags: inp.tags,
+            id: inp.id,
+            outpoint: inp.outpoint,
+            inOrdinalEdge,
+            ...(name ? { name } : {}),
+            ...(origin ? { origin } : {}),
+            ...(tokenId && tokenId !== 'deploy' ? { tokenId } : {}),
+            ...(tokenAmt ? { tokenAmt } : {}),
+            ...(tokenSym ? { tokenSym } : {}),
+        });
+    }
+    for (const out of outputs) {
+        const name = displayNameFrom(out.tags, out.customInstructions, out.opnsProfileName);
+        const origin = tagValue(out.tags, 'origin');
+        const inOrdinalEdge = edgeOutIdx.has(out.index);
+        legs.push({
+            side: 'output',
+            index: out.index,
+            satoshis: out.satoshis,
+            template: out.template ?? 'unrecognized',
+            label: legLabelOutput(out, name),
+            inOrdinalEdge,
+            ...(out.sealPending
+                ? { sealPending: true, sealKind: out.sealKind }
+                : {}),
+            basket: out.basket,
+            tags: out.tags,
+            recipient: out.recipient,
+            listingPriceSats: out.listingPriceSats,
+            listingSeller: out.listingSeller,
+            lockUntilHeight: out.lockUntilHeight,
+            opnsProfileName: out.opnsProfileName,
+            opnsAvatarOrigin: out.opnsAvatarOrigin,
+            ...(name ? { name } : {}),
+            ...(origin ? { origin } : {}),
+            ...(out.tokenId ? { tokenId: out.tokenId } : {}),
+            ...(out.tokenAmt ? { tokenAmt: out.tokenAmt } : {}),
+            ...(out.tokenSym ? { tokenSym: out.tokenSym } : {}),
+            ...(out.tokenOp ? { tokenOp: out.tokenOp } : {}),
+            ...(out.isIndexerFee ? { isIndexerFee: true } : {}),
+        });
+    }
+    return legs;
+}
+function legLabelInput(inp, name, listing) {
+    const what = name ? `“${name}”` : inp.basket;
+    if (listing)
+        return `Spend listing ${what}`;
+    return `Spend ${what} (${inp.satoshis} sats)`;
+}
+function legLabelOutput(out, name) {
+    const parts = [];
+    if (out.sealPending && out.sealKind === 'sigma') {
+        parts.push('Sign Sigma on output');
+    }
+    else if (out.sealPending && out.sealKind === 'pushdrop') {
+        parts.push('Sign PushDrop on output');
+    }
+    else if (out.template === 'ordlock' && out.listingPriceSats != null) {
+        parts.push(`List for ${out.listingPriceSats} sats`);
+    }
+    else if (out.template === 'lock' && out.lockUntilHeight != null) {
+        parts.push(`Lock until height ${out.lockUntilHeight}`);
+    }
+    else if (out.template === 'sigma') {
+        parts.push('Sigma-signed output');
+    }
+    else if (out.template === 'pushdrop') {
+        parts.push(name ? `PushDrop “${name}”` : 'PushDrop output');
+    }
+    else if (out.recipient) {
+        parts.push(`Pay ${truncate(out.recipient, 18)}`);
+    }
+    else if (out.basket) {
+        parts.push(`File to ${out.basket}`);
+    }
+    else {
+        parts.push(out.template === 'unrecognized'
+            ? 'Unrecognized script'
+            : 'Output');
+    }
+    if (name && !parts[0]?.includes(name))
+        parts.push(`“${name}”`);
+    parts.push(`${out.satoshis} sats`);
+    return parts.join(' · ');
 }
 // ---------------------------------------------------------------------------
 // Intent classification — driven by input asset basket membership.
@@ -245,30 +755,7 @@ function decodeOutput(out, index, chain) {
 function hasListingTags(tags) {
     return tags.some((t) => t === 'ordlock' || t.startsWith('price:'));
 }
-function detectKind(inputs, outputs, p1satIntent) {
-    // Prefer explicit intent labels over heuristics.
-    if (p1satIntent?.startsWith('opns.'))
-        return 'opns';
-    if (p1satIntent === 'ordinal.list' || p1satIntent === 'bsv21.list')
-        return 'listing';
-    if (p1satIntent === 'ordinal.cancel-listing' ||
-        p1satIntent === 'opns.cancel-listing')
-        return 'cancel-listing';
-    if (p1satIntent === 'ordinal.purchase' ||
-        p1satIntent === 'opns.purchase' ||
-        p1satIntent === 'bsv21.purchase')
-        return 'purchase';
-    if (p1satIntent === 'ordinal.transfer')
-        return 'ordinal-transfer';
-    if (p1satIntent === 'bsv21.transfer')
-        return 'token-transfer';
-    if (p1satIntent === 'lock.lock')
-        return 'lock';
-    if (p1satIntent === 'lock.unlock')
-        return 'unlock';
-    if (p1satIntent === 'ordinal.inscribe' ||
-        p1satIntent === 'ordinal.inscribe-sigma')
-        return 'inscription';
+function detectKind(inputs, outputs) {
     // Cancel listing: spending an ordlock-tagged input back to a P2PKH owner.
     // Listings live in the basket of the listed asset (ordinals, opns, …),
     // so the ordlock/price tags are the marker, not the basket.
@@ -309,12 +796,7 @@ function detectKind(inputs, outputs, p1satIntent) {
         return 'token-transfer';
     return 'unknown';
 }
-function buildSummary(kind, inputs, outputs, intentId) {
-    if (intentId) {
-        const named = summaryFromIntentId(intentId, inputs, outputs);
-        if (named)
-            return named;
-    }
+function buildSummary(kind, inputs, outputs) {
     switch (kind) {
         case 'ordinal-transfer': {
             const recipient = outputs.find((o) => o.recipient)?.recipient;
@@ -358,64 +840,22 @@ function buildSummary(kind, inputs, outputs, intentId) {
         case 'social-post':
             return `Create social post`;
         case 'opns': {
-            const name = tagValue(inputs[0]?.tags, 'name') ??
-                tagValue(outputs.find((o) => o.basket === OPNS_BASKET)?.tags, 'name');
-            return name ? `Update OpNS name “${name}”` : 'OpNS operation';
+            const out = outputs.find((o) => o.basket === OPNS_BASKET);
+            const name = tagValue(inputs[0]?.tags, 'name') ?? tagValue(out?.tags, 'name');
+            const published = out?.tags.includes('opns:published');
+            if (published) {
+                return name ? `Publish name “${name}”` : 'Publish OpNS name';
+            }
+            return name ? `OpNS operation on “${name}”` : 'OpNS operation';
+        }
+        case 'purchase': {
+            const name = tagValue(outputs[0]?.tags, 'name') ?? tagValue(inputs[0]?.tags, 'name');
+            return name ? `Buy “${name}”` : 'Buy asset';
         }
         default:
             return `Approve transaction`;
     }
 }
-function summaryFromIntentId(intentId, inputs, outputs) {
-    const name = tagValue(inputs[0]?.tags, 'name') ??
-        tagValue(outputs.find((o) => o.basket === OPNS_BASKET)?.tags, 'name');
-    const what = name ? `“${name}”` : undefined;
-    switch (intentId) {
-        case 'opns.register':
-            return what ? `Publish name ${what}` : 'Publish OpNS name';
-        case 'opns.deregister':
-            return what ? `Unpublish name ${what}` : 'Unpublish OpNS name';
-        case 'opns.list':
-            return what ? `List name ${what} for sale` : 'List OpNS name for sale';
-        case 'opns.transfer':
-            return what ? `Transfer name ${what}` : 'Transfer OpNS name';
-        case 'opns.cancel-listing':
-            return what ? `Cancel listing of ${what}` : 'Cancel OpNS listing';
-        case 'opns.purchase':
-            return what ? `Buy name ${what}` : 'Buy OpNS name';
-        case 'ordinal.transfer':
-            return 'Send ordinal';
-        case 'ordinal.list':
-            return 'List ordinal for sale';
-        case 'ordinal.cancel-listing':
-            return 'Cancel ordinal listing';
-        case 'ordinal.purchase':
-            return 'Buy ordinal';
-        case 'ordinal.burn':
-            return 'Burn ordinal';
-        case 'ordinal.inscribe':
-        case 'ordinal.inscribe-sigma':
-            return 'Create inscription';
-        case 'ordinal.mint-collection':
-            return 'Mint collection';
-        case 'ordinal.mint-item':
-            return 'Mint collection item';
-        case 'lock.lock':
-            return 'Lock BSV';
-        case 'lock.unlock':
-            return 'Unlock BSV';
-        case 'bsv21.transfer':
-            return 'Send tokens';
-        case 'bsv21.purchase':
-            return 'Buy tokens';
-        case 'bsv21.mint':
-            return 'Mint tokens';
-        case 'bsv21.deploy':
-            return 'Deploy token';
-        default:
-            return undefined;
-    }
-}
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -436,7 +876,6 @@ function truncate(s, max) {
 }
 function contentUrlFromOrigin(host, origin) {
     const trimmed = host.replace(/\/$/, '');
-    const formatted = origin.replace('.', '_');
-    return `${trimmed}/${formatted}`;
+    return `${trimmed}/${formatOrdinalOutpoint(origin)}`;
 }
 //# sourceMappingURL=enrichIntent.js.map