@1sat/cli 0.0.80 → 0.0.82

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@1sat/cli",
-	"version": "0.0.80",
+	"version": "0.0.82",
 	"description": "CLI for 1Sat Ordinals SDK",
 	"type": "module",
 	"main": "./src/cli.ts",
@@ -26,11 +26,11 @@
 	],
 	"license": "MIT",
 	"dependencies": {
-		"@1sat/actions": "0.0.186",
+		"@1sat/actions": "0.0.187",
 		"@1sat/client": "0.0.43",
 		"@1sat/types": "0.0.34",
-		"@1sat/wallet-node": "0.0.59",
-		"@1sat/wallet-server": "0.0.28",
+		"@1sat/wallet-node": "0.0.60",
+		"@1sat/wallet-server": "0.0.29",
 		"@bsv/sdk": "^2.1.6",
 		"@bsv/wallet-toolbox": "2.1.24",
 		"chalk": "^5.0.0",

package/src/commands/opns.ts

@@ -1,14 +1,19 @@
 /**
- * OpNS commands - register, deregister, lookup.
+ * OpNS commands - register, deregister, lookup, sell, buy, cancel-listing.
  *
- * Manage OpNS name identity bindings. Paid mining is product code on 1sat.name.
+ * Manage OpNS names: payment identity bindings and market listings. Paid
+ * mining is product code on 1sat.name.
  */
 
 import {
+	cancelListing,
+	deriveDepositAddresses,
 	getDisplayValue,
 	getOpnsNames,
+	listOrdinal,
 	opnsDeregister as opnsDeregisterAction,
 	opnsRegister as opnsRegisterAction,
+	purchaseOrdinal,
 } from '@1sat/actions'
 import { confirm, isCancel } from '@clack/prompts'
 import type { GlobalFlags } from '../args'
@@ -31,6 +36,12 @@ export async function handleOpnsCommand(
 			return opnsDeregister(rest, opts)
 		case 'lookup':
 			return opnsLookup(rest, opts)
+		case 'sell':
+			return opnsSell(rest, opts)
+		case 'buy':
+			return opnsBuy(rest, opts)
+		case 'cancel-listing':
+			return opnsCancelListing(rest, opts)
 		default:
 			printCommandHelp('opns', opts.json)
 			if (subcommand && subcommand !== 'help') {
@@ -149,9 +160,15 @@ async function opnsLookup(_args: string[], opts: GlobalFlags): Promise<void> {
 			const nameTag = getDisplayValue(o, 'name', 'name') ?? ''
 			const publishedTag = o.tags?.find((t) => t === 'opns:published')
 			const status = publishedTag ? 'registered' : 'unregistered'
+			const price = o.tags?.some((t) => t === 'ordlock')
+				? (o.tags
+						?.find((t) => t.startsWith('price:'))
+						?.slice('price:'.length) ?? '?')
+				: undefined
+			const listed = price ? `  ${formatLabel(`listed @ ${price}`)}` : ''
 
 			console.log(
-				`  ${formatValue(o.outpoint)}  ${nameTag ? formatValue(nameTag) : ''}  ${formatLabel(status)}`,
+				`  ${formatValue(o.outpoint)}  ${nameTag ? formatValue(nameTag) : ''}  ${formatLabel(status)}${listed}`,
 			)
 		}
 
@@ -160,3 +177,138 @@ async function opnsLookup(_args: string[], opts: GlobalFlags): Promise<void> {
 		await destroy()
 	}
 }
+
+async function opnsCancelListing(
+	args: string[],
+	opts: GlobalFlags,
+): Promise<void> {
+	const outpoint = extractFlag(args, '--outpoint')
+
+	if (!outpoint) fatal('Missing --outpoint <txid.vout>')
+
+	if (!opts.yes) {
+		const ok = await confirm({
+			message: `Cancel listing for OpNS name ${outpoint}?`,
+		})
+		if (isCancel(ok) || !ok) {
+			fatal('Cancellation cancelled.')
+		}
+	}
+
+	const privateKey = await loadKey()
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		const namesResult = await getOpnsNames.execute(ctx, { limit: 10000 })
+		const listing = namesResult.outputs.find((o) => o.outpoint === outpoint)
+		if (!listing) {
+			fatal(`Listing not found in wallet OpNS basket: ${outpoint}`)
+		}
+
+		const result = await cancelListing.execute(ctx, {
+			listing,
+			inputBEEF: namesResult.BEEF as number[] | undefined,
+		})
+
+		if (result.error) {
+			fatal(result.error)
+		}
+
+		output(opts.json ? result : { txid: result.txid }, opts)
+	} finally {
+		await destroy()
+	}
+}
+
+async function opnsSell(args: string[], opts: GlobalFlags): Promise<void> {
+	const outpoint = extractFlag(args, '--outpoint')
+	const priceStr = extractFlag(args, '--price')
+
+	if (!outpoint) fatal('Missing --outpoint <txid.vout>')
+	if (!priceStr) fatal('Missing --price <satoshis>')
+
+	const price = Number(priceStr)
+	if (!Number.isFinite(price) || price <= 0) {
+		fatal('--price must be a positive number')
+	}
+
+	if (!opts.yes) {
+		const ok = await confirm({
+			message: `List OpNS name ${outpoint} for sale at ${price} satoshis?`,
+		})
+		if (isCancel(ok) || !ok) {
+			fatal('Listing cancelled.')
+		}
+	}
+
+	const privateKey = await loadKey()
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		const namesResult = await getOpnsNames.execute(ctx, { limit: 10000 })
+		const ordinal = namesResult.outputs.find((o) => o.outpoint === outpoint)
+		if (!ordinal) {
+			fatal(`OpNS name not found in wallet: ${outpoint}`)
+		}
+
+		const addressResult = await deriveDepositAddresses.execute(ctx, {
+			prefix: '1sat',
+			count: 1,
+		})
+		const payAddress = addressResult.derivations[0]?.address
+		if (!payAddress) {
+			fatal('Failed to derive pay address')
+		}
+
+		const result = await listOrdinal.execute(ctx, {
+			ordinal,
+			price,
+			payAddress,
+			inputBEEF: namesResult.BEEF as number[] | undefined,
+		})
+
+		if (result.error) {
+			fatal(result.error)
+		}
+
+		output(opts.json ? result : { txid: result.txid }, opts)
+	} finally {
+		await destroy()
+	}
+}
+
+async function opnsBuy(args: string[], opts: GlobalFlags): Promise<void> {
+	const outpoint = extractFlag(args, '--outpoint')
+
+	if (!outpoint) fatal('Missing --outpoint <txid.vout>')
+
+	if (!opts.yes) {
+		const ok = await confirm({
+			message: `Purchase OpNS name listing ${outpoint}?`,
+		})
+		if (isCancel(ok) || !ok) {
+			fatal('Purchase cancelled.')
+		}
+	}
+
+	const privateKey = await loadKey()
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		const result = await purchaseOrdinal.execute(ctx, { outpoint })
+
+		if (result.error) {
+			fatal(result.error)
+		}
+
+		output(opts.json ? result : { txid: result.txid }, opts)
+	} finally {
+		await destroy()
+	}
+}

