@1sat/actions 0.0.189 → 0.0.191

package/dist/opns/index.js

@@ -1,136 +1,242 @@
 /**
  * OpNS Module
  *
- * Actions for managing OpNS names. Identity bind is a signed PushDrop on the
- * name UTXO (field0 = BRC-100 identity key). Moving the name spends that
- * script and re-locks under the normal ordinal formats (P2PKH / OrdLock).
+ * Wallet-owned names live in OPNS_BASKET with id: tags.
+ * Self-moves: id → one loadBasketOutputBeef → ordinalSeedTags + domain tags.
+ * Ingress (internalizeOpns / buyOpns) stamps full tags including id:.
  */
-import { OPNS_BASKET, OPNS_PUBLISHED_TAG, OPNS_PUSHDROP_TEMPLATE, OPNS_REGISTER_COUNTERPARTY, P1SAT_PROTOCOL, opnsRegisterKeyId, } from '@1sat/types';
-import { PushDrop, Utils, } from '@bsv/sdk';
-import { buildTransferOrdinals, listOrdinal, transferOrdinals } from '../ordinals';
-import { executeTrackedAction } from '../utils/createTrackedAction';
-import { resolveBeef } from '../utils/resolveBeef';
+import { OpNS, OrdLock } from '@1sat/templates';
+import { OPNS_BASKET, OPNS_PUBLISHED_TAG, OPNS_PUSHDROP_TEMPLATE, OPNS_REGISTER_COUNTERPARTY, P1SAT_PROTOCOL, buildInputAssetLabel, opnsRegisterKeyId, readAssetIdTag, } from '@1sat/types';
+import { P2PKH, PublicKey, PushDrop, Transaction, Utils, } from '@bsv/sdk';
+import { buildOrdLockScript, buyOrdinal, defaultPayAddress, deriveCancelAddressInternal, } from '../ordinals';
+import { executeTrackedAction, randomActionId, } from '../utils/createTrackedAction';
+import { loadBasketOutputBeef } from '../utils/loadBasketOutput';
+import { ordinalSeedTags } from '../utils/ordinalSeedTags';
 import { signOrdinalInput, unlockingScriptLengthForInstructions, } from '../utils/signOrdinalInput';
+const OPNS_CONTENT_TYPE = 'application/op-ns';
 export { opnsRegisterKeyId } from '@1sat/types';
 // ============================================================================
 // Helpers
 // ============================================================================
