@1sat/sweep-ui 0.0.1

package/src/components/ui/input.tsx

@@ -0,0 +1,20 @@
+import * as React from "react"
+import { cn } from "../../lib/utils"
+
+function Input({ className, type, ...props }: React.ComponentProps<"input">) {
+	return (
+		<input
+			type={type}
+			data-slot="input"
+			className={cn(
+				"h-9 w-full min-w-0 rounded-md border border-input bg-transparent px-3 py-1 text-base shadow-xs transition-[color,box-shadow] outline-none selection:bg-primary selection:text-primary-foreground file:inline-flex file:h-7 file:border-0 file:bg-transparent file:text-sm file:font-medium file:text-foreground placeholder:text-muted-foreground disabled:pointer-events-none disabled:cursor-not-allowed disabled:opacity-50 md:text-sm dark:bg-input/30",
+				"focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50",
+				"aria-invalid:border-destructive aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40",
+				className
+			)}
+			{...props}
+		/>
+	)
+}
+
+export { Input }

package/src/components/ui/tabs.tsx

@@ -0,0 +1,51 @@
+import * as React from "react"
+import { cn } from "../../lib/utils"
+
+type TabsContextValue = {
+	value: string
+	onValueChange: (value: string) => void
+}
+
+const TabsContext = React.createContext<TabsContextValue | null>(null)
+
+function useTabsContext() {
+	const context = React.useContext(TabsContext)
+	if (!context) {
+		throw new Error("Tabs components must be used within a <Tabs> provider")
+	}
+	return context
+}
+
+function Tabs({ value, onValueChange, className, ...props }: React.ComponentProps<"div"> & { value: string; onValueChange: (value: string) => void }) {
+	return (
+		<TabsContext.Provider value={{ value, onValueChange }}>
+			<div data-slot="tabs" className={cn("flex flex-col gap-2", className)} {...props} />
+		</TabsContext.Provider>
+	)
+}
+
+function TabsList({ className, ...props }: React.ComponentProps<"div">) {
+	return (<div data-slot="tabs-list" className={cn("inline-flex h-9 items-center justify-start gap-1 rounded-lg bg-muted p-1 text-muted-foreground", className)} {...props} />)
+}
+
+function TabsTrigger({ value, className, ...props }: React.ComponentProps<"button"> & { value: string }) {
+	const context = useTabsContext()
+	const isActive = context.value === value
+	return (
+		<button
+			data-slot="tabs-trigger"
+			data-active={isActive ? "" : undefined}
+			className={cn("inline-flex items-center justify-center whitespace-nowrap rounded-md px-3 py-1 text-sm font-medium transition-all outline-none focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50 disabled:pointer-events-none disabled:opacity-50", isActive && "bg-background text-foreground shadow-sm", className)}
+			onClick={() => context.onValueChange(value)}
+			{...props}
+		/>
+	)
+}
+
+function TabsContent({ value, className, ...props }: React.ComponentProps<"div"> & { value: string }) {
+	const context = useTabsContext()
+	if (context.value !== value) return null
+	return (<div data-slot="tabs-content" className={cn("mt-2", className)} {...props} />)
+}
+
+export { Tabs, TabsList, TabsTrigger, TabsContent }

package/src/components/wif-input.tsx