package/src/commands/storage.ts

@@ -0,0 +1,117 @@
+/**
+ * Storage maintenance commands — operate directly on the serve wallet's
+ * storage database (config under server.storage in config.json).
+ */
+
+import { nominateInvalidReqs, StorageBunSqlite } from '@1sat/wallet-node'
+import { StorageProvider } from '@bsv/wallet-toolbox'
+import { join } from 'node:path'
+import type { GlobalFlags } from '../args'
+import { extractFlag } from '../args'
+import { ensureDataDir, loadConfig } from '../config'
+import { printCommandHelp } from '../help'
+import { fatal, output } from '../output'
+
+export async function handleStorageCommand(
+	args: string[],
+	opts: GlobalFlags,
+): Promise<void> {
+	const [subcommand, ...rest] = args
+
+	switch (subcommand) {
+		case 'unfail':
+			return storageUnfail(rest, opts)
+		default:
+			printCommandHelp('storage', opts.json)
+			if (subcommand && subcommand !== 'help') {
+				process.exit(1)
+			}
+	}
+}
+
+/**
+ * Nominate invalid proven_tx_reqs for recovery. Writes only the `unfail`
+ * status; the running monitor's TaskUnFail verifies each txid against
+ * the chain, restores the ones that actually mined, and returns the rest
+ * to `invalid`. Safe to run against a live serve instance — same
+ * single-field status update the monitor's own review tasks perform.
+ */
+async function storageUnfail(
+	args: string[],
+	opts: GlobalFlags,
+): Promise<void> {
+	const rawWindow = extractFlag(args, '--window')
+	if (!rawWindow) {
+		fatal(
+			"--window is required: 'all' for every invalid record (one-time cleanup), or a duration like 30d / 12h / 90m",
+		)
+	}
+	const windowMsecs = parseWindow(rawWindow)
+
+	const storage = await openServeStorage(opts)
+	try {
+		const { nominated } = await nominateInvalidReqs(storage, windowMsecs)
+
+		if (opts.json) {
+			output({ nominated }, opts)
+			return
+		}
+
+		if (nominated.length === 0) {
+			console.log('No invalid reqs in window — nothing nominated.')
+			return
+		}
+		console.log(`Nominated ${nominated.length} invalid req(s) for unfail review:`)
+		for (const n of nominated) {
+			console.log(`  ${n.provenTxReqId}  ${n.txid}`)
+		}
+		console.log(
+			'The running monitor (1sat serve / serve monitor) processes these on its next TaskUnFail tick: mined transactions are restored, the rest return to invalid.',
+		)
+	} finally {
+		await storage.destroy()
+	}
+}
+
+function parseWindow(raw: string): number | undefined {
+	if (raw === 'all') return undefined
+	const m = raw.match(/^(\d+)([dhm])$/)
+	if (!m) {
+		fatal(
+			`--window must be 'all' or a duration like 30d, 12h, 90m — got: ${raw}`,
+		)
+	}
+	const units: Record<string, number> = {
+		d: 24 * 60 * 60 * 1000,
+		h: 60 * 60 * 1000,
+		m: 60 * 1000,
+	}
+	return Number(m[1]) * units[m[2]]
+}
+
+/** Open the serve wallet's storage exactly as `1sat serve` resolves it. */
+async function openServeStorage(opts: GlobalFlags): Promise<StorageProvider> {
+	const config = loadConfig()
+	const chain = opts.chain ?? config.chain ?? 'main'
+	const storageConfig = config.server?.storage ?? { provider: 'bun-sqlite' }
+	const baseOptions = StorageProvider.createStorageBaseOptions(chain)
+
+	let storage: StorageProvider
+	if (storageConfig.provider === 'pg') {
+		if (!storageConfig.dbUrl) {
+			fatal(
+				'server.storage.provider is pg but server.storage.dbUrl is not set.',
+			)
+		}
+		const { StoragePg } = await import('@1sat/wallet-node')
+		storage = new StoragePg({ ...baseOptions, dbUrl: storageConfig.dbUrl })
+	} else {
+		storage = new StorageBunSqlite({
+			...baseOptions,
+			filename: join(ensureDataDir(), `wallet-${chain}.db`),
+		})
+	}
+
+	await storage.makeAvailable()
+	return storage
+}

