@1sat/actions 0.0.197 → 0.0.199

package/dist/tokens/index.js

@@ -4,27 +4,63 @@
  * Actions for managing BSV21 tokens.
  */
 import { BSV21, OrdLock, P2MS } from '@1sat/templates';
-import { BSV21_DEPLOY_TAG, P1SAT_INTENTS, buildInputAssetLabel, buildTokenLabel, readAssetIdTag, } from '@1sat/types';
+import { BSV21_DEPLOY_TAG, buildInputAssetLabel, buildTokenLabel, readAssetIdTag, } from '@1sat/types';
 import { parseOutpoint } from '@1sat/utils';
 import { BigNumber, LockingScript, OP, P2PKH, PublicKey, TransactionSignature, UnlockingScript, Utils, } from '@bsv/sdk';
 import { prepareP1SatArgs } from '../apply';
-import { BSV21_AUTH_BASKET, BSV21_BASKET, P1SAT_PROTOCOL, } from '../constants';
+import { BSV21_AUTH_TAG, BSV21_BASKET, P1SAT_PROTOCOL, } from '../constants';
 import { executeTrackedAction } from '../utils/createTrackedAction';
 import { getDisplayValue } from '../utils/displayValue';
+import { bsv21FieldsFromOutput, bsv21FilterTags, buildBsv21CustomInstructions, normalizeBsv21TokenId, } from '../utils/bsv21Remittance';
 import { resolveDestination } from '../utils/resolveDestination';
 import { signP2PKHInput } from '../utils/signP2PKH';
-/** tokenId from tags, or deploy outpoint when tagged bsv21:deploy. */
+/** tokenId: CI `id` → tag `bsv21:<id>` → deploy outpoint. */
 function tokenIdFromOutput(o) {
-    const idTag = o.tags?.find((t) => t.startsWith('bsv21:') && t !== BSV21_DEPLOY_TAG);
-    if (idTag)
-        return idTag.slice(6);
-    if (o.tags?.includes(BSV21_DEPLOY_TAG)) {
-        return o.outpoint.replace('.', '_');
-    }
-    return undefined;
+    return bsv21FieldsFromOutput({
+        tags: o.tags,
+        customInstructions: o.customInstructions,
+        outpoint: o.outpoint,
+    }).tokenId;
 }
 function matchesTokenId(o, tokenId) {
-    return tokenIdFromOutput(o) === tokenId;
+    const id = tokenIdFromOutput(o);
+    if (!id)
+        return false;
+    return normalizeBsv21TokenId(id) === normalizeBsv21TokenId(tokenId);
+}
+function amtFromOutput(o) {
+    return bsv21FieldsFromOutput({
+        tags: o.tags,
+        customInstructions: o.customInstructions,
+        outpoint: o.outpoint,
+    }).amt;
+}
+/** Value tips only — skip pure auth rows in balances. */
+function isBalanceableBsv21Output(o) {
+    const f = bsv21FieldsFromOutput({
+        tags: o.tags,
+        customInstructions: o.customInstructions,
+        outpoint: o.outpoint,
+    });
+    // Auth-only UTXOs (not deploy+mint value)
+    if (f.isAuth && !f.isDeploy)
+        return false;
+    const op = parseBsv21Op(o);
+    if (op === 'auth' || op === 'deploy+auth')
+        return false;
+    return !!f.amt && f.amt !== '0';
+}
+function parseBsv21Op(o) {
+    const ci = o.customInstructions;
+    if (!ci)
+        return undefined;
+    try {
+        const op = JSON.parse(ci).op;
+        return typeof op === 'string' ? op : undefined;
+    }
+    catch {
+        return undefined;
+    }
 }
 // ============================================================================
 // Internal helpers
