@1sat/sweep-ui 0.0.19 → 0.0.21

package/src/lib/legacy-send.ts

@@ -1,234 +1,238 @@
-import { parseOutpoint } from "@1sat/utils";
-import type { IndexedOutput } from "@1sat/types";
-import { MAP_PREFIX } from "@1sat/types";
-import { OP, P2PKH, PrivateKey, Script, Transaction, Utils } from "@bsv/sdk";
-import { deriveAddress } from "./scanner";
-import { getServices } from "./services";
-import type { LegacyKeys } from "../types";
+import type { IndexedOutput } from '@1sat/types'
+import { MAP_PREFIX } from '@1sat/types'
+import { parseOutpoint } from '@1sat/utils'
+import { OP, P2PKH, PrivateKey, Script, Transaction, Utils } from '@bsv/sdk'
+import type { LegacyKeys } from '../types'
+import { deriveAddress } from './scanner'
+import { getServices } from './services'
 
 export interface LegacySendResult {
-	txid: string;
-	rawtx: string;
+	txid: string
+	rawtx: string
 }
 
 async function fetchSourceTx(txid: string): Promise<Transaction> {
-	const services = getServices();
-	const beef = await services.getBeefForTxid(txid);
-	const found = beef.findTxid(txid);
-	if (!found?.tx) throw new Error(`Transaction ${txid} not found in BEEF`);
-	return found.tx;
+	const services = getServices()
+	const beef = await services.getBeefForTxid(txid)
+	const found = beef.findTxid(txid)
+	if (!found?.tx) throw new Error(`Transaction ${txid} not found in BEEF`)
+	return found.tx
 }
 
 function buildKeyMap(keys: LegacyKeys): Map<string, PrivateKey> {
-	const map = new Map<string, PrivateKey>();
-	const payKey = PrivateKey.fromWif(keys.payPk);
-	const ordKey = PrivateKey.fromWif(keys.ordPk);
-	map.set(deriveAddress(keys.payPk), payKey);
-	map.set(deriveAddress(keys.ordPk), ordKey);
+	const map = new Map<string, PrivateKey>()
+	const payKey = PrivateKey.fromWif(keys.payPk)
+	const ordKey = PrivateKey.fromWif(keys.ordPk)
+	map.set(deriveAddress(keys.payPk), payKey)
+	map.set(deriveAddress(keys.ordPk), ordKey)
 	if (keys.identityPk) {
-		map.set(deriveAddress(keys.identityPk), PrivateKey.fromWif(keys.identityPk));
+		map.set(deriveAddress(keys.identityPk), PrivateKey.fromWif(keys.identityPk))
 	}
-	return map;
+	return map
 }
 
-function keyForOutput(output: IndexedOutput, keyMap: Map<string, PrivateKey>, fallback: PrivateKey): PrivateKey {
+function keyForOutput(
+	output: IndexedOutput,
+	keyMap: Map<string, PrivateKey>,
+	fallback: PrivateKey,
+): PrivateKey {
 	if (output.events) {
 		for (const event of output.events) {
-			if (event.startsWith("own:") || event.startsWith("p2pkh:")) {
-				const addr = event.split(":")[1];
-				const key = keyMap.get(addr);
-				if (key) return key;
+			if (event.startsWith('own:') || event.startsWith('p2pkh:')) {
+				const addr = event.split(':')[1]
+				const key = keyMap.get(addr)
+				if (key) return key
 			}
 		}
 	}
-	return fallback;
+	return fallback
 }
 
 export async function legacySendBsv(params: {
-	funding: IndexedOutput[];
-	keys: LegacyKeys;
-	destination: string;
-	amount?: number;
+	funding: IndexedOutput[]
+	keys: LegacyKeys
+	destination: string
+	amount?: number
 }): Promise<LegacySendResult> {
-	const { funding, keys, destination, amount } = params;
-	if (!funding.length) throw new Error("No funding UTXOs");
-	if (!destination) throw new Error("No destination address");
+	const { funding, keys, destination, amount } = params
+	if (!funding.length) throw new Error('No funding UTXOs')
+	if (!destination) throw new Error('No destination address')
 
-	const keyMap = buildKeyMap(keys);
-	const payKey = PrivateKey.fromWif(keys.payPk);
-	const sourceAddress = payKey.toPublicKey().toAddress();
-	const p2pkh = new P2PKH();
-	const tx = new Transaction();
+	const keyMap = buildKeyMap(keys)
+	const payKey = PrivateKey.fromWif(keys.payPk)
+	const sourceAddress = payKey.toPublicKey().toAddress()
+	const p2pkh = new P2PKH()
+	const tx = new Transaction()
 
 	for (const utxo of funding) {
-		const { txid, vout } = parseOutpoint(utxo.outpoint);
-		const key = keyForOutput(utxo, keyMap, payKey);
+		const { txid, vout } = parseOutpoint(utxo.outpoint)
+		const key = keyForOutput(utxo, keyMap, payKey)
 		tx.addInput({
 			sourceTXID: txid,
 			sourceOutputIndex: vout,
 			sourceTransaction: await fetchSourceTx(txid),
 			unlockingScriptTemplate: p2pkh.unlock(key),
 			sequence: 0xffffffff,
-		});
+		})
 	}
 
 	if (amount) {
 		tx.addOutput({
 			lockingScript: p2pkh.lock(destination),
 			satoshis: amount,
-		});
+		})
 		tx.addOutput({
 			lockingScript: p2pkh.lock(sourceAddress),
 			change: true,
-		});
+		})
 	} else {
 		tx.addOutput({
 			lockingScript: p2pkh.lock(destination),
 			change: true,
-		});
+		})
 	}
 
