firo temp SIST

diff --git a/lib/pages/exchange_view/exchange_step_views/step_4_view.dart b/lib/pages/exchange_view/exchange_step_views/step_4_view.dart
index c19352f..a48b85b 100644
--- a/lib/pages/exchange_view/exchange_step_views/step_4_view.dart
+++ b/lib/pages/exchange_view/exchange_step_views/step_4_view.dart
@@ -288,13 +288,9 @@ class _Step4ViewState extends ConsumerState<Step4View> {
       );
 
       if (wallet is FiroWallet && !firoPublicSend) {
-        txDataFuture = wallet.prepareSendSpark(
-          txData: TxData(
-            recipients: [recipient],
-            note:
-                "${model.trade!.payInCurrency.toUpperCase()}/"
-                "${model.trade!.payOutCurrency.toUpperCase()} exchange",
-          ),
+        throw Exception(
+          "Sending private Firo funds to an exchange address is temporarily "
+          "unavailable.",
         );
       } else {
         final memo = wallet.info.coin is Stellar
diff --git a/lib/pages/exchange_view/send_from_view.dart b/lib/pages/exchange_view/send_from_view.dart
index dcde13e..1e3555c 100644
--- a/lib/pages/exchange_view/send_from_view.dart
+++ b/lib/pages/exchange_view/send_from_view.dart
@@ -293,7 +293,6 @@ class _SendFromCardState extends ConsumerState<SendFromCard> {
           ),
         );
       } else {
-        final firoWallet = wallet as FiroWallet;
         // otherwise do firo send based on balance selected
         if (shouldSendPublicFiroFunds) {
           txDataFuture = wallet.prepareSend(
@@ -303,21 +302,9 @@ class _SendFromCardState extends ConsumerState<SendFromCard> {
             ),
           );
         } else {
-          txDataFuture = firoWallet.prepareSendSpark(
-            txData: TxData(
-              recipients: recipient.addressType == .spark ? null : [recipient],
-              sparkRecipients: recipient.addressType == .spark
-                  ? [
-                      (
-                        address: recipient.address,
-                        amount: recipient.amount,
-                        memo: "",
-                        isChange: false,
-                      ),
-                    ]
-                  : null,
-              // feeRateType: FeeRateType.average,
-            ),
+          throw Exception(
+            "Sending private Firo funds to an exchange address is "
+            "temporarily unavailable.",
           );
         }
       }
diff --git a/lib/pages/send_view/confirm_transaction_view.dart b/lib/pages/send_view/confirm_transaction_view.dart
index 8da704e..b54b3b0 100644
--- a/lib/pages/send_view/confirm_transaction_view.dart
+++ b/lib/pages/send_view/confirm_transaction_view.dart
@@ -18,8 +18,8 @@ import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:flutter_svg/svg.dart';
 import 'package:isar_community/isar.dart';
 
-import '../../models/isar/models/isar_models.dart';
 import '../../models/input.dart';
+import '../../models/isar/models/isar_models.dart';
 import '../../models/isar/models/transaction_note.dart';
 import '../../models/isar/ordinal.dart';
 import '../../notifications/show_flush_bar.dart';
@@ -449,6 +449,8 @@ class _ConfirmTransactionViewState
 
       if (wallet is FiroWallet && confirmedTx.sparkMints != null) {
         txids.addAll(confirmedTx.sparkMints!.map((e) => e.txid!));
+      } else if (wallet is FiroWallet && confirmedTx.sparkSpends != null) {
+        txids.addAll(confirmedTx.sparkSpends!.map((e) => e.txid!));
       } else {
         txids.add(confirmedTx.txid!);
       }
diff --git a/lib/pages/spark_names/confirm_spark_name_transaction_view.dart b/lib/pages/spark_names/confirm_spark_name_transaction_view.dart
index d1f4e68..1c466c7 100644
--- a/lib/pages/spark_names/confirm_spark_name_transaction_view.dart
+++ b/lib/pages/spark_names/confirm_spark_name_transaction_view.dart
@@ -116,7 +116,7 @@ class _ConfirmSparkNameTransactionViewState
         Future<void>.delayed(const Duration(seconds: 5)),
       ]);
 
-      txids.add(txData.txid!);
+      txids.addAll(txData.sparkSpends?.map((e) => e.txid!) ?? [txData.txid!]);
       ref.refresh(desktopUseUTXOs);
 
       // save note
