@1sat/cli 0.0.51 → 0.0.53

package/src/commands/tokens.ts

@@ -3,12 +3,16 @@
  */
 
 import {
+	deployBsv21Auth,
+	deployBsv21Mint,
 	getBsv21Balances,
 	getDisplayValue,
 	listTokens,
+	mintBsv21,
 	purchaseBsv21,
 	sendBsv21,
 } from '@1sat/actions'
+import type { Destination } from '@1sat/types'
 import { confirm, isCancel } from '@clack/prompts'
 import type { GlobalFlags } from '../args'
 import { extractFlag } from '../args'
@@ -30,18 +34,16 @@ export async function handleTokensCommand(
 			return tokenList(rest, opts)
 		case 'send':
 			return tokenSend(rest, opts)
-		case 'deploy':
-			return tokenDeploy(rest, opts)
+		case 'deploy-mint':
+			return tokenDeployMint(rest, opts)
+		case 'deploy-auth':
+			return tokenDeployAuth(rest, opts)
+		case 'mint':
+			return tokenMint(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 (not yet available)',
-				buy: 'Purchase listed tokens (--outpoint <op> --token-id <id> --amount <n>)',
-			})
+			printCommandHelp('tokens', opts.json)
 			if (subcommand && subcommand !== 'help') {
 				process.exit(1)
 			}
@@ -131,23 +133,47 @@ async function tokenList(args: string[], opts: GlobalFlags): Promise<void> {
 	}
 }
 
