@1sat/sweep-ui 0.0.19 → 0.0.21

package/src/lib/sweeper.ts

@@ -2,80 +2,93 @@ import {
 	createContext,
 	prepareSweepInputs,
 	sweepBsv,
-	sweepOrdinals,
 	sweepBsv21,
-} from "@1sat/actions";
-import type { IndexedOutput } from "@1sat/types";
-import { PrivateKey, type WalletInterface } from "@bsv/sdk";
-import type { TokenBalance } from "./scanner";
-import { getServices } from "./services";
+	sweepOrdinals,
+} from '@1sat/actions'
+import type { IndexedOutput } from '@1sat/types'
+import type { PrivateKey, WalletInterface } from '@bsv/sdk'
+import type { TokenBalance } from './scanner'
+import { getServices } from './services'
 
 export interface SweepResult {
-	bsvTxid?: string;
-	ordinalTxids: string[];
-	bsv21Txids: string[];
-	errors: string[];
+	bsvTxid?: string
+	ordinalTxids: string[]
+	bsv21Txids: string[]
+	errors: string[]
 }
 
 function getOwner(output: IndexedOutput): string | undefined {
-	return output.events?.find((e) => e.startsWith("own:"))?.slice(4);
+	return output.events?.find((e) => e.startsWith('own:'))?.slice(4)
 }
 
