@1sat/cli 0.0.1 → 0.0.3

package/package.json

@@ -1,13 +1,13 @@
 {
 	"name": "@1sat/cli",
-	"version": "0.0.1",
+	"version": "0.0.3",
 	"description": "CLI for 1Sat Ordinals SDK",
 	"type": "module",
 	"main": "./src/cli.ts",
 	"bin": {
 		"1sat": "./src/cli.ts"
 	},
-	"files": ["src", "bin"],
+	"files": ["src"],
 	"scripts": {
 		"build": "bun build ./src/cli.ts --compile --outfile=bin/1sat --external pg --external pg-native --external pg-query-stream --external tedious --external oracledb --external mysql",
 		"dev": "bun run src/cli.ts",

package/src/commands/identity.ts

@@ -83,7 +83,7 @@ async function identityInfo(
 		if (opts.json) {
 			output({ identityKey: publicKey }, opts)
 		} else {
-			printKeyValue('Identity Key', publicKey)
+			printKeyValue({ 'Identity Key': publicKey })
 		}
 	} finally {
 		await destroy()

package/src/commands/opns.ts

@@ -4,10 +4,18 @@
  * Manage OpNS name identity bindings.
  */
 
+import {
+	getOpnsNames,
+	opnsDeregister as opnsDeregisterAction,
+	opnsRegister as opnsRegisterAction,
+} 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 { fatal } from '../output'
+import { loadKey, resolvePassword } from '../keys'
+import { fatal, formatLabel, formatValue, output } from '../output'
 
 export async function handleOpnsCommand(
 	args: string[],
@@ -26,7 +34,7 @@ export async function handleOpnsCommand(
 			printCommandHelp('opns', {
 				register: 'Register identity on an OpNS name (--outpoint <op>)',
 				deregister: 'Deregister identity from an OpNS name (--outpoint <op>)',
-				lookup: 'Look up an OpNS name (--name <name>)',
+				lookup: 'List OpNS names from wallet',
 			})
 			if (subcommand && subcommand !== 'help') {
 				process.exit(1)
@@ -34,40 +42,124 @@ export async function handleOpnsCommand(
 	}
 }
 
-async function opnsRegister(args: string[], _opts: GlobalFlags): Promise<void> {
+async function opnsRegister(args: string[], opts: GlobalFlags): Promise<void> {
 	const outpoint = extractFlag(args, '--outpoint')
 
 	if (!outpoint) fatal('Missing --outpoint <txid.vout>')
 
-	// TODO: Load context via loadContext() + loadKey()
-	// TODO: Look up OpNS ordinal from wallet by outpoint
-	// TODO: Call opnsRegister.execute(ctx, { ordinal })
-	// TODO: Output txid
-	fatal('opns register is not yet implemented')
+	if (!opts.yes) {
+		const ok = await confirm({
+			message: `Register identity on OpNS name ${outpoint}?`,
+		})
+		if (isCancel(ok) || !ok) {
+			fatal('Registration cancelled.')
+		}
+	}
+
+	const privateKey = await loadKey(resolvePassword())
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		// Look up the OpNS ordinal from the wallet
+		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 result = await opnsRegisterAction.execute(ctx, {
+			ordinal,
+			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 opnsDeregister(
 	args: string[],
-	_opts: GlobalFlags,
+	opts: GlobalFlags,
 ): Promise<void> {
 	const outpoint = extractFlag(args, '--outpoint')
 
 	if (!outpoint) fatal('Missing --outpoint <txid.vout>')
 
-	// TODO: Load context via loadContext() + loadKey()
-	// TODO: Look up OpNS ordinal from wallet by outpoint
-	// TODO: Call opnsDeregister.execute(ctx, { ordinal })
-	// TODO: Output txid
-	fatal('opns deregister is not yet implemented')
+	if (!opts.yes) {
+		const ok = await confirm({
+			message: `Deregister identity from OpNS name ${outpoint}?`,
+		})
+		if (isCancel(ok) || !ok) {
+			fatal('Deregistration cancelled.')
+		}
+	}
+
+	const privateKey = await loadKey(resolvePassword())
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		// Look up the OpNS ordinal from the wallet
+		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 result = await opnsDeregisterAction.execute(ctx, {
+			ordinal,
+			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 opnsLookup(args: string[], _opts: GlobalFlags): Promise<void> {
-	const name = extractFlag(args, '--name')
+async function opnsLookup(_args: string[], opts: GlobalFlags): Promise<void> {
+	const privateKey = await loadKey(resolvePassword())
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
 
-	if (!name) fatal('Missing --name <name>')
+	try {
+		const result = await getOpnsNames.execute(ctx, { limit: 100 })
 
-	// TODO: Load context via loadContext() + loadKey()
-	// TODO: Use services.ordfs to look up OpNS name resolution
-	// TODO: Output resolved identity info
-	fatal('opns lookup is not yet implemented')
+		if (opts.json) {
+			output(result.outputs, opts)
+			return
+		}
+
+		if (result.outputs.length === 0) {
+			output('No OpNS names found.', opts)
+			return
+		}
+
+		for (const o of result.outputs) {
+			const nameTag = o.tags?.find((t) => t.startsWith('name:'))?.slice(5) ?? ''
+			const publishedTag = o.tags?.find((t) => t === 'opns:published')
+			const status = publishedTag ? 'registered' : 'unregistered'
+
+			console.log(
+				`  ${formatValue(o.outpoint)}  ${nameTag ? formatValue(nameTag) : ''}  ${formatLabel(status)}`,
+			)
+		}
+
+		console.log(`\n  ${result.outputs.length} OpNS name(s) found.`)
+	} finally {
+		await destroy()
+	}
 }

package/src/commands/sweep.ts

@@ -4,10 +4,21 @@
  * Sweep assets from external wallets into the BRC-100 wallet.
  */
 
+import {
+	prepareSweepInputs,
+	scanAddressUtxos,
+	sweepBsv,
+	sweepBsv21,
+	sweepOrdinals,
+} from '@1sat/actions'
+import { PrivateKey } from '@bsv/sdk'
+import { confirm, isCancel } from '@clack/prompts'
 import type { GlobalFlags } from '../args'
 import { extractFlag } from '../args'
+import { loadContext } from '../context'
 import { printCommandHelp } from '../help'
-import { fatal } from '../output'
+import { loadKey, resolvePassword } from '../keys'
+import { fatal, formatLabel, formatValue, output } from '../output'
 
 export async function handleSweepCommand(
 	args: string[],
@@ -22,7 +33,7 @@ export async function handleSweepCommand(
 			return sweepImport(rest, opts)
 		default:
 			printCommandHelp('sweep', {
-				scan: 'Scan an address for UTXOs (--address <addr>)',
+				scan: 'Scan an address for UTXOs (--wif <key>)',
 				import: 'Import UTXOs into wallet (--wif <key>)',
 			})
 			if (subcommand && subcommand !== 'help') {
@@ -31,24 +42,180 @@ export async function handleSweepCommand(
 	}
 }
 
-async function sweepScan(args: string[], _opts: GlobalFlags): Promise<void> {
-	const address = extractFlag(args, '--address')
+async function sweepScan(args: string[], opts: GlobalFlags): Promise<void> {
+	const wif = extractFlag(args, '--wif')
+
+	if (!wif) fatal('Missing --wif <private-key>')
+
+	let address: string
+	try {
+		const pk = PrivateKey.fromWif(wif)
+		address = pk.toPublicKey().toAddress()
+	} catch {
+		fatal('Invalid WIF private key')
+	}
+
+	const privateKey = await loadKey(resolvePassword())
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
 
-	if (!address) fatal('Missing --address <addr>')
+	try {
+		if (!ctx.services) {
+			fatal('Services required for sweep scan')
+		}
+
+		const result = await scanAddressUtxos(ctx.services, address)
+
+		if (opts.json) {
+			output(result, opts)
+			return
+		}
+
+		console.log(`\n  Scan results for ${formatValue(address)}:\n`)
+
+		console.log(`  ${formatLabel('Funding UTXOs:')} ${result.funding.length}`)
+		if (result.funding.length > 0) {
+			console.log(`  ${formatLabel('Total funding:')} ${formatValue(result.totalFundingSats)} satoshis`)
+			for (const f of result.funding) {
+				console.log(`    ${formatValue(f.outpoint)}  ${formatLabel(`${f.satoshis} sats`)}`)
+			}
+		}
 
-	// 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')
+		console.log(`\n  ${formatLabel('Ordinal UTXOs:')} ${result.ordinals.length}`)
+		if (result.ordinals.length > 0) {
+			for (const o of result.ordinals) {
+				console.log(`    ${formatValue(o.outpoint)}`)
+			}
+		}
+
+		console.log(`\n  ${formatLabel('BSV-21 Tokens:')} ${result.bsv21Tokens.length}`)
+		if (result.bsv21Tokens.length > 0) {
+			for (const t of result.bsv21Tokens) {
+				console.log(
+					`    ${formatValue(t.symbol ?? t.tokenId.slice(0, 12))}  ${formatLabel('amount:')} ${formatValue(t.totalAmount)}  ${formatLabel('UTXOs:')} ${t.inputs.length}  ${formatLabel('dec:')} ${t.decimals}`,
+				)
+			}
+		}
+
+		const total = result.funding.length + result.ordinals.length + result.bsv21Tokens.reduce((n, t) => n + t.inputs.length, 0)
+		console.log(`\n  ${total} total UTXO(s) found.`)
+	} finally {
+		await destroy()
+	}
 }
 
-async function sweepImport(args: string[], _opts: GlobalFlags): Promise<void> {
+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')
+	let address: string
+	try {
+		const pk = PrivateKey.fromWif(wif)
+		address = pk.toPublicKey().toAddress()
+	} catch {
+		fatal('Invalid WIF private key')
+	}
+
+	const privateKey = await loadKey(resolvePassword())
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		if (!ctx.services) {
+			fatal('Services required for sweep import')
+		}
+
+		// Scan first to discover what's available
+		const scan = await scanAddressUtxos(ctx.services, address)
+
+		const hasFunding = scan.funding.length > 0
+		const hasOrdinals = scan.ordinals.length > 0
+		const hasTokens = scan.bsv21Tokens.length > 0
+
+		if (!hasFunding && !hasOrdinals && !hasTokens) {
+			fatal(`No UTXOs found at ${address}`)
+		}
+
+		// Summarize what will be swept
+		const parts: string[] = []
+		if (hasFunding) parts.push(`${scan.totalFundingSats} sats (${scan.funding.length} UTXOs)`)
+		if (hasOrdinals) parts.push(`${scan.ordinals.length} ordinal(s)`)
+		if (hasTokens) {
+			for (const t of scan.bsv21Tokens) {
+				parts.push(`${t.totalAmount} ${t.symbol ?? t.tokenId.slice(0, 12)} token(s)`)
+			}
+		}
+
+		if (!opts.yes) {
+			const ok = await confirm({
+				message: `Sweep ${parts.join(', ')} from ${address}?`,
+			})
+			if (isCancel(ok) || !ok) {
+				fatal('Sweep cancelled.')
+			}
+		}
+
+		const txids: string[] = []
+
+		// Convert SweepInput to IndexedOutput shape for prepareSweepInputs
+		const toIndexed = (items: Array<{ outpoint: string; satoshis: number }>) =>
+			items.map((item) => ({
+				outpoint: item.outpoint,
+				satoshis: item.satoshis,
+				score: 0,
+			}))
+
+		// Sweep BSV funding UTXOs
+		if (hasFunding) {
+			const inputs = await prepareSweepInputs(ctx, toIndexed(scan.funding))
+
+			const result = await sweepBsv.execute(ctx, { inputs, wif })
+			if (result.error) {
+				fatal(`BSV sweep failed: ${result.error}`)
+			}
+			if (result.txid) txids.push(result.txid)
+		}
+
+		// Sweep ordinals
+		if (hasOrdinals) {
+			const inputs = await prepareSweepInputs(ctx, toIndexed(scan.ordinals))
+
+			const result = await sweepOrdinals.execute(ctx, { inputs, wif })
+			if (result.error) {
+				fatal(`Ordinals sweep failed: ${result.error}`)
+			}
+			if (result.txid) txids.push(result.txid)
+		}
+
+		// Sweep BSV-21 tokens (one sweep per tokenId)
+		if (hasTokens) {
+			for (const tokenGroup of scan.bsv21Tokens) {
+				const inputs = await prepareSweepInputs(ctx, toIndexed(tokenGroup.inputs))
+
+				const sweepInputs = inputs.map((inp, idx) => ({
+					...inp,
+					tokenId: tokenGroup.inputs[idx].tokenId,
+					amount: tokenGroup.inputs[idx].amount,
+				}))
+
+				const result = await sweepBsv21.execute(ctx, { inputs: sweepInputs, wif })
+				if (result.error) {
+					fatal(`Token sweep failed (${tokenGroup.symbol ?? tokenGroup.tokenId.slice(0, 12)}): ${result.error}`)
+				}
+				if (result.txid) txids.push(result.txid)
+			}
+		}
+
+		output(
+			opts.json
+				? { txids, swept: parts }
+				: `Sweep complete. ${txids.length} transaction(s): ${txids.join(', ')}`,
+			opts,
+		)
+	} finally {
+		await destroy()
+	}
 }

package/src/commands/tokens.ts

@@ -2,7 +2,12 @@
  * Token commands - balances, list, send, deploy, buy.
  */
 
-import { getBsv21Balances, listTokens, sendBsv21 } from '@1sat/actions'
+import {
+	getBsv21Balances,
+	listTokens,
+	purchaseBsv21,
+	sendBsv21,
+} from '@1sat/actions'
 import { confirm, isCancel } from '@clack/prompts'
 import type { GlobalFlags } from '../args'
 import { extractFlag } from '../args'
@@ -33,8 +38,8 @@ export async function handleTokensCommand(
 				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>)',
+				deploy: 'Deploy a new BSV21 token (not yet available)',
+				buy: 'Purchase listed tokens (--outpoint <op> --token-id <id> --amount <n>)',
 			})
 			if (subcommand && subcommand !== 'help') {
 				process.exit(1)
@@ -170,25 +175,46 @@ async function tokenSend(args: string[], opts: GlobalFlags): Promise<void> {
 	}
 }
 
-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 tokenDeploy(_args: string[], _opts: GlobalFlags): Promise<void> {
+	fatal('tokens deploy is not yet available. No deploy action exists in the actions package.')
 }
 
-async function tokenBuy(args: string[], _opts: GlobalFlags): Promise<void> {
+async function tokenBuy(args: string[], opts: GlobalFlags): Promise<void> {
 	const outpoint = extractFlag(args, '--outpoint')
+	const tokenId = extractFlag(args, '--token-id')
+	const amountStr = extractFlag(args, '--amount')
 
 	if (!outpoint) fatal('Missing --outpoint <txid.vout>')
+	if (!tokenId) fatal('Missing --token-id <id>')
+	if (!amountStr) fatal('Missing --amount <token-amount>')
+
+	if (!opts.yes) {
+		const ok = await confirm({
+			message: `Purchase ${amountStr} tokens (${tokenId.slice(0, 12)}...) from listing ${outpoint}?`,
+		})
+		if (isCancel(ok) || !ok) {
+			fatal('Purchase cancelled.')
+		}
+	}
 
-	// TODO: Call purchaseTokenListing action
-	// TODO: Output txid
-	fatal('tokens buy is not yet implemented')
+	const privateKey = await loadKey(resolvePassword())
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		const result = await purchaseBsv21.execute(ctx, {
+			tokenId,
+			outpoint,
+			amount: amountStr,
+		})
+
+		if (result.error) {
+			fatal(result.error)
+		}
+
+		output(opts.json ? result : { txid: result.txid }, opts)
+	} finally {
+		await destroy()
+	}
 }

package/src/help.ts

@@ -2,18 +2,24 @@
  * Help text and version display for the 1sat CLI.
  */
 
-import { readFileSync } from 'node:fs'
 import chalk from 'chalk'
 
-export function getVersion(): string {
+// Version is read at build time via Bun's import. Works in both source and compiled binary.
+const VERSION = (() => {
 	try {
+		// biome-ignore lint/style/noVar: dynamic require for Bun compiled binary compat
+		const { readFileSync } = require('node:fs')
 		const pkg = JSON.parse(
 			readFileSync(new URL('../package.json', import.meta.url), 'utf8'),
 		)
-		return pkg.version || 'unknown'
+		return pkg.version || '0.0.1'
 	} catch {
-		return 'unknown'
+		return '0.0.1'
 	}
+})()
+
+export function getVersion(): string {
+	return VERSION
 }
 
 export function printVersion(): void {

package/src/output.ts

@@ -51,7 +51,23 @@ export function output(
 
 	if (typeof data === 'object' && data !== null) {
 		for (const [key, value] of Object.entries(data)) {
-			console.log(`${formatLabel(`${key}:`)} ${formatValue(String(value))}`)
+			if (Array.isArray(value)) {
+				console.log(`${formatLabel(`${key}:`)}`)
+				for (const item of value) {
+					if (typeof item === 'object' && item !== null) {
+						const parts = Object.entries(item)
+							.map(([k, v]) => `${k}=${v}`)
+							.join(' ')
+						console.log(`  ${formatValue(parts)}`)
+					} else {
+						console.log(`  ${formatValue(String(item))}`)
+					}
+				}
+			} else if (typeof value === 'object' && value !== null) {
+				console.log(`${formatLabel(`${key}:`)} ${JSON.stringify(value)}`)
+			} else {
+				console.log(`${formatLabel(`${key}:`)} ${formatValue(String(value))}`)
+			}
 		}
 		return
 	}