@@ -121,14 +157,21 @@ export const getBsv21Balances = {
         const outputs = await listTokensInternal(ctx);
         const balanceMap = new Map();
         for (const o of outputs) {
-            const tokenId = tokenIdFromOutput(o);
-            const amtTag = o.tags?.find((t) => t.startsWith('amt:'))?.slice(4);
-            if (!tokenId || !amtTag)
+            if (!isBalanceableBsv21Output(o))
+                continue;
+            const fields = bsv21FieldsFromOutput({
+                tags: o.tags,
+                customInstructions: o.customInstructions,
+                outpoint: o.outpoint,
+            });
+            const tokenId = fields.tokenId;
+            const amtStr = fields.amt;
+            if (!tokenId || !amtStr)
                 continue;
-            const amt = BigInt(amtTag);
-            const dec = Number.parseInt(o.tags?.find((t) => t.startsWith('dec:'))?.slice(4) || '0', 10);
-            const symTag = getDisplayValue(o, 'sym', 'sym');
-            const rawIcon = o.tags?.find((t) => t.startsWith('icon:'))?.slice(5);
+            const amt = BigInt(amtStr);
+            const dec = Number.parseInt(fields.dec || '0', 10);
+            const symTag = fields.sym ?? getDisplayValue(o, 'sym', 'sym');
+            const rawIcon = fields.icon;
             const icon = rawIcon?.startsWith('_')
                 ? `${tokenId.split('_')[0]}${rawIcon}`
                 : rawIcon;
@@ -189,6 +232,10 @@ export const sendBsv21 = {
                         required: ['amount', 'destination'],
                     },
                 },
+                validateOverlay: {
+                    type: 'boolean',
+                    description: 'Default true. When true, require active token + per-input overlay unspent check (hard fail). When false, spend wallet tips only.',
+                },
             },
             required: ['tokenId', 'recipients'],
         },
@@ -211,14 +258,32 @@ export const sendBsv21 = {
                 resolved.push({ amount, destination: r.destination });
             }
             const totalAmount = resolved.reduce((sum, r) => sum + r.amount, 0n);