diff --git a/lib/wallets/models/tx_data.dart b/lib/wallets/models/tx_data.dart
index bdff31c..744d848 100644
--- a/lib/wallets/models/tx_data.dart
+++ b/lib/wallets/models/tx_data.dart
@@ -87,6 +87,7 @@ class TxData {
   final List<({String address, Amount amount, String memo, bool isChange})>?
   sparkRecipients;
   final List<TxData>? sparkMints;
+  final List<TxData>? sparkSpends;
   final List<SparkCoin>? usedSparkCoins;
   final ({
     String additionalInfo,
@@ -145,6 +146,7 @@ class TxData {
     this.sparkRecipients,
     this.otherData,
     this.sparkMints,
+    this.sparkSpends,
     this.usedSparkCoins,
     this.tempTx,
     this.ignoreCachedBalanceChecks = false,
@@ -292,6 +294,7 @@ class TxData {
     List<({String address, Amount amount, String memo, bool isChange})>?
     sparkRecipients,
     List<TxData>? sparkMints,
+    List<TxData>? sparkSpends,
     List<SparkCoin>? usedSparkCoins,
     TransactionV2? tempTx,
     bool? ignoreCachedBalanceChecks,
@@ -338,6 +341,7 @@ class TxData {
       tezosOperationsList: tezosOperationsList ?? this.tezosOperationsList,
       sparkRecipients: sparkRecipients ?? this.sparkRecipients,
       sparkMints: sparkMints ?? this.sparkMints,
+      sparkSpends: sparkSpends ?? this.sparkSpends,
       usedSparkCoins: usedSparkCoins ?? this.usedSparkCoins,
       tempTx: tempTx ?? this.tempTx,
       ignoreCachedBalanceChecks:
@@ -381,6 +385,7 @@ class TxData {
       'tezosOperationsList: $tezosOperationsList, '
       'sparkRecipients: $sparkRecipients, '
       'sparkMints: $sparkMints, '
+      'sparkSpends: $sparkSpends, '
       'usedSparkCoins: $usedSparkCoins, '
       'otherData: $otherData, '
       'tempTx: $tempTx, '
diff --git a/lib/wallets/wallet/wallet_mixin_interfaces/spark_interface.dart b/lib/wallets/wallet/wallet_mixin_interfaces/spark_interface.dart
index bf3e627..0f71059 100644
--- a/lib/wallets/wallet/wallet_mixin_interfaces/spark_interface.dart
+++ b/lib/wallets/wallet/wallet_mixin_interfaces/spark_interface.dart
@@ -38,6 +38,7 @@ import '../../models/tx_data.dart';
 import '../intermediate/bip39_hd_wallet.dart';
 import 'cpfp_interface.dart';
 import 'electrumx_interface.dart';
+import 'spark_spend_planner.dart';
 
 const kDefaultSparkIndex = 1;
 
@@ -54,6 +55,21 @@ const OP_SPARKSPEND = 0xd3;
 const OP_SPARKNAMEID = 0xe1;
 const OP_DROP = 0x75;
 
+const _maxSingleInputSparkTransactions = 50;
+
+int _compareSparkCoinsForSingleInputSpend(SparkCoin a, SparkCoin b) {
+  int result = b.value.compareTo(a.value);
+  if (result != 0) return result;
+
+  result = a.height!.compareTo(b.height!);
+  if (result != 0) return result;
+
+  result = a.txHash.compareTo(b.txHash);
+  if (result != 0) return result;
+
+  return a.lTagHash.compareTo(b.lTagHash);
+}
+
 /// top level function for use with [compute]
 String _hashTag(String tag) {
   final components = tag.split(",");
@@ -448,10 +464,9 @@ mixin SparkInterface<T extends ElectrumXCurrencyInterface>
       throw Exception("Fee estimation is not supported for view only wallets");
     }
 
-    final spendAmount = amount.raw.toInt();
-    if (spendAmount == 0) {
+    if (amount.raw <= BigInt.zero) {
       return Amount(
-        rawValue: BigInt.from(0),
+        rawValue: BigInt.zero,
         fractionDigits: cryptoCurrency.fractionDigits,
       );
     } else {
@@ -467,6 +482,13 @@ mixin SparkInterface<T extends ElectrumXCurrencyInterface>
           .not()
           .valueIntStringEqualTo("0")
           .findAll();
+      if (coins.isEmpty) {
+        return Amount(
+          rawValue: BigInt.zero,
+          fractionDigits: cryptoCurrency.fractionDigits,
+        );
+      }
+      coins.sort(_compareSparkCoinsForSingleInputSpend);
 
       final available = coins
           .map((e) => e.value)
@@ -474,43 +496,60 @@ mixin SparkInterface<T extends ElectrumXCurrencyInterface>
 
       if (amount.raw > available) {
         return Amount(
-          rawValue: BigInt.from(0),
+          rawValue: BigInt.zero,
           fractionDigits: cryptoCurrency.fractionDigits,
         );
       }
 
-      // prepare coin data for ffi
-      final serializedCoins = coins
-          .map(
-            (e) => (
-              serializedCoin: e.serializedCoinB64!,
-              serializedCoinContext: e.contextB64!,
-              groupId: e.groupId,
-              height: e.height!,
-            ),
-          )
-          .toList();
+      final serializedCoins = [
+        (
+          serializedCoin: coins.first.serializedCoinB64!,
+          serializedCoinContext: coins.first.contextB64!,
+          groupId: coins.first.groupId,
+          height: coins.first.height!,
+        ),
+      ];
 
       final root = await getRootHDNode();
       final privateKey = root.derivePath(sparkDerivationPath).privateKey.data;
-      int estimate = await _asyncSparkFeesWrapper(
-        privateKeyHex: privateKey.toHex,
-        index: sparkIndex,
-        sendAmount: spendAmount,
-        subtractFeeFromAmount: true,
-        serializedCoins: serializedCoins,
-        // privateRecipientsCount: (txData.sparkRecipients?.length ?? 0),
-        privateRecipientsCount: 1, // ROUGHLY!
-        utxoNum: 0, // TODO not zero?
-        additionalTxSize: 0, // spark name script size
+      BigInt singleInputFee = BigInt.from(
+        await _asyncSparkFeesWrapper(
+          privateKeyHex: privateKey.toHex,
+          index: sparkIndex,
+          sendAmount: 1,
+          subtractFeeFromAmount: true,
+          serializedCoins: serializedCoins,
+          privateRecipientsCount: 1,
+          utxoNum: 0,
+          additionalTxSize: 0,
+        ),
       );
 
-      if (estimate < 0) {
-        estimate = 0;
+      if (singleInputFee < BigInt.zero) singleInputFee = BigInt.zero;
+
+      int transactionCount = 0;
+      BigInt remaining = amount.raw;
+      if (remaining == available) {
+        transactionCount = coins.length;
+      } else {
+        for (final coin in coins) {
+          final capacity = coin.value - singleInputFee;
+          if (capacity <= BigInt.zero) continue;
+
+          transactionCount++;
+          remaining -= remaining < capacity ? remaining : capacity;
+          if (remaining == BigInt.zero) break;
+        }
+      }
+      if (remaining > BigInt.zero && amount.raw != available) {
+        return Amount(
+          rawValue: BigInt.zero,
+          fractionDigits: cryptoCurrency.fractionDigits,
+        );
       }
 
       return Amount(
-        rawValue: BigInt.from(estimate),
+        rawValue: singleInputFee * BigInt.from(transactionCount),
         fractionDigits: cryptoCurrency.fractionDigits,
       );
     }
@@ -522,7 +561,218 @@ mixin SparkInterface<T extends ElectrumXCurrencyInterface>
       throw Exception("Spending is not supported for view only wallets");
     }
 
-    // There should be at least one output.
+    final transparentRecipients = txData.recipients ?? [];
+    final privateRecipients = txData.sparkRecipients ?? [];
+    if (transparentRecipients.isEmpty && privateRecipients.isEmpty) {
+      throw Exception("No recipients provided.");
+    }
+    if (transparentRecipients.any((e) => e.amount.raw <= BigInt.zero) ||
+        privateRecipients.any((e) => e.amount.raw <= BigInt.zero)) {
+      throw Exception("Recipient has invalid amount.");
+    }
+
+    final coins = await mainDB.isar.sparkCoins
+        .where()
+        .walletIdEqualToAnyLTagHash(walletId)
+        .filter()
+        .isUsedEqualTo(false)
+        .and()
+        .heightIsNotNull()
+        .and()
+        .not()
+        .valueIntStringEqualTo("0")
+        .findAll();
+
+    if (coins.isEmpty) {
+      throw Exception("No spendable Spark coins found");
+    }
+    coins.sort(_compareSparkCoinsForSingleInputSpend);
+
+    final txAmount = transparentRecipients
+        .map((e) => e.amount.raw)
+        .followedBy(privateRecipients.map((e) => e.amount.raw))
+        .fold(BigInt.zero, (sum, amount) => sum + amount);
+    final available = coins
+        .map((e) => e.value)
+        .fold(BigInt.zero, (sum, value) => sum + value);
+    if (txAmount > available) {
+      throw Exception("Insufficient Spark balance");
+    }
+
+    final isSendAll = shouldSubtractSparkFeeFromAmount(
+      isSparkNameRegistration: txData.sparkNameInfo != null,
+      spendsAll: available == txAmount,
+    );
+
+    final root = await getRootHDNode();
+    final privateKeyHex = root
+        .derivePath(sparkDerivationPath)
+        .privateKey
+        .data
+        .toHex;
+    final lockTime = await chainHeight;
+
+    if (txData.sparkNameInfo != null) {
+      final spend = await _prepareSingleSparkSpend(
+        txData: txData,
+        coin: coins.first,
+        subtractFeeFromAmount: false,
+        privateKeyHex: privateKeyHex,
+        lockTime: lockTime,
+      );
+      return spend.copyWith(sparkSpends: [spend]);
+    }
+
+    if (isSendAll) {
+      if (coins.length != 1) {
+        throw Exception(
+          "Subtracting the fee is temporarily unavailable when a Spark "
+          "payment requires multiple transactions.",
+        );
+      }
+
+      final spend = await _prepareSingleSparkSpend(
+        txData: txData,
+        coin: coins.single,
+        subtractFeeFromAmount: true,
+        privateKeyHex: privateKeyHex,
+        lockTime: lockTime,
+      );
+      return spend.copyWith(sparkSpends: [spend]);
+    }
+
+    final requests = <SparkSpendRecipientRequest>[
+      for (int i = 0; i < transparentRecipients.length; i++)
+        SparkSpendRecipientRequest(
+          type: SparkSpendRecipientType.transparent,
+          index: i,
+          amount: transparentRecipients[i].amount.raw,
+        ),
+      for (int i = 0; i < privateRecipients.length; i++)
+        SparkSpendRecipientRequest(
+          type: SparkSpendRecipientType.private,
+          index: i,
+          amount: privateRecipients[i].amount.raw,
+        ),
+    ];
+    final serializedFeeCoin = [
+      (
+        serializedCoin: coins.first.serializedCoinB64!,
+        serializedCoinContext: coins.first.contextB64!,
+        groupId: coins.first.groupId,
+        height: coins.first.height!,
+      ),
+    ];
+    final feeCache = <(int, int), BigInt>{};
+    Future<BigInt> estimateSingleInputFee({
+      required int privateRecipientCount,
+      required int transparentRecipientCount,
+    }) async {
+      final key = (privateRecipientCount, transparentRecipientCount);
+      final cached = feeCache[key];
+      if (cached != null) return cached;
+
+      final fee = BigInt.from(
+        await _asyncSparkFeesWrapper(
+          privateKeyHex: privateKeyHex,
+          index: sparkIndex,
+          sendAmount: 1,
+          subtractFeeFromAmount: true,
+          serializedCoins: serializedFeeCoin,
+          privateRecipientsCount: privateRecipientCount,
+          utxoNum: transparentRecipientCount,
+          additionalTxSize: 0,
+        ),
+      );
+      feeCache[key] = fee;
+      return fee;
+    }
+
+    final maxTransparentAmount = Amount.fromDecimal(
+      Decimal.parse("50000"),
+      fractionDigits: cryptoCurrency.fractionDigits,
+    ).raw;
+    final plans = await planSingleInputSparkSpends(
+      coinValues: coins.map((e) => e.value).toList(),
+      recipients: requests,
+      estimateFee: estimateSingleInputFee,
+      maxTransparentAmount: maxTransparentAmount,
+      maxPrivateRecipients: SPARK_OUT_LIMIT_PER_TX - 2,
+      maxTransactions: _maxSingleInputSparkTransactions,
+      maxTransactionWeight: MAX_NEW_TX_WEIGHT,
+    );
+
+    final spends = <TxData>[];
+    for (final plan in plans) {
+      final batchTransparentRecipients = <TxRecipient>[];
+      final batchPrivateRecipients =
+          <({String address, Amount amount, String memo, bool isChange})>[];
+
+      for (final fragment in plan.recipients) {
+        final amount = Amount(
+          rawValue: fragment.amount,
+          fractionDigits: cryptoCurrency.fractionDigits,
+        );
+        switch (fragment.type) {
+          case SparkSpendRecipientType.transparent:
+            batchTransparentRecipients.add(
+              transparentRecipients[fragment.index].copyWith(amount: amount),
+            );
+          case SparkSpendRecipientType.private:
+            final recipient = privateRecipients[fragment.index];
+            batchPrivateRecipients.add((
+              address: recipient.address,
+              amount: amount,
+              memo: recipient.memo,
+              isChange: recipient.isChange,
+            ));
+        }
+      }
+
+      final spend = await _prepareSingleSparkSpend(
+        txData: txData.copyWith(
+          recipients: batchTransparentRecipients,
+          sparkRecipients: batchPrivateRecipients,
+        ),
+        coin: coins[plan.coinIndex],
+        subtractFeeFromAmount: false,
+        privateKeyHex: privateKeyHex,
+        lockTime: lockTime,
+      );
+      if (spend.fee?.raw != plan.fee) {
+        throw Exception("Spark transaction fee changed during creation.");
+      }
+      spends.add(spend);
+    }
+
+    if (spends.length == 1) {
+      return spends.single.copyWith(sparkSpends: List.unmodifiable(spends));
+    }
+
+    final totalFee = spends
+        .map((e) => e.fee!.raw)
+        .fold(BigInt.zero, (sum, fee) => sum + fee);
+    final usedCoins = spends
+        .expand((e) => e.usedSparkCoins!)
+        .toList(growable: false);
+    return txData.copyWith(
+      fee: Amount(
+        rawValue: totalFee,
+        fractionDigits: cryptoCurrency.fractionDigits,
+      ),
+      vSize: spends.fold<int>(0, (sum, spend) => sum + spend.vSize!),
+      sparkSpends: List.unmodifiable(spends),
+      usedSparkCoins: usedCoins,
+    );
+  }
+
+  Future<TxData> _prepareSingleSparkSpend({
+    required TxData txData,
+    required SparkCoin coin,
+    required bool subtractFeeFromAmount,
+    required String privateKeyHex,
+    required int lockTime,
+  }) async {
     if (!(txData.recipients?.isNotEmpty == true ||
         txData.sparkRecipients?.isNotEmpty == true)) {
       throw Exception("No recipients provided.");
@@ -569,34 +819,8 @@ mixin SparkInterface<T extends ElectrumXCurrencyInterface>
         );
 
     final txAmount = transparentSumOut + sparkSumOut;
-
-    // fetch spendable spark coins
-    final coins = await mainDB.isar.sparkCoins
-        .where()
-        .walletIdEqualToAnyLTagHash(walletId)
-        .filter()
-        .isUsedEqualTo(false)
-        .and()
-        .heightIsNotNull()
-        .and()
-        .not()
-        .valueIntStringEqualTo("0")
-        .findAll();
-
-    if (coins.isEmpty) {
-      throw Exception("No spendable Spark coins found");
-    }
-
-    final available = info.cachedBalanceTertiary.spendable;
-
-    if (txAmount > available) {
-      throw Exception("Insufficient Spark balance");
-    }
-
-    final bool isSendAll = shouldSubtractSparkFeeFromAmount(
-      isSparkNameRegistration: txData.sparkNameInfo != null,
-      spendsAll: available == txAmount,
-    );
+    final coins = [coin];
+    final isSendAll = subtractFeeFromAmount;
 
     // prepare coin data for ffi
     final serializedCoins = coins
@@ -663,11 +887,8 @@ mixin SparkInterface<T extends ElectrumXCurrencyInterface>
         )
         .toList();
 
-    final root = await getRootHDNode();
-    final privateKey = root.derivePath(sparkDerivationPath).privateKey.data;
-
     final txb = btc.TransactionBuilder(network: _bitcoinDartNetwork);
-    txb.setLockTime(await chainHeight);
+    txb.setLockTime(lockTime);
     txb.setVersion(3 | (9 << 16));
 
     List<TxRecipient>? recipientsWithFeeSubtracted;
@@ -681,7 +902,7 @@ mixin SparkInterface<T extends ElectrumXCurrencyInterface>
     final BigInt estimatedFee;
     if (isSendAll) {
       final estFee = await _asyncSparkFeesWrapper(
-        privateKeyHex: privateKey.toHex,
+        privateKeyHex: privateKeyHex,
         index: sparkIndex,
         sendAmount: txAmount.raw.toInt(),
         subtractFeeFromAmount: true,
@@ -811,7 +1032,7 @@ mixin SparkInterface<T extends ElectrumXCurrencyInterface>
         name: txData.sparkNameInfo!.name,
         additionalInfo: txData.sparkNameInfo!.additionalInfo,
         scalarHex: extractedTx.getId(),
-        privateKeyHex: privateKey.toHex,
+        privateKeyHex: privateKeyHex,
         spendKeyIndex: sparkIndex,
         diversifier: txData.sparkNameInfo!.sparkAddress.derivationIndex,
         isTestNet: cryptoCurrency.network != CryptoCurrencyNetwork.main,
@@ -821,7 +1042,7 @@ mixin SparkInterface<T extends ElectrumXCurrencyInterface>
     }
 
     final spend = await computeWithLibSparkLogging(_createSparkSend, (
-      privateKeyHex: privateKey.toHex,
+      privateKeyHex: privateKeyHex,
       index: sparkIndex,
       recipients:
           txData.recipients
@@ -857,6 +1078,10 @@ mixin SparkInterface<T extends ElectrumXCurrencyInterface>
           : noProofNameTxData!.size + sparkNameFeeScriptSizeDelta,
     ));
 
+    if (spend.usedCoins.length != 1) {
+      throw Exception("Unable to create a single-input Spark transaction.");
+    }
+
     for (final outputScript in spend.outputScripts) {
       extractedTx.addOutput(outputScript, 0);
     }
@@ -884,7 +1109,7 @@ mixin SparkInterface<T extends ElectrumXCurrencyInterface>
             name: txData.sparkNameInfo!.name,
             additionalInfo: txData.sparkNameInfo!.additionalInfo,
             scalarHex: hash,
-            privateKeyHex: privateKey.toHex,
+            privateKeyHex: privateKeyHex,
             spendKeyIndex: sparkIndex,
             diversifier: txData.sparkNameInfo!.sparkAddress.derivationIndex,
             isTestNet: cryptoCurrency.network != CryptoCurrencyNetwork.main,
@@ -963,6 +1188,9 @@ mixin SparkInterface<T extends ElectrumXCurrencyInterface>
         );
       }
     }
+    if (usedSparkCoins.length != 1) {
+      throw Exception("Unable to create a single-input Spark transaction.");
+    }
 
     return txData.copyWith(
       raw: rawTxHex,
@@ -988,7 +1216,6 @@ mixin SparkInterface<T extends ElectrumXCurrencyInterface>
     );
   }
 
-  // this may not be needed for either mints or spends or both
   Future<TxData> confirmSendSpark({required TxData txData}) async {
     if (isViewOnly) {
       throw Exception("Spending is not supported for view only wallets");
@@ -997,31 +1224,67 @@ mixin SparkInterface<T extends ElectrumXCurrencyInterface>
     try {
       Logging.instance.d("confirmSend txData: $txData");
 
-      final txHash = await electrumXClient.broadcastTransaction(
-        rawTx: txData.raw!,
-      );
-      Logging.instance.d("Sent txHash: $txHash");
+      final transactions = txData.sparkSpends ?? [txData];
+      if (transactions.isEmpty ||
+          transactions.any(
+            (e) =>
+                e.raw == null ||
+                e.usedSparkCoins == null ||
+                e.usedSparkCoins!.length != 1,
+          )) {
+        throw Exception(
+          "Refusing to broadcast a non-single-input Spark transaction.",
+        );
+      }
+      final coinIds = transactions
+          .map((e) => e.usedSparkCoins!.single.lTagHash)
+          .toSet();
+      if (coinIds.length != transactions.length) {
+        throw Exception(
+          "A Spark coin cannot be used by multiple transactions.",
+        );
+      }
 
-      txData = txData.copyWith(
-        // TODO revisit setting these both
-        txHash: txHash,
-        txid: txHash,
-      );
+      final confirmed = <TxData>[];
+      for (int i = 0; i < transactions.length; i++) {
+        try {
+          final txHash = await electrumXClient.broadcastTransaction(
+            rawTx: transactions[i].raw!,
+          );
+          Logging.instance.d("Sent txHash: $txHash");
 
-      // Update used spark coins as used in database. They should already have
-      // been marked as isUsed.
-      // TODO: [prio=med] Could (probably should) throw an exception here
-      //  if txData.usedSparkCoins is null or empty
-      if (txData.usedSparkCoins != null && txData.usedSparkCoins!.isNotEmpty) {
-        await mainDB.isar.writeTxn(() async {
-          await mainDB.isar.sparkCoins.putAll(txData.usedSparkCoins!);
-        });
+          TxData confirmedTx = transactions[i].copyWith(
+            txHash: txHash,
+            txid: txHash,
+          );
+          confirmed.add(confirmedTx);
+
+          await mainDB.isar.writeTxn(() async {
+            await mainDB.isar.sparkCoins.putAll(confirmedTx.usedSparkCoins!);
+          });
+          confirmedTx = await updateSentCachedTxData(txData: confirmedTx);
+          confirmed[confirmed.length - 1] = confirmedTx;
+        } catch (e) {
+          if (confirmed.isNotEmpty) {
+            final txids = confirmed.map((e) => e.txid).join(", ");
+            throw Exception(
+              "Spark transaction ${i + 1} of ${transactions.length} failed: "
+              "$e ${confirmed.length} transaction(s) were already sent: "
+              "$txids. Do not retry the full payment.",
+            );
+          }
+          rethrow;
+        }
       }
 
-      return await updateSentCachedTxData(txData: txData);
+      return txData.copyWith(
+        txHash: confirmed.first.txHash,
+        txid: confirmed.first.txid,
+        sparkSpends: List.unmodifiable(confirmed),
+      );
     } catch (e, s) {
       Logging.instance.e(
-        "Exception rethrown from confirmSend(): ",
+        "Exception rethrown from confirmSendSpark(): ",
         error: e,
         stackTrace: s,
       );
diff --git a/lib/wallets/wallet/wallet_mixin_interfaces/spark_spend_planner.dart b/lib/wallets/wallet/wallet_mixin_interfaces/spark_spend_planner.dart
new file mode 100644
index 0000000..9a5592c
--- /dev/null
+++ b/lib/wallets/wallet/wallet_mixin_interfaces/spark_spend_planner.dart
@@ -0,0 +1,183 @@
+typedef SparkSpendFeeEstimator =
+    Future<BigInt> Function({
+      required int privateRecipientCount,
+      required int transparentRecipientCount,
+    });
+
+const _sparkBaseSize = 924;
+const _sparkInputSize = 1803;
+const _sparkPrivateOutputSize = 322;
+const _transparentOutputSize = 34;
+const _witnessScaleFactor = 4;
+
+enum SparkSpendRecipientType { transparent, private }
+
+final class SparkSpendRecipientRequest {
+  final SparkSpendRecipientType type;
+  final int index;
+  final BigInt amount;
+
+  const SparkSpendRecipientRequest({
+    required this.type,
+    required this.index,
+    required this.amount,
+  });
+}
+
+final class SparkSpendRecipientFragment {
+  final SparkSpendRecipientType type;
+  final int index;
+  final BigInt amount;
+
+  const SparkSpendRecipientFragment({
+    required this.type,
+    required this.index,
+    required this.amount,
+  });
+}
+
+final class SingleInputSparkSpendPlan {
+  final int coinIndex;
+  final BigInt fee;
+  final List<SparkSpendRecipientFragment> recipients;
+
+  const SingleInputSparkSpendPlan({
+    required this.coinIndex,
+    required this.fee,
+    required this.recipients,
+  });
+}
+
+final class _RemainingSparkRecipient {
+  final SparkSpendRecipientRequest recipient;
+  BigInt amount;
+
+  _RemainingSparkRecipient(this.recipient) : amount = recipient.amount;
+}
+
+Future<List<SingleInputSparkSpendPlan>> planSingleInputSparkSpends({
+  required List<BigInt> coinValues,
+  required List<SparkSpendRecipientRequest> recipients,
+  required SparkSpendFeeEstimator estimateFee,
+  required BigInt maxTransparentAmount,
+  required int maxPrivateRecipients,
+  required int maxTransactions,
+  required int maxTransactionWeight,
+}) async {
+  if (recipients.isEmpty) {
+    throw Exception("No recipients provided.");
+  }
+  if (recipients.any((e) => e.amount <= BigInt.zero)) {
+    throw Exception("Recipient has invalid amount.");
+  }
+
+  final remaining = recipients.map(_RemainingSparkRecipient.new).toList();
+  final plans = <SingleInputSparkSpendPlan>[];
+  int recipientIndex = 0;
+
+  for (
+    int coinIndex = 0;
+    coinIndex < coinValues.length && recipientIndex < remaining.length;
+    coinIndex++
+  ) {
+    final coinValue = coinValues[coinIndex];
+    final fragments = <SparkSpendRecipientFragment>[];
+    BigInt amount = BigInt.zero;
+    BigInt fee = BigInt.zero;
+    BigInt transparentAmount = BigInt.zero;
+    int privateRecipientCount = 0;
+    int transparentRecipientCount = 0;
+
+    while (recipientIndex < remaining.length) {
+      final current = remaining[recipientIndex];
+      final isPrivate =
+          current.recipient.type == SparkSpendRecipientType.private;
+      final nextPrivateCount = privateRecipientCount + (isPrivate ? 1 : 0);
+      final nextTransparentCount =
+          transparentRecipientCount + (isPrivate ? 0 : 1);
+
+      if (nextPrivateCount > maxPrivateRecipients ||
+          (!isPrivate && transparentAmount >= maxTransparentAmount)) {
+        break;
+      }
+      final estimatedSize =
+          _sparkBaseSize +
+          _sparkInputSize +
+          _sparkPrivateOutputSize * (nextPrivateCount + 1) +
+          _transparentOutputSize * nextTransparentCount;
+      if (estimatedSize * _witnessScaleFactor >= maxTransactionWeight) {
+        break;
+      }
+
+      final nextFee = await estimateFee(
+        privateRecipientCount: nextPrivateCount,
+        transparentRecipientCount: nextTransparentCount,
+      );
+      if (nextFee < BigInt.zero) {
+        throw Exception("Invalid Spark transaction fee.");
+      }
+
+      BigInt available = coinValue - amount - nextFee;
+      if (!isPrivate) {
+        final transparentAvailable = maxTransparentAmount - transparentAmount;
+        if (available > transparentAvailable) {
+          available = transparentAvailable;
+        }
+      }
+      if (available <= BigInt.zero) {
+        break;
+      }
+
+      final fragmentAmount = current.amount < available
+          ? current.amount
+          : available;
+      fragments.add(
+        SparkSpendRecipientFragment(
+          type: current.recipient.type,
+          index: current.recipient.index,
+          amount: fragmentAmount,
+        ),
+      );
+      amount += fragmentAmount;
+      fee = nextFee;
+      if (isPrivate) {
+        privateRecipientCount = nextPrivateCount;
+      } else {
+        transparentRecipientCount = nextTransparentCount;
+        transparentAmount += fragmentAmount;
+      }
+
+      current.amount -= fragmentAmount;
+      if (current.amount == BigInt.zero) {
+        recipientIndex++;
+      } else {
+        break;
+      }
+    }
+
+    if (fragments.isEmpty) {
+      continue;
+    }
+
+    plans.add(
+      SingleInputSparkSpendPlan(
+        coinIndex: coinIndex,
+        fee: fee,
+        recipients: List.unmodifiable(fragments),
+      ),
+    );
+    if (plans.length == maxTransactions && recipientIndex < remaining.length) {
+      throw Exception(
+        "A Spark payment may use at most $maxTransactions transactions.",
+      );
+    }
+  }
+
+  if (recipientIndex != remaining.length) {
+    throw Exception(
+      "The available Spark coins cannot cover the amount and transaction fees.",
+    );
+  }
+
+  return List.unmodifiable(plans);
+}
diff --git a/test/wallets/spark_spend_planner_test.dart b/test/wallets/spark_spend_planner_test.dart
new file mode 100644
index 0000000..83a09d7
--- /dev/null
+++ b/test/wallets/spark_spend_planner_test.dart
@@ -0,0 +1,60 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:stackwallet/wallets/wallet/wallet_mixin_interfaces/spark_spend_planner.dart';
+
+void main() {
+  test('splits a payment into one plan per Spark coin', () async {
+    final plans = await planSingleInputSparkSpends(
+      coinValues: [BigInt.from(7000), BigInt.from(5000)],
+      recipients: [
+        SparkSpendRecipientRequest(
+          type: SparkSpendRecipientType.private,
+          index: 0,
+          amount: BigInt.from(9000),
+        ),
+      ],
+      estimateFee:
+          ({
+            required privateRecipientCount,
+            required transparentRecipientCount,
+          }) async => BigInt.from(1000),
+      maxTransparentAmount: BigInt.from(50000),
+      maxPrivateRecipients: 14,
+      maxTransactions: 50,
+      maxTransactionWeight: 1000000,
+    );
+
+    expect(plans.map((e) => e.coinIndex), [0, 1]);
+    expect(plans.map((e) => e.recipients.single.amount), [
+      BigInt.from(6000),
+      BigInt.from(3000),
+    ]);
+    expect(plans.map((e) => e.fee), [BigInt.from(1000), BigInt.from(1000)]);
+  });
+
+  test('applies the transparent limit to each transaction', () async {
+    final plans = await planSingleInputSparkSpends(
+      coinValues: [BigInt.from(7000), BigInt.from(7000)],
+      recipients: [
+        SparkSpendRecipientRequest(
+          type: SparkSpendRecipientType.transparent,
+          index: 0,
+          amount: BigInt.from(6000),
+        ),
+      ],
+      estimateFee:
+          ({
+            required privateRecipientCount,
+            required transparentRecipientCount,
+          }) async => BigInt.from(1000),
+      maxTransparentAmount: BigInt.from(4000),
+      maxPrivateRecipients: 14,
+      maxTransactions: 50,
+      maxTransactionWeight: 1000000,
+    );
+
+    expect(plans.map((e) => e.recipients.single.amount), [
+      BigInt.from(4000),
+      BigInt.from(2000),
+    ]);
+  });
+}