@@ -0,0 +1,332 @@
+import { useCallback, useRef, useState } from "react";
+import { KeyRound, Loader2, Search, Upload, X } from "lucide-react";
+import { Button } from "./ui/button";
+import { Card, CardContent, CardHeader, CardTitle } from "./ui/card";
+import { Input } from "./ui/input";
+import {
+	decryptBackup,
+	isOneSatBackup,
+	isYoursWalletBackup,
+	isWifBackup,
+	getBackupType,
+	type DecryptedBackup,
+} from "bitcoin-backup";
+import { deriveAddress } from "../lib/scanner";
+import { deriveIdentityKey } from "@1sat/utils";
+import type { LegacyKeys } from "../types";
+
+interface Props {
+	onScan: (keys: LegacyKeys) => void;
+	scanning: boolean;
+	disabled: boolean;
+}
+
+type InputMode = "choose" | "backup" | "wif";
+
+function withIdentityKey(keys: LegacyKeys): LegacyKeys {
+	if (keys.identityPk) return keys;
+	return { ...keys, identityPk: deriveIdentityKey(keys.payPk, keys.ordPk).toWif() };
+}
+
+function extractKeys(backup: DecryptedBackup): LegacyKeys | null {
+	if (isOneSatBackup(backup)) {
+		return withIdentityKey({
+			payPk: backup.payPk,
+			ordPk: backup.ordPk,
+			identityPk: backup.identityPk,
+		});
+	}
+	if (isYoursWalletBackup(backup)) {
+		return withIdentityKey({
+			payPk: backup.payPk,
+			ordPk: backup.ordPk,
+			identityPk: backup.identityPk,
+		});
+	}
+	if (isWifBackup(backup)) {
+		return withIdentityKey({
+			payPk: backup.wif,
+			ordPk: backup.wif,
+		});
+	}
+	return null;
+}
+
+function tryParseBackup(text: string): LegacyKeys | null {
+	try {
+		const parsed = JSON.parse(text);
+		if (parsed.payPk && parsed.ordPk) {
+			return withIdentityKey({
+				payPk: parsed.payPk,
+				ordPk: parsed.ordPk,
+				identityPk: parsed.identityPk,
+			});
+		}
+		if (parsed.accounts && parsed.selectedAccount) {
+			const account = parsed.accounts[parsed.selectedAccount];
+			if (account?.encryptedKeys) {
+				return null;
+			}
+		}
+	} catch {
+		// Not JSON
+	}
+	return null;
+}
+
+function looksEncrypted(text: string): boolean {
+	if (text.startsWith("{")) return false;
+	if (text.startsWith("5") || text.startsWith("K") || text.startsWith("L")) return false;
+	return text.length > 50;
+}
+
+export function WifInput({ onScan, scanning, disabled }: Props) {
+	const [mode, setMode] = useState<InputMode>("choose");
+	const [keys, setKeys] = useState<LegacyKeys | null>(null);
+	const [backupText, setBackupText] = useState("");
+	const [password, setPassword] = useState("");
+	const [needsPassword, setNeedsPassword] = useState(false);
+	const [decrypting, setDecrypting] = useState(false);
+	const [error, setError] = useState("");
+	const [backupType, setBackupType] = useState("");
+	const fileInputRef = useRef<HTMLInputElement>(null);
+	const [payWif, setPayWif] = useState("");
+	const [ordWif, setOrdWif] = useState("");
+	const [sameKey, setSameKey] = useState(true);
+
+	const handleReset = useCallback(() => {
+		setKeys(null);
+		setBackupText("");
+		setPassword("");
+		setNeedsPassword(false);
+		setError("");
+		setBackupType("");
+		setMode("choose");
+		setPayWif("");
+		setOrdWif("");
+	}, []);
+
+	const processBackupText = useCallback(async (text: string) => {
+		setError("");
+		setBackupText(text);
+
+		const directKeys = tryParseBackup(text);
+		if (directKeys) {
+			setKeys(directKeys);
+			setBackupType("JSON");
+			return;
+		}
+
+		try {
+			const parsed = JSON.parse(text);
+			if (parsed.encryptedBackup) {
+				setBackupText(parsed.encryptedBackup);
+				setNeedsPassword(true);
+				return;
+			}
+			if (parsed.encryptedKeys) {
+				setBackupText(parsed.encryptedKeys);
+				setNeedsPassword(true);
+				return;
+			}
+			if (parsed.accounts && parsed.selectedAccount) {
+				const account = parsed.accounts[parsed.selectedAccount];
+				if (account?.encryptedKeys) {
+					setBackupText(account.encryptedKeys);
+					setNeedsPassword(true);
+					return;
+				}
+			}
+		} catch {
+			// Not JSON
+		}
+
+		if (looksEncrypted(text)) {
+			setNeedsPassword(true);
+			return;
+		}
+
+		setError("Unrecognized backup format");
+	}, []);
+
+	const handleDecrypt = useCallback(async () => {
+		if (!backupText || !password) return;
+		setDecrypting(true);
+		setError("");
+
+		try {
+			const decrypted = await decryptBackup(backupText, password);
+			const extracted = extractKeys(decrypted);
+			if (!extracted) {
+				setError(`Unsupported backup type: ${getBackupType(decrypted)}`);
+				return;
+			}
+			setKeys(extracted);
+			setBackupType(getBackupType(decrypted));
+			setNeedsPassword(false);
+		} catch (e) {
+			setError(e instanceof Error ? e.message : "Decryption failed");
+		} finally {
+			setDecrypting(false);
+		}
+	}, [backupText, password]);
+
+	const handleFileUpload = useCallback((e: React.ChangeEvent<HTMLInputElement>) => {
+		const file = e.target.files?.[0];
+		if (!file) return;
+		const reader = new FileReader();
+		reader.onload = () => {
+			processBackupText((reader.result as string).trim());
+		};
+		reader.readAsText(file);
+		e.target.value = "";
+	}, [processBackupText]);
+
+	const handleScan = useCallback(() => {
+		if (keys) {
+			onScan(keys);
+		} else if (mode === "wif") {
+			const pay = payWif.trim();
+			const ord = sameKey ? pay : ordWif.trim();
+			if (pay) onScan({ payPk: pay, ordPk: ord });
+		}
+	}, [keys, mode, payWif, ordWif, sameKey, onScan]);
+
+	if (keys) {
+		return (
+			<Card>
+				<CardHeader>
+					<div className="flex items-center justify-between">
+						<CardTitle className="flex items-center gap-2">
+							<KeyRound className="h-5 w-5" />
+							Legacy Keys
+						</CardTitle>
+						<Button variant="ghost" size="sm" className="h-6 w-6 p-0" onClick={handleReset}>
+							<X className="h-3 w-3" />
+						</Button>
+					</div>
+				</CardHeader>
+				<CardContent className="space-y-3">
+					{backupType && (
+						<span className="text-xs px-2 py-0.5 rounded bg-blue-500/20 text-blue-400">{backupType}</span>
+					)}
+					<div className="space-y-1 text-xs text-muted-foreground font-mono">
+						<div>Pay: {deriveAddress(keys.payPk)}</div>
+						{keys.ordPk !== keys.payPk && <div>Ord: {deriveAddress(keys.ordPk)}</div>}
+						{keys.identityPk && keys.identityPk !== keys.payPk && <div>ID: {deriveAddress(keys.identityPk)}</div>}
+					</div>
+					<Button onClick={handleScan} disabled={disabled || scanning} className="w-full">
+						{scanning ? <Loader2 className="h-4 w-4 animate-spin mr-2" /> : <Search className="h-4 w-4 mr-2" />}
+						{scanning ? "Scanning..." : "Scan for Assets"}
+					</Button>
+				</CardContent>
+			</Card>
+		);
+	}
+
+	if (mode === "choose") {
+		return (
+			<Card>
+				<CardHeader>
+					<CardTitle className="flex items-center gap-2">
+						<KeyRound className="h-5 w-5" />
+						Legacy Keys
+					</CardTitle>
+				</CardHeader>
+				<CardContent className="space-y-3">
+					<input ref={fileInputRef} type="file" accept=".json,.bep,.txt" className="hidden" onChange={handleFileUpload} />
+					<Button variant="outline" className="w-full gap-2" onClick={() => fileInputRef.current?.click()}>
+						<Upload className="h-4 w-4" />
+						Import Backup File
+					</Button>
+					<Button variant="outline" className="w-full gap-2" onClick={() => setMode("backup")}>
+						Paste Backup Data
+					</Button>
+					<Button variant="ghost" className="w-full text-xs text-muted-foreground" onClick={() => setMode("wif")}>
+						Enter WIF keys manually
+					</Button>
+				</CardContent>
+			</Card>
+		);
+	}
+
+	if (mode === "backup") {
+		return (
+			<Card>
+				<CardHeader>
+					<div className="flex items-center justify-between">
+						<CardTitle className="flex items-center gap-2">
+							<KeyRound className="h-5 w-5" />
+							Import Backup
+						</CardTitle>
+						<Button variant="ghost" size="sm" className="h-6 w-6 p-0" onClick={handleReset}>
+							<X className="h-3 w-3" />
+						</Button>
+					</div>
+				</CardHeader>
+				<CardContent className="space-y-3">
+					{!needsPassword ? (
+						<>
+							<textarea
+								placeholder="Paste backup JSON or encrypted data..."
+								className="w-full h-24 rounded-md border border-input bg-transparent px-3 py-2 text-sm font-mono resize-none focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50"
+								onChange={(e) => processBackupText(e.target.value.trim())}
+							/>
+							<input ref={fileInputRef} type="file" accept=".json,.bep,.txt" className="hidden" onChange={handleFileUpload} />
+							<Button variant="outline" size="sm" className="w-full gap-2" onClick={() => fileInputRef.current?.click()}>
+								<Upload className="h-4 w-4" />
+								Or upload a file
+							</Button>
+						</>
+					) : (
+						<>
+							<p className="text-sm text-muted-foreground">This backup is encrypted. Enter the password to decrypt.</p>
+							<Input type="password" placeholder="Backup password..." value={password} onChange={(e) => setPassword(e.target.value)} onKeyDown={(e) => { if (e.key === "Enter") handleDecrypt(); }} />
+							<Button onClick={handleDecrypt} disabled={!password || decrypting} className="w-full">
+								{decrypting ? <Loader2 className="h-4 w-4 animate-spin mr-2" /> : null}
+								{decrypting ? "Decrypting..." : "Decrypt"}
+							</Button>
+						</>
+					)}
+					{error && <p className="text-sm text-destructive">{error}</p>}
+				</CardContent>
+			</Card>
+		);
+	}
+
+	return (
+		<Card>
+			<CardHeader>
+				<div className="flex items-center justify-between">
+					<CardTitle className="flex items-center gap-2">
+						<KeyRound className="h-5 w-5" />
+						Manual WIF Entry
+					</CardTitle>
+					<Button variant="ghost" size="sm" className="h-6 w-6 p-0" onClick={handleReset}>
+						<X className="h-3 w-3" />
+					</Button>
+				</div>
+			</CardHeader>
+			<CardContent className="space-y-4">
+				<div className="space-y-2">
+					<label className="text-sm font-medium">{sameKey ? "Private Key (WIF)" : "Pay Key (WIF)"}</label>
+					<Input type="password" placeholder="Enter WIF private key..." value={payWif} onChange={(e) => setPayWif(e.target.value)} disabled={disabled || scanning} />
+				</div>
+				<label className="flex items-center gap-2 text-sm">
+					<input type="checkbox" checked={sameKey} onChange={(e) => setSameKey(e.target.checked)} disabled={disabled || scanning} />
+					Same key for pay and ordinals
+				</label>
+				{!sameKey && (
+					<div className="space-y-2">
+						<label className="text-sm font-medium">Ordinals Key (WIF)</label>
+						<Input type="password" placeholder="Enter ordinals WIF..." value={ordWif} onChange={(e) => setOrdWif(e.target.value)} disabled={disabled || scanning} />
+					</div>
+				)}
+				<Button onClick={handleScan} disabled={disabled || scanning || !payWif.trim()} className="w-full">
+					{scanning ? <Loader2 className="h-4 w-4 animate-spin mr-2" /> : <Search className="h-4 w-4 mr-2" />}
+					{scanning ? "Scanning..." : "Scan for Assets"}
+				</Button>
+			</CardContent>
+		</Card>
+	);
+}