-	await tx.fee();
-	await tx.sign();
+	await tx.fee()
+	await tx.sign()
 
-	const rawTx = tx.toBinary();
-	const result = await getServices().arcade.submitTransaction(rawTx);
+	const rawTx = tx.toBinary()
+	const result = await getServices().arcade.submitTransaction(rawTx)
 
 	return {
 		txid: result.txid,
 		rawtx: Utils.toHex(rawTx),
-	};
+	}
 }
 
 export async function legacySendOrdinals(params: {
-	ordinals: IndexedOutput[];
-	funding: IndexedOutput[];
-	keys: LegacyKeys;
-	destination: string;
+	ordinals: IndexedOutput[]
+	funding: IndexedOutput[]
+	keys: LegacyKeys
+	destination: string
 }): Promise<LegacySendResult> {
-	const { ordinals, funding, keys, destination } = params;
-	if (!ordinals.length) throw new Error("No ordinals to send");
-	if (!funding.length) throw new Error("No funding UTXOs for fees");
-	if (!destination) throw new Error("No destination address");
+	const { ordinals, funding, keys, destination } = params
+	if (!ordinals.length) throw new Error('No ordinals to send')
+	if (!funding.length) throw new Error('No funding UTXOs for fees')
+	if (!destination) throw new Error('No destination address')
 
-	const keyMap = buildKeyMap(keys);
-	const payKey = PrivateKey.fromWif(keys.payPk);
-	const sourceAddress = payKey.toPublicKey().toAddress();
-	const p2pkh = new P2PKH();
-	const tx = new Transaction();
+	const keyMap = buildKeyMap(keys)
+	const payKey = PrivateKey.fromWif(keys.payPk)
+	const sourceAddress = payKey.toPublicKey().toAddress()
+	const p2pkh = new P2PKH()
+	const tx = new Transaction()
 
 	for (const ord of ordinals) {
-		const { txid, vout } = parseOutpoint(ord.outpoint);
-		const key = keyForOutput(ord, keyMap, payKey);
+		const { txid, vout } = parseOutpoint(ord.outpoint)
+		const key = keyForOutput(ord, keyMap, payKey)
 		tx.addInput({
 			sourceTXID: txid,
 			sourceOutputIndex: vout,
 			sourceTransaction: await fetchSourceTx(txid),
 			unlockingScriptTemplate: p2pkh.unlock(key),
 			sequence: 0xffffffff,
-		});
+		})
 	}
 
 	for (const _ord of ordinals) {
 		tx.addOutput({
 			lockingScript: p2pkh.lock(destination),
 			satoshis: 1,
-		});
+		})
 	}
 
 	for (const utxo of funding) {
-		const { txid, vout } = parseOutpoint(utxo.outpoint);
-		const key = keyForOutput(utxo, keyMap, payKey);
+		const { txid, vout } = parseOutpoint(utxo.outpoint)
+		const key = keyForOutput(utxo, keyMap, payKey)
 		tx.addInput({
 			sourceTXID: txid,
 			sourceOutputIndex: vout,
 			sourceTransaction: await fetchSourceTx(txid),
 			unlockingScriptTemplate: p2pkh.unlock(key),
 			sequence: 0xffffffff,
-		});
+		})
 	}
 
 	tx.addOutput({
 		lockingScript: p2pkh.lock(sourceAddress),
 		change: true,
-	});
+	})
 
-	await tx.fee();
-	await tx.sign();
+	await tx.fee()
+	await tx.sign()
 
