@1sat/actions 0.0.189 → 0.0.191

package/dist/ordinals/index.js

@@ -11,7 +11,8 @@ import { parseOutpoint } from '@1sat/utils';
 import { Beef, BigNumber, LockingScript, OP, P2PKH, PublicKey, Script, TransactionSignature, UnlockingScript, Utils, } from '@bsv/sdk';
 import { OPNS_BASKET, ORDINALS_BASKET, ORD_LOCK_PREFIX, ORD_LOCK_SUFFIX, P1SAT_PROTOCOL, } from '../constants';
 import { executeTrackedAction } from '../utils/createTrackedAction';
-import { resolveBeef } from '../utils/resolveBeef';
+import { loadBasketOutputBeef } from '../utils/loadBasketOutput';
+import { ordinalSeedTags } from '../utils/ordinalSeedTags';
 import { signOrdinalInput, unlockingScriptLengthForInstructions, } from '../utils/signOrdinalInput';
 // ============================================================================
 // Helpers
@@ -102,7 +103,8 @@ export async function resolveOrdinalTags(ctx, outpoint, source) {
 // ============================================================================
 // Internal helpers
 // ============================================================================
-async function deriveCancelAddressInternal(ctx, outpoint) {
+/** Cancel/list key address for an outpoint (P1SAT self). */
+export async function deriveCancelAddressInternal(ctx, outpoint) {
     const result = await ctx.wallet.getPublicKey({
         protocolID: P1SAT_PROTOCOL,
         keyID: outpoint,
@@ -110,7 +112,17 @@ async function deriveCancelAddressInternal(ctx, outpoint) {
     });
     return PublicKey.fromString(result.publicKey).toAddress();
 }
-function buildOrdLockScript(ordAddress, payAddress, price) {
+/** Default OrdLock payment address: P1SAT keyID `1sat 0`, self. */
+export async function defaultPayAddress(ctx) {
+    const result = await ctx.wallet.getPublicKey({
+        protocolID: P1SAT_PROTOCOL,
+        keyID: '1sat 0',
+        counterparty: 'self',
+        forSelf: true,
+    });
+    return PublicKey.fromString(result.publicKey).toAddress();
+}
+export function buildOrdLockScript(ordAddress, payAddress, price) {
     const cancelPkh = Utils.fromBase58Check(ordAddress).data;
     const payPkh = Utils.fromBase58Check(payAddress).data;
     const payoutScript = new P2PKH().lock(payPkh).toBinary();
@@ -172,9 +184,26 @@ async function buildPurchaseUnlockingScript(tx, inputIndex, sourceSatoshis, lock
 // ============================================================================
 // Builder functions (utilities for advanced use)
 // ============================================================================
+async function loadOrdinalSpend(ctx, id) {
+    return loadBasketOutputBeef(ctx.wallet, ORDINALS_BASKET, id);
+}
+function nameFromOutput(output, tags) {
+    if (output.customInstructions) {
+        try {
+            const n = JSON.parse(output.customInstructions).name;
+            if (typeof n === 'string' && n)
+                return n.slice(0, 64);
+        }
+        catch { }
+    }
+    const fromTags = (tags ?? output.tags)
+        ?.find((t) => t.startsWith('name:'))
+        ?.slice(5);
+    return fromTags?.slice(0, 64);
+}
 /**
  * Build CreateActionArgs for transferring one or more ordinals.
- * Does NOT execute - returns params for createAction.
+ * Loads each id once from the ordinals basket.
  */
 export async function buildTransferOrdinals(ctx, request) {
     const { transfers } = request;
@@ -184,11 +213,21 @@ export async function buildTransferOrdinals(ctx, request) {
     const inputs = [];
     const outputs = [];
     const labels = [];
-    let resolvedBasket = ORDINALS_BASKET;
-    for (const { ordinal, counterparty, address, map, extraTags } of transfers) {
+    const sources = [];
+    const beefParts = [];
+    for (const item of transfers) {
+        const { id, counterparty, address, map } = item;
+        if (!id)
+            return { error: 'missing-id' };
         if (!counterparty && !address) {
             return { error: 'must-provide-counterparty-or-address' };
         }
+        const loaded = await loadOrdinalSpend(ctx, id);
+        if ('error' in loaded)
+            return loaded;
+        const { output: ordinal, beef } = loaded;
+        sources.push(ordinal);
+        beefParts.push(beef);
         const outpoint = ordinal.outpoint;
         const sourceType = ordinal.tags
             ?.find((t) => t.startsWith('type:'))
@@ -215,24 +254,16 @@ export async function buildTransferOrdinals(ctx, request) {
         else {
             return { error: 'must-provide-counterparty-or-address' };
         }
-        const { tags, basket } = await resolveOrdinalTags(ctx, outpoint, {
-            tags: ordinal.tags,
-        });
-        if (extraTags)
-            tags.push(...extraTags);
-        resolvedBasket = basket;
+        const tags = ordinalSeedTags(ordinal);
+        const basket = ORDINALS_BASKET;
         inputs?.push({
             outpoint,
             inputDescription: 'Ordinal to transfer',
             unlockingScriptLength: unlockingScriptLengthForInstructions(ordinal.customInstructions),
         });
-        // Emit a per-ordinal input label so the 1Sat permission module can
-        // resolve the source output's id-tagged record in wallet storage and
-        // render trusted metadata (origin / contentType / name).
         const inputId = readAssetIdTag(ordinal.tags);
         if (inputId)
             labels.push(buildInputAssetLabel(basket, inputId));
-        // Build locking script — append MAP metadata when provided
         const p2pkhScript = new P2PKH().lock(recipientAddress);
         let lockingScript;
         if (map && Object.keys(map).length > 0) {
@@ -247,20 +278,8 @@ export async function buildTransferOrdinals(ctx, request) {
         else {
             lockingScript = p2pkhScript.toHex();
         }
-        // Carry forward the name from CI, else from resolved tags.
-        let sourceName;
-        if (ordinal.customInstructions) {
-            try {
-                sourceName = JSON.parse(ordinal.customInstructions).name;
-            }
-            catch { }
-        }
-        if (!sourceName) {
-            sourceName = tags.find((t) => t.startsWith('name:'))?.slice(5);
-        }
+        const sourceName = nameFromOutput(ordinal, tags);
         if (isSelf) {
-            // Keep the ordinal in our wallet with full labeling (register/deregister,
-            // self-retags). External sends must not basket on the sender side.
             outputs?.push({
                 lockingScript,
                 satoshis: 1,
@@ -285,8 +304,9 @@ export async function buildTransferOrdinals(ctx, request) {
             });
         }
     }
-    const inputBEEF = request.inputBEEF ??
-        (await resolveBeef(ctx.wallet, resolvedBasket, transfers[0].ordinal));
+    if (!beefParts.length)
+        return { error: 'missing-input-beef' };
+    const inputBEEF = beefParts[0];
     return {
         description: transfers.length === 1
             ? 'Transfer ordinal'
@@ -295,18 +315,24 @@ export async function buildTransferOrdinals(ctx, request) {
         inputs,
         outputs,
         labels,
+        sources,
     };
 }
 /**
  * Build CreateActionArgs for listing an ordinal for sale.
- * Does NOT execute - returns params for createAction.
+ * Loads id once from the ordinals basket.
  */
 export async function buildListOrdinal(ctx, request) {
-    const { ordinal, price, payAddress, map } = request;
-    if (!payAddress)
-        return { error: 'missing-pay-address' };
+    const { id, price, map } = request;
+    if (!id)
+        return { error: 'missing-id' };
     if (price <= 0)
         return { error: 'invalid-price' };
+    const loaded = await loadOrdinalSpend(ctx, id);
+    if ('error' in loaded)
+        return loaded;
+    const { output: ordinal, beef } = loaded;
+    const payAddress = request.payAddress ?? (await defaultPayAddress(ctx));
     const outpoint = ordinal.outpoint;
     const cancelAddress = await deriveCancelAddressInternal(ctx, outpoint);
     const ordLockScript = buildOrdLockScript(cancelAddress, payAddress, price);
@@ -325,23 +351,14 @@ export async function buildListOrdinal(ctx, request) {
     else {
         lockingScript = ordLockScript.toHex();
     }
-    const { tags, basket } = await resolveOrdinalTags(ctx, outpoint, {
-        tags: ordinal.tags,
-    });
-    tags.push('ordlock', `price:${price}`);
-    let sourceName;
-    if (ordinal.customInstructions) {
-        try {
-            sourceName = JSON.parse(ordinal.customInstructions).name;
-        }
-        catch { }
-    }
-    const inputBEEF = request.inputBEEF ?? (await resolveBeef(ctx.wallet, basket, ordinal));
+    const tags = [...ordinalSeedTags(ordinal), 'ordlock', `price:${price}`];
+    const basket = ORDINALS_BASKET;
+    const sourceName = nameFromOutput(ordinal, tags);
     const inputId = readAssetIdTag(ordinal.tags);
     const labels = inputId ? [buildInputAssetLabel(basket, inputId)] : undefined;
     return {
         description: `List ordinal for ${price} sats`,
-        inputBEEF,
+        inputBEEF: beef,
         ...(labels && { labels }),
         inputs: [
             {
@@ -364,6 +381,7 @@ export async function buildListOrdinal(ctx, request) {
                 }),
             },
         ],
+        source: ordinal,
     };
 }
 /**
@@ -371,17 +389,23 @@ export async function buildListOrdinal(ctx, request) {
  * Does NOT execute - returns params for createAction.
  */
 export async function buildBurnOrdinals(ctx, request) {
-    const { ordinals } = request;
-    if (!ordinals.length) {
+    const ordinals = [];
+    const beefParts = [];
+    if (!request.ids?.length) {
         return { error: 'no-ordinals' };
     }
+    for (const id of request.ids) {
+        const loaded = await loadOrdinalSpend(ctx, id);
+        if ('error' in loaded)
+            return loaded;
+        ordinals.push(loaded.output);
+        beefParts.push(loaded.beef);
+    }
     const inputs = ordinals.map((ordinal) => ({
         outpoint: ordinal.outpoint,
         inputDescription: 'Ordinal to burn',
         unlockingScriptLength: unlockingScriptLengthForInstructions(ordinal.customInstructions),
     }));
-    const inputBEEF = request.inputBEEF ??
-        (await resolveBeef(ctx.wallet, ORDINALS_BASKET, ordinals[0]));
     const mapScript = MAPTemplate.set({
         app: request.app ?? '1sat',
         type: 'ord',
@@ -398,7 +422,7 @@ export async function buildBurnOrdinals(ctx, request) {
         description: ordinals.length === 1
             ? 'Burn ordinal'
             : `Burn ${ordinals.length} ordinals`,
-        inputBEEF,
+        inputBEEF: beefParts[0],
         ...(labels.length > 0 && { labels }),
         inputs,
         outputs: [
@@ -408,19 +432,27 @@ export async function buildBurnOrdinals(ctx, request) {
                 outputDescription: 'Burn ordinals',
             },
         ],
+        sources: ordinals,
     };
 }
 /**
- * Get ordinals from the wallet with BEEF for spending.
+ * List ordinals in the wallet. Metadata (tags/CI) by default; BEEF on demand.
  */
-export const getOrdinals = {
+export const listOrdinals = {
     meta: {
-        name: 'getOrdinals',
-        description: 'Get ordinals/inscriptions from the wallet with BEEF for spending',
+        name: 'listOrdinals',
+        description: 'List ordinals/inscriptions (metadata by default; optional BEEF)',
         category: 'ordinals',
         inputSchema: {
             type: 'object',
             properties: {
+                tags: { type: 'array', items: { type: 'string' } },
+                tagQueryMode: { type: 'string', enum: ['all', 'any'] },
+                ids: { type: 'array', items: { type: 'string' } },
+                include: {
+                    type: 'string',
+                    enum: ['locking scripts', 'entire transactions'],
+                },
                 limit: {
                     type: 'integer',
                     description: 'Max ordinals to return (default: 100)',
@@ -433,26 +465,42 @@ export const getOrdinals = {
         },
     },
     async execute(ctx, input) {
+        const tags = [...(input.tags ?? [])];
+        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: ORDINALS_BASKET,
-            includeTags: true,
-            includeCustomInstructions: true,
-            include: 'entire transactions',
+            ...(filtering && {
+                tags,
+                tagQueryMode: input.tagQueryMode ?? 'any',
+            }),
+            ...(input.include && { include: input.include }),
+            includeTags: input.includeTags ?? true,
+            includeCustomInstructions: input.includeCustomInstructions ?? 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,
         };
     },
 };
+/** @deprecated Use listOrdinals */
+export const getOrdinals = listOrdinals;
 /**
  * Transfer an ordinal to a new owner.
  */
-export const transferOrdinals = {
+export const sendOrdinals = {
     meta: {
-        name: 'transferOrdinals',
+        name: 'sendOrdinals',
         description: 'Transfer one or more ordinals to new owners',
         category: 'ordinals',
         inputSchema: {
@@ -464,9 +512,9 @@ export const transferOrdinals = {
                     items: {
                         type: 'object',
                         properties: {
-                            ordinal: {
-                                type: 'object',
-                                description: 'WalletOutput from listOutputs',
+                            id: {
+                                type: 'string',
+                                description: 'Tracking id in the ordinals basket',
                             },
                             counterparty: {
                                 type: 'string',
@@ -481,15 +529,11 @@ export const transferOrdinals = {
                                 description: 'Optional MAP metadata to append to the output script',
                             },
                         },
-                        required: ['ordinal'],
+                        required: ['id'],
                     },
                 },
-                inputBEEF: {
-                    type: 'array',
-                    description: "BEEF from listOutputs with include: 'entire transactions'",
-                },
             },
-            required: ['transfers', 'inputBEEF'],
+            required: ['transfers'],
         },
     },
     async execute(ctx, input) {
@@ -522,13 +566,14 @@ export const transferOrdinals = {
             catch (e) {
                 console.log('[transferOrdinals] BEEF parse error:', e);
             }
+            const { sources, ...createArgs } = params;
             const result = await executeTrackedAction(ctx.wallet, {
-                ...params,
+                ...createArgs,
                 options: { randomizeOutputs: false },
             }, input.fundingProvider, params.inputBEEF, async (tx) => {
                 const spends = {};
-                for (let i = 0; i < input.transfers.length; i++) {
-                    const { ordinal } = input.transfers[i];
+                for (let i = 0; i < sources.length; i++) {
+                    const ordinal = sources[i];
                     if (!ordinal.customInstructions) {
                         throw new Error(`missing-custom-instructions-for-${ordinal.outpoint}`);
                     }
@@ -540,10 +585,10 @@ export const transferOrdinals = {
                 return spends;
             });
             if (ctx.debug && ctx.log) {
-                const logOutputs = input.transfers.map((t, i) => ({
+                const logOutputs = sources.map((s, i) => ({
                     index: i,
                     protocolID: P1SAT_PROTOCOL,
-                    keyID: t.ordinal.outpoint,
+                    keyID: s.outpoint,
                     basket: ORDINALS_BASKET,
                     satoshis: 1,
                 }));
@@ -552,7 +597,7 @@ export const transferOrdinals = {
                     action: 'transferOrdinals',
                     input: {
                         transfers: input.transfers.map((t) => ({
-                            outpoint: t.ordinal.outpoint,
+                            id: t.id,
                             counterparty: t.counterparty,
                             address: t.address,
                         })),
@@ -572,7 +617,7 @@ export const transferOrdinals = {
                     action: 'transferOrdinals',
                     input: {
                         transfers: input.transfers.map((t) => ({
-                            outpoint: t.ordinal.outpoint,
+                            id: t.id,
                         })),
                     },
                     error: error instanceof Error ? error.message : 'unknown-error',
@@ -584,36 +629,34 @@ export const transferOrdinals = {
         }
     },
 };
+/** @deprecated Use sendOrdinals */
+export const transferOrdinals = sendOrdinals;
 /**
  * List an ordinal for sale on the global orderbook.
  */
-export const listOrdinal = {
+export const sellOrdinal = {
     meta: {
-        name: 'listOrdinal',
+        name: 'sellOrdinal',
         description: 'List an ordinal for sale on the global orderbook',
         category: 'ordinals',
         inputSchema: {
             type: 'object',
             properties: {
-                ordinal: {
-                    type: 'object',
-                    description: 'WalletOutput from listOutputs',
-                },
-                inputBEEF: {
-                    type: 'array',
-                    description: "BEEF from listOutputs with include: 'entire transactions'",
+                id: {
+                    type: 'string',
+                    description: 'Tracking id in the ordinals basket',
                 },
                 price: { type: 'integer', description: 'Price in satoshis' },
                 payAddress: {
                     type: 'string',
-                    description: 'Address to receive payment on purchase',
+                    description: 'Address to receive payment (default: P1SAT keyID 1sat 0)',
                 },
                 map: {
                     type: 'object',
                     description: 'Optional MAP metadata to append to the listing output script',
                 },
             },
-            required: ['ordinal', 'inputBEEF', 'price', 'payAddress'],
+            required: ['id', 'price'],
         },
     },
     async execute(ctx, input) {
@@ -622,14 +665,15 @@ export const listOrdinal = {
             if ('error' in params) {
                 return params;
             }
-            if (!input.ordinal.customInstructions) {
+            const { source, ...createArgs } = params;
+            if (!source.customInstructions) {
                 return { error: 'missing-custom-instructions' };
             }
             const result = await executeTrackedAction(ctx.wallet, {
-                ...params,
+                ...createArgs,
                 options: { randomizeOutputs: false },
             }, input.fundingProvider, params.inputBEEF, async (tx) => {
-                const unlocking = await signOrdinalInput(ctx, tx, 0, input.ordinal.customInstructions);
+                const unlocking = await signOrdinalInput(ctx, tx, 0, source.customInstructions);
                 if (typeof unlocking !== 'string')
                     throw new Error(unlocking.error);
                 return { 0: { unlockingScript: unlocking } };
@@ -637,15 +681,15 @@ export const listOrdinal = {
             if (ctx.debug && ctx.log) {
                 ctx.log({
                     timestamp: new Date().toISOString(),
-                    action: 'listOrdinal',
-                    input: { outpoint: input.ordinal.outpoint, price: input.price },
+                    action: 'sellOrdinal',
+                    input: { outpoint: source.outpoint, price: input.price },
                     txid: result.txid,
                     rawtx: result.tx ? Utils.toHex(result.tx) : undefined,
                     outputs: [
                         {
                             index: 0,
                             protocolID: P1SAT_PROTOCOL,
-                            keyID: input.ordinal.outpoint,
+                            keyID: source.outpoint,
                             basket: ORDINALS_BASKET,
                             satoshis: 1,
                         },
@@ -655,12 +699,12 @@ export const listOrdinal = {
             return result;
         }
         catch (error) {
-            console.error('[listOrdinal]', error);
+            console.error('[sellOrdinal]', error);
             if (ctx.debug && ctx.log) {
                 ctx.log({
                     timestamp: new Date().toISOString(),
-                    action: 'listOrdinal',
-                    input: { outpoint: input.ordinal.outpoint, price: input.price },
+                    action: 'sellOrdinal',
+                    input: { price: input.price },
                     error: error instanceof Error ? error.message : 'unknown-error',
                 });
             }
@@ -670,32 +714,35 @@ export const listOrdinal = {
         }
     },
 };
+/** @deprecated Use sellOrdinal */
+export const listOrdinal = sellOrdinal;
 /**
  * Cancel an ordinal listing.
  */
-export const cancelListing = {
+export const cancelOrdinalListing = {
     meta: {
-        name: 'cancelListing',
+        name: 'cancelOrdinalListing',
         description: 'Cancel an ordinal listing and return the ordinal to the wallet',
         category: 'ordinals',
         inputSchema: {
             type: 'object',
             properties: {
-                listing: {
-                    type: 'object',
-                    description: 'WalletOutput of the listing (must include lockingScript)',
-                },
-                inputBEEF: {
-                    type: 'array',
-                    description: 'BEEF — resolved automatically via ID tag if omitted',
+                id: {
+                    type: 'string',
+                    description: 'Tracking id of the listing in the ordinals basket',
                 },
             },
-            required: ['listing'],
+            required: ['id'],
         },
     },
     async execute(ctx, input) {
         try {
-            const { listing } = input;
+            if (!input.id)
+                return { error: 'missing-id' };
+            const loaded = await loadOrdinalSpend(ctx, input.id);
+            if ('error' in loaded)
+                return loaded;
+            const { output: listing, beef: inputBEEF } = loaded;
             const outpoint = listing.outpoint;
             if (!listing.customInstructions) {
                 return { error: 'missing-custom-instructions' };
@@ -712,18 +759,9 @@ export const cancelListing = {
             // derivation so the next spend reproduces the same key.
             const newKeyID = outpoint;
             const cancelAddress = await deriveCancelAddressInternal(ctx, newKeyID);
-            const { tags, basket } = await resolveOrdinalTags(ctx, outpoint, {
-                tags: listing.tags,
-            });
-            const inputBEEF = input.inputBEEF ?? (await resolveBeef(ctx.wallet, basket, listing));
-            let sourceName;
-            try {
-                sourceName = JSON.parse(listing.customInstructions).name;
-            }
-            catch { }
-            if (!sourceName) {
-                sourceName = tags.find((t) => t.startsWith('name:'))?.slice(5);
-            }
+            const tags = ordinalSeedTags(listing);
+            const basket = ORDINALS_BASKET;
+            const sourceName = nameFromOutput(listing, tags);
             const cancelUnlock = OrdLock.cancelWithWallet(ctx.wallet, signProtocolID, signKeyID, signCounterparty);
             const inputId = readAssetIdTag(listing.tags);
             const result = await executeTrackedAction(ctx.wallet, {
@@ -761,7 +799,7 @@ export const cancelListing = {
             if (ctx.debug && ctx.log) {
                 ctx.log({
                     timestamp: new Date().toISOString(),
-                    action: 'cancelListing',
+                    action: 'cancelOrdinalListing',
                     input: { outpoint, signKeyID },
                     txid: result.txid,
                     rawtx: result.tx ? Utils.toHex(result.tx) : undefined,
@@ -778,12 +816,12 @@ export const cancelListing = {
             return result;
         }
         catch (error) {
-            console.error('[cancelListing]', error);
+            console.error('[cancelOrdinalListing]', error);
             if (ctx.debug && ctx.log) {
                 ctx.log({
                     timestamp: new Date().toISOString(),
-                    action: 'cancelListing',
-                    input: { outpoint: input.listing.outpoint },
+                    action: 'cancelOrdinalListing',
+                    input: { id: input.id },
                     error: error instanceof Error ? error.message : 'unknown-error',
                 });
             }
@@ -793,12 +831,14 @@ export const cancelListing = {
         }
     },
 };
+/** @deprecated Use cancelOrdinalListing */
+export const cancelListing = cancelOrdinalListing;
 /**
  * Purchase an ordinal from the global orderbook.
  */
-export const purchaseOrdinal = {
+export const buyOrdinal = {
     meta: {
-        name: 'purchaseOrdinal',
+        name: 'buyOrdinal',
         description: 'Purchase an ordinal from the global orderbook',
         category: 'ordinals',
         requiresServices: true,
@@ -809,6 +849,11 @@ export const purchaseOrdinal = {
                     type: 'string',
                     description: 'Outpoint of the listing to purchase',
                 },
+                inputBEEF: {
+                    type: 'array',
+                    description: 'BEEF for listing tx; else services fetch',
+                    items: { type: 'integer' },
+                },
                 marketplaceAddress: {
                     type: 'string',
                     description: 'Marketplace address for fees',
@@ -832,16 +877,32 @@ export const purchaseOrdinal = {
     async execute(ctx, input) {
         try {
             const { outpoint, marketplaceAddress, marketplaceRate } = input;
-            if (!ctx.services) {
-                return { error: 'services-required-for-purchase' };
-            }
             const { txid, vout } = parseOutpoint(outpoint);
-            const { tags, basket } = await resolveOrdinalTags(ctx, outpoint, {
-                contentType: input.contentType,
-                origin: input.origin,
-                name: input.name,
-            });
-            const beef = await ctx.services.getBeefForTxid(txid);
+            let tags;
+            let basket;
+            if (input.tags?.length) {
+                basket = input.basket ?? ORDINALS_BASKET;
+                tags = input.tags;
+            }
+            else {
+                const resolved = await resolveOrdinalTags(ctx, outpoint, {
+                    contentType: input.contentType,
+                    origin: input.origin,
+                    name: input.name,
+                });
+                tags = resolved.tags;
+                basket = input.basket ?? resolved.basket;
+            }
+            let beef;
+            if (input.inputBEEF) {
+                beef = Beef.fromBinary(input.inputBEEF);
+            }
+            else {
+                if (!ctx.services) {
+                    return { error: 'services-required-for-purchase' };
+                }
+                beef = await ctx.services.getBeefForTxid(txid);
+            }
             const listingBeefTx = beef.findTxid(txid);
             if (!listingBeefTx?.tx) {
                 return { error: 'listing-transaction-not-found' };
@@ -862,6 +923,7 @@ export const purchaseOrdinal = {
             });
             const ourOrdAddress = PublicKey.fromString(publicKey).toAddress();
             const outputs = [];
+            const name = input.name ?? tags.find((t) => t.startsWith('name:'))?.slice(5);
             outputs.push({
                 lockingScript: new P2PKH().lock(ourOrdAddress).toHex(),
                 satoshis: 1,
@@ -871,7 +933,7 @@ export const purchaseOrdinal = {
                 customInstructions: JSON.stringify({
                     protocolID: P1SAT_PROTOCOL,
                     keyID: outpoint,
-                    ...(input.name && { name: input.name }),
+                    ...(name && { name }),
                 }),
             });
             const payoutReader = new Utils.Reader(ordLockData.payout);
@@ -916,7 +978,7 @@ export const purchaseOrdinal = {
             if (ctx.debug && ctx.log) {
                 ctx.log({
                     timestamp: new Date().toISOString(),
-                    action: 'purchaseOrdinal',
+                    action: 'buyOrdinal',
                     input: { outpoint },
                     txid: result.txid,
                     rawtx: result.tx ? Utils.toHex(result.tx) : undefined,
@@ -934,11 +996,11 @@ export const purchaseOrdinal = {
             return result;
         }
         catch (error) {
-            console.error('[purchaseOrdinal]', error);
+            console.error('[buyOrdinal]', error);
             if (ctx.debug && ctx.log) {
                 ctx.log({
                     timestamp: new Date().toISOString(),
-                    action: 'purchaseOrdinal',
+                    action: 'buyOrdinal',
                     input: { outpoint: input.outpoint },
                     error: error instanceof Error ? error.message : 'unknown-error',
                 });
@@ -949,6 +1011,8 @@ export const purchaseOrdinal = {
         }
     },
 };
+/** @deprecated Use buyOrdinal */
+export const purchaseOrdinal = buyOrdinal;
 /**
  * Burn one or more ordinals (send to OP_FALSE OP_RETURN).
  */
@@ -960,20 +1024,13 @@ export const burnOrdinals = {
         inputSchema: {
             type: 'object',
             properties: {
-                ordinals: {
+                ids: {
                     type: 'array',
-                    description: 'WalletOutputs to burn',
-                    items: {
-                        type: 'object',
-                        description: 'WalletOutput from listOutputs',
-                    },
-                },
-                inputBEEF: {
-                    type: 'array',
-                    description: 'BEEF — resolved automatically via ID tag if omitted',
+                    description: 'Tracking ids in the ordinals basket',
+                    items: { type: 'string' },
                 },
             },
-            required: ['ordinals'],
+            required: ['ids'],
         },
     },
     async execute(ctx, input) {
@@ -982,24 +1039,14 @@ export const burnOrdinals = {
             if ('error' in params) {
                 return params;
             }
-            console.log('[burnOrdinals] params:', JSON.stringify({
-                description: params.description,
-                inputBEEF: params.inputBEEF
-                    ? `[${params.inputBEEF.length} bytes]`
-                    : 'undefined',
-                inputs: params.inputs,
-                outputs: params.outputs?.map((o) => ({
-                    ...o,
-                    lockingScript: `${o.lockingScript?.slice(0, 20)}...`,
-                })),
-            }, null, 2));
+            const { sources, ...createArgs } = params;
             const result = await executeTrackedAction(ctx.wallet, {
-                ...params,
+                ...createArgs,
                 options: { randomizeOutputs: false },
             }, input.fundingProvider, params.inputBEEF, async (tx) => {
                 const spends = {};
-                for (let i = 0; i < input.ordinals.length; i++) {
-                    const ordinal = input.ordinals[i];
+                for (let i = 0; i < sources.length; i++) {
+                    const ordinal = sources[i];
                     if (!ordinal.customInstructions) {
                         throw new Error(`missing-custom-instructions-for-${ordinal.outpoint}`);
                     }
@@ -1014,11 +1061,7 @@ export const burnOrdinals = {
                 ctx.log({
                     timestamp: new Date().toISOString(),
                     action: 'burnOrdinals',
-                    input: {
-                        ordinals: input.ordinals.map((o) => ({
-                            outpoint: o.outpoint,
-                        })),
-                    },
+                    input: { ids: input.ids },
                     txid: result.txid,
                     rawtx: result.tx ? Utils.toHex(result.tx) : undefined,
                 });
@@ -1031,11 +1074,7 @@ export const burnOrdinals = {
                 ctx.log({
                     timestamp: new Date().toISOString(),
                     action: 'burnOrdinals',
-                    input: {
-                        ordinals: input.ordinals.map((o) => ({
-                            outpoint: o.outpoint,
-                        })),
-                    },
+                    input: { ids: input.ids },
                     error: error instanceof Error ? error.message : 'unknown-error',
                 });
             }
@@ -1050,11 +1089,11 @@ export const burnOrdinals = {
 // ============================================================================
 /** All ordinals actions for registry */
 export const ordinalsActions = [
-    getOrdinals,
-    transferOrdinals,
-    listOrdinal,
-    cancelListing,
-    purchaseOrdinal,
+    listOrdinals,
+    sendOrdinals,
+    sellOrdinal,
+    cancelOrdinalListing,
+    buyOrdinal,
     burnOrdinals,
 ];
 //# sourceMappingURL=index.js.map