+/**
+ * Build a {@link Destination} from CLI flags. Only the first set wins.
+ * Returns undefined when no flags are set — actions interpret that as 'self'.
+ */
+function destinationFromFlags(opts: {
+	to?: string
+	counterparty?: string
+	lockingScript?: string
+}): Destination | undefined {
+	if (opts.lockingScript) return { lockingScript: opts.lockingScript }
+	if (opts.counterparty) return { counterparty: opts.counterparty }
+	if (opts.to) return { address: opts.to }
+	return undefined
+}
+
 async function tokenSend(args: string[], opts: GlobalFlags): Promise<void> {
 	const tokenId = extractFlag(args, '--token-id')
 	const to = extractFlag(args, '--to')
+	const counterparty = extractFlag(args, '--counterparty')
+	const lockingScript = extractFlag(args, '--locking-script')
 	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 destination = destinationFromFlags({ to, counterparty, lockingScript })
+	if (!destination) {
+		fatal(
+			'Missing destination — provide one of: --to <address>, --counterparty <pubkey>, --locking-script <hex>',
+		)
+	}
+
 	const amount = BigInt(amountStr)
 	if (amount <= 0n) {
 		fatal('--amount must be a positive number')
 	}
 
 	if (!opts.yes) {
+		const dest = to ?? counterparty ?? lockingScript ?? ''
 		const ok = await confirm({
-			message: `Send ${amountStr} tokens (${tokenId.slice(0, 12)}...) to ${to}?`,
+			message: `Send ${amountStr} tokens (${tokenId.slice(0, 12)}...) to ${dest.slice(0, 32)}?`,
 		})
 		if (isCancel(ok) || !ok) {
 			fatal('Token send cancelled.')
@@ -162,7 +188,9 @@ async function tokenSend(args: string[], opts: GlobalFlags): Promise<void> {
 	try {
 		const result = await sendBsv21.execute(ctx, {
 			tokenId,
-			recipients: [{ amount: amountStr, address: to }],
+			recipients: [
+				{ amount: amountStr, destination: destination as Destination },
+			],
 		})
 
 		if (result.error) {
@@ -175,10 +203,214 @@ async function tokenSend(args: string[], opts: GlobalFlags): Promise<void> {
 	}
 }
 
-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 tokenDeployMint(
+	args: string[],
+	opts: GlobalFlags,
+): Promise<void> {
+	const symbol = extractFlag(args, '--symbol')
+	const amountStr = extractFlag(args, '--amount')
+	const decimalsStr = extractFlag(args, '--decimals')
+	const icon = extractFlag(args, '--icon')
+	const to = extractFlag(args, '--to')
+	const counterparty = extractFlag(args, '--counterparty')
+	const lockingScript = extractFlag(args, '--locking-script')
+
+	if (!symbol) fatal('Missing --symbol <ticker>')
+	if (!amountStr) fatal('Missing --amount <total-supply>')
+
+	const amount = BigInt(amountStr)
+	if (amount <= 0n) fatal('--amount must be a positive number')
+
+	const decimals = decimalsStr ? Number.parseInt(decimalsStr, 10) : 0
+	if (Number.isNaN(decimals) || decimals < 0 || decimals > 18) {
+		fatal('--decimals must be an integer between 0 and 18')
+	}
+
+	if (!opts.yes) {
+		const ok = await confirm({
+			message: `Deploy ${symbol} with fixed supply ${amountStr} (decimals=${decimals})?`,
+		})
+		if (isCancel(ok) || !ok) {
+			fatal('Deploy cancelled.')
+		}
+	}
+
+	const privateKey = await loadKey()
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		const result = await deployBsv21Mint.execute(ctx, {
+			symbol,
+			amount: amountStr,
+			decimals,
+			icon,
+			destination: destinationFromFlags({ to, counterparty, lockingScript }),
+		})
+
+		if (result.error) {
+			fatal(result.error)
+		}
+
+		output(
+			opts.json ? result : { txid: result.txid, tokenId: result.tokenId },
+			opts,
+		)
+	} finally {
+		await destroy()
+	}
+}
+
+async function tokenDeployAuth(
+	args: string[],
+	opts: GlobalFlags,
+): Promise<void> {
+	const symbol = extractFlag(args, '--symbol')
+	const decimalsStr = extractFlag(args, '--decimals')
+	const icon = extractFlag(args, '--icon')
+	const to = extractFlag(args, '--to')
+	const counterparty = extractFlag(args, '--counterparty')
+	const lockingScript = extractFlag(args, '--locking-script')
+
+	if (!symbol) fatal('Missing --symbol <ticker>')
+
+	const decimals = decimalsStr ? Number.parseInt(decimalsStr, 10) : 0
+	if (Number.isNaN(decimals) || decimals < 0 || decimals > 18) {
+		fatal('--decimals must be an integer between 0 and 18')
+	}
+
+	if (!opts.yes) {
+		const ok = await confirm({
+			message: `Deploy ${symbol} as a mintable token (decimals=${decimals})?`,
+		})
+		if (isCancel(ok) || !ok) {
+			fatal('Deploy cancelled.')
+		}
+	}
+
+	const privateKey = await loadKey()
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		const result = await deployBsv21Auth.execute(ctx, {
+			symbol,
+			decimals,
+			icon,
+			destination: destinationFromFlags({ to, counterparty, lockingScript }),
+		})
+
+		if (result.error) {
+			fatal(result.error)
+		}
+
+		output(
+			opts.json
+				? result
+				: {
+						txid: result.txid,
+						tokenId: result.tokenId,
+						authOutpoint: result.authOutpoint,
+					},
+			opts,
+		)
+	} finally {
+		await destroy()
+	}
+}
+
+async function tokenMint(args: string[], opts: GlobalFlags): Promise<void> {
+	const tokenId = extractFlag(args, '--token-id')
+	const amountStr = extractFlag(args, '--amount')
+
+	const mintTo = extractFlag(args, '--to')
+	const mintCounterparty = extractFlag(args, '--counterparty')
+	const mintLockingScript = extractFlag(args, '--locking-script')
+
+	const authTo = extractFlag(args, '--auth-to')
+	const authCounterparty = extractFlag(args, '--auth-counterparty')
+	const authLockingScript = extractFlag(args, '--auth-locking-script')
+
+	const endMinting = args.includes('--end-minting')
+
+	if (!tokenId) fatal('Missing --token-id <id>')
+
+	const mintDestination = destinationFromFlags({
+		to: mintTo,
+		counterparty: mintCounterparty,
+		lockingScript: mintLockingScript,
+	})
+	const authDestination = destinationFromFlags({
+		to: authTo,
+		counterparty: authCounterparty,
+		lockingScript: authLockingScript,
+	})
+
+	// At least one operation
+	if (!amountStr && !authDestination && !endMinting) {
+		fatal(
+			'Provide either --amount (and optional mint destination) or auth destination, or --end-minting to burn authority',
+		)
+	}
+
+	const mint = amountStr
+		? {
+				amount: amountStr,
+				// Default mint destination to self when only amount is provided
+				destination: mintDestination ?? ({} as Destination),
+			}
+		: undefined
+	// Default auth destination to self when not ending minting. Symmetric
+	// with the mint default above. The action treats omitted `auth` as
+	// "burn authority" and requires `endMinting: true` for that, so leave
+	// auth undefined only when the user explicitly opted into ending.
+	const auth = endMinting
+		? authDestination
+			? { destination: authDestination }
+			: undefined
+		: { destination: authDestination ?? ({} as Destination) }
+
+	if (!opts.yes) {
+		const summary: string[] = []
+		if (mint) summary.push(`mint ${amountStr}`)
+		if (auth) summary.push('re-issue auth')
+		if (!auth && endMinting) summary.push('END MINTING (burn auth)')
+		const ok = await confirm({
+			message: `${summary.join(' + ')} for token ${tokenId.slice(0, 12)}...?`,
+		})
+		if (isCancel(ok) || !ok) {
+			fatal('Mint cancelled.')
+		}
+	}
+
+	const privateKey = await loadKey()
+	const { ctx, destroy } = await loadContext(privateKey, {
+		chain: opts.chain,
+	})
+
+	try {
+		const result = await mintBsv21.execute(ctx, {
+			tokenId,
+			mint,
+			auth,
+			endMinting: endMinting || undefined,
+		})
+
+		if (result.error) {
+			fatal(result.error)
+		}
+
+		output(
+			opts.json
+				? result
+				: { txid: result.txid, authOutpoint: result.authOutpoint },
+			opts,
+		)
+	} finally {
+		await destroy()
+	}
 }
 
 async function tokenBuy(args: string[], opts: GlobalFlags): Promise<void> {

package/src/commands/tx.ts

@@ -17,9 +17,7 @@ export async function handleTxCommand(
 		case 'decode':
 			return txDecode(rest, opts)
 		default:
-			printCommandHelp('tx', {
-				decode: 'Decode a raw transaction hex',
-			})
+			printCommandHelp('tx', opts.json)
 			if (subcommand && subcommand !== 'help') {
 				process.exit(1)
 			}

package/src/commands/wallet.ts

@@ -53,26 +53,7 @@ export async function handleWalletCommand(
 		case 'relinquish-certificate':
 			return walletRelinquishCertificate(rest, opts)
 		default:
-			printCommandHelp('wallet', {
-				balance: 'Show wallet balance in satoshis',
-				address:
-					'Show deposit address [--prefix <p>] [--start-index <n>] [--count <n>]',
-				send: 'Send BSV (--to <addr> --sats <n> | --script <hex> --sats <n> | --data-asm "<asm>")',
-				'send-all': 'Send all BSV to an address (--to <addr>)',
-				sync: 'Sync inbound payments at BRC-29 deposit addresses [--prefix <p>] [--start-index <n>] [--count <n>]',
-				info: 'Show wallet info (address, balance, network)',
-				'list-outputs':
-					'List wallet outputs (--basket <name> [--tags <t1,t2>] [--limit N] [--include-tags] [--include <val>])',
-				'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>)',
-			})
+			printCommandHelp('wallet', opts.json)
 			if (subcommand && subcommand !== 'help') {
 				process.exit(1)
 			}

package/src/config.ts

@@ -40,6 +40,28 @@ export interface ServerAccountsConfig {
 	freeIdentityKeys?: string[]
 }
 
+export interface ServerMessageboxConfig {
+	/** Port to bind. Defaults to `8101`. */
+	port?: number
+	/** Enable WebSocket delivery. Defaults to `true`. */
+	websockets?: boolean
+	/**
+	 * SQLite file path for messagebox storage. Used only when wallet storage
+	 * is `bun-sqlite`. Defaults to `<dataDir>/messagebox-{chain}.db`.
+	 */
+	dbPath?: string
+	/**
+	 * Postgres schema for messagebox tables. Used only when wallet storage
+	 * is `pg`. Defaults to `messagebox`.
+	 */
+	pgSchema?: string
+	/**
+	 * Override the wallet storage URL messagebox calls for BRC-31/BRC-29
+	 * operations. Defaults to the local wallet server URL (`http://<host>:<port>/`).
+	 */
+	walletStorageUrl?: string
+}
+
 export interface ServerConfig {
 	/** Hostname to bind. Defaults to `127.0.0.1`. */
 	host?: string
@@ -49,6 +71,8 @@ export interface ServerConfig {
 	storage?: ServerStorageConfig
 	/** Optional account/metering layer (opt-in per-deployment). */
 	accounts?: ServerAccountsConfig
+	/** Messagebox subcommand settings. */
+	messagebox?: ServerMessageboxConfig
 }
 
 export interface OneSatCliConfig {