@1sat/cli 0.0.1

package/src/commands/ordinals.ts

@@ -0,0 +1,355 @@
+/**
+ * Ordinals commands - list, mint, transfer, sell, cancel, buy.
+ */
+
+import {
+	cancelListing,
+	deriveDepositAddresses,
+	getOrdinals,
+	inscribe,
+	listOrdinal,
+	purchaseOrdinal,
+	transferOrdinals,
+} from '@1sat/actions'
+import { Utils } from '@bsv/sdk'
+import { confirm, isCancel } from '@clack/prompts'
+import { readFileSync } from 'node:fs'
+import { basename, extname } from 'node:path'
+import type { GlobalFlags } from '../args'
+import { extractFlag } from '../args'
+import { loadContext } from '../context'
+import { printCommandHelp } from '../help'
+import { loadKey, resolvePassword } from '../keys'
+import { fatal, formatLabel, formatValue, output } from '../output'
+
+export async function handleOrdinalsCommand(
+	args: string[],
+	opts: GlobalFlags,
+): Promise<void> {
+	const [subcommand, ...rest] = args
+
+	switch (subcommand) {
+		case 'list':
+			return ordinalsList(rest, opts)
+		case 'mint':
+			return ordinalsMint(rest, opts)
+		case 'transfer':
+			return ordinalsTransfer(rest, opts)
+		case 'sell':
+			return ordinalsSell(rest, opts)
+		case 'cancel':
+			return ordinalsCancel(rest, opts)
+		case 'buy':
+			return ordinalsBuy(rest, opts)
+		default:
+			printCommandHelp('ordinals', {
+				list: 'List owned ordinals/inscriptions',
+				mint: 'Mint a new ordinal inscription (--file <path> --type <mime>)',
+				transfer: 'Transfer an ordinal (--outpoint <op> --to <addr>)',
+				sell: 'List an ordinal for sale (--outpoint <op> --price <sats>)',
+				cancel: 'Cancel an ordinal listing (--outpoint <op>)',
+				buy: 'Purchase a listed ordinal (--outpoint <op>)',
+			})
+			if (subcommand && subcommand !== 'help') {
+				process.exit(1)
+			}
+	}
+}
+
+async function ordinalsList(_args: string[], opts: GlobalFlags): Promise<void> {
+	const privateKey = await loadKey(resolvePassword())
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		const result = await getOrdinals.execute(ctx, {
+			limit: 100,
+			offset: 0,
+		})
+
+		if (opts.json) {
+			output(result.outputs, opts)
+			return
+		}
+
+		if (result.outputs.length === 0) {
+			output('No ordinals found.', opts)
+			return
+		}
+
+		for (const o of result.outputs) {
+			const typeTag =
+				o.tags?.find((t) => t.startsWith('type:'))?.slice(5) ?? 'unknown'
+			const originTag =
+				o.tags?.find((t) => t.startsWith('origin:'))?.slice(7) ?? ''
+			const nameTag = o.tags?.find((t) => t.startsWith('name:'))?.slice(5) ?? ''
+
+			console.log(
+				`  ${formatValue(o.outpoint)}  ${formatLabel(typeTag)}${nameTag ? `  ${nameTag}` : ''}${originTag ? `  origin:${originTag}` : ''}`,
+			)
+		}
+
+		console.log(`\n  ${result.outputs.length} ordinal(s) found.`)
+	} finally {
+		await destroy()
+	}
+}
+
+const MIME_TYPES: Record<string, string> = {
+	'.txt': 'text/plain',
+	'.html': 'text/html',
+	'.css': 'text/css',
+	'.js': 'application/javascript',
+	'.json': 'application/json',
+	'.xml': 'application/xml',
+	'.svg': 'image/svg+xml',
+	'.png': 'image/png',
+	'.jpg': 'image/jpeg',
+	'.jpeg': 'image/jpeg',
+	'.gif': 'image/gif',
+	'.webp': 'image/webp',
+	'.bmp': 'image/bmp',
+	'.mp3': 'audio/mpeg',
+	'.wav': 'audio/wav',
+	'.mp4': 'video/mp4',
+	'.webm': 'video/webm',
+	'.pdf': 'application/pdf',
+}
+
+async function ordinalsMint(args: string[], opts: GlobalFlags): Promise<void> {
+	const file = extractFlag(args, '--file')
+	const type = extractFlag(args, '--type')
+
+	if (!file) fatal('Missing --file <path>')
+
+	const contentType = type ?? MIME_TYPES[extname(file).toLowerCase()]
+	if (!contentType) {
+		fatal(
+			`Cannot detect content type for ${basename(file)}. Use --type <mime-type>`,
+		)
+	}
+
+	let fileBytes: Uint8Array
+	try {
+		fileBytes = readFileSync(file)
+	} catch (err) {
+		fatal(`Failed to read file: ${(err as Error).message}`)
+	}
+
+	const base64Content = Utils.toBase64(Array.from(fileBytes))
+
+	if (!opts.yes) {
+		const ok = await confirm({
+			message: `Inscribe ${basename(file)} (${contentType}, ${fileBytes.length} bytes)?`,
+		})
+		if (isCancel(ok) || !ok) {
+			fatal('Inscription cancelled.')
+		}
+	}
+
+	const privateKey = await loadKey(resolvePassword())
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		const result = await inscribe.execute(ctx, {
+			base64Content,
+			contentType,
+		})
+
+		if (result.error) {
+			fatal(result.error)
+		}
+
+		output(opts.json ? result : { txid: result.txid }, opts)
+	} finally {
+		await destroy()
+	}
+}
+
+async function ordinalsTransfer(
+	args: string[],
+	opts: GlobalFlags,
+): Promise<void> {
+	const outpoint = extractFlag(args, '--outpoint')
+	const to = extractFlag(args, '--to')
+
+	if (!outpoint) fatal('Missing --outpoint <txid.vout>')
+	if (!to) fatal('Missing --to <address>')
+
+	if (!opts.yes) {
+		const ok = await confirm({
+			message: `Transfer ordinal ${outpoint} to ${to}?`,
+		})
+		if (isCancel(ok) || !ok) {
+			fatal('Transfer cancelled.')
+		}
+	}
+
+	const privateKey = await loadKey(resolvePassword())
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		// Look up the ordinal from the wallet
+		const ordinalsResult = await getOrdinals.execute(ctx, { limit: 10000 })
+		const ordinal = ordinalsResult.outputs.find((o) => o.outpoint === outpoint)
+		if (!ordinal) {
+			fatal(`Ordinal not found in wallet: ${outpoint}`)
+		}
+
+		const result = await transferOrdinals.execute(ctx, {
+			transfers: [{ ordinal, address: to }],
+			inputBEEF: ordinalsResult.BEEF as number[] | undefined,
+		})
+
+		if (result.error) {
+			fatal(result.error)
+		}
+
+		output(opts.json ? result : { txid: result.txid }, opts)
+	} finally {
+		await destroy()
+	}
+}
+
+async function ordinalsSell(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 ordinal ${outpoint} for sale at ${price} satoshis?`,
+		})
+		if (isCancel(ok) || !ok) {
+			fatal('Listing cancelled.')
+		}
+	}
+
+	const privateKey = await loadKey(resolvePassword())
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		// Look up the ordinal from the wallet
+		const ordinalsResult = await getOrdinals.execute(ctx, { limit: 10000 })
+		const ordinal = ordinalsResult.outputs.find((o) => o.outpoint === outpoint)
+		if (!ordinal) {
+			fatal(`Ordinal not found in wallet: ${outpoint}`)
+		}
+
+		// Derive a BRC-29 address to receive payment
+		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: ordinalsResult.BEEF as number[] | undefined,
+		})
+
+		if (result.error) {
+			fatal(result.error)
+		}
+
+		output(opts.json ? result : { txid: result.txid }, opts)
+	} finally {
+		await destroy()
+	}
+}
+
+async function ordinalsCancel(
+	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 ordinal ${outpoint}?`,
+		})
+		if (isCancel(ok) || !ok) {
+			fatal('Cancellation cancelled.')
+		}
+	}
+
+	const privateKey = await loadKey(resolvePassword())
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		// Look up the listing from the wallet (listings are in ordinals basket with ordlock tag)
+		const ordinalsResult = await getOrdinals.execute(ctx, { limit: 10000 })
+		const listing = ordinalsResult.outputs.find((o) => o.outpoint === outpoint)
+		if (!listing) {
+			fatal(`Listing not found in wallet: ${outpoint}`)
+		}
+
+		const result = await cancelListing.execute(ctx, {
+			listing,
+			inputBEEF: ordinalsResult.BEEF as number[] | undefined,
+		})
+
+		if (result.error) {
+			fatal(result.error)
+		}
+
+		output(opts.json ? result : { txid: result.txid }, opts)
+	} finally {
+		await destroy()
+	}
+}
+
+async function ordinalsBuy(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 ordinal listing ${outpoint}?`,
+		})
+		if (isCancel(ok) || !ok) {
+			fatal('Purchase cancelled.')
+		}
+	}
+
+	const privateKey = await loadKey(resolvePassword())
+	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/social.ts

@@ -0,0 +1,56 @@
+/**
+ * Social commands - post.
+ *
+ * On-chain social protocol (BSocial) actions.
+ */
+
+import { createSocialPost } from '@1sat/actions'
+import type { GlobalFlags } from '../args'
+import { extractFlag } from '../args'
+import { loadContext } from '../context'
+import { printCommandHelp } from '../help'
+import { loadKey, resolvePassword } from '../keys'
+import { fatal, output } from '../output'
+
+export async function handleSocialCommand(
+	args: string[],
+	opts: GlobalFlags,
+): Promise<void> {
+	const [subcommand, ...rest] = args
+
+	switch (subcommand) {
+		case 'post':
+			return socialPost(rest, opts)
+		default:
+			printCommandHelp('social', {
+				post: 'Create an on-chain social post (--content <text> --app <name>)',
+			})
+			if (subcommand && subcommand !== 'help') {
+				process.exit(1)
+			}
+	}
+}
+
+async function socialPost(args: string[], opts: GlobalFlags): Promise<void> {
+	const content = extractFlag(args, '--content')
+	const app = extractFlag(args, '--app') ?? '1sat-cli'
+
+	if (!content) fatal('Missing --content <text>')
+
+	const privateKey = await loadKey(resolvePassword())
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		const result = await createSocialPost.execute(ctx, { app, content })
+
+		if (result.error) {
+			fatal(result.error)
+		}
+
+		output(opts.json ? result : { txid: result.txid }, opts)
+	} finally {
+		await destroy()
+	}
+}

package/src/commands/sweep.ts

@@ -0,0 +1,54 @@
+/**
+ * Sweep commands - scan, import.
+ *
+ * Sweep assets from external wallets into the BRC-100 wallet.
+ */
+
+import type { GlobalFlags } from '../args'
+import { extractFlag } from '../args'
+import { printCommandHelp } from '../help'
+import { fatal } from '../output'
+
+export async function handleSweepCommand(
+	args: string[],
+	opts: GlobalFlags,
+): Promise<void> {
+	const [subcommand, ...rest] = args
+
+	switch (subcommand) {
+		case 'scan':
+			return sweepScan(rest, opts)
+		case 'import':
+			return sweepImport(rest, opts)
+		default:
+			printCommandHelp('sweep', {
+				scan: 'Scan an address for UTXOs (--address <addr>)',
+				import: 'Import UTXOs into wallet (--wif <key>)',
+			})
+			if (subcommand && subcommand !== 'help') {
+				process.exit(1)
+			}
+	}
+}
+
+async function sweepScan(args: string[], _opts: GlobalFlags): Promise<void> {
+	const address = extractFlag(args, '--address')
+
+	if (!address) fatal('Missing --address <addr>')
+
+	// TODO: Load context via loadContext() + loadKey()
+	// TODO: Use services to scan address for UTXOs (BSV, ordinals, tokens)
+	// TODO: Display found UTXOs with type classification
+	fatal('sweep scan is not yet implemented')
+}
+
+async function sweepImport(args: string[], _opts: GlobalFlags): Promise<void> {
+	const wif = extractFlag(args, '--wif')
+
+	if (!wif) fatal('Missing --wif <private-key>')
+
+	// TODO: Load context via loadContext() + loadKey()
+	// TODO: Call sweepBsv/sweepOrdinals/sweepBsv21 actions
+	// TODO: Output sweep results: txids and amounts imported
+	fatal('sweep import is not yet implemented')
+}

package/src/commands/tokens.ts

@@ -0,0 +1,194 @@
+/**
+ * Token commands - balances, list, send, deploy, buy.
+ */
+
+import { getBsv21Balances, listTokens, sendBsv21 } from '@1sat/actions'
+import { confirm, isCancel } from '@clack/prompts'
+import type { GlobalFlags } from '../args'
+import { extractFlag } from '../args'
+import { loadContext } from '../context'
+import { printCommandHelp } from '../help'
+import { loadKey, resolvePassword } from '../keys'
+import { fatal, formatLabel, formatValue, output } from '../output'
+
+export async function handleTokensCommand(
+	args: string[],
+	opts: GlobalFlags,
+): Promise<void> {
+	const [subcommand, ...rest] = args
+
+	switch (subcommand) {
+		case 'balances':
+			return tokenBalances(rest, opts)
+		case 'list':
+			return tokenList(rest, opts)
+		case 'send':
+			return tokenSend(rest, opts)
+		case 'deploy':
+			return tokenDeploy(rest, opts)
+		case 'buy':
+			return tokenBuy(rest, opts)
+		default:
+			printCommandHelp('tokens', {
+				balances: 'Show token balances by token ID',
+				list: 'List owned token UTXOs (--token-id <id>)',
+				send: 'Transfer tokens (--token-id <id> --to <addr> --amount <n>)',
+				deploy: 'Deploy a new BSV21 token (--symbol <sym> --amount <n>)',
+				buy: 'Purchase listed tokens (--outpoint <op>)',
+			})
+			if (subcommand && subcommand !== 'help') {
+				process.exit(1)
+			}
+	}
+}
+
+async function tokenBalances(
+	_args: string[],
+	opts: GlobalFlags,
+): Promise<void> {
+	const privateKey = await loadKey(resolvePassword())
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		const balances = await getBsv21Balances.execute(ctx, {})
+
+		if (opts.json) {
+			output(balances, opts)
+			return
+		}
+
+		if (balances.length === 0) {
+			output('No token balances found.', opts)
+			return
+		}
+
+		for (const b of balances) {
+			const symbol = b.sym ?? b.id.slice(0, 12)
+			console.log(
+				`  ${formatValue(symbol)}  ${formatLabel('amount:')} ${formatValue(b.amt)}  ${formatLabel('id:')} ${b.id}  ${formatLabel('dec:')} ${b.dec}`,
+			)
+		}
+	} finally {
+		await destroy()
+	}
+}
+
+async function tokenList(args: string[], opts: GlobalFlags): Promise<void> {
+	const tokenId = extractFlag(args, '--token-id')
+
+	const privateKey = await loadKey(resolvePassword())
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		const outputs = await listTokens.execute(ctx, { limit: 10000 })
+
+		const filtered = tokenId
+			? outputs.filter((o) => {
+					const idTag = o.tags?.find((t) => t.startsWith('id:'))
+					return idTag && idTag.slice(3) === tokenId
+				})
+			: outputs
+
+		if (opts.json) {
+			output(filtered, opts)
+			return
+		}
+
+		if (filtered.length === 0) {
+			output(
+				tokenId
+					? `No token UTXOs found for token ${tokenId}.`
+					: 'No token UTXOs found.',
+				opts,
+			)
+			return
+		}
+
+		for (const o of filtered) {
+			const idTag =
+				o.tags?.find((t) => t.startsWith('id:'))?.slice(3) ?? 'unknown'
+			const amtTag = o.tags?.find((t) => t.startsWith('amt:'))?.slice(4) ?? '0'
+			const symTag = o.tags?.find((t) => t.startsWith('sym:'))?.slice(4) ?? ''
+
+			console.log(
+				`  ${formatValue(o.outpoint)}  ${formatLabel(symTag || idTag.slice(0, 12))}  ${formatLabel('amt:')} ${formatValue(amtTag)}`,
+			)
+		}
+
+		console.log(`\n  ${filtered.length} token UTXO(s) found.`)
+	} finally {
+		await destroy()
+	}
+}
+
+async function tokenSend(args: string[], opts: GlobalFlags): Promise<void> {
+	const tokenId = extractFlag(args, '--token-id')
+	const to = extractFlag(args, '--to')
+	const amountStr = extractFlag(args, '--amount')
+
+	if (!tokenId) fatal('Missing --token-id <id>')
+	if (!to) fatal('Missing --to <address>')
+	if (!amountStr) fatal('Missing --amount <number>')
+
+	const amount = BigInt(amountStr)
+	if (amount <= 0n) {
+		fatal('--amount must be a positive number')
+	}
+
+	if (!opts.yes) {
+		const ok = await confirm({
+			message: `Send ${amountStr} tokens (${tokenId.slice(0, 12)}...) to ${to}?`,
+		})
+		if (isCancel(ok) || !ok) {
+			fatal('Token send cancelled.')
+		}
+	}
+
+	const privateKey = await loadKey(resolvePassword())
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		const result = await sendBsv21.execute(ctx, {
+			tokenId,
+			amount: amountStr,
+			address: to,
+		})
+
+		if (result.error) {
+			fatal(result.error)
+		}
+
+		output(opts.json ? result : { txid: result.txid }, opts)
+	} finally {
+		await destroy()
+	}
+}
+
+async function tokenDeploy(args: string[], _opts: GlobalFlags): Promise<void> {
+	const symbol = extractFlag(args, '--symbol')
+	const amountStr = extractFlag(args, '--amount')
+	const _icon = extractFlag(args, '--icon')
+
+	if (!symbol) fatal('Missing --symbol <sym>')
+	if (!amountStr) fatal('Missing --amount <initial-supply>')
+
+	// TODO: Call deployToken action
+	// TODO: Output txid and token origin
+	fatal('tokens deploy is not yet implemented')
+}
+
+async function tokenBuy(args: string[], _opts: GlobalFlags): Promise<void> {
+	const outpoint = extractFlag(args, '--outpoint')
+
+	if (!outpoint) fatal('Missing --outpoint <txid.vout>')
+
+	// TODO: Call purchaseTokenListing action
+	// TODO: Output txid
+	fatal('tokens buy is not yet implemented')
+}