-	const rawTx = tx.toBinary();
-	const result = await getServices().arcade.submitTransaction(rawTx);
+	const rawTx = tx.toBinary()
+	const result = await getServices().arcade.submitTransaction(rawTx)
 
 	return {
 		txid: result.txid,
 		rawtx: Utils.toHex(rawTx),
-	};
+	}
 }
 
 export async function legacyBurnOrdinals(params: {
-	ordinals: IndexedOutput[];
-	funding: IndexedOutput[];
-	keys: LegacyKeys;
+	ordinals: IndexedOutput[]
+	funding: IndexedOutput[]
+	keys: LegacyKeys
 }): Promise<LegacySendResult> {
-	const { ordinals, funding, keys } = params;
-	if (!ordinals.length) throw new Error("No ordinals to burn");
+	const { ordinals, funding, keys } = params
+	if (!ordinals.length) throw new Error('No ordinals to burn')
 
-	const keyMap = buildKeyMap(keys);
-	const payKey = PrivateKey.fromWif(keys.payPk);
-	const sourceAddress = payKey.toPublicKey().toAddress();
-	const p2pkh = new P2PKH();
-	const tx = new Transaction();
+	const keyMap = buildKeyMap(keys)
+	const payKey = PrivateKey.fromWif(keys.payPk)
+	const sourceAddress = payKey.toPublicKey().toAddress()
+	const p2pkh = new P2PKH()
+	const tx = new Transaction()
 
 	for (const ord of ordinals) {
-		const { txid, vout } = parseOutpoint(ord.outpoint);
-		const key = keyForOutput(ord, keyMap, payKey);
+		const { txid, vout } = parseOutpoint(ord.outpoint)
+		const key = keyForOutput(ord, keyMap, payKey)
 		tx.addInput({
 			sourceTXID: txid,
 			sourceOutputIndex: vout,
 			sourceTransaction: await fetchSourceTx(txid),
 			unlockingScriptTemplate: p2pkh.unlock(key),
 			sequence: 0xffffffff,
-		});
+		})
 	}
 
 	for (const utxo of funding) {
-		const { txid, vout } = parseOutpoint(utxo.outpoint);
-		const key = keyForOutput(utxo, keyMap, payKey);
+		const { txid, vout } = parseOutpoint(utxo.outpoint)
+		const key = keyForOutput(utxo, keyMap, payKey)
 		tx.addInput({
 			sourceTXID: txid,
 			sourceOutputIndex: vout,
 			sourceTransaction: await fetchSourceTx(txid),
 			unlockingScriptTemplate: p2pkh.unlock(key),
 			sequence: 0xffffffff,
-		});
+		})
 	}
 
 	const burnScript = new Script()
 		.writeOpCode(OP.OP_FALSE)
 		.writeOpCode(OP.OP_RETURN)
 		.writeBin(Utils.toArray(MAP_PREFIX))
-		.writeBin(Utils.toArray("SET"))
-		.writeBin(Utils.toArray("app"))
-		.writeBin(Utils.toArray("1sat-sweep"))
-		.writeBin(Utils.toArray("type"))
-		.writeBin(Utils.toArray("ord"))
-		.writeBin(Utils.toArray("op"))
-		.writeBin(Utils.toArray("burn"));
-	tx.addOutput({ satoshis: 0, lockingScript: burnScript });
+		.writeBin(Utils.toArray('SET'))
+		.writeBin(Utils.toArray('app'))
+		.writeBin(Utils.toArray('1sat-sweep'))
+		.writeBin(Utils.toArray('type'))
+		.writeBin(Utils.toArray('ord'))
+		.writeBin(Utils.toArray('op'))
+		.writeBin(Utils.toArray('burn'))
+	tx.addOutput({ satoshis: 0, lockingScript: burnScript })
 
 	tx.addOutput({
 		lockingScript: p2pkh.lock(sourceAddress),
 		change: true,
-	});
+	})
 
-	await tx.fee();
-	await tx.sign();
+	await tx.fee()
+	await tx.sign()
 
-	const rawTx = tx.toBinary();
-	const result = await getServices().arcade.submitTransaction(rawTx);
+	const rawTx = tx.toBinary()
+	const result = await getServices().arcade.submitTransaction(rawTx)
 
 	return {
 		txid: result.txid,
 		rawtx: Utils.toHex(rawTx),
-	};
+	}
 }

package/src/lib/scanner.ts