-function sourceNameFromOrdinal(ordinal) {
-    if (ordinal.customInstructions) {
-        try {
-            const name = JSON.parse(ordinal.customInstructions).name;
-            if (typeof name === 'string' && name)
-                return name;
-        }
-        catch { }
+function findMintNameDelivery(tx) {
+    for (let i = 0; i + 2 < tx.outputs.length; i++) {
+        const parent = OpNS.decode(tx.outputs[i].lockingScript);
+        const child = OpNS.decode(tx.outputs[i + 1].lockingScript);
+        if (!parent || !child)
+            continue;
+        const name = child.domain.trim().slice(0, 64);
+        if (!name)
+            continue;
+        return { vout: i + 2, name };
     }
-    return ordinal.tags?.find((t) => t.startsWith('name:'))?.slice(5);
+    return null;
 }
-async function signSingleOrdinalInput(ctx, ordinal) {
-    if (!ordinal.customInstructions) {
-        return { error: 'missing-custom-instructions' };
+function nameFromOutput(out) {
+    const fromTag = out.tags?.find((t) => t.startsWith('name:'))?.slice(5);
+    if (fromTag)
+        return fromTag.slice(0, 64);
+    if (!out.customInstructions)
+        return undefined;
+    try {
+        const n = JSON.parse(out.customInstructions).name;
+        return typeof n === 'string' && n ? n.slice(0, 64) : undefined;
     }
-    return {
-        sign: async (tx) => {
-            const unlocking = await signOrdinalInput(ctx, tx, 0, ordinal.customInstructions);
-            if (typeof unlocking !== 'string')
-                throw new Error(unlocking.error);
-            return { 0: { unlockingScript: unlocking } };
-        },
-    };
+    catch {
+        return undefined;
+    }
+}
+/** Load OPNS row + BEEF from wallet storage by id. */
+async function loadOpnsSpend(ctx, input) {
+    return loadBasketOutputBeef(ctx.wallet, OPNS_BASKET, input.id);
+}
+/** Ordinal seed + opns domain tag; optional extras (ordlock, published, …). */
+function opnsFileTags(output, extra = []) {
+    const tags = ordinalSeedTags(output);
+    if (!tags.includes('opns'))
+        tags.unshift('opns');
+    for (const e of extra) {
+        if (e && !tags.includes(e))
+            tags.push(e);
+    }
+    return tags;
 }
 // ============================================================================
-// Actions
+// listOpns
 // ============================================================================
-/**
- * Get OpNS names from the wallet with BEEF for spending.
- */
-export const getOpnsNames = {
+export const listOpns = {
     meta: {
-        name: 'getOpnsNames',
-        description: 'Get OpNS names from the wallet with BEEF for spending',
+        name: 'listOpns',
+        description: 'List OpNS names from the wallet (metadata by default; optional BEEF)',
         category: 'opns',
         inputSchema: {
             type: 'object',
             properties: {
-                limit: {
-                    type: 'integer',
-                    description: 'Max names to return (default: 100)',
-                },
-                offset: {
-                    type: 'integer',
-                    description: 'Offset for pagination (default: 0)',
+                tags: { type: 'array', items: { type: 'string' } },
+                tagQueryMode: { type: 'string', enum: ['all', 'any'] },
+                names: { type: 'array', items: { type: 'string' } },
+                ids: { type: 'array', items: { type: 'string' } },
+                include: {
+                    type: 'string',
+                    enum: ['locking scripts', 'entire transactions'],
                 },
+                includeCustomInstructions: { type: 'boolean' },
+                includeTags: { type: 'boolean' },
+                includeLabels: { type: 'boolean' },
+                limit: { type: 'integer' },
+                offset: { type: 'integer' },
             },
         },
     },
     async execute(ctx, input) {
+        const tags = [...(input.tags ?? [])];
+        for (const n of input.names ?? []) {
+            if (n)
+                tags.push(`name:${n}`);
+        }
+        for (const id of input.ids ?? []) {
+            if (id)
+                tags.push(id.startsWith('id:') ? id : `id:${id}`);
+        }
+        const filtering = tags.length > 0;
         const result = await ctx.wallet.listOutputs({
             basket: OPNS_BASKET,
-            includeTags: true,
-            includeCustomInstructions: true,
-            include: 'entire transactions',
+            ...(filtering && {
+                tags,
+                tagQueryMode: input.tagQueryMode ?? 'any',
+            }),
+            ...(input.include && { include: input.include }),
+            includeCustomInstructions: input.includeCustomInstructions ?? true,
+            includeTags: input.includeTags ?? true,
+            ...(input.includeLabels != null && {
+                includeLabels: input.includeLabels,
+            }),
             limit: input.limit ?? 100,
             offset: input.offset ?? 0,
         });
         return {
             outputs: result.outputs,
             BEEF: result.BEEF,
+            totalOutputs: result.totalOutputs,
         };
     },
 };
-/**
- * Bind the wallet identity key to an OpNS name via signed PushDrop.
- *
- * Lock: PushDrop under [0,'p 1sat'] / opns:{inputOutpoint} / anyone, forSelf.
- * fields[0] = identity pubkey bytes; field-sig included (same derivation).
- */
-export const opnsRegister = {
+/** @deprecated Use listOpns */
+export const getOpnsNames = listOpns;
+// ============================================================================
+// internalizeOpns (ingress)
+// ============================================================================
+export const internalizeOpns = {
+    meta: {
+        name: 'internalizeOpns',
+        description: 'Internalize a foreign-created OpNS mint (AtomicBEEF) into the OPNS basket',
+        category: 'opns',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                tx: { type: 'array', items: { type: 'integer' } },
+                protocolID: { type: 'array' },
+                keyID: { type: 'string' },
+                counterparty: { type: 'string' },
+            },
+            required: ['tx', 'protocolID', 'keyID'],
+        },
+    },
+    async execute(ctx, input) {
+        try {
+            const parsed = Transaction.fromAtomicBEEF(input.tx);
+            const txid = parsed.id('hex');
+            const delivery = findMintNameDelivery(parsed);
+            if (!delivery)
+                return { error: 'not-an-opns-mint' };
+            const { vout, name } = delivery;
+            const outpoint = `${txid}.${vout}`;
+            const actionId = randomActionId();
+            const idTag = `id:${actionId}_${vout}`;
+            const counterparty = input.counterparty ?? 'self';
+            await ctx.wallet.internalizeAction({
+                tx: input.tx,
+                outputs: [
+                    {
+                        outputIndex: vout,
+                        protocol: 'basket insertion',
+                        insertionRemittance: {
+                            basket: OPNS_BASKET,
+                            tags: [
+                                'opns',
+                                `type:${OPNS_CONTENT_TYPE}`,
+                                `origin:${outpoint}`,
+                                `name:${name}`,
+                                idTag,
+                            ],
+                            customInstructions: JSON.stringify({
+                                protocolID: input.protocolID,
+                                keyID: input.keyID,
+                                counterparty,
+                                name,
+                            }),
+                        },
+                    },
+                ],
+                description: `opns name ${name}`.slice(0, 50),
+            });
+            return {
+                txid,
+                outpoint,
+                name,
+                id: `${actionId}_${vout}`,
+            };
+        }
+        catch (err) {
+            return {
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    },
+};
+// ============================================================================
+// register / deregister
+// ============================================================================
+export const registerOpns = {
     meta: {
-        name: 'opnsRegister',
+        name: 'registerOpns',
         description: 'Bind BRC-100 identity key to an OpNS name via signed PushDrop',
         category: 'opns',
         inputSchema: {
             type: 'object',
             properties: {
-                ordinal: {
-                    type: 'object',
-                    description: 'WalletOutput of the OpNS ordinal from listOutputs',
-                },
-                inputBEEF: {
-                    type: 'array',
-                    description: "BEEF from listOutputs with include: 'entire transactions'",
-                },
+                id: { type: 'string', description: 'OPNS basket tracking id' },
             },
-            required: ['ordinal'],
+            required: ['id'],
         },
     },
     async execute(ctx, input) {
         try {
-            const { ordinal } = input;
-            if (!ordinal.customInstructions) {
+            const loaded = await loadOpnsSpend(ctx, input);
+            if ('error' in loaded)
+                return loaded;
+            const { output, beef } = loaded;
+            if (!output.customInstructions) {
                 return { error: 'missing-custom-instructions' };
             }
-            const inputBEEF = input.inputBEEF ??
-                (await resolveBeef(ctx.wallet, OPNS_BASKET, ordinal));
             const { publicKey: identityPubKey } = await ctx.wallet.getPublicKey({
                 identityKey: true,
             });
-            const keyID = opnsRegisterKeyId(ordinal.outpoint);
+            const keyID = opnsRegisterKeyId(output.outpoint);
             const lockingScript = await new PushDrop(ctx.wallet).lock([Utils.toArray(identityPubKey, 'hex')], P1SAT_PROTOCOL, keyID, OPNS_REGISTER_COUNTERPARTY, true, true);
-            const tags = [
-                ...(ordinal.tags ?? []).filter((t) => t !== OPNS_PUBLISHED_TAG && !t.startsWith('ordlock')),
-                OPNS_PUBLISHED_TAG,
-            ];
-            const name = sourceNameFromOrdinal(ordinal);
-            const result = await executeTrackedAction(ctx.wallet, {
+            const name = nameFromOutput(output);
+            const tags = opnsFileTags(output, [OPNS_PUBLISHED_TAG]);
+            const inputId = readAssetIdTag(output.tags);
+            return await executeTrackedAction(ctx.wallet, {
                 description: 'Register OpNS identity bind',
-                inputBEEF,
+                inputBEEF: beef,
+                ...(inputId && {
+                    labels: [buildInputAssetLabel(OPNS_BASKET, inputId)],
+                }),
                 inputs: [
                     {
-                        outpoint: ordinal.outpoint,
+                        outpoint: output.outpoint,
                         inputDescription: 'OpNS name to register',
-                        unlockingScriptLength: unlockingScriptLengthForInstructions(ordinal.customInstructions),
+                        unlockingScriptLength: unlockingScriptLengthForInstructions(output.customInstructions),
                     },
                 ],
                 outputs: [
@@ -150,185 +256,408 @@ export const opnsRegister = {
                     },
                 ],
                 options: { randomizeOutputs: false },
-            }, input.fundingProvider, inputBEEF, async (tx) => {
-                const unlocking = await signOrdinalInput(ctx, tx, 0, ordinal.customInstructions);
+            }, input.fundingProvider, beef, async (tx) => {
+                const unlocking = await signOrdinalInput(ctx, tx, 0, output.customInstructions);
                 if (typeof unlocking !== 'string')
                     throw new Error(unlocking.error);
                 return { 0: { unlockingScript: unlocking } };
             });
-            return result;
         }
         catch (error) {
-            console.error('[opnsRegister]', error);
-            if (ctx.debug && ctx.log) {
-                ctx.log({
-                    timestamp: new Date().toISOString(),
-                    action: 'opnsRegister',
-                    input: { outpoint: input.ordinal.outpoint },
-                    error: error instanceof Error ? error.message : 'unknown-error',
-                });
-            }
+            console.error('[registerOpns]', error);
             return {
                 error: error instanceof Error ? error.message : 'unknown-error',
             };
         }
     },
 };
-/**
- * Remove an identity bind by self-transferring to plain P2PKH.
- * Spending the PushDrop clears the on-chain bind.
- */
-export const opnsDeregister = {
+/** @deprecated Use registerOpns */
+export const opnsRegister = registerOpns;
+export const deregisterOpns = {
     meta: {
-        name: 'opnsDeregister',
+        name: 'deregisterOpns',
         description: 'Remove identity bind from an OpNS name (self-transfer to P2PKH)',
         category: 'opns',
         inputSchema: {
             type: 'object',
             properties: {
-                ordinal: {
-                    type: 'object',
-                    description: 'WalletOutput of the OpNS ordinal from listOutputs',
-                },
-                inputBEEF: {
-                    type: 'array',
-                    description: "BEEF from listOutputs with include: 'entire transactions'",
-                },
+                id: { type: 'string' },
             },
-            required: ['ordinal'],
+            required: ['id'],
         },
     },
     async execute(ctx, input) {
         try {
-            const { ordinal } = input;
-            const inputBEEF = input.inputBEEF ?? (await resolveBeef(ctx.wallet, OPNS_BASKET, ordinal));
-            const params = await buildTransferOrdinals(ctx, {
-                transfers: [
+            const loaded = await loadOpnsSpend(ctx, input);
+            if ('error' in loaded)
+                return loaded;
+            const { output, beef } = loaded;
+            if (!output.customInstructions) {
+                return { error: 'missing-custom-instructions' };
+            }
+            const outpoint = output.outpoint;
+            const { publicKey } = await ctx.wallet.getPublicKey({
+                protocolID: P1SAT_PROTOCOL,
+                keyID: outpoint,
+                counterparty: 'self',
+                forSelf: true,
+            });
+            const address = PublicKey.fromString(publicKey).toAddress();
+            const tags = opnsFileTags(output);
+            const name = nameFromOutput(output);
+            const inputId = readAssetIdTag(output.tags);
+            return await executeTrackedAction(ctx.wallet, {
+                description: 'Deregister OpNS identity bind',
+                inputBEEF: beef,
+                ...(inputId && {
+                    labels: [buildInputAssetLabel(OPNS_BASKET, inputId)],
+                }),
+                inputs: [
                     {
-                        ordinal,
-                        counterparty: 'self',
-                        extraTags: [],
+                        outpoint,
+                        inputDescription: 'OpNS name to deregister',
+                        unlockingScriptLength: unlockingScriptLengthForInstructions(output.customInstructions),
                     },
                 ],
-                inputBEEF,
+                outputs: [
+                    {
+                        lockingScript: new P2PKH().lock(address).toHex(),
+                        satoshis: 1,
+                        outputDescription: 'OpNS name (unbound)',
+                        basket: OPNS_BASKET,
+                        tags,
+                        customInstructions: JSON.stringify({
+                            protocolID: P1SAT_PROTOCOL,
+                            keyID: outpoint,
+                            ...(name && { name }),
+                        }),
+                    },
+                ],
+                options: { randomizeOutputs: false },
+            }, input.fundingProvider, beef, async (tx) => {
+                const unlocking = await signOrdinalInput(ctx, tx, 0, output.customInstructions);
+                if (typeof unlocking !== 'string')
+                    throw new Error(unlocking.error);
+                return { 0: { unlockingScript: unlocking } };
             });
-            if ('error' in params) {
-                return params;
-            }
-            // Drop published tag on the plain self-transfer output
-            if (params.outputs?.[0]?.tags) {
-                params.outputs[0].tags = params.outputs[0].tags.filter((t) => t !== OPNS_PUBLISHED_TAG);
+        }
+        catch (error) {
+            console.error('[deregisterOpns]', error);
+            return {
+                error: error instanceof Error ? error.message : 'unknown-error',
+            };
+        }
+    },
+};
+/** @deprecated Use deregisterOpns */
+export const opnsDeregister = deregisterOpns;
+// ============================================================================
+// sell / send / cancel
+// ============================================================================
+export const sellOpns = {
+    meta: {
+        name: 'sellOpns',
+        description: 'List an OpNS name for sale',
+        category: 'opns',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string' },
+                price: { type: 'integer' },
+                payAddress: {
+                    type: 'string',
+                    description: 'Payment address (default: P1SAT keyID 1sat 0)',
+                },
+            },
+            required: ['id', 'price'],
+        },
+    },
+    async execute(ctx, input) {
+        try {
+            if (input.price <= 0)
+                return { error: 'invalid-price' };
+            const loaded = await loadOpnsSpend(ctx, input);
+            if ('error' in loaded)
+                return loaded;
+            const { output, beef } = loaded;
+            if (!output.customInstructions) {
+                return { error: 'missing-custom-instructions' };
             }
-            const signer = await signSingleOrdinalInput(ctx, ordinal);
-            if ('error' in signer)
-                return signer;
+            const outpoint = output.outpoint;
+            const payAddress = input.payAddress ?? (await defaultPayAddress(ctx));
+            const cancelAddress = await deriveCancelAddressInternal(ctx, outpoint);
+            const lockingScript = buildOrdLockScript(cancelAddress, payAddress, input.price).toHex();
+            const tags = opnsFileTags(output, ['ordlock', `price:${input.price}`]);
+            const name = nameFromOutput(output);
+            const inputId = readAssetIdTag(output.tags);
             return await executeTrackedAction(ctx.wallet, {
-                ...params,
-                description: 'Deregister OpNS identity bind',
+                description: `List OpNS for ${input.price} sats`,
+                inputBEEF: beef,
+                ...(inputId && {
+                    labels: [buildInputAssetLabel(OPNS_BASKET, inputId)],
+                }),
+                inputs: [
+                    {
+                        outpoint,
+                        inputDescription: 'OpNS name to list',
+                        unlockingScriptLength: unlockingScriptLengthForInstructions(output.customInstructions),
+                    },
+                ],
+                outputs: [
+                    {
+                        lockingScript,
+                        satoshis: 1,
+                        outputDescription: `List OpNS for ${input.price} sats`,
+                        basket: OPNS_BASKET,
+                        tags,
+                        customInstructions: JSON.stringify({
+                            protocolID: P1SAT_PROTOCOL,
+                            keyID: outpoint,
+                            ...(name && { name }),
+                        }),
+                    },
+                ],
                 options: { randomizeOutputs: false },
-            }, input.fundingProvider, inputBEEF, signer.sign);
+            }, input.fundingProvider, beef, async (tx) => {
+                const unlocking = await signOrdinalInput(ctx, tx, 0, output.customInstructions);
+                if (typeof unlocking !== 'string')
+                    throw new Error(unlocking.error);
+                return { 0: { unlockingScript: unlocking } };
+            });
         }
         catch (error) {
-            console.error('[opnsDeregister]', error);
-            if (ctx.debug && ctx.log) {
-                ctx.log({
-                    timestamp: new Date().toISOString(),
-                    action: 'opnsDeregister',
-                    input: { outpoint: input.ordinal.outpoint },
-                    error: error instanceof Error ? error.message : 'unknown-error',
+            console.error('[sellOpns]', error);
+            return {
+                error: error instanceof Error ? error.message : 'unknown-error',
+            };
+        }
+    },
+};
+/** @deprecated Use sellOpns */
+export const opnsList = sellOpns;
+export const sendOpns = {
+    meta: {
+        name: 'sendOpns',
+        description: 'Transfer an OpNS name to a new owner',
+        category: 'opns',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string' },
+                counterparty: { type: 'string' },
+                address: { type: 'string' },
+            },
+            required: ['id'],
+        },
+    },
+    async execute(ctx, input) {
+        try {
+            if (!input.counterparty && !input.address) {
+                return { error: 'must-provide-counterparty-or-address' };
+            }
+            const loaded = await loadOpnsSpend(ctx, input);
+            if ('error' in loaded)
+                return loaded;
+            const { output, beef } = loaded;
+            if (!output.customInstructions) {
+                return { error: 'missing-custom-instructions' };
+            }
+            const outpoint = output.outpoint;
+            const isSelf = input.counterparty === 'self';
+            let recipientAddress;
+            if (input.counterparty) {
+                const { publicKey } = await ctx.wallet.getPublicKey({
+                    protocolID: P1SAT_PROTOCOL,
+                    keyID: outpoint,
+                    counterparty: input.counterparty,
+                    forSelf: isSelf,
                 });
+                recipientAddress = PublicKey.fromString(publicKey).toAddress();
+            }
+            else {
+                recipientAddress = input.address;
             }
+            const inputId = readAssetIdTag(output.tags);
+            const name = nameFromOutput(output);
+            const tags = opnsFileTags(output);
+            return await executeTrackedAction(ctx.wallet, {
+                description: 'Transfer OpNS name',
+                inputBEEF: beef,
+                ...(inputId && {
+                    labels: [buildInputAssetLabel(OPNS_BASKET, inputId)],
+                }),
+                inputs: [
+                    {
+                        outpoint,
+                        inputDescription: 'OpNS name to transfer',
+                        unlockingScriptLength: unlockingScriptLengthForInstructions(output.customInstructions),
+                    },
+                ],
+                outputs: [
+                    isSelf
+                        ? {
+                            lockingScript: new P2PKH().lock(recipientAddress).toHex(),
+                            satoshis: 1,
+                            outputDescription: 'OpNS self-transfer',
+                            basket: OPNS_BASKET,
+                            tags,
+                            customInstructions: JSON.stringify({
+                                protocolID: P1SAT_PROTOCOL,
+                                keyID: outpoint,
+                                ...(name && { name }),
+                            }),
+                        }
+                        : {
+                            lockingScript: new P2PKH().lock(recipientAddress).toHex(),
+                            satoshis: 1,
+                            outputDescription: 'OpNS transfer',
+                            tags: [],
+                        },
+                ],
+                options: { randomizeOutputs: false },
+            }, input.fundingProvider, beef, async (tx) => {
+                const unlocking = await signOrdinalInput(ctx, tx, 0, output.customInstructions);
+                if (typeof unlocking !== 'string')
+                    throw new Error(unlocking.error);
+                return { 0: { unlockingScript: unlocking } };
+            });
+        }
+        catch (error) {
+            console.error('[sendOpns]', error);
             return {
                 error: error instanceof Error ? error.message : 'unknown-error',
             };
         }
     },
 };
-/**
- * List an OpNS name for sale.
- * Spends the current lock (PushDrop or P2PKH); OrdLock output has no identity bind.
- */
-export const opnsList = {
+/** @deprecated Use sendOpns */
+export const opnsTransfer = sendOpns;
+export const cancelOpnsListing = {
     meta: {
-        name: 'opnsList',
-        description: 'List an OpNS name for sale',
+        name: 'cancelOpnsListing',
+        description: 'Cancel an OpNS name listing back into the OPNS basket',
         category: 'opns',
         inputSchema: {
             type: 'object',
             properties: {
-                ordinal: {
-                    type: 'object',
-                    description: 'WalletOutput of the OpNS ordinal from listOutputs',
-                },
-                inputBEEF: {
-                    type: 'array',
-                    description: "BEEF from listOutputs with include: 'entire transactions'",
-                },
-                price: { type: 'integer', description: 'Price in satoshis' },
-                payAddress: {
-                    type: 'string',
-                    description: 'Address to receive payment on purchase',
-                },
+                id: { type: 'string' },
             },
-            required: ['ordinal', 'price', 'payAddress'],
+            required: ['id'],
         },
     },
     async execute(ctx, input) {
-        return listOrdinal.execute(ctx, input);
+        try {
+            const loaded = await loadOpnsSpend(ctx, input);
+            if ('error' in loaded)
+                return loaded;
+            const { output: listing, beef: inputBEEF } = loaded;
+            const outpoint = listing.outpoint;
+            if (!listing.customInstructions) {
+                return { error: 'missing-custom-instructions' };
+            }
+            const { protocolID: signProtocolID, keyID: signKeyID, counterparty: signCounterparty, } = JSON.parse(listing.customInstructions);
+            const newKeyID = outpoint;
+            const cancelAddress = await deriveCancelAddressInternal(ctx, newKeyID);
+            const tags = opnsFileTags(listing);
+            const name = nameFromOutput(listing);
+            const inputId = readAssetIdTag(listing.tags);
+            const cancelUnlock = OrdLock.cancelWithWallet(ctx.wallet, signProtocolID, signKeyID, signCounterparty);
+            return await executeTrackedAction(ctx.wallet, {
+                description: 'Cancel OpNS listing',
+                inputBEEF,
+                ...(inputId && {
+                    labels: [buildInputAssetLabel(OPNS_BASKET, inputId)],
+                }),
+                inputs: [
+                    {
+                        outpoint,
+                        inputDescription: 'Listed OpNS name',
+                        unlockingScriptLength: 108,
+                    },
+                ],
+                outputs: [
+                    {
+                        lockingScript: new P2PKH().lock(cancelAddress).toHex(),
+                        satoshis: 1,
+                        outputDescription: 'Cancelled OpNS listing',
+                        basket: OPNS_BASKET,
+                        tags,
+                        customInstructions: JSON.stringify({
+                            protocolID: P1SAT_PROTOCOL,
+                            keyID: newKeyID,
+                            ...(name && { name }),
+                        }),
+                    },
+                ],
+                options: { randomizeOutputs: false },
+            }, input.fundingProvider, inputBEEF, async (tx) => {
+                const unlockingScript = await cancelUnlock.sign(tx, 0);
+                return { 0: { unlockingScript: unlockingScript.toHex() } };
+            });
+        }
+        catch (error) {
+            console.error('[cancelOpnsListing]', error);
+            return {
+                error: error instanceof Error ? error.message : 'unknown-error',
+            };
+        }
     },
 };
+/** @deprecated Use cancelOpnsListing */
+export const opnsCancelListing = cancelOpnsListing;
 /**
- * Transfer an OpNS name to a new owner.
- * Spends the current lock; recipient gets plain P2PKH (bind does not carry forward).
+ * Buy an OpNS listing and file into the OPNS basket with full tags.
  */
-export const opnsTransfer = {
+export const buyOpns = {
     meta: {
-        name: 'opnsTransfer',
-        description: 'Transfer an OpNS name to a new owner',
+        name: 'buyOpns',
+        description: 'Purchase an OpNS name listing into the OPNS basket',
         category: 'opns',
+        requiresServices: true,
         inputSchema: {
             type: 'object',
             properties: {
-                ordinal: {
-                    type: 'object',
-                    description: 'WalletOutput of the OpNS ordinal from listOutputs',
-                },
-                counterparty: {
-                    type: 'string',
-                    description: 'Recipient identity public key (hex)',
-                },
-                address: {
-                    type: 'string',
-                    description: 'Recipient P2PKH address',
-                },
-                inputBEEF: {
-                    type: 'array',
-                    description: "BEEF from listOutputs with include: 'entire transactions'",
-                },
+                outpoint: { type: 'string' },
+                inputBEEF: { type: 'array', items: { type: 'integer' } },
+                name: { type: 'string' },
+                origin: { type: 'string' },
+                marketplaceAddress: { type: 'string' },
+                marketplaceRate: { type: 'number' },
             },
-            required: ['ordinal'],
+            required: ['outpoint'],
         },
     },
     async execute(ctx, input) {
-        return transferOrdinals.execute(ctx, {
-            transfers: [
-                {
-                    ordinal: input.ordinal,
-                    counterparty: input.counterparty,
-                    address: input.address,
-                },
-            ],
+        const name = input.name?.slice(0, 64);
+        const origin = input.origin ?? input.outpoint;
+        const tags = [
+            'opns',
+            `type:${OPNS_CONTENT_TYPE}`,
+            `origin:${origin}`,
+            ...(name ? [`name:${name}`] : []),
+        ];
+        return buyOrdinal.execute(ctx, {
+            outpoint: input.outpoint,
             inputBEEF: input.inputBEEF,
+            marketplaceAddress: input.marketplaceAddress,
+            marketplaceRate: input.marketplaceRate,
+            name,
+            origin,
+            contentType: OPNS_CONTENT_TYPE,
             fundingProvider: input.fundingProvider,
+            basket: OPNS_BASKET,
+            tags,
         });
     },
 };
-/** All OpNS actions for registry (paid mine lives on 1sat.name / orchestrator). */
 export const opnsActions = [
-    getOpnsNames,
-    opnsRegister,
-    opnsDeregister,
-    opnsList,
-    opnsTransfer,
+    listOpns,
+    internalizeOpns,
+    registerOpns,
+    deregisterOpns,
+    sellOpns,
+    sendOpns,
+    cancelOpnsListing,
+    buyOpns,
 ];
 //# sourceMappingURL=index.js.map