-function buildKeys(outputs: IndexedOutput[], keyMap: Map<string, PrivateKey>): PrivateKey[] {
+function buildKeys(
+	outputs: IndexedOutput[],
+	keyMap: Map<string, PrivateKey>,
+): PrivateKey[] {
 	return outputs.map((output) => {
-		const owner = getOwner(output);
-		const key = owner ? keyMap.get(owner) : undefined;
-		if (!key) throw new Error(`No key for output ${output.outpoint} (owner: ${owner})`);
-		return key;
-	});
+		const owner = getOwner(output)
+		const key = owner ? keyMap.get(owner) : undefined
+		if (!key)
+			throw new Error(`No key for output ${output.outpoint} (owner: ${owner})`)
+		return key
+	})
 }
 
 /**
  * Sweep BSV funding and ordinals into the connected wallet.
  */
 export async function executeSweep(params: {
-	wallet: WalletInterface;
-	keys: Map<string, PrivateKey>;
-	funding: IndexedOutput[];
-	ordinals: IndexedOutput[];
-	amount?: number;
-	onProgress: (stage: string) => void;
+	wallet: WalletInterface
+	keys: Map<string, PrivateKey>
+	funding: IndexedOutput[]
+	ordinals: IndexedOutput[]
+	amount?: number
+	onProgress: (stage: string) => void
 }): Promise<SweepResult> {
-	const { wallet, keys, funding, ordinals, amount, onProgress } = params;
-	const ctx = createContext(wallet, { services: getServices(), chain: "main" });
+	const { wallet, keys, funding, ordinals, 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...`);
+		onProgress(`Sweeping ${funding.length} BSV UTXOs...`)
 		try {
-			const inputs = await prepareSweepInputs(ctx, funding);
-			const bsvResult = await sweepBsv.execute(ctx, { inputs, keys: buildKeys(funding, keys), amount });
-			if (bsvResult.error) result.errors.push(`BSV: ${bsvResult.error}`);
-			else if (bsvResult.txid) result.bsvTxid = bsvResult.txid;
+			const inputs = await prepareSweepInputs(ctx, funding)
+			const bsvResult = await sweepBsv.execute(ctx, {
+				inputs,
+				keys: buildKeys(funding, keys),
+				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)}`);
+			result.errors.push(`BSV: ${e instanceof Error ? e.message : String(e)}`)
 		}
 	}
 
 	if (ordinals.length > 0) {
-		onProgress(`Sweeping ${ordinals.length} ordinals...`);
+		onProgress(`Sweeping ${ordinals.length} ordinals...`)
 		try {
-			const inputs = await prepareSweepInputs(ctx, ordinals);
-			const ordResult = await sweepOrdinals.execute(ctx, { inputs, keys: buildKeys(ordinals, keys) });
-			if (ordResult.error) result.errors.push(`Ordinals: ${ordResult.error}`);
-			else if (ordResult.txid) result.ordinalTxids.push(ordResult.txid);
+			const inputs = await prepareSweepInputs(ctx, ordinals)
+			const ordResult = await sweepOrdinals.execute(ctx, {
+				inputs,
+				keys: buildKeys(ordinals, keys),
+			})
+			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)}`);
+			result.errors.push(
+				`Ordinals: ${e instanceof Error ? e.message : String(e)}`,
+			)
 		}
 	}
 
-	onProgress("Sweep complete");
-	return result;
+	onProgress('Sweep complete')
+	return result
 }
 
 /**
@@ -83,29 +96,29 @@ export async function executeSweep(params: {
  * Each token requires its own transaction since all inputs must share a tokenId.
  */
 export async function sweepBsv21Token(params: {
-	wallet: WalletInterface;
-	keys: Map<string, PrivateKey>;
-	token: TokenBalance;
-	onProgress: (stage: string) => void;
+	wallet: WalletInterface
+	keys: Map<string, PrivateKey>
+	token: TokenBalance
+	onProgress: (stage: string) => void
 }): Promise<{ txid?: string; error?: string }> {
-	const { wallet, keys, token, onProgress } = params;
-	const ctx = createContext(wallet, { services: getServices(), chain: "main" });
+	const { wallet, keys, token, onProgress } = params
+	const ctx = createContext(wallet, { services: getServices(), chain: 'main' })
 
-	onProgress(`Sweeping ${token.symbol ?? token.tokenId.slice(0, 8)}...`);
+	onProgress(`Sweeping ${token.symbol ?? token.tokenId.slice(0, 8)}...`)
 
 	try {
 		const inputs = token.outputs.map((out) => ({
 			outpoint: out.outpoint,
 			tokenId: token.tokenId,
-			amount: token.amounts.get(out.outpoint) ?? "0",
-		}));
+			amount: token.amounts.get(out.outpoint) ?? '0',
+		}))
 
-		const tokenKeys = buildKeys(token.outputs, keys);
+		const tokenKeys = buildKeys(token.outputs, keys)
 
-		const result = await sweepBsv21.execute(ctx, { inputs, keys: tokenKeys });
-		if (result.error) return { error: result.error };
-		return { txid: result.txid };
+		const result = await sweepBsv21.execute(ctx, { inputs, keys: tokenKeys })
+		if (result.error) return { error: result.error }
+		return { txid: result.txid }
 	} catch (e) {
-		return { error: e instanceof Error ? e.message : String(e) };
+		return { error: e instanceof Error ? e.message : String(e) }
 	}
 }

package/src/lib/utils.ts

@@ -1,23 +1,23 @@
-import { type ClassValue, clsx } from "clsx";
-import { twMerge } from "tailwind-merge";
+import { type ClassValue, clsx } from 'clsx'
+import { twMerge } from 'tailwind-merge'
 
 export function cn(...inputs: ClassValue[]) {
-	return twMerge(clsx(inputs));
+	return twMerge(clsx(inputs))
 }
 
 export function formatSats(sats: number): string {
-	return sats.toLocaleString();
+	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;
+	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)}`;
+	if (s.length <= len * 2 + 3) return s
+	return `${s.slice(0, len)}...${s.slice(-len)}`
 }

package/src/lib/wallet.ts

@@ -1,32 +1,35 @@
-import { connectWallet as connect, type ConnectWalletResult } from "@1sat/connect";
-import type { WalletInterface } from "@bsv/sdk";
+import {
+	type ConnectWalletResult,
+	connectWallet as connect,
+} from '@1sat/connect'
+import type { WalletInterface } from '@bsv/sdk'
 
-let connection: ConnectWalletResult | null = null;
+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;
+	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;
+	return connection?.wallet ?? null
 }
 
 export function getIdentityKey(): string | null {
-	return connection?.identityKey ?? null;
+	return connection?.identityKey ?? null
 }
 
 export function getProvider(): string | null {
-	return connection?.provider ?? null;
+	return connection?.provider ?? null
 }
 
 export function disconnectWallet(): void {
-	connection?.disconnect();
-	connection = null;
+	connection?.disconnect()
+	connection = null
 }
 
 export function isConnected(): boolean {
-	return connection !== null;
+	return connection !== null
 }

package/src/types.ts

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