@1sat/sweep-ui 0.0.1

package/src/lib/scanner.ts

@@ -0,0 +1,226 @@
+import { PrivateKey } from "@bsv/sdk";
+import type { IndexedOutput } from "@1sat/types";
+import { getServices } from "./services";
+
+export interface EnrichedOrdinal extends IndexedOutput {
+	origin?: string;
+	contentType?: string;
+	name?: string;
+	contentUrl: string;
+}
+
+export interface TokenBalance {
+	tokenId: string;
+	symbol?: string;
+	icon: string;
+	decimals: number;
+	totalAmount: bigint;
+	outputs: IndexedOutput[];
+	isActive: boolean;
+}
+
+export interface ScannedAssets {
+	funding: IndexedOutput[];
+	ordinals: EnrichedOrdinal[];
+	opnsNames: EnrichedOrdinal[];
+	bsv21Tokens: TokenBalance[];
+	bsv20Tokens: IndexedOutput[];
+	locked: IndexedOutput[];
+	totalBsv: number;
+}
+
+export interface ScanProgress {
+	phase: string;
+	detail?: string;
+}
+
+export function deriveAddress(wif: string): string {
+	return PrivateKey.fromWif(wif.trim()).toPublicKey().toAddress();
+}
+
+function getEvent(events: string[], prefix: string): string | undefined {
+	const e = events.find((e) => e.startsWith(prefix));
+	return e ? e.slice(prefix.length) : undefined;
+}
+
+function getEvents(events: string[], prefix: string): string[] {
+	return events.filter((e) => e.startsWith(prefix)).map((e) => e.slice(prefix.length));
+}
+
+function enrichOrdinal(out: IndexedOutput): EnrichedOrdinal {
+	const events = out.events ?? [];
+	const origin = getEvent(events, "origin:");
+	const types = getEvents(events, "type:");
+	const contentType = types.find((t) => t.includes("/")) ?? types[0];
+	const name = getEvent(events, "name:");
+	const contentUrl = getServices().ordfs.getContentUrl(origin ?? out.outpoint, { raw: true });
+
+	return { ...out, origin, contentType, name, contentUrl };
+}
+
+function resolveIconOutpoint(tokenId: string, icon?: string): string | undefined {
+	if (!icon) return undefined;
+	if (icon.startsWith("_")) {
+		const txid = tokenId.split("_")[0];
+		return `${txid}${icon}`;
+	}
+	return icon;
+}
+
+async function groupBsv21Tokens(outputs: IndexedOutput[]): Promise<TokenBalance[]> {
+	const groups = new Map<string, { outputs: IndexedOutput[]; totalAmount: bigint }>();
+
+	for (const out of outputs) {
+		const events = out.events ?? [];
+		const tokenId = getEvent(events, "bsv21:");
+		if (!tokenId) continue;
+
+		const amtStr = getEvent(events, "amt:");
+		const amount = amtStr ? BigInt(amtStr) : 0n;
+
+		let group = groups.get(tokenId);
+		if (!group) {
+			group = { outputs: [], totalAmount: 0n };
+			groups.set(tokenId, group);
+		}
+		group.outputs.push(out);
+		group.totalAmount += amount;
+	}
+
+	if (groups.size === 0) return [];
+
+	const services = getServices();
+	const tokenIds = [...groups.keys()];
+
+	let details: Array<{ tokenId: string; token?: { sym?: string; dec?: string; icon?: string }; status?: { is_active?: boolean } }> = [];
+	try {
+		details = await services.bsv21.lookupTokens(tokenIds);
+	} catch {
+		// BSV21 service may not be available
+	}
+
+	const detailMap = new Map(details.map((d) => [d.tokenId, d]));
+
+	const balances: TokenBalance[] = [];
+	for (const [tokenId, group] of groups) {
+		const detail = detailMap.get(tokenId);
+		const iconOutpoint = resolveIconOutpoint(tokenId, detail?.token?.icon);
+
+		balances.push({
+			tokenId,
+			symbol: detail?.token?.sym,
+			icon: iconOutpoint ? services.ordfs.getContentUrl(iconOutpoint) : "",
+			decimals: Number(detail?.token?.dec ?? 0),
+			totalAmount: group.totalAmount,
+			outputs: group.outputs,
+			isActive: detail?.status?.is_active ?? false,
+		});
+	}
+	return balances;
+}
+
+async function categorizeOutputs(outputs: IndexedOutput[]): Promise<ScannedAssets> {
+	const funding: IndexedOutput[] = [];
+	const rawOrdinals: IndexedOutput[] = [];
+	const opnsRaw: IndexedOutput[] = [];
+	const bsv21Raw: IndexedOutput[] = [];
+	const bsv20Tokens: IndexedOutput[] = [];
+	const locked: IndexedOutput[] = [];
+
+	for (const out of outputs) {
+		const events = out.events ?? [];
+		const sats = out.satoshis ?? 0;
+
+		if (events.some((e) => e.startsWith("bsv21:"))) {
+			bsv21Raw.push(out);
+			continue;
+		}
+
+		if (events.some((e) => e.startsWith("lock:"))) {
+			locked.push(out);
+			continue;
+		}
+
+		if (events.some((e) => e === "type:application/bsv-20" || e === "type:Token")) {
+			bsv20Tokens.push(out);
+			continue;
+		}
+
+		if (sats === 1) {
+			if (events.some((e) => e === "type:application/op-ns")) {
+				opnsRaw.push(out);
+			} else {
+				rawOrdinals.push(out);
+			}
+			continue;
+		}
+
+		if (sats > 1) {
+			funding.push(out);
+		}
+	}
+
+	return {
+		funding,
+		ordinals: rawOrdinals.map(enrichOrdinal),
+		opnsNames: opnsRaw.map(enrichOrdinal),
+		bsv21Tokens: await groupBsv21Tokens(bsv21Raw),
+		bsv20Tokens,
+		locked,
+		totalBsv: funding.reduce((sum, o) => sum + (o.satoshis ?? 0), 0),
+	};
+}
+
+export async function scanAddress(
+	address: string,
+	onProgress?: (p: ScanProgress) => void,
+): Promise<ScannedAssets> {
+	const services = getServices();
+
+	onProgress?.({ phase: "sync", detail: "Syncing address..." });
+	for await (const event of services.owner.getTxos(address, { refresh: true, limit: 1 })) {
+		if (event.type === "sync") {
+			const p = event.data;
+			onProgress?.({
+				phase: "sync",
+				detail: `${p.phase}: ${p.processed ?? 0}/${p.total ?? "?"}`,
+			});
+		} else if (event.type === "done" || event.type === "error") {
+			break;
+		}
+	}
+
+	onProgress?.({ phase: "search", detail: "Searching for assets..." });
+	const allOutputs = await services.txo.search(`own:${address}`, {
+		unspent: true,
+		events: true,
+		sats: true,
+		limit: 0,
+	});
+
+	onProgress?.({ phase: "categorize", detail: "Loading token details..." });
+	return await categorizeOutputs(allOutputs);
+}
+
+export async function scanAddresses(
+	addresses: string[],
+	onProgress?: (p: ScanProgress) => void,
+): Promise<ScannedAssets> {
+	const unique = [...new Set(addresses)];
+	const allResults: ScannedAssets[] = [];
+
+	for (const addr of unique) {
+		onProgress?.({ phase: "sync", detail: `Scanning ${addr.slice(0, 8)}...` });
+		allResults.push(await scanAddress(addr, onProgress));
+	}
+
+	return {
+		funding: allResults.flatMap((r) => r.funding),
+		ordinals: allResults.flatMap((r) => r.ordinals),
+		opnsNames: allResults.flatMap((r) => r.opnsNames),
+		bsv21Tokens: allResults.flatMap((r) => r.bsv21Tokens),
+		bsv20Tokens: allResults.flatMap((r) => r.bsv20Tokens),
+		locked: allResults.flatMap((r) => r.locked),
+		totalBsv: allResults.reduce((sum, r) => sum + r.totalBsv, 0),
+	};
+}