package/src/index.ts

@@ -0,0 +1,28 @@
+// Main app component
+export { SweepApp, type SweepAppProps } from "./components/SweepApp";
+
+// Feature components
+export { ConnectWallet } from "./components/connect-wallet";
+export { WifInput } from "./components/wif-input";
+export { FundingSection, OrdinalsSection, Bsv21Section, Bsv20Section, LockedSection } from "./components/asset-preview";
+export { OpnsSection } from "./components/opns-section";
+export { TxHistory, type TxRecord } from "./components/tx-history";
+export { SweepProgress } from "./components/sweep-progress";
+
+// UI primitives
+export { Badge, badgeVariants } from "./components/ui/badge";
+export { Button, buttonVariants } from "./components/ui/button";
+export { Card, CardHeader, CardFooter, CardTitle, CardAction, CardDescription, CardContent } from "./components/ui/card";
+export { Input } from "./components/ui/input";
+export { Tabs, TabsList, TabsTrigger, TabsContent } from "./components/ui/tabs";
+
+// Lib
+export { configureServices, getServices } from "./lib/services";
+export { connectWallet, getWallet, getIdentityKey, getProvider, disconnectWallet, isConnected } from "./lib/wallet";
+export { deriveAddress, scanAddress, scanAddresses, type ScannedAssets, type EnrichedOrdinal, type TokenBalance, type ScanProgress } from "./lib/scanner";
+export { executeSweep, type SweepResult } from "./lib/sweeper";
+export { legacySendBsv, legacySendOrdinals, legacyBurnOrdinals, type LegacySendResult } from "./lib/legacy-send";
+export { cn, formatSats, formatTokenAmount, truncate } from "./lib/utils";
+
+// Types
+export type { LegacyKeys } from "./types";

package/src/lib/legacy-send.ts

@@ -0,0 +1,234 @@
+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";
+
+export interface LegacySendResult {
+	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;
+}
+
+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);
+	if (keys.identityPk) {
+		map.set(deriveAddress(keys.identityPk), PrivateKey.fromWif(keys.identityPk));
+	}
+	return map;
+}
+
+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;
+			}
+		}
+	}
+	return fallback;
+}
+
+export async function legacySendBsv(params: {
+	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 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);
+		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();
+
+	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;
+}): 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 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);
+		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);
+		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();
+
+	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;
+}): Promise<LegacySendResult> {
+	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();
+
+	for (const ord of ordinals) {
+		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);
+		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 });
+
+	tx.addOutput({
+		lockingScript: p2pkh.lock(sourceAddress),
+		change: true,
+	});
+
+	await tx.fee();
+	await tx.sign();
+
+	const rawTx = tx.toBinary();
+	const result = await getServices().arcade.submitTransaction(rawTx);
+
+	return {
+		txid: result.txid,
+		rawtx: Utils.toHex(rawTx),
+	};
+}