v0.9.9

README.md

@@ -72,4 +72,11 @@ Please use the [Issues](https://github.com/sparrowwallet/sparrow/issues) tab abo
 
 ## License
 
-Sparrow is licensed under the Apache 2 software licence.
+Sparrow is licensed under the Apache 2 software licence.
+
+## Credit
+
+![Yourkit](https://www.yourkit.com/images/yklogo.png)
+
+Sparrow Wallet uses the [Yourkit Java Profiler](https://www.yourkit.com/java/profiler/) to profile and improve performance. 
+YourKit supports open source projects with useful tools for monitoring and profiling Java and .NET applications.

build.gradle

@@ -5,7 +5,7 @@ plugins {
     id 'org.beryx.jlink' version '2.22.0'
 }
 
-def sparrowVersion = '0.9.6'
+def sparrowVersion = '0.9.9'
 def os = org.gradle.internal.os.OperatingSystem.current()
 def osName = os.getFamilyName()
 if(os.macOsX) {
@@ -51,7 +51,7 @@ dependencies {
     implementation('com.github.arteam:simple-json-rpc-server:1.0') {
         exclude group: 'org.slf4j'
     }
-    implementation('com.sparrowwallet:hummingbird:1.2')
+    implementation('com.sparrowwallet:hummingbird:1.5.2')
     implementation('com.nativelibs4java:bridj:0.7-20140918-3') {
         exclude group: 'com.google.android.tools', module: 'dx'
     }

src/main/deploy/package/osx/Info.plist

@@ -21,7 +21,7 @@
   <key>CFBundlePackageType</key>
   <string>APPL</string>
   <key>CFBundleShortVersionString</key>
-  <string>0.9.6</string>
+  <string>0.9.9</string>
   <key>CFBundleSignature</key>
   <string>????</string>
   <!-- See https://developer.apple.com/app-store/categories/ for list of AppStore categories -->

src/main/java/com/sparrowwallet/sparrow/AppServices.java

@@ -0,0 +1,488 @@
+package com.sparrowwallet.sparrow;
+
+import com.google.common.eventbus.Subscribe;
+import com.sparrowwallet.drongo.address.Address;
+import com.sparrowwallet.drongo.protocol.Transaction;
+import com.sparrowwallet.drongo.psbt.PSBT;
+import com.sparrowwallet.drongo.uri.BitcoinURI;
+import com.sparrowwallet.drongo.wallet.KeystoreSource;
+import com.sparrowwallet.drongo.wallet.Wallet;
+import com.sparrowwallet.sparrow.event.*;
+import com.sparrowwallet.sparrow.io.Config;
+import com.sparrowwallet.sparrow.io.Device;
+import com.sparrowwallet.sparrow.io.Hwi;
+import com.sparrowwallet.sparrow.io.Storage;
+import com.sparrowwallet.sparrow.net.ElectrumServer;
+import com.sparrowwallet.sparrow.net.ExchangeSource;
+import com.sparrowwallet.sparrow.net.MempoolRateSize;
+import com.sparrowwallet.sparrow.net.VersionCheckService;
+import javafx.application.Platform;
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.SimpleBooleanProperty;
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import javafx.concurrent.ScheduledService;
+import javafx.concurrent.Worker;
+import javafx.fxml.FXMLLoader;
+import javafx.scene.Parent;
+import javafx.scene.Scene;
+import javafx.scene.control.Alert;
+import javafx.scene.image.Image;
+import javafx.scene.text.Font;
+import javafx.stage.Stage;
+import javafx.stage.Window;
+import javafx.util.Duration;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.File;
+import java.io.IOException;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.temporal.ChronoUnit;
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class AppServices {
+    private static final Logger log = LoggerFactory.getLogger(AppServices.class);
+
+    private static final int SERVER_PING_PERIOD = 1 * 60 * 1000;
+    private static final int ENUMERATE_HW_PERIOD = 30 * 1000;
+    private static final int RATES_PERIOD = 5 * 60 * 1000;
+    private static final int VERSION_CHECK_PERIOD_HOURS = 24;
+    private static final ExchangeSource DEFAULT_EXCHANGE_SOURCE = ExchangeSource.COINGECKO;
+    private static final Currency DEFAULT_FIAT_CURRENCY = Currency.getInstance("USD");
+
+    private static AppServices INSTANCE;
+
+    private final MainApp application;
+
+    private final Map<Window, Map<Wallet, Storage>> walletWindows = new LinkedHashMap<>();
+
+    private static final BooleanProperty onlineProperty = new SimpleBooleanProperty(false);
+
+    private ExchangeSource.RatesService ratesService;
+
+    private ElectrumServer.ConnectionService connectionService;
+
+    private Hwi.ScheduledEnumerateService deviceEnumerateService;
+
+    private VersionCheckService versionCheckService;
+
+    private static Integer currentBlockHeight;
+
+    private static Map<Integer, Double> targetBlockFeeRates;
+
+    private static final Map<Date, Set<MempoolRateSize>> mempoolHistogram = new TreeMap<>();
+
+    private static Double minimumRelayFeeRate;
+
+    private static CurrencyRate fiatCurrencyExchangeRate;
+
+    private static List<Device> devices;
+
+    private static final Map<Address, BitcoinURI> payjoinURIs = new HashMap<>();
+
+    private final ChangeListener<Boolean> onlineServicesListener = new ChangeListener<>() {
+        @Override
+        public void changed(ObservableValue<? extends Boolean> observable, Boolean oldValue, Boolean online) {
+            Config.get().setMode(online ? Mode.ONLINE : Mode.OFFLINE);
+            if(online) {
+                restartService(connectionService);
+
+                if(ratesService.getExchangeSource() != ExchangeSource.NONE) {
+                    restartService(ratesService);
+                }
+
+                if(Config.get().isCheckNewVersions()) {
+                    restartService(versionCheckService);
+                }
+            } else {
+                connectionService.cancel();
+                ratesService.cancel();
+                versionCheckService.cancel();
+            }
+        }
+    };
+
+    private void restartService(ScheduledService<?> service) {
+        if(service.isRunning()) {
+            service.cancel();
+        }
+
+        if(service.getState() == Worker.State.CANCELLED) {
+            service.reset();
+        }
+
+        if(!service.isRunning()) {
+            service.start();
+        }
+    }
+
+    public AppServices(MainApp application) {
+        this.application = application;
+        EventManager.get().register(this);
+    }
+
+    public void start() {
+        Config config = Config.get();
+        connectionService = createConnectionService();
+        if(config.getMode() == Mode.ONLINE && config.getElectrumServer() != null && !config.getElectrumServer().isEmpty()) {
+            connectionService.start();
+        }
+
+        ExchangeSource source = config.getExchangeSource() != null ? config.getExchangeSource() : DEFAULT_EXCHANGE_SOURCE;
+        Currency currency = config.getFiatCurrency() != null ? config.getFiatCurrency() : DEFAULT_FIAT_CURRENCY;
+        ratesService = createRatesService(source, currency);
+        if(config.getMode() == Mode.ONLINE && source != ExchangeSource.NONE) {
+            ratesService.start();
+        }
+
+        versionCheckService = createVersionCheckService();
+        if(config.getMode() == Mode.ONLINE && config.isCheckNewVersions()) {
+            versionCheckService.start();
+        }
+
+        onlineProperty.addListener(onlineServicesListener);
+    }
+
+    private ElectrumServer.ConnectionService createConnectionService() {
+        ElectrumServer.ConnectionService connectionService = new ElectrumServer.ConnectionService();
+        connectionService.setPeriod(new Duration(SERVER_PING_PERIOD));
+        connectionService.setRestartOnFailure(true);
+
+        EventManager.get().register(connectionService);
+        connectionService.statusProperty().addListener((observable, oldValue, newValue) -> {
+            if(connectionService.isRunning()) {
+                EventManager.get().post(new StatusEvent(newValue));
+            }
+        });
+
+        connectionService.setOnSucceeded(successEvent -> {
+            onlineProperty.removeListener(onlineServicesListener);
+            onlineProperty.setValue(true);
+            onlineProperty.addListener(onlineServicesListener);
+
+            if(connectionService.getValue() != null) {
+                EventManager.get().post(connectionService.getValue());
+            }
+        });
+        connectionService.setOnFailed(failEvent -> {
+            //Close connection here to create a new transport next time we try
+            connectionService.resetConnection();
+
+            onlineProperty.removeListener(onlineServicesListener);
+            onlineProperty.setValue(false);
+            onlineProperty.addListener(onlineServicesListener);
+
+            log.debug("Connection failed", failEvent.getSource().getException());
+            EventManager.get().post(new ConnectionFailedEvent(failEvent.getSource().getException()));
+        });
+
+        return connectionService;
+    }
+
+    private ExchangeSource.RatesService createRatesService(ExchangeSource exchangeSource, Currency currency) {
+        ExchangeSource.RatesService ratesService = new ExchangeSource.RatesService(exchangeSource, currency);
+        ratesService.setPeriod(new Duration(RATES_PERIOD));
+        ratesService.setRestartOnFailure(true);
+
+        ratesService.setOnSucceeded(successEvent -> {
+            EventManager.get().post(ratesService.getValue());
+        });
+
+        return ratesService;
+    }
+
+    private VersionCheckService createVersionCheckService() {
+        VersionCheckService versionCheckService = new VersionCheckService();
+        versionCheckService.setDelay(Duration.seconds(10));
+        versionCheckService.setPeriod(Duration.hours(VERSION_CHECK_PERIOD_HOURS));
+        versionCheckService.setRestartOnFailure(true);
+
+        versionCheckService.setOnSucceeded(successEvent -> {
+            VersionUpdatedEvent event = versionCheckService.getValue();
+            if(event != null) {
+                EventManager.get().post(event);
+            }
+        });
+
+        return versionCheckService;
+    }
+
+    private Hwi.ScheduledEnumerateService createDeviceEnumerateService() {
+        Hwi.ScheduledEnumerateService enumerateService = new Hwi.ScheduledEnumerateService(null);
+        enumerateService.setPeriod(new Duration(ENUMERATE_HW_PERIOD));
+        enumerateService.setOnSucceeded(workerStateEvent -> {
+            List<Device> devices = enumerateService.getValue();
+
+            //Null devices are returned if the app is currently prompting for a pin. Otherwise, the enumerate clears the pin screen
+            if(devices != null) {
+                //If another instance of HWI is currently accessing the usb interface, HWI returns empty device models. Ignore this run if that happens
+                List<Device> validDevices = devices.stream().filter(device -> device.getModel() != null).collect(Collectors.toList());
+                if(validDevices.size() == devices.size()) {
+                    Platform.runLater(() -> EventManager.get().post(new UsbDeviceEvent(devices)));
+                }
+            }
+        });
+
+        return enumerateService;
+    }
+
+    static void initialize(MainApp application) {
+        INSTANCE = new AppServices(application);
+    }
+
+    public static AppServices get() {
+        return INSTANCE;
+    }
+
+    public static AppController newAppWindow(Stage stage) {
+        try {
+            FXMLLoader appLoader = new FXMLLoader(AppServices.class.getResource("app.fxml"));
+            Parent root = appLoader.load();
+            AppController appController = appLoader.getController();
+
+            Scene scene = new Scene(root);
+            scene.getStylesheets().add(AppServices.class.getResource("app.css").toExternalForm());
+
+            stage.setTitle("Sparrow");
+            stage.setMinWidth(650);
+            stage.setMinHeight(800);
+            stage.setScene(scene);
+            stage.getIcons().add(new Image(MainApp.class.getResourceAsStream("/image/sparrow.png")));
+
+            appController.initializeView();
+            stage.show();
+            return appController;
+        } catch(IOException e) {
+            log.error("Could not load app FXML", e);
+            throw new IllegalStateException(e);
+        }
+    }
+
+    public MainApp getApplication() {
+        return application;
+    }
+
+    public Map<Wallet, Storage> getOpenWallets(Window window) {
+        return walletWindows.get(window);
+    }
+
+    public Window getWindowForWallet(Storage storage) {
+        Optional<Window> optWindow = walletWindows.entrySet().stream().filter(entry -> entry.getValue().values().stream().anyMatch(storage1 -> storage1.getWalletFile().equals(storage.getWalletFile()))).map(Map.Entry::getKey).findFirst();
+        return optWindow.orElse(null);
+    }
+
+    public Window getWindowForPSBT(PSBT psbt) {
+        Optional<Window> optWindow = walletWindows.entrySet().stream().filter(entry -> entry.getValue().keySet().stream().anyMatch(wallet -> wallet.canSign(psbt))).map(Map.Entry::getKey).findFirst();
+        return optWindow.orElse(null);
+    }
+
+    public double getWalletWindowMaxX() {
+        return walletWindows.keySet().stream().mapToDouble(Window::getX).max().orElse(0d);
+    }
+
+    public static boolean isOnline() {
+        return onlineProperty.get();
+    }
+
+    public static BooleanProperty onlineProperty() {
+        return onlineProperty;
+    }
+
+    public static Integer getCurrentBlockHeight() {
+        return currentBlockHeight;
+    }
+
+    public static Map<Integer, Double> getTargetBlockFeeRates() {
+        return targetBlockFeeRates;
+    }
+
+    public static Map<Date, Set<MempoolRateSize>> getMempoolHistogram() {
+        return mempoolHistogram;
+    }
+
+    private void addMempoolRateSizes(Set<MempoolRateSize> rateSizes) {
+        LocalDateTime dateMinute = LocalDateTime.now().truncatedTo(ChronoUnit.MINUTES);
+        if(mempoolHistogram.isEmpty()) {
+            mempoolHistogram.put(Date.from(dateMinute.minusMinutes(1).atZone(ZoneId.systemDefault()).toInstant()), rateSizes);
+        }
+
+        mempoolHistogram.put(Date.from(dateMinute.atZone(ZoneId.systemDefault()).toInstant()), rateSizes);
+    }
+
+    public static Double getMinimumRelayFeeRate() {
+        return minimumRelayFeeRate == null ? Transaction.DEFAULT_MIN_RELAY_FEE : minimumRelayFeeRate;
+    }
+
+    public static CurrencyRate getFiatCurrencyExchangeRate() {
+        return fiatCurrencyExchangeRate;
+    }
+
+    public static List<Device> getDevices() {
+        return devices == null ? new ArrayList<>() : devices;
+    }
+
+    public static BitcoinURI getPayjoinURI(Address address) {
+        return payjoinURIs.get(address);
+    }
+
+    public static void addPayjoinURI(BitcoinURI bitcoinURI) {
+        if(bitcoinURI.getPayjoinUrl() == null) {
+            throw new IllegalArgumentException("Not a payjoin URI");
+        }
+        payjoinURIs.put(bitcoinURI.getAddress(), bitcoinURI);
+    }
+
+    public static void showErrorDialog(String title, String content) {
+        Alert alert = new Alert(Alert.AlertType.ERROR);
+        setStageIcon(alert.getDialogPane().getScene().getWindow());
+        alert.getDialogPane().getScene().getStylesheets().add(AppServices.class.getResource("general.css").toExternalForm());
+        alert.setTitle(title);
+        alert.setHeaderText(title);
+        alert.setContentText(content);
+        alert.showAndWait();
+    }
+
+    public static void setStageIcon(Window window) {
+        Stage stage = (Stage)window;
+        stage.getIcons().add(new Image(AppServices.class.getResourceAsStream("/image/sparrow.png")));
+
+        if(stage.getScene() != null && Config.get().getTheme() == Theme.DARK) {
+            stage.getScene().getStylesheets().add(AppServices.class.getResource("darktheme.css").toExternalForm());
+        }
+    }
+
+    public static Font getMonospaceFont() {
+        return Font.font("Roboto Mono", 13);
+    }
+
+    @Subscribe
+    public void newConnection(ConnectionEvent event) {
+        currentBlockHeight = event.getBlockHeight();
+        targetBlockFeeRates = event.getTargetBlockFeeRates();
+        addMempoolRateSizes(event.getMempoolRateSizes());
+        minimumRelayFeeRate = event.getMinimumRelayFeeRate();
+        String banner = event.getServerBanner();
+        String status = "Connected to " + Config.get().getElectrumServer() + " at height " + event.getBlockHeight();
+        EventManager.get().post(new StatusEvent(status));
+    }
+
+    @Subscribe
+    public void connectionFailed(ConnectionFailedEvent event) {
+        String reason = event.getException().getCause() != null ? event.getException().getCause().getMessage() : event.getException().getMessage();
+        String status = "Connection error: " + reason;
+        EventManager.get().post(new StatusEvent(status));
+    }
+
+    @Subscribe
+    public void usbDevicesFound(UsbDeviceEvent event) {
+        devices = Collections.unmodifiableList(event.getDevices());
+    }
+
+    @Subscribe
+    public void newBlock(NewBlockEvent event) {
+        currentBlockHeight = event.getHeight();
+        String status = "Updating to new block height " + event.getHeight();
+        EventManager.get().post(new StatusEvent(status));
+    }
+
+    @Subscribe
+    public void feesUpdated(FeeRatesUpdatedEvent event) {
+        targetBlockFeeRates = event.getTargetBlockFeeRates();
+        addMempoolRateSizes(event.getMempoolRateSizes());
+    }
+
+    @Subscribe
+    public void feeRateSourceChanged(FeeRatesSourceChangedEvent event) {
+        ElectrumServer.FeeRatesService feeRatesService = new ElectrumServer.FeeRatesService();
+        feeRatesService.setOnSucceeded(workerStateEvent -> {
+            EventManager.get().post(feeRatesService.getValue());
+        });
+        //Perform once-off fee rates retrieval to immediately change displayed rates
+        feeRatesService.start();
+    }
+
+    @Subscribe
+    public void fiatCurrencySelected(FiatCurrencySelectedEvent event) {
+        ratesService.cancel();
+
+        if(Config.get().getMode() != Mode.OFFLINE && event.getExchangeSource() != ExchangeSource.NONE) {
+            ratesService = createRatesService(event.getExchangeSource(), event.getCurrency());
+            ratesService.start();
+        }
+    }
+
+    @Subscribe
+    public void exchangeRatesUpdated(ExchangeRatesUpdatedEvent event) {
+        fiatCurrencyExchangeRate = event.getCurrencyRate();
+    }
+
+    @Subscribe
+    public void versionCheckStatus(VersionCheckStatusEvent event) {
+        versionCheckService.cancel();
+
+        if(Config.get().getMode() != Mode.OFFLINE && event.isEnabled()) {
+            versionCheckService = createVersionCheckService();
+            versionCheckService.start();
+        }
+    }
+
+    @Subscribe
+    public void openWallets(OpenWalletsEvent event) {
+        if(event.getWalletsMap().isEmpty()) {
+            walletWindows.remove(event.getWindow());
+        } else {
+            walletWindows.put(event.getWindow(), event.getWalletsMap());
+        }
+
+        List<Map.Entry<Wallet, Storage>> allWallets = walletWindows.values().stream().flatMap(map -> map.entrySet().stream()).collect(Collectors.toList());
+
+        Platform.runLater(() -> {
+            if(!Window.getWindows().isEmpty()) {
+                List<File> walletFiles = allWallets.stream().map(entry -> entry.getValue().getWalletFile()).collect(Collectors.toList());
+                Config.get().setRecentWalletFiles(walletFiles);
+            }
+        });
+
+        boolean usbWallet = false;
+        for(Map.Entry<Wallet, Storage> entry : allWallets) {
+            Wallet wallet = entry.getKey();
+            Storage storage = entry.getValue();
+
+            if(!storage.getWalletFile().exists() || wallet.containsSource(KeystoreSource.HW_USB)) {
+                usbWallet = true;
+
+                if(deviceEnumerateService == null) {
+                    deviceEnumerateService = createDeviceEnumerateService();
+                }
+
+                if(deviceEnumerateService.getState() == Worker.State.CANCELLED) {
+                    deviceEnumerateService.reset();
+                }
+
+                if(!deviceEnumerateService.isRunning()) {
+                    deviceEnumerateService.start();
+                }
+
+                break;
+            }
+        }
+
+        if(!usbWallet && deviceEnumerateService != null && deviceEnumerateService.isRunning()) {
+            deviceEnumerateService.cancel();
+            EventManager.get().post(new UsbDeviceEvent(Collections.emptyList()));
+        }
+    }
+
+    @Subscribe
+    public void requestConnect(RequestConnectEvent event) {
+        onlineProperty.set(true);
+    }
+
+    @Subscribe
+    public void requestDisconnect(RequestDisconnectEvent event) {
+        onlineProperty.set(false);
+    }
+}

src/main/java/com/sparrowwallet/sparrow/MainApp.java

@@ -31,7 +31,7 @@ public class MainApp extends Application {
     private static final Logger log = LoggerFactory.getLogger(MainApp.class);
 
     public static final String APP_NAME = "Sparrow";
-    public static final String APP_VERSION = "0.9.6";
+    public static final String APP_VERSION = "0.9.9";
     public static final String APP_HOME_PROPERTY = "sparrow.home";
     public static final String NETWORK_ENV_PROPERTY = "SPARROW_NETWORK";
 
@@ -49,7 +49,7 @@ public class MainApp extends Application {
 
         GlyphFontRegistry.register(new FontAwesome5());
         GlyphFontRegistry.register(new FontAwesome5Brands());
-        Font.loadFont(AppController.class.getResourceAsStream("/font/RobotoMono-Regular.ttf"), 13);
+        Font.loadFont(AppServices.class.getResourceAsStream("/font/RobotoMono-Regular.ttf"), 13);
 
         boolean createNewWallet = false;
         Mode mode = Config.get().getMode();
@@ -68,23 +68,8 @@ public class MainApp extends Application {
             }
         }
 
-        FXMLLoader transactionLoader = new FXMLLoader(getClass().getResource("app.fxml"));
-        Parent root = transactionLoader.load();
-        AppController appController = transactionLoader.getController();
-        appController.setApplication(this);
-
-        Scene scene = new Scene(root);
-        scene.getStylesheets().add(getClass().getResource("app.css").toExternalForm());
-
-        stage.setTitle("Sparrow");
-        stage.setMinWidth(650);
-        stage.setMinHeight(700);
-        stage.setScene(scene);
-        stage.getIcons().add(new Image(MainApp.class.getResourceAsStream("/image/sparrow.png")));
-
-        appController.initializeView();
-
-        stage.show();
+        AppServices.initialize(this);
+        AppController appController = AppServices.newAppWindow(stage);
 
         if(createNewWallet) {
             appController.newWallet(null);
@@ -92,7 +77,7 @@ public class MainApp extends Application {
 
         List<File> recentWalletFiles = Config.get().getRecentWalletFiles();
         if(recentWalletFiles != null) {
-            //Resort to preserve wallet order as far as possible. Unencrypted wallets will still be opened first.
+            //Re-sort to preserve wallet order as far as possible. Unencrypted wallets will still be opened first.
             List<File> encryptedWalletFiles = recentWalletFiles.stream().filter(file -> FileType.BINARY.equals(IOUtils.getFileType(file))).collect(Collectors.toList());
             Collections.reverse(encryptedWalletFiles);
             List<File> sortedWalletFiles = new ArrayList<>(recentWalletFiles);
@@ -101,10 +86,12 @@ public class MainApp extends Application {
 
             for(File walletFile : sortedWalletFiles) {
                 if(walletFile.exists()) {
-                    Platform.runLater(() -> appController.openWalletFile(walletFile));
+                    appController.openWalletFile(walletFile, false);
                 }
             }
         }
+
+        AppServices.get().start();
     }
 
     @Override

src/main/java/com/sparrowwallet/sparrow/TabData.java

@@ -1,11 +1,7 @@
 package com.sparrowwallet.sparrow;
 
-import java.io.File;
-
 public class TabData {
-    private TabType type;
-    private File file;
-    private String text;
+    private final TabType type;
 
     public TabData(TabType type) {
         this.type = type;
@@ -15,22 +11,6 @@ public class TabData {
         return type;
     }
 
-    public File getFile() {
-        return file;
-    }
-
-    public void setFile(File file) {
-        this.file = file;
-    }
-
-    public String getText() {
-        return text;
-    }
-
-    public void setText(String text) {
-        this.text = text;
-    }
-
     public enum TabType {
         WALLET, TRANSACTION
     }

src/main/java/com/sparrowwallet/sparrow/TransactionTabData.java

@@ -4,14 +4,22 @@ import com.sparrowwallet.drongo.protocol.Transaction;
 import com.sparrowwallet.drongo.psbt.PSBT;
 import com.sparrowwallet.sparrow.transaction.TransactionData;
 
+import java.io.File;
+
 public class TransactionTabData extends TabData {
+    private final File file;
     private final TransactionData transactionData;
 
-    public TransactionTabData(TabType type, TransactionData transactionData) {
+    public TransactionTabData(TabType type, File file, TransactionData transactionData) {
         super(type);
+        this.file = file;
         this.transactionData = transactionData;
     }
 
+    public File getFile() {
+        return file;
+    }
+
     public TransactionData getTransactionData() {
         return transactionData;
     }

src/main/java/com/sparrowwallet/sparrow/control/AddressTreeTable.java

@@ -1,7 +1,7 @@
 package com.sparrowwallet.sparrow.control;
 
 import com.sparrowwallet.drongo.wallet.WalletNode;
-import com.sparrowwallet.sparrow.AppController;
+import com.sparrowwallet.sparrow.AppServices;
 import com.sparrowwallet.sparrow.EventManager;
 import com.sparrowwallet.sparrow.event.ReceiveActionEvent;
 import com.sparrowwallet.sparrow.event.ReceiveToEvent;
@@ -14,6 +14,7 @@ import javafx.scene.input.MouseButton;
 
 import java.util.List;
 import java.util.Optional;
+import java.util.OptionalInt;
 
 public class AddressTreeTable extends CoinTreeTable {
     public void initialize(NodeEntry rootEntry) {
@@ -33,7 +34,7 @@ public class AddressTreeTable extends CoinTreeTable {
         getColumns().add(addressCol);
 
         if(address != null) {
-            addressCol.setMinWidth(TextUtils.computeTextWidth(AppController.getMonospaceFont(), address, 0.0));
+            addressCol.setMinWidth(TextUtils.computeTextWidth(AppServices.getMonospaceFont(), address, 0.0));
         }
 
         TreeTableColumn<Entry, String> labelCol = new TreeTableColumn<>("Label");
@@ -60,7 +61,10 @@ public class AddressTreeTable extends CoinTreeTable {
 
         Integer highestUsedIndex = rootEntry.getNode().getHighestUsedIndex();
         if(highestUsedIndex != null) {
-            scrollTo(highestUsedIndex);
+            OptionalInt tableIndex = rootEntry.getChildren().stream().filter(childEntry -> ((NodeEntry)childEntry).getNode().getIndex() == highestUsedIndex + 1).mapToInt(childEntry -> rootEntry.getChildren().indexOf(childEntry)).findFirst();
+            if(tableIndex.isPresent() && tableIndex.getAsInt() > 5) {
+                scrollTo(tableIndex.getAsInt());
+            }
         }
 
         setOnMouseClicked(mouseEvent -> {

src/main/java/com/sparrowwallet/sparrow/control/BalanceChart.java

@@ -82,9 +82,9 @@ public class BalanceChart extends LineChart<Number, Number> {
 
         for(int i = 0; i < balanceSeries.getData().size(); i++) {
             XYChart.Data<Number, Number> data = balanceSeries.getData().get(i);
-            Node symbol = lookup(".chart-line-symbol.data" + i);
-            if(symbol != null) {
-                if(transactionEntry.getBlockTransaction().getDate() != null && data.getXValue().equals(transactionEntry.getBlockTransaction().getDate().getTime()) && data.getExtraValue() != null) {
+            if(transactionEntry.getBlockTransaction().getDate() != null && data.getXValue().equals(transactionEntry.getBlockTransaction().getDate().getTime()) && data.getExtraValue() != null) {
+                Node symbol = lookup(".chart-line-symbol.data" + i);
+                if(symbol != null) {
                     symbol.getStyleClass().add("selected");
                     selectedEntry = transactionEntry;
                 }

src/main/java/com/sparrowwallet/sparrow/control/BlockTargetFeeRatesChart.java

@@ -9,11 +9,11 @@ import javafx.scene.chart.XYChart;
 import java.util.Iterator;
 import java.util.Map;
 
-public class FeeRatesChart extends LineChart<String, Number> {
+public class BlockTargetFeeRatesChart extends LineChart<String, Number> {
     private XYChart.Series<String, Number> feeRateSeries;
     private Integer selectedTargetBlocks;
 
-    public FeeRatesChart(@NamedArg("xAxis") Axis<String> xAxis, @NamedArg("yAxis") Axis<Number> yAxis) {
+    public BlockTargetFeeRatesChart(@NamedArg("xAxis") Axis<String> xAxis, @NamedArg("yAxis") Axis<Number> yAxis) {
         super(xAxis, yAxis);
     }
 

src/main/java/com/sparrowwallet/sparrow/control/CoinTreeTable.java

@@ -38,18 +38,23 @@ public class CoinTreeTable extends TreeTableView<Entry> {
     }
 
     public void updateHistoryStatus(WalletHistoryStatusEvent event) {
-        Platform.runLater(() -> {
-            if(event.getErrorMessage() != null) {
-                setPlaceholder(new Label("Error loading transactions: " + event.getErrorMessage()));
-            } else if(event.isLoading()) {
-                if(event.getStatusMessage() != null) {
-                    setPlaceholder(new Label(event.getStatusMessage() + "..."));
-                } else {
-                    setPlaceholder(new Label("Loading transactions..."));
-                }
-            } else {
-                setPlaceholder(new Label("No transactions"));
+        if(getRoot() != null) {
+            Entry entry = getRoot().getValue();
+            if(entry != null && event.getWallet() != null && entry.getWallet() == event.getWallet()) {
+                Platform.runLater(() -> {
+                    if(event.getErrorMessage() != null) {
+                        setPlaceholder(new Label("Error loading transactions: " + event.getErrorMessage()));
+                    } else if(event.isLoading()) {
+                        if(event.getStatusMessage() != null) {
+                            setPlaceholder(new Label(event.getStatusMessage() + "..."));
+                        } else {
+                            setPlaceholder(new Label("Loading transactions..."));
+                        }
+                    } else {
+                        setPlaceholder(new Label("No transactions"));
+                    }
+                });
             }
-        });
+        }
     }
 }

src/main/java/com/sparrowwallet/sparrow/control/DeviceDialog.java

@@ -1,6 +1,6 @@
 package com.sparrowwallet.sparrow.control;
 
-import com.sparrowwallet.sparrow.AppController;
+import com.sparrowwallet.sparrow.AppServices;
 import com.sparrowwallet.sparrow.EventManager;
 import com.sparrowwallet.sparrow.event.UsbDeviceEvent;
 import com.sparrowwallet.sparrow.glyphfont.FontAwesome5Brands;
@@ -33,8 +33,8 @@ public abstract class DeviceDialog<R> extends Dialog<R> {
         this.operationFingerprints = operationFingerprints;
 
         final DialogPane dialogPane = getDialogPane();
-        dialogPane.getStylesheets().add(AppController.class.getResource("general.css").toExternalForm());
-        AppController.setStageIcon(dialogPane.getScene().getWindow());
+        dialogPane.getStylesheets().add(AppServices.class.getResource("general.css").toExternalForm());
+        AppServices.setStageIcon(dialogPane.getScene().getWindow());
 
         StackPane stackPane = new StackPane();
         dialogPane.setContent(stackPane);
@@ -67,7 +67,7 @@ public abstract class DeviceDialog<R> extends Dialog<R> {
 
         stackPane.getChildren().addAll(anchorPane, scanBox);
 
-        List<Device> devices = AppController.getDevices();
+        List<Device> devices = AppServices.getDevices();
         if(devices == null || devices.isEmpty()) {
             scanBox.setVisible(true);
         } else {

src/main/java/com/sparrowwallet/sparrow/control/DevicePane.java

@@ -3,6 +3,7 @@ package com.sparrowwallet.sparrow.control;
 import com.sparrowwallet.drongo.ExtendedKey;
 import com.sparrowwallet.drongo.KeyDerivation;
 import com.sparrowwallet.drongo.crypto.ChildNumber;
+import com.sparrowwallet.drongo.protocol.ScriptType;
 import com.sparrowwallet.drongo.psbt.PSBT;
 import com.sparrowwallet.drongo.wallet.Keystore;
 import com.sparrowwallet.drongo.wallet.KeystoreSource;
@@ -31,10 +32,14 @@ import org.controlsfx.validation.ValidationResult;
 import org.controlsfx.validation.ValidationSupport;
 import org.controlsfx.validation.Validator;
 import org.controlsfx.validation.decoration.StyleClassValidationDecoration;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import java.util.List;
 
 public class DevicePane extends TitledDescriptionPane {
+    private static final Logger log = LoggerFactory.getLogger(DevicePane.class);
+
     private final DeviceOperation deviceOperation;
     private final Wallet wallet;
     private final PSBT psbt;
@@ -68,7 +73,12 @@ public class DevicePane extends TitledDescriptionPane {
         createSetPassphraseButton();
         createImportButton();
 
-        if (device.getNeedsPinSent() != null && device.getNeedsPinSent()) {
+        if(device.getError() != null) {
+            setError("Error", device.getError());
+            Platform.runLater(() -> {
+                setExpanded(true);
+            });
+        } else if(device.getNeedsPinSent() != null && device.getNeedsPinSent()) {
             unlockButton.setVisible(true);
         } else if(device.getNeedsPassphraseSent() != null && device.getNeedsPassphraseSent()) {
             setPassphraseButton.setVisible(true);
@@ -199,7 +209,8 @@ public class DevicePane extends TitledDescriptionPane {
             importKeystore(wallet.getScriptType().getDefaultDerivation());
         });
         String[] accounts = new String[] {"Default Account #0", "Account #1", "Account #2", "Account #3", "Account #4", "Account #5", "Account #6", "Account #7", "Account #8", "Account #9"};
-        for(int i = 0; i < accounts.length; i++) {
+        int scriptAccountsLength = ScriptType.P2SH.equals(wallet.getScriptType()) ? 1 : accounts.length;
+        for(int i = 0; i < scriptAccountsLength; i++) {
             MenuItem item = new MenuItem(accounts[i]);
             final List<ChildNumber> derivation = wallet.getScriptType().getDefaultDerivation(i);
             item.setOnAction(event -> {
@@ -465,6 +476,7 @@ public class DevicePane extends TitledDescriptionPane {
         });
         signPSBTService.setOnFailed(workerStateEvent -> {
             setError("Signing Error", signPSBTService.getException().getMessage());
+            log.error("Signing Error: " + signPSBTService.getException().getMessage());
             signButton.setDisable(false);
         });
         setDescription("Signing...");

src/main/java/com/sparrowwallet/sparrow/control/EntryCell.java

@@ -2,8 +2,10 @@ package com.sparrowwallet.sparrow.control;
 
 import com.sparrowwallet.drongo.Utils;
 import com.sparrowwallet.drongo.address.Address;
-import com.sparrowwallet.drongo.wallet.BlockTransaction;
-import com.sparrowwallet.drongo.wallet.KeystoreSource;
+import com.sparrowwallet.drongo.protocol.Transaction;
+import com.sparrowwallet.drongo.protocol.TransactionOutput;
+import com.sparrowwallet.drongo.wallet.*;
+import com.sparrowwallet.sparrow.AppServices;
 import com.sparrowwallet.sparrow.EventManager;
 import com.sparrowwallet.sparrow.event.*;
 import com.sparrowwallet.sparrow.glyphfont.FontAwesome5;
@@ -19,7 +21,7 @@ import org.controlsfx.glyphfont.Glyph;
 
 import java.text.DateFormat;
 import java.text.SimpleDateFormat;
-import java.util.List;
+import java.util.*;
 import java.util.stream.Collectors;
 
 class EntryCell extends TreeTableCell<Entry, Entry> {
@@ -46,10 +48,10 @@ class EntryCell extends TreeTableCell<Entry, Entry> {
                 TransactionEntry transactionEntry = (TransactionEntry)entry;
                 if(transactionEntry.getBlockTransaction().getHeight() == -1) {
                     setText("Unconfirmed Parent");
-                    setContextMenu(new UnconfirmedTransactionContextMenu(transactionEntry.getBlockTransaction()));
+                    setContextMenu(new UnconfirmedTransactionContextMenu(transactionEntry));
                 } else if(transactionEntry.getBlockTransaction().getHeight() == 0) {
                     setText("Unconfirmed");
-                    setContextMenu(new UnconfirmedTransactionContextMenu(transactionEntry.getBlockTransaction()));
+                    setContextMenu(new UnconfirmedTransactionContextMenu(transactionEntry));
                 } else {
                     String date = DATE_FORMAT.format(transactionEntry.getBlockTransaction().getDate());
                     setText(date);
@@ -60,14 +62,29 @@ class EntryCell extends TreeTableCell<Entry, Entry> {
                 tooltip.setText(transactionEntry.getBlockTransaction().getHash().toString());
                 setTooltip(tooltip);
 
+                HBox actionBox = new HBox();
                 Button viewTransactionButton = new Button("");
                 Glyph searchGlyph = new Glyph(FontAwesome5.FONT_NAME, FontAwesome5.Glyph.SEARCH);
                 searchGlyph.setFontSize(12);
                 viewTransactionButton.setGraphic(searchGlyph);
                 viewTransactionButton.setOnAction(event -> {
-                    EventManager.get().post(new ViewTransactionEvent(transactionEntry.getBlockTransaction()));
+                    EventManager.get().post(new ViewTransactionEvent(this.getScene().getWindow(), transactionEntry.getBlockTransaction()));
                 });
-                setGraphic(viewTransactionButton);
+                actionBox.getChildren().add(viewTransactionButton);
+
+                BlockTransaction blockTransaction = transactionEntry.getBlockTransaction();
+                if(blockTransaction.getHeight() <= 0 && blockTransaction.getTransaction().isReplaceByFee() && transactionEntry.getWallet().allInputsFromWallet(blockTransaction.getHash())) {
+                    Button increaseFeeButton = new Button("");
+                    Glyph increaseFeeGlyph = new Glyph(FontAwesome5.FONT_NAME, FontAwesome5.Glyph.HAND_HOLDING_MEDICAL);
+                    increaseFeeGlyph.setFontSize(12);
+                    increaseFeeButton.setGraphic(increaseFeeGlyph);
+                    increaseFeeButton.setOnAction(event -> {
+                        increaseFee(transactionEntry);
+                    });
+                    actionBox.getChildren().add(increaseFeeButton);
+                }
+
+                setGraphic(actionBox);
             } else if(entry instanceof NodeEntry) {
                 NodeEntry nodeEntry = (NodeEntry)entry;
                 Address address = nodeEntry.getAddress();
@@ -107,7 +124,7 @@ class EntryCell extends TreeTableCell<Entry, Entry> {
             } else if(entry instanceof HashIndexEntry) {
                 HashIndexEntry hashIndexEntry = (HashIndexEntry)entry;
                 setText(hashIndexEntry.getDescription());
-                setContextMenu(new HashIndexEntryContextMenu(hashIndexEntry));
+                setContextMenu(new HashIndexEntryContextMenu(getTreeTableView(), hashIndexEntry));
                 Tooltip tooltip = new Tooltip();
                 tooltip.setText(hashIndexEntry.getHashIndex().toString());
                 setTooltip(tooltip);
@@ -118,30 +135,17 @@ class EntryCell extends TreeTableCell<Entry, Entry> {
                 searchGlyph.setFontSize(12);
                 viewTransactionButton.setGraphic(searchGlyph);
                 viewTransactionButton.setOnAction(event -> {
-                    EventManager.get().post(new ViewTransactionEvent(hashIndexEntry.getBlockTransaction(), hashIndexEntry));
+                    EventManager.get().post(new ViewTransactionEvent(this.getScene().getWindow(), hashIndexEntry.getBlockTransaction(), hashIndexEntry));
                 });
                 actionBox.getChildren().add(viewTransactionButton);
 
-                if(hashIndexEntry.getType().equals(HashIndexEntry.Type.OUTPUT) && hashIndexEntry.isSpendable()) {
+                if(hashIndexEntry.getType().equals(HashIndexEntry.Type.OUTPUT) && hashIndexEntry.isSpendable() && !hashIndexEntry.getHashIndex().isSpent()) {
                     Button spendUtxoButton = new Button("");
                     Glyph sendGlyph = new Glyph("FontAwesome", FontAwesome.Glyph.SEND);
                     sendGlyph.setFontSize(12);
                     spendUtxoButton.setGraphic(sendGlyph);
                     spendUtxoButton.setOnAction(event -> {
-                        List<HashIndexEntry> utxoEntries = getTreeTableView().getSelectionModel().getSelectedCells().stream()
-                                .map(tp -> tp.getTreeItem().getValue())
-                                .filter(e -> e instanceof HashIndexEntry)
-                                .map(e -> (HashIndexEntry)e)
-                                .filter(e -> e.getType().equals(HashIndexEntry.Type.OUTPUT) && e.isSpendable())
-                                .collect(Collectors.toList());
-
-                        if(!utxoEntries.contains(hashIndexEntry)) {
-                            utxoEntries = List.of(hashIndexEntry);
-                        }
-
-                        final List<HashIndexEntry> spendingUtxoEntries = utxoEntries;
-                        EventManager.get().post(new SendActionEvent(utxoEntries));
-                        Platform.runLater(() -> EventManager.get().post(new SpendUtxoEvent(spendingUtxoEntries)));
+                        sendSelectedUtxos(getTreeTableView(), hashIndexEntry);
                     });
                     actionBox.getChildren().add(spendUtxoButton);
                 }
@@ -151,8 +155,90 @@ class EntryCell extends TreeTableCell<Entry, Entry> {
         }
     }
 
+    private static void increaseFee(TransactionEntry transactionEntry) {
+        BlockTransaction blockTransaction = transactionEntry.getBlockTransaction();
+        Map<BlockTransactionHashIndex, WalletNode> walletTxos = transactionEntry.getWallet().getWalletTxos();
+        List<BlockTransactionHashIndex> utxos = transactionEntry.getChildren().stream()
+                .filter(e -> e instanceof HashIndexEntry)
+                .map(e -> (HashIndexEntry)e)
+                .filter(e -> e.getType().equals(HashIndexEntry.Type.INPUT) && e.isSpendable())
+                .map(e -> blockTransaction.getTransaction().getInputs().get((int)e.getHashIndex().getIndex()))
+                .map(txInput -> walletTxos.keySet().stream().filter(txo -> txo.getHash().equals(txInput.getOutpoint().getHash()) && txo.getIndex() == txInput.getOutpoint().getIndex()).findFirst().get())
+                .collect(Collectors.toList());
+
+        List<TransactionOutput> ourOutputs = transactionEntry.getChildren().stream()
+                .filter(e -> e instanceof HashIndexEntry)
+                .map(e -> (HashIndexEntry)e)
+                .filter(e -> e.getType().equals(HashIndexEntry.Type.OUTPUT))
+                .map(e -> e.getBlockTransaction().getTransaction().getOutputs().get((int)e.getHashIndex().getIndex()))
+                .collect(Collectors.toList());
+
+        long changeTotal = ourOutputs.stream().mapToLong(TransactionOutput::getValue).sum();
+        Transaction tx = blockTransaction.getTransaction();
+        int vSize = tx.getVirtualSize();
+        int inputSize = tx.getInputs().get(0).getLength() + (tx.getInputs().get(0).hasWitness() ? tx.getInputs().get(0).getWitness().getLength() / Transaction.WITNESS_SCALE_FACTOR : 0);
+        List<BlockTransactionHashIndex> walletUtxos = new ArrayList<>(transactionEntry.getWallet().getWalletUtxos().keySet());
+        Collections.shuffle(walletUtxos);
+        while((double)changeTotal / vSize < getMaxFeeRate() && !walletUtxos.isEmpty()) {
+            //If there is insufficent change output, include another random UTXO so the fee can be increased
+            BlockTransactionHashIndex utxo = walletUtxos.remove(0);
+            utxos.add(utxo);
+            changeTotal += utxo.getValue();
+            vSize += inputSize;
+        }
+
+        List<TransactionOutput> externalOutputs = new ArrayList<>(blockTransaction.getTransaction().getOutputs());
+        externalOutputs.removeAll(ourOutputs);
+        List<Payment> payments = externalOutputs.stream().map(txOutput -> {
+            try {
+                return new Payment(txOutput.getScript().getToAddresses()[0], transactionEntry.getLabel(), txOutput.getValue(), false);
+            } catch(Exception e) {
+                return null;
+            }
+        }).filter(Objects::nonNull).collect(Collectors.toList());
+
+        EventManager.get().post(new SendActionEvent(transactionEntry.getWallet(), utxos));
+        Platform.runLater(() -> EventManager.get().post(new SpendUtxoEvent(transactionEntry.getWallet(), utxos, payments, blockTransaction.getFee(), true)));
+    }
+
+    private static Double getMaxFeeRate() {
+        if(AppServices.getTargetBlockFeeRates().isEmpty()) {
+            return 100.0;
+        }
+
+        return AppServices.getTargetBlockFeeRates().values().iterator().next();
+    }
+
+    private static void sendSelectedUtxos(TreeTableView<Entry> treeTableView, HashIndexEntry hashIndexEntry) {
+        List<HashIndexEntry> utxoEntries = treeTableView.getSelectionModel().getSelectedCells().stream()
+                .map(tp -> tp.getTreeItem().getValue())
+                .filter(e -> e instanceof HashIndexEntry)
+                .map(e -> (HashIndexEntry)e)
+                .filter(e -> e.getType().equals(HashIndexEntry.Type.OUTPUT) && e.isSpendable())
+                .collect(Collectors.toList());
+
+        if(!utxoEntries.contains(hashIndexEntry)) {
+            utxoEntries = List.of(hashIndexEntry);
+        }
+
+        final List<BlockTransactionHashIndex> spendingUtxos = utxoEntries.stream().map(HashIndexEntry::getHashIndex).collect(Collectors.toList());
+        EventManager.get().post(new SendActionEvent(hashIndexEntry.getWallet(), spendingUtxos));
+        Platform.runLater(() -> EventManager.get().post(new SpendUtxoEvent(hashIndexEntry.getWallet(), spendingUtxos)));
+    }
+
+    private static void freezeUtxo(HashIndexEntry hashIndexEntry) {
+        hashIndexEntry.getHashIndex().setStatus(Status.FROZEN);
+        EventManager.get().post(new WalletUtxoStatusChangedEvent(hashIndexEntry.getWallet(), hashIndexEntry.getHashIndex()));
+    }
+
+    private static void unfreezeUtxo(HashIndexEntry hashIndexEntry) {
+        hashIndexEntry.getHashIndex().setStatus(null);
+        EventManager.get().post(new WalletUtxoStatusChangedEvent(hashIndexEntry.getWallet(), hashIndexEntry.getHashIndex()));
+    }
+
     private static class UnconfirmedTransactionContextMenu extends ContextMenu {
-        public UnconfirmedTransactionContextMenu(BlockTransaction blockTransaction) {
+        public UnconfirmedTransactionContextMenu(TransactionEntry transactionEntry) {
+            BlockTransaction blockTransaction = transactionEntry.getBlockTransaction();
             MenuItem copyTxid = new MenuItem("Copy Transaction ID");
             copyTxid.setOnAction(AE -> {
                 hide();
@@ -161,7 +247,17 @@ class EntryCell extends TreeTableCell<Entry, Entry> {
                 Clipboard.getSystemClipboard().setContent(content);
             });
 
-            getItems().addAll(copyTxid);
+            getItems().add(copyTxid);
+
+            if(blockTransaction.getTransaction().isReplaceByFee() && transactionEntry.getWallet().allInputsFromWallet(blockTransaction.getHash())) {
+                MenuItem increaseFee = new MenuItem("Increase Fee");
+                increaseFee.setOnAction(AE -> {
+                    hide();
+                    increaseFee(transactionEntry);
+                });
+
+                getItems().add(increaseFee);
+            }
         }
     }
 
@@ -237,7 +333,7 @@ class EntryCell extends TreeTableCell<Entry, Entry> {
     }
 
     private static class HashIndexEntryContextMenu extends ContextMenu {
-        public HashIndexEntryContextMenu(HashIndexEntry hashIndexEntry) {
+        public HashIndexEntryContextMenu(TreeTableView<Entry> treeTableView, HashIndexEntry hashIndexEntry) {
             String label = "Copy " + (hashIndexEntry.getType().equals(HashIndexEntry.Type.OUTPUT) ? "Transaction Output" : "Transaction Input");
             MenuItem copyHashIndex = new MenuItem(label);
             copyHashIndex.setOnAction(AE -> {
@@ -246,8 +342,34 @@ class EntryCell extends TreeTableCell<Entry, Entry> {
                 content.putString(hashIndexEntry.getHashIndex().toString());
                 Clipboard.getSystemClipboard().setContent(content);
             });
-
             getItems().add(copyHashIndex);
+
+            if(hashIndexEntry.getType().equals(HashIndexEntry.Type.OUTPUT) && hashIndexEntry.isSpendable() && !hashIndexEntry.getHashIndex().isSpent()) {
+                MenuItem sendSelected = new MenuItem("Send Selected");
+                sendSelected.setOnAction(AE -> {
+                    hide();
+                    sendSelectedUtxos(treeTableView, hashIndexEntry);
+                });
+                getItems().add(sendSelected);
+            }
+
+            if(hashIndexEntry.getType().equals(HashIndexEntry.Type.OUTPUT) && !hashIndexEntry.getHashIndex().isSpent()) {
+                if(hashIndexEntry.getHashIndex().getStatus() == null || hashIndexEntry.getHashIndex().getStatus() != Status.FROZEN) {
+                    MenuItem freezeUtxo = new MenuItem("Freeze UTXO");
+                    freezeUtxo.setOnAction(AE -> {
+                        hide();
+                        freezeUtxo(hashIndexEntry);
+                    });
+                    getItems().add(freezeUtxo);
+                } else {
+                    MenuItem unfreezeUtxo = new MenuItem("Unfreeze UTXO");
+                    unfreezeUtxo.setOnAction(AE -> {
+                        hide();
+                        unfreezeUtxo(hashIndexEntry);
+                    });
+                    getItems().add(unfreezeUtxo);
+                }
+            }
         }
     }
 

src/main/java/com/sparrowwallet/sparrow/control/FileImportPane.java

@@ -2,6 +2,9 @@ package com.sparrowwallet.sparrow.control;
 
 import com.google.gson.JsonParseException;
 import com.sparrowwallet.drongo.crypto.InvalidPasswordException;
+import com.sparrowwallet.drongo.protocol.ScriptType;
+import com.sparrowwallet.drongo.wallet.Keystore;
+import com.sparrowwallet.drongo.wallet.Wallet;
 import com.sparrowwallet.sparrow.glyphfont.FontAwesome5;
 import com.sparrowwallet.sparrow.io.FileImport;
 import com.sparrowwallet.sparrow.io.ImportException;
@@ -21,11 +24,13 @@ import org.controlsfx.control.SegmentedButton;
 import org.controlsfx.control.textfield.CustomPasswordField;
 import org.controlsfx.control.textfield.TextFields;
 import org.controlsfx.glyphfont.Glyph;
+import org.controlsfx.tools.Platform;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.io.*;
 import java.nio.charset.StandardCharsets;
+import java.util.List;
 import java.util.Optional;
 
 public abstract class FileImportPane extends TitledDescriptionPane {
@@ -35,6 +40,7 @@ public abstract class FileImportPane extends TitledDescriptionPane {
     protected ButtonBase importButton;
     private final SimpleStringProperty password = new SimpleStringProperty("");
     private final boolean scannable;
+    protected List<Wallet> wallets;
 
     public FileImportPane(FileImport importer, String title, String description, String content, String imageUrl, boolean scannable) {
         super(title, description, content, imageUrl);
@@ -84,7 +90,7 @@ public abstract class FileImportPane extends TitledDescriptionPane {
         FileChooser fileChooser = new FileChooser();
         fileChooser.setTitle("Open " + importer.getWalletModel().toDisplayString() + " File");
         fileChooser.getExtensionFilters().addAll(
-                new FileChooser.ExtensionFilter("All Files", "*"),
+                new FileChooser.ExtensionFilter("All Files", Platform.getCurrent().equals(Platform.UNIX) ? "*" : "*.*"),
                 new FileChooser.ExtensionFilter("JSON", "*.json"),
                 new FileChooser.ExtensionFilter("TXT", "*.txt")
         );
@@ -131,7 +137,14 @@ public abstract class FileImportPane extends TitledDescriptionPane {
         Optional<QRScanDialog.Result> optionalResult = qrScanDialog.showAndWait();
         if(optionalResult.isPresent()) {
             QRScanDialog.Result result = optionalResult.get();
-            if(result.payload != null) {
+            if(result.wallets != null) {
+                wallets = result.wallets;
+                try {
+                    importFile(importer.getName(), null, null);
+                } catch(ImportException e) {
+                    setError("Import Error", e.getMessage());
+                }
+            } else if(result.payload != null) {
                 try {
                     importFile(importer.getName(), new ByteArrayInputStream(result.payload.getBytes(StandardCharsets.UTF_8)), null);
                 } catch(Exception e) {
@@ -145,10 +158,27 @@ public abstract class FileImportPane extends TitledDescriptionPane {
                     }
                     setError("Import Error", errorMessage);
                 }
+            } else if(result.exception != null) {
+                log.error("Error importing QR", result.exception);
+                setError("Import Error", result.exception.getMessage());
             }
         }
     }
 
+    protected Keystore getScannedKeystore(ScriptType scriptType) throws ImportException {
+        if(wallets != null) {
+            for(Wallet wallet : wallets) {
+                if(scriptType.equals(wallet.getScriptType()) && !wallet.getKeystores().isEmpty()) {
+                    return wallet.getKeystores().get(0);
+                }
+            }
+
+            throw new ImportException("Script type " + scriptType + " is not supported");
+        }
+
+        return null;
+    }
+
     protected abstract void importFile(String fileName, InputStream inputStream, String password) throws ImportException;
 
     private Node getPasswordEntry(File file) {

src/main/java/com/sparrowwallet/sparrow/control/FileKeystoreImportPane.java

@@ -14,13 +14,17 @@ public class FileKeystoreImportPane extends FileImportPane {
     private final KeystoreFileImport importer;
 
     public FileKeystoreImportPane(Wallet wallet, KeystoreFileImport importer) {
-        super(importer, importer.getName(), "Keystore import", importer.getKeystoreImportDescription(), "image/" + importer.getWalletModel().getType() + ".png", importer.isScannable());
+        super(importer, importer.getName(), "Keystore import", importer.getKeystoreImportDescription(), "image/" + importer.getWalletModel().getType() + ".png", importer.isKeystoreImportScannable());
         this.wallet = wallet;
         this.importer = importer;
     }
 
     protected void importFile(String fileName, InputStream inputStream, String password) throws ImportException {
-        Keystore keystore = importer.getKeystore(wallet.getScriptType(), inputStream, password);
+        Keystore keystore = getScannedKeystore(wallet.getScriptType());
+        if(keystore == null) {
+            keystore = importer.getKeystore(wallet.getScriptType(), inputStream, password);
+        }
+
         EventManager.get().post(new KeystoreImportEvent(keystore));
     }
 }

src/main/java/com/sparrowwallet/sparrow/control/FileWalletImportPane.java

@@ -12,7 +12,7 @@ public class FileWalletImportPane extends FileImportPane {
     private final WalletImport importer;
 
     public FileWalletImportPane(WalletImport importer) {
-        super(importer, importer.getName(), "Wallet import", importer.getWalletImportDescription(), "image/" + importer.getWalletModel().getType() + ".png", importer.isScannable());
+        super(importer, importer.getName(), "Wallet import", importer.getWalletImportDescription(), "image/" + importer.getWalletModel().getType() + ".png", importer.isWalletImportScannable());
         this.importer = importer;
     }
 

src/main/java/com/sparrowwallet/sparrow/control/FileWalletKeystoreImportPane.java

@@ -36,7 +36,7 @@ public class FileWalletKeystoreImportPane extends FileImportPane {
     private byte[] fileBytes;
 
     public FileWalletKeystoreImportPane(KeystoreFileImport importer) {
-        super(importer, importer.getName(), "Wallet import", importer.getKeystoreImportDescription(), "image/" + importer.getWalletModel().getType() + ".png", importer.isScannable());
+        super(importer, importer.getName(), "Wallet import", importer.getKeystoreImportDescription(), "image/" + importer.getWalletModel().getType() + ".png", importer.isKeystoreImportScannable());
         this.importer = importer;
     }
 

src/main/java/com/sparrowwallet/sparrow/control/IdLabel.java

@@ -1,6 +1,6 @@
 package com.sparrowwallet.sparrow.control;
 
-import com.sparrowwallet.sparrow.AppController;
+import com.sparrowwallet.sparrow.AppServices;
 
 public class IdLabel extends CopyableLabel {
     public IdLabel() {
@@ -9,6 +9,6 @@ public class IdLabel extends CopyableLabel {
 
     public IdLabel(String text) {
         super(text);
-        setFont(AppController.getMonospaceFont());
+        setFont(AppServices.getMonospaceFont());
     }
 }

src/main/java/com/sparrowwallet/sparrow/control/KeystorePassphraseDialog.java

@@ -1,7 +1,7 @@
 package com.sparrowwallet.sparrow.control;
 
 import com.sparrowwallet.drongo.wallet.Keystore;
-import com.sparrowwallet.sparrow.AppController;
+import com.sparrowwallet.sparrow.AppServices;
 import com.sparrowwallet.sparrow.glyphfont.FontAwesome5;
 import javafx.application.Platform;
 import javafx.scene.control.ButtonType;
@@ -25,8 +25,8 @@ public class KeystorePassphraseDialog extends Dialog<String> {
         final DialogPane dialogPane = getDialogPane();
         setTitle("Keystore Passphrase" + (walletName != null ? " - " + walletName : ""));
         dialogPane.setHeaderText("Please enter the passphrase for keystore: \n" + keystore.getLabel());
-        dialogPane.getStylesheets().add(AppController.class.getResource("general.css").toExternalForm());
-        AppController.setStageIcon(dialogPane.getScene().getWindow());
+        dialogPane.getStylesheets().add(AppServices.class.getResource("general.css").toExternalForm());
+        AppServices.setStageIcon(dialogPane.getScene().getWindow());
         dialogPane.getButtonTypes().addAll(ButtonType.CANCEL, ButtonType.OK);
         dialogPane.setPrefWidth(380);
         dialogPane.setPrefHeight(200);

src/main/java/com/sparrowwallet/sparrow/control/MempoolSizeFeeRatesChart.java

@@ -0,0 +1,188 @@
+package com.sparrowwallet.sparrow.control;
+
+import com.sparrowwallet.sparrow.glyphfont.FontAwesome5;
+import com.sparrowwallet.sparrow.net.MempoolRateSize;
+import com.sparrowwallet.sparrow.wallet.SendController;
+import javafx.application.Platform;
+import javafx.beans.NamedArg;
+import javafx.collections.FXCollections;
+import javafx.geometry.Point2D;
+import javafx.scene.Cursor;
+import javafx.scene.Node;
+import javafx.scene.chart.*;
+import javafx.scene.control.Label;
+import javafx.scene.control.Tooltip;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.VBox;
+import javafx.util.Duration;
+import javafx.util.StringConverter;
+import org.controlsfx.glyphfont.Glyph;
+
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class MempoolSizeFeeRatesChart extends StackedAreaChart<String, Number> {
+    private static final DateFormat dateFormatter = new SimpleDateFormat("HH:mm");
+    public static final int MAX_PERIOD_HOURS = 2;
+
+    private Tooltip tooltip;
+
+    public MempoolSizeFeeRatesChart(@NamedArg("xAxis") Axis<String> xAxis, @NamedArg("yAxis") Axis<Number> yAxis) {
+        super(xAxis, yAxis);
+    }
+
+    public void initialize() {
+        setCreateSymbols(false);
+        setCursor(Cursor.CROSSHAIR);
+        setVerticalGridLinesVisible(false);
+        tooltip = new Tooltip();
+        tooltip.setShowDelay(Duration.ZERO);
+        tooltip.setHideDelay(Duration.ZERO);
+        tooltip.setShowDuration(Duration.INDEFINITE);
+        Platform.runLater(() -> {
+            Node node = this.lookup(".plot-content");
+            Tooltip.install(node, tooltip);
+        });
+    }
+
+    public void update(Map<Date, Set<MempoolRateSize>> mempoolRateSizes) {
+        getData().clear();
+        if(tooltip.isShowing()) {
+            tooltip.hide();
+        }
+
+        Map<Date, Set<MempoolRateSize>> periodRateSizes = getPeriodRateSizes(mempoolRateSizes);
+        Map<Date, String> categories = getCategories(periodRateSizes);
+
+        CategoryAxis categoryAxis = (CategoryAxis)getXAxis();
+        categoryAxis.setTickMarkVisible(false);
+        categoryAxis.setTickLabelGap(10);
+        categoryAxis.setAutoRanging(false);
+        categoryAxis.setCategories(FXCollections.observableArrayList(categories.values()));
+        categoryAxis.invalidateRange(new ArrayList<>(categories.values()));
+        categoryAxis.setGapStartAndEnd(false);
+        categoryAxis.setTickLabelRotation(0);
+
+        NumberAxis numberAxis = (NumberAxis)getYAxis();
+        numberAxis.setTickLabelFormatter(new StringConverter<Number>() {
+            @Override
+            public String toString(Number object) {
+                long vSizeBytes = object.longValue();
+                return (vSizeBytes / (1000 * 1000)) + " MvB";
+            }
+
+            @Override
+            public Number fromString(String string) {
+                return null;
+            }
+        });
+
+        this.setOnMouseMoved(mouseEvent -> {
+            Point2D sceneCoords = this.localToScene(mouseEvent.getX(), mouseEvent.getY());
+            String category = categoryAxis.getValueForDisplay(categoryAxis.sceneToLocal(sceneCoords).getX());
+            if(category != null) {
+                Optional<String> time = categories.entrySet().stream().filter(entry -> entry.getValue().equals(category)).map(entry -> dateFormatter.format(entry.getKey())).findFirst();
+                time.ifPresent(s -> tooltip.setGraphic(new ChartTooltip(category, s, getData())));
+            }
+        });
+
+        long previousFeeRate = 0;
+        for(Long feeRate : SendController.FEE_RATES_RANGE) {
+            XYChart.Series<String, Number> series = new XYChart.Series<>();
+            series.setName(feeRate + "+ vB");
+            long seriesTotalVSize = 0;
+
+            for(Date date : periodRateSizes.keySet()) {
+                Set<MempoolRateSize> rateSizes = periodRateSizes.get(date);
+                long totalVSize = 0;
+                for(MempoolRateSize rateSize : rateSizes) {
+                    if(rateSize.getFee() > previousFeeRate && rateSize.getFee() <= feeRate) {
+                        totalVSize += rateSize.getVSize();
+                    }
+                }
+
+                series.getData().add(new XYChart.Data<>(categories.get(date), totalVSize));
+                seriesTotalVSize += totalVSize;
+            }
+
+            if(seriesTotalVSize > 0) {
+                getData().add(series);
+            }
+
+            previousFeeRate = feeRate;
+        }
+
+        if(categories.keySet().iterator().hasNext()) {
+            String time = categories.values().iterator().next();
+            tooltip.setGraphic(new ChartTooltip(time, time, getData()));
+            numberAxis.setTickLabelsVisible(true);
+            numberAxis.setOpacity(1);
+        } else {
+            numberAxis.setTickLabelsVisible(false);
+            numberAxis.setOpacity(0);
+        }
+    }
+
+    private Map<Date, Set<MempoolRateSize>> getPeriodRateSizes(Map<Date, Set<MempoolRateSize>> mempoolRateSizes) {
+        if(mempoolRateSizes.size() == 1) {
+            return mempoolRateSizes;
+        }
+
+        LocalDateTime period = LocalDateTime.now().minusHours(MAX_PERIOD_HOURS);
+        return mempoolRateSizes.entrySet().stream().filter(entry -> {
+            LocalDateTime dateTime = entry.getKey().toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
+            return dateTime.isAfter(period);
+        }).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue,
+                (u, v) -> { throw new IllegalStateException("Duplicate dates"); },
+                TreeMap::new));
+    }
+
+    private Map<Date, String> getCategories(Map<Date, Set<MempoolRateSize>> mempoolHistogram) {
+        Map<Date, String> categories = new LinkedHashMap<>();
+
+        String invisible = "" + '\ufeff';
+        for(Iterator<Date> iter = mempoolHistogram.keySet().iterator(); iter.hasNext(); ) {
+            Date date = iter.next();
+            String label = dateFormatter.format(date);
+            if(!categories.isEmpty() && iter.hasNext()) {
+                label = invisible;
+                invisible += '\ufeff';
+            }
+
+            categories.put(date, label);
+        }
+
+        return categories;
+    }
+
+    private static class ChartTooltip extends VBox {
+        public ChartTooltip(String category, String time, List<Series<String, Number>> seriesList) {
+            Label title = new Label("At " + time);
+            HBox titleBox = new HBox(title);
+            title.setStyle("-fx-alignment: center; -fx-font-size: 12px; -fx-padding: 0 0 5 0;");
+            getChildren().add(titleBox);
+
+            for(int i = seriesList.size() - 1; i >= 0; i--) {
+                Series<String, Number> series = seriesList.get(i);
+                for(XYChart.Data<String, Number> data : series.getData()) {
+                    if(data.getXValue().equals(category)) {
+                        double mvb = data.getYValue().doubleValue() / (1000 * 1000);
+                        if(mvb >= 0.01) {
+                            Label label = new Label(series.getName() + ": " + String.format("%.2f", mvb) + " MvB");
+                            Glyph circle = new Glyph(FontAwesome5.FONT_NAME, FontAwesome5.Glyph.CIRCLE);
+                            if(i < 8) {
+                                circle.setStyle("-fx-text-fill: CHART_COLOR_" + (i+1));
+                            }
+                            label.setGraphic(circle);
+                            getChildren().add(label);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

src/main/java/com/sparrowwallet/sparrow/control/MessageSignDialog.java

@@ -12,7 +12,7 @@ import com.sparrowwallet.drongo.wallet.Keystore;
 import com.sparrowwallet.drongo.wallet.KeystoreSource;
 import com.sparrowwallet.drongo.wallet.Wallet;
 import com.sparrowwallet.drongo.wallet.WalletNode;
-import com.sparrowwallet.sparrow.AppController;
+import com.sparrowwallet.sparrow.AppServices;
 import com.sparrowwallet.sparrow.EventManager;
 import com.sparrowwallet.sparrow.event.OpenWalletsEvent;
 import com.sparrowwallet.sparrow.event.RequestOpenWalletsEvent;
@@ -37,8 +37,6 @@ import java.security.SignatureException;
 import java.util.List;
 import java.util.Optional;
 
-import static com.sparrowwallet.sparrow.AppController.setStageIcon;
-
 public class MessageSignDialog extends Dialog<ButtonBar.ButtonData> {
     private static final Logger log = LoggerFactory.getLogger(MessageSignDialog.class);
 
@@ -84,8 +82,8 @@ public class MessageSignDialog extends Dialog<ButtonBar.ButtonData> {
         this.walletNode = walletNode;
 
         final DialogPane dialogPane = getDialogPane();
-        dialogPane.getStylesheets().add(AppController.class.getResource("general.css").toExternalForm());
-        AppController.setStageIcon(dialogPane.getScene().getWindow());
+        dialogPane.getStylesheets().add(AppServices.class.getResource("general.css").toExternalForm());
+        AppServices.setStageIcon(dialogPane.getScene().getWindow());
         dialogPane.setHeaderText(wallet == null ? "Verify Message" : "Sign/Verify Message");
 
         Image image = new Image("image/seed.png", 50, 50, false, false);
@@ -209,7 +207,7 @@ public class MessageSignDialog extends Dialog<ButtonBar.ButtonData> {
 
     private void signMessage() {
         if(walletNode == null) {
-            AppController.showErrorDialog("Address not in wallet", "The provided address is not present in the currently selected wallet.");
+            AppServices.showErrorDialog("Address not in wallet", "The provided address is not present in the currently selected wallet.");
             return;
         }
 
@@ -234,7 +232,7 @@ public class MessageSignDialog extends Dialog<ButtonBar.ButtonData> {
             signature.appendText(signatureText);
         } catch(Exception e) {
             log.error("Could not sign message", e);
-            AppController.showErrorDialog("Could not sign message", e.getMessage());
+            AppServices.showErrorDialog("Could not sign message", e.getMessage());
         }
     }
 
@@ -272,19 +270,19 @@ public class MessageSignDialog extends Dialog<ButtonBar.ButtonData> {
 
             if(verified) {
                 Alert alert = new Alert(Alert.AlertType.INFORMATION);
-                setStageIcon(alert.getDialogPane().getScene().getWindow());
+                AppServices.setStageIcon(alert.getDialogPane().getScene().getWindow());
                 alert.setTitle("Verification Succeeded");
                 alert.setHeaderText("Verification Succeeded");
                 alert.setContentText("The signature verified against the message.");
                 alert.showAndWait();
             } else {
-                AppController.showErrorDialog("Verification failed", "The provided signature did not match the message for this address.");
+                AppServices.showErrorDialog("Verification failed", "The provided signature did not match the message for this address.");
             }
         } catch(IllegalArgumentException e) {
-            AppController.showErrorDialog("Could not verify message", e.getMessage());
+            AppServices.showErrorDialog("Could not verify message", e.getMessage());
         } catch(Exception e) {
             log.error("Could not verify message", e);
-            AppController.showErrorDialog("Could not verify message", e.getMessage());
+            AppServices.showErrorDialog("Could not verify message", e.getMessage());
         }
     }
 
@@ -306,7 +304,8 @@ public class MessageSignDialog extends Dialog<ButtonBar.ButtonData> {
     public void openWallets(OpenWalletsEvent event) {
         Storage storage = event.getStorage(wallet);
         if(storage == null) {
-            throw new IllegalStateException("Wallet " + wallet + " without Storage");
+            //Another window, ignore
+            return;
         }
 
         WalletPasswordDialog dlg = new WalletPasswordDialog(WalletPasswordDialog.PasswordRequirement.LOAD);
@@ -320,7 +319,7 @@ public class MessageSignDialog extends Dialog<ButtonBar.ButtonData> {
             });
             decryptWalletService.setOnFailed(workerStateEvent -> {
                 EventManager.get().post(new StorageEvent(storage.getWalletFile(), TimedEvent.Action.END, "Failed"));
-                AppController.showErrorDialog("Incorrect Password", decryptWalletService.getException().getMessage());
+                AppServices.showErrorDialog("Incorrect Password", decryptWalletService.getException().getMessage());
             });
             EventManager.get().post(new StorageEvent(storage.getWalletFile(), TimedEvent.Action.START, "Decrypting wallet..."));
             decryptWalletService.start();

src/main/java/com/sparrowwallet/sparrow/control/MnemonicKeystoreImportPane.java

@@ -2,6 +2,7 @@ package com.sparrowwallet.sparrow.control;
 
 import com.sparrowwallet.drongo.KeyDerivation;
 import com.sparrowwallet.drongo.crypto.ChildNumber;
+import com.sparrowwallet.drongo.protocol.ScriptType;
 import com.sparrowwallet.drongo.wallet.*;
 import com.sparrowwallet.sparrow.EventManager;
 import com.sparrowwallet.sparrow.event.KeystoreImportEvent;
@@ -107,7 +108,8 @@ public class MnemonicKeystoreImportPane extends TitledDescriptionPane {
             importKeystore(wallet.getScriptType().getDefaultDerivation(), false);
         });
         String[] accounts = new String[] {"Default Account #0", "Account #1", "Account #2", "Account #3", "Account #4", "Account #5", "Account #6", "Account #7", "Account #8", "Account #9"};
-        for(int i = 0; i < accounts.length; i++) {
+        int scriptAccountsLength = ScriptType.P2SH.equals(wallet.getScriptType()) ? 1 : accounts.length;
+        for(int i = 0; i < scriptAccountsLength; i++) {
             MenuItem item = new MenuItem(accounts[i]);
             final List<ChildNumber> derivation = wallet.getScriptType().getDefaultDerivation(i);
             item.setOnAction(event -> {

src/main/java/com/sparrowwallet/sparrow/control/QRDisplayDialog.java

@@ -5,20 +5,22 @@ import com.google.zxing.client.j2se.MatrixToImageConfig;
 import com.google.zxing.client.j2se.MatrixToImageWriter;
 import com.google.zxing.common.BitMatrix;
 import com.google.zxing.qrcode.QRCodeWriter;
-import com.sparrowwallet.sparrow.AppController;
+import com.sparrowwallet.hummingbird.LegacyUREncoder;
+import com.sparrowwallet.hummingbird.registry.RegistryType;
+import com.sparrowwallet.sparrow.AppServices;
+import com.sparrowwallet.sparrow.glyphfont.FontAwesome5;
 import com.sparrowwallet.sparrow.io.ImportException;
 import com.sparrowwallet.hummingbird.UR;
 import com.sparrowwallet.hummingbird.UREncoder;
 import javafx.concurrent.ScheduledService;
 import javafx.concurrent.Task;
-import javafx.scene.control.ButtonBar;
-import javafx.scene.control.ButtonType;
-import javafx.scene.control.Dialog;
-import javafx.scene.control.DialogPane;
+import javafx.scene.Node;
+import javafx.scene.control.*;
 import javafx.scene.image.Image;
 import javafx.scene.image.ImageView;
 import javafx.scene.layout.StackPane;
 import javafx.util.Duration;
+import org.controlsfx.glyphfont.Glyph;
 import org.controlsfx.tools.Borders;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -26,29 +28,42 @@ import org.slf4j.LoggerFactory;
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 
+@SuppressWarnings("deprecation")
 public class QRDisplayDialog extends Dialog<UR> {
     private static final Logger log = LoggerFactory.getLogger(QRDisplayDialog.class);
 
     private static final int MIN_FRAGMENT_LENGTH = 10;
     private static final int MAX_FRAGMENT_LENGTH = 100;
 
+    private static final int ANIMATION_PERIOD_MILLIS = 400;
+
     private final UR ur;
     private final UREncoder encoder;
 
     private final ImageView qrImageView;
 
+    private AnimateQRService animateQRService;
     private String currentPart;
 
-    public QRDisplayDialog(String type, byte[] data) throws UR.URException {
-        this(UR.fromBytes(type, data));
+    private boolean useLegacyEncoding;
+    private String[] legacyParts;
+    private int legacyPartIndex;
+
+    public QRDisplayDialog(String type, byte[] data, boolean addLegacyEncodingOption) throws UR.URException {
+        this(UR.fromBytes(type, data), addLegacyEncodingOption);
     }
 
     public QRDisplayDialog(UR ur) {
+        this(ur, false);
+    }
+
+    public QRDisplayDialog(UR ur, boolean addLegacyEncodingOption) {
         this.ur = ur;
         this.encoder = new UREncoder(ur, MAX_FRAGMENT_LENGTH, MIN_FRAGMENT_LENGTH, 0);
 
-        final DialogPane dialogPane = getDialogPane();
-        AppController.setStageIcon(dialogPane.getScene().getWindow());
+        final DialogPane dialogPane = new QRDisplayDialogPane();
+        setDialogPane(dialogPane);
+        AppServices.setStageIcon(dialogPane.getScene().getWindow());
 
         StackPane stackPane = new StackPane();
         qrImageView = new ImageView();
@@ -60,8 +75,8 @@ public class QRDisplayDialog extends Dialog<UR> {
         if(encoder.isSinglePart()) {
             qrImageView.setImage(getQrCode(currentPart));
         } else {
-            AnimateQRService animateQRService = new AnimateQRService();
-            animateQRService.setPeriod(Duration.millis(100));
+            animateQRService = new AnimateQRService();
+            animateQRService.setPeriod(Duration.millis(ANIMATION_PERIOD_MILLIS));
             animateQRService.start();
             setOnCloseRequest(event -> {
                 animateQRService.cancel();
@@ -69,7 +84,13 @@ public class QRDisplayDialog extends Dialog<UR> {
         }
 
         final ButtonType cancelButtonType = new javafx.scene.control.ButtonType("Cancel", ButtonBar.ButtonData.CANCEL_CLOSE);
-        dialogPane.getButtonTypes().addAll(cancelButtonType);
+        dialogPane.getButtonTypes().add(cancelButtonType);
+
+        if(addLegacyEncodingOption) {
+            final ButtonType legacyEncodingButtonType = new javafx.scene.control.ButtonType("Use Legacy Encoding (Cobo Vault)", ButtonBar.ButtonData.LEFT);
+            dialogPane.getButtonTypes().add(legacyEncodingButtonType);
+        }
+
         dialogPane.setPrefWidth(500);
         dialogPane.setPrefHeight(550);
 
@@ -81,7 +102,7 @@ public class QRDisplayDialog extends Dialog<UR> {
         this.encoder = null;
 
         final DialogPane dialogPane = getDialogPane();
-        AppController.setStageIcon(dialogPane.getScene().getWindow());
+        AppServices.setStageIcon(dialogPane.getScene().getWindow());
 
         StackPane stackPane = new StackPane();
         qrImageView = new ImageView();
@@ -99,8 +120,16 @@ public class QRDisplayDialog extends Dialog<UR> {
     }
 
     private void nextPart() {
-        String fragment = encoder.nextPart();
-        currentPart = fragment.toUpperCase();
+        if(!useLegacyEncoding) {
+            String fragment = encoder.nextPart();
+            currentPart = fragment.toUpperCase();
+        } else {
+            currentPart = legacyParts[legacyPartIndex];
+            legacyPartIndex++;
+            if(legacyPartIndex > legacyParts.length - 1) {
+                legacyPartIndex = 0;
+            }
+        }
     }
 
     private Image getQrCode(String fragment) {
@@ -120,6 +149,44 @@ public class QRDisplayDialog extends Dialog<UR> {
         return null;
     }
 
+    private void setUseLegacyEncoding(boolean useLegacyEncoding) {
+        if(useLegacyEncoding) {
+            try {
+                //Force to be bytes type for legacy encoding
+                LegacyUREncoder legacyEncoder = new LegacyUREncoder(new UR(RegistryType.BYTES.toString(), ur.getCborBytes()));
+                this.legacyParts = legacyEncoder.encode();
+                this.useLegacyEncoding = true;
+
+                if(legacyParts.length == 1) {
+                    if(animateQRService != null) {
+                        animateQRService.cancel();
+                    }
+
+                    nextPart();
+                    qrImageView.setImage(getQrCode(currentPart));
+                } else if(!animateQRService.isRunning()) {
+                    animateQRService.reset();
+                    animateQRService.start();
+                }
+            } catch(UR.InvalidTypeException e) {
+                //Can't happen
+            }
+        } else {
+            this.useLegacyEncoding = false;
+
+            if(encoder.isSinglePart()) {
+                if(animateQRService != null) {
+                    animateQRService.cancel();
+                }
+
+                qrImageView.setImage(getQrCode(currentPart));
+            } else if(!animateQRService.isRunning()) {
+                animateQRService.reset();
+                animateQRService.start();
+            }
+        }
+    }
+
     private class AnimateQRService extends ScheduledService<Boolean> {
         @Override
         protected Task<Boolean> createTask() {
@@ -134,4 +201,44 @@ public class QRDisplayDialog extends Dialog<UR> {
             };
         }
     }
+
+    private class QRDisplayDialogPane extends DialogPane {
+        @Override
+        protected Node createButton(ButtonType buttonType) {
+            if(buttonType.getButtonData() == ButtonBar.ButtonData.LEFT) {
+                ToggleButton legacy = new ToggleButton(buttonType.getText());
+                legacy.setGraphicTextGap(5);
+                setLegacyGraphic(legacy, false);
+
+                final ButtonBar.ButtonData buttonData = buttonType.getButtonData();
+                ButtonBar.setButtonData(legacy, buttonData);
+                legacy.selectedProperty().addListener((observable, oldValue, newValue) -> {
+                    setUseLegacyEncoding(newValue);
+                    setLegacyGraphic(legacy, newValue);
+                });
+
+                return legacy;
+            }
+
+            return super.createButton(buttonType);
+        }
+
+        private void setLegacyGraphic(ToggleButton legacy, boolean useLegacyEncoding) {
+            if(useLegacyEncoding) {
+                legacy.setGraphic(getGlyph(FontAwesome5.Glyph.CHECK_CIRCLE, "success"));
+            } else {
+                legacy.setGraphic(getGlyph(FontAwesome5.Glyph.QUESTION_CIRCLE, null));
+            }
+        }
+
+        private Glyph getGlyph(FontAwesome5.Glyph glyphName, String styleClass) {
+            Glyph glyph = new Glyph(FontAwesome5.FONT_NAME, glyphName);
+            glyph.setFontSize(12);
+            if(styleClass != null) {
+                glyph.getStyleClass().add(styleClass);
+            }
+
+            return glyph;
+        }
+    }
 }

src/main/java/com/sparrowwallet/sparrow/control/QRScanDialog.java

@@ -2,16 +2,27 @@ package com.sparrowwallet.sparrow.control;
 
 import com.github.sarxos.webcam.WebcamResolution;
 import com.sparrowwallet.drongo.ExtendedKey;
+import com.sparrowwallet.drongo.KeyDerivation;
+import com.sparrowwallet.drongo.OutputDescriptor;
 import com.sparrowwallet.drongo.Utils;
 import com.sparrowwallet.drongo.address.Address;
+import com.sparrowwallet.drongo.address.P2PKHAddress;
+import com.sparrowwallet.drongo.address.P2SHAddress;
+import com.sparrowwallet.drongo.address.P2WPKHAddress;
+import com.sparrowwallet.drongo.crypto.*;
 import com.sparrowwallet.drongo.protocol.Base43;
+import com.sparrowwallet.drongo.protocol.ScriptType;
 import com.sparrowwallet.drongo.protocol.Transaction;
 import com.sparrowwallet.drongo.psbt.PSBT;
 import com.sparrowwallet.drongo.uri.BitcoinURI;
-import com.sparrowwallet.sparrow.AppController;
+import com.sparrowwallet.drongo.wallet.Keystore;
+import com.sparrowwallet.drongo.wallet.Wallet;
+import com.sparrowwallet.hummingbird.LegacyURDecoder;
+import com.sparrowwallet.hummingbird.registry.*;
 import com.sparrowwallet.hummingbird.ResultType;
 import com.sparrowwallet.hummingbird.UR;
 import com.sparrowwallet.hummingbird.URDecoder;
+import com.sparrowwallet.sparrow.AppServices;
 import javafx.application.Platform;
 import javafx.beans.value.ChangeListener;
 import javafx.beans.value.ObservableValue;
@@ -21,16 +32,24 @@ import javafx.scene.control.Dialog;
 import javafx.scene.control.DialogPane;
 import javafx.scene.layout.StackPane;
 import org.controlsfx.tools.Borders;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Objects;
+import java.nio.ByteBuffer;
+import java.nio.CharBuffer;
+import java.nio.charset.CharsetDecoder;
+import java.nio.charset.StandardCharsets;
+import java.util.*;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.stream.IntStream;
 
+@SuppressWarnings("deprecation")
 public class QRScanDialog extends Dialog<QRScanDialog.Result> {
+    private static final Logger log = LoggerFactory.getLogger(QRScanDialog.class);
+
     private final URDecoder decoder;
+    private final LegacyURDecoder legacyDecoder;
     private final WebcamService webcamService;
     private List<String> parts;
 
@@ -41,12 +60,13 @@ public class QRScanDialog extends Dialog<QRScanDialog.Result> {
 
     public QRScanDialog() {
         this.decoder = new URDecoder();
+        this.legacyDecoder = new LegacyURDecoder();
 
         this.webcamService = new WebcamService(WebcamResolution.VGA);
         WebcamView webcamView = new WebcamView(webcamService);
 
         final DialogPane dialogPane = getDialogPane();
-        AppController.setStageIcon(dialogPane.getScene().getWindow());
+        AppServices.setStageIcon(dialogPane.getScene().getWindow());
 
         StackPane stackPane = new StackPane();
         stackPane.getChildren().add(webcamView.getView());
@@ -83,35 +103,28 @@ public class QRScanDialog extends Dialog<QRScanDialog.Result> {
 
             if(isUr || qrtext.toLowerCase().startsWith(UR.UR_PREFIX)) {
                 isUr = true;
-                decoder.receivePart(qrtext);
 
-                if(decoder.getResult() != null) {
-                    URDecoder.Result urResult = decoder.getResult();
-                    if(urResult.type == ResultType.SUCCESS) {
-                        //TODO: Confirm once UR type registry is updated
-                        if(urResult.ur.getType().contains(UR.BYTES_TYPE) || urResult.ur.getType().equals(UR.CRYPTO_PSBT_TYPE)) {
-                            try {
-                                PSBT psbt = new PSBT(urResult.ur.toBytes());
-                                result = new Result(psbt);
-                                return;
-                            } catch(Exception e) {
-                                //ignore, bytes not parsable as PSBT
-                            }
+                if(LegacyURDecoder.isLegacyURFragment(qrtext)) {
+                    legacyDecoder.receivePart(qrtext.toLowerCase());
 
-                            try {
-                                Transaction transaction = new Transaction(urResult.ur.toBytes());
-                                result = new Result(transaction);
-                                return;
-                            } catch(Exception e) {
-                                //ignore, bytes not parsable as tx
-                            }
-
-                            result = new Result("Parsed UR of type " + urResult.ur.getType() + " was not a PSBT or transaction");
-                        } else {
-                            result = new Result("Cannot parse UR type of " + urResult.ur.getType());
+                    if(legacyDecoder.isComplete()) {
+                        try {
+                            UR ur = legacyDecoder.decode();
+                            result = extractResultFromUR(ur);
+                        } catch(Exception e) {
+                            result = new Result(new URException(e.getMessage()));
+                        }
+                    }
+                } else {
+                    decoder.receivePart(qrtext);
+
+                    if(decoder.getResult() != null) {
+                        URDecoder.Result urResult = decoder.getResult();
+                        if(urResult.type == ResultType.SUCCESS) {
+                            result = extractResultFromUR(urResult.ur);
+                        } else {
+                            result = new Result(new URException(urResult.error));
                         }
-                    } else {
-                        result = new Result(urResult.error);
                     }
                 }
             } else if(partMatcher.matches()) {
@@ -143,7 +156,7 @@ public class QRScanDialog extends Dialog<QRScanDialog.Result> {
                         //ignore, bytes not parsable as tx
                     }
 
-                    result = new Result("Parsed QR parts were not a PSBT or transaction");
+                    result = new Result(new ScanException("Parsed QR parts were not a PSBT or transaction"));
                 }
             } else {
                 PSBT psbt;
@@ -227,6 +240,189 @@ public class QRScanDialog extends Dialog<QRScanDialog.Result> {
                 result = new Result(qrtext);
             }
         }
+
+        private Result extractResultFromUR(UR ur) {
+            try {
+                RegistryType urRegistryType = ur.getRegistryType();
+
+                if(urRegistryType.equals(RegistryType.BYTES)) {
+                    byte[] urBytes = (byte[])ur.decodeFromRegistry();
+                    try {
+                        PSBT psbt = new PSBT(urBytes);
+                        return new Result(psbt);
+                    } catch(Exception e) {
+                        //ignore, bytes not parsable as PSBT
+                    }
+
+                    try {
+                        Transaction transaction = new Transaction(urBytes);
+                        return new Result(transaction);
+                    } catch(Exception e) {
+                        //ignore, bytes not parsable as tx
+                    }
+
+                    try {
+                        CharsetDecoder decoder = StandardCharsets.UTF_8.newDecoder();
+                        ByteBuffer buf = ByteBuffer.wrap(urBytes);
+                        CharBuffer charBuffer = decoder.decode(buf);
+                        return new Result(charBuffer.toString());
+                    } catch(Exception e) {
+                        //ignore, bytes not parsable as utf-8
+                    }
+
+                    result = new Result(new URException("Parsed UR of type " + urRegistryType + " was not a PSBT, transaction or UTF-8 text"));
+                } else if(urRegistryType.equals(RegistryType.CRYPTO_PSBT)) {
+                    CryptoPSBT cryptoPSBT = (CryptoPSBT)ur.decodeFromRegistry();
+                    try {
+                        PSBT psbt = new PSBT(cryptoPSBT.getPsbt());
+                        return new Result(psbt);
+                    } catch(Exception e) {
+                        log.error("Error parsing PSBT from UR type " + urRegistryType, e);
+                        return new Result(new URException("Error parsing PSBT from UR type " + urRegistryType, e));
+                    }
+                } else if(urRegistryType.equals(RegistryType.CRYPTO_ADDRESS)) {
+                    CryptoAddress cryptoAddress = (CryptoAddress)ur.decodeFromRegistry();
+                    Address address = getAddress(cryptoAddress);
+                    if(address != null) {
+                        return new Result(BitcoinURI.fromAddress(address));
+                    } else {
+                        return new Result(new URException("Unknown " + urRegistryType + " type of " + cryptoAddress.getType()));
+                    }
+                } else if(urRegistryType.equals(RegistryType.CRYPTO_HDKEY)) {
+                    CryptoHDKey cryptoHDKey = (CryptoHDKey)ur.decodeFromRegistry();
+                    ExtendedKey extendedKey = getExtendedKey(cryptoHDKey);
+                    return new Result(extendedKey);
+                } else if(urRegistryType.equals(RegistryType.CRYPTO_OUTPUT)) {
+                    CryptoOutput cryptoOutput = (CryptoOutput)ur.decodeFromRegistry();
+                    OutputDescriptor outputDescriptor = getOutputDescriptor(cryptoOutput);
+                    return new Result(outputDescriptor);
+                } else if(urRegistryType.equals(RegistryType.CRYPTO_ACCOUNT)) {
+                    CryptoAccount cryptoAccount = (CryptoAccount)ur.decodeFromRegistry();
+                    List<Wallet> wallets = getWallets(cryptoAccount);
+                    return new Result(wallets);
+                } else {
+                    log.error("Unsupported UR type " + urRegistryType);
+                    return new Result(new URException("UR type " + urRegistryType + " is not supported"));
+                }
+            } catch(IllegalArgumentException e) {
+                log.error("Unknown UR type of " + ur.getType(), e);
+                return new Result(new URException("Unknown UR type of " + ur.getType(), e));
+            } catch(UR.InvalidCBORException e) {
+                log.error("Invalid CBOR in UR", e);
+                return new Result(new URException("Invalid CBOR in UR", e));
+            } catch(Exception e) {
+                log.error("Error parsing UR CBOR", e);
+                return new Result(new URException("Error parsing UR CBOR", e));
+            }
+
+            return null;
+        }
+
+        private Address getAddress(CryptoAddress cryptoAddress) {
+            Address address = null;
+            if(cryptoAddress.getType() == null || cryptoAddress.getType() == CryptoAddress.Type.P2PKH) {
+                address = new P2PKHAddress(cryptoAddress.getData());
+            } else if(cryptoAddress.getType() == CryptoAddress.Type.P2SH) {
+                address = new P2SHAddress(cryptoAddress.getData());
+            } else if(cryptoAddress.getType() == CryptoAddress.Type.P2WPKH) {
+                address = new P2WPKHAddress(cryptoAddress.getData());
+            }
+            return address;
+        }
+
+        private ExtendedKey getExtendedKey(CryptoHDKey cryptoHDKey) {
+            if(cryptoHDKey.isPrivateKey()) {
+                DeterministicKey prvKey = HDKeyDerivation.createMasterPrivKeyFromBytes(Arrays.copyOfRange(cryptoHDKey.getKey(), 1, 33), cryptoHDKey.getChainCode(), List.of(ChildNumber.ZERO));
+                return new ExtendedKey(prvKey, new byte[4], ChildNumber.ZERO);
+            } else {
+                ChildNumber lastChild = ChildNumber.ZERO;
+                int depth = 1;
+                byte[] parentFingerprint = new byte[4];
+                if(cryptoHDKey.getOrigin() != null) {
+                    if(!cryptoHDKey.getOrigin().getComponents().isEmpty()) {
+                        PathComponent lastComponent = cryptoHDKey.getOrigin().getComponents().get(cryptoHDKey.getOrigin().getComponents().size() - 1);
+                        lastChild = new ChildNumber(lastComponent.getIndex(), lastComponent.isHardened());
+                        depth = cryptoHDKey.getOrigin().getComponents().size();
+                    }
+                    if(cryptoHDKey.getParentFingerprint() != null) {
+                        parentFingerprint = cryptoHDKey.getParentFingerprint();
+                    }
+                }
+                DeterministicKey pubKey = new DeterministicKey(List.of(lastChild), cryptoHDKey.getChainCode(), cryptoHDKey.getKey(), depth, parentFingerprint);
+                return new ExtendedKey(pubKey, parentFingerprint, lastChild);
+            }
+        }
+
+        private OutputDescriptor getOutputDescriptor(CryptoOutput cryptoOutput) {
+            ScriptType scriptType = getScriptType(cryptoOutput.getScriptExpressions());
+
+            if(cryptoOutput.getMultiKey() != null) {
+                MultiKey multiKey = cryptoOutput.getMultiKey();
+                Map<ExtendedKey, KeyDerivation> extendedPublicKeys = new LinkedHashMap<>();
+                for(CryptoHDKey cryptoHDKey : multiKey.getHdKeys()) {
+                    ExtendedKey extendedKey = getExtendedKey(cryptoHDKey);
+                    KeyDerivation keyDerivation = getKeyDerivation(cryptoHDKey.getOrigin());
+                    extendedPublicKeys.put(extendedKey, keyDerivation);
+                }
+                return new OutputDescriptor(scriptType, multiKey.getThreshold(), extendedPublicKeys);
+            } else if(cryptoOutput.getEcKey() != null) {
+                throw new IllegalArgumentException("EC keys are currently unsupported");
+            } else if(cryptoOutput.getHdKey() != null) {
+                ExtendedKey extendedKey = getExtendedKey(cryptoOutput.getHdKey());
+                KeyDerivation keyDerivation = getKeyDerivation(cryptoOutput.getHdKey().getOrigin());
+                return new OutputDescriptor(scriptType, extendedKey, keyDerivation);
+            }
+
+            throw new IllegalStateException("CryptoOutput did not contain sufficient information");
+        }
+
+        private List<Wallet> getWallets(CryptoAccount cryptoAccount) {
+            List<Wallet> wallets = new ArrayList<>();
+            String masterFingerprint = Utils.bytesToHex(cryptoAccount.getMasterFingerprint());
+            for(CryptoOutput cryptoOutput : cryptoAccount.getOutputDescriptors()) {
+                Wallet wallet = new Wallet();
+                OutputDescriptor outputDescriptor = getOutputDescriptor(cryptoOutput);
+                if(outputDescriptor.isMultisig()) {
+                    throw new IllegalStateException("Multisig output descriptors are unsupported in CryptoAccount");
+                }
+
+                ExtendedKey extendedKey = outputDescriptor.getSingletonExtendedPublicKey();
+                wallet.setScriptType(outputDescriptor.getScriptType());
+                Keystore keystore = new Keystore();
+                keystore.setKeyDerivation(new KeyDerivation(masterFingerprint, outputDescriptor.getKeyDerivation(extendedKey).getDerivationPath()));
+                keystore.setExtendedPublicKey(extendedKey);
+                wallet.getKeystores().add(keystore);
+                wallets.add(wallet);
+            }
+
+            return wallets;
+        }
+
+        private ScriptType getScriptType(List<ScriptExpression> expressions) {
+            if(List.of(ScriptExpression.PUBLIC_KEY_HASH).equals(expressions)) {
+                return ScriptType.P2PKH;
+            } else if(List.of(ScriptExpression.SCRIPT_HASH, ScriptExpression.WITNESS_PUBLIC_KEY_HASH).equals(expressions)) {
+                return ScriptType.P2SH_P2WPKH;
+            } else if(List.of(ScriptExpression.WITNESS_PUBLIC_KEY_HASH).equals(expressions)) {
+                return ScriptType.P2WPKH;
+            } else if(List.of(ScriptExpression.SCRIPT_HASH).equals(expressions)) {
+                return ScriptType.P2SH;
+            } else if(List.of(ScriptExpression.SCRIPT_HASH, ScriptExpression.WITNESS_SCRIPT_HASH).equals(expressions)) {
+                return ScriptType.P2SH_P2WSH;
+            } else if(List.of(ScriptExpression.WITNESS_SCRIPT_HASH).equals(expressions)) {
+                return ScriptType.P2WSH;
+            }
+
+            throw new IllegalArgumentException("Unknown script of " + expressions);
+        }
+
+        private KeyDerivation getKeyDerivation(CryptoKeypath cryptoKeypath) {
+            if(cryptoKeypath != null) {
+                return new KeyDerivation(Utils.bytesToHex(cryptoKeypath.getSourceFingerprint()), cryptoKeypath.getPath());
+            }
+
+            return null;
+        }
     }
 
     public static class Result {
@@ -234,6 +430,8 @@ public class QRScanDialog extends Dialog<QRScanDialog.Result> {
         public final PSBT psbt;
         public final BitcoinURI uri;
         public final ExtendedKey extendedKey;
+        public final OutputDescriptor outputDescriptor;
+        public final List<Wallet> wallets;
         public final String payload;
         public final Throwable exception;
 
@@ -242,6 +440,8 @@ public class QRScanDialog extends Dialog<QRScanDialog.Result> {
             this.psbt = null;
             this.uri = null;
             this.extendedKey = null;
+            this.outputDescriptor = null;
+            this.wallets = null;
             this.payload = null;
             this.exception = null;
         }
@@ -251,6 +451,8 @@ public class QRScanDialog extends Dialog<QRScanDialog.Result> {
             this.psbt = psbt;
             this.uri = null;
             this.extendedKey = null;
+            this.outputDescriptor = null;
+            this.wallets = null;
             this.payload = null;
             this.exception = null;
         }
@@ -260,6 +462,8 @@ public class QRScanDialog extends Dialog<QRScanDialog.Result> {
             this.psbt = null;
             this.uri = uri;
             this.extendedKey = null;
+            this.outputDescriptor = null;
+            this.wallets = null;
             this.payload = null;
             this.exception = null;
         }
@@ -269,6 +473,8 @@ public class QRScanDialog extends Dialog<QRScanDialog.Result> {
             this.psbt = null;
             this.uri = BitcoinURI.fromAddress(address);
             this.extendedKey = null;
+            this.outputDescriptor = null;
+            this.wallets = null;
             this.payload = null;
             this.exception = null;
         }
@@ -278,6 +484,30 @@ public class QRScanDialog extends Dialog<QRScanDialog.Result> {
             this.psbt = null;
             this.uri = null;
             this.extendedKey = extendedKey;
+            this.outputDescriptor = null;
+            this.wallets = null;
+            this.payload = null;
+            this.exception = null;
+        }
+
+        public Result(OutputDescriptor outputDescriptor) {
+            this.transaction = null;
+            this.psbt = null;
+            this.uri = null;
+            this.extendedKey = null;
+            this.outputDescriptor = outputDescriptor;
+            this.wallets = null;
+            this.payload = null;
+            this.exception = null;
+        }
+
+        public Result(List<Wallet> wallets) {
+            this.transaction = null;
+            this.psbt = null;
+            this.uri = null;
+            this.extendedKey = null;
+            this.outputDescriptor = null;
+            this.wallets = wallets;
             this.payload = null;
             this.exception = null;
         }
@@ -287,6 +517,8 @@ public class QRScanDialog extends Dialog<QRScanDialog.Result> {
             this.psbt = null;
             this.uri = null;
             this.extendedKey = null;
+            this.outputDescriptor = null;
+            this.wallets = null;
             this.payload = payload;
             this.exception = null;
         }
@@ -296,8 +528,46 @@ public class QRScanDialog extends Dialog<QRScanDialog.Result> {
             this.psbt = null;
             this.uri = null;
             this.extendedKey = null;
+            this.outputDescriptor = null;
+            this.wallets = null;
             this.payload = null;
             this.exception = exception;
         }
     }
+
+    public static class ScanException extends Exception {
+        public ScanException() {
+            super();
+        }
+
+        public ScanException(String message) {
+            super(message);
+        }
+
+        public ScanException(Throwable cause) {
+            super(cause);
+        }
+
+        public ScanException(String message, Throwable cause) {
+            super(message, cause);
+        }
+    }
+
+    public static class URException extends ScanException {
+        public URException() {
+            super();
+        }
+
+        public URException(String message) {
+            super(message);
+        }
+
+        public URException(Throwable cause) {
+            super(cause);
+        }
+
+        public URException(String message, Throwable cause) {
+            super(message, cause);
+        }
+    }
 }

src/main/java/com/sparrowwallet/sparrow/control/SeedDisplayDialog.java

@@ -1,7 +1,7 @@
 package com.sparrowwallet.sparrow.control;
 
 import com.sparrowwallet.drongo.wallet.Keystore;
-import com.sparrowwallet.sparrow.AppController;
+import com.sparrowwallet.sparrow.AppServices;
 import javafx.application.Platform;
 import javafx.scene.control.*;
 import javafx.scene.layout.AnchorPane;
@@ -10,8 +10,8 @@ import javafx.scene.layout.StackPane;
 public class SeedDisplayDialog extends Dialog<Void> {
     public SeedDisplayDialog(Keystore decryptedKeystore) {
         final DialogPane dialogPane = getDialogPane();
-        dialogPane.getStylesheets().add(AppController.class.getResource("general.css").toExternalForm());
-        AppController.setStageIcon(dialogPane.getScene().getWindow());
+        dialogPane.getStylesheets().add(AppServices.class.getResource("general.css").toExternalForm());
+        AppServices.setStageIcon(dialogPane.getScene().getWindow());
 
         int lines = decryptedKeystore.getSeed().getMnemonicCode().size() / 3;
         int height = lines * 40;

src/main/java/com/sparrowwallet/sparrow/control/TextAreaDialog.java

@@ -1,6 +1,6 @@
 package com.sparrowwallet.sparrow.control;
 
-import com.sparrowwallet.sparrow.AppController;
+import com.sparrowwallet.sparrow.AppServices;
 import javafx.application.Platform;
 import javafx.beans.NamedArg;
 import javafx.scene.control.*;
@@ -29,8 +29,8 @@ public class TextAreaDialog extends Dialog<String> {
         this.defaultValue = defaultValue;
 
         dialogPane.setContent(hbox);
-        dialogPane.getStylesheets().add(AppController.class.getResource("general.css").toExternalForm());
-        AppController.setStageIcon(dialogPane.getScene().getWindow());
+        dialogPane.getStylesheets().add(AppServices.class.getResource("general.css").toExternalForm());
+        AppServices.setStageIcon(dialogPane.getScene().getWindow());
 
         dialogPane.getStyleClass().add("text-input-dialog");
         dialogPane.getButtonTypes().addAll(ButtonType.OK, ButtonType.CANCEL);

src/main/java/com/sparrowwallet/sparrow/control/TitledDescriptionPane.java

@@ -1,6 +1,6 @@
 package com.sparrowwallet.sparrow.control;
 
-import com.sparrowwallet.sparrow.AppController;
+import com.sparrowwallet.sparrow.AppServices;
 import javafx.application.Platform;
 import javafx.geometry.Insets;
 import javafx.geometry.Pos;
@@ -21,7 +21,7 @@ public class TitledDescriptionPane extends TitledPane {
     protected HBox buttonBox;
 
     public TitledDescriptionPane(String title, String description, String content, String imageUrl) {
-        getStylesheets().add(AppController.class.getResource("general.css").toExternalForm());
+        getStylesheets().add(AppServices.class.getResource("general.css").toExternalForm());
         getStyleClass().add("titled-description-pane");
 
         setPadding(Insets.EMPTY);

src/main/java/com/sparrowwallet/sparrow/control/TransactionDiagram.java

@@ -1,11 +1,13 @@
 package com.sparrowwallet.sparrow.control;
 
-import com.sparrowwallet.drongo.KeyDerivation;
+import com.sparrowwallet.drongo.address.Address;
 import com.sparrowwallet.drongo.protocol.Sha256Hash;
+import com.sparrowwallet.drongo.uri.BitcoinURI;
 import com.sparrowwallet.drongo.wallet.BlockTransactionHashIndex;
 import com.sparrowwallet.drongo.wallet.Payment;
 import com.sparrowwallet.drongo.wallet.WalletNode;
 import com.sparrowwallet.drongo.wallet.WalletTransaction;
+import com.sparrowwallet.sparrow.AppServices;
 import com.sparrowwallet.sparrow.EventManager;
 import com.sparrowwallet.sparrow.event.ExcludeUtxoEvent;
 import com.sparrowwallet.sparrow.glyphfont.FontAwesome5;
@@ -74,6 +76,11 @@ public class TransactionDiagram extends GridPane {
     private Map<BlockTransactionHashIndex, WalletNode> getDisplayedUtxos() {
         Map<BlockTransactionHashIndex, WalletNode> selectedUtxos = walletTx.getSelectedUtxos();
 
+        if(getPayjoinURI() != null) {
+            selectedUtxos = new LinkedHashMap<>(selectedUtxos);
+            selectedUtxos.put(new PayjoinBlockTransactionHashIndex(), null);
+        }
+
         if(selectedUtxos.size() > MAX_UTXOS) {
             Map<BlockTransactionHashIndex, WalletNode> utxos = new LinkedHashMap<>();
             List<BlockTransactionHashIndex> additional = new ArrayList<>();
@@ -92,6 +99,22 @@ public class TransactionDiagram extends GridPane {
         }
     }
 
+    private BitcoinURI getPayjoinURI() {
+        for(Payment payment : walletTx.getPayments()) {
+            try {
+                Address address = payment.getAddress();
+                BitcoinURI bitcoinURI = AppServices.getPayjoinURI(address);
+                if(bitcoinURI != null) {
+                    return bitcoinURI;
+                }
+            } catch(Exception e) {
+                //ignore
+            }
+        }
+
+        return null;
+    }
+
     private Pane getInputsType(Map<BlockTransactionHashIndex, WalletNode> displayedUtxos) {
         StackPane stackPane = new StackPane();
 
@@ -166,9 +189,6 @@ public class TransactionDiagram extends GridPane {
                 EventManager.get().post(new ExcludeUtxoEvent(walletTx, input));
             });
 
-            label.setGraphic(excludeUtxoButton);
-            label.setContentDisplay(ContentDisplay.LEFT);
-
             Tooltip tooltip = new Tooltip();
             if(walletNode != null) {
                 tooltip.setText("Spending " + getSatsValue(input.getValue()) + " sats from " + walletNode.getDerivationPath().replace("m", "..") + "\n" + input.getHashAsString() + ":" + input.getIndex() + "\n" + walletTx.getWallet().getAddress(walletNode));
@@ -177,13 +197,20 @@ public class TransactionDiagram extends GridPane {
                 if(input.getLabel() == null || input.getLabel().isEmpty()) {
                     label.getStyleClass().add("input-label");
                 }
+
+                label.setGraphic(excludeUtxoButton);
+                label.setContentDisplay(ContentDisplay.LEFT);
             } else {
-                AdditionalBlockTransactionHashIndex additionalReference = (AdditionalBlockTransactionHashIndex)input;
-                StringJoiner joiner = new StringJoiner("\n");
-                for(BlockTransactionHashIndex additionalInput : additionalReference.getAdditionalInputs()) {
-                    joiner.add(getInputDescription(additionalInput));
+                if(input instanceof PayjoinBlockTransactionHashIndex) {
+                    tooltip.setText("Added once transaction is signed and sent to the payjoin server");
+                } else {
+                    AdditionalBlockTransactionHashIndex additionalReference = (AdditionalBlockTransactionHashIndex) input;
+                    StringJoiner joiner = new StringJoiner("\n");
+                    for(BlockTransactionHashIndex additionalInput : additionalReference.getAdditionalInputs()) {
+                        joiner.add(getInputDescription(additionalInput));
+                    }
+                    tooltip.setText(joiner.toString());
                 }
-                tooltip.setText(joiner.toString());
                 tooltip.getStyleClass().add("input-label");
             }
             tooltip.setShowDelay(new Duration(TOOLTIP_SHOW_DELAY));
@@ -218,11 +245,16 @@ public class TransactionDiagram extends GridPane {
         group.getChildren().add(yaxisLine);
 
         double width = 140.0;
+        List<BlockTransactionHashIndex> inputs = new ArrayList<>(displayedUtxos.keySet());
         int numUtxos = displayedUtxos.size();
         for(int i = 1; i <= numUtxos; i++) {
             CubicCurve curve = new CubicCurve();
             curve.getStyleClass().add("input-line");
 
+            if(inputs.get(numUtxos-i) instanceof PayjoinBlockTransactionHashIndex) {
+                curve.getStyleClass().add("input-dashed-line");
+            }
+
             curve.setStartX(0);
             double scaleFactor = (double)i / (numUtxos + 1);
             int nodeHeight = 17;
@@ -399,6 +431,17 @@ public class TransactionDiagram extends GridPane {
         return consolidationGlyph;
     }
 
+    public static Glyph getTxoGlyph() {
+        return getChangeGlyph();
+    }
+
+    public static Glyph getPayjoinGlyph() {
+        Glyph payjoinGlyph = new Glyph(FontAwesome5.FONT_NAME, FontAwesome5.Glyph.RANDOM);
+        payjoinGlyph.getStyleClass().add("payjoin-icon");
+        payjoinGlyph.setFontSize(12);
+        return payjoinGlyph;
+    }
+
     public static Glyph getChangeGlyph() {
         Glyph changeGlyph = new Glyph(FontAwesome5.FONT_NAME, FontAwesome5.Glyph.COINS);
         changeGlyph.getStyleClass().add("change-icon");
@@ -427,6 +470,17 @@ public class TransactionDiagram extends GridPane {
         return lockGlyph;
     }
 
+    private static class PayjoinBlockTransactionHashIndex extends BlockTransactionHashIndex {
+        public PayjoinBlockTransactionHashIndex() {
+            super(Sha256Hash.ZERO_HASH, 0, new Date(), 0L, 0, 0);
+        }
+
+        @Override
+        public String getLabel() {
+            return "Payjoin input";
+        }
+    }
+
     private static class AdditionalBlockTransactionHashIndex extends BlockTransactionHashIndex {
         private final List<BlockTransactionHashIndex> additionalInputs;
 

src/main/java/com/sparrowwallet/sparrow/control/TransactionIdDialog.java

@@ -2,7 +2,7 @@ package com.sparrowwallet.sparrow.control;
 
 import com.sparrowwallet.drongo.Utils;
 import com.sparrowwallet.drongo.protocol.Sha256Hash;
-import com.sparrowwallet.sparrow.AppController;
+import com.sparrowwallet.sparrow.AppServices;
 import javafx.application.Platform;
 import javafx.beans.binding.Bindings;
 import javafx.beans.binding.BooleanBinding;
@@ -23,13 +23,13 @@ public class TransactionIdDialog extends Dialog<Sha256Hash> {
 
     public TransactionIdDialog() {
         this.txid = (CustomTextField) TextFields.createClearableTextField();
-        txid.setFont(AppController.getMonospaceFont());
+        txid.setFont(AppServices.getMonospaceFont());
         final DialogPane dialogPane = getDialogPane();
-        AppController.setStageIcon(dialogPane.getScene().getWindow());
+        AppServices.setStageIcon(dialogPane.getScene().getWindow());
 
         setTitle("Load Transaction");
         dialogPane.setHeaderText("Enter the transaction ID:");
-        dialogPane.getStylesheets().add(AppController.class.getResource("general.css").toExternalForm());
+        dialogPane.getStylesheets().add(AppServices.class.getResource("general.css").toExternalForm());
         dialogPane.getButtonTypes().addAll(ButtonType.CANCEL);
         dialogPane.setPrefWidth(550);
         dialogPane.setPrefHeight(200);

src/main/java/com/sparrowwallet/sparrow/control/UtxosChart.java

@@ -39,7 +39,7 @@ public class UtxosChart extends BarChart<String, Number> {
     public void update(WalletUtxosEntry walletUtxosEntry) {
         List<Data<String, Number>> utxoDataList = walletUtxosEntry.getChildren().stream()
                 .map(entry -> new XYChart.Data<>(getCategoryName(entry), (Number)entry.getValue(), entry))
-                .sorted((o1, o2) -> (int) (o2.getYValue().longValue() - o1.getYValue().longValue()))
+                .sorted((o1, o2) -> Long.compare(o2.getYValue().longValue(), o1.getYValue().longValue()))
                 .collect(Collectors.toList());
 
         totalUtxos = utxoDataList.size();
@@ -86,11 +86,10 @@ public class UtxosChart extends BarChart<String, Number> {
 
         for(int i = 0; i < utxoSeries.getData().size(); i++) {
             XYChart.Data<String, Number> data = utxoSeries.getData().get(i);
-            Node bar = lookup(".data" + i);
-            if(bar != null) {
-                if(data.getExtraValue() != null && entries.contains((Entry)data.getExtraValue())) {
-                    bar.getStyleClass().add("selected");
-                } else if(data.getExtraValue() == null && entries.size() == totalUtxos) {
+
+            if((data.getExtraValue() != null && entries.contains((Entry)data.getExtraValue())) || (data.getExtraValue() == null && entries.size() == totalUtxos)) {
+                Node bar = lookup(".data" + i);
+                if(bar != null) {
                     bar.getStyleClass().add("selected");
                 }
             }

src/main/java/com/sparrowwallet/sparrow/control/WalletExportDialog.java

@@ -3,7 +3,7 @@ package com.sparrowwallet.sparrow.control;
 import com.google.common.eventbus.Subscribe;
 import com.sparrowwallet.drongo.policy.PolicyType;
 import com.sparrowwallet.drongo.wallet.Wallet;
-import com.sparrowwallet.sparrow.AppController;
+import com.sparrowwallet.sparrow.AppServices;
 import com.sparrowwallet.sparrow.EventManager;
 import com.sparrowwallet.sparrow.event.WalletExportEvent;
 import com.sparrowwallet.sparrow.io.*;
@@ -23,7 +23,7 @@ public class WalletExportDialog extends Dialog<Wallet> {
         });
 
         final DialogPane dialogPane = getDialogPane();
-        AppController.setStageIcon(dialogPane.getScene().getWindow());
+        AppServices.setStageIcon(dialogPane.getScene().getWindow());
 
         StackPane stackPane = new StackPane();
         dialogPane.setContent(stackPane);
@@ -41,9 +41,9 @@ public class WalletExportDialog extends Dialog<Wallet> {
 
         List<WalletExport> exporters;
         if(wallet.getPolicyType() == PolicyType.SINGLE) {
-            exporters = List.of(new Electrum(), new Specter());
+            exporters = List.of(new Electrum(), new SpecterDesktop());
         } else if(wallet.getPolicyType() == PolicyType.MULTI) {
-            exporters = List.of(new ColdcardMultisig(), new CoboVaultMultisig(), new Electrum(), new Specter());
+            exporters = List.of(new ColdcardMultisig(), new CoboVaultMultisig(), new Electrum(), new SpecterDesktop());
         } else {
             throw new UnsupportedOperationException("Cannot export wallet with policy type " + wallet.getPolicyType());
         }

src/main/java/com/sparrowwallet/sparrow/control/WalletImportDialog.java

@@ -2,7 +2,7 @@ package com.sparrowwallet.sparrow.control;
 
 import com.google.common.eventbus.Subscribe;
 import com.sparrowwallet.drongo.wallet.Wallet;
-import com.sparrowwallet.sparrow.AppController;
+import com.sparrowwallet.sparrow.AppServices;
 import com.sparrowwallet.sparrow.EventManager;
 import com.sparrowwallet.sparrow.event.WalletImportEvent;
 import com.sparrowwallet.sparrow.io.*;
@@ -22,7 +22,7 @@ public class WalletImportDialog extends Dialog<Wallet> {
         });
 
         final DialogPane dialogPane = getDialogPane();
-        AppController.setStageIcon(dialogPane.getScene().getWindow());
+        AppServices.setStageIcon(dialogPane.getScene().getWindow());
 
         StackPane stackPane = new StackPane();
         dialogPane.setContent(stackPane);
@@ -45,7 +45,7 @@ public class WalletImportDialog extends Dialog<Wallet> {
             importAccordion.getPanes().add(importPane);
         }
 
-        List<WalletImport> walletImporters = List.of(new ColdcardMultisig(), new CoboVaultMultisig(), new Electrum(), new Specter());
+        List<WalletImport> walletImporters = List.of(new ColdcardMultisig(), new CoboVaultMultisig(), new Electrum(), new SpecterDesktop());
         for(WalletImport importer : walletImporters) {
             FileWalletImportPane importPane = new FileWalletImportPane(importer);
             importAccordion.getPanes().add(importPane);

src/main/java/com/sparrowwallet/sparrow/control/WalletNameDialog.java

@@ -1,6 +1,6 @@
 package com.sparrowwallet.sparrow.control;
 
-import com.sparrowwallet.sparrow.AppController;
+import com.sparrowwallet.sparrow.AppServices;
 import com.sparrowwallet.sparrow.glyphfont.FontAwesome5;
 import com.sparrowwallet.sparrow.io.Storage;
 import javafx.application.Platform;
@@ -22,11 +22,11 @@ public class WalletNameDialog extends Dialog<String> {
     public WalletNameDialog() {
         this.name = (CustomTextField)TextFields.createClearableTextField();
         final DialogPane dialogPane = getDialogPane();
-        AppController.setStageIcon(dialogPane.getScene().getWindow());
+        AppServices.setStageIcon(dialogPane.getScene().getWindow());
 
         setTitle("Wallet Name");
         dialogPane.setHeaderText("Enter a name for this wallet:");
-        dialogPane.getStylesheets().add(AppController.class.getResource("general.css").toExternalForm());
+        dialogPane.getStylesheets().add(AppServices.class.getResource("general.css").toExternalForm());
         dialogPane.getButtonTypes().addAll(ButtonType.CANCEL);
         dialogPane.setPrefWidth(380);
         dialogPane.setPrefHeight(200);

src/main/java/com/sparrowwallet/sparrow/control/WalletPasswordDialog.java

@@ -1,7 +1,7 @@
 package com.sparrowwallet.sparrow.control;
 
 import com.sparrowwallet.drongo.SecureString;
-import com.sparrowwallet.sparrow.AppController;
+import com.sparrowwallet.sparrow.AppServices;
 import javafx.application.Platform;
 import javafx.beans.binding.Bindings;
 import javafx.beans.binding.BooleanBinding;
@@ -37,8 +37,8 @@ public class WalletPasswordDialog extends Dialog<SecureString> {
         final DialogPane dialogPane = getDialogPane();
         setTitle("Wallet Password" + (walletName != null ? " - " + walletName : ""));
         dialogPane.setHeaderText(walletName != null ? requirement.description.substring(0, requirement.description.length() - 1) + " for " + walletName + ":" : requirement.description);
-        dialogPane.getStylesheets().add(AppController.class.getResource("general.css").toExternalForm());
-        AppController.setStageIcon(dialogPane.getScene().getWindow());
+        dialogPane.getStylesheets().add(AppServices.class.getResource("general.css").toExternalForm());
+        AppServices.setStageIcon(dialogPane.getScene().getWindow());
         dialogPane.getButtonTypes().addAll(ButtonType.CANCEL);
         dialogPane.setPrefWidth(380);
         dialogPane.setPrefHeight(260);

src/main/java/com/sparrowwallet/sparrow/control/WelcomeDialog.java

@@ -1,6 +1,6 @@
 package com.sparrowwallet.sparrow.control;
 
-import com.sparrowwallet.sparrow.AppController;
+import com.sparrowwallet.sparrow.AppServices;
 import com.sparrowwallet.sparrow.Mode;
 import javafx.application.HostServices;
 import javafx.geometry.Insets;
@@ -27,8 +27,8 @@ public class WelcomeDialog extends Dialog<Mode> {
 
         setTitle("Welcome to Sparrow");
         dialogPane.setHeaderText("Welcome to Sparrow!");
-        dialogPane.getStylesheets().add(AppController.class.getResource("general.css").toExternalForm());
-        AppController.setStageIcon(dialogPane.getScene().getWindow());
+        dialogPane.getStylesheets().add(AppServices.class.getResource("general.css").toExternalForm());
+        AppServices.setStageIcon(dialogPane.getScene().getWindow());
         dialogPane.setPrefWidth(600);
         dialogPane.setPrefHeight(480);
 

src/main/java/com/sparrowwallet/sparrow/event/ConnectionEvent.java

@@ -1,9 +1,11 @@
 package com.sparrowwallet.sparrow.event;
 
 import com.sparrowwallet.drongo.protocol.BlockHeader;
+import com.sparrowwallet.sparrow.net.MempoolRateSize;
 
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 public class ConnectionEvent extends FeeRatesUpdatedEvent {
     private final List<String> serverVersion;
@@ -12,8 +14,8 @@ public class ConnectionEvent extends FeeRatesUpdatedEvent {
     private final BlockHeader blockHeader;
     private final Double minimumRelayFeeRate;
 
-    public ConnectionEvent(List<String> serverVersion, String serverBanner, int blockHeight, BlockHeader blockHeader, Map<Integer, Double> targetBlockFeeRates, Double minimumRelayFeeRate) {
-        super(targetBlockFeeRates);
+    public ConnectionEvent(List<String> serverVersion, String serverBanner, int blockHeight, BlockHeader blockHeader, Map<Integer, Double> targetBlockFeeRates, Set<MempoolRateSize> mempoolRateSizes, Double minimumRelayFeeRate) {
+        super(targetBlockFeeRates, mempoolRateSizes);
         this.serverVersion = serverVersion;
         this.serverBanner = serverBanner;
         this.blockHeight = blockHeight;

src/main/java/com/sparrowwallet/sparrow/event/FeeRatesSelectionChangedEvent.java

@@ -0,0 +1,15 @@
+package com.sparrowwallet.sparrow.event;
+
+import com.sparrowwallet.sparrow.wallet.FeeRatesSelection;
+
+public class FeeRatesSelectionChangedEvent {
+    private final FeeRatesSelection feeRatesSelection;
+
+    public FeeRatesSelectionChangedEvent(FeeRatesSelection feeRatesSelection) {
+        this.feeRatesSelection = feeRatesSelection;
+    }
+
+    public FeeRatesSelection getFeeRateSelection() {
+        return feeRatesSelection;
+    }
+}

src/main/java/com/sparrowwallet/sparrow/event/FeeRatesSourceChangedEvent.java

@@ -0,0 +1,15 @@
+package com.sparrowwallet.sparrow.event;
+
+import com.sparrowwallet.sparrow.net.FeeRatesSource;
+
+public class FeeRatesSourceChangedEvent {
+    private final FeeRatesSource feeRatesSource;
+
+    public FeeRatesSourceChangedEvent(FeeRatesSource feeRatesSource) {
+        this.feeRatesSource = feeRatesSource;
+    }
+
+    public FeeRatesSource getFeeRateSource() {
+        return feeRatesSource;
+    }
+}

src/main/java/com/sparrowwallet/sparrow/event/FeeRatesUpdatedEvent.java

@@ -1,15 +1,24 @@
 package com.sparrowwallet.sparrow.event;
 
+import com.sparrowwallet.sparrow.net.MempoolRateSize;
+
 import java.util.Map;
+import java.util.Set;
 
 public class FeeRatesUpdatedEvent {
     private final Map<Integer, Double> targetBlockFeeRates;
+    private final Set<MempoolRateSize> mempoolRateSizes;
 
-    public FeeRatesUpdatedEvent(Map<Integer, Double> targetBlockFeeRates) {
+    public FeeRatesUpdatedEvent(Map<Integer, Double> targetBlockFeeRates, Set<MempoolRateSize> mempoolRateSizes) {
         this.targetBlockFeeRates = targetBlockFeeRates;
+        this.mempoolRateSizes = mempoolRateSizes;
     }
 
     public Map<Integer, Double> getTargetBlockFeeRates() {
         return targetBlockFeeRates;
     }
+
+    public Set<MempoolRateSize> getMempoolRateSizes() {
+        return mempoolRateSizes;
+    }
 }

src/main/java/com/sparrowwallet/sparrow/event/FiatCurrencySelectedEvent.java

@@ -1,6 +1,6 @@
 package com.sparrowwallet.sparrow.event;
 
-import com.sparrowwallet.sparrow.io.ExchangeSource;
+import com.sparrowwallet.sparrow.net.ExchangeSource;
 
 import java.util.Currency;
 

src/main/java/com/sparrowwallet/sparrow/event/HideEmptyUsedAddressesStatusEvent.java

@@ -0,0 +1,13 @@
+package com.sparrowwallet.sparrow.event;
+
+public class HideEmptyUsedAddressesStatusEvent {
+    private final boolean hideEmptyUsedAddresses;
+
+    public HideEmptyUsedAddressesStatusEvent(boolean hideEmptyUsedAddresses) {
+        this.hideEmptyUsedAddresses = hideEmptyUsedAddresses;
+    }
+
+    public boolean isHideEmptyUsedAddresses() {
+        return hideEmptyUsedAddresses;
+    }
+}

src/main/java/com/sparrowwallet/sparrow/event/OpenWalletsEvent.java

@@ -2,18 +2,25 @@ package com.sparrowwallet.sparrow.event;
 
 import com.sparrowwallet.drongo.wallet.Wallet;
 import com.sparrowwallet.sparrow.io.Storage;
+import javafx.stage.Window;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 
 public class OpenWalletsEvent {
+    private final Window window;
     private final Map<Wallet, Storage> walletsMap;
 
-    public OpenWalletsEvent(Map<Wallet, Storage> walletsMap) {
+    public OpenWalletsEvent(Window window, Map<Wallet, Storage> walletsMap) {
+        this.window = window;
         this.walletsMap = walletsMap;
     }
 
+    public Window getWindow() {
+        return window;
+    }
+
     public List<Wallet> getWallets() {
         return new ArrayList<>(walletsMap.keySet());
     }

src/main/java/com/sparrowwallet/sparrow/event/OpenWalletsNewWindowsStatusEvent.java

@@ -0,0 +1,13 @@
+package com.sparrowwallet.sparrow.event;
+
+public class OpenWalletsNewWindowsStatusEvent {
+    private final boolean openWalletsInNewWindows;
+
+    public OpenWalletsNewWindowsStatusEvent(boolean openWalletsInNewWindows) {
+        this.openWalletsInNewWindows = openWalletsInNewWindows;
+    }
+
+    public boolean isOpenWalletsInNewWindows() {
+        return openWalletsInNewWindows;
+    }
+}

src/main/java/com/sparrowwallet/sparrow/event/RequestQRScanEvent.java

@@ -1,5 +1,18 @@
 package com.sparrowwallet.sparrow.event;
 
+import javafx.stage.Window;
+
+/**
+ * Event class used to request the QRScanDialog is opened
+ */
 public class RequestQRScanEvent {
-    //Empty event class used to request the QRScanDialog is opened
+    private final Window window;
+
+    public RequestQRScanEvent(Window window) {
+        this.window = window;
+    }
+
+    public Window getWindow() {
+        return window;
+    }
 }

src/main/java/com/sparrowwallet/sparrow/event/RequestTransactionOpenEvent.java

@@ -1,5 +1,18 @@
 package com.sparrowwallet.sparrow.event;
 
+import javafx.stage.Window;
+
+/**
+ * Event class used to request the transaction open file dialog
+ */
 public class RequestTransactionOpenEvent {
-    //Empty event class used to request the transaction open file dialog
+    private final Window window;
+
+    public RequestTransactionOpenEvent(Window window) {
+        this.window = window;
+    }
+
+    public Window getWindow() {
+        return window;
+    }
 }

src/main/java/com/sparrowwallet/sparrow/event/RequestWalletOpenEvent.java

@@ -1,5 +1,18 @@
 package com.sparrowwallet.sparrow.event;
 
+import javafx.stage.Window;
+
+/**
+ * Event class used to request the wallet open dialog
+ */
 public class RequestWalletOpenEvent {
-    //Empty event class used to request the wallet open dialog
+    private final Window window;
+
+    public RequestWalletOpenEvent(Window window) {
+        this.window = window;
+    }
+
+    public Window getWindow() {
+        return window;
+    }
 }

src/main/java/com/sparrowwallet/sparrow/event/SendActionEvent.java

@@ -1,17 +1,24 @@
 package com.sparrowwallet.sparrow.event;
 
-import com.sparrowwallet.sparrow.wallet.HashIndexEntry;
+import com.sparrowwallet.drongo.wallet.BlockTransactionHashIndex;
+import com.sparrowwallet.drongo.wallet.Wallet;
 
 import java.util.List;
 
 public class SendActionEvent {
-    private final List<HashIndexEntry> utxoEntries;
+    private final Wallet wallet;
+    private final List<BlockTransactionHashIndex> utxos;
 
-    public SendActionEvent(List<HashIndexEntry> utxoEntries) {
-        this.utxoEntries = utxoEntries;
+    public SendActionEvent(Wallet wallet, List<BlockTransactionHashIndex> utxos) {
+        this.wallet = wallet;
+        this.utxos = utxos;
     }
 
-    public List<HashIndexEntry> getUtxoEntries() {
-        return utxoEntries;
+    public Wallet getWallet() {
+        return wallet;
+    }
+
+    public List<BlockTransactionHashIndex> getUtxos() {
+        return utxos;
     }
 }

src/main/java/com/sparrowwallet/sparrow/event/SpendUtxoEvent.java

@@ -1,17 +1,47 @@
 package com.sparrowwallet.sparrow.event;
 
-import com.sparrowwallet.sparrow.wallet.HashIndexEntry;
+import com.sparrowwallet.drongo.wallet.BlockTransactionHashIndex;
+import com.sparrowwallet.drongo.wallet.Payment;
+import com.sparrowwallet.drongo.wallet.Wallet;
 
 import java.util.List;
 
 public class SpendUtxoEvent {
-    private final List<HashIndexEntry> utxoEntries;
+    private final Wallet wallet;
+    private final List<BlockTransactionHashIndex> utxos;
+    private final List<Payment> payments;
+    private final Long fee;
+    private final boolean includeMempoolInputs;
 
-    public SpendUtxoEvent(List<HashIndexEntry> utxoEntries) {
-        this.utxoEntries = utxoEntries;
+    public SpendUtxoEvent(Wallet wallet, List<BlockTransactionHashIndex> utxos) {
+        this(wallet, utxos, null, null, false);
     }
 
-    public List<HashIndexEntry> getUtxoEntries() {
-        return utxoEntries;
+    public SpendUtxoEvent(Wallet wallet, List<BlockTransactionHashIndex> utxos, List<Payment> payments, Long fee, boolean includeMempoolInputs) {
+        this.wallet = wallet;
+        this.utxos = utxos;
+        this.payments = payments;
+        this.fee = fee;
+        this.includeMempoolInputs = includeMempoolInputs;
+    }
+
+    public Wallet getWallet() {
+        return wallet;
+    }
+
+    public List<BlockTransactionHashIndex> getUtxos() {
+        return utxos;
+    }
+
+    public List<Payment> getPayments() {
+        return payments;
+    }
+
+    public Long getFee() {
+        return fee;
+    }
+
+    public boolean isIncludeMempoolInputs() {
+        return includeMempoolInputs;
     }
 }

src/main/java/com/sparrowwallet/sparrow/event/ThemeChangedEvent.java

@@ -0,0 +1,15 @@
+package com.sparrowwallet.sparrow.event;
+
+import com.sparrowwallet.sparrow.Theme;
+
+public class ThemeChangedEvent {
+    private final Theme theme;
+
+    public ThemeChangedEvent(Theme theme) {
+        this.theme = theme;
+    }
+
+    public Theme getTheme() {
+        return theme;
+    }
+}

src/main/java/com/sparrowwallet/sparrow/event/ViewPSBTEvent.java

@@ -2,28 +2,43 @@ package com.sparrowwallet.sparrow.event;
 
 import com.sparrowwallet.drongo.psbt.PSBT;
 import com.sparrowwallet.sparrow.transaction.TransactionView;
+import javafx.stage.Window;
+
+import java.io.File;
 
 public class ViewPSBTEvent {
+    private final Window window;
     private final String label;
+    private final File file;
     private final PSBT psbt;
     private final TransactionView initialView;
     private final Integer initialIndex;
 
-    public ViewPSBTEvent(String label, PSBT psbt) {
-        this(label, psbt, TransactionView.HEADERS, null);
+    public ViewPSBTEvent(Window window, String label, File file, PSBT psbt) {
+        this(window, label, file, psbt, TransactionView.HEADERS, null);
     }
 
-    public ViewPSBTEvent(String label, PSBT psbt, TransactionView initialView, Integer initialIndex) {
+    public ViewPSBTEvent(Window window, String label, File file, PSBT psbt, TransactionView initialView, Integer initialIndex) {
+        this.window = window;
         this.label = label;
+        this.file = file;
         this.psbt = psbt;
         this.initialView = initialView;
         this.initialIndex = initialIndex;
     }
 
+    public Window getWindow() {
+        return window;
+    }
+
     public String getLabel() {
         return label;
     }
 
+    public File getFile() {
+        return file;
+    }
+
     public PSBT getPsbt() {
         return psbt;
     }

src/main/java/com/sparrowwallet/sparrow/event/ViewTransactionEvent.java

@@ -3,26 +3,33 @@ package com.sparrowwallet.sparrow.event;
 import com.sparrowwallet.drongo.wallet.BlockTransaction;
 import com.sparrowwallet.sparrow.transaction.TransactionView;
 import com.sparrowwallet.sparrow.wallet.HashIndexEntry;
+import javafx.stage.Window;
 
 public class ViewTransactionEvent {
+    private final Window window;
     private final BlockTransaction blockTransaction;
     private final TransactionView initialView;
     private final Integer initialIndex;
 
-    public ViewTransactionEvent(BlockTransaction blockTransaction) {
-        this(blockTransaction, TransactionView.HEADERS, null);
+    public ViewTransactionEvent(Window window, BlockTransaction blockTransaction) {
+        this(window, blockTransaction, TransactionView.HEADERS, null);
     }
 
-    public ViewTransactionEvent(BlockTransaction blockTransaction, HashIndexEntry hashIndexEntry) {
-        this(blockTransaction, hashIndexEntry.getType().equals(HashIndexEntry.Type.INPUT) ? TransactionView.INPUT : TransactionView.OUTPUT, (int)hashIndexEntry.getHashIndex().getIndex());
+    public ViewTransactionEvent(Window window, BlockTransaction blockTransaction, HashIndexEntry hashIndexEntry) {
+        this(window, blockTransaction, hashIndexEntry.getType().equals(HashIndexEntry.Type.INPUT) ? TransactionView.INPUT : TransactionView.OUTPUT, (int)hashIndexEntry.getHashIndex().getIndex());
     }
 
-    public ViewTransactionEvent(BlockTransaction blockTransaction, TransactionView initialView, Integer initialIndex) {
+    public ViewTransactionEvent(Window window, BlockTransaction blockTransaction, TransactionView initialView, Integer initialIndex) {
+        this.window = window;
         this.blockTransaction = blockTransaction;
         this.initialView = initialView;
         this.initialIndex = initialIndex;
     }
 
+    public Window getWindow() {
+        return window;
+    }
+
     public BlockTransaction getBlockTransaction() {
         return blockTransaction;
     }

src/main/java/com/sparrowwallet/sparrow/event/ViewWalletEvent.java

@@ -0,0 +1,29 @@
+package com.sparrowwallet.sparrow.event;
+
+import com.sparrowwallet.drongo.wallet.Wallet;
+import com.sparrowwallet.sparrow.io.Storage;
+import javafx.stage.Window;
+
+public class ViewWalletEvent {
+    private final Window window;
+    private final Wallet wallet;
+    private final Storage storage;
+
+    public ViewWalletEvent(Window window, Wallet wallet, Storage storage) {
+        this.window = window;
+        this.wallet = wallet;
+        this.storage = storage;
+    }
+
+    public Window getWindow() {
+        return window;
+    }
+
+    public Wallet getWallet() {
+        return wallet;
+    }
+
+    public Storage getStorage() {
+        return storage;
+    }
+}

src/main/java/com/sparrowwallet/sparrow/event/WalletAddressesStatusEvent.java

@@ -0,0 +1,18 @@
+package com.sparrowwallet.sparrow.event;
+
+import com.sparrowwallet.drongo.wallet.Wallet;
+
+/**
+ * Used to indicate that the display configuration of wallet addresses has been updated
+ */
+public class WalletAddressesStatusEvent {
+    private final Wallet wallet;
+
+    public WalletAddressesStatusEvent(Wallet wallet) {
+        this.wallet = wallet;
+    }
+
+    public Wallet getWallet() {
+        return wallet;
+    }
+}

src/main/java/com/sparrowwallet/sparrow/event/WalletHistoryStatusEvent.java

@@ -1,28 +1,38 @@
 package com.sparrowwallet.sparrow.event;
 
+import com.sparrowwallet.drongo.wallet.Wallet;
+
 public class WalletHistoryStatusEvent {
+    private final Wallet wallet;
     private final boolean loaded;
     private final String statusMessage;
     private final String errorMessage;
 
-    public WalletHistoryStatusEvent(boolean loaded) {
+    public WalletHistoryStatusEvent(Wallet wallet, boolean loaded) {
+        this.wallet = wallet;
         this.loaded = loaded;
         this.statusMessage = null;
         this.errorMessage = null;
     }
 
-    public WalletHistoryStatusEvent(boolean loaded, String statusMessage) {
+    public WalletHistoryStatusEvent(Wallet wallet,boolean loaded, String statusMessage) {
+        this.wallet = wallet;
         this.loaded = false;
         this.statusMessage = statusMessage;
         this.errorMessage = null;
     }
 
-    public WalletHistoryStatusEvent(String errorMessage) {
+    public WalletHistoryStatusEvent(Wallet wallet,String errorMessage) {
+        this.wallet = wallet;
         this.loaded = false;
         this.statusMessage = null;
         this.errorMessage = errorMessage;
     }
 
+    public Wallet getWallet() {
+        return wallet;
+    }
+
     public boolean isLoading() {
         return !loaded;
     }

src/main/java/com/sparrowwallet/sparrow/event/WalletUtxoStatusChangedEvent.java

@@ -0,0 +1,17 @@
+package com.sparrowwallet.sparrow.event;
+
+import com.sparrowwallet.drongo.wallet.BlockTransactionHashIndex;
+import com.sparrowwallet.drongo.wallet.Wallet;
+
+public class WalletUtxoStatusChangedEvent extends WalletDataChangedEvent {
+    private final BlockTransactionHashIndex utxo;
+
+    public WalletUtxoStatusChangedEvent(Wallet wallet, BlockTransactionHashIndex utxo) {
+        super(wallet);
+        this.utxo = utxo;
+    }
+
+    public BlockTransactionHashIndex getUtxo() {
+        return utxo;
+    }
+}

src/main/java/com/sparrowwallet/sparrow/glyphfont/FontAwesome5.java

@@ -30,6 +30,7 @@ public class FontAwesome5 extends GlyphFont {
         ELLIPSIS_H('\uf141'),
         EYE('\uf06e'),
         HAND_HOLDING('\uf4bd'),
+        HAND_HOLDING_MEDICAL('\ue05c'),
         KEY('\uf084'),
         LAPTOP('\uf109'),
         LOCK('\uf023'),
@@ -38,6 +39,7 @@ public class FontAwesome5 extends GlyphFont {
         PLUS('\uf067'),
         QRCODE('\uf029'),
         QUESTION_CIRCLE('\uf059'),
+        RANDOM('\uf074'),
         REPLY_ALL('\uf122'),
         SATELLITE_DISH('\uf7c0'),
         SD_CARD('\uf7c2'),

src/main/java/com/sparrowwallet/sparrow/io/CoboVaultMultisig.java

@@ -29,7 +29,7 @@ public class CoboVaultMultisig extends ColdcardMultisig {
 
     @Override
     public String getKeystoreImportDescription() {
-        return "Import file or QR created by using the Multisig Wallet > Show/Export XPUB > Export All > Export feature on your Cobo Vault.";
+        return "Import file or QR created by using the Multisig Wallet > Show/Export XPUB feature on your Cobo Vault.";
     }
 
     @Override
@@ -54,7 +54,12 @@ public class CoboVaultMultisig extends ColdcardMultisig {
     }
 
     @Override
-    public boolean isScannable() {
+    public boolean isWalletImportScannable() {
+        return true;
+    }
+
+    @Override
+    public boolean isKeystoreImportScannable() {
         return true;
     }
 }

src/main/java/com/sparrowwallet/sparrow/io/CoboVaultSinglesig.java

@@ -6,10 +6,7 @@ import com.sparrowwallet.drongo.KeyDerivation;
 import com.sparrowwallet.drongo.policy.Policy;
 import com.sparrowwallet.drongo.policy.PolicyType;
 import com.sparrowwallet.drongo.protocol.ScriptType;
-import com.sparrowwallet.drongo.wallet.Keystore;
-import com.sparrowwallet.drongo.wallet.KeystoreSource;
-import com.sparrowwallet.drongo.wallet.Wallet;
-import com.sparrowwallet.drongo.wallet.WalletModel;
+import com.sparrowwallet.drongo.wallet.*;
 
 import java.io.File;
 import java.io.InputStream;
@@ -23,7 +20,7 @@ public class CoboVaultSinglesig implements KeystoreFileImport, WalletImport {
 
     @Override
     public String getKeystoreImportDescription() {
-        return "Import file or QR created by using the Watch-Only Wallet > Generic Wallet > Export Wallet feature on your Cobo Vault.";
+        return "Import file or QR created by using the Settings > Watch-Only Wallet > Generic Wallet > Export Wallet feature on your Cobo Vault.";
     }
 
     @Override
@@ -75,8 +72,10 @@ public class CoboVaultSinglesig implements KeystoreFileImport, WalletImport {
         wallet.getKeystores().add(keystore);
         wallet.setDefaultPolicy(Policy.getPolicy(PolicyType.SINGLE, ScriptType.P2WPKH, wallet.getKeystores(), null));
 
-        if(!wallet.isValid()) {
-            throw new ImportException("Wallet is in an inconsistent state.");
+        try {
+            wallet.checkWallet();
+        } catch(InvalidWalletException e) {
+            throw new ImportException("Imported Cobo Vault wallet was invalid: " + e.getMessage());
         }
 
         return wallet;
@@ -88,7 +87,12 @@ public class CoboVaultSinglesig implements KeystoreFileImport, WalletImport {
     }
 
     @Override
-    public boolean isScannable() {
+    public boolean isWalletImportScannable() {
+        return true;
+    }
+
+    @Override
+    public boolean isKeystoreImportScannable() {
         return true;
     }
 

src/main/java/com/sparrowwallet/sparrow/io/ColdcardMultisig.java

@@ -88,7 +88,7 @@ public class ColdcardMultisig implements WalletImport, KeystoreFileImport, Walle
         wallet.setPolicyType(PolicyType.MULTI);
 
         int threshold = 2;
-        ScriptType scriptType = null;
+        ScriptType scriptType = ScriptType.P2SH;
         String derivation = null;
 
         try {
@@ -211,7 +211,12 @@ public class ColdcardMultisig implements WalletImport, KeystoreFileImport, Walle
     }
 
     @Override
-    public boolean isScannable() {
+    public boolean isWalletImportScannable() {
+        return false;
+    }
+
+    @Override
+    public boolean isKeystoreImportScannable() {
         return false;
     }
 }

src/main/java/com/sparrowwallet/sparrow/io/ColdcardSinglesig.java

@@ -8,10 +8,7 @@ import com.sparrowwallet.drongo.KeyDerivation;
 import com.sparrowwallet.drongo.policy.Policy;
 import com.sparrowwallet.drongo.policy.PolicyType;
 import com.sparrowwallet.drongo.protocol.ScriptType;
-import com.sparrowwallet.drongo.wallet.Keystore;
-import com.sparrowwallet.drongo.wallet.KeystoreSource;
-import com.sparrowwallet.drongo.wallet.Wallet;
-import com.sparrowwallet.drongo.wallet.WalletModel;
+import com.sparrowwallet.drongo.wallet.*;
 
 import java.io.File;
 import java.io.InputStream;
@@ -41,7 +38,12 @@ public class ColdcardSinglesig implements KeystoreFileImport, WalletImport {
     }
 
     @Override
-    public boolean isScannable() {
+    public boolean isWalletImportScannable() {
+        return false;
+    }
+
+    @Override
+    public boolean isKeystoreImportScannable() {
         return false;
     }
 
@@ -101,8 +103,10 @@ public class ColdcardSinglesig implements KeystoreFileImport, WalletImport {
         wallet.getKeystores().add(keystore);
         wallet.setDefaultPolicy(Policy.getPolicy(PolicyType.SINGLE, ScriptType.P2WPKH, wallet.getKeystores(), null));
 
-        if(!wallet.isValid()) {
-            throw new ImportException("Wallet is in an inconsistent state.");
+        try {
+            wallet.checkWallet();
+        } catch(InvalidWalletException e) {
+            throw new ImportException("Imported Coldcard wallet was invalid: " + e.getMessage());
         }
 
         return wallet;

src/main/java/com/sparrowwallet/sparrow/io/Config.java

@@ -4,6 +4,9 @@ import com.google.gson.*;
 import com.sparrowwallet.drongo.BitcoinUnit;
 import com.sparrowwallet.sparrow.Mode;
 import com.sparrowwallet.sparrow.Theme;
+import com.sparrowwallet.sparrow.net.ExchangeSource;
+import com.sparrowwallet.sparrow.net.FeeRatesSource;
+import com.sparrowwallet.sparrow.wallet.FeeRatesSelection;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -19,6 +22,8 @@ public class Config {
 
     private Mode mode;
     private BitcoinUnit bitcoinUnit;
+    private FeeRatesSource feeRatesSource;
+    private FeeRatesSelection feeRatesSelection;
     private Currency fiatCurrency;
     private ExchangeSource exchangeSource;
     private boolean groupByAddress = true;
@@ -26,6 +31,9 @@ public class Config {
     private boolean notifyNewTransactions = true;
     private boolean checkNewVersions = true;
     private Theme theme;
+    private boolean openWalletsInNewWindows = false;
+    private boolean hideEmptyUsedAddresses = false;
+    private boolean showTransactionHex = true;
     private List<File> recentWalletFiles;
     private Integer keyDerivationPeriod;
     private File hwi;
@@ -98,6 +106,24 @@ public class Config {
         flush();
     }
 
+    public FeeRatesSource getFeeRatesSource() {
+        return feeRatesSource;
+    }
+
+    public void setFeeRatesSource(FeeRatesSource feeRatesSource) {
+        this.feeRatesSource = feeRatesSource;
+        flush();
+    }
+
+    public FeeRatesSelection getFeeRatesSelection() {
+        return feeRatesSelection;
+    }
+
+    public void setFeeRatesSelection(FeeRatesSelection feeRatesSelection) {
+        this.feeRatesSelection = feeRatesSelection;
+        flush();
+    }
+
     public Currency getFiatCurrency() {
         return fiatCurrency;
     }
@@ -161,6 +187,33 @@ public class Config {
         flush();
     }
 
+    public boolean isOpenWalletsInNewWindows() {
+        return openWalletsInNewWindows;
+    }
+
+    public void setOpenWalletsInNewWindows(boolean openWalletsInNewWindows) {
+        this.openWalletsInNewWindows = openWalletsInNewWindows;
+        flush();
+    }
+
+    public boolean isHideEmptyUsedAddresses() {
+        return hideEmptyUsedAddresses;
+    }
+
+    public void setHideEmptyUsedAddresses(boolean hideEmptyUsedAddresses) {
+        this.hideEmptyUsedAddresses = hideEmptyUsedAddresses;
+        flush();
+    }
+
+    public boolean isShowTransactionHex() {
+        return showTransactionHex;
+    }
+
+    public void setShowTransactionHex(boolean showTransactionHex) {
+        this.showTransactionHex = showTransactionHex;
+        flush();
+    }
+
     public List<File> getRecentWalletFiles() {
         return recentWalletFiles;
     }

src/main/java/com/sparrowwallet/sparrow/io/Device.java

@@ -11,6 +11,7 @@ public class Device {
     private Boolean needsPinSent;
     private Boolean needsPassphraseSent;
     private String fingerprint;
+    private String error;
 
     public String getType() {
         return type;
@@ -60,6 +61,14 @@ public class Device {
         this.fingerprint = fingerprint;
     }
 
+    public String getError() {
+        return error;
+    }
+
+    public void setError(String error) {
+        this.error = error;
+    }
+
     public String toString() {
         return getModel() + ":" + getPath();
     }

src/main/java/com/sparrowwallet/sparrow/io/Electrum.java

@@ -4,7 +4,9 @@ import com.google.gson.*;
 import com.google.gson.reflect.TypeToken;
 import com.sparrowwallet.drongo.ExtendedKey;
 import com.sparrowwallet.drongo.KeyDerivation;
+import com.sparrowwallet.drongo.KeyPurpose;
 import com.sparrowwallet.drongo.Utils;
+import com.sparrowwallet.drongo.address.Address;
 import com.sparrowwallet.drongo.crypto.*;
 import com.sparrowwallet.drongo.policy.Policy;
 import com.sparrowwallet.drongo.policy.PolicyType;
@@ -91,6 +93,10 @@ public class Electrum implements KeystoreFileImport, WalletImport, WalletExport
                     }
                 }
 
+                if(key.equals("addresses")) {
+                    ew.addresses = gson.fromJson(map.get(key), ElectrumAddresses.class);
+                }
+
                 if(key.equals("verified_tx3")) {
                     JsonObject jsonObject = (JsonObject)map.get(key);
                     for(String txKey : jsonObject.keySet()) {
@@ -138,6 +144,9 @@ public class Electrum implements KeystoreFileImport, WalletImport, WalletExport
                     if(keystore.getWalletModel() == null) {
                         throw new ImportException("Wallet has keystore of unknown hardware wallet type \"" + ek.hw_type + "\".");
                     }
+                    if(keystore.getWalletModel().equals(WalletModel.TREZOR_1)) {
+                        keystore.setWalletModel(WalletModel.TREZOR_T);
+                    }
                 } else if("bip32".equals(ek.type)) {
                     if(ek.xprv != null && ek.seed == null) {
                         throw new ImportException("Electrum does not support exporting BIP39 derived seeds, as it does not store the mnemonic words. Only seeds created with its native Electrum Seed Version System are exportable. " +
@@ -192,14 +201,33 @@ public class Electrum implements KeystoreFileImport, WalletImport, WalletExport
                         blockTransaction.setLabel(ew.labels.get(key));
                     }
                 } catch(Exception e) {
-                    //not a tx, probably an address
+                    //not a tx - try an address
+                    if(ew.addresses != null) {
+                        try {
+                            Address address = Address.fromString(key);
+                            Map<KeyPurpose, List<String>> keyPurposes = Map.of(KeyPurpose.RECEIVE, ew.addresses.receiving, KeyPurpose.CHANGE, ew.addresses.change);
+                            for(KeyPurpose keyPurpose : keyPurposes.keySet()) {
+                                WalletNode purposeNode = wallet.getNode(keyPurpose);
+                                purposeNode.fillToIndex(keyPurposes.get(keyPurpose).size() - 1);
+                                for(WalletNode addressNode : purposeNode.getChildren()) {
+                                    if(address.equals(wallet.getAddress(addressNode))) {
+                                        addressNode.setLabel(ew.labels.get(key));
+                                    }
+                                }
+                            }
+                        } catch(Exception ex) {
+                            //not an address
+                        }
+                    }
                 }
             }
 
             wallet.updateTransactions(ew.transactions);
 
-            if(!wallet.isValid()) {
-                throw new IllegalStateException("Electrum wallet is in an inconsistent state.");
+            try {
+                wallet.checkWallet();
+            } catch(InvalidWalletException e) {
+                throw new IllegalStateException("Imported Electrum wallet was invalid: " + e.getMessage());
             }
 
             return wallet;
@@ -318,7 +346,12 @@ public class Electrum implements KeystoreFileImport, WalletImport, WalletExport
     }
 
     @Override
-    public boolean isScannable() {
+    public boolean isWalletImportScannable() {
+        return false;
+    }
+
+    @Override
+    public boolean isKeystoreImportScannable() {
         return false;
     }
 
@@ -332,6 +365,7 @@ public class Electrum implements KeystoreFileImport, WalletImport, WalletExport
         public String wallet_type;
         public String seed_type;
         public Boolean use_encryption;
+        public ElectrumAddresses addresses;
         public Map<String, String> labels = new LinkedHashMap<>();
         public Map<Sha256Hash, BlockTransaction> transactions = new HashMap<>();
     }
@@ -350,4 +384,9 @@ public class Electrum implements KeystoreFileImport, WalletImport, WalletExport
         public String passphrase;
         public Integer pw_hash_version;
     }
+
+    public static class ElectrumAddresses {
+        public List<String> receiving;
+        public List<String> change;
+    }
 }

src/main/java/com/sparrowwallet/sparrow/io/FileImport.java

@@ -4,5 +4,4 @@ import java.io.File;
 
 public interface FileImport extends Import {
     boolean isEncrypted(File file);
-    boolean isScannable();
 }

src/main/java/com/sparrowwallet/sparrow/io/Hwi.java

@@ -29,7 +29,7 @@ import java.util.zip.ZipInputStream;
 
 public class Hwi {
     private static final Logger log = LoggerFactory.getLogger(Hwi.class);
-    private static final String TEMP_FILE_PREFIX = "hwi-1.2.0-";
+    private static final String TEMP_FILE_PREFIX = "hwi-1.2.1-";
 
     private static boolean isPromptActive = false;
 
@@ -84,7 +84,7 @@ public class Hwi {
             if(result.get("xpub") != null) {
                 return result.get("xpub").getAsString();
             } else {
-                throw new ImportException("Could not retrieve xpub");
+                throw new ImportException("Could not retrieve xpub - reconnect your device and try again.");
             }
         } catch(IOException e) {
             throw new ImportException(e);
@@ -218,7 +218,7 @@ public class Hwi {
                 //The check will still happen on first invocation, but will not thereafter
                 //See https://github.com/bitcoin-core/HWI/issues/327 for details
                 if(platform == Platform.OSX) {
-                    InputStream inputStream = Hwi.class.getResourceAsStream("/native/osx/x64/hwi-1.2.0-mac-amd64-signed.zip");
+                    InputStream inputStream = Hwi.class.getResourceAsStream("/native/osx/x64/hwi-1.2.1-mac-amd64-signed.zip");
                     Path tempHwiDirPath = Files.createTempDirectory(TEMP_FILE_PREFIX, PosixFilePermissions.asFileAttribute(ownerExecutableWritable));
                     File tempHwiDir = tempHwiDirPath.toFile();
                     //tempHwiDir.deleteOnExit();
@@ -535,7 +535,17 @@ public class Hwi {
     private static class DeviceModelDeserializer implements JsonDeserializer<WalletModel> {
         @Override
         public WalletModel deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
-            return WalletModel.valueOf(json.getAsJsonPrimitive().getAsString().toUpperCase());
+            String modelStr = json.getAsJsonPrimitive().getAsString();
+            try {
+                return WalletModel.valueOf(modelStr.toUpperCase());
+            } catch(Exception e) {
+                for(WalletModel model : WalletModel.values()) {
+                    if(modelStr.startsWith(model.getType())) {
+                        return model;
+                    }
+                }
+            }
+            throw new IllegalArgumentException("Could not determine wallet model for " + modelStr);
         }
     }
 

src/main/java/com/sparrowwallet/sparrow/io/KeystoreFileImport.java

@@ -3,9 +3,9 @@ package com.sparrowwallet.sparrow.io;
 import com.sparrowwallet.drongo.protocol.ScriptType;
 import com.sparrowwallet.drongo.wallet.Keystore;
 
-import java.io.File;
 import java.io.InputStream;
 
 public interface KeystoreFileImport extends KeystoreImport, FileImport {
     Keystore getKeystore(ScriptType scriptType, InputStream inputStream, String password) throws ImportException;
+    boolean isKeystoreImportScannable();
 }

src/main/java/com/sparrowwallet/sparrow/io/SpecterDIY.java

@@ -0,0 +1,64 @@
+package com.sparrowwallet.sparrow.io;
+
+import com.google.common.io.CharStreams;
+import com.sparrowwallet.drongo.OutputDescriptor;
+import com.sparrowwallet.drongo.protocol.ScriptType;
+import com.sparrowwallet.drongo.wallet.Keystore;
+import com.sparrowwallet.drongo.wallet.KeystoreSource;
+import com.sparrowwallet.drongo.wallet.Wallet;
+import com.sparrowwallet.drongo.wallet.WalletModel;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+
+public class SpecterDIY implements KeystoreFileImport {
+    @Override
+    public Keystore getKeystore(ScriptType scriptType, InputStream inputStream, String password) throws ImportException {
+        try {
+            String text = CharStreams.toString(new InputStreamReader(inputStream));
+            String outputDesc = "sh(" + text + ")";
+            OutputDescriptor outputDescriptor = OutputDescriptor.getOutputDescriptor(outputDesc);
+            Wallet wallet = outputDescriptor.toWallet();
+
+            if(wallet.getKeystores().size() != 1) {
+                throw new ImportException("Could not determine keystore from import");
+            }
+
+            Keystore keystore = wallet.getKeystores().get(0);
+            keystore.setLabel(getName());
+            keystore.setWalletModel(WalletModel.SPECTER_DIY);
+            keystore.setSource(KeystoreSource.HW_AIRGAPPED);
+
+            return keystore;
+        } catch(IOException e) {
+            throw new ImportException(e);
+        }
+    }
+
+    @Override
+    public boolean isKeystoreImportScannable() {
+        return true;
+    }
+
+    @Override
+    public String getKeystoreImportDescription() {
+        return "Import file or QR created by using the Master Public Keys feature on your Specter DIY device. Note the default is P2WPKH for Single Signature, and P2WSH for Multi Signature.";
+    }
+
+    @Override
+    public boolean isEncrypted(File file) {
+        return false;
+    }
+
+    @Override
+    public String getName() {
+        return "Specter DIY";
+    }
+
+    @Override
+    public WalletModel getWalletModel() {
+        return WalletModel.SPECTER_DIY;
+    }
+}

src/main/java/com/sparrowwallet/sparrow/io/SpecterDesktop.java

@@ -3,6 +3,7 @@ package com.sparrowwallet.sparrow.io;
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.sparrowwallet.drongo.OutputDescriptor;
+import com.sparrowwallet.drongo.wallet.InvalidWalletException;
 import com.sparrowwallet.drongo.wallet.Wallet;
 import com.sparrowwallet.drongo.wallet.WalletModel;
 
@@ -12,7 +13,7 @@ import java.io.InputStreamReader;
 import java.io.OutputStream;
 import java.nio.charset.StandardCharsets;
 
-public class Specter implements WalletImport, WalletExport {
+public class SpecterDesktop implements WalletImport, WalletExport {
     @Override
     public void exportWallet(Wallet wallet, OutputStream outputStream) throws ExportException {
         try {
@@ -57,8 +58,10 @@ public class Specter implements WalletImport, WalletExport {
                 Wallet wallet = outputDescriptor.toWallet();
                 wallet.setName(specterWallet.label);
 
-                if(!wallet.isValid()) {
-                    throw new ImportException("Specter wallet file did not contain a valid wallet");
+                try {
+                    wallet.checkWallet();
+                } catch(InvalidWalletException e) {
+                    throw new ImportException("Imported Specter wallet was invalid: " + e.getMessage());
                 }
 
                 return wallet;
@@ -67,7 +70,7 @@ public class Specter implements WalletImport, WalletExport {
             throw new ImportException(e);
         }
 
-        throw new ImportException("File was not a valid Specter wallet");
+        throw new ImportException("File was not a valid Specter Desktop wallet");
     }
 
     @Override
@@ -76,18 +79,18 @@ public class Specter implements WalletImport, WalletExport {
     }
 
     @Override
-    public boolean isScannable() {
+    public boolean isWalletImportScannable() {
         return true;
     }
 
     @Override
     public String getName() {
-        return "Specter";
+        return "Specter Desktop";
     }
 
     @Override
     public WalletModel getWalletModel() {
-        return WalletModel.SPECTER;
+        return WalletModel.SPECTER_DESKTOP;
     }
 
     public static class SpecterWallet {

src/main/java/com/sparrowwallet/sparrow/io/Storage.java

@@ -248,8 +248,8 @@ public class Storage {
     }
 
     public static boolean walletExists(String walletName) {
-        File encrypted = new File(getWalletsDir(), walletName);
-        File unencrypted = new File(getWalletsDir(), walletName + ".json");
+        File encrypted = new File(getWalletsDir(), walletName.trim());
+        File unencrypted = new File(getWalletsDir(), walletName.trim() + ".json");
 
         return (encrypted.exists() || unencrypted.exists());
     }

src/main/java/com/sparrowwallet/sparrow/io/WalletImport.java

@@ -2,10 +2,10 @@ package com.sparrowwallet.sparrow.io;
 
 import com.sparrowwallet.drongo.wallet.Wallet;
 
-import java.io.File;
 import java.io.InputStream;
 
 public interface WalletImport extends Import, FileImport {
     String getWalletImportDescription();
     Wallet importWallet(InputStream inputStream, String password) throws ImportException;
+    boolean isWalletImportScannable();
 }

src/main/java/com/sparrowwallet/sparrow/keystoreimport/HwAirgappedController.java

@@ -16,9 +16,9 @@ public class HwAirgappedController extends KeystoreImportDetailController {
     public void initializeView() {
         List<KeystoreFileImport> importers = Collections.emptyList();
         if(getMasterController().getWallet().getPolicyType().equals(PolicyType.SINGLE)) {
-            importers = List.of(new ColdcardSinglesig(), new CoboVaultSinglesig());
+            importers = List.of(new ColdcardSinglesig(), new CoboVaultSinglesig(), new SpecterDIY());
         } else if(getMasterController().getWallet().getPolicyType().equals(PolicyType.MULTI)) {
-            importers = List.of(new ColdcardMultisig(), new CoboVaultMultisig());
+            importers = List.of(new ColdcardMultisig(), new CoboVaultMultisig(), new SpecterDIY());
         }
 
         for(KeystoreImport importer : importers) {

src/main/java/com/sparrowwallet/sparrow/keystoreimport/KeystoreImportController.java

@@ -2,7 +2,7 @@ package com.sparrowwallet.sparrow.keystoreimport;
 
 import com.sparrowwallet.drongo.wallet.KeystoreSource;
 import com.sparrowwallet.drongo.wallet.Wallet;
-import com.sparrowwallet.sparrow.AppController;
+import com.sparrowwallet.sparrow.AppServices;
 import com.sparrowwallet.sparrow.io.Device;
 import javafx.application.Platform;
 import javafx.fxml.FXML;
@@ -84,7 +84,7 @@ public class KeystoreImportController implements Initializable {
         importPane.getChildren().removeAll(importPane.getChildren());
 
         try {
-            FXMLLoader importLoader = new FXMLLoader(AppController.class.getResource("keystoreimport/" + fxmlName + ".fxml"));
+            FXMLLoader importLoader = new FXMLLoader(AppServices.class.getResource("keystoreimport/" + fxmlName + ".fxml"));
             Node importTypeNode = importLoader.load();
             KeystoreImportDetailController controller = importLoader.getController();
             controller.setMasterController(this);

src/main/java/com/sparrowwallet/sparrow/keystoreimport/KeystoreImportDialog.java

@@ -7,7 +7,7 @@ import com.sparrowwallet.drongo.wallet.Keystore;
 import com.sparrowwallet.drongo.wallet.KeystoreSource;
 import com.sparrowwallet.drongo.wallet.Wallet;
 import com.sparrowwallet.drongo.wallet.WalletModel;
-import com.sparrowwallet.sparrow.AppController;
+import com.sparrowwallet.sparrow.AppServices;
 import com.sparrowwallet.sparrow.EventManager;
 import com.sparrowwallet.sparrow.event.KeystoreImportEvent;
 import javafx.fxml.FXMLLoader;
@@ -32,10 +32,10 @@ public class KeystoreImportDialog extends Dialog<Keystore> {
         });
 
         final DialogPane dialogPane = getDialogPane();
-        AppController.setStageIcon(dialogPane.getScene().getWindow());
+        AppServices.setStageIcon(dialogPane.getScene().getWindow());
 
         try {
-            FXMLLoader ksiLoader = new FXMLLoader(AppController.class.getResource("keystoreimport/keystoreimport.fxml"));
+            FXMLLoader ksiLoader = new FXMLLoader(AppServices.class.getResource("keystoreimport/keystoreimport.fxml"));
             dialogPane.setContent(Borders.wrap(ksiLoader.load()).emptyBorder().buildAll());
             keystoreImportController = ksiLoader.getController();
             keystoreImportController.initializeView(wallet);

src/main/java/com/sparrowwallet/sparrow/net/BatchedElectrumServerRpc.java

@@ -6,6 +6,7 @@ import com.github.arteam.simplejsonrpc.client.builder.BatchRequestBuilder;
 import com.github.arteam.simplejsonrpc.client.exception.JsonRpcBatchException;
 import com.github.arteam.simplejsonrpc.client.exception.JsonRpcException;
 import com.sparrowwallet.drongo.protocol.Sha256Hash;
+import com.sparrowwallet.drongo.wallet.Wallet;
 import com.sparrowwallet.sparrow.EventManager;
 import com.sparrowwallet.sparrow.event.WalletHistoryStatusEvent;
 import org.slf4j.Logger;
@@ -14,6 +15,7 @@ import org.slf4j.LoggerFactory;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.TreeMap;
 import java.util.concurrent.atomic.AtomicLong;
 
 public class BatchedElectrumServerRpc implements ElectrumServerRpc {
@@ -69,10 +71,10 @@ public class BatchedElectrumServerRpc implements ElectrumServerRpc {
 
     @Override
     @SuppressWarnings("unchecked")
-    public Map<String, ScriptHashTx[]> getScriptHashHistory(Transport transport, Map<String, String> pathScriptHashes, boolean failOnError) {
+    public Map<String, ScriptHashTx[]> getScriptHashHistory(Transport transport, Wallet wallet, Map<String, String> pathScriptHashes, boolean failOnError) {
         JsonRpcClient client = new JsonRpcClient(transport);
         BatchRequestBuilder<String, ScriptHashTx[]> batchRequest = client.createBatchRequest().keysType(String.class).returnType(ScriptHashTx[].class);
-        EventManager.get().post(new WalletHistoryStatusEvent(false, "Loading transactions"));
+        EventManager.get().post(new WalletHistoryStatusEvent(wallet, false, "Loading transactions"));
 
         for(String path : pathScriptHashes.keySet()) {
             batchRequest.add(path, "blockchain.scripthash.get_history", pathScriptHashes.get(path));
@@ -98,7 +100,7 @@ public class BatchedElectrumServerRpc implements ElectrumServerRpc {
 
     @Override
     @SuppressWarnings("unchecked")
-    public Map<String, ScriptHashTx[]> getScriptHashMempool(Transport transport, Map<String, String> pathScriptHashes, boolean failOnError) {
+    public Map<String, ScriptHashTx[]> getScriptHashMempool(Transport transport, Wallet wallet, Map<String, String> pathScriptHashes, boolean failOnError) {
         JsonRpcClient client = new JsonRpcClient(transport);
         BatchRequestBuilder<String, ScriptHashTx[]> batchRequest = client.createBatchRequest().keysType(String.class).returnType(ScriptHashTx[].class);
 
@@ -125,10 +127,10 @@ public class BatchedElectrumServerRpc implements ElectrumServerRpc {
     }
 
     @Override
-    public Map<String, String> subscribeScriptHashes(Transport transport, Map<String, String> pathScriptHashes) {
+    public Map<String, String> subscribeScriptHashes(Transport transport, Wallet wallet, Map<String, String> pathScriptHashes) {
         JsonRpcClient client = new JsonRpcClient(transport);
         BatchRequestBuilder<String, String> batchRequest = client.createBatchRequest().keysType(String.class).returnType(String.class);
-        EventManager.get().post(new WalletHistoryStatusEvent(false, "Finding transactions"));
+        EventManager.get().post(new WalletHistoryStatusEvent(wallet, false, "Finding transactions"));
 
         for(String path : pathScriptHashes.keySet()) {
             batchRequest.add(path, "blockchain.scripthash.subscribe", pathScriptHashes.get(path));
@@ -146,10 +148,10 @@ public class BatchedElectrumServerRpc implements ElectrumServerRpc {
 
     @Override
     @SuppressWarnings("unchecked")
-    public Map<Integer, String> getBlockHeaders(Transport transport, Set<Integer> blockHeights) {
+    public Map<Integer, String> getBlockHeaders(Transport transport, Wallet wallet, Set<Integer> blockHeights) {
         JsonRpcClient client = new JsonRpcClient(transport);
         BatchRequestBuilder<Integer, String> batchRequest = client.createBatchRequest().keysType(Integer.class).returnType(String.class);
-        EventManager.get().post(new WalletHistoryStatusEvent(false, "Retrieving blocks"));
+        EventManager.get().post(new WalletHistoryStatusEvent(wallet, false, "Retrieving blocks"));
 
         for(Integer height : blockHeights) {
             batchRequest.add(height, "blockchain.block.header", height);
@@ -166,10 +168,10 @@ public class BatchedElectrumServerRpc implements ElectrumServerRpc {
 
     @Override
     @SuppressWarnings("unchecked")
-    public Map<String, String> getTransactions(Transport transport, Set<String> txids) {
+    public Map<String, String> getTransactions(Transport transport, Wallet wallet, Set<String> txids) {
         JsonRpcClient client = new JsonRpcClient(transport);
         BatchRequestBuilder<String, String> batchRequest = client.createBatchRequest().keysType(String.class).returnType(String.class);
-        EventManager.get().post(new WalletHistoryStatusEvent(false, "Retrieving transactions"));
+        EventManager.get().post(new WalletHistoryStatusEvent(wallet, false, "Retrieving transactions"));
 
         for(String txid : txids) {
             batchRequest.add(txid, "blockchain.transaction.get", txid);
@@ -228,6 +230,24 @@ public class BatchedElectrumServerRpc implements ElectrumServerRpc {
         }
     }
 
+    @Override
+    public Map<Long, Long> getFeeRateHistogram(Transport transport) {
+        try {
+            JsonRpcClient client = new JsonRpcClient(transport);
+            Long[][] feesArray = new RetryLogic<Long[][]>(MAX_RETRIES, RETRY_DELAY, IllegalStateException.class).getResult(() ->
+                    client.createRequest().returnAs(Long[][].class).method("mempool.get_fee_histogram").id(idCounter.incrementAndGet()).execute());
+
+            Map<Long, Long> feeRateHistogram = new TreeMap<>();
+            for(Long[] feePair : feesArray) {
+                feeRateHistogram.put(feePair[0], feePair[1]);
+            }
+
+            return feeRateHistogram;
+        } catch(Exception e) {
+            throw new ElectrumServerRpcException("Error getting fee rate histogram", e);
+        }
+    }
+
     @Override
     public Double getMinimumRelayFee(Transport transport) {
         try {

src/main/java/com/sparrowwallet/sparrow/net/ElectrumServer.java

@@ -5,6 +5,7 @@ import com.google.common.collect.Iterables;
 import com.google.common.eventbus.Subscribe;
 import com.google.common.net.HostAndPort;
 import com.sparrowwallet.drongo.KeyPurpose;
+import com.sparrowwallet.drongo.Network;
 import com.sparrowwallet.drongo.Utils;
 import com.sparrowwallet.drongo.protocol.*;
 import com.sparrowwallet.drongo.wallet.*;
@@ -137,7 +138,16 @@ public class ElectrumServer {
 
     public Map<WalletNode, Set<BlockTransactionHash>> getHistory(Wallet wallet, Collection<WalletNode> nodes) throws ServerException {
         Map<WalletNode, Set<BlockTransactionHash>> nodeTransactionMap = new TreeMap<>();
-        subscribeWalletNodes(wallet, nodes, nodeTransactionMap, 0);
+
+        Set<WalletNode> historyNodes = new HashSet<>(nodes);
+        //Add any nodes with mempool transactions in case these have been replaced
+        Set<WalletNode> mempoolNodes = wallet.getWalletTxos().entrySet().stream()
+                .filter(entry -> entry.getKey().getHeight() <= 0 || (entry.getKey().getSpentBy() != null && entry.getKey().getSpentBy().getHeight() <= 0))
+                .map(Map.Entry::getValue)
+                .collect(Collectors.toSet());
+        historyNodes.addAll(mempoolNodes);
+
+        subscribeWalletNodes(wallet, historyNodes, nodeTransactionMap, 0);
         getReferences(wallet, nodeTransactionMap.keySet(), nodeTransactionMap, 0);
         Set<BlockTransactionHash> newReferences = nodeTransactionMap.values().stream().flatMap(Collection::stream).filter(ref -> !wallet.getTransactions().containsKey(ref.getHash())).collect(Collectors.toSet());
         getReferencedTransactions(wallet, nodeTransactionMap);
@@ -151,7 +161,7 @@ public class ElectrumServer {
                 BlockTransaction blockTransaction = wallet.getTransactions().get(reference.getHash());
                 for(TransactionOutput txOutput : blockTransaction.getTransaction().getOutputs()) {
                     WalletNode node = walletScriptHashes.get(getScriptHash(txOutput));
-                    if(node != null && !nodes.contains(node)) {
+                    if(node != null && !historyNodes.contains(node)) {
                         additionalNodes.add(node);
                     }
                 }
@@ -161,7 +171,7 @@ public class ElectrumServer {
                     if(inputBlockTransaction != null) {
                         TransactionOutput txOutput = inputBlockTransaction.getTransaction().getOutputs().get((int)txInput.getOutpoint().getIndex());
                         WalletNode node = walletScriptHashes.get(getScriptHash(txOutput));
-                        if(node != null && !nodes.contains(node)) {
+                        if(node != null && !historyNodes.contains(node)) {
                             additionalNodes.add(node);
                         }
                     }
@@ -224,7 +234,7 @@ public class ElectrumServer {
             }
 
             //Even if we have some successes, failure to retrieve all references will result in an incomplete wallet history. Don't proceed if that's the case.
-            Map<String, ScriptHashTx[]> result = electrumServerRpc.getScriptHashHistory(getTransport(), pathScriptHashes, true);
+            Map<String, ScriptHashTx[]> result = electrumServerRpc.getScriptHashHistory(getTransport(), wallet, pathScriptHashes, true);
 
             for(String path : result.keySet()) {
                 ScriptHashTx[] txes = result.get(path);
@@ -233,7 +243,19 @@ public class ElectrumServer {
                 if(optionalNode.isPresent()) {
                     WalletNode node = optionalNode.get();
 
-                    Set<BlockTransactionHash> references = Arrays.stream(txes).map(ScriptHashTx::getBlockchainTransactionHash).collect(Collectors.toCollection(TreeSet::new));
+                    //Some servers can return the same tx as multiple ScriptHashTx entries with different heights. Take the highest height only
+                    Set<BlockTransactionHash> references = Arrays.stream(txes).map(ScriptHashTx::getBlockchainTransactionHash)
+                            .collect(TreeSet::new, (set, ref) -> {
+                                Optional<BlockTransactionHash> optExisting = set.stream().filter(prev -> prev.getHash().equals(ref.getHash())).findFirst();
+                                if(optExisting.isPresent()) {
+                                    if(optExisting.get().getHeight() < ref.getHeight()) {
+                                        set.remove(optExisting.get());
+                                        set.add(ref);
+                                    }
+                                } else {
+                                    set.add(ref);
+                                }
+                            }, TreeSet::addAll);
                     Set<BlockTransactionHash> existingReferences = nodeTransactionMap.get(node);
 
                     if(existingReferences == null) {
@@ -267,7 +289,7 @@ public class ElectrumServer {
             Map<String, String> pathScriptHashes = new LinkedHashMap<>();
             for(WalletNode node : nodes) {
                 if(node == null) {
-                    log.error("Null node for wallet " + wallet.getName() + " subscribing nodes " + nodes + " startIndex " + startIndex);
+                    log.error("Null node for wallet " + wallet.getName() + " subscribing nodes " + nodes + " startIndex " + startIndex, new Throwable());
                 }
 
                 if(node != null && node.getIndex() >= startIndex) {
@@ -286,7 +308,7 @@ public class ElectrumServer {
                 return;
             }
 
-            Map<String, String> result = electrumServerRpc.subscribeScriptHashes(getTransport(), pathScriptHashes);
+            Map<String, String> result = electrumServerRpc.subscribeScriptHashes(getTransport(), wallet, pathScriptHashes);
 
             for(String path : result.keySet()) {
                 String status = result.get(path);
@@ -320,7 +342,7 @@ public class ElectrumServer {
                 pathScriptHashes.put(Integer.toString(i), getScriptHash(output));
             }
 
-            Map<String, ScriptHashTx[]> result = electrumServerRpc.getScriptHashHistory(getTransport(), pathScriptHashes, false);
+            Map<String, ScriptHashTx[]> result = electrumServerRpc.getScriptHashHistory(getTransport(), null, pathScriptHashes, false);
 
             List<Set<BlockTransactionHash>> blockTransactionHashes = new ArrayList<>(transaction.getOutputs().size());
             for(int i = 0; i < transaction.getOutputs().size(); i++) {
@@ -372,8 +394,8 @@ public class ElectrumServer {
 
         Map<Sha256Hash, BlockTransaction> transactionMap = new HashMap<>();
         if(!references.isEmpty()) {
-            Map<Integer, BlockHeader> blockHeaderMap = getBlockHeaders(references);
-            transactionMap = getTransactions(references, blockHeaderMap);
+            Map<Integer, BlockHeader> blockHeaderMap = getBlockHeaders(wallet, references);
+            transactionMap = getTransactions(wallet, references, blockHeaderMap);
         }
 
         if(!transactionMap.equals(wallet.getTransactions())) {
@@ -381,7 +403,7 @@ public class ElectrumServer {
         }
     }
 
-    public Map<Integer, BlockHeader> getBlockHeaders(Set<BlockTransactionHash> references) throws ServerException {
+    public Map<Integer, BlockHeader> getBlockHeaders(Wallet wallet, Set<BlockTransactionHash> references) throws ServerException {
         try {
             Set<Integer> blockHeights = new TreeSet<>();
             for(BlockTransactionHash reference : references) {
@@ -394,7 +416,7 @@ public class ElectrumServer {
                 return Collections.emptyMap();
             }
 
-            Map<Integer, String> result = electrumServerRpc.getBlockHeaders(getTransport(), blockHeights);
+            Map<Integer, String> result = electrumServerRpc.getBlockHeaders(getTransport(), wallet, blockHeights);
 
             Map<Integer, BlockHeader> blockHeaderMap = new TreeMap<>();
             for(Integer height : result.keySet()) {
@@ -416,7 +438,7 @@ public class ElectrumServer {
         }
     }
 
-    public Map<Sha256Hash, BlockTransaction> getTransactions(Set<BlockTransactionHash> references, Map<Integer, BlockHeader> blockHeaderMap) throws ServerException {
+    public Map<Sha256Hash, BlockTransaction> getTransactions(Wallet wallet, Set<BlockTransactionHash> references, Map<Integer, BlockHeader> blockHeaderMap) throws ServerException {
         try {
             Set<BlockTransactionHash> checkReferences = new TreeSet<>(references);
 
@@ -425,7 +447,7 @@ public class ElectrumServer {
                 txids.add(reference.getHashAsString());
             }
 
-            Map<String, String> result = electrumServerRpc.getTransactions(getTransport(), txids);
+            Map<String, String> result = electrumServerRpc.getTransactions(getTransport(), wallet, txids);
 
             String strErrorTx = Sha256Hash.ZERO_HASH.toString();
             Map<Sha256Hash, BlockTransaction> transactionMap = new HashMap<>();
@@ -592,12 +614,28 @@ public class ElectrumServer {
                 targetBlocksFeeRatesSats.put(target, minFeeRateSatsKb / 1000d);
             }
 
+            FeeRatesSource feeRatesSource = Config.get().getFeeRatesSource();
+            feeRatesSource = (feeRatesSource == null ? FeeRatesSource.MEMPOOL_SPACE : feeRatesSource);
+            if(Network.get().equals(Network.MAINNET)) {
+                targetBlocksFeeRatesSats.putAll(feeRatesSource.getBlockTargetFeeRates(targetBlocksFeeRatesSats));
+            }
+
             return targetBlocksFeeRatesSats;
         } catch(ElectrumServerRpcException e) {
             throw new ServerException(e.getMessage(), e);
         }
     }
 
+    public Set<MempoolRateSize> getMempoolRateSizes() throws ServerException {
+        Map<Long, Long> feeRateHistogram = electrumServerRpc.getFeeRateHistogram(getTransport());
+        Set<MempoolRateSize> mempoolRateSizes = new TreeSet<>();
+        for(Long fee : feeRateHistogram.keySet()) {
+            mempoolRateSizes.add(new MempoolRateSize(fee, feeRateHistogram.get(fee)));
+        }
+
+        return mempoolRateSizes;
+    }
+
     public Double getMinimumRelayFee() throws ServerException {
         Double minFeeRateBtcKb = electrumServerRpc.getMinimumRelayFee(getTransport());
         if(minFeeRateBtcKb != null) {
@@ -696,7 +734,7 @@ public class ElectrumServer {
     }
 
     public static class ConnectionService extends ScheduledService<FeeRatesUpdatedEvent> implements Thread.UncaughtExceptionHandler {
-        private static final int FEE_RATES_PERIOD = 10 * 60 * 1000;
+        private static final int FEE_RATES_PERIOD = 30 * 1000;
 
         private final boolean subscribe;
         private boolean firstCall = true;
@@ -748,6 +786,7 @@ public class ElectrumServer {
                         String banner = electrumServer.getServerBanner();
 
                         Map<Integer, Double> blockTargetFeeRates = electrumServer.getFeeEstimates(SendController.TARGET_BLOCKS_RANGE);
+                        Set<MempoolRateSize> mempoolRateSizes = electrumServer.getMempoolRateSizes();
                         feeRatesRetrievedAt = System.currentTimeMillis();
 
                         Double minimumRelayFeeRate = electrumServer.getMinimumRelayFee();
@@ -755,7 +794,7 @@ public class ElectrumServer {
                             blockTargetFeeRates.computeIfPresent(blockTarget, (blocks, feeRate) -> feeRate < minimumRelayFeeRate ? minimumRelayFeeRate : feeRate);
                         }
 
-                        return new ConnectionEvent(serverVersion, banner, tip.height, tip.getBlockHeader(), blockTargetFeeRates, minimumRelayFeeRate);
+                        return new ConnectionEvent(serverVersion, banner, tip.height, tip.getBlockHeader(), blockTargetFeeRates, mempoolRateSizes, minimumRelayFeeRate);
                     } else {
                         if(reader.isAlive()) {
                             electrumServer.ping();
@@ -763,8 +802,9 @@ public class ElectrumServer {
                             long elapsed = System.currentTimeMillis() - feeRatesRetrievedAt;
                             if(elapsed > FEE_RATES_PERIOD) {
                                 Map<Integer, Double> blockTargetFeeRates = electrumServer.getFeeEstimates(SendController.TARGET_BLOCKS_RANGE);
+                                Set<MempoolRateSize> mempoolRateSizes = electrumServer.getMempoolRateSizes();
                                 feeRatesRetrievedAt = System.currentTimeMillis();
-                                return new FeeRatesUpdatedEvent(blockTargetFeeRates);
+                                return new FeeRatesUpdatedEvent(blockTargetFeeRates, mempoolRateSizes);
                             }
                         } else {
                             resetConnection();
@@ -934,8 +974,8 @@ public class ElectrumServer {
 
                     Map<Sha256Hash, BlockTransaction> transactionMap = new HashMap<>();
                     if(!setReferences.isEmpty()) {
-                        Map<Integer, BlockHeader> blockHeaderMap = electrumServer.getBlockHeaders(setReferences);
-                        transactionMap = electrumServer.getTransactions(setReferences, blockHeaderMap);
+                        Map<Integer, BlockHeader> blockHeaderMap = electrumServer.getBlockHeaders(null, setReferences);
+                        transactionMap = electrumServer.getTransactions(null, setReferences, blockHeaderMap);
                     }
 
                     for(int i = 0; i < outputTransactionReferences.size(); i++) {
@@ -990,4 +1030,18 @@ public class ElectrumServer {
             };
         }
     }
+
+    public static class FeeRatesService extends Service<FeeRatesUpdatedEvent> {
+        @Override
+        protected Task<FeeRatesUpdatedEvent> createTask() {
+            return new Task<>() {
+                protected FeeRatesUpdatedEvent call() throws ServerException {
+                    ElectrumServer electrumServer = new ElectrumServer();
+                    Map<Integer, Double> blockTargetFeeRates = electrumServer.getFeeEstimates(SendController.TARGET_BLOCKS_RANGE);
+                    Set<MempoolRateSize> mempoolRateSizes = electrumServer.getMempoolRateSizes();
+                    return new FeeRatesUpdatedEvent(blockTargetFeeRates, mempoolRateSizes);
+                }
+            };
+        }
+    }
 }

src/main/java/com/sparrowwallet/sparrow/net/ElectrumServerRpc.java

@@ -1,6 +1,7 @@
 package com.sparrowwallet.sparrow.net;
 
 import com.github.arteam.simplejsonrpc.client.Transport;
+import com.sparrowwallet.drongo.wallet.Wallet;
 
 import java.util.List;
 import java.util.Map;
@@ -15,20 +16,22 @@ public interface ElectrumServerRpc {
 
     BlockHeaderTip subscribeBlockHeaders(Transport transport);
 
-    Map<String, ScriptHashTx[]> getScriptHashHistory(Transport transport, Map<String, String> pathScriptHashes, boolean failOnError);
+    Map<String, ScriptHashTx[]> getScriptHashHistory(Transport transport, Wallet wallet, Map<String, String> pathScriptHashes, boolean failOnError);
 
-    Map<String, ScriptHashTx[]> getScriptHashMempool(Transport transport, Map<String, String> pathScriptHashes, boolean failOnError);
+    Map<String, ScriptHashTx[]> getScriptHashMempool(Transport transport, Wallet wallet, Map<String, String> pathScriptHashes, boolean failOnError);
 
-    Map<String, String> subscribeScriptHashes(Transport transport, Map<String, String> pathScriptHashes);
+    Map<String, String> subscribeScriptHashes(Transport transport, Wallet wallet, Map<String, String> pathScriptHashes);
 
-    Map<Integer, String> getBlockHeaders(Transport transport, Set<Integer> blockHeights);
+    Map<Integer, String> getBlockHeaders(Transport transport, Wallet wallet, Set<Integer> blockHeights);
 
-    Map<String, String> getTransactions(Transport transport, Set<String> txids);
+    Map<String, String> getTransactions(Transport transport, Wallet wallet, Set<String> txids);
 
     Map<String, VerboseTransaction> getVerboseTransactions(Transport transport, Set<String> txids, String scriptHash);
 
     Map<Integer, Double> getFeeEstimates(Transport transport, List<Integer> targetBlocks);
 
+    Map<Long, Long> getFeeRateHistogram(Transport transport);
+
     Double getMinimumRelayFee(Transport transport);
 
     String broadcastTransaction(Transport transport, String txHex);

src/main/java/com/sparrowwallet/sparrow/net/ExchangeSource.java

@@ -1,7 +1,9 @@
-package com.sparrowwallet.sparrow.io;
+package com.sparrowwallet.sparrow.net;
 
+import com.google.common.net.HostAndPort;
 import com.google.gson.Gson;
 import com.sparrowwallet.sparrow.event.ExchangeRatesUpdatedEvent;
+import com.sparrowwallet.sparrow.io.Config;
 import javafx.concurrent.ScheduledService;
 import javafx.concurrent.Service;
 import javafx.concurrent.Task;
@@ -11,6 +13,8 @@ import org.slf4j.LoggerFactory;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.Reader;
+import java.net.InetSocketAddress;
+import java.net.Proxy;
 import java.net.URL;
 import java.nio.charset.StandardCharsets;
 import java.util.*;
@@ -48,8 +52,9 @@ public enum ExchangeSource {
 
         private CoinbaseRates getRates() {
             String url = "https://api.coinbase.com/v2/exchange-rates?currency=BTC";
+            Proxy proxy = getProxy();
 
-            try(InputStream is = new URL(url).openStream(); Reader reader = new InputStreamReader(is, StandardCharsets.UTF_8)) {
+            try(InputStream is = (proxy == null ? new URL(url).openStream() : new URL(url).openConnection(proxy).getInputStream()); Reader reader = new InputStreamReader(is, StandardCharsets.UTF_8)) {
                 Gson gson = new Gson();
                 return gson.fromJson(reader, CoinbaseRates.class);
             } catch (Exception e) {
@@ -78,8 +83,9 @@ public enum ExchangeSource {
 
         private CoinGeckoRates getRates() {
             String url = "https://api.coingecko.com/api/v3/exchange_rates";
+            Proxy proxy = getProxy();
 
-            try(InputStream is = new URL(url).openStream(); Reader reader = new InputStreamReader(is, StandardCharsets.UTF_8)) {
+            try(InputStream is = (proxy == null ? new URL(url).openStream() : new URL(url).openConnection(proxy).getInputStream()); Reader reader = new InputStreamReader(is, StandardCharsets.UTF_8)) {
                 Gson gson = new Gson();
                 return gson.fromJson(reader, CoinGeckoRates.class);
             } catch (Exception e) {
@@ -110,6 +116,17 @@ public enum ExchangeSource {
         }
     }
 
+    private static Proxy getProxy() {
+        Config config = Config.get();
+        if(config.isUseProxy()) {
+            HostAndPort proxy = HostAndPort.fromString(config.getProxyServer());
+            InetSocketAddress proxyAddress = new InetSocketAddress(proxy.getHost(), proxy.getPortOrDefault(ProxyTcpOverTlsTransport.DEFAULT_PROXY_PORT));
+            return new Proxy(Proxy.Type.SOCKS, proxyAddress);
+        }
+
+        return null;
+    }
+
     @Override
     public String toString() {
         return name;

src/main/java/com/sparrowwallet/sparrow/net/FeeRatesSource.java

@@ -0,0 +1,102 @@
+package com.sparrowwallet.sparrow.net;
+
+import com.google.common.net.HostAndPort;
+import com.google.gson.Gson;
+import com.sparrowwallet.sparrow.io.Config;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.Reader;
+import java.net.InetSocketAddress;
+import java.net.Proxy;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+public enum FeeRatesSource {
+    ELECTRUM_SERVER("Electrum Server") {
+        @Override
+        public Map<Integer, Double> getBlockTargetFeeRates(Map<Integer, Double> defaultblockTargetFeeRates) {
+            return Collections.emptyMap();
+        }
+    },
+    MEMPOOL_SPACE("mempool.space") {
+        @Override
+        public Map<Integer, Double> getBlockTargetFeeRates(Map<Integer, Double> defaultblockTargetFeeRates) {
+            String url = "https://mempool.space/api/v1/fees/recommended";
+            return getThreeTierFeeRates(defaultblockTargetFeeRates, url);
+        }
+    },
+    BITCOINFEES_EARN_COM("bitcoinfees.earn.com") {
+        @Override
+        public Map<Integer, Double> getBlockTargetFeeRates(Map<Integer, Double> defaultblockTargetFeeRates) {
+            String url = "https://bitcoinfees.earn.com/api/v1/fees/recommended";
+            return getThreeTierFeeRates(defaultblockTargetFeeRates, url);
+        }
+    };
+
+    private static final Logger log = LoggerFactory.getLogger(FeeRatesSource.class);
+
+    private final String name;
+
+    FeeRatesSource(String name) {
+        this.name = name;
+    }
+
+    public abstract Map<Integer, Double> getBlockTargetFeeRates(Map<Integer, Double> defaultblockTargetFeeRates);
+
+    public String getName() {
+        return name;
+    }
+
+    private static Map<Integer, Double> getThreeTierFeeRates(Map<Integer, Double> defaultblockTargetFeeRates, String url) {
+        Proxy proxy = getProxy();
+
+        Map<Integer, Double> blockTargetFeeRates = new LinkedHashMap<>();
+        try(InputStream is = (proxy == null ? new URL(url).openStream() : new URL(url).openConnection(proxy).getInputStream()); Reader reader = new InputStreamReader(is, StandardCharsets.UTF_8)) {
+            Gson gson = new Gson();
+            ThreeTierRates threeTierRates = gson.fromJson(reader, ThreeTierRates.class);
+            for(Integer blockTarget : defaultblockTargetFeeRates.keySet()) {
+                if(blockTarget < 3) {
+                    blockTargetFeeRates.put(blockTarget, threeTierRates.fastestFee);
+                } else if(blockTarget < 6) {
+                    blockTargetFeeRates.put(blockTarget, threeTierRates.halfHourFee);
+                } else if(blockTarget <= 10 || defaultblockTargetFeeRates.get(blockTarget) > threeTierRates.hourFee) {
+                    blockTargetFeeRates.put(blockTarget, threeTierRates.hourFee);
+                } else {
+                    blockTargetFeeRates.put(blockTarget, defaultblockTargetFeeRates.get(blockTarget));
+                }
+            }
+        } catch (Exception e) {
+            log.warn("Error retrieving recommended fee rates from " + url, e);
+        }
+
+        return blockTargetFeeRates;
+    }
+
+    private static Proxy getProxy() {
+        Config config = Config.get();
+        if(config.isUseProxy()) {
+            HostAndPort proxy = HostAndPort.fromString(config.getProxyServer());
+            InetSocketAddress proxyAddress = new InetSocketAddress(proxy.getHost(), proxy.getPortOrDefault(ProxyTcpOverTlsTransport.DEFAULT_PROXY_PORT));
+            return new Proxy(Proxy.Type.SOCKS, proxyAddress);
+        }
+
+        return null;
+    }
+
+    @Override
+    public String toString() {
+        return name;
+    }
+
+    private static class ThreeTierRates {
+        Double fastestFee;
+        Double halfHourFee;
+        Double hourFee;
+    }
+}

src/main/java/com/sparrowwallet/sparrow/net/MempoolRateSize.java

@@ -0,0 +1,51 @@
+package com.sparrowwallet.sparrow.net;
+
+import java.util.Objects;
+
+public class MempoolRateSize implements Comparable<MempoolRateSize> {
+    private final long fee;
+    private final long vSize;
+
+    public MempoolRateSize(long fee, long vSize) {
+        this.fee = fee;
+        this.vSize = vSize;
+    }
+
+    public long getFee() {
+        return fee;
+    }
+
+    public long getVSize() {
+        return vSize;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if(this == o) {
+            return true;
+        }
+        if(o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        MempoolRateSize that = (MempoolRateSize) o;
+        return fee == that.fee;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(fee);
+    }
+
+    @Override
+    public int compareTo(MempoolRateSize other) {
+        return Long.compare(fee, other.fee);
+    }
+
+    @Override
+    public String toString() {
+        return "MempoolRateSize{" +
+                "fee=" + fee +
+                ", vSize=" + vSize +
+                '}';
+    }
+}

src/main/java/com/sparrowwallet/sparrow/net/SimpleElectrumServerRpc.java

@@ -6,7 +6,8 @@ import com.github.arteam.simplejsonrpc.client.exception.JsonRpcException;
 import com.sparrowwallet.drongo.Utils;
 import com.sparrowwallet.drongo.protocol.Sha256Hash;
 import com.sparrowwallet.drongo.protocol.Transaction;
-import com.sparrowwallet.sparrow.AppController;
+import com.sparrowwallet.drongo.wallet.Wallet;
+import com.sparrowwallet.sparrow.AppServices;
 import com.sparrowwallet.sparrow.EventManager;
 import com.sparrowwallet.sparrow.event.WalletHistoryStatusEvent;
 import org.slf4j.Logger;
@@ -69,12 +70,12 @@ public class SimpleElectrumServerRpc implements ElectrumServerRpc {
     }
 
     @Override
-    public Map<String, ScriptHashTx[]> getScriptHashHistory(Transport transport, Map<String, String> pathScriptHashes, boolean failOnError) {
+    public Map<String, ScriptHashTx[]> getScriptHashHistory(Transport transport, Wallet wallet, Map<String, String> pathScriptHashes, boolean failOnError) {
         JsonRpcClient client = new JsonRpcClient(transport);
 
         Map<String, ScriptHashTx[]> result = new LinkedHashMap<>();
         for(String path : pathScriptHashes.keySet()) {
-            EventManager.get().post(new WalletHistoryStatusEvent(false, "Loading transactions for " + path));
+            EventManager.get().post(new WalletHistoryStatusEvent(wallet, false, "Loading transactions for " + path));
             try {
                 ScriptHashTx[] scriptHashTxes = new RetryLogic<ScriptHashTx[]>(MAX_RETRIES, RETRY_DELAY, List.of(IllegalStateException.class, IllegalArgumentException.class)).getResult(() ->
                         client.createRequest().returnAs(ScriptHashTx[].class).method("blockchain.scripthash.get_history").id(path + "-" + idCounter.incrementAndGet()).params(pathScriptHashes.get(path)).execute());
@@ -92,7 +93,7 @@ public class SimpleElectrumServerRpc implements ElectrumServerRpc {
     }
 
     @Override
-    public Map<String, ScriptHashTx[]> getScriptHashMempool(Transport transport, Map<String, String> pathScriptHashes, boolean failOnError) {
+    public Map<String, ScriptHashTx[]> getScriptHashMempool(Transport transport, Wallet wallet, Map<String, String> pathScriptHashes, boolean failOnError) {
         JsonRpcClient client = new JsonRpcClient(transport);
 
         Map<String, ScriptHashTx[]> result = new LinkedHashMap<>();
@@ -114,12 +115,12 @@ public class SimpleElectrumServerRpc implements ElectrumServerRpc {
     }
 
     @Override
-    public Map<String, String> subscribeScriptHashes(Transport transport, Map<String, String> pathScriptHashes) {
+    public Map<String, String> subscribeScriptHashes(Transport transport, Wallet wallet, Map<String, String> pathScriptHashes) {
         JsonRpcClient client = new JsonRpcClient(transport);
 
         Map<String, String> result = new LinkedHashMap<>();
         for(String path : pathScriptHashes.keySet()) {
-            EventManager.get().post(new WalletHistoryStatusEvent(false, "Finding transactions for " + path));
+            EventManager.get().post(new WalletHistoryStatusEvent(wallet, false, "Finding transactions for " + path));
             try {
                 String scriptHash = new RetryLogic<String>(MAX_RETRIES, RETRY_DELAY, List.of(IllegalStateException.class, IllegalArgumentException.class)).getResult(() ->
                         client.createRequest().returnAs(String.class).method("blockchain.scripthash.subscribe").id(path + "-" + idCounter.incrementAndGet()).params(pathScriptHashes.get(path)).executeNullable());
@@ -134,12 +135,12 @@ public class SimpleElectrumServerRpc implements ElectrumServerRpc {
     }
 
     @Override
-    public Map<Integer, String> getBlockHeaders(Transport transport, Set<Integer> blockHeights) {
+    public Map<Integer, String> getBlockHeaders(Transport transport, Wallet wallet, Set<Integer> blockHeights) {
         JsonRpcClient client = new JsonRpcClient(transport);
 
         Map<Integer, String> result = new LinkedHashMap<>();
         for(Integer blockHeight : blockHeights) {
-            EventManager.get().post(new WalletHistoryStatusEvent(false, "Retrieving block at height " + blockHeight));
+            EventManager.get().post(new WalletHistoryStatusEvent(wallet, false, "Retrieving block at height " + blockHeight));
             try {
                 String blockHeader = new RetryLogic<String>(MAX_RETRIES, RETRY_DELAY, List.of(IllegalStateException.class, IllegalArgumentException.class)).getResult(() ->
                         client.createRequest().returnAs(String.class).method("blockchain.block.header").id(idCounter.incrementAndGet()).params(blockHeight).execute());
@@ -155,12 +156,12 @@ public class SimpleElectrumServerRpc implements ElectrumServerRpc {
     }
 
     @Override
-    public Map<String, String> getTransactions(Transport transport, Set<String> txids) {
+    public Map<String, String> getTransactions(Transport transport, Wallet wallet, Set<String> txids) {
         JsonRpcClient client = new JsonRpcClient(transport);
 
         Map<String, String> result = new LinkedHashMap<>();
         for(String txid : txids) {
-            EventManager.get().post(new WalletHistoryStatusEvent(false, "Retrieving transaction [" + txid.substring(0, 6) + "]"));
+            EventManager.get().post(new WalletHistoryStatusEvent(wallet, false, "Retrieving transaction [" + txid.substring(0, 6) + "]"));
             try {
                 String rawTxHex = new RetryLogic<String>(MAX_RETRIES, RETRY_DELAY, List.of(IllegalStateException.class, IllegalArgumentException.class)).getResult(() ->
                         client.createRequest().returnAs(String.class).method("blockchain.transaction.get").id(idCounter.incrementAndGet()).params(txid).execute());
@@ -208,7 +209,7 @@ public class SimpleElectrumServerRpc implements ElectrumServerRpc {
                     VerboseTransaction verboseTransaction = new VerboseTransaction();
                     verboseTransaction.txid = id;
                     verboseTransaction.hex = rawTxHex;
-                    verboseTransaction.confirmations = (height <= 0 ? 0 : AppController.getCurrentBlockHeight() - height + 1);
+                    verboseTransaction.confirmations = (height <= 0 ? 0 : AppServices.getCurrentBlockHeight() - height + 1);
                     verboseTransaction.blockhash = Sha256Hash.ZERO_HASH.toString();
                     result.put(txid, verboseTransaction);
                 } catch(Exception ex) {
@@ -245,6 +246,24 @@ public class SimpleElectrumServerRpc implements ElectrumServerRpc {
         return result;
     }
 
+    @Override
+    public Map<Long, Long> getFeeRateHistogram(Transport transport) {
+        try {
+            JsonRpcClient client = new JsonRpcClient(transport);
+            Long[][] feesArray = new RetryLogic<Long[][]>(MAX_RETRIES, RETRY_DELAY, IllegalStateException.class).getResult(() ->
+                    client.createRequest().returnAs(Long[][].class).method("mempool.get_fee_histogram").id(idCounter.incrementAndGet()).execute());
+
+            Map<Long, Long> feeRateHistogram = new TreeMap<>();
+            for(Long[] feePair : feesArray) {
+                feeRateHistogram.put(feePair[0], feePair[1]);
+            }
+
+            return feeRateHistogram;
+        } catch(Exception e) {
+            throw new ElectrumServerRpcException("Error getting fee rate histogram", e);
+        }
+    }
+
     @Override
     public Double getMinimumRelayFee(Transport transport) {
         try {

src/main/java/com/sparrowwallet/sparrow/net/SubscriptionService.java

@@ -1,6 +1,7 @@
 package com.sparrowwallet.sparrow.net;
 
 import com.github.arteam.simplejsonrpc.core.annotation.JsonRpcMethod;
+import com.github.arteam.simplejsonrpc.core.annotation.JsonRpcOptional;
 import com.github.arteam.simplejsonrpc.core.annotation.JsonRpcParam;
 import com.github.arteam.simplejsonrpc.core.annotation.JsonRpcService;
 import com.google.common.collect.Iterables;
@@ -23,7 +24,12 @@ public class SubscriptionService {
     }
 
     @JsonRpcMethod("blockchain.scripthash.subscribe")
-    public void scriptHashStatusUpdated(@JsonRpcParam("scripthash") final String scriptHash, @JsonRpcParam("status") final String status) {
+    public void scriptHashStatusUpdated(@JsonRpcParam("scripthash") final String scriptHash, @JsonRpcOptional @JsonRpcParam("status") final String status) {
+        if(status == null) {
+            //Mempool transaction was replaced returning change/consolidation script hash status to null, ignore this update
+            return;
+        }
+
         Set<String> existingStatuses = ElectrumServer.getSubscribedScriptHashes().get(scriptHash);
         if(existingStatuses == null) {
             log.warn("Received script hash status update for unsubscribed script hash: " + scriptHash);

src/main/java/com/sparrowwallet/sparrow/net/TcpTransport.java

@@ -133,7 +133,7 @@ public class TcpTransport implements Transport, Closeable {
             while(running) {
                 try {
                     String received = readInputStream();
-                    if(received.contains("method")) {
+                    if(received.contains("method") && !received.contains("error")) {
                         //Handle subscription notification
                         jsonRpcServer.handle(received, subscriptionService);
                     } else {

src/main/java/com/sparrowwallet/sparrow/net/VerboseTransaction.java

@@ -5,7 +5,7 @@ import com.sparrowwallet.drongo.Utils;
 import com.sparrowwallet.drongo.protocol.Sha256Hash;
 import com.sparrowwallet.drongo.protocol.Transaction;
 import com.sparrowwallet.drongo.wallet.BlockTransaction;
-import com.sparrowwallet.sparrow.AppController;
+import com.sparrowwallet.sparrow.AppServices;
 
 import java.util.Date;
 
@@ -26,7 +26,7 @@ class VerboseTransaction {
             return 0;
         }
 
-        Integer currentHeight = AppController.getCurrentBlockHeight();
+        Integer currentHeight = AppServices.getCurrentBlockHeight();
         if(currentHeight != null) {
             return currentHeight - confirmations + 1;
         }

src/main/java/com/sparrowwallet/sparrow/payjoin/Payjoin.java

@@ -0,0 +1,321 @@
+package com.sparrowwallet.sparrow.payjoin;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.gson.Gson;
+import com.sparrowwallet.drongo.KeyPurpose;
+import com.sparrowwallet.drongo.protocol.Script;
+import com.sparrowwallet.drongo.protocol.Transaction;
+import com.sparrowwallet.drongo.protocol.TransactionInput;
+import com.sparrowwallet.drongo.protocol.TransactionOutput;
+import com.sparrowwallet.drongo.psbt.PSBT;
+import com.sparrowwallet.drongo.psbt.PSBTInput;
+import com.sparrowwallet.drongo.psbt.PSBTOutput;
+import com.sparrowwallet.drongo.psbt.PSBTParseException;
+import com.sparrowwallet.drongo.uri.BitcoinURI;
+import com.sparrowwallet.drongo.wallet.Wallet;
+import com.sparrowwallet.drongo.wallet.WalletNode;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.*;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.util.*;
+
+public class Payjoin {
+    private static final Logger log = LoggerFactory.getLogger(Payjoin.class);
+
+    private final BitcoinURI payjoinURI;
+    private final Wallet wallet;
+    private final PSBT psbt;
+
+    public Payjoin(BitcoinURI payjoinURI, Wallet wallet, PSBT psbt) {
+        this.payjoinURI = payjoinURI;
+        this.wallet = wallet;
+        this.psbt = psbt;
+
+        for(PSBTInput psbtInput : psbt.getPsbtInputs()) {
+            if(psbtInput.getUtxo() == null) {
+                throw new IllegalArgumentException("Original PSBT for payjoin transaction must have non_witness_utxo or witness_utxo fields for all inputs");
+            }
+        }
+
+        if(!psbt.isFinalized()) {
+            throw new IllegalArgumentException("Original PSBT for payjoin transaction must be finalized");
+        }
+    }
+
+    public PSBT requestPayjoinPSBT(boolean allowOutputSubstitution) throws PayjoinReceiverException {
+        if(!payjoinURI.isPayjoinOutputSubstitutionAllowed()) {
+            allowOutputSubstitution = false;
+        }
+
+        URI uri = payjoinURI.getPayjoinUrl();
+        if(uri == null) {
+            log.error("No payjoin URL provided");
+            throw new PayjoinReceiverException("No payjoin URL provided");
+        }
+
+        try {
+            String base64Psbt = psbt.getPublicCopy().toBase64String();
+
+            String appendQuery = "v=1";
+            int changeOutputIndex = getChangeOutputIndex();
+            long maxAdditionalFeeContribution = 0;
+            if(changeOutputIndex > -1) {
+                appendQuery += "&additionalfeeoutputindex=" + changeOutputIndex;
+                maxAdditionalFeeContribution = getAdditionalFeeContribution();
+                appendQuery += "&maxadditionalfeecontribution=" + maxAdditionalFeeContribution;
+            }
+
+            URI finalUri = new URI(uri.getScheme(), uri.getAuthority(), uri.getPath(), uri.getQuery() == null ? appendQuery : uri.getQuery() + "&" + appendQuery, uri.getFragment());
+            log.info("Sending PSBT to " + finalUri.toURL());
+
+            HttpClient client = HttpClient.newHttpClient();
+            HttpRequest request = HttpRequest.newBuilder()
+                    .uri(finalUri)
+                    .header("Content-Type", "text/plain")
+                    .POST(HttpRequest.BodyPublishers.ofString(base64Psbt))
+                    .build();
+
+            HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
+
+            if(response.statusCode() != 200) {
+                Gson gson = new Gson();
+                PayjoinReceiverError payjoinReceiverError = gson.fromJson(response.body(), PayjoinReceiverError.class);
+                log.warn("Payjoin receiver returned an error of " + payjoinReceiverError.getErrorCode() + " (" + payjoinReceiverError.getMessage() + ")");
+                throw new PayjoinReceiverException(payjoinReceiverError.getSafeMessage());
+            }
+
+            PSBT proposalPsbt = PSBT.fromString(response.body());
+            checkProposal(psbt, proposalPsbt, changeOutputIndex, maxAdditionalFeeContribution, allowOutputSubstitution);
+
+            return proposalPsbt;
+        } catch(URISyntaxException e) {
+            log.error("Invalid payjoin receiver URI", e);
+            throw new PayjoinReceiverException("Invalid payjoin receiver URI", e);
+        } catch(IOException | InterruptedException e) {
+            log.error("Payjoin receiver error", e);
+            throw new PayjoinReceiverException("Payjoin receiver error", e);
+        } catch(PSBTParseException e) {
+            log.error("Error parsing received PSBT", e);
+            throw new PayjoinReceiverException("Payjoin receiver returned invalid PSBT", e);
+        }
+    }
+
+    private void checkProposal(PSBT original, PSBT proposal, int changeOutputIndex, long maxAdditionalFeeContribution, boolean allowOutputSubstitution) throws PayjoinReceiverException {
+        Queue<Map.Entry<TransactionInput, PSBTInput>> originalInputs = new ArrayDeque<>();
+        for(int i = 0; i < original.getPsbtInputs().size(); i++) {
+            originalInputs.add(Map.entry(original.getTransaction().getInputs().get(i), original.getPsbtInputs().get(i)));
+        }
+
+        Queue<Map.Entry<TransactionOutput, PSBTOutput>> originalOutputs = new ArrayDeque<>();
+        for(int i = 0; i < original.getPsbtOutputs().size(); i++) {
+            originalOutputs.add(Map.entry(original.getTransaction().getOutputs().get(i), original.getPsbtOutputs().get(i)));
+        }
+
+        // Checking that the PSBT of the receiver is clean
+        if(!proposal.getExtendedPublicKeys().isEmpty()) {
+            throw new PayjoinReceiverException("Global xpubs should not be included in the receiver's PSBT");
+        }
+
+        Transaction originalTx = original.getTransaction();
+        Transaction proposalTx = proposal.getTransaction();
+        // Verify that the transaction version, and nLockTime are unchanged.
+        if(proposalTx.getVersion() != originalTx.getVersion()) {
+            throw new PayjoinReceiverException("The proposal PSBT changed the transaction version");
+        }
+        if(proposalTx.getLocktime() != originalTx.getLocktime()) {
+            throw new PayjoinReceiverException("The proposal PSBT changed the nLocktime");
+        }
+
+        Set<Long> sequences = new HashSet<>();
+        // For each inputs in the proposal:
+        for(PSBTInput proposedPSBTInput : proposal.getPsbtInputs()) {
+            if(!proposedPSBTInput.getDerivedPublicKeys().isEmpty()) {
+                throw new PayjoinReceiverException("The receiver added keypaths to an input");
+            }
+            if(!proposedPSBTInput.getPartialSignatures().isEmpty()) {
+                throw new PayjoinReceiverException("The receiver added partial signatures to an input");
+            }
+
+            TransactionInput proposedTxIn = proposedPSBTInput.getInput();
+            boolean isOriginalInput = originalInputs.size() > 0 && originalInputs.peek().getKey().getOutpoint().equals(proposedTxIn.getOutpoint());
+            if(isOriginalInput) {
+                Map.Entry<TransactionInput, PSBTInput> originalInput = originalInputs.remove();
+                TransactionInput originalTxIn = originalInput.getKey();
+
+                // Verify that sequence is unchanged.
+                if(originalTxIn.getSequenceNumber() != proposedTxIn.getSequenceNumber()) {
+                    throw new PayjoinReceiverException("The proposed transaction input modified the sequence of one of the original inputs");
+                }
+                // Verify the PSBT input is not finalized
+                if(proposedPSBTInput.isFinalized()) {
+                    throw new PayjoinReceiverException("The receiver finalized one of the original inputs");
+                }
+                // Verify that non_witness_utxo and witness_utxo are not specified.
+                if(proposedPSBTInput.getNonWitnessUtxo() != null || proposedPSBTInput.getWitnessUtxo() != null) {
+                    throw new PayjoinReceiverException("The receiver added non_witness_utxo or witness_utxo to one of the original inputs");
+                }
+                sequences.add(proposedTxIn.getSequenceNumber());
+
+                PSBTInput originalPSBTInput = originalInput.getValue();
+                // Fill up the info from the original PSBT input so we can sign and get fees.
+                proposedPSBTInput.setNonWitnessUtxo(originalPSBTInput.getNonWitnessUtxo());
+                proposedPSBTInput.setWitnessUtxo(originalPSBTInput.getWitnessUtxo());
+                // We fill up information we had on the signed PSBT, so we can sign it.
+                proposedPSBTInput.getDerivedPublicKeys().putAll(originalPSBTInput.getDerivedPublicKeys());
+                proposedPSBTInput.getProprietary().putAll(originalPSBTInput.getProprietary());
+                proposedPSBTInput.setRedeemScript(originalPSBTInput.getFinalScriptSig().getFirstNestedScript());
+                proposedPSBTInput.setWitnessScript(originalPSBTInput.getFinalScriptWitness().getWitnessScript());
+                proposedPSBTInput.setSigHash(originalPSBTInput.getSigHash());
+            } else {
+                // Verify the PSBT input is finalized
+                if(!proposedPSBTInput.isFinalized()) {
+                    throw new PayjoinReceiverException("The receiver did not finalize one of their inputs");
+                }
+                // Verify that non_witness_utxo or witness_utxo are filled in.
+                if(proposedPSBTInput.getNonWitnessUtxo() == null && proposedPSBTInput.getWitnessUtxo() == null) {
+                    throw new PayjoinReceiverException("The receiver did not specify non_witness_utxo or witness_utxo for one of their inputs");
+                }
+                sequences.add(proposedTxIn.getSequenceNumber());
+                // Verify that the payjoin proposal did not introduced mixed inputs' type.
+                if(wallet.getScriptType() != proposedPSBTInput.getScriptType()) {
+                    throw new PayjoinReceiverException("Proposal script type of " + proposedPSBTInput.getScriptType() + " did not match wallet script type of " + wallet.getScriptType());
+                }
+            }
+        }
+
+        // Verify that all of sender's inputs from the original PSBT are in the proposal.
+        if(!originalInputs.isEmpty()) {
+            throw new PayjoinReceiverException("Some of the original inputs are not included in the proposal");
+        }
+
+        // Verify that the payjoin proposal did not introduced mixed inputs' sequence.
+        if(sequences.size() != 1) {
+            throw new PayjoinReceiverException("Mixed sequences detected in the proposal");
+        }
+
+        Long newFee = proposal.getFee();
+        long additionalFee = newFee - original.getFee();
+        if(additionalFee < 0) {
+            throw new PayjoinReceiverException("The receiver decreased absolute fee");
+        }
+
+        TransactionOutput changeOutput = (changeOutputIndex > -1 ? originalTx.getOutputs().get(changeOutputIndex) : null);
+
+        // For each outputs in the proposal:
+        for(int i = 0; i < proposal.getPsbtOutputs().size(); i++) {
+            PSBTOutput proposedPSBTOutput = proposal.getPsbtOutputs().get(i);
+            // Verify that no keypaths is in the PSBT output
+            if(!proposedPSBTOutput.getDerivedPublicKeys().isEmpty()) {
+                throw new PayjoinReceiverException("The receiver added keypaths to an output");
+            }
+
+            TransactionOutput proposedTxOut = proposalTx.getOutputs().get(i);
+            boolean isOriginalOutput = originalOutputs.size() > 0 && originalOutputs.peek().getKey().getScript().equals(proposedTxOut.getScript());
+            if(isOriginalOutput) {
+                Map.Entry<TransactionOutput, PSBTOutput> originalOutput = originalOutputs.remove();
+                if(originalOutput.getKey() == changeOutput) {
+                    var actualContribution = changeOutput.getValue() - proposedTxOut.getValue();
+                    // The amount that was subtracted from the output's value is less than or equal to maxadditionalfeecontribution
+                    if(actualContribution > maxAdditionalFeeContribution) {
+                        throw new PayjoinReceiverException("The actual contribution is more than maxadditionalfeecontribution");
+                    }
+                    // Make sure the actual contribution is only paying fee
+                    if(actualContribution > additionalFee) {
+                        throw new PayjoinReceiverException("The actual contribution is not only paying fee");
+                    }
+                    // Make sure the actual contribution is only paying for fee incurred by additional inputs
+                    int additionalInputsCount = proposalTx.getInputs().size() - originalTx.getInputs().size();
+                    if(actualContribution > getSingleInputFee() * additionalInputsCount) {
+                        throw new PayjoinReceiverException("The actual contribution is not only paying for additional inputs");
+                    }
+                } else if(allowOutputSubstitution && originalOutput.getKey().getScript().equals(payjoinURI.getAddress().getOutputScript())) {
+                    // That's the payment output, the receiver may have changed it.
+                } else {
+                    if(originalOutput.getKey().getValue() > proposedTxOut.getValue()) {
+                        throw new PayjoinReceiverException("The receiver decreased the value of one of the outputs");
+                    }
+                }
+
+                PSBTOutput originalPSBTOutput = originalOutput.getValue();
+                // We fill up information we had on the signed PSBT, so we can sign it.
+                proposedPSBTOutput.getDerivedPublicKeys().putAll(originalPSBTOutput.getDerivedPublicKeys());
+                proposedPSBTOutput.getProprietary().putAll(originalPSBTOutput.getProprietary());
+                proposedPSBTOutput.setRedeemScript(originalPSBTOutput.getRedeemScript());
+                proposedPSBTOutput.setWitnessScript(originalPSBTOutput.getWitnessScript());
+            }
+        }
+
+        // Verify that all of sender's outputs from the original PSBT are in the proposal.
+        if(!originalOutputs.isEmpty()) {
+            // The payment output may have been substituted
+            if(!allowOutputSubstitution || originalOutputs.size() != 1 || !originalOutputs.remove().getKey().getScript().equals(payjoinURI.getAddress().getOutputScript())) {
+                throw new PayjoinReceiverException("Some of our outputs are not included in the proposal");
+            }
+        }
+
+        //Add global pubkey map for signing
+        proposal.getExtendedPublicKeys().putAll(psbt.getExtendedPublicKeys());
+        proposal.getGlobalProprietary().putAll(psbt.getGlobalProprietary());
+    }
+
+    private int getChangeOutputIndex() {
+        Map<Script, WalletNode> changeScriptNodes = wallet.getWalletOutputScripts(KeyPurpose.CHANGE);
+        for(int i = 0; i < psbt.getTransaction().getOutputs().size(); i++) {
+            if(changeScriptNodes.containsKey(psbt.getTransaction().getOutputs().get(i).getScript())) {
+                return i;
+            }
+        }
+
+        return -1;
+    }
+
+    private long getAdditionalFeeContribution() {
+        return getSingleInputFee();
+    }
+
+    private long getSingleInputFee() {
+        Transaction transaction = psbt.extractTransaction();
+        double feeRate = psbt.getFee().doubleValue() / transaction.getVirtualSize();
+        int vSize = 68;
+
+        if(transaction.getInputs().size() > 0) {
+            TransactionInput input = transaction.getInputs().get(0);
+            vSize = input.getLength() * Transaction.WITNESS_SCALE_FACTOR;
+            vSize += input.getWitness() != null ? input.getWitness().getLength() : 0;
+            vSize = (int)Math.ceil((double)vSize / Transaction.WITNESS_SCALE_FACTOR);
+        }
+
+        return (long) (vSize * feeRate);
+    }
+
+    private static class PayjoinReceiverError {
+        Map<String, String> knownErrors = ImmutableMap.of(
+                "unavailable", "The payjoin endpoint is not available for now.",
+                "not-enough-money", "The receiver added some inputs but could not bump the fee of the payjoin proposal.",
+                "version-unsupported", "This version of payjoin is not supported.",
+                "original-psbt-rejected", "The receiver rejected the original PSBT."
+        );
+
+        public String errorCode;
+        public String message;
+
+        public String getErrorCode() {
+            return errorCode;
+        }
+
+        public String getMessage() {
+            return message;
+        }
+
+        public String getSafeMessage() {
+            String message = knownErrors.get(errorCode);
+            return (message == null ? "Unknown Error" : message);
+        }
+    }
+}

src/main/java/com/sparrowwallet/sparrow/payjoin/PayjoinReceiverException.java

@@ -0,0 +1,19 @@
+package com.sparrowwallet.sparrow.payjoin;
+
+public class PayjoinReceiverException extends Exception {
+    public PayjoinReceiverException() {
+        super();
+    }
+
+    public PayjoinReceiverException(String msg) {
+        super(msg);
+    }
+
+    public PayjoinReceiverException(Throwable cause) {
+        super(cause);
+    }
+
+    public PayjoinReceiverException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}

src/main/java/com/sparrowwallet/sparrow/preferences/GeneralPreferencesController.java

@@ -3,11 +3,10 @@ package com.sparrowwallet.sparrow.preferences;
 import com.sparrowwallet.drongo.BitcoinUnit;
 import com.sparrowwallet.sparrow.EventManager;
 import com.sparrowwallet.sparrow.control.UnlabeledToggleSwitch;
-import com.sparrowwallet.sparrow.event.BitcoinUnitChangedEvent;
-import com.sparrowwallet.sparrow.event.FiatCurrencySelectedEvent;
-import com.sparrowwallet.sparrow.event.VersionCheckStatusEvent;
+import com.sparrowwallet.sparrow.event.*;
 import com.sparrowwallet.sparrow.io.Config;
-import com.sparrowwallet.sparrow.io.ExchangeSource;
+import com.sparrowwallet.sparrow.net.ExchangeSource;
+import com.sparrowwallet.sparrow.net.FeeRatesSource;
 import javafx.beans.value.ChangeListener;
 import javafx.beans.value.ObservableValue;
 import javafx.fxml.FXML;
@@ -24,6 +23,9 @@ public class GeneralPreferencesController extends PreferencesDetailController {
     @FXML
     private ComboBox<BitcoinUnit> bitcoinUnit;
 
+    @FXML
+    private ComboBox<FeeRatesSource> feeRatesSource;
+
     @FXML
     private ComboBox<Currency> fiatCurrency;
 
@@ -63,6 +65,18 @@ public class GeneralPreferencesController extends PreferencesDetailController {
             EventManager.get().post(new BitcoinUnitChangedEvent(newValue));
         });
 
+        if(config.getFeeRatesSource() != null) {
+            feeRatesSource.setValue(config.getFeeRatesSource());
+        } else {
+            feeRatesSource.getSelectionModel().select(1);
+            config.setFeeRatesSource(feeRatesSource.getValue());
+        }
+
+        feeRatesSource.valueProperty().addListener((observable, oldValue, newValue) -> {
+            config.setFeeRatesSource(newValue);
+            EventManager.get().post(new FeeRatesSourceChangedEvent(newValue));
+        });
+
         if(config.getExchangeSource() != null) {
             exchangeSource.setValue(config.getExchangeSource());
         } else {

src/main/java/com/sparrowwallet/sparrow/preferences/PreferencesController.java

@@ -1,10 +1,7 @@
 package com.sparrowwallet.sparrow.preferences;
 
-import com.sparrowwallet.drongo.wallet.KeystoreSource;
-import com.sparrowwallet.drongo.wallet.Wallet;
-import com.sparrowwallet.sparrow.AppController;
+import com.sparrowwallet.sparrow.AppServices;
 import com.sparrowwallet.sparrow.io.Config;
-import com.sparrowwallet.sparrow.keystoreimport.KeystoreImportDetailController;
 import javafx.application.Platform;
 import javafx.fxml.FXML;
 import javafx.fxml.FXMLLoader;
@@ -63,7 +60,7 @@ public class PreferencesController implements Initializable {
         preferencesPane.getChildren().removeAll(preferencesPane.getChildren());
 
         try {
-            FXMLLoader preferencesDetailLoader = new FXMLLoader(AppController.class.getResource("preferences/" + fxmlName + ".fxml"));
+            FXMLLoader preferencesDetailLoader = new FXMLLoader(AppServices.class.getResource("preferences/" + fxmlName + ".fxml"));
             Node preferenceGroupNode = preferencesDetailLoader.load();
             PreferencesDetailController controller = preferencesDetailLoader.getController();
             controller.setMasterController(this);

src/main/java/com/sparrowwallet/sparrow/preferences/PreferencesDialog.java

@@ -1,6 +1,6 @@
 package com.sparrowwallet.sparrow.preferences;
 
-import com.sparrowwallet.sparrow.AppController;
+import com.sparrowwallet.sparrow.AppServices;
 import com.sparrowwallet.sparrow.EventManager;
 import com.sparrowwallet.sparrow.event.RequestConnectEvent;
 import com.sparrowwallet.sparrow.io.Config;
@@ -27,10 +27,10 @@ public class PreferencesDialog extends Dialog<Boolean> {
 
     public PreferencesDialog(PreferenceGroup initialGroup, boolean initialSetup) {
         final DialogPane dialogPane = getDialogPane();
-        AppController.setStageIcon(dialogPane.getScene().getWindow());
+        AppServices.setStageIcon(dialogPane.getScene().getWindow());
 
         try {
-            FXMLLoader preferencesLoader = new FXMLLoader(AppController.class.getResource("preferences/preferences.fxml"));
+            FXMLLoader preferencesLoader = new FXMLLoader(AppServices.class.getResource("preferences/preferences.fxml"));
             dialogPane.setContent(Borders.wrap(preferencesLoader.load()).emptyBorder().buildAll());
             PreferencesController preferencesController = preferencesLoader.getController();
             preferencesController.initializeView(Config.get());
@@ -49,7 +49,7 @@ public class PreferencesDialog extends Dialog<Boolean> {
             }
 
             dialogPane.setPrefWidth(650);
-            dialogPane.setPrefHeight(500);
+            dialogPane.setPrefHeight(550);
 
             existingConnection = ElectrumServer.isConnected();
             setOnCloseRequest(event -> {

src/main/java/com/sparrowwallet/sparrow/preferences/ServerPreferencesController.java

@@ -109,7 +109,7 @@ public class ServerPreferencesController extends PreferencesDetailController {
             FileChooser fileChooser = new FileChooser();
             fileChooser.setTitle("Select Electrum Server certificate");
             fileChooser.getExtensionFilters().addAll(
-                    new FileChooser.ExtensionFilter("All Files", "*"),
+                    new FileChooser.ExtensionFilter("All Files", org.controlsfx.tools.Platform.getCurrent().equals(org.controlsfx.tools.Platform.UNIX) ? "*" : "*.*"),
                     new FileChooser.ExtensionFilter("CRT", "*.crt")
             );
 
@@ -296,6 +296,10 @@ public class ServerPreferencesController extends PreferencesDetailController {
     @NotNull
     private ChangeListener<String> getProxyListener(Config config) {
         return (observable, oldValue, newValue) -> {
+            if(oldValue.trim().equals(newValue.trim())) {
+                return;
+            }
+
             String hostAsString = getHost(proxyHost.getText());
             Integer portAsInteger = getPort(proxyPort.getText());
             if(hostAsString != null && portAsInteger != null && isValidPort(portAsInteger)) {

src/main/java/com/sparrowwallet/sparrow/transaction/HeadersController.java

@@ -3,12 +3,15 @@ package com.sparrowwallet.sparrow.transaction;
 import com.sparrowwallet.drongo.KeyPurpose;
 import com.sparrowwallet.drongo.SecureString;
 import com.sparrowwallet.drongo.Utils;
+import com.sparrowwallet.drongo.address.Address;
 import com.sparrowwallet.drongo.protocol.*;
 import com.sparrowwallet.drongo.psbt.PSBT;
 import com.sparrowwallet.drongo.psbt.PSBTInput;
+import com.sparrowwallet.drongo.uri.BitcoinURI;
 import com.sparrowwallet.drongo.wallet.*;
 import com.sparrowwallet.hummingbird.UR;
-import com.sparrowwallet.sparrow.AppController;
+import com.sparrowwallet.hummingbird.registry.RegistryType;
+import com.sparrowwallet.sparrow.AppServices;
 import com.sparrowwallet.sparrow.EventManager;
 import com.sparrowwallet.sparrow.control.*;
 import com.sparrowwallet.sparrow.event.*;
@@ -16,6 +19,8 @@ import com.sparrowwallet.sparrow.glyphfont.FontAwesome5Brands;
 import com.sparrowwallet.sparrow.io.Device;
 import com.sparrowwallet.sparrow.net.ElectrumServer;
 import com.sparrowwallet.sparrow.io.Storage;
+import com.sparrowwallet.sparrow.payjoin.Payjoin;
+import com.sparrowwallet.sparrow.payjoin.PayjoinReceiverException;
 import com.sparrowwallet.sparrow.wallet.HashIndexEntry;
 import com.sparrowwallet.sparrow.wallet.TransactionEntry;
 import javafx.application.Platform;
@@ -40,10 +45,8 @@ import tornadofx.control.Fieldset;
 import com.google.common.eventbus.Subscribe;
 import tornadofx.control.Form;
 
-import java.io.File;
-import java.io.IOException;
-import java.io.PrintWriter;
-import java.net.URL;
+import java.io.*;
+import java.net.*;
 import java.nio.charset.StandardCharsets;
 import java.text.SimpleDateFormat;
 import java.time.*;
@@ -196,6 +199,9 @@ public class HeadersController extends TransactionFormController implements Init
     @FXML
     private Button saveFinalButton;
 
+    @FXML
+    private Button payjoinButton;
+
     @Override
     public void initialize(URL location, ResourceBundle resources) {
         EventManager.get().register(this);
@@ -246,8 +252,8 @@ public class HeadersController extends TransactionFormController implements Init
                     locktimeFieldset.getChildren().add(locktimeBlockField);
                     Integer block = locktimeBlock.getValue();
                     if(block != null) {
-                        locktimeCurrentHeight.setVisible(headersForm.isEditable() && AppController.getCurrentBlockHeight() != null && block < AppController.getCurrentBlockHeight());
-                        futureBlockWarning.setVisible(AppController.getCurrentBlockHeight() != null && block > AppController.getCurrentBlockHeight());
+                        locktimeCurrentHeight.setVisible(headersForm.isEditable() && AppServices.getCurrentBlockHeight() != null && block < AppServices.getCurrentBlockHeight());
+                        futureBlockWarning.setVisible(AppServices.getCurrentBlockHeight() != null && block > AppServices.getCurrentBlockHeight());
                         tx.setLocktime(block);
                         if(old_toggle != null) {
                             EventManager.get().post(new TransactionChangedEvent(tx));
@@ -297,8 +303,8 @@ public class HeadersController extends TransactionFormController implements Init
 
         locktimeBlock.valueProperty().addListener((obs, oldValue, newValue) -> {
             tx.setLocktime(newValue);
-            locktimeCurrentHeight.setVisible(headersForm.isEditable() && AppController.getCurrentBlockHeight() != null && newValue < AppController.getCurrentBlockHeight());
-            futureBlockWarning.setVisible(AppController.getCurrentBlockHeight() != null && newValue > AppController.getCurrentBlockHeight());
+            locktimeCurrentHeight.setVisible(headersForm.isEditable() && AppServices.getCurrentBlockHeight() != null && newValue < AppServices.getCurrentBlockHeight());
+            futureBlockWarning.setVisible(AppServices.getCurrentBlockHeight() != null && newValue > AppServices.getCurrentBlockHeight());
             if(oldValue != null) {
                 EventManager.get().post(new TransactionChangedEvent(tx));
                 EventManager.get().post(new TransactionLocktimeChangedEvent(tx));
@@ -354,7 +360,13 @@ public class HeadersController extends TransactionFormController implements Init
         broadcastButton.managedProperty().bind(broadcastButton.visibleProperty());
         saveFinalButton.managedProperty().bind(saveFinalButton.visibleProperty());
         saveFinalButton.visibleProperty().bind(broadcastButton.visibleProperty().not());
-        broadcastButton.visibleProperty().bind(AppController.onlineProperty());
+        broadcastButton.visibleProperty().bind(AppServices.onlineProperty());
+
+        BitcoinURI payjoinURI = getPayjoinURI();
+        boolean isPayjoinOriginalTx = payjoinURI != null && headersForm.getPsbt() != null && headersForm.getPsbt().getPsbtInputs().stream().noneMatch(PSBTInput::isFinalized);
+        payjoinButton.managedProperty().bind(payjoinButton.visibleProperty());
+        payjoinButton.visibleProperty().set(isPayjoinOriginalTx);
+        broadcastButton.setDefaultButton(!isPayjoinOriginalTx);
 
         blockchainForm.setVisible(false);
         signingWalletForm.setVisible(false);
@@ -365,8 +377,7 @@ public class HeadersController extends TransactionFormController implements Init
         broadcastButtonBox.setVisible(false);
 
         if(headersForm.getBlockTransaction() != null) {
-            blockchainForm.setVisible(true);
-            updateBlockchainForm(headersForm.getBlockTransaction(), AppController.getCurrentBlockHeight());
+            updateBlockchainForm(headersForm.getBlockTransaction(), AppServices.getCurrentBlockHeight());
         } else if(headersForm.getPsbt() != null) {
             PSBT psbt = headersForm.getPsbt();
 
@@ -409,12 +420,20 @@ public class HeadersController extends TransactionFormController implements Init
                 signaturesProgressBar.initialize(headersForm.getSignatureKeystoreMap(), threshold);
             });
 
-            EventManager.get().post(new RequestOpenWalletsEvent());
+            Platform.runLater(this::requestOpenWallets);
         }
 
         blockchainForm.setDynamicUpdate(this);
     }
 
+    private void requestOpenWallets() {
+        if(id.getScene() != null) {
+            EventManager.get().post(new RequestOpenWalletsEvent());
+        } else {
+            Platform.runLater(this::requestOpenWallets);
+        }
+    }
+
     private void updateType() {
         String type = "Legacy";
         if(headersForm.getTransaction().isSegwit() || (headersForm.getPsbt() != null && headersForm.getPsbt().getPsbtInputs().stream().anyMatch(in -> in.getWitnessUtxo() != null))) {
@@ -470,6 +489,7 @@ public class HeadersController extends TransactionFormController implements Init
     }
 
     private void updateBlockchainForm(BlockTransaction blockTransaction, Integer currentHeight) {
+        signaturesForm.setVisible(false);
         blockchainForm.setVisible(true);
 
         if(Sha256Hash.ZERO_HASH.equals(blockTransaction.getBlockHash()) && blockTransaction.getHeight() == 0 && headersForm.getSigningWallet() == null) {
@@ -541,6 +561,24 @@ public class HeadersController extends TransactionFormController implements Init
         }
     }
 
+    private BitcoinURI getPayjoinURI() {
+        if(headersForm.getPsbt() != null) {
+            for(TransactionOutput txOutput : headersForm.getPsbt().getTransaction().getOutputs()) {
+                try {
+                    Address address = txOutput.getScript().getToAddresses()[0];
+                    BitcoinURI bitcoinURI = AppServices.getPayjoinURI(address);
+                    if(bitcoinURI != null) {
+                        return bitcoinURI;
+                    }
+                } catch(Exception e) {
+                    //ignore
+                }
+            }
+        }
+
+        return null;
+    }
+
     private static class BlockHeightContextMenu extends ContextMenu {
         public BlockHeightContextMenu(Sha256Hash blockHash) {
             MenuItem copyBlockHash = new MenuItem("Copy Block Hash");
@@ -556,7 +594,7 @@ public class HeadersController extends TransactionFormController implements Init
 
     private void updateTxId() {
         id.setText(headersForm.getTransaction().calculateTxId(false).toString());
-        if(headersForm.getPsbt() != null && !(headersForm.getTransaction().hasScriptSigs() || headersForm.getTransaction().hasWitnesses())) {
+        if(!headersForm.isTransactionFinalized()) {
             if(!id.getStyleClass().contains(UNFINALIZED_TXID_CLASS)) {
                 id.getStyleClass().add(UNFINALIZED_TXID_CLASS);
             }
@@ -572,14 +610,14 @@ public class HeadersController extends TransactionFormController implements Init
     }
 
     public void setLocktimeToCurrentHeight(ActionEvent event) {
-        if(AppController.getCurrentBlockHeight() != null && locktimeBlock.isEditable()) {
-            locktimeBlock.getValueFactory().setValue(AppController.getCurrentBlockHeight());
+        if(AppServices.getCurrentBlockHeight() != null && locktimeBlock.isEditable()) {
+            locktimeBlock.getValueFactory().setValue(AppServices.getCurrentBlockHeight());
             Platform.runLater(() -> locktimeBlockType.requestFocus());
         }
     }
 
     public void openWallet(ActionEvent event) {
-        EventManager.get().post(new RequestWalletOpenEvent());
+        EventManager.get().post(new RequestWalletOpenEvent(noWalletsWarningLink.getScene().getWindow()));
     }
 
     public void finalizeTransaction(ActionEvent event) {
@@ -590,8 +628,11 @@ public class HeadersController extends TransactionFormController implements Init
         ToggleButton toggleButton = (ToggleButton)event.getSource();
         toggleButton.setSelected(false);
 
+        //TODO: Remove once Cobo Vault has upgraded to UR2.0
+        boolean addLegacyEncodingOption = headersForm.getSigningWallet().getKeystores().stream().anyMatch(keystore -> keystore.getWalletModel().equals(WalletModel.COBO_VAULT));
+
         try {
-            QRDisplayDialog qrDisplayDialog = new QRDisplayDialog(UR.CRYPTO_PSBT_TYPE, headersForm.getPsbt().serialize());
+            QRDisplayDialog qrDisplayDialog = new QRDisplayDialog(RegistryType.CRYPTO_PSBT.toString(), headersForm.getPsbt().serialize(), addLegacyEncodingOption);
             qrDisplayDialog.show();
         } catch(UR.URException e) {
             log.error("Error creating PSBT UR", e);
@@ -602,7 +643,7 @@ public class HeadersController extends TransactionFormController implements Init
         ToggleButton toggleButton = (ToggleButton)event.getSource();
         toggleButton.setSelected(false);
 
-        EventManager.get().post(new RequestQRScanEvent());
+        EventManager.get().post(new RequestQRScanEvent(toggleButton.getScene().getWindow()));
     }
 
     public void savePSBT(ActionEvent event) {
@@ -626,7 +667,7 @@ public class HeadersController extends TransactionFormController implements Init
                 }
             } catch(IOException e) {
                 log.error("Error saving PSBT", e);
-                AppController.showErrorDialog("Error saving PSBT", "Cannot write to " + file.getAbsolutePath());
+                AppServices.showErrorDialog("Error saving PSBT", "Cannot write to " + file.getAbsolutePath());
             }
         }
     }
@@ -635,7 +676,7 @@ public class HeadersController extends TransactionFormController implements Init
         ToggleButton toggleButton = (ToggleButton)event.getSource();
         toggleButton.setSelected(false);
 
-        EventManager.get().post(new RequestTransactionOpenEvent());
+        EventManager.get().post(new RequestTransactionOpenEvent(toggleButton.getScene().getWindow()));
     }
 
     public void signPSBT(ActionEvent event) {
@@ -667,7 +708,7 @@ public class HeadersController extends TransactionFormController implements Init
                 });
                 decryptWalletService.setOnFailed(workerStateEvent -> {
                     EventManager.get().post(new StorageEvent(file, TimedEvent.Action.END, "Failed"));
-                    AppController.showErrorDialog("Incorrect Password", decryptWalletService.getException().getMessage());
+                    AppServices.showErrorDialog("Incorrect Password", decryptWalletService.getException().getMessage());
                 });
                 EventManager.get().post(new StorageEvent(file, TimedEvent.Action.START, "Decrypting wallet..."));
                 decryptWalletService.start();
@@ -683,7 +724,7 @@ public class HeadersController extends TransactionFormController implements Init
             updateSignedKeystores(headersForm.getSigningWallet());
         } catch(Exception e) {
             log.warn("Failed to Sign", e);
-            AppController.showErrorDialog("Failed to Sign", e.getMessage());
+            AppServices.showErrorDialog("Failed to Sign", e.getMessage());
         }
     }
 
@@ -693,7 +734,7 @@ public class HeadersController extends TransactionFormController implements Init
         }
 
         List<String> fingerprints = headersForm.getSigningWallet().getKeystores().stream().map(keystore -> keystore.getKeyDerivation().getMasterFingerprint()).collect(Collectors.toList());
-        List<Device> signingDevices = AppController.getDevices().stream().filter(device -> fingerprints.contains(device.getFingerprint())).collect(Collectors.toList());
+        List<Device> signingDevices = AppServices.getDevices().stream().filter(device -> fingerprints.contains(device.getFingerprint())).collect(Collectors.toList());
         if(signingDevices.isEmpty() && headersForm.getSigningWallet().getKeystores().stream().noneMatch(keystore -> keystore.getSource().equals(KeystoreSource.HW_USB))) {
             return;
         }
@@ -755,7 +796,7 @@ public class HeadersController extends TransactionFormController implements Init
         broadcastTransactionService.setOnFailed(workerStateEvent -> {
             broadcastProgressBar.setProgress(0);
             log.error("Error broadcasting transaction", workerStateEvent.getSource().getException());
-            AppController.showErrorDialog("Error broadcasting transaction", "The server returned an error when broadcasting the transaction. The server response is contained in sparrow.log");
+            AppServices.showErrorDialog("Error broadcasting transaction", "The server returned an error when broadcasting the transaction. The server response is contained in sparrow.log");
             broadcastButton.setDisable(false);
         });
 
@@ -783,11 +824,26 @@ public class HeadersController extends TransactionFormController implements Init
                 }
             } catch(IOException e) {
                 log.error("Error saving transaction", e);
-                AppController.showErrorDialog("Error saving transaction", "Cannot write to " + file.getAbsolutePath());
+                AppServices.showErrorDialog("Error saving transaction", "Cannot write to " + file.getAbsolutePath());
             }
         }
     }
 
+    public void getPayjoinTransaction(ActionEvent event) {
+        BitcoinURI payjoinURI = getPayjoinURI();
+        if(payjoinURI == null) {
+            throw new IllegalStateException("No valid Payjoin URI");
+        }
+
+        try {
+            Payjoin payjoin = new Payjoin(payjoinURI, headersForm.getSigningWallet(), headersForm.getPsbt());
+            PSBT proposalPsbt = payjoin.requestPayjoinPSBT(true);
+            EventManager.get().post(new ViewPSBTEvent(payjoinButton.getScene().getWindow(), headersForm.getName() + " Payjoin", null, proposalPsbt));
+        } catch(PayjoinReceiverException e) {
+            AppServices.showErrorDialog("Invalid Payjoin Transaction", e.getMessage());
+        }
+    }
+
     @Override
     public void update() {
         BlockTransaction blockTransaction = headersForm.getBlockTransaction();
@@ -796,8 +852,8 @@ public class HeadersController extends TransactionFormController implements Init
             blockTransaction = headersForm.getSigningWallet().getTransactions().get(txId);
         }
 
-        if(blockTransaction != null && AppController.getCurrentBlockHeight() != null) {
-            updateBlockchainForm(blockTransaction, AppController.getCurrentBlockHeight());
+        if(blockTransaction != null && AppServices.getCurrentBlockHeight() != null) {
+            updateBlockchainForm(blockTransaction, AppServices.getCurrentBlockHeight());
         }
     }
 
@@ -819,7 +875,7 @@ public class HeadersController extends TransactionFormController implements Init
     public void blockTransactionFetched(BlockTransactionFetchedEvent event) {
         if(event.getTxId().equals(headersForm.getTransaction().getTxId())) {
             if(event.getBlockTransaction() != null && (!Sha256Hash.ZERO_HASH.equals(event.getBlockTransaction().getBlockHash()) || headersForm.getBlockTransaction() == null)) {
-                updateBlockchainForm(event.getBlockTransaction(), AppController.getCurrentBlockHeight());
+                updateBlockchainForm(event.getBlockTransaction(), AppServices.getCurrentBlockHeight());
             }
 
             Long feeAmt = calculateFee(event.getInputTransactions());
@@ -836,7 +892,7 @@ public class HeadersController extends TransactionFormController implements Init
 
     @Subscribe
     public void openWallets(OpenWalletsEvent event) {
-        if(headersForm.getPsbt() != null && headersForm.getBlockTransaction() == null) {
+        if(id.getScene().getWindow().equals(event.getWindow()) && headersForm.getPsbt() != null && headersForm.getBlockTransaction() == null) {
             List<Wallet> availableWallets = event.getWallets().stream().filter(wallet -> wallet.canSign(headersForm.getPsbt())).sorted(new WalletSignComparator()).collect(Collectors.toList());
             Map<Wallet, Storage> availableWalletsMap = new LinkedHashMap<>(event.getWalletsMap());
             availableWalletsMap.keySet().retainAll(availableWallets);
@@ -936,6 +992,10 @@ public class HeadersController extends TransactionFormController implements Init
     @Subscribe
     public void psbtFinalized(PSBTFinalizedEvent event) {
         if(event.getPsbt().equals(headersForm.getPsbt())) {
+            if(headersForm.getSigningWallet() != null) {
+                updateSignedKeystores(headersForm.getSigningWallet());
+            }
+
             signButtonBox.setVisible(false);
             broadcastButtonBox.setVisible(true);
         }
@@ -961,7 +1021,7 @@ public class HeadersController extends TransactionFormController implements Init
 
     @Subscribe
     public void walletNodeHistoryChanged(WalletNodeHistoryChangedEvent event) {
-        if(headersForm.getSigningWallet() != null && event.getWalletNode(headersForm.getSigningWallet()) != null) {
+        if(headersForm.getSigningWallet() != null && event.getWalletNode(headersForm.getSigningWallet()) != null && headersForm.isTransactionFinalized()) {
             Sha256Hash txid = headersForm.getTransaction().getTxId();
             ElectrumServer.TransactionReferenceService transactionReferenceService = new ElectrumServer.TransactionReferenceService(Set.of(txid), event.getScriptHash());
             transactionReferenceService.setOnSucceeded(successEvent -> {
@@ -969,8 +1029,7 @@ public class HeadersController extends TransactionFormController implements Init
                 BlockTransaction blockTransaction = transactionMap.get(txid);
                 if(blockTransaction != null) {
                     headersForm.setBlockTransaction(blockTransaction);
-                    signaturesForm.setVisible(false);
-                    updateBlockchainForm(blockTransaction, AppController.getCurrentBlockHeight());
+                    updateBlockchainForm(blockTransaction, AppServices.getCurrentBlockHeight());
                 }
             });
             transactionReferenceService.setOnFailed(failEvent -> {
@@ -1013,7 +1072,7 @@ public class HeadersController extends TransactionFormController implements Init
             updateBlockchainForm(headersForm.getBlockTransaction(), event.getHeight());
         }
         if(futureBlockWarning.isVisible()) {
-            futureBlockWarning.setVisible(AppController.getCurrentBlockHeight() != null && locktimeBlock.getValue() > event.getHeight());
+            futureBlockWarning.setVisible(AppServices.getCurrentBlockHeight() != null && locktimeBlock.getValue() > event.getHeight());
         }
     }
 

src/main/java/com/sparrowwallet/sparrow/transaction/InputController.java

@@ -8,6 +8,7 @@ import com.sparrowwallet.drongo.protocol.*;
 import com.sparrowwallet.drongo.psbt.PSBTInput;
 import com.sparrowwallet.drongo.wallet.BlockTransaction;
 import com.sparrowwallet.drongo.wallet.Keystore;
+import com.sparrowwallet.drongo.wallet.Wallet;
 import com.sparrowwallet.sparrow.EventManager;
 import com.sparrowwallet.sparrow.control.*;
 import com.sparrowwallet.sparrow.event.*;
@@ -120,6 +121,11 @@ public class InputController extends TransactionFormController implements Initia
         TransactionInput txInput = inputForm.getTransactionInput();
         PSBTInput psbtInput = inputForm.getPsbtInput();
 
+        inputForm.signingWalletProperty().addListener((observable, oldValue, signingWallet) -> {
+            updateInputLegendFromWallet(txInput, signingWallet);
+        });
+        updateInputLegendFromWallet(txInput, inputForm.getSigningWallet());
+
         initializeInputFields(txInput, psbtInput);
         initializeScriptFields(txInput, psbtInput);
         initializeStatusFields(txInput, psbtInput);
@@ -132,9 +138,27 @@ public class InputController extends TransactionFormController implements Initia
         }
     }
 
-    private void initializeInputFields(TransactionInput txInput, PSBTInput psbtInput) {
-        inputFieldset.setText("Input #" + txInput.getIndex());
+    private String getLegendText(TransactionInput txInput) {
+        return "Input #" + txInput.getIndex();
+    }
 
+    private void updateInputLegendFromWallet(TransactionInput txInput, Wallet signingWallet) {
+        String baseText = getLegendText(txInput);
+        if(signingWallet != null) {
+            if(inputForm.isWalletTxo()) {
+                inputFieldset.setText(baseText + " - " + signingWallet.getName());
+                inputFieldset.setIcon(TransactionDiagram.getTxoGlyph());
+            } else {
+                inputFieldset.setText(baseText + " - Payjoin");
+                inputFieldset.setIcon(TransactionDiagram.getPayjoinGlyph());
+            }
+        } else {
+            inputFieldset.setText(baseText);
+            inputFieldset.setIcon(null);
+        }
+    }
+
+    private void initializeInputFields(TransactionInput txInput, PSBTInput psbtInput) {
         outpoint.managedProperty().bind(outpoint.visibleProperty());
         linkedOutpoint.managedProperty().bind(linkedOutpoint.visibleProperty());
 
@@ -170,7 +194,7 @@ public class InputController extends TransactionFormController implements Initia
         linkedOutpoint.setText(txInput.getOutpoint().getHash().toString() + ":" + txInput.getOutpoint().getIndex());
         linkedOutpoint.setOnAction(event -> {
             BlockTransaction linkedTransaction = inputTransactions.get(txInput.getOutpoint().getHash());
-            EventManager.get().post(new ViewTransactionEvent(linkedTransaction, TransactionView.OUTPUT, (int)txInput.getOutpoint().getIndex()));
+            EventManager.get().post(new ViewTransactionEvent(linkedOutpoint.getScene().getWindow(), linkedTransaction, TransactionView.OUTPUT, (int)txInput.getOutpoint().getIndex()));
         });
         linkedOutpoint.setContextMenu(new TransactionReferenceContextMenu(linkedOutpoint.getText()));
     }

src/main/java/com/sparrowwallet/sparrow/transaction/InputForm.java

@@ -46,6 +46,11 @@ public class InputForm extends IndexedTransactionForm {
         return null;
     }
 
+    public boolean isWalletTxo() {
+        TransactionInput txInput = getTransactionInput();
+        return getSigningWallet() != null && getSigningWallet().getWalletTxos().keySet().stream().anyMatch(ref -> ref.getHash().equals(txInput.getOutpoint().getHash()) && ref.getIndex() == txInput.getOutpoint().getIndex());
+    }
+
     @Override
     public Node getContents() throws IOException {
         FXMLLoader loader = new FXMLLoader(getClass().getResource("input.fxml"));

src/main/java/com/sparrowwallet/sparrow/transaction/OutputController.java

@@ -1,7 +1,6 @@
 package com.sparrowwallet.sparrow.transaction;
 
 import com.google.common.eventbus.Subscribe;
-import com.sparrowwallet.drongo.KeyPurpose;
 import com.sparrowwallet.drongo.address.Address;
 import com.sparrowwallet.drongo.protocol.NonStandardScriptException;
 import com.sparrowwallet.drongo.protocol.TransactionInput;
@@ -106,10 +105,10 @@ public class OutputController extends TransactionFormController implements Initi
     private void updateOutputLegendFromWallet(TransactionOutput txOutput, Wallet signingWallet) {
         String baseText = getLegendText(txOutput);
         if(signingWallet != null) {
-            if(signingWallet.getWalletOutputScripts(KeyPurpose.RECEIVE).containsKey(txOutput.getScript())) {
+            if(outputForm.isWalletConsolidation()) {
                 outputFieldset.setText(baseText + " - Consolidation");
                 outputFieldset.setIcon(TransactionDiagram.getConsolidationGlyph());
-            } else if(signingWallet.getWalletOutputScripts(KeyPurpose.CHANGE).containsKey(txOutput.getScript())) {
+            } else if(outputForm.isWalletChange()) {
                 outputFieldset.setText(baseText + " - Change");
                 outputFieldset.setIcon(TransactionDiagram.getChangeGlyph());
             } else {
@@ -149,7 +148,7 @@ public class OutputController extends TransactionFormController implements Initi
                         final Integer inputIndex = i;
                         spentBy.setText(outputBlockTransaction.getHash().toString() + ":" + inputIndex);
                         spentBy.setOnAction(event -> {
-                            EventManager.get().post(new ViewTransactionEvent(outputBlockTransaction, TransactionView.INPUT, inputIndex));
+                            EventManager.get().post(new ViewTransactionEvent(spentBy.getScene().getWindow(), outputBlockTransaction, TransactionView.INPUT, inputIndex));
                         });
                         spentBy.setContextMenu(new TransactionReferenceContextMenu(spentBy.getText()));
                     }

src/main/java/com/sparrowwallet/sparrow/transaction/OutputForm.java

@@ -1,5 +1,6 @@
 package com.sparrowwallet.sparrow.transaction;
 
+import com.sparrowwallet.drongo.KeyPurpose;
 import com.sparrowwallet.drongo.protocol.TransactionOutput;
 import com.sparrowwallet.drongo.psbt.PSBTOutput;
 import javafx.fxml.FXMLLoader;
@@ -30,6 +31,18 @@ public class OutputForm extends IndexedTransactionForm {
         return psbtOutput;
     }
 
+    public boolean isWalletConsolidation() {
+        return (getSigningWallet() != null && getSigningWallet().getWalletOutputScripts(KeyPurpose.RECEIVE).containsKey(getTransactionOutput().getScript()));
+    }
+
+    public boolean isWalletChange() {
+        return (getSigningWallet() != null && getSigningWallet().getWalletOutputScripts(KeyPurpose.CHANGE).containsKey(getTransactionOutput().getScript()));
+    }
+
+    public boolean isWalletPayment() {
+        return getSigningWallet() != null;
+    }
+
     @Override
     public Node getContents() throws IOException {
         FXMLLoader loader = new FXMLLoader(getClass().getResource("output.fxml"));

src/main/java/com/sparrowwallet/sparrow/transaction/TransactionController.java

@@ -6,22 +6,23 @@ import com.sparrowwallet.drongo.psbt.PSBT;
 import com.sparrowwallet.drongo.psbt.PSBTInput;
 import com.sparrowwallet.drongo.psbt.PSBTOutput;
 import com.sparrowwallet.drongo.wallet.BlockTransaction;
-import com.sparrowwallet.sparrow.AppController;
+import com.sparrowwallet.sparrow.AppServices;
 import com.sparrowwallet.sparrow.EventManager;
 import com.sparrowwallet.sparrow.TransactionTabData;
+import com.sparrowwallet.sparrow.control.TransactionDiagram;
 import com.sparrowwallet.sparrow.control.TransactionHexArea;
 import com.sparrowwallet.sparrow.event.*;
+import com.sparrowwallet.sparrow.io.Config;
 import com.sparrowwallet.sparrow.net.ElectrumServer;
 import javafx.application.Platform;
 import javafx.fxml.FXML;
 import javafx.fxml.Initializable;
 import javafx.scene.Node;
 import javafx.scene.Parent;
+import javafx.scene.control.TreeCell;
 import javafx.scene.control.TreeItem;
 import javafx.scene.control.TreeView;
-import javafx.scene.control.cell.TextFieldTreeCell;
 import javafx.scene.layout.Pane;
-import javafx.util.StringConverter;
 import org.controlsfx.control.MasterDetailPane;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -63,7 +64,7 @@ public class TransactionController implements Initializable {
 
     public void initializeView() {
         initializeTxTree();
-        transactionMasterDetail.setShowDetailNode(AppController.showTxHexProperty);
+        transactionMasterDetail.setShowDetailNode(Config.get().isShowTransactionHex());
         txhex.setTransaction(getTransaction());
         highlightTxHex();
         fetchThisAndInputBlockTransactions(0, Math.min(getTransaction().getInputs().size(), PageForm.PAGE_SIZE));
@@ -125,17 +126,46 @@ public class TransactionController implements Initializable {
         rootItem.getChildren().add(outputsItem);
         txtree.setRoot(rootItem);
 
-        txtree.setCellFactory(p -> new TextFieldTreeCell<>(new StringConverter<TransactionForm>() {
+        txtree.setCellFactory(tc -> new TreeCell<>() {
             @Override
-            public String toString(TransactionForm transactionForm) {
-                return transactionForm.toString();
-            }
+            protected void updateItem(TransactionForm form, boolean empty) {
+                super.updateItem(form, empty);
 
-            @Override
-            public TransactionForm fromString(String string) {
-                throw new IllegalStateException("No editing");
+                setText(null);
+                setGraphic(null);
+                setTooltip(null);
+                setContextMenu(null);
+
+                if(form != null) {
+                    setText(form.toString());
+
+                    if(form.getSigningWallet() != null) {
+                        if(form instanceof InputForm) {
+                            InputForm inputForm = (InputForm)form;
+                            if(inputForm.isWalletTxo()) {
+                                setGraphic(TransactionDiagram.getTxoGlyph());
+                            } else {
+                                setGraphic(TransactionDiagram.getPayjoinGlyph());
+                            }
+                        }
+                        if(form instanceof OutputForm) {
+                            OutputForm outputForm = (OutputForm)form;
+                            if(outputForm.isWalletConsolidation()) {
+                                setGraphic(TransactionDiagram.getConsolidationGlyph());
+                            } else if(outputForm.isWalletChange()) {
+                                setGraphic(TransactionDiagram.getChangeGlyph());
+                            } else {
+                                setGraphic(TransactionDiagram.getPaymentGlyph());
+                            }
+                        }
+                    }
+                }
             }
-        }));
+        });
+
+        txdata.signingWalletProperty().addListener((observable, oldValue, newValue) -> {
+            txtree.refresh();
+        });
 
         txtree.getSelectionModel().selectedItemProperty().addListener((observable, old_val, selectedItem) -> {
             TransactionForm transactionForm = selectedItem.getValue();
@@ -296,7 +326,7 @@ public class TransactionController implements Initializable {
     }
 
     private void fetchThisAndInputBlockTransactions(int indexStart, int indexEnd) {
-        if(AppController.isOnline() && indexStart < getTransaction().getInputs().size()) {
+        if(AppServices.isOnline() && indexStart < getTransaction().getInputs().size()) {
             Set<Sha256Hash> references = new HashSet<>();
             if(getPSBT() == null) {
                 references.add(getTransaction().getTxId());
@@ -348,7 +378,7 @@ public class TransactionController implements Initializable {
     }
 
     private void fetchOutputBlockTransactions(int indexStart, int indexEnd) {
-        if(AppController.isOnline() && getPSBT() == null && indexStart < getTransaction().getOutputs().size()) {
+        if(AppServices.isOnline() && getPSBT() == null && indexStart < getTransaction().getOutputs().size()) {
             int maxIndex = Math.min(getTransaction().getOutputs().size(), indexEnd);
             ElectrumServer.TransactionOutputsReferenceService transactionOutputsReferenceService = new ElectrumServer.TransactionOutputsReferenceService(getTransaction(), indexStart, maxIndex);
             transactionOutputsReferenceService.setOnSucceeded(successEvent -> {

src/main/java/com/sparrowwallet/sparrow/transaction/TransactionForm.java

@@ -107,6 +107,10 @@ public abstract class TransactionForm {
         return true;
     }
 
+    public boolean isTransactionFinalized() {
+        return getPsbt() == null || getTransaction().hasScriptSigs() || getTransaction().hasWitnesses();
+    }
+
     public abstract Node getContents() throws IOException;
 
     public abstract TransactionView getView();

src/main/java/com/sparrowwallet/sparrow/wallet/AddressesController.java

@@ -67,4 +67,20 @@ public class AddressesController extends WalletFormController implements Initial
         receiveTable.setBitcoinUnit(getWalletForm().getWallet(), event.getBitcoinUnit());
         changeTable.setBitcoinUnit(getWalletForm().getWallet(), event.getBitcoinUnit());
     }
+
+    @Subscribe
+    public void walletUtxoStatusChanged(WalletUtxoStatusChangedEvent event) {
+        if(event.getWallet().equals(getWalletForm().getWallet())) {
+            receiveTable.refresh();
+            changeTable.refresh();
+        }
+    }
+
+    @Subscribe
+    public void walletAddressesStatusChanged(WalletAddressesStatusEvent event) {
+        if(event.getWallet().equals(walletForm.getWallet())) {
+            receiveTable.updateAll(getWalletForm().getNodeEntry(KeyPurpose.RECEIVE));
+            changeTable.updateAll(getWalletForm().getNodeEntry(KeyPurpose.CHANGE));
+        }
+    }
 }