@1sat/actions 0.0.115 → 0.0.116

package/dist/tokens/index.js

@@ -5,10 +5,11 @@
  */
 import { BSV21, OrdLock } from '@1sat/templates';
 import { parseOutpoint } from '@1sat/utils';
-import { BigNumber, LockingScript, OP, P2PKH, PublicKey, TransactionSignature, UnlockingScript, Utils, } from '@bsv/sdk';
-import { BSV21_BASKET, BSV21_PROTOCOL } from '../constants';
+import { Beef, BigNumber, LockingScript, OP, P2PKH, PublicKey, Transaction, TransactionSignature, UnlockingScript, Utils, } from '@bsv/sdk';
+import { BSV21_AUTH_BASKET, BSV21_BASKET, BSV21_DEPLOY_FUNDING_BASKET, BSV21_PROTOCOL, } from '../constants';
 import { executeTrackedAction } from '../utils/createTrackedAction';
 import { getDisplayValue } from '../utils/displayValue';
+import { resolveDestination } from '../utils/resolveDestination';
 import { signP2PKHInput } from '../utils/signP2PKH';
 // ============================================================================
 // Internal helpers
@@ -150,7 +151,7 @@ export const getBsv21Balances = {
 export const sendBsv21 = {
     meta: {
         name: 'sendBsv21',
-        description: 'Send BSV21 tokens to one or more recipients (counterparty or address)',
+        description: 'Send BSV21 tokens to one or more recipients',
         category: 'tokens',
         inputSchema: {
             type: 'object',
@@ -166,16 +167,12 @@ export const sendBsv21 = {
                                 type: 'string',
                                 description: 'Amount to send (as string for bigint)',
                             },
-                            counterparty: {
-                                type: 'string',
-                                description: 'Recipient identity public key (hex)',
-                            },
-                            address: {
-                                type: 'string',
-                                description: 'Recipient P2PKH address',
+                            destination: {
+                                type: 'object',
+                                description: 'Where to lock the output. One of lockingScript (hex), counterparty (pubkey), or address.',
                             },
                         },
-                        required: ['amount'],
+                        required: ['amount', 'destination'],
                     },
                 },
             },
@@ -194,14 +191,10 @@ export const sendBsv21 = {
                 if (amount <= 0n) {
                     return { error: 'amount-must-be-positive' };
                 }
-                if (!r.counterparty && !r.address) {
-                    return { error: 'must-provide-counterparty-or-address' };
+                if (!r.destination) {
+                    return { error: 'recipient-missing-destination' };
                 }
-                resolved.push({
-                    amount,
-                    counterparty: r.counterparty,
-                    address: r.address,
-                });
+                resolved.push({ amount, destination: r.destination });
             }
             const totalAmount = resolved.reduce((sum, r) => sum + r.amount, 0n);
             if (!ctx.services) {
@@ -266,27 +259,12 @@ export const sendBsv21 = {
             const recipientKeyIDs = [];
             // Build recipient outputs
             for (const r of resolved) {
-                let recipientAddress;
-                let recipientKeyID;
-                if (r.counterparty) {
-                    recipientKeyID = `${tokenId}-${Date.now()}`;
-                    const { publicKey } = await ctx.wallet.getPublicKey({
-                        protocolID: BSV21_PROTOCOL,
-                        keyID: recipientKeyID,
-                        counterparty: r.counterparty,
-                        forSelf: false,
-                    });
-                    recipientAddress = PublicKey.fromString(publicKey).toAddress();
-                }
-                else if (r.address) {
-                    recipientAddress = r.address;
-                }
-                else {
-                    return { error: 'must-provide-counterparty-or-address' };
-                }
-                recipientKeyIDs.push(recipientKeyID);
-                const destinationLockingScript = p2pkh.lock(recipientAddress);
-                const transferScript = BSV21.transfer(tokenId, r.amount).lock(destinationLockingScript);
+                const recipientResolved = await resolveDestination(ctx, r.destination, {
+                    protocolID: BSV21_PROTOCOL,
+                    keyIDPrefix: tokenId,
+                });
+                recipientKeyIDs.push(recipientResolved.customInstructions?.keyID);
+                const transferScript = BSV21.transfer(tokenId, r.amount).lock(recipientResolved.lockingScript);
                 outputs.push({
                     lockingScript: transferScript.toHex(),
                     satoshis: 1,
@@ -415,8 +393,7 @@ export const sendBsv21 = {
                         tokenId,
                         recipients: resolved.map((r) => ({
                             amount: r.amount.toString(),
-                            counterparty: r.counterparty,
-                            address: r.address,
+                            destination: r.destination,
                         })),
                     },
                     txid: result.txid,
@@ -637,6 +614,570 @@ export const purchaseBsv21 = {
         }
     },
 };
+/** Miner fee rate used for manual deploy tx fee calculation. */
+const DEPLOY_FEE_PER_KB = 100;
+/**
+ * Estimate the byte size of the manually-built deploy tx (1 input, 1 output, no
+ * change). Conservative — sized for a typical signed P2PKH unlocking script.
+ */
+function estimateDeployTxSize(deployScriptBytes) {
+    const overhead = 10; // version(4) + locktime(4) + inCount(1) + outCount(1)
+    const input = 148; // P2PKH spend: txid(32)+vout(4)+scriptLen(1)+script(~107)+seq(4)
+    const scriptLenVarint = deployScriptBytes < 0xfd
+        ? 1
+        : deployScriptBytes < 0x10000
+            ? 3
+            : 5;
+    const output = 8 + scriptLenVarint + deployScriptBytes;
+    return overhead + input + output;
+}
+/**
+ * Shared deploy flow: createAction a funding intermediate → manually build the
+ * deploy tx spending it → internalizeAction adopts the deploy with proper
+ * tokenId-bearing tags and broadcasts.
+ *
+ * Used by both deployBsv21Mint and deployBsv21Auth — they only differ in the
+ * deploy script (BSV21.deployMint vs BSV21.deployAuth) and target basket.
+ */
+async function executeBsv21Deploy(args) {
+    const { ctx, symbol, deployScript, basket } = args;
+    const deployScriptBin = deployScript.toBinary();
+    const txSize = estimateDeployTxSize(deployScriptBin.length);
+    const fee = Math.ceil((txSize * DEPLOY_FEE_PER_KB) / 1000);
+    // 1 sat for the deploy output + computed fee + small buffer for unlocking
+    // script size variance (low-S signatures can be a byte shorter, etc.)
+    const fundingValue = 1 + fee + 5;
+    const fundingKeyID = `bsv21-deploy-fund-${symbol}-${Date.now()}`;
+    const { publicKey: fundingPubKey } = await ctx.wallet.getPublicKey({
+        protocolID: BSV21_PROTOCOL,
+        keyID: fundingKeyID,
+        counterparty: 'self',
+        forSelf: true,
+    });
+    const fundingAddress = PublicKey.fromString(fundingPubKey).toAddress();
+    const fundingScript = new P2PKH().lock(fundingAddress);
+    const fundingResult = await ctx.wallet.createAction({
+        description: `${args.description} (funding)`,
+        outputs: [
+            {
+                lockingScript: fundingScript.toHex(),
+                satoshis: fundingValue,
+                outputDescription: 'Deploy funding intermediate',
+                basket: BSV21_DEPLOY_FUNDING_BASKET,
+                customInstructions: JSON.stringify({
+                    protocolID: BSV21_PROTOCOL,
+                    keyID: fundingKeyID,
+                }),
+            },
+        ],
+        options: { randomizeOutputs: false },
+    });
+    if (!fundingResult.txid || !fundingResult.tx) {
+        return { error: 'funding-failed' };
+    }
+    const fundingBeef = Beef.fromBinary(Array.from(fundingResult.tx));
+    const fundingTx = fundingBeef.findAtomicTransaction(fundingResult.txid);
+    if (!fundingTx) {
+        return { error: 'funding-tx-not-in-beef' };
+    }
+    const deployTx = new Transaction();
+    deployTx.addInput({
+        sourceTransaction: fundingTx,
+        // Setting sourceTXID is required so BeefTx.updateInputTxids picks up
+        // the dependency. Without it, the deploy's inputTxids is empty and
+        // Beef.sortTxs orders the deploy before its ancestors, which then get
+        // trimmed by toBinaryAtomic.
+        sourceTXID: fundingResult.txid,
+        sourceOutputIndex: 0,
+        unlockingScript: new UnlockingScript(),
+        sequence: 0xffffffff,
+    });
+    deployTx.addOutput({
+        lockingScript: deployScript,
+        satoshis: 1,
+    });
+    const sigResult = await signP2PKHInput(ctx, deployTx, 0, BSV21_PROTOCOL, fundingKeyID);
+    if (typeof sigResult !== 'string') {
+        return { error: sigResult.error };
+    }
+    deployTx.inputs[0].unlockingScript = UnlockingScript.fromHex(sigResult);
+    const deployTxid = deployTx.id('hex');
+    const tokenId = `${deployTxid}_0`;
+    fundingBeef.mergeTransaction(deployTx);
+    const deployBeefBin = fundingBeef.toBinaryAtomic(deployTxid);
+    const customInstructions = args.destinationCustomInstructions
+        ? JSON.stringify({
+            protocolID: args.destinationCustomInstructions.protocolID,
+            keyID: args.destinationCustomInstructions.keyID,
+            sym: symbol,
+        })
+        : undefined;
+    await ctx.wallet.internalizeAction({
+        tx: deployBeefBin,
+        outputs: [
+            {
+                outputIndex: 0,
+                protocol: 'basket insertion',
+                insertionRemittance: {
+                    basket,
+                    tags: args.buildTags(tokenId),
+                    customInstructions,
+                },
+            },
+        ],
+        description: args.description,
+        labels: ['bsv21:deploy'],
+    });
+    return {
+        txid: deployTxid,
+        tx: deployBeefBin,
+        tokenId,
+    };
+}
+/**
+ * Deploy a new BSV21 token with a fixed supply (deploy+mint).
+ *
+ * The entire supply is minted in this transaction and sent to the destination.
+ * No further minting is possible — total supply is locked at deploy time.
+ */
+export const deployBsv21Mint = {
+    meta: {
+        name: 'deployBsv21Mint',
+        description: 'Deploy a new BSV21 token with fixed supply (deploy+mint)',
+        category: 'tokens',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                symbol: { type: 'string', description: 'Token symbol/ticker' },
+                amount: {
+                    type: 'string',
+                    description: 'Total fixed supply (as string for bigint)',
+                },
+                decimals: {
+                    type: 'integer',
+                    description: 'Decimal places (0-18, default 0)',
+                },
+                icon: { type: 'string', description: 'Icon URL or data URI' },
+                destination: {
+                    type: 'object',
+                    description: 'Recipient destination. One of lockingScript (hex), counterparty (pubkey), or address. Defaults to self.',
+                },
+            },
+            required: ['symbol', 'amount'],
+        },
+    },
+    async execute(ctx, input) {
+        try {
+            const { symbol, amount: rawAmount, decimals = 0, icon, destination } = input;
+            const amount = typeof rawAmount === 'string' ? BigInt(rawAmount) : rawAmount;
+            if (amount <= 0n) {
+                return { error: 'amount-must-be-positive' };
+            }
+            const resolved = await resolveDestination(ctx, destination, {
+                protocolID: BSV21_PROTOCOL,
+                keyIDPrefix: `bsv21-deploy-${symbol}`,
+            });
+            const deployScript = BSV21.deployMint(symbol, amount, decimals, icon).lock(resolved.lockingScript);
+            const result = await executeBsv21Deploy({
+                ctx,
+                symbol,
+                deployScript,
+                destinationCustomInstructions: resolved.customInstructions,
+                basket: BSV21_BASKET,
+                description: `Deploy ${symbol} (${amount} fixed supply)`,
+                outputDescription: `Deploy ${symbol}`,
+                buildTags: (tokenId) => {
+                    const tags = [
+                        `bsv21:${tokenId}`,
+                        `amt:${amount}`,
+                        `dec:${decimals}`,
+                        `sym:${symbol}`,
+                    ];
+                    if (icon)
+                        tags.push(`icon:${icon}`);
+                    return tags;
+                },
+            });
+            if (result.error)
+                return { error: result.error };
+            if (result.tx && ctx.services) {
+                try {
+                    await ctx.services.overlay.submitBsv21Discovery(result.tx);
+                }
+                catch (overlayError) {
+                    console.warn('[deployBsv21Mint] Overlay submission failed:', overlayError);
+                }
+            }
+            if (ctx.debug && ctx.log) {
+                ctx.log({
+                    timestamp: new Date().toISOString(),
+                    action: 'deployBsv21Mint',
+                    input: {
+                        symbol,
+                        amount: amount.toString(),
+                        decimals,
+                        icon,
+                        destination,
+                    },
+                    txid: result.txid,
+                    rawtx: result.tx ? Utils.toHex(result.tx) : undefined,
+                    outputs: [
+                        {
+                            index: 0,
+                            protocolID: BSV21_PROTOCOL,
+                            keyID: resolved.customInstructions?.keyID,
+                            basket: BSV21_BASKET,
+                            satoshis: 1,
+                        },
+                    ],
+                });
+            }
+            return result;
+        }
+        catch (error) {
+            console.error('[deployBsv21Mint]', error);
+            if (ctx.debug && ctx.log) {
+                ctx.log({
+                    timestamp: new Date().toISOString(),
+                    action: 'deployBsv21Mint',
+                    input: { symbol: input.symbol },
+                    error: error instanceof Error ? error.message : 'unknown-error',
+                });
+            }
+            return {
+                error: error instanceof Error ? error.message : 'unknown-error',
+            };
+        }
+    },
+};
+/**
+ * Deploy a new BSV21 token with mintable supply (deploy+auth).
+ *
+ * Emits a single `deploy+auth` output that doubles as the genesis auth UTXO.
+ * Initial supply is zero — the auth holder must spend this output via a
+ * separate mint transaction to create supply. Authority can be split,
+ * combined, transferred, or burned via subsequent auth operations.
+ */
+export const deployBsv21Auth = {
+    meta: {
+        name: 'deployBsv21Auth',
+        description: 'Deploy a new BSV21 token with mintable supply via auth UTXOs (deploy+auth)',
+        category: 'tokens',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                symbol: { type: 'string', description: 'Token symbol/ticker' },
+                decimals: {
+                    type: 'integer',
+                    description: 'Decimal places (0-18, default 0)',
+                },
+                icon: { type: 'string', description: 'Icon URL or data URI' },
+                destination: {
+                    type: 'object',
+                    description: 'Auth-holder destination. One of lockingScript (hex), counterparty (pubkey), or address. Defaults to self.',
+                },
+            },
+            required: ['symbol'],
+        },
+    },
+    async execute(ctx, input) {
+        try {
+            const { symbol, decimals = 0, icon, destination } = input;
+            const resolved = await resolveDestination(ctx, destination, {
+                protocolID: BSV21_PROTOCOL,
+                keyIDPrefix: `bsv21-auth-${symbol}`,
+            });
+            const deployScript = BSV21.deployAuth(symbol, decimals, icon).lock(resolved.lockingScript);
+            const result = await executeBsv21Deploy({
+                ctx,
+                symbol,
+                deployScript,
+                destinationCustomInstructions: resolved.customInstructions,
+                basket: BSV21_AUTH_BASKET,
+                description: `Deploy ${symbol} (mintable)`,
+                outputDescription: `Deploy ${symbol} auth`,
+                buildTags: (tokenId) => {
+                    const tags = [`bsv21:${tokenId}`, `dec:${decimals}`, `sym:${symbol}`];
+                    if (icon)
+                        tags.push(`icon:${icon}`);
+                    return tags;
+                },
+            });
+            if (result.error)
+                return { error: result.error };
+            if (result.tx && ctx.services) {
+                try {
+                    await ctx.services.overlay.submitBsv21Discovery(result.tx);
+                }
+                catch (overlayError) {
+                    console.warn('[deployBsv21Auth] Overlay submission failed:', overlayError);
+                }
+            }
+            if (ctx.debug && ctx.log) {
+                ctx.log({
+                    timestamp: new Date().toISOString(),
+                    action: 'deployBsv21Auth',
+                    input: { symbol, decimals, icon, destination },
+                    txid: result.txid,
+                    rawtx: result.tx ? Utils.toHex(result.tx) : undefined,
+                    outputs: [
+                        {
+                            index: 0,
+                            protocolID: BSV21_PROTOCOL,
+                            keyID: resolved.customInstructions?.keyID,
+                            basket: BSV21_AUTH_BASKET,
+                            satoshis: 1,
+                        },
+                    ],
+                });
+            }
+            // For deploy+auth, the deploy output IS the first auth UTXO.
+            return {
+                ...result,
+                authOutpoint: result.tokenId,
+            };
+        }
+        catch (error) {
+            console.error('[deployBsv21Auth]', error);
+            if (ctx.debug && ctx.log) {
+                ctx.log({
+                    timestamp: new Date().toISOString(),
+                    action: 'deployBsv21Auth',
+                    input: { symbol: input.symbol },
+                    error: error instanceof Error ? error.message : 'unknown-error',
+                });
+            }
+            return {
+                error: error instanceof Error ? error.message : 'unknown-error',
+            };
+        }
+    },
+};
+/**
+ * Spend an auth UTXO to mint new supply, transfer authority, or burn it.
+ *
+ * Both `mint` and `auth` are optional, but at least one must be present.
+ * Omitting `auth` ends minting permanently and requires `endMinting: true`
+ * as explicit confirmation.
+ */
+export const mintBsv21 = {
+    meta: {
+        name: 'mintBsv21',
+        description: 'Spend an auth UTXO to mint new supply and/or re-issue authority',
+        category: 'tokens',
+        requiresServices: true,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                tokenId: { type: 'string', description: 'Token ID (txid_vout format)' },
+                mint: {
+                    type: 'object',
+                    description: 'Optional mint output: { amount, destination }',
+                },
+                auth: {
+                    type: 'object',
+                    description: 'Optional continuing auth output: { destination }',
+                },
+                endMinting: {
+                    type: 'boolean',
+                    description: 'Required when auth is omitted — explicit confirmation that minting ends.',
+                },
+            },
+            required: ['tokenId'],
+        },
+    },
+    async execute(ctx, input) {
+        try {
+            const { tokenId, mint, auth, endMinting } = input;
+            if (!mint && !auth) {
+                return { error: 'must-provide-mint-or-auth' };
+            }
+            if (!auth && !endMinting) {
+                return { error: 'omitting-auth-requires-endMinting-true' };
+            }
+            const mintAmount = mint?.amount !== undefined
+                ? typeof mint.amount === 'string'
+                    ? BigInt(mint.amount)
+                    : mint.amount
+                : 0n;
+            if (mint && mintAmount <= 0n) {
+                return { error: 'mint-amount-must-be-positive' };
+            }
+            if (!ctx.services) {
+                return { error: 'services-required' };
+            }
+            // 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.
+            const authList = await ctx.wallet.listOutputs({
+                basket: BSV21_AUTH_BASKET,
+                includeTags: true,
+                includeCustomInstructions: true,
+                include: 'entire transactions',
+                limit: 1000,
+            });
+            const authUtxo = authList.outputs.find((o) => o.tags?.includes(`bsv21:${tokenId}`));
+            if (!authUtxo) {
+                return { error: 'no-auth-utxo-for-token' };
+            }
+            if (!authUtxo.customInstructions) {
+                return { error: 'auth-utxo-missing-custom-instructions' };
+            }
+            const authCI = JSON.parse(authUtxo.customInstructions);
+            // Build outputs.
+            const outputs = [];
+            let authOutputIndex;
+            if (mint) {
+                const mintResolved = await resolveDestination(ctx, mint.destination, {
+                    protocolID: BSV21_PROTOCOL,
+                    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({
+                        protocolID: mintResolved.customInstructions.protocolID,
+                        keyID: mintResolved.customInstructions.keyID,
+                        ...(tokenDetails.token.sym && { sym: tokenDetails.token.sym }),
+                    })
+                    : undefined;
+                outputs.push({
+                    lockingScript: mintScript.toHex(),
+                    satoshis: 1,
+                    outputDescription: `Mint ${mintAmount} tokens`,
+                    basket: BSV21_BASKET,
+                    tags: mintTags,
+                    customInstructions: mintCI,
+                });
+            }
+            if (auth) {
+                const authResolved = await resolveDestination(ctx, auth.destination, {
+                    protocolID: BSV21_PROTOCOL,
+                    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({
+                        protocolID: authResolved.customInstructions.protocolID,
+                        keyID: authResolved.customInstructions.keyID,
+                        ...(tokenDetails.token.sym && { sym: tokenDetails.token.sym }),
+                    })
+                    : undefined;
+                authOutputIndex = outputs.length;
+                outputs.push({
+                    lockingScript: authScript.toHex(),
+                    satoshis: 1,
+                    outputDescription: 'Continuing mint authority',
+                    basket: BSV21_AUTH_BASKET,
+                    tags: authTags,
+                    customInstructions: authCustomInstructions,
+                });
+            }
+            // Optional fee output to overlay fund address (per token output).
+            const tokenOutputCount = (mint ? 1 : 0) + (auth ? 1 : 0);
+            if (tokenDetails.status.is_active &&
+                tokenDetails.status.fee_per_output > 0) {
+                outputs.push({
+                    lockingScript: new P2PKH()
+                        .lock(tokenDetails.status.fee_address)
+                        .toHex(),
+                    satoshis: tokenDetails.status.fee_per_output * tokenOutputCount,
+                    outputDescription: 'Overlay processing fee',
+                    tags: [],
+                });
+            }
+            let inputBEEF = authList.BEEF;
+            if (!inputBEEF || inputBEEF.length === 0) {
+                const beef = await ctx.services.getBeefForTxid(authUtxo.outpoint.split('.')[0]);
+                inputBEEF = beef.toBinary();
+            }
+            const symbol = tokenDetails.token.sym || tokenId.slice(0, 8);
+            const result = await executeTrackedAction(ctx.wallet, {
+                description: mint
+                    ? `Mint ${mintAmount} ${symbol}`
+                    : `Re-issue ${symbol} authority`,
+                labels: [`bsv21:${tokenId}`],
+                inputBEEF,
+                inputs: [
+                    {
+                        outpoint: authUtxo.outpoint,
+                        inputDescription: 'Mint authority',
+                        unlockingScriptLength: 108,
+                    },
+                ],
+                outputs,
+                options: { randomizeOutputs: false },
+            }, input.fundingProvider, inputBEEF, async (tx) => {
+                const unlocking = await signP2PKHInput(ctx, tx, 0, authCI.protocolID, authCI.keyID);
+                if (typeof unlocking !== 'string')
+                    throw new Error(unlocking.error);
+                return { 0: { unlockingScript: unlocking } };
+            });
+            if (result.error)
+                return { error: result.error };
+            // Submit to per-token overlay topic.
+            if (result.tx && ctx.services) {
+                try {
+                    await ctx.services.overlay.submitBsv21(result.tx, tokenId);
+                }
+                catch (overlayError) {
+                    console.warn('[mintBsv21] Overlay submission failed:', overlayError);
+                }
+            }
+            const authOutpoint = result.txid && authOutputIndex !== undefined
+                ? `${result.txid}_${authOutputIndex}`
+                : undefined;
+            if (ctx.debug && ctx.log) {
+                ctx.log({
+                    timestamp: new Date().toISOString(),
+                    action: 'mintBsv21',
+                    input: { tokenId, mint, auth, endMinting },
+                    txid: result.txid,
+                    rawtx: result.tx ? Utils.toHex(result.tx) : undefined,
+                });
+            }
+            return {
+                txid: result.txid,
+                tx: result.tx,
+                authOutpoint,
+            };
+        }
+        catch (error) {
+            console.error('[mintBsv21]', error);
+            if (ctx.debug && ctx.log) {
+                ctx.log({
+                    timestamp: new Date().toISOString(),
+                    action: 'mintBsv21',
+                    input: { tokenId: input.tokenId },
+                    error: error instanceof Error ? error.message : 'unknown-error',
+                });
+            }
+            return {
+                error: error instanceof Error ? error.message : 'unknown-error',
+            };
+        }
+    },
+};
 // ============================================================================
 // Module exports
 // ============================================================================
@@ -646,5 +1187,8 @@ export const tokensActions = [
     getBsv21Balances,
     sendBsv21,
     purchaseBsv21,
+    deployBsv21Mint,
+    deployBsv21Auth,
+    mintBsv21,
 ];
 //# sourceMappingURL=index.js.map