@@ -1,85 +1,90 @@
-import { PrivateKey } from "@bsv/sdk";
-import type { IndexedOutput } from "@1sat/types";
 import {
-	scanAddresses as coreScanAddresses,
-	type ScanResult,
 	type ScanProgress,
+	type ScanResult,
 	type TokenBalance,
-} from "@1sat/actions";
-import { getServices } from "./services";
+	scanAddresses as coreScanAddresses,
+} from '@1sat/actions'
+import type { IndexedOutput } from '@1sat/types'
+import { PrivateKey } from '@bsv/sdk'
+import { getServices } from './services'
 
-export type { TokenBalance, ScanProgress, ScanResult };
+export type { TokenBalance, ScanProgress, ScanResult }
 
 export interface EnrichedOrdinal extends IndexedOutput {
-	origin?: string;
-	contentType?: string;
-	name?: string;
-	contentUrl: string;
+	origin?: string
+	contentType?: string
+	name?: string
+	contentUrl: string
 }
 
-export interface ScannedAssets extends Omit<ScanResult, "ordinals" | "opnsNames"> {
-	ordinals: EnrichedOrdinal[];
-	opnsNames: EnrichedOrdinal[];
-	bsv21Tokens: TokenBalance[];
-	totalBsv: number;
+export interface ScannedAssets
+	extends Omit<ScanResult, 'ordinals' | 'opnsNames'> {
+	ordinals: EnrichedOrdinal[]
+	opnsNames: EnrichedOrdinal[]
+	bsv21Tokens: TokenBalance[]
+	totalBsv: number
 }
 
 export function deriveAddress(wif: string): string {
-	return PrivateKey.fromWif(wif.trim()).toPublicKey().toAddress();
+	return PrivateKey.fromWif(wif.trim()).toPublicKey().toAddress()
 }
 
 function getEvent(events: string[], prefix: string): string | undefined {
-	const e = events.find((ev) => ev.startsWith(prefix));
-	return e ? e.slice(prefix.length) : undefined;
+	const e = events.find((ev) => ev.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));
+	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 });
+	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 };
+	return { ...out, origin, contentType, name, contentUrl }
 }
 
 function resolveIconUrl(tokenId: string, icon?: string): string {
-	if (!icon) return "";
-	let outpoint = icon;
-	if (icon.startsWith("_")) {
-		const txid = tokenId.split("_")[0];
-		outpoint = `${txid}${icon}`;
+	if (!icon) return ''
+	let outpoint = icon
+	if (icon.startsWith('_')) {
+		const txid = tokenId.split('_')[0]
+		outpoint = `${txid}${icon}`
 	}
-	return getServices().ordfs.getContentUrl(outpoint);
+	return getServices().ordfs.getContentUrl(outpoint)
 }
 
 function enrichTokenBalances(tokens: TokenBalance[]): TokenBalance[] {
 	return tokens.map((t) => ({
 		...t,
 		icon: resolveIconUrl(t.tokenId, t.icon),
-	}));
+	}))
 }
 
 export async function scanAddress(
 	address: string,
 	onProgress?: (p: ScanProgress) => void,
 ): Promise<ScannedAssets> {
-	const result = await coreScanAddresses(getServices(), [address], onProgress);
-	return toScannedAssets(result);
+	const result = await coreScanAddresses(getServices(), [address], onProgress)
+	return toScannedAssets(result)
 }
 
 export async function scanAddresses(
 	addresses: string[],
 	onProgress?: (p: ScanProgress) => void,
 ): Promise<ScannedAssets> {
-	const unique = [...new Set(addresses)];
-	const result = await coreScanAddresses(getServices(), unique, onProgress);
-	return toScannedAssets(result);
+	const unique = [...new Set(addresses)]
+	const result = await coreScanAddresses(getServices(), unique, onProgress)
+	return toScannedAssets(result)
 }
 
 function toScannedAssets(result: ScanResult): ScannedAssets {
@@ -93,5 +98,5 @@ function toScannedAssets(result: ScanResult): ScannedAssets {
 		run: result.run,
 		totalFundingSats: result.totalFundingSats,
 		totalBsv: result.totalFundingSats,
-	};
+	}
 }

package/src/lib/services.ts

@@ -1,18 +1,20 @@
-import { OneSatServices } from "@1sat/client";
+import { OneSatServices } from '@1sat/client'
 
-let _services: OneSatServices | null = null;
-let _baseUrl: string | undefined;
+let _services: OneSatServices | null = null
+let _baseUrl: string | undefined
 
 export function configureServices(baseUrl: string): void {
-	_baseUrl = baseUrl;
-	_services = null;
+	_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);
+		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;
+	return _services
 }