@1sat/cli 0.0.63 → 0.0.64

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1sat/cli",
-  "version": "0.0.63",
+  "version": "0.0.64",
   "description": "CLI for 1Sat Ordinals SDK",
   "type": "module",
   "main": "./src/cli.ts",
@@ -15,7 +15,8 @@
     "preinstall": "node scripts/check-bun.cjs",
     "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",
-    "lint": "biome check src"
+    "lint": "biome check src",
+    "test": "bun test"
   },
   "keywords": [
     "1sat",
@@ -25,11 +26,11 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "@1sat/actions": "0.0.153",
-    "@1sat/client": "0.0.36",
-    "@1sat/types": "0.0.28",
-    "@1sat/wallet-node": "0.0.50",
-    "@1sat/wallet-server": "0.0.19",
+    "@1sat/actions": "0.0.162",
+    "@1sat/client": "0.0.38",
+    "@1sat/types": "0.0.30",
+    "@1sat/wallet-node": "0.0.51",
+    "@1sat/wallet-server": "0.0.20",
     "@bsv/sdk": "^2.0.13",
     "@bsv/wallet-toolbox": "npm:@bopen-io/wallet-toolbox@2.1.21-parity-fix.2",
     "chalk": "^5.0.0",

package/src/commands/serve.ts

@@ -31,12 +31,18 @@ import {
 	type ServerAccountsConfig,
 	type ServerStorageConfig,
 	loadConfig,
+	setConfigPath,
 } from '../config'
 import { ensureDataDir } from '../config'
 import { printCommandHelp } from '../help'
 import { loadKey } from '../keys'
 import { clearMonitorPid, writeMonitorPid } from '../monitor-lock'
 import { fatal } from '../output'
+import {
+	buildPriceUpdateTask,
+	createAccountsConfigLoader,
+	resolveRateProvider,
+} from '../repricer'
 import { startMessagebox } from './serve-messagebox'
 
 const DEFAULT_HOST = '127.0.0.1'
@@ -72,6 +78,14 @@ interface ResolvedAccounts {
 	satsPerUnit: number
 	durationBlocks: number
 	freeIdentityKeys: string[]
+	repricer?: {
+		enabled?: boolean
+		targetUsd?: number
+		intervalMs?: number
+		provider?: string
+		maxMovePct?: number
+		minSats?: number
+	}
 }
 
 export async function handleServeCommand(
@@ -217,6 +231,7 @@ function resolveAccounts(accounts?: ServerAccountsConfig): ResolvedAccounts {
 		satsPerUnit: accounts?.satsPerUnit ?? DEFAULT_SATS_PER_UNIT,
 		durationBlocks: accounts?.durationBlocks ?? DEFAULT_DURATION_BLOCKS,
 		freeIdentityKeys: accounts?.freeIdentityKeys ?? [],
+		repricer: accounts?.repricer,
 	}
 }
 
@@ -259,6 +274,42 @@ async function runWithStorage(
 			? undefined
 			: await startWalletServer(resolved, walletResult, accounts)
 
+	if (mode !== 'wallet' && accounts) {
+		const accountsCfg = resolved.accounts
+		const r = accountsCfg.repricer
+		if (
+			accountsCfg.enabled &&
+			r?.enabled &&
+			typeof r.targetUsd === 'number' &&
+			r.targetUsd > 0
+		) {
+			walletResult.monitor.addTask(
+				buildPriceUpdateTask({
+					monitor: walletResult.monitor,
+					rateProvider: resolveRateProvider(r.provider ?? 'whatsonchain', {
+						chain: resolved.chain,
+					}),
+					intervalMs: r.intervalMs ?? 15 * 60 * 1000,
+					targetUsd: r.targetUsd,
+					bounds: {
+						maxMovePct: r.maxMovePct ?? 25,
+						minSats: r.minSats ?? 1,
+					},
+					readCurrentSats: () =>
+						loadConfig().server?.accounts?.satsPerUnit ?? DEFAULT_SATS_PER_UNIT,
+					onPersist: async (sats) => {
+						setConfigPath('server.accounts.satsPerUnit', sats)
+					},
+				}),
+			)
+			console.log(
+				`[repricer] enabled — $${r.targetUsd}/unit every ${Math.round(
+					(r.intervalMs ?? 900_000) / 1000,
+				)}s via ${r.provider ?? 'whatsonchain'}`,
+			)
+		}
+	}
+
 	if (mode !== 'wallet') {
 		// startTasks loops until stopTasks flips its flag. Fire without
 		// awaiting so the caller can install shutdown handlers and write
@@ -318,16 +369,25 @@ async function buildAccountsForServer(
 	// storage; accounts semantics don't apply.
 	if (resolved.activeRemote) return undefined
 
+	const getConfig = createAccountsConfigLoader({
+		ttlMs: 60_000,
+		read: () => {
+			const fresh = loadConfig()
+			const a = fresh.server?.accounts
+			return {
+				enabled: a?.enabled ?? false,
+				baselineBytes: a?.baselineBytes ?? DEFAULT_BASELINE_BYTES,
+				purchaseUnitBytes: a?.purchaseUnitBytes ?? DEFAULT_PURCHASE_UNIT_BYTES,
+				satsPerUnit: a?.satsPerUnit ?? DEFAULT_SATS_PER_UNIT,
+				durationBlocks: a?.durationBlocks ?? DEFAULT_DURATION_BLOCKS,
+				freeIdentityKeys: a?.freeIdentityKeys ?? [],
+			}
+		},
+	})
+
 	return {
 		walletServerAccounts: {
-			config: {
-				enabled: resolved.accounts.enabled,
-				baselineBytes: resolved.accounts.baselineBytes,
-				purchaseUnitBytes: resolved.accounts.purchaseUnitBytes,
-				satsPerUnit: resolved.accounts.satsPerUnit,
-				durationBlocks: resolved.accounts.durationBlocks,
-				freeIdentityKeys: resolved.accounts.freeIdentityKeys,
-			},
+			getConfig,
 			currentBlock: () => walletResult.services.chaintracks.currentHeight(),
 		},
 	}

package/src/config.ts

@@ -25,6 +25,21 @@ export type ServerStorageConfig =
 	| ServerStorageBunSqliteConfig
 	| ServerStoragePgConfig
 
+export interface RepricerConfig {
+	/** Master toggle. Defaults to false. */
+	enabled?: boolean
+	/** Target price per `purchaseUnitBytes` chunk, in USD. */
+	targetUsd?: number
+	/** Interval between rate checks in ms. Defaults to 900000 (15 min). */
+	intervalMs?: number
+	/** Rate provider name. Defaults to "whatsonchain". */
+	provider?: string
+	/** Max percent change allowed per update. Larger moves are skipped. Defaults to 25. */
+	maxMovePct?: number
+	/** Lower bound for `satsPerUnit`. Defaults to 1. */
+	minSats?: number
+}
+
 export interface ServerAccountsConfig {
 	/** Master toggle. Defaults to false when omitted. */
 	enabled?: boolean
@@ -38,6 +53,8 @@ export interface ServerAccountsConfig {
 	durationBlocks?: number
 	/** Identity keys that bypass metering (server's own key is auto-added). */
 	freeIdentityKeys?: string[]
+	/** Optional auto-repricer. When enabled, updates `satsPerUnit` from a live BSV/USD rate. */
+	repricer?: RepricerConfig
 }
 
 export interface ServerMessageboxConfig {

package/src/repricer/buildPriceUpdateTask.ts

@@ -0,0 +1,80 @@
+import { computeReprice } from './computeReprice'
+import type { RateProvider, RepricerBounds } from './types'
+
+export interface PriceUpdateTaskOptions {
+	monitor: unknown
+	rateProvider: RateProvider
+	/** Interval between successful tick attempts. */
+	intervalMs: number
+	/** USD target per purchase unit. Task no-ops when this is 0. */
+	targetUsd: number
+	bounds: RepricerBounds
+	/** Read current `satsPerUnit` (typically from disk via the same loader the servers use). */
+	readCurrentSats: () => number
+	/** Persist the new `satsPerUnit` value. Wraps `setConfigPath('server.accounts.satsPerUnit', sats)`. */
+	onPersist: (newSats: number) => Promise<void>
+}
+
+export interface PriceUpdateTask {
+	monitor: unknown
+	storage: unknown
+	name: 'PriceUpdate'
+	lastRunMsecsSinceEpoch: number
+	asyncSetup(): Promise<void>
+	trigger(now: number): { run: boolean }
+	runTask(): Promise<string>
+}
+
+export function buildPriceUpdateTask(
+	options: PriceUpdateTaskOptions,
+): PriceUpdateTask {
+	const {
+		monitor,
+		rateProvider,
+		intervalMs,
+		targetUsd,
+		bounds,
+		readCurrentSats,
+		onPersist,
+	} = options
+
+	const storage = (monitor as { storage?: unknown } | null | undefined)?.storage
+
+	return {
+		monitor,
+		storage,
+		name: 'PriceUpdate',
+		lastRunMsecsSinceEpoch: 0,
+		async asyncSetup() {},
+		trigger(now: number): { run: boolean } {
+			if (!(targetUsd > 0)) return { run: false }
+			if (now - this.lastRunMsecsSinceEpoch < intervalMs) return { run: false }
+			return { run: true }
+		},
+		async runTask(): Promise<string> {
+			let quote: Awaited<ReturnType<RateProvider['getBsvUsd']>>
+			try {
+				quote = await rateProvider.getBsvUsd()
+			} catch (err) {
+				return `rate fetch failed: ${(err as Error).message}`
+			}
+
+			const currentSats = readCurrentSats()
+			const result = computeReprice({
+				targetUsd,
+				bsvUsd: quote.bsvUsd,
+				currentSats,
+				bounds,
+			})
+
+			if (result.status === 'skipped') return `skipped: ${result.reason}`
+
+			try {
+				await onPersist(result.newSats)
+			} catch (err) {
+				return `persist failed: ${(err as Error).message}`
+			}
+			return `${currentSats} → ${result.newSats} sats/unit @ $${quote.bsvUsd}/BSV`
+		},
+	}
+}

package/src/repricer/computeReprice.ts

@@ -0,0 +1,34 @@
+import type { ComputeRepriceInput, ComputeRepriceResult } from './types'
+
+const SATS_PER_BSV = 100_000_000
+
+export function computeReprice(
+	input: ComputeRepriceInput,
+): ComputeRepriceResult {
+	const { targetUsd, bsvUsd, currentSats, bounds } = input
+
+	if (!(targetUsd > 0))
+		return { status: 'skipped', reason: 'targetUsd must be > 0' }
+	if (!(bsvUsd > 0)) return { status: 'skipped', reason: 'bsvUsd must be > 0' }
+	if (!(currentSats > 0))
+		return { status: 'skipped', reason: 'currentSats must be > 0' }
+
+	const newSats = Math.round((targetUsd / bsvUsd) * SATS_PER_BSV)
+
+	if (newSats < bounds.minSats) {
+		return {
+			status: 'skipped',
+			reason: `computed ${newSats} is below minSats ${bounds.minSats}`,
+		}
+	}
+
+	const movePct = (Math.abs(newSats - currentSats) / currentSats) * 100
+	if (movePct > bounds.maxMovePct) {
+		return {
+			status: 'skipped',
+			reason: `move ${movePct.toFixed(2)}% exceeds maxMovePct ${bounds.maxMovePct}`,
+		}
+	}
+
+	return { status: 'ok', newSats }
+}

package/src/repricer/configLoader.ts

@@ -0,0 +1,37 @@
+import type {
+	AccountsConfig,
+	AccountsConfigProvider,
+} from '@1sat/wallet-server'
+
+export interface AccountsConfigLoaderOptions {
+	ttlMs: number
+	read: () => AccountsConfig
+	/** Override clock (testing). */
+	now?: () => number
+}
+
+/**
+ * Build an `AccountsConfigProvider` that re-reads its source no more often
+ * than `ttlMs`. If `read` throws after the first success, the last good
+ * value is returned and the failure is silently absorbed.
+ */
+export function createAccountsConfigLoader(
+	options: AccountsConfigLoaderOptions,
+): AccountsConfigProvider {
+	const now = options.now ?? (() => Date.now())
+	let cached: AccountsConfig | undefined
+	let cachedAt = 0
+
+	return () => {
+		const t = now()
+		if (cached && t - cachedAt < options.ttlMs) return cached
+		try {
+			cached = options.read()
+			cachedAt = t
+			return cached
+		} catch (err) {
+			if (cached) return cached
+			throw err
+		}
+	}
+}

package/src/repricer/index.ts

@@ -0,0 +1,14 @@
+export { buildPriceUpdateTask } from './buildPriceUpdateTask'
+export type { PriceUpdateTaskOptions } from './buildPriceUpdateTask'
+export { computeReprice } from './computeReprice'
+export { createAccountsConfigLoader } from './configLoader'
+export type { AccountsConfigLoaderOptions } from './configLoader'
+export { resolveRateProvider } from './providers'
+export { createWhatsOnChainProvider } from './whatsOnChain'
+export type {
+	BsvUsdQuote,
+	ComputeRepriceInput,
+	ComputeRepriceResult,
+	RateProvider,
+	RepricerBounds,
+} from './types'

package/src/repricer/providers.ts

@@ -0,0 +1,20 @@
+import type { RateProvider } from './types'
+import { createWhatsOnChainProvider } from './whatsOnChain'
+
+export interface ResolveProviderOptions {
+	chain: 'main' | 'test'
+}
+
+export function resolveRateProvider(
+	name: string,
+	options: ResolveProviderOptions,
+): RateProvider {
+	switch (name) {
+		case 'whatsonchain':
+			return createWhatsOnChainProvider({ chain: options.chain })
+		default:
+			throw new Error(
+				`Unknown rate provider "${name}". Supported: whatsonchain.`,
+			)
+	}
+}

package/src/repricer/types.ts

@@ -0,0 +1,28 @@
+export interface BsvUsdQuote {
+	bsvUsd: number
+	timestamp: number
+	source: string
+}
+
+export interface RateProvider {
+	readonly name: string
+	getBsvUsd(): Promise<BsvUsdQuote>
+}
+
+export interface RepricerBounds {
+	/** Reject moves larger than this percent. */
+	maxMovePct: number
+	/** Floor for the new sats value. */
+	minSats: number
+}
+
+export interface ComputeRepriceInput {
+	targetUsd: number
+	bsvUsd: number
+	currentSats: number
+	bounds: RepricerBounds
+}
+
+export type ComputeRepriceResult =
+	| { status: 'ok'; newSats: number }
+	| { status: 'skipped'; reason: string }

package/src/repricer/whatsOnChain.ts

@@ -0,0 +1,36 @@
+import type { BsvUsdQuote, RateProvider } from './types'
+
+export interface WhatsOnChainOptions {
+	chain: 'main' | 'test'
+	/** Override base URL (testing). */
+	baseUrl?: string
+}
+
+export function createWhatsOnChainProvider(
+	options: WhatsOnChainOptions,
+): RateProvider {
+	const base = options.baseUrl ?? 'https://api.whatsonchain.com/v1/bsv'
+	const url = `${base}/${options.chain}/exchangerate`
+
+	return {
+		name: 'whatsonchain',
+		async getBsvUsd(): Promise<BsvUsdQuote> {
+			const res = await fetch(url)
+			if (!res.ok) {
+				throw new Error(
+					`whatsonchain: ${res.status} ${await res.text().catch(() => '')}`,
+				)
+			}
+			const body = (await res.json()) as { rate?: number; time?: number }
+			if (typeof body.rate !== 'number' || !(body.rate > 0)) {
+				throw new Error('whatsonchain: missing or invalid "rate" in response')
+			}
+			return {
+				bsvUsd: body.rate,
+				timestamp:
+					typeof body.time === 'number' ? body.time * 1000 : Date.now(),
+				source: 'whatsonchain',
+			}
+		},
+	}
+}