package/src/lib/services.ts

@@ -0,0 +1,18 @@
+import { OneSatServices } from "@1sat/client";
+
+let _services: OneSatServices | null = null;
+let _baseUrl: string | undefined;
+
+export function configureServices(baseUrl: string): void {
+	_baseUrl = baseUrl;
+	_services = null;
+}
+
+export function getServices(): OneSatServices {
+	if (!_services) {
+		const url = _baseUrl ?? (typeof window !== "undefined" ? window.location.origin : "");
+		if (!url) throw new Error("No base URL configured. Call configureServices() first.");
+		_services = new OneSatServices("main", url);
+	}
+	return _services;
+}

package/src/lib/sweeper.ts

@@ -0,0 +1,93 @@
+import {
+	createContext,
+	prepareSweepInputs,
+	sweepBsv,
+	sweepOrdinals,
+	sweepBsv21,
+} from "@1sat/actions";
+import type { IndexedOutput } from "@1sat/types";
+import type { WalletInterface } from "@bsv/sdk";
+import { getServices } from "./services";
+
+export interface SweepResult {
+	bsvTxid?: string;
+	ordinalTxids: string[];
+	bsv21Txids: string[];
+	errors: string[];
+}
+
+export async function executeSweep(params: {
+	wallet: WalletInterface;
+	wif: string;
+	funding: IndexedOutput[];
+	ordinals: IndexedOutput[];
+	bsv21Tokens: IndexedOutput[];
+	amount?: number;
+	onProgress: (stage: string) => void;
+}): Promise<SweepResult> {
+	const { wallet, wif, funding, ordinals, bsv21Tokens, amount, onProgress } = params;
+	const ctx = createContext(wallet, { services: getServices(), chain: "main" });
+
+	const result: SweepResult = {
+		ordinalTxids: [],
+		bsv21Txids: [],
+		errors: [],
+	};
+
+	if (funding.length > 0) {
+		onProgress(`Sweeping ${funding.length} BSV UTXOs...`);
+		try {
+			const inputs = await prepareSweepInputs(ctx, funding);
+			const bsvResult = await sweepBsv.execute(ctx, { inputs, wif, amount });
+			if (bsvResult.error) result.errors.push(`BSV: ${bsvResult.error}`);
+			else if (bsvResult.txid) result.bsvTxid = bsvResult.txid;
+		} catch (e) {
+			result.errors.push(`BSV: ${e instanceof Error ? e.message : String(e)}`);
+		}
+	}
+
+	if (ordinals.length > 0) {
+		onProgress(`Sweeping ${ordinals.length} ordinals...`);
+		try {
+			const inputs = await prepareSweepInputs(ctx, ordinals);
+			const ordResult = await sweepOrdinals.execute(ctx, { inputs, wif });
+			if (ordResult.error) result.errors.push(`Ordinals: ${ordResult.error}`);
+			else if (ordResult.txid) result.ordinalTxids.push(ordResult.txid);
+		} catch (e) {
+			result.errors.push(`Ordinals: ${e instanceof Error ? e.message : String(e)}`);
+		}
+	}
+
+	if (bsv21Tokens.length > 0) {
+		const groups = new Map<string, IndexedOutput[]>();
+		for (const token of bsv21Tokens) {
+			const tokenEvent = token.events?.find((e) => e.startsWith("tokenId:"));
+			const tokenId = tokenEvent?.slice(8) ?? "unknown";
+			const group = groups.get(tokenId) ?? [];
+			group.push(token);
+			groups.set(tokenId, group);
+		}
+
+		for (const [tokenId, tokens] of groups) {
+			onProgress(`Sweeping ${tokens.length} tokens (${tokenId.slice(0, 8)}...)...`);
+			try {
+				const inputs = await prepareSweepInputs(ctx, tokens);
+				const tokenResult = await sweepBsv21.execute(ctx, {
+					inputs: inputs.map((inp) => ({
+						...inp,
+						tokenId,
+						amount: "0",
+					})),
+					wif,
+				});
+				if (tokenResult.error) result.errors.push(`BSV-21 (${tokenId.slice(0, 8)}): ${tokenResult.error}`);
+				else if (tokenResult.txid) result.bsv21Txids.push(tokenResult.txid);
+			} catch (e) {
+				result.errors.push(`BSV-21 (${tokenId.slice(0, 8)}): ${e instanceof Error ? e.message : String(e)}`);
+			}
+		}
+	}
+
+	onProgress("Sweep complete");
+	return result;
+}

