@1sat/cli 0.0.21 → 0.0.22

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@1sat/cli",
-	"version": "0.0.21",
+	"version": "0.0.22",
 	"description": "CLI for 1Sat Ordinals SDK",
 	"type": "module",
 	"main": "./src/cli.ts",

package/src/args.ts

@@ -82,6 +82,24 @@ export function extractFlag(args: string[], flag: string): string | undefined {
 	return args[idx + 1]
 }
 
+/**
+ * Extract multiple values for a flag, supporting comma-delimited and multiple flag occurrences.
+ * Example: --tags a,b,c OR --tags a --tags b --tags c
+ */
+export function extractFlags(args: string[], flag: string): string[] {
+	const values: string[] = []
+	for (let i = 0; i < args.length - 1; i++) {
+		if (args[i] === flag) {
+			const value = args[i + 1]
+			if (value && !value.startsWith('--')) {
+				// Split comma-delimited values
+				values.push(...value.split(',').filter(v => v.length > 0))
+			}
+		}
+	}
+	return values
+}
+
 /**
  * Check if a boolean flag is present.
  */

package/src/commands/init.ts

@@ -8,6 +8,7 @@
  * 4. Config file creation
  */
 
+import { randomBytes } from 'node:crypto'
 import { PrivateKey } from '@bsv/sdk'
 import {
 	cancel,
@@ -162,16 +163,8 @@ export async function handleInitCommand(
 		// bitcoin-backup Touch ID not available — skip silently
 	}
 
-	// 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)
-	}
+	// 4. Generate random storage identity key
+	const storageId = `1sat-cli-${randomBytes(8).toString('hex')}`
 
 	// 5. Optional: remote storage configuration
 	const useRemote = await confirm({
@@ -220,7 +213,7 @@ export async function handleInitCommand(
 	saveConfig({
 		...loadConfig(),
 		chain: chain as 'main' | 'test',
-		storageIdentityKey: storageId as string,
+		storageIdentityKey: storageId,
 		activeRemote,
 	})
 

package/src/commands/remote.ts

@@ -81,6 +81,9 @@ async function remoteAdd(args: string[], opts: GlobalFlags): Promise<void> {
 		chain: opts.chain,
 	})
 
+	// Load config early — needed for storage identity key lookups
+	const config = loadConfig()
+
 	try {
 		// For backup-only, we use StorageClient via wallet-node
 		// biome-ignore lint/suspicious/noExplicitAny: StorageClient constructor not typed in wallet-toolbox
@@ -99,7 +102,6 @@ async function remoteAdd(args: string[], opts: GlobalFlags): Promise<void> {
 		await walletResult.storage.updateBackups()
 
 		// Persist to config — connectivity will be validated on next monitor run
-		const config = loadConfig()
 		const existing = config.backups ?? []
 		if (!existing.includes(url)) {
 			saveConfig({ ...config, backups: [...existing, url] })

package/src/commands/wallet.ts

@@ -1,11 +1,12 @@
 /**
  * Wallet commands - balance, address, send, send-all, info.
+ * BRC-100 interface commands - list-outputs, relinquish-output, list-actions, etc.
  */
 
 import { deriveDepositAddresses, sendAllBsv, sendBsv } from '@1sat/actions'
 import { confirm, isCancel } from '@clack/prompts'
 import type { GlobalFlags } from '../args'
-import { extractFlag } from '../args'
+import { extractFlag, extractFlags } from '../args'
 import { loadContext } from '../context'
 import { printCommandHelp } from '../help'
 import { loadKey, resolvePassword } from '../keys'
@@ -28,6 +29,22 @@ export async function handleWalletCommand(
 			return walletSendAll(rest, opts)
 		case 'info':
 			return walletInfo(rest, opts)
+		case 'list-outputs':
+			return walletListOutputs(rest, opts)
+		case 'relinquish-output':
+			return walletRelinquishOutput(rest, opts)
+		case 'list-actions':
+			return walletListActions(rest, opts)
+		case 'create-action':
+			return walletCreateAction(rest, opts)
+		case 'sign-action':
+			return walletSignAction(rest, opts)
+		case 'abort-action':
+			return walletAbortAction(rest, opts)
+		case 'list-certificates':
+			return walletListCertificates(rest, opts)
+		case 'relinquish-certificate':
+			return walletRelinquishCertificate(rest, opts)
 		default:
 			printCommandHelp('wallet', {
 				balance: 'Show wallet balance in satoshis',
@@ -35,6 +52,14 @@ export async function handleWalletCommand(
 				send: 'Send BSV to an address (--to <addr> --sats <amount>)',
 				'send-all': 'Send all BSV to an address (--to <addr>)',
 				info: 'Show wallet info (address, balance, network)',
+				'list-outputs': 'List wallet outputs (--basket <name> [--tags <t1,t2>] [--limit N])',
+				'relinquish-output': 'Remove output from basket (--basket <name> --output <txid.vout>)',
+				'list-actions': 'List wallet actions [--labels <l1,l2>] [--limit N]',
+				'create-action': 'Create action (JSON args)',
+				'sign-action': 'Sign action (JSON args)',
+				'abort-action': 'Abort action (--reference <ref>)',
+				'list-certificates': 'List certificates',
+				'relinquish-certificate': 'Relinquish certificate (--type <t> --serialNumber <s> --certifier <c>)',
 			})
 			if (subcommand && subcommand !== 'help') {
 				process.exit(1)
@@ -216,3 +241,258 @@ async function walletInfo(_args: string[], opts: GlobalFlags): Promise<void> {
 		await destroy()
 	}
 }
+
+// BRC-100 Interface Commands
+
+async function walletListOutputs(args: string[], opts: GlobalFlags): Promise<void> {
+	const basket = extractFlag(args, '--basket')
+	if (!basket) fatal('Missing required --basket <name>')
+
+	const tags = extractFlags(args, '--tags')
+	const limitStr = extractFlag(args, '--limit')
+	const limit = limitStr ? parseInt(limitStr, 10) : 10
+	if (!Number.isFinite(limit) || limit < 1 || limit > 10000) {
+		fatal('--limit must be between 1 and 10000')
+	}
+
+	const privateKey = await loadKey(resolvePassword())
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		const listArgs: Parameters<typeof ctx.wallet.listOutputs>[0] = {
+			basket,
+			limit,
+		}
+		if (tags.length > 0) {
+			listArgs.tags = tags
+		}
+
+		const result = await ctx.wallet.listOutputs(listArgs)
+
+		if (opts.json) {
+			output(result, opts)
+		} else {
+			console.log(`\n${result.totalOutputs} total outputs in basket '${basket}':\n`)
+			for (const out of result.outputs) {
+				const tags = out.tags?.join(', ') || 'none'
+				console.log(`  ${out.outpoint} | ${out.satoshis} sats | tags: ${tags}`)
+			}
+			console.log()
+		}
+	} finally {
+		await destroy()
+	}
+}
+
+async function walletRelinquishOutput(
+	args: string[],
+	opts: GlobalFlags,
+): Promise<void> {
+	const basket = extractFlag(args, '--basket')
+	const outpoint = extractFlag(args, '--output')
+
+	if (!basket) fatal('Missing required --basket <name>')
+	if (!outpoint) fatal('Missing required --output <txid.vout>')
+
+	// Validate output format (txid.vout)
+	if (!outpoint.includes('.') || outpoint.split('.').length !== 2) {
+		fatal('Invalid --output format. Expected: txid.vout (e.g., abc123...0)')
+	}
+
+	const privateKey = await loadKey(resolvePassword())
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		const result = await ctx.wallet.relinquishOutput({ basket, output: outpoint })
+
+		if (opts.json) {
+			output(result, opts)
+		} else {
+			output({ relinquished: true, basket, output: outpoint }, opts)
+		}
+	} finally {
+		await destroy()
+	}
+}
+
+async function walletListActions(args: string[], opts: GlobalFlags): Promise<void> {
+	const labels = extractFlags(args, '--labels')
+	const limitStr = extractFlag(args, '--limit')
+	const limit = limitStr ? parseInt(limitStr, 10) : 10
+	if (!Number.isFinite(limit) || limit < 1 || limit > 10000) {
+		fatal('--limit must be between 1 and 10000')
+	}
+
+	const privateKey = await loadKey(resolvePassword())
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		const listArgs: Parameters<typeof ctx.wallet.listActions>[0] = {
+			labels: labels.length > 0 ? labels : ['*'], // Default to all labels if none specified
+			limit,
+		}
+
+		const result = await ctx.wallet.listActions(listArgs)
+
+		if (opts.json) {
+			output(result, opts)
+		} else {
+			console.log(`\n${result.totalActions} total actions:\n`)
+			for (const action of result.actions) {
+				console.log(`  ${action.txid || 'pending'} | status: ${action.status}`)
+			}
+			console.log()
+		}
+	} finally {
+		await destroy()
+	}
+}
+
+async function walletCreateAction(args: string[], opts: GlobalFlags): Promise<void> {
+	const jsonInput = args[0]
+
+	if (!jsonInput) fatal('Missing JSON arguments. Usage: wallet create-action \'{...}\'')
+
+	let actionArgs: Parameters<typeof ctx.wallet.createAction>[0]
+	try {
+		actionArgs = JSON.parse(jsonInput)
+	} catch {
+		fatal(`Invalid JSON: ${jsonInput}`)
+	}
+
+	const privateKey = await loadKey(resolvePassword())
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		const result = await ctx.wallet.createAction(actionArgs)
+		output(result, opts)
+	} finally {
+		await destroy()
+	}
+}
+
+async function walletSignAction(args: string[], opts: GlobalFlags): Promise<void> {
+	const jsonInput = args[0]
+
+	if (!jsonInput) fatal('Missing JSON arguments. Usage: wallet sign-action \'{...}\'') 
+
+	let signArgs: Parameters<typeof ctx.wallet.signAction>[0]
+	try {
+		signArgs = JSON.parse(jsonInput)
+	} catch {
+		fatal(`Invalid JSON: ${jsonInput}`)
+	}
+
+	const privateKey = await loadKey(resolvePassword())
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		const result = await ctx.wallet.signAction(signArgs)
+		output(result, opts)
+	} finally {
+		await destroy()
+	}
+}
+
+async function walletAbortAction(args: string[], opts: GlobalFlags): Promise<void> {
+	const reference = extractFlag(args, '--reference')
+
+	if (!reference) fatal('Missing required --reference <ref>')
+
+	const privateKey = await loadKey(resolvePassword())
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		const result = await ctx.wallet.abortAction({ reference })
+		output(result, opts)
+	} finally {
+		await destroy()
+	}
+}
+
+async function walletListCertificates(
+	args: string[],
+	opts: GlobalFlags,
+): Promise<void> {
+	const certifiers = extractFlags(args, '--certifiers')
+	const types = extractFlags(args, '--types')
+	const limitStr = extractFlag(args, '--limit')
+	const limit = limitStr ? parseInt(limitStr, 10) : 10
+
+	if (!Number.isFinite(limit) || limit < 1 || limit > 10000) {
+		fatal('--limit must be between 1 and 10000')
+	}
+
+	const privateKey = await loadKey(resolvePassword())
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		const listArgs: Parameters<typeof ctx.wallet.listCertificates>[0] = {
+			certifiers: certifiers.length > 0 ? certifiers : [],
+			types: types.length > 0 ? types : [],
+			limit,
+		}
+
+		const result = await ctx.wallet.listCertificates(listArgs)
+
+		if (opts.json) {
+			output(result, opts)
+		} else {
+			console.log(`\n${result.totalCertificates} total certificates:\n`)
+			for (const cert of result.certificates) {
+				console.log(`  ${cert.type} | ${cert.serialNumber} | ${cert.certifier}`)
+			}
+			console.log()
+		}
+	} finally {
+		await destroy()
+	}
+}
+
+async function walletRelinquishCertificate(
+	args: string[],
+	opts: GlobalFlags,
+): Promise<void> {
+	const type = extractFlag(args, '--type')
+	const serialNumber = extractFlag(args, '--serialNumber')
+	const certifier = extractFlag(args, '--certifier')
+
+	if (!type) fatal('Missing required --type <type>')
+	if (!serialNumber) fatal('Missing required --serialNumber <serial>')
+	if (!certifier) fatal('Missing required --certifier <certifier>')
+
+	const privateKey = await loadKey(resolvePassword())
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		const result = await ctx.wallet.relinquishCertificate({
+			type,
+			serialNumber,
+			certifier,
+		})
+
+		if (opts.json) {
+			output(result, opts)
+		} else {
+			output({ relinquished: true, type, serialNumber, certifier }, opts)
+		}
+	} finally {
+		await destroy()
+	}
+}