package/src/help.ts

@@ -496,19 +496,37 @@ export const COMMANDS: CommandSpec[] = [
 	{
 		group: 'OpNS',
 		name: 'opns',
-		description: 'Ordinals Name System — bind BAP identity to a name',
+		description: 'Ordinals Name System — on-chain names',
 		subcommands: [
 			{
 				name: 'register',
-				description: 'Register identity on an OpNS name',
+				description: 'Register a payment identity key on an OpNS name',
 				args: [{ flag: '--outpoint', values: '<txid.vout>', required: true }],
 			},
 			{
 				name: 'deregister',
-				description: 'Deregister identity from an OpNS name',
+				description: 'Deregister the payment identity from an OpNS name',
 				args: [{ flag: '--outpoint', values: '<txid.vout>', required: true }],
 			},
 			{ name: 'lookup', description: 'List OpNS names from wallet' },
+			{
+				name: 'sell',
+				description: 'List an OpNS name for sale',
+				args: [
+					{ flag: '--outpoint', values: '<txid.vout>', required: true },
+					{ flag: '--price', values: '<satoshis>', required: true },
+				],
+			},
+			{
+				name: 'buy',
+				description: 'Purchase an OpNS name listing',
+				args: [{ flag: '--outpoint', values: '<txid.vout>', required: true }],
+			},
+			{
+				name: 'cancel-listing',
+				description: 'Cancel a market listing on an OpNS name',
+				args: [{ flag: '--outpoint', values: '<txid.vout>', required: true }],
+			},
 		],
 	},
 
@@ -552,6 +570,28 @@ export const COMMANDS: CommandSpec[] = [
 			},
 		],
 	},
+	{
+		group: 'Server',
+		name: 'storage',
+		description:
+			'Serve-wallet storage maintenance (config under server.storage in config.json)',
+		subcommands: [
+			{
+				name: 'unfail',
+				description:
+					'Nominate invalid proven_tx_reqs for chain re-check; the running monitor restores any that actually mined',
+				args: [
+					{
+						flag: '--window',
+						values: "<all|30d|12h|90m>",
+						required: true,
+						description:
+							"Only reqs created within the window; 'all' for every invalid record",
+					},
+				],
+			},
+		],
+	},
 
 	// MCP
 	{

package/src/main.ts

@@ -21,6 +21,7 @@ import { handleOpnsCommand } from './commands/opns'
 import { handleOrdinalsCommand } from './commands/ordinals'
 import { handleRemoteCommand } from './commands/remote'
 import { handleServeCommand } from './commands/serve'
+import { handleStorageCommand } from './commands/storage'
 import { handleSocialCommand } from './commands/social'
 import { handleSweepCommand } from './commands/sweep'
 import { handleTokensCommand } from './commands/tokens'
@@ -134,6 +135,10 @@ async function main(): Promise<void> {
 			await handleServeCommand(rest, flags)
 			break
 
+		case 'storage':
+			await handleStorageCommand(rest, flags)
+			break
+
 		// Hidden: parent CLI spawns this after wallet destroy so monitor
 		// stdout/stderr go to ~/.1sat/cli/monitor.log instead of the TTY.
 		case '__monitor-once':