-            if (!ctx.services) {
-                return { error: 'services-required' };
+            const validateOverlay = input.validateOverlay !== false;
+            let tokenDetails;
+            if (validateOverlay) {
+                if (!ctx.services?.bsv21) {
+                    return { error: 'services-required' };
+                }
+                try {
+                    tokenDetails = await ctx.services.bsv21.getTokenDetails(tokenId);
+                }
+                catch (e) {
+                    console.error('[sendBsv21] getTokenDetails failed:', e);
+                    return { error: 'token-not-found' };
+                }
+                if (!tokenDetails.status.is_active) {
+                    return { error: 'token-not-active' };
+                }
             }
-            const tokenDetails = await ctx.services.bsv21.getTokenDetails(tokenId);
-            if (!tokenDetails.status.is_active) {
-                return { error: 'token-not-active' };
+            else if (ctx.services?.bsv21) {
+                // Best-effort meta/fees only — never gate the send.
+                try {
+                    tokenDetails = await ctx.services.bsv21.getTokenDetails(tokenId);
+                }
+                catch {
+                    tokenDetails = undefined;
+                }
             }
-            const { fee_address, fee_per_output } = tokenDetails.status;
             const listResult = await ctx.wallet.listOutputs({
                 basket: BSV21_BASKET,
                 includeTags: true,
@@ -227,17 +292,14 @@ export const sendBsv21 = {
                 limit: 10000,
             });
             const tokenUtxos = listResult.outputs.filter((o) => matchesTokenId(o, tokenId));
-            // Batch-validate all candidate outpoints against the overlay
+            // When validateOverlay: only spend tips the overlay still lists unspent.
             const validOutpoints = new Set();
-            let overlayValidated = false;
-            if (ctx.services?.bsv21) {
+            if (validateOverlay) {
                 const candidateOutpoints = tokenUtxos.map((o) => o.outpoint);
                 try {
                     const validated = await ctx.services.bsv21.validateOutputs(tokenId, candidateOutpoints, { unspent: true });
-                    overlayValidated = true;
                     for (const v of validated) {
-                        const normalizedOutpoint = v.outpoint.replace('_', '.');
-                        validOutpoints.add(normalizedOutpoint);
+                        validOutpoints.add(v.outpoint.replace('_', '.'));
                     }
                 }
                 catch (e) {
@@ -250,29 +312,42 @@ export const sendBsv21 = {
             for (const utxo of tokenUtxos) {
                 if (totalIn >= totalAmount)
                     break;
-                const amtTag = utxo.tags?.find((t) => t.startsWith('amt:'));
-                if (!amtTag)
+                const amtStr = amtFromOutput(utxo);
+                if (!amtStr)
                     continue;
-                const utxoAmount = BigInt(amtTag.slice(4));
-                if (overlayValidated && !validOutpoints.has(utxo.outpoint)) {
+                const utxoAmount = BigInt(amtStr);
+                if (validateOverlay && !validOutpoints.has(utxo.outpoint)) {
                     continue;
                 }
                 selected.push(utxo);
                 totalIn += utxoAmount;
             }
             if (totalIn < totalAmount) {
-                return { error: 'insufficient-tokens' };
+                return {
+                    error: validateOverlay
+                        ? 'insufficient-valid-tokens'
+                        : 'insufficient-tokens',
+                };
             }
             const outputs = [];
             const p2pkh = new P2PKH();
             const recipientKeyIDs = [];
-            // Build recipient outputs
-            const tokenTags = [
-                `bsv21:${tokenId}`,
-                `dec:${tokenDetails.token.dec ?? 0}`,
-                ...(tokenDetails.token.sym ? [`sym:${tokenDetails.token.sym}`] : []),
-                ...(tokenDetails.token.icon ? [`icon:${tokenDetails.token.icon}`] : []),
-            ];
+            // Meta: overlay when present, else first selected tip CI.
+            const fromTip = selected[0]
+                ? bsv21FieldsFromOutput({
+                    tags: selected[0].tags,
+                    customInstructions: selected[0].customInstructions,
+                    outpoint: selected[0].outpoint,
+                })
+                : {};
+            const tokenTags = bsv21FilterTags({ tokenId });
+            const tokenMeta = {
+                id: tokenId,
+                op: 'transfer',
+                sym: tokenDetails?.token.sym ?? fromTip.sym,
+                dec: tokenDetails?.token.dec ?? fromTip.dec ?? 0,
+                icon: tokenDetails?.token.icon ?? fromTip.icon,
+            };
             for (const r of resolved) {
                 const recipientResolved = await resolveDestination(ctx, r.destination, {
                     protocolID: P1SAT_PROTOCOL,
@@ -280,7 +355,7 @@ export const sendBsv21 = {
                 });
                 recipientKeyIDs.push(recipientResolved.customInstructions?.keyID);
                 const transferScript = BSV21.transfer(tokenId, r.amount).lock(recipientResolved.lockingScript);
-                // Self destinations stay in the BSV21 basket with full tags + id:.
+                // Self destinations stay in the BSV21 basket with filter tags + CI.
                 const isSelf = r.destination.counterparty === 'self' ||
                     recipientResolved.customInstructions?.counterparty === 'self';
                 outputs.push({
@@ -289,20 +364,18 @@ export const sendBsv21 = {
                     outputDescription: `Send ${r.amount} tokens`,
                     ...(isSelf && {
                         basket: BSV21_BASKET,
-                        tags: [...tokenTags, `amt:${r.amount}`],
+                        tags: tokenTags,
                         // Only when the wallet actually derived the key. A literal
                         // address or lockingScript destination has no derivation, and
                         // inventing a keyID here would record a triple that was never
                         // used to lock this output — leaving it unspendable from its
                         // own record.
                         ...(recipientResolved.customInstructions?.keyID && {
-                            customInstructions: JSON.stringify({
+                            customInstructions: buildBsv21CustomInstructions({
+                                token: { ...tokenMeta, amt: String(r.amount) },
                                 protocolID: P1SAT_PROTOCOL,
                                 keyID: recipientResolved.customInstructions.keyID,
                                 counterparty: 'self',
-                                ...(tokenDetails.token.sym && {
-                                    sym: tokenDetails.token.sym,
-                                }),
                             }),
                         }),
                     }),
@@ -329,34 +402,30 @@ export const sendBsv21 = {
                     satoshis: 1,
                     outputDescription: 'Token change',
                     basket: BSV21_BASKET,
-                    tags: [
-                        `bsv21:${tokenId}`,
-                        `amt:${change}`,
-                        `dec:${tokenDetails.token.dec ?? 0}`,
-                        ...(tokenDetails.token.sym
-                            ? [`sym:${tokenDetails.token.sym}`]
-                            : []),
-                        ...(tokenDetails.token.icon
-                            ? [`icon:${tokenDetails.token.icon}`]
-                            : []),
-                    ],
-                    customInstructions: JSON.stringify({
+                    tags: tokenTags,
+                    customInstructions: buildBsv21CustomInstructions({
+                        token: { ...tokenMeta, amt: String(change) },
                         protocolID: P1SAT_PROTOCOL,
                         keyID: changeKeyID,
-                        ...(tokenDetails.token.sym && {
-                            sym: tokenDetails.token.sym,
-                        }),
+                        counterparty: 'self',
                     }),
                 });
             }
-            // Fee output to overlay fund address (per token output)
-            outputs.push({
-                lockingScript: p2pkh.lock(fee_address).toHex(),
-                satoshis: fee_per_output * tokenOutputCount,
-                outputDescription: 'Overlay processing fee',
-                tags: ['fee:overlay'],
-            });
-            const symbol = tokenDetails.token.sym || tokenId.slice(0, 8);
+            // Fee out when we have fund params (required path always has details).
+            const fee_address = tokenDetails?.status?.fee_address;
+            const fee_per_output = tokenDetails?.status?.fee_per_output;
+            if (typeof fee_address === 'string' &&
+                fee_address &&
+                typeof fee_per_output === 'number' &&
+                fee_per_output > 0) {
+                outputs.push({
+                    lockingScript: p2pkh.lock(fee_address).toHex(),
+                    satoshis: fee_per_output * tokenOutputCount,
+                    outputDescription: 'Overlay processing fee',
+                    tags: ['fee:overlay'],
+                });
+            }
+            const symbol = tokenMeta.sym || tokenId.slice(0, 8);
             let inputBEEF = listResult.BEEF;
             if (!inputBEEF || inputBEEF.length === 0) {
                 if (!ctx.services)
@@ -386,20 +455,19 @@ export const sendBsv21 = {
                 })),
                 outputs,
                 options: { randomizeOutputs: false },
-            }, P1SAT_INTENTS.BSV21_TRANSFER);
-            const result = await executeTrackedAction(ctx.wallet, sendArgs, input.fundingProvider, inputBEEF, async (tx) => {
-                const spends = {};
-                for (let i = 0; i < selected.length; i++) {
-                    const utxo = selected[i];
-                    if (!utxo.customInstructions)
-                        continue;
-                    const { protocolID, keyID, counterparty } = JSON.parse(utxo.customInstructions);
-                    const unlocking = await signP2PKHInput(ctx, tx, i, protocolID, keyID, counterparty);
-                    if (typeof unlocking !== 'string')
-                        throw new Error(unlocking.error);
-                    spends[i] = { unlockingScript: unlocking };
-                }
-                return spends;
+            });
+            const spends = selected
+                .map((o) => {
+                const id = readAssetIdTag(o.tags);
+                return id
+                    ? ({ basket: BSV21_BASKET, id })
+                    : null;
+            })
+                .filter((t) => !!t);
+            const result = await executeTrackedAction(ctx.wallet, sendArgs, input.fundingProvider, inputBEEF, undefined, {
+                spends,
+                usePermissionModule: input.usePermissionModule ?? input.useOneSatModule ?? input.useModule,
+                permissionScheme: 'bsv21',
             });
             // Submit to overlay service for indexing
             if (result.tx && ctx.services) {
@@ -540,21 +608,19 @@ export const buyBsv21 = {
                 satoshis: 1,
                 outputDescription: 'Purchased tokens',
                 basket: BSV21_BASKET,
-                tags: [
-                    `bsv21:${tokenId}`,
-                    `amt:${tokenAmount}`,
-                    `dec:${tokenDetails.token.dec ?? 0}`,
-                    ...(tokenDetails.token.sym ? [`sym:${tokenDetails.token.sym}`] : []),
-                    ...(tokenDetails.token.icon
-                        ? [`icon:${tokenDetails.token.icon}`]
-                        : []),
-                ],
-                customInstructions: JSON.stringify({
+                tags: bsv21FilterTags({ tokenId }),
+                customInstructions: buildBsv21CustomInstructions({
+                    token: {
+                        id: tokenId,
+                        amt: String(tokenAmount),
+                        op: 'transfer',
+                        sym: tokenDetails.token.sym,
+                        dec: tokenDetails.token.dec ?? 0,
+                        icon: tokenDetails.token.icon,
+                    },
                     protocolID: P1SAT_PROTOCOL,
                     keyID: bsv21KeyID,
-                    ...(tokenDetails.token.sym && {
-                        sym: tokenDetails.token.sym,
-                    }),
+                    counterparty: 'self',
                 }),
             });
             const payoutReader = new Utils.Reader(ordLockData.payout);
@@ -602,10 +668,11 @@ export const buyBsv21 = {
                 ],
                 outputs,
                 options: { randomizeOutputs: false },
-            }, P1SAT_INTENTS.BSV21_PURCHASE);
-            const result = await executeTrackedAction(ctx.wallet, buyArgs, input.fundingProvider, beefBinary, async (tx) => {
-                const unlockingScript = await buildPurchaseUnlockingScript(tx, 0, listingOutput.satoshis ?? 1, listingOutput.lockingScript);
-                return { 0: { unlockingScript: unlockingScript.toHex() } };
+            });
+            const result = await executeTrackedAction(ctx.wallet, buyArgs, input.fundingProvider, beefBinary, undefined, {
+                spends: [{ outpoint, scheme: 'bsv21' }],
+                usePermissionModule: input.usePermissionModule ?? input.useOneSatModule ?? input.useModule,
+                permissionScheme: 'bsv21',
             });
             // Submit to overlay service for indexing
             if (result.tx && ctx.services) {
@@ -658,25 +725,32 @@ export const buyBsv21 = {
     },
 };
 /**
- * Single createAction deploy. Tags include `bsv21:deploy` + metadata;
- * tokenId is the resulting outpoint (`txid_0`). Balance queries treat
- * deploy rows as that token when outpoint matches.
+ * Deploy via createAction. Tags: `bsv21:deploy` (+ auth). No `bsv21:<tokenId>`
+ * (id = this outpoint, known only after the tx). Balance/selection resolve id
+ * from outpoint when that tag is present.
  */
 async function executeBsv21Deploy(args) {
     const { ctx, symbol, deployScript, basket } = args;
+    // Deploy filing: `bsv21:deploy` (+ optional auth). No `bsv21:<tokenId>`
+    // (id = outpoint after mine). Never amt/sym/dec/icon tags.
+    const tags = args.buildTags().filter((t) => t === BSV21_DEPLOY_TAG || t === BSV21_AUTH_TAG);
+    if (!tags.includes(BSV21_DEPLOY_TAG))
+        tags.push(BSV21_DEPLOY_TAG);
     const customInstructions = args.destinationCustomInstructions
-        ? JSON.stringify({
+        ? buildBsv21CustomInstructions({
+            token: {
+                // No `id` — readers use deploy outpoint as token id.
+                amt: args.token.amt,
+                op: args.token.op,
+                sym: symbol,
+                dec: args.token.dec,
+                icon: args.token.icon,
+            },
             protocolID: args.destinationCustomInstructions.protocolID,
             keyID: args.destinationCustomInstructions.keyID,
-            ...(args.destinationCustomInstructions.counterparty !== undefined && {
-                counterparty: args.destinationCustomInstructions.counterparty,
-            }),
-            sym: symbol,
+            counterparty: args.destinationCustomInstructions.counterparty,
         })
         : undefined;
-    const tags = args.buildTags();
-    if (!tags.includes(BSV21_DEPLOY_TAG))
-        tags.push(BSV21_DEPLOY_TAG);
     const caArgs = {
         description: args.description,
         outputs: [
@@ -691,7 +765,7 @@ async function executeBsv21Deploy(args) {
         ],
         options: { randomizeOutputs: false },
     };
-    const prepared = await prepareP1SatArgs(ctx, caArgs, P1SAT_INTENTS.BSV21_DEPLOY);
+    const prepared = await prepareP1SatArgs(ctx, caArgs);
     const result = await executeTrackedAction(ctx.wallet, prepared, args.fundingProvider);
     if (!result.txid) {
         return { error: 'deploy-no-txid' };
@@ -754,17 +828,13 @@ export const deployBsv21Mint = {
                 basket: BSV21_BASKET,
                 description: `Deploy ${symbol} (${amount} fixed supply)`,
                 outputDescription: `Deploy ${symbol}`,
-                buildTags: () => {
-                    const tags = [
-                        BSV21_DEPLOY_TAG,
-                        `amt:${amount}`,
-                        `dec:${decimals}`,
-                        `sym:${symbol}`,
-                    ];
-                    if (icon)
-                        tags.push(`icon:${icon}`);
-                    return tags;
+                token: {
+                    amt: String(amount),
+                    op: 'deploy+mint',
+                    dec: decimals,
+                    icon,
                 },
+                buildTags: () => [BSV21_DEPLOY_TAG],
             });
             if (result.error)
                 return { error: result.error };
@@ -861,15 +931,16 @@ export const deployBsv21Auth = {
                 symbol,
                 deployScript,
                 destinationCustomInstructions: resolved.customInstructions,
-                basket: BSV21_AUTH_BASKET,
+                basket: BSV21_BASKET,
                 description: `Deploy ${symbol} (mintable)`,
                 outputDescription: `Deploy ${symbol} auth`,
-                buildTags: () => {
-                    const tags = [BSV21_DEPLOY_TAG, `dec:${decimals}`, `sym:${symbol}`];
-                    if (icon)
-                        tags.push(`icon:${icon}`);
-                    return tags;
+                token: {
+                    amt: '0',
+                    op: 'deploy+auth',
+                    dec: decimals,
+                    icon,
                 },
+                buildTags: () => [BSV21_DEPLOY_TAG, BSV21_AUTH_TAG],
             });
             if (result.error)
                 return { error: result.error };
@@ -893,7 +964,7 @@ export const deployBsv21Auth = {
                             index: 0,
                             protocolID: P1SAT_PROTOCOL,
                             keyID: resolved.customInstructions?.keyID,
-                            basket: BSV21_AUTH_BASKET,
+                            basket: BSV21_BASKET,
                             satoshis: 1,
                         },
                     ],
@@ -976,15 +1047,17 @@ export const mintBsv21 = {
             }
             // Look up the token's metadata for tag enrichment.
             const tokenDetails = await ctx.services.bsv21.getTokenDetails(tokenId);
-            // Find a spendable auth UTXO for this token.
+            // Find a spendable auth UTXO for this token (same basket as balance).
             const authList = await ctx.wallet.listOutputs({
-                basket: BSV21_AUTH_BASKET,
+                basket: BSV21_BASKET,
+                tags: [BSV21_AUTH_TAG, `bsv21:${tokenId}`],
+                tagQueryMode: 'all',
                 includeTags: true,
                 includeCustomInstructions: true,
                 include: 'entire transactions',
                 limit: 1000,
             });
-            const authUtxo = authList.outputs.find((o) => o.tags?.includes(`bsv21:${tokenId}`));
+            const authUtxo = authList.outputs[0];
             if (!authUtxo) {
                 return { error: 'no-auth-utxo-for-token' };
             }
@@ -1001,30 +1074,29 @@ export const mintBsv21 = {
                     keyIDPrefix: `bsv21-mint-${tokenId}`,
                 });
                 const mintScript = BSV21.mint(tokenId, mintAmount).lock(mintResolved.lockingScript);
-                const mintTags = [
-                    `bsv21:${tokenId}`,
-                    `amt:${mintAmount}`,
-                    `dec:${tokenDetails.token.dec ?? 0}`,
-                    ...(tokenDetails.token.sym ? [`sym:${tokenDetails.token.sym}`] : []),
-                    ...(tokenDetails.token.icon
-                        ? [`icon:${tokenDetails.token.icon}`]
-                        : []),
-                ];
-                const mintCI = mintResolved.customInstructions
-                    ? JSON.stringify({
-                        ...mintResolved.customInstructions,
-                        ...(tokenDetails.token.sym && { sym: tokenDetails.token.sym }),
-                    })
-                    : tokenDetails.token.sym
-                        ? JSON.stringify({ sym: tokenDetails.token.sym })
-                        : undefined;
+                const mintMeta = {
+                    id: tokenId,
+                    amt: String(mintAmount),
+                    op: 'mint',
+                    sym: tokenDetails.token.sym,
+                    dec: tokenDetails.token.dec ?? 0,
+                    icon: tokenDetails.token.icon,
+                };
                 outputs.push({
                     lockingScript: mintScript.toHex(),
                     satoshis: 1,
                     outputDescription: `Mint ${mintAmount} tokens`,
                     basket: BSV21_BASKET,
-                    tags: mintTags,
-                    customInstructions: mintCI,
+                    tags: bsv21FilterTags({ tokenId }),
+                    customInstructions: mintResolved.customInstructions
+                        ? buildBsv21CustomInstructions({
+                            token: mintMeta,
+                            protocolID: mintResolved.customInstructions.protocolID,
+                            keyID: mintResolved.customInstructions.keyID,
+                            counterparty: mintResolved.customInstructions
+                                .counterparty,
+                        })
+                        : buildBsv21CustomInstructions({ token: mintMeta }),
                 });
             }
             if (!endMinting) {
@@ -1033,30 +1105,30 @@ export const mintBsv21 = {
                     keyIDPrefix: `bsv21-auth-${tokenId}`,
                 });
                 const authScript = BSV21.auth(tokenId).lock(authResolved.lockingScript);
-                const authTags = [
-                    `bsv21:${tokenId}`,
-                    `dec:${tokenDetails.token.dec ?? 0}`,
-                    ...(tokenDetails.token.sym ? [`sym:${tokenDetails.token.sym}`] : []),
-                    ...(tokenDetails.token.icon
-                        ? [`icon:${tokenDetails.token.icon}`]
-                        : []),
-                ];
-                const authCustomInstructions = authResolved.customInstructions
-                    ? JSON.stringify({
-                        ...authResolved.customInstructions,
-                        ...(tokenDetails.token.sym && { sym: tokenDetails.token.sym }),
-                    })
-                    : tokenDetails.token.sym
-                        ? JSON.stringify({ sym: tokenDetails.token.sym })
-                        : undefined;
+                const authMeta = {
+                    id: tokenId,
+                    amt: '0',
+                    op: 'auth',
+                    sym: tokenDetails.token.sym,
+                    dec: tokenDetails.token.dec ?? 0,
+                    icon: tokenDetails.token.icon,
+                };
                 authOutputIndex = outputs.length;
                 outputs.push({
                     lockingScript: authScript.toHex(),
                     satoshis: 1,
                     outputDescription: 'Continuing mint authority',
-                    basket: BSV21_AUTH_BASKET,
-                    tags: authTags,
-                    customInstructions: authCustomInstructions,
+                    basket: BSV21_BASKET,
+                    tags: bsv21FilterTags({ tokenId, auth: true }),
+                    customInstructions: authResolved.customInstructions
+                        ? buildBsv21CustomInstructions({
+                            token: authMeta,
+                            protocolID: authResolved.customInstructions.protocolID,
+                            keyID: authResolved.customInstructions.keyID,
+                            counterparty: authResolved.customInstructions
+                                .counterparty,
+                        })
+                        : buildBsv21CustomInstructions({ token: authMeta }),
                 });
             }
             // Optional fee output to overlay fund address (per token output).
@@ -1086,7 +1158,7 @@ export const mintBsv21 = {
                 labels: [
                     buildTokenLabel(tokenId),
                     ...(authInputId
-                        ? [buildInputAssetLabel(BSV21_AUTH_BASKET, authInputId)]
+                        ? [buildInputAssetLabel(BSV21_BASKET, authInputId)]
                         : []),
                 ],
                 inputBEEF,
@@ -1099,7 +1171,7 @@ export const mintBsv21 = {
                 ],
                 outputs,
                 options: { randomizeOutputs: false },
-            }, P1SAT_INTENTS.BSV21_MINT);
+            });
             const result = await executeTrackedAction(ctx.wallet, mintArgs, input.fundingProvider, inputBEEF, async (tx) => {
                 if (authCI.multiSig === true) {
                     // 1-of-N P2MS auth: this wallet contributes its single