package/src/help.ts

@@ -47,6 +47,22 @@ ${bold('Wallet:')}
   ${cyan('wallet send-all')}          Send all BSV to an address
   ${cyan('wallet info')}              Show wallet info
 
+${bold('Wallet (BRC-100 Interface):')}
+  ${cyan('wallet list-outputs')}      List outputs in basket
+                               ${dim('--basket <name> [--tags <t1,t2>] [--limit N]')}
+  ${cyan('wallet relinquish-output')} Remove output from basket
+                               ${dim('--basket <name> --output <txid.vout>')}
+  ${cyan('wallet list-actions')}      List wallet actions
+                               ${dim('[--labels <l1,l2>] [--limit N]')}
+  ${cyan('wallet create-action')}     Create raw action (JSON args)
+  ${cyan('wallet sign-action')}       Sign raw action (JSON args)
+  ${cyan('wallet abort-action')}      Abort pending action
+                               ${dim('--reference <ref>')}
+  ${cyan('wallet list-certificates')} List certificates
+                               ${dim('[--certifiers <c1,c2>] [--types <t1,t2>] [--limit N]')}
+  ${cyan('wallet relinquish-certificate')} Relinquish certificate
+                               ${dim('--type <t> --serialNumber <s> --certifier <c>')}
+
 ${bold('Ordinals:')}
   ${cyan('ordinals list')}            List owned ordinals
   ${cyan('ordinals mint')}            Mint a new ordinal inscription