@1sat/sweep-ui 0.0.96 → 0.0.98

package/dist/index.js

@@ -277,26 +277,46 @@ async function legacyBurnOrdinals(params) {
 // src/lib/sweeper.ts
 import {
   SWEEP_BATCH_SIZE,
+  bsv20SweepBatches,
   bsv21SweepBatches,
   createContext,
   groupBsv20Tokens,
+  isListedOutput,
   prepareSweepInputs,
   sweepBsv,
   sweepBsv20,
   sweepBsv21,
   sweepOrdinals
 } from "@1sat/actions";
-function getOwner(output) {
-  return output.events?.find((e) => e.startsWith("own:"))?.slice(4);
+import { formatOutpoint, parseOutpoint as parseOutpoint2 } from "@1sat/utils";
+function selectAllSweepClasses(assets) {
+  return {
+    sweepBsv: assets.funding.length > 0,
+    ordinalOutpoints: new Set(assets.ordinals.map((o) => o.outpoint)),
+    opnsOutpoints: new Set(assets.opnsNames.map((o) => o.outpoint)),
+    bsv20Ticks: new Set(groupBsv20Tokens(assets.bsv20Tokens).map((t) => t.tick)),
+    bsv21TokenIds: new Set(assets.bsv21Tokens.filter((t) => t.outputs.length > 0).map((t) => t.tokenId))
+  };
+}
+function isSweepAllDisabled(available, skipped) {
+  return available.every((id) => skipped.has(id));
+}
+function showClassSkips(available, skipped) {
+  return available.length > 1 || skipped.size > 0;
+}
+function normalizeOutpoint(outpoint) {
+  const { txid, vout } = parseOutpoint2(outpoint);
+  return formatOutpoint(txid, vout);
 }
 function buildKeys(outputs, keyMap, inputs = outputs) {
-  const owners = new Map(outputs.map((output) => [output.outpoint, getOwner(output)]));
+  const byOutpoint = new Map(outputs.map((output) => [normalizeOutpoint(output.outpoint), output]));
   return inputs.map(({ outpoint }) => {
-    const owner = owners.get(outpoint);
-    const key = owner ? keyMap.get(owner) : undefined;
-    if (!key)
-      throw new Error(`No key for output ${outpoint} (owner: ${owner})`);
-    return key;
+    const output = byOutpoint.get(normalizeOutpoint(outpoint));
+    const owners = new Set((output?.events ?? []).filter((e) => e.startsWith("own:")).map((e) => e.slice(4)));
+    const matches = [...owners].filter((owner) => keyMap.has(owner));
+    if (matches.length !== 1)
+      throw new Error(`No key for output ${outpoint} (owner: ${[...owners].join(",") || "unknown"})`);
+    return keyMap.get(matches[0]);
   });
 }
 function chunk(items, size) {
@@ -314,63 +334,147 @@ async function executeSweep(params) {
     bsv20Txids: [],
     bsv21Txids: [],
     errors: [],
-    sweptOutpoints: []
+    sweptOutpoints: [],
+    cancelledListings: []
   };
-  if (funding.length > 0) {
-    onProgress(`Sweeping ${funding.length} BSV UTXOs...`);
+  const fundingStep = await sweepFundingStep({
+    ctx,
+    keys,
+    funding,
+    amount,
+    completed: params.completed,
+    signal: params.signal,
+    onProgress,
+    onResult: params.onResult
+  });
+  if (fundingStep.bsvTxid)
+    result.bsvTxid = fundingStep.bsvTxid;
+  if (fundingStep.error)
+    result.errors.push(fundingStep.error);
+  const ordinalBatches = await sweepOrdinalBatches({
+    ctx,
+    keys,
+    ordinals,
+    sweepClass: "ordinals",
+    completed: params.completed,
+    signal: params.signal,
+    onProgress,
+    onResult: params.onResult
+  });
+  result.ordinalTxids.push(...ordinalBatches.txids);
+  result.sweptOutpoints.push(...ordinalBatches.swept);
+  result.errors.push(...ordinalBatches.errors);
+  result.cancelledListings.push(...cancelledIn(funding, fundingStep.swept), ...cancelledIn(ordinals, ordinalBatches.swept));
+  onProgress(result.errors.length > 0 ? "Sweep stopped with errors" : "Sweep complete");
+  return result;
+}
+function isCompleted(completed, outpoint) {
+  if (!completed)
+    return false;
+  return completed.has(normalizeOutpoint(outpoint));
+}
+function cancelledIn(outputs, swept) {
+  const done = new Set(swept.map(normalizeOutpoint));
+  return outputs.filter((o) => done.has(normalizeOutpoint(o.outpoint)) && isListedOutput(o)).map((o) => o.outpoint);
+}
+function markCompleted(completed, outputs) {
+  if (!completed)
+    return;
+  for (const output of outputs)
+    completed.add(normalizeOutpoint(output.outpoint));
+}
+async function sweepFundingStep(options) {
+  const { ctx, keys, amount, completed, signal, onProgress, onResult } = options;
+  const pending = options.funding.filter((o) => !isCompleted(completed, o.outpoint));
+  if (pending.length === 0)
+    return { swept: [] };
+  signal?.throwIfAborted();
+  onProgress(`Sweeping ${pending.length} BSV UTXOs...`);
+  try {
+    const inputs = await prepareSweepInputs(ctx, pending);
+    const bsvResult = await sweepBsv.execute(ctx, {
+      inputs,
+      keys: buildKeys(pending, keys, inputs),
+      amount
+    });
+    if (bsvResult.error)
+      throw new Error(bsvResult.error);
+    const txid = bsvResult.txid?.trim();
+    if (!txid)
+      throw new Error("Sweep returned no transaction ID");
+    markCompleted(completed, pending);
+    onResult?.({ sweepClass: "bsv", label: "BSV", txid });
+    return { bsvTxid: txid, swept: pending.map((o) => o.outpoint) };
+  } catch (e) {
+    if (signal?.aborted)
+      throw e;
+    const error = e instanceof Error ? e.message : String(e);
+    onResult?.({ sweepClass: "bsv", label: "BSV", error });
+    return { error: `BSV: ${error}`, swept: [] };
+  }
+}
+var ORDINAL_CLASS_LABEL = {
+  ordinals: "Ordinals",
+  opns: "OpNS"
+};
+async function sweepOrdinalBatches(options) {
+  const { ctx, keys, sweepClass, completed, signal, onProgress, onResult } = options;
+  const label = ORDINAL_CLASS_LABEL[sweepClass];
+  const singular = sweepClass === "opns" ? "OpNS name" : "ordinal";
+  const txids = [];
+  const swept = [];
+  const errors = [];
+  const pending = options.ordinals.filter((o) => !isCompleted(completed, o.outpoint));
+  if (pending.length === 0)
+    return { txids, swept, errors };
+  const batches = chunk(pending, SWEEP_BATCH_SIZE);
+  for (let b = 0;b < batches.length; b++) {
+    signal?.throwIfAborted();
+    const batch = batches[b];
+    const from = b * SWEEP_BATCH_SIZE + 1;
+    const to = b * SWEEP_BATCH_SIZE + batch.length;
+    const batchLabel = batches.length === 1 ? label : `${label} (${from}–${to} of ${pending.length})`;
+    onProgress(batches.length === 1 ? `Sweeping ${batch.length} ${singular}${batch.length !== 1 ? "s" : ""}...` : `Sweeping ${singular}s ${from}–${to} of ${pending.length} (batch ${b + 1}/${batches.length})...`);
     try {
-      const inputs = await prepareSweepInputs(ctx, funding);
-      const bsvResult = await sweepBsv.execute(ctx, {
+      const inputs = await prepareSweepInputs(ctx, batch);
+      const ordResult = await sweepOrdinals.execute(ctx, {
         inputs,
-        keys: buildKeys(funding, keys, inputs),
-        amount
+        keys: buildKeys(batch, keys, inputs)
       });
-      if (bsvResult.error)
-        throw new Error(bsvResult.error);
-      const txid = bsvResult.txid?.trim();
+      if (ordResult.error)
+        throw new Error(ordResult.error);
+      const txid = ordResult.txid?.trim();
       if (!txid)
         throw new Error("Sweep returned no transaction ID");
-      result.bsvTxid = txid;
+      txids.push(txid);
+      swept.push(...batch.map((o) => o.outpoint));
+      markCompleted(completed, batch);
+      onResult?.({ sweepClass, label: batchLabel, txid });
     } catch (e) {
-      result.errors.push(`BSV: ${e instanceof Error ? e.message : String(e)}`);
-    }
-  }
-  if (ordinals.length > 0) {
-    const batches = chunk(ordinals, SWEEP_BATCH_SIZE);
-    for (let b = 0;b < batches.length; b++) {
-      const batch = batches[b];
-      const from = b * SWEEP_BATCH_SIZE + 1;
-      const to = b * SWEEP_BATCH_SIZE + batch.length;
-      onProgress(batches.length === 1 ? `Sweeping ${batch.length} ordinal${batch.length !== 1 ? "s" : ""}...` : `Sweeping ordinals ${from}–${to} of ${ordinals.length} (batch ${b + 1}/${batches.length})...`);
-      try {
-        const inputs = await prepareSweepInputs(ctx, batch);
-        const ordResult = await sweepOrdinals.execute(ctx, {
-          inputs,
-          keys: buildKeys(batch, keys, inputs)
-        });
-        if (ordResult.error)
-          throw new Error(ordResult.error);
-        const txid = ordResult.txid?.trim();
-        if (!txid)
-          throw new Error("Sweep returned no transaction ID");
-        result.ordinalTxids.push(txid);
-        result.sweptOutpoints.push(...batch.map((o) => o.outpoint));
-      } catch (e) {
-        result.errors.push(`Ordinals batch ${b + 1}/${batches.length}: ${e instanceof Error ? e.message : String(e)}`);
-        break;
-      }
+      if (signal?.aborted)
+        throw e;
+      const error = e instanceof Error ? e.message : String(e);
+      errors.push(`${label} batch ${b + 1}/${batches.length}: ${error}`);
+      onResult?.({ sweepClass, label: batchLabel, error });
+      break;
     }
   }
-  onProgress(result.errors.length > 0 ? "Sweep stopped with errors" : "Sweep complete");
-  return result;
+  return { txids, swept, errors };
 }
 async function sweepBsv21Token(params) {
-  const { wallet, keys, token, onProgress } = params;
+  const { wallet, keys, token, onProgress, signal, completed, onResult } = params;
   const ctx = createContext(wallet, { services: getServices(), chain: "main" });
   const txids = [];
+  const sweptOutpoints = [];
   const errors = [];
   const name = token.symbol ?? token.tokenId.slice(0, 8);
-  for (const batch of bsv21SweepBatches(token.outputs)) {
+  const amounts = new Map([...token.amounts].map(([outpoint, amount]) => [
+    normalizeOutpoint(outpoint),
+    amount
+  ]));
+  const outputs = token.outputs.filter((o) => !isCompleted(completed, o.outpoint));
+  for (const batch of bsv21SweepBatches(outputs)) {
+    signal?.throwIfAborted();
     onProgress(`Sweeping ${name}...`);
     try {
       const sweepInputs = await prepareSweepInputs(ctx, batch);
@@ -382,7 +486,7 @@ async function sweepBsv21Token(params) {
         return {
           ...base,
           tokenId: token.tokenId,
-          amount: token.amounts.get(out.outpoint) ?? "0"
+          amount: amounts.get(normalizeOutpoint(out.outpoint)) ?? "0"
         };
       });
       const result = await sweepBsv21.execute(ctx, {
@@ -391,103 +495,197 @@ async function sweepBsv21Token(params) {
       });
       if (result.error)
         errors.push(result.error);
-      else if (result.txid)
+      else if (result.txid) {
         txids.push(result.txid);
+        sweptOutpoints.push(...batch.map((o) => o.outpoint));
+        markCompleted(completed, batch);
+        onResult?.({ sweepClass: "bsv21", label: name, txid: result.txid });
+      }
     } catch (e) {
+      if (signal?.aborted)
+        throw e;
       errors.push(e instanceof Error ? e.message : String(e));
     }
   }
   return {
     txid: txids.at(-1),
     txids,
+    sweptOutpoints,
+    cancelledListings: cancelledIn(outputs, sweptOutpoints),
     error: errors[0]
   };
 }
 async function sweepBsv20Token(params) {
-  const { wallet, keys, token, onProgress } = params;
+  const {
+    wallet,
+    keys,
+    token,
+    onProgress,
+    signal,
+    splitListed,
+    completed,
+    onResult
+  } = params;
   const ctx = createContext(wallet, { services: getServices(), chain: "main" });
-  onProgress(`Sweeping ${token.tick}...`);
-  try {
-    const sweepInputs = await prepareSweepInputs(ctx, token.outputs);
-    const sweepInputMap = new Map(sweepInputs.map((s) => [s.outpoint, s]));
-    const inputs = token.outputs.map((out) => {
-      const base = sweepInputMap.get(out.outpoint);
-      if (!base)
-        throw new Error(`Missing sweep input for ${out.outpoint}`);
-      return {
-        ...base,
-        tick: token.tick,
-        amount: token.amounts.get(out.outpoint) ?? "0"
-      };
-    });
-    const result = await sweepBsv20.execute(ctx, {
-      inputs,
-      keys: buildKeys(token.outputs, keys)
-    });
-    if (result.error)
-      return { error: result.error };
-    return { txid: result.txid };
-  } catch (e) {
-    return { error: e instanceof Error ? e.message : String(e) };
+  const txids = [];
+  const sweptOutpoints = [];
+  const errors = [];
+  const amounts = new Map([...token.amounts].map(([outpoint, amount]) => [
+    normalizeOutpoint(outpoint),
+    amount
+  ]));
+  const outputs = token.outputs.filter((o) => !isCompleted(completed, o.outpoint));
+  if (outputs.length === 0)
+    return { txids: [], sweptOutpoints: [], cancelledListings: [] };
+  const batches = splitListed ? bsv20SweepBatches(outputs) : [outputs];
+  for (const batch of batches) {
+    signal?.throwIfAborted();
+    onProgress(`Sweeping ${token.tick}...`);
+    try {
+      const sweepInputs = await prepareSweepInputs(ctx, batch);
+      const sweepInputMap = new Map(sweepInputs.map((s) => [s.outpoint, s]));
+      const inputs = batch.map((out) => {
+        const base = sweepInputMap.get(out.outpoint);
+        if (!base)
+          throw new Error(`Missing sweep input for ${out.outpoint}`);
+        return {
+          ...base,
+          tick: token.tick,
+          amount: amounts.get(normalizeOutpoint(out.outpoint)) ?? "0"
+        };
+      });
+      const result = await sweepBsv20.execute(ctx, {
+        inputs,
+        keys: buildKeys(batch, keys)
+      });
+      if (result.error)
+        errors.push(result.error);
+      else if (result.txid) {
+        txids.push(result.txid);
+        sweptOutpoints.push(...batch.map((o) => o.outpoint));
+        markCompleted(completed, batch);
+        onResult?.({
+          sweepClass: "bsv20",
+          label: token.tick,
+          txid: result.txid
+        });
+      }
+    } catch (e) {
+      if (signal?.aborted)
+        throw e;
+      errors.push(e instanceof Error ? e.message : String(e));
+    }
   }
+  return {
+    txid: txids.at(-1),
+    txids,
+    sweptOutpoints,
+    cancelledListings: cancelledIn(outputs, sweptOutpoints),
+    error: errors[0]
+  };
 }
 async function sweepAllClasses(params) {
   const { wallet, keys, assets, amount, onProgress } = params;
+  const selection = params.selection ?? selectAllSweepClasses(assets);
+  const completed = params.completed;
+  const signal = params.signal;
+  const onResult = params.onResult;
+  const ctx = createContext(wallet, { services: getServices(), chain: "main" });
   const result = {
     ordinalTxids: [],
     bsv20Txids: [],
     bsv21Txids: [],
     errors: [],
-    sweptOutpoints: []
+    sweptOutpoints: [],
+    cancelledListings: []
   };
-  const first = await executeSweep({
-    wallet,
-    keys,
-    funding: assets.funding,
-    ordinals: assets.ordinals,
-    amount,
-    onProgress
-  });
-  result.bsvTxid = first.bsvTxid;
-  result.ordinalTxids.push(...first.ordinalTxids);
-  result.sweptOutpoints.push(...first.sweptOutpoints);
-  result.errors.push(...first.errors);
-  if (assets.opnsNames.length > 0) {
-    const opns = await executeSweep({
-      wallet,
+  signal?.throwIfAborted();
+  if (selection.sweepBsv) {
+    const fundingStep = await sweepFundingStep({
+      ctx,
       keys,
-      funding: [],
-      ordinals: assets.opnsNames,
-      onProgress
+      funding: assets.funding,
+      amount,
+      completed,
+      signal,
+      onProgress,
+      onResult
     });
-    result.ordinalTxids.push(...opns.ordinalTxids);
-    result.sweptOutpoints.push(...opns.sweptOutpoints);
-    result.errors.push(...opns.errors);
+    if (fundingStep.bsvTxid)
+      result.bsvTxid = fundingStep.bsvTxid;
+    if (fundingStep.error)
+      result.errors.push(fundingStep.error);
+    result.cancelledListings.push(...cancelledIn(assets.funding, fundingStep.swept));
+  }
+  const inSelection = (outpoints) => (o) => [...outpoints].some((selected) => normalizeOutpoint(selected) === normalizeOutpoint(o.outpoint));
+  for (const [sweepClass, outputs] of [
+    [
+      "ordinals",
+      assets.ordinals.filter(inSelection(selection.ordinalOutpoints))
+    ],
+    ["opns", assets.opnsNames.filter(inSelection(selection.opnsOutpoints))]
+  ]) {
+    signal?.throwIfAborted();
+    if (outputs.length === 0)
+      continue;
+    const batches = await sweepOrdinalBatches({
+      ctx,
+      keys,
+      ordinals: outputs,
+      sweepClass,
+      completed,
+      signal,
+      onProgress,
+      onResult
+    });
+    result.ordinalTxids.push(...batches.txids);
+    result.sweptOutpoints.push(...batches.swept);
+    result.errors.push(...batches.errors);
+    result.cancelledListings.push(...cancelledIn(outputs, batches.swept));
   }
   for (const token of groupBsv20Tokens(assets.bsv20Tokens)) {
+    signal?.throwIfAborted();
+    if (!selection.bsv20Ticks.has(token.tick))
+      continue;
     const swept = await sweepBsv20Token({
       wallet,
       keys,
       token,
-      onProgress
+      onProgress,
+      signal,
+      splitListed: params.splitListedBsv20,
+      completed,
+      onResult
     });
-    if (swept.error)
+    result.bsv20Txids.push(...swept.txids);
+    result.cancelledListings.push(...swept.cancelledListings);
+    if (swept.error) {
       result.errors.push(`BSV-20 ${token.tick}: ${swept.error}`);
-    else if (swept.txid)
-      result.bsv20Txids.push(swept.txid);
+      onResult?.({ sweepClass: "bsv20", label: token.tick, error: swept.error });
+    }
   }
   for (const token of assets.bsv21Tokens) {
-    if (token.outputs.length === 0)
+    signal?.throwIfAborted();
+    if (!selection.bsv21TokenIds.has(token.tokenId))
       continue;
     const swept = await sweepBsv21Token({
       wallet,
       keys,
       token,
-      onProgress
+      onProgress,
+      signal,
+      completed,
+      onResult
     });
     result.bsv21Txids.push(...swept.txids);
+    result.cancelledListings.push(...swept.cancelledListings);
     if (swept.error) {
       result.errors.push(`BSV-21 ${token.symbol ?? token.tokenId.slice(0, 8)}: ${swept.error}`);
+      onResult?.({
+        sweepClass: "bsv21",
+        label: token.symbol ?? token.tokenId,
+        error: swept.error
+      });
     }
   }
   onProgress(result.errors.length > 0 ? "Sweep stopped with errors" : "Sweep complete");
@@ -524,7 +722,7 @@ function isConnected() {
 }
 
 // src/components/asset-preview.tsx
-import { isListedOutput } from "@1sat/actions";
+import { isListedOutput as isListedOutput2 } from "@1sat/actions";
 import { useState } from "react";
 
 // src/lib/utils.ts
@@ -681,7 +879,7 @@ function OrdinalCard({
       /* @__PURE__ */ jsxs("div", {
         className: "min-h-[2rem] flex flex-col justify-end",
         children: [
-          isListedOutput(ordinal) && /* @__PURE__ */ jsx4("div", {
+          isListedOutput2(ordinal) && /* @__PURE__ */ jsx4("div", {
             className: "mb-1",
             children: /* @__PURE__ */ jsx4("span", {
               className: "inline-block px-1 py-0.5 text-[9px] rounded bg-amber-500/20 text-amber-400",
@@ -1046,7 +1244,7 @@ function TokenRow({
   onSweep,
   walletConnected
 }) {
-  const listed = tb.outputs.filter(isListedOutput).length;
+  const listed = tb.outputs.filter(isListedOutput2).length;
   return /* @__PURE__ */ jsxs("div", {
     className: `flex items-center justify-between p-3 rounded-lg border ${tb.isActive ? "bg-muted/30 border-purple-500/10" : "bg-muted/20 border-muted/20 opacity-60"}`,
     children: [
@@ -1199,7 +1397,7 @@ function Bsv20Section({
       /* @__PURE__ */ jsx4("div", {
         className: "space-y-3",
         children: tokens.map((tb) => {
-          const listed = tb.outputs.filter(isListedOutput).length;
+          const listed = tb.outputs.filter(isListedOutput2).length;
           return /* @__PURE__ */ jsxs("div", {
             className: "flex items-center justify-between p-3 rounded-lg border bg-muted/30 border-teal-500/10",
             children: [
@@ -1394,7 +1592,7 @@ function ConnectWallet({
 }
 
 // src/components/opns-section.tsx
-import { isListedOutput as isListedOutput2 } from "@1sat/actions";
+import { isListedOutput as isListedOutput3 } from "@1sat/actions";
 import { useEffect, useState as useState3 } from "react";
 import { jsx as jsx6, jsxs as jsxs3 } from "react/jsx-runtime";
 function OpnsSection({
@@ -1556,7 +1754,7 @@ function OpnsSection({
                 className: "text-sm text-foreground truncate",
                 children: displayName
               }),
-              isListedOutput2(item) && /* @__PURE__ */ jsx6("span", {
+              isListedOutput3(item) && /* @__PURE__ */ jsx6("span", {
                 className: "shrink-0 text-[10px] font-medium px-1.5 py-0.5 rounded bg-amber-500/20 text-amber-400",
                 children: "listed"
               }),
@@ -1670,7 +1868,12 @@ function OpnsSection({
 import { ExternalLink, Loader2 as Loader22 } from "lucide-react";
 import { jsx as jsx7, jsxs as jsxs4, Fragment } from "react/jsx-runtime";
 var EXPLORER_BASE = "https://bananablocks.com/tx/";
-function TxHistory({ sweeping, progress, history }) {
+function TxHistory({
+  sweeping,
+  progress,
+  history,
+  cancelledListings = 0
+}) {
   return /* @__PURE__ */ jsxs4(Fragment, {
     children: [
       sweeping && /* @__PURE__ */ jsxs4("div", {
@@ -1697,7 +1900,17 @@ function TxHistory({ sweeping, progress, history }) {
             children: [
               "Transactions (",
               history.length,
-              ")"
+              ")",
+              cancelledListings > 0 && /* @__PURE__ */ jsxs4("span", {
+                children: [
+                  " ",
+                  "· ",
+                  cancelledListings,
+                  " listing",
+                  cancelledListings !== 1 ? "s" : "",
+                  " canceled"
+                ]
+              })
             ]
           }),
           /* @__PURE__ */ jsx7("div", {
@@ -2368,10 +2581,12 @@ function SweepApp({
   const [sweeping, setSweeping] = useState5(false);
   const [sweepProgress, setSweepProgress] = useState5("");
   const [txHistory, setTxHistory] = useState5([]);
+  const [cancelledListings, setCancelledListings] = useState5(0);
   const [selectedOrdinals, setSelectedOrdinals] = useState5(new Set);
   const [selectedOpns, setSelectedOpns] = useState5(new Set);
   const [sweepAmount, setSweepAmount] = useState5(null);
   const [activeTab, setActiveTab] = useState5("ordinals");
+  const [skippedClasses, setSkippedClasses] = useState5(new Set);
   useEffect2(() => {
     setWalletConnected(!!externalWallet);
   }, [externalWallet]);
@@ -2395,6 +2610,10 @@ function SweepApp({
       { label, txid, timestamp: new Date, error }
     ]);
   }, []);
+  const addCancelled = useCallback2((count) => {
+    if (count > 0)
+      setCancelledListings((prev) => prev + count);
+  }, []);
   const groupedBsv20 = useMemo(() => assets ? groupBsv20Tokens2(assets.bsv20Tokens) : [], [assets]);
   const unparsedBsv20 = assets ? assets.bsv20Tokens.length - groupedBsv20.reduce((n, t) => n + t.outputs.length, 0) : 0;
   const tabs = useMemo(() => {
@@ -2476,6 +2695,7 @@ function SweepApp({
     setAssets(null);
     setSelectedOrdinals(new Set);
     setSelectedOpns(new Set);
+    setSkippedClasses(new Set);
     setSweepAmount(null);
     setLegacyKeys(keys);
     try {
@@ -2560,6 +2780,7 @@ function SweepApp({
       });
       if (result.errors.length > 0)
         throw new Error(result.errors[0]);
+      addCancelled(result.cancelledListings.length);
       return result.bsvTxid ?? "";
     });
   }, [
@@ -2569,7 +2790,8 @@ function SweepApp({
     sweepAmount,
     getSelectedFunding,
     runOperation,
-    keyMap
+    keyMap,
+    addCancelled
   ]);
   const handleSendBsv = useCallback2(async (destination) => {
     if (!legacyKeys || !assets)
@@ -2611,12 +2833,21 @@ function SweepApp({
           await refreshAssets();
         throw new Error(result.errors[0]);
       }
+      addCancelled(result.cancelledListings.length);
       for (let i = 0;i < result.ordinalTxids.length - 1; i++) {
         addTx(label, result.ordinalTxids[i]);
       }
       return result.ordinalTxids[result.ordinalTxids.length - 1] ?? "";
     });
-  }, [resolveWallet, legacyKeys, keyMap, runOperation, addTx, refreshAssets]);
+  }, [
+    resolveWallet,
+    legacyKeys,
+    keyMap,
+    runOperation,
+    addTx,
+    addCancelled,
+    refreshAssets
+  ]);
   const handleSweepOrdinals = useCallback2(async () => {
     if (!assets)
       return;
@@ -2688,12 +2919,21 @@ function SweepApp({
           await refreshAssets();
         throw new Error(result.errors[0]);
       }
+      addCancelled(result.cancelledListings.length);
       for (let i = 0;i < result.ordinalTxids.length - 1; i++) {
         addTx(label, result.ordinalTxids[i]);
       }
       return result.ordinalTxids[result.ordinalTxids.length - 1] ?? "";
     });
-  }, [resolveWallet, legacyKeys, keyMap, runOperation, addTx, refreshAssets]);
+  }, [
+    resolveWallet,
+    legacyKeys,
+    keyMap,
+    runOperation,
+    addTx,
+    addCancelled,
+    refreshAssets
+  ]);
   const handleSweepOpns = useCallback2(async () => {
     if (!assets)
       return;
@@ -2756,9 +2996,10 @@ function SweepApp({
         addTx("BSV-21", txid);
       if (result.error)
         throw new Error(result.error);
+      addCancelled(result.cancelledListings.length);
       return result.txid ?? "";
     });
-  }, [resolveWallet, assets, keyMap, runOperation, addTx]);
+  }, [resolveWallet, assets, keyMap, runOperation, addTx, addCancelled]);
   const handleSweepBsv20Token = useCallback2(async (tick) => {
     const wallet = resolveWallet();
     if (!wallet || !assets)
@@ -2775,20 +3016,71 @@ function SweepApp({
       });
       if (result.error)
         throw new Error(result.error);
+      addCancelled(result.cancelledListings.length);
       return result.txid ?? "";
     });
-  }, [resolveWallet, assets, groupedBsv20, keyMap, runOperation]);
+  }, [resolveWallet, assets, groupedBsv20, keyMap, runOperation, addCancelled]);
+  const toggleSweepClass = useCallback2((sweepClass) => {
+    setSkippedClasses((prev) => {
+      const next = new Set(prev);
+      if (next.has(sweepClass))
+        next.delete(sweepClass);
+      else
+        next.add(sweepClass);
+      return next;
+    });
+  }, []);
+  const sweepClasses = useMemo(() => {
+    if (!assets)
+      return [];
+    const classes = [];
+    if (assets.funding.length > 0)
+      classes.push({ id: "bsv", label: "BSV", count: assets.funding.length });
+    if (assets.ordinals.length > 0)
+      classes.push({
+        id: "ordinals",
+        label: "Ordinals",
+        count: assets.ordinals.length
+      });
+    if (assets.opnsNames.length > 0)
+      classes.push({
+        id: "opns",
+        label: "OpNS",
+        count: assets.opnsNames.length
+      });
+    if (groupedBsv20.length > 0)
+      classes.push({
+        id: "bsv20",
+        label: "BSV-20",
+        count: groupedBsv20.reduce((n, t) => n + t.outputs.length, 0)
+      });
+    if (assets.bsv21Tokens.some((t) => t.outputs.length > 0))
+      classes.push({
+        id: "bsv21",
+        label: "BSV-21",
+        count: assets.bsv21Tokens.reduce((n, t) => n + t.outputs.length, 0)
+      });
+    return classes;
+  }, [assets, groupedBsv20]);
   const handleSweepAll = useCallback2(async () => {
     const wallet = resolveWallet();
     if (!wallet || !legacyKeys || !assets)
       return;
-    await runOperation("Sweep all", async () => {
+    await runOperation("Sweep selected", async () => {
+      const all = selectAllSweepClasses(assets);
       const result = await sweepAllClasses({
         wallet,
         keys: keyMap,
         assets,
         amount: sweepAmount ?? undefined,
-        onProgress: setSweepProgress
+        onProgress: setSweepProgress,
+        selection: {
+          sweepBsv: !skippedClasses.has("bsv") && all.sweepBsv,
+          ordinalOutpoints: skippedClasses.has("ordinals") ? new Set : selectedOrdinals.size > 0 ? selectedOrdinals : all.ordinalOutpoints,
+          opnsOutpoints: skippedClasses.has("opns") ? new Set : selectedOpns.size > 0 ? selectedOpns : all.opnsOutpoints,
+          bsv20Ticks: skippedClasses.has("bsv20") ? new Set : all.bsv20Ticks,
+          bsv21TokenIds: skippedClasses.has("bsv21") ? new Set : all.bsv21TokenIds
+        }
       });
       if (result.bsvTxid)
         addTx("BSV", result.bsvTxid);
@@ -2798,6 +3090,7 @@ function SweepApp({
         addTx("BSV-20", txid);
       for (const txid of result.bsv21Txids)
         addTx("BSV-21", txid);
+      addCancelled(result.cancelledListings.length);
       if (result.errors.length > 0)
         throw new Error(result.errors[0]);
       return result.bsvTxid ?? result.ordinalTxids.at(-1) ?? result.bsv20Txids.at(-1) ?? result.bsv21Txids.at(-1) ?? "";
@@ -2809,7 +3102,11 @@ function SweepApp({
     keyMap,
     sweepAmount,
     runOperation,
-    addTx
+    addTx,
+    addCancelled,
+    skippedClasses,
+    selectedOrdinals,
+    selectedOpns
   ]);
   return /* @__PURE__ */ jsxs6("div", {
     className: "min-h-screen bg-background text-foreground",
@@ -2850,12 +3147,33 @@ function SweepApp({
           assets && !sweeping && /* @__PURE__ */ jsxs6("div", {
             className: "space-y-3",
             children: [
+              showClassSkips(sweepClasses.map((c) => c.id), skippedClasses) && /* @__PURE__ */ jsx11("div", {
+                className: "flex flex-wrap gap-1.5",
+                children: sweepClasses.map((sweepClass) => {
+                  const skipped = skippedClasses.has(sweepClass.id);
+                  return /* @__PURE__ */ jsxs6(Button, {
+                    variant: skipped ? "outline" : "secondary",
+                    size: "sm",
+                    className: "gap-1.5",
+                    onClick: () => toggleSweepClass(sweepClass.id),
+                    title: skipped ? `Include ${sweepClass.label} in Sweep-selected` : `Skip ${sweepClass.label} in Sweep-selected`,
+                    children: [
+                      sweepClass.label,
+                      /* @__PURE__ */ jsx11(Badge, {
+                        variant: "secondary",
+                        className: "text-[10px] px-1.5 py-0",
+                        children: sweepClass.count
+                      })
+                    ]
+                  }, sweepClass.id);
+                })
+              }),
               /* @__PURE__ */ jsx11(Button, {
                 className: "w-full",
-                disabled: !walletConnected,
+                disabled: !walletConnected || isSweepAllDisabled(sweepClasses.map((c) => c.id), skippedClasses),
                 onClick: handleSweepAll,
                 title: walletConnected ? undefined : "Connect BRC-100 wallet to sweep",
-                children: "Sweep all to wallet"
+                children: skippedClasses.size > 0 ? "Sweep selected to wallet" : "Sweep all to wallet"
               }),
               /* @__PURE__ */ jsx11(FundingSection, {
                 funding: assets.funding,
@@ -2951,7 +3269,8 @@ function SweepApp({
           /* @__PURE__ */ jsx11(TxHistory, {
             sweeping,
             progress: sweepProgress,
-            history: txHistory
+            history: txHistory,
+            cancelledListings
           })
         ]
       })
@@ -3104,11 +3423,16 @@ export {
   getServices,
   getWallet,
   isConnected,
+  isSweepAllDisabled,
   legacyBurnOrdinals,
   legacySendBsv,
   legacySendOrdinals,
   scanAddress,
   scanAddresses,
+  selectAllSweepClasses,
+  showClassSkips,
   sweepAllClasses,
+  sweepBsv20Token,
+  sweepBsv21Token,
   truncate
 };