@1sat/cli 0.0.1

package/src/commands/init.ts

@@ -0,0 +1,172 @@
+/**
+ * Interactive wallet setup wizard.
+ *
+ * Guides the user through:
+ * 1. Network selection (mainnet/testnet)
+ * 2. Key generation or import
+ * 3. Password-protected key encryption
+ * 4. Config file creation
+ */
+
+import { PrivateKey } from '@bsv/sdk'
+import {
+	cancel,
+	confirm,
+	intro,
+	isCancel,
+	outro,
+	password,
+	select,
+	text,
+} from '@clack/prompts'
+import type { GlobalFlags } from '../args'
+import { ensureConfigDir, loadConfig, saveConfig } from '../config'
+import { hasKey, saveKey } from '../keys'
+import { fatal, formatSuccess, formatValue, formatWarning } from '../output'
+
+export async function handleInitCommand(
+	_args: string[],
+	opts: GlobalFlags,
+): Promise<void> {
+	if (opts.json) {
+		fatal('init command requires interactive mode (remove --json)')
+	}
+
+	intro('1sat wallet setup')
+
+	// Warn if key already exists
+	if (hasKey()) {
+		const overwrite = await confirm({
+			message: 'A wallet key already exists. Overwrite it?',
+		})
+		if (isCancel(overwrite) || !overwrite) {
+			cancel('Setup cancelled.')
+			process.exit(0)
+		}
+	}
+
+	// 1. Network selection
+	const chain = await select({
+		message: 'Select network:',
+		options: [
+			{ value: 'main', label: 'Mainnet', hint: 'real BSV' },
+			{ value: 'test', label: 'Testnet', hint: 'test BSV' },
+		],
+	})
+	if (isCancel(chain)) {
+		cancel('Setup cancelled.')
+		process.exit(0)
+	}
+
+	// 2. Key source
+	const keySource = await select({
+		message: 'How would you like to set up your key?',
+		options: [
+			{
+				value: 'generate',
+				label: 'Generate new key',
+				hint: 'creates a new random private key',
+			},
+			{
+				value: 'import',
+				label: 'Import existing key',
+				hint: 'enter a WIF-encoded private key',
+			},
+		],
+	})
+	if (isCancel(keySource)) {
+		cancel('Setup cancelled.')
+		process.exit(0)
+	}
+
+	let wif: string
+
+	if (keySource === 'generate') {
+		const pk = PrivateKey.fromRandom()
+		wif = pk.toWif()
+		const address = pk.toPublicKey().toAddress()
+
+		console.log()
+		console.log(formatWarning('  IMPORTANT: Back up your private key!'))
+		console.log(formatWarning('  If you lose it, your funds are gone forever.'))
+		console.log()
+		console.log(`  ${formatValue('WIF:')}    ${wif}`)
+		console.log(`  ${formatValue('Address:')} ${address}`)
+		console.log()
+
+		const confirmed = await confirm({
+			message: 'Have you saved your private key somewhere safe?',
+		})
+		if (isCancel(confirmed) || !confirmed) {
+			cancel('Setup cancelled. Please save your key and try again.')
+			process.exit(0)
+		}
+	} else {
+		const wifInput = await text({
+			message: 'Enter your WIF-encoded private key:',
+			validate(value) {
+				try {
+					PrivateKey.fromWif(value)
+				} catch {
+					return 'Invalid WIF key. Keys start with 5, K, L (mainnet) or c (testnet).'
+				}
+			},
+		})
+		if (isCancel(wifInput)) {
+			cancel('Setup cancelled.')
+			process.exit(0)
+		}
+		wif = wifInput as string
+	}
+
+	// 3. Password for encryption
+	const pw = await password({
+		message: 'Set a password to encrypt your key:',
+		validate(value) {
+			if (value.length < 8) return 'Password must be at least 8 characters.'
+		},
+	})
+	if (isCancel(pw)) {
+		cancel('Setup cancelled.')
+		process.exit(0)
+	}
+
+	const pwConfirm = await password({
+		message: 'Confirm password:',
+	})
+	if (isCancel(pwConfirm)) {
+		cancel('Setup cancelled.')
+		process.exit(0)
+	}
+
+	if (pw !== pwConfirm) {
+		fatal('Passwords do not match.')
+	}
+
+	// 4. Optional: storage identity key
+	const storageId = await text({
+		message: 'Storage identity key (for wallet persistence):',
+		defaultValue: '1sat-cli-default',
+		placeholder: '1sat-cli-default',
+	})
+	if (isCancel(storageId)) {
+		cancel('Setup cancelled.')
+		process.exit(0)
+	}
+
+	// 5. Save everything
+	ensureConfigDir()
+
+	await saveKey(wif, pw as string)
+
+	saveConfig({
+		...loadConfig(),
+		chain: chain as 'main' | 'test',
+		storageIdentityKey: storageId as string,
+	})
+
+	const pk = PrivateKey.fromWif(wif)
+	const address = pk.toPublicKey().toAddress()
+
+	outro(formatSuccess(`Wallet configured! Address: ${address}`))
+}