package/src/lib/utils.ts

@@ -0,0 +1,23 @@
+import { type ClassValue, clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+export function cn(...inputs: ClassValue[]) {
+	return twMerge(clsx(inputs));
+}
+
+export function formatSats(sats: number): string {
+	return sats.toLocaleString();
+}
+
+export function formatTokenAmount(rawAmount: string, decimals: number): string {
+	if (decimals === 0) return rawAmount;
+	const padded = rawAmount.padStart(decimals + 1, "0");
+	const intPart = padded.slice(0, -decimals) || "0";
+	const decPart = padded.slice(-decimals).replace(/0+$/, "");
+	return decPart ? `${intPart}.${decPart}` : intPart;
+}
+
+export function truncate(s: string, len = 8): string {
+	if (s.length <= len * 2 + 3) return s;
+	return `${s.slice(0, len)}...${s.slice(-len)}`;
+}

package/src/lib/wallet.ts

@@ -0,0 +1,32 @@
+import { connectWallet as connect, type ConnectWalletResult } from "@1sat/connect";
+import type { WalletInterface } from "@bsv/sdk";
+
+let connection: ConnectWalletResult | null = null;
+
+export async function connectWallet(): Promise<ConnectWalletResult> {
+	const result = await connect();
+	if (!result) throw new Error("No wallet available");
+	connection = result;
+	return result;
+}
+
+export function getWallet(): WalletInterface | null {
+	return connection?.wallet ?? null;
+}
+
+export function getIdentityKey(): string | null {
+	return connection?.identityKey ?? null;
+}
+
+export function getProvider(): string | null {
+	return connection?.provider ?? null;
+}
+
+export function disconnectWallet(): void {
+	connection?.disconnect();
+	connection = null;
+}
+
+export function isConnected(): boolean {
+	return connection !== null;
+}

package/src/types.ts

@@ -0,0 +1,5 @@
+export interface LegacyKeys {
+	payPk: string;
+	ordPk: string;
+	identityPk?: string;
+}