BSQ swaps: Low risk refactorings [2]

core/src/main/java/bisq/core/btc/wallet/BsqCoinSelector.java

@@ -26,6 +26,8 @@
 
 import javax.inject.Inject;
 
+import lombok.Getter;
+import lombok.Setter;
 import lombok.extern.slf4j.Slf4j;
 
 /**
@@ -36,9 +38,13 @@
 public class BsqCoinSelector extends BisqDefaultCoinSelector {
     private final DaoStateService daoStateService;
     private final UnconfirmedBsqChangeOutputListService unconfirmedBsqChangeOutputListService;
+    @Setter
+    @Getter
+    private boolean allowSpendMyOwnUnconfirmedTxOutputs = true;
 
     @Inject
-    public BsqCoinSelector(DaoStateService daoStateService, UnconfirmedBsqChangeOutputListService unconfirmedBsqChangeOutputListService) {
+    public BsqCoinSelector(DaoStateService daoStateService,
+                           UnconfirmedBsqChangeOutputListService unconfirmedBsqChangeOutputListService) {
         // permitForeignPendingTx is not relevant here as we do not support pending foreign utxos anyway.
         super(false);
         this.daoStateService = daoStateService;
@@ -53,17 +59,19 @@ protected boolean isTxOutputSpendable(TransactionOutput output) {
             return false;
 
         // If it is a normal confirmed BSQ output we use the default lookup at the daoState
-        if (daoStateService.isTxOutputSpendable(new TxOutputKey(parentTransaction.getTxId().toString(), output.getIndex())))
+        TxOutputKey txOutputKey = new TxOutputKey(parentTransaction.getTxId().toString(), output.getIndex());
+        if (daoStateService.isTxOutputSpendable(txOutputKey))
             return true;
 
         // It might be that it is an unconfirmed change output which we allow to be used for spending without requiring a confirmation.
         // We check if we have the output in the dao state, if so we have a confirmed but unspendable output (e.g. confiscated).
-        if (daoStateService.getTxOutput(new TxOutputKey(parentTransaction.getTxId().toString(), output.getIndex())).isPresent())
+        if (daoStateService.getTxOutput(txOutputKey).isPresent())
             return false;
 
+        // If we have set the isUnconfirmedSpendable flag to true (default) we check for unconfirmed own change outputs.
         // Only if it's not existing yet in the dao state (unconfirmed) we use our unconfirmedBsqChangeOutputList to
         // check if it is an own change output.
-        return unconfirmedBsqChangeOutputListService.hasTransactionOutput(output);
+        return allowSpendMyOwnUnconfirmedTxOutputs && unconfirmedBsqChangeOutputListService.hasTransactionOutput(output);
     }
 
     // For BSQ we do not check for dust attack utxos as they are 5.46 BSQ and a considerable value.

core/src/main/java/bisq/core/btc/wallet/BtcWalletService.java

@@ -23,6 +23,7 @@
 import bisq.core.btc.exceptions.WalletException;
 import bisq.core.btc.model.AddressEntry;
 import bisq.core.btc.model.AddressEntryList;
+import bisq.core.btc.model.RawTransactionInput;
 import bisq.core.btc.setup.WalletsSetup;
 import bisq.core.btc.wallet.http.MemPoolSpaceTxBroadcaster;
 import bisq.core.provider.fee.FeeService;
@@ -47,6 +48,7 @@
 import org.bitcoinj.script.Script;
 import org.bitcoinj.script.ScriptBuilder;
 import org.bitcoinj.script.ScriptPattern;
+import org.bitcoinj.wallet.CoinSelection;
 import org.bitcoinj.wallet.SendRequest;
 import org.bitcoinj.wallet.Wallet;
 
@@ -61,6 +63,7 @@
 
 import java.util.Arrays;
 import java.util.List;
+import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
 import java.util.stream.Collectors;
@@ -152,6 +155,21 @@ String getWalletAsString(boolean includePrivKeys) {
     // Public Methods
     ///////////////////////////////////////////////////////////////////////////////////////////
 
+    public Transaction signTx(Transaction tx) throws WalletException, TransactionVerificationException {
+        for (int i = 0; i < tx.getInputs().size(); i++) {
+            TransactionInput input = tx.getInput(i);
+            if (input.getConnectedOutput() != null && input.getConnectedOutput().isMine(wallet)) {
+                signTransactionInput(wallet, aesKey, tx, input, i);
+                checkScriptSig(tx, input, i);
+            }
+        }
+
+        checkWalletConsistency(wallet);
+        verifyTransaction(tx);
+        printTx("BTC wallet: Signed Tx", tx);
+        return tx;
+    }
+
     ///////////////////////////////////////////////////////////////////////////////////////////
     // Burn BSQ txs (some proposal txs, asset listing fee tx, proof of burn tx)
     ///////////////////////////////////////////////////////////////////////////////////////////
@@ -1330,4 +1348,30 @@ public Transaction createRefundPayoutTx(Coin buyerAmount,
 
         return resultTx;
     }
+
+
+    ///////////////////////////////////////////////////////////////////////////////////////////
+    // Find inputs and change
+    ///////////////////////////////////////////////////////////////////////////////////////////
+
+    public Tuple2<List<RawTransactionInput>, Coin> getInputsAndChange(Coin required) throws InsufficientMoneyException {
+        BtcCoinSelector coinSelector = new BtcCoinSelector(walletsSetup.getAddressesByContext(AddressEntry.Context.AVAILABLE),
+                preferences.getIgnoreDustThreshold());
+        CoinSelection coinSelection = coinSelector.select(required, Objects.requireNonNull(wallet).calculateAllSpendCandidates());
+
+        Coin change;
+        try {
+            change = coinSelector.getChange(required, coinSelection);
+        } catch (InsufficientMoneyException e) {
+            log.error("Missing funds in getSellersBtcInputsForBsqSwapTx. missing={}", e.missing);
+            throw new InsufficientMoneyException(e.missing);
+        }
+
+        Transaction dummyTx = new Transaction(params);
+        coinSelection.gathered.forEach(dummyTx::addInput);
+        List<RawTransactionInput> inputs = dummyTx.getInputs().stream()
+                .map(RawTransactionInput::new)
+                .collect(Collectors.toList());
+        return new Tuple2<>(inputs, change);
+    }
 }

core/src/main/java/bisq/core/btc/wallet/TradeWalletService.java

@@ -889,8 +889,7 @@ public Transaction sellerSignsAndFinalizesPayoutTx(Transaction depositTx,
             input.setScriptSig(inputScript);
         } else {
             input.setScriptSig(ScriptBuilder.createEmpty());
-            TransactionWitness witness = TransactionWitness.redeemP2WSH(redeemScript, sellerTxSig, buyerTxSig);
-            input.setWitness(witness);
+            input.setWitness(TransactionWitness.redeemP2WSH(redeemScript, sellerTxSig, buyerTxSig));
         }
         WalletService.printTx("payoutTx", payoutTx);
         WalletService.verifyTransaction(payoutTx);
@@ -969,8 +968,7 @@ public Transaction finalizeMediatedPayoutTx(Transaction depositTx,
             input.setScriptSig(inputScript);
         } else {
             input.setScriptSig(ScriptBuilder.createEmpty());
-            TransactionWitness witness = TransactionWitness.redeemP2WSH(redeemScript, sellerTxSig, buyerTxSig);
-            input.setWitness(witness);
+            input.setWitness(TransactionWitness.redeemP2WSH(redeemScript, sellerTxSig, buyerTxSig));
         }
         WalletService.printTx("mediated payoutTx", payoutTx);
         WalletService.verifyTransaction(payoutTx);
@@ -1057,8 +1055,7 @@ public Transaction traderSignAndFinalizeDisputedPayoutTx(byte[] depositTxSeriali
             input.setScriptSig(inputScript);
         } else {
             input.setScriptSig(ScriptBuilder.createEmpty());
-            TransactionWitness witness = TransactionWitness.redeemP2WSH(redeemScript, arbitratorTxSig, tradersTxSig);
-            input.setWitness(witness);
+            input.setWitness(TransactionWitness.redeemP2WSH(redeemScript, arbitratorTxSig, tradersTxSig));
         }
         WalletService.printTx("disputed payoutTx", payoutTx);
         WalletService.verifyTransaction(payoutTx);
@@ -1147,8 +1144,7 @@ public Tuple2<String, String> emergencyApplySignatureToPayoutTxFrom2of2MultiSig(
             input.setScriptSig(inputScript);
         } else {
             input.setScriptSig(ScriptBuilder.createEmpty());
-            TransactionWitness witness = TransactionWitness.redeemP2WSH(redeemScript, sellerTxSig, buyerTxSig);
-            input.setWitness(witness);
+            input.setWitness(TransactionWitness.redeemP2WSH(redeemScript, sellerTxSig, buyerTxSig));
         }
         String txId = payoutTx.getTxId().toString();
         String signedTxHex = Utils.HEX.encode(payoutTx.bitcoinSerialize(!hashedMultiSigOutputIsLegacy));
@@ -1228,10 +1224,13 @@ private RawTransactionInput getRawInputFromTransactionInput(TransactionInput inp
                 input.getValue().value);
     }
 
-    private TransactionInput getTransactionInput(Transaction depositTx,
+    private TransactionInput getTransactionInput(Transaction parentTransaction,
                                                  byte[] scriptProgram,
                                                  RawTransactionInput rawTransactionInput) {
-        return new TransactionInput(params, depositTx, scriptProgram, getConnectedOutPoint(rawTransactionInput),
+        return new TransactionInput(params,
+                parentTransaction,
+                scriptProgram,
+                getConnectedOutPoint(rawTransactionInput),
                 Coin.valueOf(rawTransactionInput.value));
     }
 
@@ -1245,7 +1244,6 @@ public boolean isP2WH(RawTransactionInput rawTransactionInput) {
                 checkNotNull(getConnectedOutPoint(rawTransactionInput).getConnectedOutput()).getScriptPubKey());
     }
 
-
     // TODO: Once we have removed legacy arbitrator from dispute domain we can remove that method as well.
     // Atm it is still used by traderSignAndFinalizeDisputedPayoutTx which is used by ArbitrationManager.
 

core/src/main/java/bisq/core/btc/wallet/WalletService.java

@@ -357,12 +357,13 @@ public static void signTransactionInput(Wallet wallet,
                         txIn.setScriptSig(ScriptBuilder.createEmpty());
                         txIn.setWitness(TransactionWitness.redeemP2WPKH(txSig, key));
                     } catch (ECKey.KeyIsEncryptedException e1) {
+                        log.error(e1.toString());
                         throw e1;
                     } catch (ECKey.MissingPrivateKeyException e1) {
                         log.warn("No private key in keypair for input {}", index);
                     }
                 } else {
-                    // log.error("Unexpected script type.");
+                    log.error("Unexpected script type.");
                     throw new RuntimeException("Unexpected script type.");
                 }
             } else {
@@ -546,6 +547,10 @@ public boolean isAddressUnused(Address address) {
         return getNumTxOutputsForAddress(address) == 0;
     }
 
+    public boolean isMine(TransactionOutput transactionOutput) {
+        return transactionOutput.isMine(wallet);
+    }
+
     // BISQ issue #4039: Prevent dust outputs from being created.
     // Check the outputs of a proposed transaction.  If any are below the dust threshold,
     // add up the dust, log the details, and return the cumulative dust amount.