package/src/commands/locks.ts

@@ -0,0 +1,126 @@
+/**
+ * Lock commands - info, lock, unlock.
+ */
+
+import { getLockData, lockBsv, unlockBsv } 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, output, printKeyValue } from '../output'
+
+export async function handleLocksCommand(
+	args: string[],
+	opts: GlobalFlags,
+): Promise<void> {
+	const [subcommand, ...rest] = args
+
+	switch (subcommand) {
+		case 'info':
+			return locksInfo(rest, opts)
+		case 'lock':
+			return locksLock(rest, opts)
+		case 'unlock':
+			return locksUnlock(rest, opts)
+		default:
+			printCommandHelp('locks', {
+				info: 'Show lock information and maturity status',
+				lock: 'Time-lock BSV (--sats <amount> --blocks <n>)',
+				unlock: 'Unlock matured BSV locks',
+			})
+			if (subcommand && subcommand !== 'help') {
+				process.exit(1)
+			}
+	}
+}
+
+async function locksInfo(_args: string[], opts: GlobalFlags): Promise<void> {
+	const privateKey = await loadKey(resolvePassword())
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		const data = await getLockData.execute(ctx, {})
+
+		if (opts.json) {
+			output(data, opts)
+			return
+		}
+
+		printKeyValue({
+			'Total Locked (sats)': data.totalLocked,
+			'Unlockable (sats)': data.unlockable,
+			'Next Unlock Block': data.nextUnlock || 'none',
+		})
+	} finally {
+		await destroy()
+	}
+}
+
+async function locksLock(args: string[], opts: GlobalFlags): Promise<void> {
+	const satsStr = extractFlag(args, '--sats')
+	const blocksStr = extractFlag(args, '--blocks')
+
+	if (!satsStr) fatal('Missing --sats <amount>')
+	if (!blocksStr) fatal('Missing --blocks <n>')
+
+	const satoshis = Number(satsStr)
+	if (!Number.isFinite(satoshis) || satoshis <= 0) {
+		fatal('--sats must be a positive number')
+	}
+
+	const until = Number(blocksStr)
+	if (!Number.isFinite(until) || until <= 0) {
+		fatal('--blocks must be a positive block height')
+	}
+
+	if (!opts.yes) {
+		const ok = await confirm({
+			message: `Lock ${satoshis} satoshis until block ${until}?`,
+		})
+		if (isCancel(ok) || !ok) {
+			fatal('Lock cancelled.')
+		}
+	}
+
+	const privateKey = await loadKey(resolvePassword())
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		const result = await lockBsv.execute(ctx, {
+			requests: [{ satoshis, until }],
+		})
+
+		if (result.error) {
+			fatal(result.error)
+		}
+
+		output(opts.json ? result : { txid: result.txid }, opts)
+	} finally {
+		await destroy()
+	}
+}
+
+async function locksUnlock(_args: string[], opts: GlobalFlags): Promise<void> {
+	const privateKey = await loadKey(resolvePassword())
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		const result = await unlockBsv.execute(ctx, {})
+
+		if (result.error) {
+			fatal(result.error)
+		}
+
+		output(opts.json ? result : { txid: result.txid }, opts)
+	} finally {
+		await destroy()
+	}
+}

package/src/commands/opns.ts

@@ -0,0 +1,73 @@
+/**
+ * OpNS commands - register, deregister, lookup.
+ *
+ * Manage OpNS name identity bindings.
+ */
+
+import type { GlobalFlags } from '../args'
+import { extractFlag } from '../args'
+import { printCommandHelp } from '../help'
+import { fatal } from '../output'
+
+export async function handleOpnsCommand(
+	args: string[],
+	opts: GlobalFlags,
+): Promise<void> {
+	const [subcommand, ...rest] = args
+
+	switch (subcommand) {
+		case 'register':
+			return opnsRegister(rest, opts)
+		case 'deregister':
+			return opnsDeregister(rest, opts)
+		case 'lookup':
+			return opnsLookup(rest, opts)
+		default:
+			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>)',
+			})
+			if (subcommand && subcommand !== 'help') {
+				process.exit(1)
+			}
+	}
+}
+
+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')
+}
+
+async function opnsDeregister(
+	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 opnsDeregister.execute(ctx, { ordinal })
+	// TODO: Output txid
+	fatal('opns deregister is not yet implemented')
+}
+
+async function opnsLookup(args: string[], _opts: GlobalFlags): Promise<void> {
+	const name = extractFlag(args, '--name')
+
+	if (!name) fatal('Missing --name <name>')
+
+	// 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')
+}