Bump version to 4.5.2

Bug fixes and additions

AutoUpdates.md

@@ -8,7 +8,7 @@
 * Build auto-update download: `tools/build-auto-update.sh` - uploads auto-update file into new git branch
 * Restart local node
 * Publish auto-update transaction using *private key* for **non-admin** member of "dev" group:
-	`tools/publish-auto-update.sh non-admin-dev-member-private-key-in-base58`
+	`tools/publish-auto-update.pl non-admin-dev-member-private-key-in-base58`
 * Wait for auto-update `ARBITRARY` transaction to be confirmed into a block
 * Have "dev" group admins 'approve' auto-update using `tools/approve-auto-update.sh`
 	This tool will prompt for *private key* of **admin** of "dev" group

lib/org/ciyam/AT/1.4.1/AT-1.4.1.pom

@@ -10,14 +10,13 @@
 	<properties>
 		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 		<skipTests>false</skipTests>
-
-		<maven-compiler-plugin.version>3.8.1</maven-compiler-plugin.version>
-		<maven-source-plugin.version>3.2.0</maven-source-plugin.version>
-		<maven-javadoc-plugin.version>3.3.1</maven-javadoc-plugin.version>
-		<maven-surefire-plugin.version>3.0.0-M4</maven-surefire-plugin.version>
-		<maven-jar-plugin.version>3.2.0</maven-jar-plugin.version>
-
-		<bouncycastle.version>1.64</bouncycastle.version>
+		<bouncycastle.version>1.69</bouncycastle.version>
+		<junit.version>4.13.2</junit.version>
+		<maven-compiler-plugin.version>3.11.0</maven-compiler-plugin.version>
+		<maven-jar-plugin.version>3.3.0</maven-jar-plugin.version>
+		<maven-javadoc-plugin.version>3.6.3</maven-javadoc-plugin.version>
+		<maven-source-plugin.version>3.3.0</maven-source-plugin.version>
+		<maven-surefire-plugin.version>3.2.2</maven-surefire-plugin.version>
 	</properties>
 
 	<build>
@@ -117,7 +116,7 @@
 		<dependency>
 			<groupId>junit</groupId>
 			<artifactId>junit</artifactId>
-			<version>4.13</version>
+			<version>${junit.version}</version>
 			<scope>test</scope>
 		</dependency>
 	</dependencies>

lib/org/ciyam/AT/1.4.2/AT-1.4.2.pom

@@ -0,0 +1,123 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<groupId>org.ciyam</groupId>
+	<artifactId>AT</artifactId>
+	<version>1.4.2</version>
+	<packaging>jar</packaging>
+
+	<properties>
+		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+		<skipTests>false</skipTests>
+		<bouncycastle.version>1.70</bouncycastle.version>
+		<junit.version>4.13.2</junit.version>
+		<maven-compiler-plugin.version>3.13.0</maven-compiler-plugin.version>
+		<maven-source-plugin.version>3.3.0</maven-source-plugin.version>
+		<maven-javadoc-plugin.version>3.6.3</maven-javadoc-plugin.version>
+		<maven-surefire-plugin.version>3.2.5</maven-surefire-plugin.version>
+		<maven-jar-plugin.version>3.4.1</maven-jar-plugin.version>
+	</properties>
+
+	<build>
+		<sourceDirectory>src/main/java</sourceDirectory>
+		<testSourceDirectory>src/test/java</testSourceDirectory>
+		<plugins>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-compiler-plugin</artifactId>
+				<version>${maven-compiler-plugin.version}</version>
+				<configuration>
+					<source>11</source>
+					<target>11</target>
+				</configuration>
+			</plugin>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-surefire-plugin</artifactId>
+				<version>${maven-surefire-plugin.version}</version>
+				<configuration>
+					<skipTests>${skipTests}</skipTests>
+				</configuration>
+			</plugin>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-source-plugin</artifactId>
+				<version>${maven-source-plugin.version}</version>
+				<executions>
+					<execution>
+						<id>attach-sources</id>
+						<goals>
+							<goal>jar</goal>
+						</goals>
+					</execution>
+				</executions>
+			</plugin>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-javadoc-plugin</artifactId>
+				<version>${maven-javadoc-plugin.version}</version>
+				<executions>
+					<execution>
+						<id>attach-javadoc</id>
+						<goals>
+							<goal>jar</goal>
+						</goals>
+					</execution>
+				</executions>
+			</plugin>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-jar-plugin</artifactId>
+				<version>${maven-jar-plugin.version}</version>
+				<executions>
+					<execution>
+						<goals>
+							<goal>test-jar</goal>
+						</goals>
+					</execution>
+				</executions>
+			</plugin>
+		</plugins>
+	</build>
+
+	<dependencies>
+		<dependency>
+			<groupId>org.apache.maven.plugins</groupId>
+			<artifactId>maven-compiler-plugin</artifactId>
+			<version>${maven-compiler-plugin.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>org.apache.maven.plugins</groupId>
+			<artifactId>maven-surefire-plugin</artifactId>
+			<version>${maven-surefire-plugin.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>org.apache.maven.plugins</groupId>
+			<artifactId>maven-source-plugin</artifactId>
+			<version>${maven-source-plugin.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>org.apache.maven.plugins</groupId>
+			<artifactId>maven-javadoc-plugin</artifactId>
+			<version>${maven-javadoc-plugin.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>org.apache.maven.plugins</groupId>
+			<artifactId>maven-jar-plugin</artifactId>
+			<version>${maven-jar-plugin.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>org.bouncycastle</groupId>
+			<artifactId>bcprov-jdk15on</artifactId>
+			<version>${bouncycastle.version}</version>
+			<scope>test</scope>
+		</dependency>
+		<dependency>
+			<groupId>junit</groupId>
+			<artifactId>junit</artifactId>
+			<version>${junit.version}</version>
+			<scope>test</scope>
+		</dependency>
+	</dependencies>
+</project>

lib/org/ciyam/AT/maven-metadata-local.xml

@@ -3,16 +3,14 @@
   <groupId>org.ciyam</groupId>
   <artifactId>AT</artifactId>
   <versioning>
-    <release>1.4.1</release>
+    <release>1.4.2</release>
     <versions>
-      <version>1.3.4</version>
-      <version>1.3.5</version>
-      <version>1.3.6</version>
       <version>1.3.7</version>
       <version>1.3.8</version>
       <version>1.4.0</version>
       <version>1.4.1</version>
+      <version>1.4.2</version>
     </versions>
-    <lastUpdated>20230821074325</lastUpdated>
+    <lastUpdated>20240426084210</lastUpdated>
   </versioning>
 </metadata>

pom.xml

@@ -3,58 +3,60 @@
 	<modelVersion>4.0.0</modelVersion>
 	<groupId>org.qortal</groupId>
 	<artifactId>qortal</artifactId>
-	<version>4.4.0</version>
+	<version>4.5.2</version>
 	<packaging>jar</packaging>
 	<properties>
+		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 		<skipTests>true</skipTests>
+
 		<altcoinj.version>7dc8c6f</altcoinj.version>
 		<bitcoinj.version>0.15.10</bitcoinj.version>
-		<bouncycastle.version>1.69</bouncycastle.version>
-		<build-helper-maven-plugin.version>3.4.0</build-helper-maven-plugin.version>
+		<bouncycastle.version>1.70</bouncycastle.version>
 		<build.timestamp>${maven.build.timestamp}</build.timestamp>
-		<ciyam-at.version>1.4.1</ciyam-at.version>
+		<ciyam-at.version>1.4.2</ciyam-at.version>
 		<commons-net.version>3.8.0</commons-net.version>
-		<commons-text.version>1.11.0</commons-text.version>
-		<commons-io.version>2.11.0</commons-io.version>
-		<commons-compress.version>1.24.0</commons-compress.version>
-		<commons-lang3.version>3.13.0</commons-lang3.version>
+		<commons-text.version>1.12.0</commons-text.version>
+		<commons-io.version>2.16.1</commons-io.version>
+		<commons-compress.version>1.26.2</commons-compress.version>
+		<commons-lang3.version>3.14.0</commons-lang3.version>
 		<dagger.version>1.2.2</dagger.version>
 		<extendedset.version>0.12.3</extendedset.version>
 		<git-commit-id-plugin.version>4.9.10</git-commit-id-plugin.version>
-		<grpc.version>1.59.0</grpc.version>
-		<guava.version>32.1.3-jre</guava.version>
+		<grpc.version>1.65.0</grpc.version>
+		<guava.version>33.2.1-jre</guava.version>
 		<hamcrest-library.version>2.2</hamcrest-library.version>
 		<homoglyph.version>1.2.1</homoglyph.version>
 		<hsqldb.version>2.5.1</hsqldb.version>
-		<icu4j.version>74.1</icu4j.version>
+		<icu4j.version>75.1</icu4j.version>
 		<java-diff-utils.version>4.12</java-diff-utils.version>
 		<javax.servlet-api.version>4.0.1</javax.servlet-api.version>
 		<jaxb-runtime.version>2.3.9</jaxb-runtime.version>
-		<jersey.version>2.41</jersey.version>
-		<jetty.version>9.4.53.v20231009</jetty.version>
+		<jersey.version>2.42</jersey.version>
+		<jetty.version>9.4.54.v20240208</jetty.version>
 		<json-simple.version>1.1.1</json-simple.version>
-		<json.version>20231013</json.version>
-		<jsoup.version>1.16.2</jsoup.version>
-		<junit-jupiter-engine.version>5.10.0</junit-jupiter-engine.version>
+		<json.version>20240303</json.version>
+		<jsoup.version>1.17.2</jsoup.version>
+		<junit-jupiter-engine.version>5.11.0-M2</junit-jupiter-engine.version>
 		<lifecycle-mapping.version>1.0.0</lifecycle-mapping.version>
-		<log4j.version>2.21.1</log4j.version>
+		<log4j.version>2.23.1</log4j.version>
 		<mail.version>1.5.0-b01</mail.version>
-		<maven-compiler-plugin.version>3.11.0</maven-compiler-plugin.version>
-		<maven-jar-plugin.version>3.3.0</maven-jar-plugin.version>
+		<maven-build-helper-plugin.version>3.6.0</maven-build-helper-plugin.version>
+		<maven-compiler-plugin.version>3.13.0</maven-compiler-plugin.version>
+		<maven-dependency-plugin.version>3.6.1</maven-dependency-plugin.version>
+		<maven-jar-plugin.version>3.4.2</maven-jar-plugin.version>
+		<maven-package-info-plugin.version>1.1.0</maven-package-info-plugin.version>
+		<maven-plugin.version>2.16.2</maven-plugin.version>
+		<maven-reproducible-build-plugin.version>0.16</maven-reproducible-build-plugin.version>
 		<maven-resources-plugin.version>3.3.1</maven-resources-plugin.version>
-		<maven-shade-plugin.version>3.5.1</maven-shade-plugin.version>
-		<maven-surefire-plugin.version>3.2.2</maven-surefire-plugin.version>
-		<package-info-maven-plugin.version>1.1.0</package-info-maven-plugin.version>
-		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-		<protobuf.version>3.24.4</protobuf.version>
+		<maven-shade-plugin.version>3.6.0</maven-shade-plugin.version>
+		<maven-surefire-plugin.version>3.3.0</maven-surefire-plugin.version>
+		<protobuf.version>3.25.3</protobuf.version>
 		<replacer.version>1.5.3</replacer.version>
-		<reproducible-build-maven-plugin.version>0.16</reproducible-build-maven-plugin.version>
 		<simplemagic.version>1.17</simplemagic.version>
 		<slf4j.version>1.7.36</slf4j.version>
 		<swagger-api.version>2.0.10</swagger-api.version>
-		<swagger-ui.version>5.9.0</swagger-ui.version>
+		<swagger-ui.version>5.17.14</swagger-ui.version>
 		<upnp.version>1.2</upnp.version>
-		<versions-maven-plugin.version>2.16.1</versions-maven-plugin.version>
 		<xz.version>1.9</xz.version>
 	</properties>
 	<build>
@@ -70,7 +72,7 @@
 			<plugin>
 				<groupId>org.codehaus.mojo</groupId>
 				<artifactId>versions-maven-plugin</artifactId>
-				<version>${versions-maven-plugin.version}</version>
+				<version>${maven-plugin.version}</version>
 				<configuration>
 					<generateBackupPoms>false</generateBackupPoms>
 				</configuration>
@@ -238,7 +240,7 @@
 			<plugin>
 				<groupId>com.github.bohnman</groupId>
 				<artifactId>package-info-maven-plugin</artifactId>
-				<version>${package-info-maven-plugin.version}</version>
+				<version>${maven-package-info-plugin.version}</version>
 				<configuration>
 					<packages>
 						<package>
@@ -268,7 +270,7 @@
 			<plugin>
 				<groupId>org.codehaus.mojo</groupId>
 				<artifactId>build-helper-maven-plugin</artifactId>
-				<version>${build-helper-maven-plugin.version}</version>
+				<version>${maven-build-helper-plugin.version}</version>
 				<executions>
 					<execution>
 						<phase>generate-sources</phase>
@@ -353,7 +355,7 @@
 			<plugin>
 				<groupId>io.github.zlika</groupId>
 				<artifactId>reproducible-build-maven-plugin</artifactId>
-				<version>${reproducible-build-maven-plugin.version}</version>
+				<version>${maven-reproducible-build-plugin.version}</version>
 				<executions>
 					<execution>
 						<phase>package</phase>
@@ -388,15 +390,9 @@
 							<pluginExecutions>
 								<pluginExecution>
 									<pluginExecutionFilter>
-										<groupId>
-											org.apache.maven.plugins
-										</groupId>
-										<artifactId>
-											maven-dependency-plugin
-										</artifactId>
-										<versionRange>
-											[3.6.0,)
-										</versionRange>
+										<groupId>org.apache.maven.plugins</groupId>
+										<artifactId>maven-dependency-plugin</artifactId>
+										<version>${maven-dependency-plugin.version}</version>
 										<goals>
 											<goal>unpack</goal>
 										</goals>
@@ -407,15 +403,9 @@
 								</pluginExecution>
 								<pluginExecution>
 									<pluginExecutionFilter>
-										<groupId>
-											com.google.code.maven-replacer-plugin
-										</groupId>
-										<artifactId>
-											replacer
-										</artifactId>
-										<versionRange>
-											[1.5.3,)
-										</versionRange>
+										<groupId>com.google.code.maven-replacer-plugin</groupId>
+										<artifactId>replacer</artifactId>
+										<version>${replacer.version}</version>
 										<goals>
 											<goal>replace</goal>
 										</goals>
@@ -448,7 +438,7 @@
 		<dependency>
 			<groupId>org.codehaus.mojo</groupId>
 			<artifactId>build-helper-maven-plugin</artifactId>
-			<version>${build-helper-maven-plugin.version}</version>
+			<version>${maven-build-helper-plugin.version}</version>
 			<scope>provided</scope>
 			<!-- needed for build, not for runtime -->
 		</dependency>
@@ -456,7 +446,7 @@
 		<dependency>
 			<groupId>com.github.bohnman</groupId>
 			<artifactId>package-info-maven-plugin</artifactId>
-			<version>${package-info-maven-plugin.version}</version>
+			<version>${maven-package-info-plugin.version}</version>
 			<scope>provided</scope>
 			<!-- needed for build, not for runtime -->
 		</dependency>

src/main/java/cash/z/wallet/sdk/rpc/Service.java

@@ -5290,7 +5290,7 @@ public final class Service {
       if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(vendor_)) {
         com.google.protobuf.GeneratedMessageV3.writeString(output, 2, vendor_);
       }
-      if (taddrSupport_ != false) {
+      if (taddrSupport_) {
         output.writeBool(3, taddrSupport_);
       }
       if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(chainName_)) {
@@ -5341,7 +5341,7 @@ public final class Service {
       if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(vendor_)) {
         size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, vendor_);
       }
-      if (taddrSupport_ != false) {
+      if (taddrSupport_) {
         size += com.google.protobuf.CodedOutputStream
           .computeBoolSize(3, taddrSupport_);
       }
@@ -5729,7 +5729,7 @@ public final class Service {
           vendor_ = other.vendor_;
           onChanged();
         }
-        if (other.getTaddrSupport() != false) {
+        if (other.getTaddrSupport()) {
           setTaddrSupport(other.getTaddrSupport());
         }
         if (!other.getChainName().isEmpty()) {

src/main/java/org/qortal/ApplyBootstrap.java

@@ -0,0 +1,227 @@
+package org.qortal;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.bouncycastle.jce.provider.BouncyCastleProvider;
+import org.bouncycastle.jsse.provider.BouncyCastleJsseProvider;
+import org.qortal.api.ApiKey;
+import org.qortal.api.ApiRequest;
+import org.qortal.controller.BootstrapNode;
+import org.qortal.settings.Settings;
+
+import java.io.IOException;
+import java.lang.management.ManagementFactory;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.SimpleFileVisitor;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.security.Security;
+import java.util.*;
+import java.util.stream.Collectors;
+
+import static org.qortal.controller.BootstrapNode.AGENTLIB_JVM_HOLDER_ARG;
+
+public class ApplyBootstrap {
+
+	static {
+		// This static block will be called before others if using ApplyBootstrap.main()
+
+		// Log into different files for bootstrap - this has to be before LogManger.getLogger() calls
+		System.setProperty("log4j2.filenameTemplate", "log-apply-bootstrap.txt");
+
+		// This must go before any calls to LogManager/Logger
+		System.setProperty("java.util.logging.manager", "org.apache.logging.log4j.jul.LogManager");
+	}
+
+	private static final Logger LOGGER = LogManager.getLogger(ApplyBootstrap.class);
+	private static final String JAR_FILENAME = BootstrapNode.JAR_FILENAME;
+	private static final String WINDOWS_EXE_LAUNCHER = "qortal.exe";
+	private static final String JAVA_TOOL_OPTIONS_NAME = "JAVA_TOOL_OPTIONS";
+	private static final String JAVA_TOOL_OPTIONS_VALUE = "";
+
+	private static final long CHECK_INTERVAL = 15 * 1000L; // ms
+	private static final int MAX_ATTEMPTS = 20;
+
+	public static void main(String[] args) {
+		Security.insertProviderAt(new BouncyCastleProvider(), 0);
+		Security.insertProviderAt(new BouncyCastleJsseProvider(), 1);
+
+		// Load/check settings, which potentially sets up blockchain config, etc.
+		if (args.length > 0)
+			Settings.fileInstance(args[0]);
+		else
+			Settings.getInstance();
+
+		LOGGER.info("Applying bootstrap...");
+
+		// Shutdown node using API
+		if (!shutdownNode())
+			return;
+
+		// Delete db
+		deleteDB();
+
+		// Restart node
+		restartNode(args);
+
+		LOGGER.info("Bootstrapping...");
+	}
+
+	private static boolean shutdownNode() {
+		String baseUri = "http://localhost:" + Settings.getInstance().getApiPort() + "/";
+		LOGGER.info(() -> String.format("Shutting down node using API via %s", baseUri));
+
+		// The /admin/stop endpoint requires an API key, which may or may not be already generated
+		boolean apiKeyNewlyGenerated = false;
+		ApiKey apiKey = null;
+		try {
+			apiKey = new ApiKey();
+			if (!apiKey.generated()) {
+				apiKey.generate();
+				apiKeyNewlyGenerated = true;
+				LOGGER.info("Generated API key");
+			}
+		} catch (IOException e) {
+			LOGGER.info("Error loading API key: {}", e.getMessage());
+		}
+
+		// Create GET params
+		Map<String, String> params = new HashMap<>();
+		if (apiKey != null) {
+			params.put("apiKey", apiKey.toString());
+		}
+
+		// Attempt to stop the node
+		int attempt;
+		for (attempt = 0; attempt < MAX_ATTEMPTS; ++attempt) {
+			final int attemptForLogging = attempt;
+			LOGGER.info(() -> String.format("Attempt #%d out of %d to shutdown node", attemptForLogging + 1, MAX_ATTEMPTS));
+			String response = ApiRequest.perform(baseUri + "admin/stop", params);
+			if (response == null) {
+				// No response - consider node shut down
+				if (apiKeyNewlyGenerated) {
+					// API key was newly generated for bootstrapping node, so we need to remove it
+					ApplyBootstrap.removeGeneratedApiKey();
+				}
+				return true;
+			}
+
+			LOGGER.info(() -> String.format("Response from API: %s", response));
+
+			try {
+				Thread.sleep(CHECK_INTERVAL);
+			} catch (InterruptedException e) {
+				// We still need to check...
+				break;
+			}
+		}
+
+		if (apiKeyNewlyGenerated) {
+			// API key was newly generated for bootstrapping node, so we need to remove it
+			ApplyBootstrap.removeGeneratedApiKey();
+		}
+
+		if (attempt == MAX_ATTEMPTS) {
+			LOGGER.error("Failed to shutdown node - giving up");
+			return false;
+		}
+
+		return true;
+	}
+
+	private static void removeGeneratedApiKey() {
+		try {
+			LOGGER.info("Removing newly generated API key...");
+
+			// Delete the API key since it was only generated for bootstrapping node
+			ApiKey apiKey = new ApiKey();
+			apiKey.delete();
+
+		} catch (IOException e) {
+			LOGGER.info("Error loading or deleting API key: {}", e.getMessage());
+		}
+	}
+
+	private static void deleteDB() {
+		// Get the repository path from settings
+		String repositoryPath = Settings.getInstance().getRepositoryPath();
+		LOGGER.debug(String.format("Repository path: %s", repositoryPath));
+
+		try {
+			Path directory = Paths.get(repositoryPath);
+			Files.walkFileTree(directory, new SimpleFileVisitor<Path>() {
+				@Override
+				public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
+					Files.delete(file);
+					return FileVisitResult.CONTINUE;
+				}
+
+				@Override
+				public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
+					Files.delete(dir);
+					return FileVisitResult.CONTINUE;
+				}
+			});
+		} catch (IOException e) {
+			LOGGER.error("Error deleting DB: {}", e.getMessage());
+		}
+	}
+
+	private static void restartNode(String[] args) {
+		String javaHome = System.getProperty("java.home");
+		LOGGER.debug(() -> String.format("Java home: %s", javaHome));
+
+		Path javaBinary = Paths.get(javaHome, "bin", "java");
+		LOGGER.debug(() -> String.format("Java binary: %s", javaBinary));
+
+		Path exeLauncher = Paths.get(WINDOWS_EXE_LAUNCHER);
+		LOGGER.debug(() -> String.format("Windows EXE launcher: %s", exeLauncher));
+
+		List<String> javaCmd;
+		if (Files.exists(exeLauncher)) {
+			javaCmd = Arrays.asList(exeLauncher.toString());
+		} else {
+			javaCmd = new ArrayList<>();
+			// Java runtime binary itself
+			javaCmd.add(javaBinary.toString());
+
+			// JVM arguments
+			javaCmd.addAll(ManagementFactory.getRuntimeMXBean().getInputArguments());
+
+			// Reapply any retained, but disabled, -agentlib JVM arg
+			javaCmd = javaCmd.stream()
+					.map(arg -> arg.replace(AGENTLIB_JVM_HOLDER_ARG, "-agentlib"))
+					.collect(Collectors.toList());
+
+			// Call mainClass in JAR
+			javaCmd.addAll(Arrays.asList("-jar", JAR_FILENAME));
+
+			// Add saved command-line args
+			javaCmd.addAll(Arrays.asList(args));
+		}
+
+		try {
+			LOGGER.info(String.format("Restarting node with: %s", String.join(" ", javaCmd)));
+
+			ProcessBuilder processBuilder = new ProcessBuilder(javaCmd);
+
+			if (Files.exists(exeLauncher)) {
+				LOGGER.debug(() -> String.format("Setting env %s to %s", JAVA_TOOL_OPTIONS_NAME, JAVA_TOOL_OPTIONS_VALUE));
+				processBuilder.environment().put(JAVA_TOOL_OPTIONS_NAME, JAVA_TOOL_OPTIONS_VALUE);
+			}
+
+			// New process will inherit our stdout and stderr
+			processBuilder.redirectOutput(ProcessBuilder.Redirect.INHERIT);
+			processBuilder.redirectError(ProcessBuilder.Redirect.INHERIT);
+
+			Process process = processBuilder.start();
+
+			// Nothing to pipe to new process, so close output stream (process's stdin)
+			process.getOutputStream().close();
+		} catch (Exception e) {
+			LOGGER.error(String.format("Failed to restart node (BAD): %s", e.getMessage()));
+		}
+	}
+}

src/main/java/org/qortal/ApplyRestart.java

@@ -0,0 +1,196 @@
+package org.qortal;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.bouncycastle.jce.provider.BouncyCastleProvider;
+import org.bouncycastle.jsse.provider.BouncyCastleJsseProvider;
+import org.qortal.api.ApiKey;
+import org.qortal.api.ApiRequest;
+import org.qortal.controller.RestartNode;
+import org.qortal.settings.Settings;
+
+import java.io.IOException;
+import java.lang.management.ManagementFactory;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.security.Security;
+import java.util.*;
+import java.util.stream.Collectors;
+
+import static org.qortal.controller.RestartNode.AGENTLIB_JVM_HOLDER_ARG;
+
+public class ApplyRestart {
+
+	static {
+		// This static block will be called before others if using ApplyRestart.main()
+
+		// Log into different files for restart node - this has to be before LogManger.getLogger() calls
+		System.setProperty("log4j2.filenameTemplate", "log-apply-restart.txt");
+
+		// This must go before any calls to LogManager/Logger
+		System.setProperty("java.util.logging.manager", "org.apache.logging.log4j.jul.LogManager");
+	}
+
+	private static final Logger LOGGER = LogManager.getLogger(ApplyRestart.class);
+	private static final String JAR_FILENAME = RestartNode.JAR_FILENAME;
+	private static final String WINDOWS_EXE_LAUNCHER = "qortal.exe";
+	private static final String JAVA_TOOL_OPTIONS_NAME = "JAVA_TOOL_OPTIONS";
+	private static final String JAVA_TOOL_OPTIONS_VALUE = "";
+
+	private static final long CHECK_INTERVAL = 10 * 1000L; // ms
+	private static final int MAX_ATTEMPTS = 12;
+
+	public static void main(String[] args) {
+		Security.insertProviderAt(new BouncyCastleProvider(), 0);
+		Security.insertProviderAt(new BouncyCastleJsseProvider(), 1);
+
+		// Load/check settings, which potentially sets up blockchain config, etc.
+		if (args.length > 0)
+			Settings.fileInstance(args[0]);
+		else
+			Settings.getInstance();
+
+		LOGGER.info("Applying restart...");
+
+		// Shutdown node using API
+		if (!shutdownNode())
+			return;
+
+		// Restart node
+		restartNode(args);
+
+		LOGGER.info("Restarting...");
+	}
+
+	private static boolean shutdownNode() {
+		String baseUri = "http://localhost:" + Settings.getInstance().getApiPort() + "/";
+		LOGGER.info(() -> String.format("Shutting down node using API via %s", baseUri));
+
+		// The /admin/stop endpoint requires an API key, which may or may not be already generated
+		boolean apiKeyNewlyGenerated = false;
+		ApiKey apiKey = null;
+		try {
+			apiKey = new ApiKey();
+			if (!apiKey.generated()) {
+				apiKey.generate();
+				apiKeyNewlyGenerated = true;
+				LOGGER.info("Generated API key");
+			}
+		} catch (IOException e) {
+			LOGGER.info("Error loading API key: {}", e.getMessage());
+		}
+
+		// Create GET params
+		Map<String, String> params = new HashMap<>();
+		if (apiKey != null) {
+			params.put("apiKey", apiKey.toString());
+		}
+
+		// Attempt to stop the node
+		int attempt;
+		for (attempt = 0; attempt < MAX_ATTEMPTS; ++attempt) {
+			final int attemptForLogging = attempt;
+			LOGGER.info(() -> String.format("Attempt #%d out of %d to shutdown node", attemptForLogging + 1, MAX_ATTEMPTS));
+			String response = ApiRequest.perform(baseUri + "admin/stop", params);
+			if (response == null) {
+				// No response - consider node shut down
+				if (apiKeyNewlyGenerated) {
+					// API key was newly generated for restarting node, so we need to remove it
+					ApplyRestart.removeGeneratedApiKey();
+				}
+				return true;
+			}
+
+			LOGGER.info(() -> String.format("Response from API: %s", response));
+
+			try {
+				Thread.sleep(CHECK_INTERVAL);
+			} catch (InterruptedException e) {
+				// We still need to check...
+				break;
+			}
+		}
+
+		if (apiKeyNewlyGenerated) {
+			// API key was newly generated for restarting node, so we need to remove it
+			ApplyRestart.removeGeneratedApiKey();
+		}
+
+		if (attempt == MAX_ATTEMPTS) {
+			LOGGER.error("Failed to shutdown node - giving up");
+			return false;
+		}
+
+		return true;
+	}
+
+	private static void removeGeneratedApiKey() {
+		try {
+			LOGGER.info("Removing newly generated API key...");
+
+			// Delete the API key since it was only generated for restarting node
+			ApiKey apiKey = new ApiKey();
+			apiKey.delete();
+
+		} catch (IOException e) {
+			LOGGER.info("Error loading or deleting API key: {}", e.getMessage());
+		}
+	}
+
+	private static void restartNode(String[] args) {
+		String javaHome = System.getProperty("java.home");
+		LOGGER.debug(() -> String.format("Java home: %s", javaHome));
+
+		Path javaBinary = Paths.get(javaHome, "bin", "java");
+		LOGGER.debug(() -> String.format("Java binary: %s", javaBinary));
+
+		Path exeLauncher = Paths.get(WINDOWS_EXE_LAUNCHER);
+		LOGGER.debug(() -> String.format("Windows EXE launcher: %s", exeLauncher));
+
+		List<String> javaCmd;
+		if (Files.exists(exeLauncher)) {
+			javaCmd = Arrays.asList(exeLauncher.toString());
+		} else {
+			javaCmd = new ArrayList<>();
+			// Java runtime binary itself
+			javaCmd.add(javaBinary.toString());
+
+			// JVM arguments
+			javaCmd.addAll(ManagementFactory.getRuntimeMXBean().getInputArguments());
+
+			// Reapply any retained, but disabled, -agentlib JVM arg
+			javaCmd = javaCmd.stream()
+					.map(arg -> arg.replace(AGENTLIB_JVM_HOLDER_ARG, "-agentlib"))
+					.collect(Collectors.toList());
+
+			// Call mainClass in JAR
+			javaCmd.addAll(Arrays.asList("-jar", JAR_FILENAME));
+
+			// Add saved command-line args
+			javaCmd.addAll(Arrays.asList(args));
+		}
+
+		try {
+			LOGGER.debug(String.format("Restarting node with: %s", String.join(" ", javaCmd)));
+
+			ProcessBuilder processBuilder = new ProcessBuilder(javaCmd);
+
+			if (Files.exists(exeLauncher)) {
+				LOGGER.debug(() -> String.format("Setting env %s to %s", JAVA_TOOL_OPTIONS_NAME, JAVA_TOOL_OPTIONS_VALUE));
+				processBuilder.environment().put(JAVA_TOOL_OPTIONS_NAME, JAVA_TOOL_OPTIONS_VALUE);
+			}
+
+			// New process will inherit our stdout and stderr
+			processBuilder.redirectOutput(ProcessBuilder.Redirect.INHERIT);
+			processBuilder.redirectError(ProcessBuilder.Redirect.INHERIT);
+
+			Process process = processBuilder.start();
+
+			// Nothing to pipe to new process, so close output stream (process's stdin)
+			process.getOutputStream().close();
+		} catch (Exception e) {
+			LOGGER.error(String.format("Failed to restart node (BAD): %s", e.getMessage()));
+		}
+	}
+}

src/main/java/org/qortal/ApplyUpdate.java

@@ -38,7 +38,7 @@ public class ApplyUpdate {
 	private static final String NEW_JAR_FILENAME = AutoUpdate.NEW_JAR_FILENAME;
 	private static final String WINDOWS_EXE_LAUNCHER = "qortal.exe";
 	private static final String JAVA_TOOL_OPTIONS_NAME = "JAVA_TOOL_OPTIONS";
-	private static final String JAVA_TOOL_OPTIONS_VALUE = "-XX:MaxRAMFraction=4";
+	private static final String JAVA_TOOL_OPTIONS_VALUE = "";
 
 	private static final long CHECK_INTERVAL = 30 * 1000L; // ms
 	private static final int MAX_ATTEMPTS = 12;
@@ -139,7 +139,7 @@ public class ApplyUpdate {
 			apiKey.delete();
 
 		} catch (IOException e) {
-			LOGGER.info("Error loading or deleting API key: {}", e.getMessage());
+			LOGGER.error("Error loading or deleting API key: {}", e.getMessage());
 		}
 	}
 
@@ -181,13 +181,13 @@ public class ApplyUpdate {
 
 	private static void restartNode(String[] args) {
 		String javaHome = System.getProperty("java.home");
-		LOGGER.info(() -> String.format("Java home: %s", javaHome));
+		LOGGER.debug(() -> String.format("Java home: %s", javaHome));
 
 		Path javaBinary = Paths.get(javaHome, "bin", "java");
-		LOGGER.info(() -> String.format("Java binary: %s", javaBinary));
+		LOGGER.debug(() -> String.format("Java binary: %s", javaBinary));
 
 		Path exeLauncher = Paths.get(WINDOWS_EXE_LAUNCHER);
-		LOGGER.info(() -> String.format("Windows EXE launcher: %s", exeLauncher));
+		LOGGER.debug(() -> String.format("Windows EXE launcher: %s", exeLauncher));
 
 		List<String> javaCmd;
 		if (Files.exists(exeLauncher)) {
@@ -213,12 +213,12 @@ public class ApplyUpdate {
 		}
 
 		try {
-			LOGGER.info(String.format("Restarting node with: %s", String.join(" ", javaCmd)));
+			LOGGER.debug(String.format("Restarting node with: %s", String.join(" ", javaCmd)));
 
 			ProcessBuilder processBuilder = new ProcessBuilder(javaCmd);
 
 			if (Files.exists(exeLauncher)) {
-				LOGGER.info(() -> String.format("Setting env %s to %s", JAVA_TOOL_OPTIONS_NAME, JAVA_TOOL_OPTIONS_VALUE));
+				LOGGER.debug(() -> String.format("Setting env %s to %s", JAVA_TOOL_OPTIONS_NAME, JAVA_TOOL_OPTIONS_VALUE));
 				processBuilder.environment().put(JAVA_TOOL_OPTIONS_NAME, JAVA_TOOL_OPTIONS_VALUE);
 			}
 

src/main/java/org/qortal/account/SelfSponsorshipAlgoV1.java

@@ -340,7 +340,7 @@ public class SelfSponsorshipAlgoV1 {
             return true;
         }
         transactionDataList.removeIf(t -> t.getTimestamp() >= this.snapshotTimestamp);
-        return transactionDataList.size() == 0;
+        return transactionDataList.isEmpty();
     }
 
     private static List<TransactionData> fetchTransactions(Repository repository, List<TransactionType> txTypes, String address, boolean reverse) throws DataException {
@@ -363,5 +363,4 @@ public class SelfSponsorshipAlgoV1 {
 
         return transactionDataList;
     }
-
-}
+}

src/main/java/org/qortal/account/SelfSponsorshipAlgoV2.java

@@ -0,0 +1,249 @@
+package org.qortal.account;
+
+import org.qortal.api.resource.TransactionsResource;
+import org.qortal.asset.Asset;
+import org.qortal.block.BlockChain;
+import org.qortal.data.account.AccountData;
+import org.qortal.data.transaction.*;
+import org.qortal.repository.DataException;
+import org.qortal.repository.Repository;
+import org.qortal.transaction.Transaction.TransactionType;
+
+import java.util.*;
+
+public class SelfSponsorshipAlgoV2 {
+
+    private final long snapshotTimestampV1 = BlockChain.getInstance().getSelfSponsorshipAlgoV1SnapshotTimestamp();
+    private final long snapshotTimestampV2 = BlockChain.getInstance().getSelfSponsorshipAlgoV2SnapshotTimestamp();
+    private final long referenceTimestamp = BlockChain.getInstance().getReferenceTimestampBlock();
+
+    private final boolean override;
+    private final Repository repository;
+    private final String address;
+
+    private int recentAssetSendCount  = 0;
+    private int recentSponsorshipCount = 0;
+
+    private final Set<String> assetAddresses = new LinkedHashSet<>();
+    private final Set<String> penaltyAddresses = new LinkedHashSet<>();
+    private final Set<String> sponsorAddresses = new LinkedHashSet<>();
+
+    private List<RewardShareTransactionData> sponsorshipRewardShares = new ArrayList<>();
+    private List<TransferAssetTransactionData> transferAssetForAddress = new ArrayList<>();
+
+    public SelfSponsorshipAlgoV2(Repository repository, String address, boolean override) {
+        this.repository = repository;
+        this.address = address;
+        this.override = override;
+    }
+
+    public String getAddress() {
+        return this.address;
+    }
+
+    public Set<String> getPenaltyAddresses() {
+        return this.penaltyAddresses;
+    }
+
+    public void run() throws DataException {
+        if (!override) {
+            this.getAccountPrivs(this.address);
+        }
+
+        if (override) {
+            this.fetchTransferAssetForAddress(this.address);
+            this.findRecentAssetSendCount();
+
+            if (this.recentAssetSendCount >= 6) {
+                this.penaltyAddresses.add(this.address);
+                this.penaltyAddresses.addAll(this.assetAddresses);
+            }
+        }
+    }
+
+    private void getAccountPrivs(String address) throws DataException {
+        AccountData accountData = this.repository.getAccountRepository().getAccount(address);
+        List<TransactionData> transferPrivsTransactions = fetchTransferPrivsForAddress(address);
+        transferPrivsTransactions.removeIf(t -> t.getTimestamp() > this.referenceTimestamp || accountData.getAddress().equals(t.getRecipient()));
+
+        if (transferPrivsTransactions.isEmpty()) {
+            // Nothing to do
+            return;
+        }
+
+        for (TransactionData transactionData : transferPrivsTransactions) {
+            TransferPrivsTransactionData transferPrivsTransactionData = (TransferPrivsTransactionData) transactionData;
+            this.penaltyAddresses.add(transferPrivsTransactionData.getRecipient());
+            this.fetchSponsorshipRewardShares(transferPrivsTransactionData.getRecipient());
+            this.findRecentSponsorshipCount();
+
+            if (this.recentSponsorshipCount >= 1) {
+                this.penaltyAddresses.addAll(this.sponsorAddresses);
+            }
+
+            String newAddress = this.getDestinationAccount(transferPrivsTransactionData.getRecipient());
+
+            while (newAddress != null) {
+                // Found destination account
+                this.penaltyAddresses.add(newAddress);
+                this.fetchSponsorshipRewardShares(newAddress);
+                this.findRecentSponsorshipCount();
+
+                if (this.recentSponsorshipCount >= 1) {
+                    this.penaltyAddresses.addAll(this.sponsorAddresses);
+                }
+
+                newAddress = this.getDestinationAccount(newAddress);
+            }
+        }
+    }
+
+    private String getDestinationAccount(String address) throws DataException {
+        AccountData accountData = this.repository.getAccountRepository().getAccount(address);
+        List<TransactionData> transferPrivsTransactions = fetchTransferPrivsForAddress(address);
+        transferPrivsTransactions.removeIf(t -> t.getTimestamp() > this.referenceTimestamp || accountData.getAddress().equals(t.getRecipient()));
+
+        if (transferPrivsTransactions.isEmpty()) {
+            return null;
+        }
+
+        if (accountData == null) {
+            return null;
+        }
+
+        for (TransactionData transactionData : transferPrivsTransactions) {
+            TransferPrivsTransactionData transferPrivsTransactionData = (TransferPrivsTransactionData) transactionData;
+            if (Arrays.equals(transferPrivsTransactionData.getSenderPublicKey(), accountData.getPublicKey())) {
+                return transferPrivsTransactionData.getRecipient();
+            }
+        }
+
+        return null;
+    }
+
+    private void fetchSponsorshipRewardShares(String address) throws DataException {
+        AccountData accountDataRs = this.repository.getAccountRepository().getAccount(address);
+        List<RewardShareTransactionData> sponsorshipRewardShares = new ArrayList<>();
+
+        // Define relevant transactions
+        List<TransactionType> txTypes = List.of(TransactionType.REWARD_SHARE);
+        List<TransactionData> transactionDataList = fetchTransactions(repository, txTypes, address, false);
+
+        for (TransactionData transactionData : transactionDataList) {
+            if (transactionData.getType() != TransactionType.REWARD_SHARE) {
+                continue;
+            }
+
+            RewardShareTransactionData rewardShareTransactionData = (RewardShareTransactionData) transactionData;
+
+            // Skip removals
+            if (rewardShareTransactionData.getSharePercent() < 0) {
+                continue;
+            }
+
+            // Skip if not sponsored by this account
+            if (!Arrays.equals(rewardShareTransactionData.getCreatorPublicKey(), accountDataRs.getPublicKey())) {
+                continue;
+            }
+
+            // Skip self shares
+            if (Objects.equals(rewardShareTransactionData.getRecipient(), address)) {
+                continue;
+            }
+
+            boolean duplicateFound = false;
+            for (RewardShareTransactionData existingRewardShare : sponsorshipRewardShares) {
+                if (Objects.equals(existingRewardShare.getRecipient(), rewardShareTransactionData.getRecipient())) {
+                    // Duplicate
+                    duplicateFound = true;
+                    break;
+                }
+            }
+
+            if (!duplicateFound) {
+                sponsorshipRewardShares.add(rewardShareTransactionData);
+                this.sponsorAddresses.add(rewardShareTransactionData.getRecipient());
+            }
+        }
+
+        this.sponsorshipRewardShares = sponsorshipRewardShares;
+    }
+
+    private void fetchTransferAssetForAddress(String address) throws DataException {
+        List<TransferAssetTransactionData> transferAssetForAddress = new ArrayList<>();
+
+        // Define relevant transactions
+        List<TransactionType> txTypes = List.of(TransactionType.TRANSFER_ASSET);
+        List<TransactionData> transactionDataList = fetchTransactions(repository, txTypes, address, false);
+        transactionDataList.removeIf(t -> t.getTimestamp() <= this.snapshotTimestampV1 || t.getTimestamp() >= this.snapshotTimestampV2);
+
+        for (TransactionData transactionData : transactionDataList) {
+            if (transactionData.getType() != TransactionType.TRANSFER_ASSET) {
+                continue;
+            }
+
+            TransferAssetTransactionData transferAssetTransactionData = (TransferAssetTransactionData) transactionData;
+
+            if (transferAssetTransactionData.getAssetId() == Asset.QORT) {
+                if (!Objects.equals(transferAssetTransactionData.getRecipient(), address)) {
+                    // Outgoing transfer asset for this account
+                    transferAssetForAddress.add(transferAssetTransactionData);
+                    this.assetAddresses.add(transferAssetTransactionData.getRecipient());
+                }
+            }
+        }
+
+        this.transferAssetForAddress = transferAssetForAddress;
+    }
+
+    private void findRecentSponsorshipCount() {
+        int recentSponsorshipCount = 0;
+
+        for (RewardShareTransactionData rewardShare : sponsorshipRewardShares) {
+            if (rewardShare.getTimestamp() >= this.snapshotTimestampV1) {
+                recentSponsorshipCount++;
+            }
+        }
+
+        this.recentSponsorshipCount = recentSponsorshipCount;
+    }
+
+    private void findRecentAssetSendCount() {
+        int recentAssetSendCount = 0;
+
+        for (TransferAssetTransactionData assetSend : transferAssetForAddress) {
+            if (assetSend.getTimestamp() >= this.snapshotTimestampV1) {
+                recentAssetSendCount++;
+            }
+        }
+
+        this.recentAssetSendCount = recentAssetSendCount;
+    }
+
+    private List<TransactionData> fetchTransferPrivsForAddress(String address) throws DataException {
+        return fetchTransactions(repository,
+                List.of(TransactionType.TRANSFER_PRIVS),
+                address, true);
+    }
+
+    private static List<TransactionData> fetchTransactions(Repository repository, List<TransactionType> txTypes, String address, boolean reverse) throws DataException {
+        // Fetch all relevant transactions for this account
+        List<byte[]> signatures = repository.getTransactionRepository()
+                .getSignaturesMatchingCriteria(null, null, null, txTypes,
+                        null, null, address, TransactionsResource.ConfirmationStatus.CONFIRMED,
+                        null, null, reverse);
+
+        List<TransactionData> transactionDataList = new ArrayList<>();
+
+        for (byte[] signature : signatures) {
+            // Fetch transaction data
+            TransactionData transactionData = repository.getTransactionRepository().fromSignature(signature);
+            if (transactionData == null) {
+                continue;
+            }
+            transactionDataList.add(transactionData);
+        }
+
+        return transactionDataList;
+    }
+}

src/main/java/org/qortal/account/SelfSponsorshipAlgoV3.java

@@ -0,0 +1,370 @@
+package org.qortal.account;
+
+import org.qortal.api.resource.TransactionsResource;
+import org.qortal.asset.Asset;
+import org.qortal.data.account.AccountData;
+import org.qortal.data.naming.NameData;
+import org.qortal.data.transaction.*;
+import org.qortal.repository.DataException;
+import org.qortal.repository.Repository;
+import org.qortal.transaction.Transaction.TransactionType;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class SelfSponsorshipAlgoV3 {
+
+    private final Repository repository;
+    private final String address;
+    private final AccountData accountData;
+    private final long snapshotTimestampV1;
+    private final long snapshotTimestampV3;
+    private final boolean override;
+
+    private int registeredNameCount = 0;
+    private int suspiciousCount = 0;
+    private int suspiciousPercent = 0;
+    private int consolidationCount = 0;
+    private int bulkIssuanceCount = 0;
+    private int recentSponsorshipCount = 0;
+
+    private List<RewardShareTransactionData> sponsorshipRewardShares = new ArrayList<>();
+    private final Map<String, List<TransactionData>> paymentsByAddress = new HashMap<>();
+    private final Set<String> sponsees = new LinkedHashSet<>();
+    private Set<String> consolidatedAddresses = new LinkedHashSet<>();
+    private final Set<String> zeroTransactionAddreses = new LinkedHashSet<>();
+    private final Set<String> penaltyAddresses = new LinkedHashSet<>();
+
+    public SelfSponsorshipAlgoV3(Repository repository, String address, long snapshotTimestampV1, long snapshotTimestampV3, boolean override) throws DataException {
+        this.repository = repository;
+        this.address = address;
+        this.accountData = this.repository.getAccountRepository().getAccount(this.address);
+        this.snapshotTimestampV1 = snapshotTimestampV1;
+        this.snapshotTimestampV3 = snapshotTimestampV3;
+        this.override = override;
+    }
+
+    public String getAddress() {
+        return this.address;
+    }
+
+    public Set<String> getPenaltyAddresses() {
+        return this.penaltyAddresses;
+    }
+
+
+    public void run() throws DataException {
+        if (this.accountData == null) {
+            // Nothing to do
+            return;
+        }
+
+        this.fetchSponsorshipRewardShares();
+        if (this.sponsorshipRewardShares.isEmpty()) {
+            // Nothing to do
+            return;
+        }
+
+        this.findConsolidatedRewards();
+        this.findBulkIssuance();
+        this.findRegisteredNameCount();
+        this.findRecentSponsorshipCount();
+
+        int score = this.calculateScore();
+        if (score <= 0 && !override) {
+            return;
+        }
+
+        String newAddress = this.getDestinationAccount(this.address);
+        while (newAddress != null) {
+            // Found destination account
+            this.penaltyAddresses.add(newAddress);
+
+            // Run algo for this address, but in "override" mode because it has already been flagged
+            SelfSponsorshipAlgoV3 algoV3 = new SelfSponsorshipAlgoV3(this.repository, newAddress, this.snapshotTimestampV1, this.snapshotTimestampV3, true);
+            algoV3.run();
+            this.penaltyAddresses.addAll(algoV3.getPenaltyAddresses());
+
+            newAddress = this.getDestinationAccount(newAddress);
+        }
+
+        this.penaltyAddresses.add(this.address);
+
+        if (this.override || this.recentSponsorshipCount < 20) {
+            this.penaltyAddresses.addAll(this.consolidatedAddresses);
+            this.penaltyAddresses.addAll(this.zeroTransactionAddreses);
+        }
+        else {
+            this.penaltyAddresses.addAll(this.sponsees);
+        }
+    }
+
+    private String getDestinationAccount(String address) throws DataException {
+        List<TransactionData> transferPrivsTransactions = fetchTransferPrivsForAddress(address);
+        if (transferPrivsTransactions.isEmpty()) {
+            // No TRANSFER_PRIVS transactions for this address
+            return null;
+        }
+
+        AccountData accountData = this.repository.getAccountRepository().getAccount(address);
+        if (accountData == null) {
+            return null;
+        }
+
+        for (TransactionData transactionData : transferPrivsTransactions) {
+            TransferPrivsTransactionData transferPrivsTransactionData = (TransferPrivsTransactionData) transactionData;
+            if (Arrays.equals(transferPrivsTransactionData.getSenderPublicKey(), accountData.getPublicKey())) {
+                return transferPrivsTransactionData.getRecipient();
+            }
+        }
+
+        return null;
+    }
+
+    private void findConsolidatedRewards() throws DataException {
+        List<String> sponseesThatSentRewards = new ArrayList<>();
+        Map<String, Integer> paymentRecipients = new HashMap<>();
+
+        // Collect outgoing payments of each sponsee
+        for (String sponseeAddress : this.sponsees) {
+
+            // Firstly fetch all payments for address, since the functions below depend on this data
+            this.fetchPaymentsForAddress(sponseeAddress);
+
+            // Check if the address has zero relevant transactions
+            if (this.hasZeroTransactions(sponseeAddress)) {
+                this.zeroTransactionAddreses.add(sponseeAddress);
+            }
+
+            // Get payment recipients
+            List<String> allPaymentRecipients = this.fetchOutgoingPaymentRecipientsForAddress(sponseeAddress);
+            if (allPaymentRecipients.isEmpty()) {
+                continue;
+            }
+            sponseesThatSentRewards.add(sponseeAddress);
+
+            List<String> addressesPaidByThisSponsee = new ArrayList<>();
+            for (String paymentRecipient : allPaymentRecipients) {
+                if (addressesPaidByThisSponsee.contains(paymentRecipient)) {
+                    // We already tracked this association - don't allow multiple to stack up
+                    continue;
+                }
+                addressesPaidByThisSponsee.add(paymentRecipient);
+
+                // Increment count for this recipient, or initialize to 1 if not present
+                if (paymentRecipients.computeIfPresent(paymentRecipient, (k, v) -> v + 1) == null) {
+                    paymentRecipients.put(paymentRecipient, 1);
+                }
+            }
+
+        }
+
+        // Exclude addresses with a low number of payments
+        Map<String, Integer> filteredPaymentRecipients = paymentRecipients.entrySet().stream()
+                .filter(p -> p.getValue() != null && p.getValue() >= 10)
+                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+
+        // Now check how many sponsees have sent to this subset of addresses
+        Map<String, Integer> sponseesThatConsolidatedRewards = new HashMap<>();
+        for (String sponseeAddress : sponseesThatSentRewards) {
+            List<String> allPaymentRecipients = this.fetchOutgoingPaymentRecipientsForAddress(sponseeAddress);
+            // Remove any that aren't to one of the flagged recipients (i.e. consolidation)
+            allPaymentRecipients.removeIf(r -> !filteredPaymentRecipients.containsKey(r));
+
+            int count = allPaymentRecipients.size();
+            if (count == 0) {
+                continue;
+            }
+            if (sponseesThatConsolidatedRewards.computeIfPresent(sponseeAddress, (k, v) -> v + count) == null) {
+                sponseesThatConsolidatedRewards.put(sponseeAddress, count);
+            }
+        }
+
+        // Remove sponsees that have only sent a low number of payments to the filtered addresses
+        Map<String, Integer> filteredSponseesThatConsolidatedRewards = sponseesThatConsolidatedRewards.entrySet().stream()
+                .filter(p -> p.getValue() != null && p.getValue() >= 2)
+                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+
+        this.consolidationCount = sponseesThatConsolidatedRewards.size();
+        this.consolidatedAddresses = new LinkedHashSet<>(filteredSponseesThatConsolidatedRewards.keySet());
+        this.suspiciousCount = this.consolidationCount + this.zeroTransactionAddreses.size();
+        this.suspiciousPercent = (int)(this.suspiciousCount / (float) this.sponsees.size() * 100);
+    }
+
+    private void findBulkIssuance() {
+        Long lastTimestamp = null;
+        for (RewardShareTransactionData rewardShareTransactionData : sponsorshipRewardShares) {
+            long timestamp = rewardShareTransactionData.getTimestamp();
+            if (timestamp >= this.snapshotTimestampV3) {
+                continue;
+            }
+
+            if (lastTimestamp != null) {
+                if (timestamp - lastTimestamp < 3*60*1000L) {
+                    this.bulkIssuanceCount++;
+                }
+            }
+            lastTimestamp = timestamp;
+        }
+    }
+
+    private void findRegisteredNameCount() throws DataException {
+        int registeredNameCount = 0;
+        for (String sponseeAddress : sponsees) {
+            List<NameData> names = repository.getNameRepository().getNamesByOwner(sponseeAddress);
+            for (NameData name : names) {
+                if (name.getRegistered() < this.snapshotTimestampV3) {
+                    registeredNameCount++;
+                    break;
+                }
+            }
+        }
+        this.registeredNameCount = registeredNameCount;
+    }
+
+    private void findRecentSponsorshipCount() {
+        int recentSponsorshipCount = 0;
+        for (RewardShareTransactionData rewardShare : sponsorshipRewardShares) {
+            if (rewardShare.getTimestamp() >= this.snapshotTimestampV1) {
+                recentSponsorshipCount++;
+            }
+        }
+        this.recentSponsorshipCount = recentSponsorshipCount;
+    }
+
+    private int calculateScore() {
+        final int suspiciousMultiplier = (this.suspiciousCount >= 100) ? this.suspiciousPercent : 1;
+        final int nameMultiplier = (this.sponsees.size() >= 25 && this.registeredNameCount <= 1) ? 21 :
+            (this.sponsees.size() >= 15 && this.registeredNameCount <= 1) ? 11 :
+                (this.sponsees.size() >= 5 && this.registeredNameCount <= 1) ? 5 : 1;
+        final int consolidationMultiplier = Math.max(this.consolidationCount, 1);
+        final int bulkIssuanceMultiplier = Math.max(this.bulkIssuanceCount / 2, 1);
+        final int offset = 20;
+        return suspiciousMultiplier * nameMultiplier * consolidationMultiplier * bulkIssuanceMultiplier - offset;
+    }
+
+    private void fetchSponsorshipRewardShares() throws DataException {
+        List<RewardShareTransactionData> sponsorshipRewardShares = new ArrayList<>();
+
+        // Define relevant transactions
+        List<TransactionType> txTypes = List.of(TransactionType.REWARD_SHARE);
+        List<TransactionData> transactionDataList = fetchTransactions(repository, txTypes, this.address, false);
+        transactionDataList.removeIf(t -> t.getTimestamp() <= this.snapshotTimestampV1 || t.getTimestamp() >= this.snapshotTimestampV3);
+
+        for (TransactionData transactionData : transactionDataList) {
+            if (transactionData.getType() != TransactionType.REWARD_SHARE) {
+                continue;
+            }
+
+            RewardShareTransactionData rewardShareTransactionData = (RewardShareTransactionData) transactionData;
+
+            // Skip removals
+            if (rewardShareTransactionData.getSharePercent() < 0) {
+                continue;
+            }
+
+            // Skip if not sponsored by this account
+            if (!Arrays.equals(rewardShareTransactionData.getCreatorPublicKey(), accountData.getPublicKey())) {
+                continue;
+            }
+
+            // Skip self shares
+            if (Objects.equals(rewardShareTransactionData.getRecipient(), this.address)) {
+                continue;
+            }
+
+            boolean duplicateFound = false;
+            for (RewardShareTransactionData existingRewardShare : sponsorshipRewardShares) {
+                if (Objects.equals(existingRewardShare.getRecipient(), rewardShareTransactionData.getRecipient())) {
+                    // Duplicate
+                    duplicateFound = true;
+                    break;
+                }
+            }
+            if (!duplicateFound) {
+                sponsorshipRewardShares.add(rewardShareTransactionData);
+                this.sponsees.add(rewardShareTransactionData.getRecipient());
+            }
+        }
+
+        this.sponsorshipRewardShares = sponsorshipRewardShares;
+    }
+
+    private List<TransactionData> fetchTransferPrivsForAddress(String address) throws DataException {
+        return fetchTransactions(repository,
+                List.of(TransactionType.TRANSFER_PRIVS),
+                address, true);
+    }
+
+    private void fetchPaymentsForAddress(String address) throws DataException {
+        List<TransactionData> payments = fetchTransactions(repository,
+                Arrays.asList(TransactionType.PAYMENT, TransactionType.TRANSFER_ASSET),
+                address, false);
+        this.paymentsByAddress.put(address, payments);
+    }
+
+    private List<String> fetchOutgoingPaymentRecipientsForAddress(String address) {
+        List<String> outgoingPaymentRecipients = new ArrayList<>();
+
+        List<TransactionData> transactionDataList = this.paymentsByAddress.get(address);
+        if (transactionDataList == null) transactionDataList = new ArrayList<>();
+        transactionDataList.removeIf(t -> t.getTimestamp() <= this.snapshotTimestampV1 || t.getTimestamp() >= this.snapshotTimestampV3);
+        for (TransactionData transactionData : transactionDataList) {
+            switch (transactionData.getType()) {
+
+                case PAYMENT:
+                    PaymentTransactionData paymentTransactionData = (PaymentTransactionData) transactionData;
+                    if (!Objects.equals(paymentTransactionData.getRecipient(), address)) {
+                        // Outgoing payment from this account
+                        outgoingPaymentRecipients.add(paymentTransactionData.getRecipient());
+                    }
+                    break;
+
+                case TRANSFER_ASSET:
+                    TransferAssetTransactionData transferAssetTransactionData = (TransferAssetTransactionData) transactionData;
+                    if (transferAssetTransactionData.getAssetId() == Asset.QORT) {
+                        if (!Objects.equals(transferAssetTransactionData.getRecipient(), address)) {
+                            // Outgoing payment from this account
+                            outgoingPaymentRecipients.add(transferAssetTransactionData.getRecipient());
+                        }
+                    }
+                    break;
+
+                default:
+                    break;
+            }
+        }
+
+        return outgoingPaymentRecipients;
+    }
+
+    private boolean hasZeroTransactions(String address) {
+        List<TransactionData> transactionDataList = this.paymentsByAddress.get(address);
+        if (transactionDataList == null) {
+            return true;
+        }
+        transactionDataList.removeIf(t -> t.getTimestamp() <= this.snapshotTimestampV1 || t.getTimestamp() >= this.snapshotTimestampV3);
+        return transactionDataList.isEmpty();
+    }
+
+    private static List<TransactionData> fetchTransactions(Repository repository, List<TransactionType> txTypes, String address, boolean reverse) throws DataException {
+        // Fetch all relevant transactions for this account
+        List<byte[]> signatures = repository.getTransactionRepository()
+                .getSignaturesMatchingCriteria(null, null, null, txTypes,
+                        null, null, address, TransactionsResource.ConfirmationStatus.CONFIRMED,
+                        null, null, reverse);
+
+        List<TransactionData> transactionDataList = new ArrayList<>();
+
+        for (byte[] signature : signatures) {
+            // Fetch transaction data
+            TransactionData transactionData = repository.getTransactionRepository().fromSignature(signature);
+            if (transactionData == null) {
+                continue;
+            }
+            transactionDataList.add(transactionData);
+        }
+
+        return transactionDataList;
+    }
+}

src/main/java/org/qortal/api/ApiRequest.java

@@ -141,7 +141,7 @@ public class ApiRequest {
 		}
 
 		String resultString = result.toString();
-		return resultString.length() > 0 ? resultString.substring(0, resultString.length() - 1) : resultString;
+		return !resultString.isEmpty() ? resultString.substring(0, resultString.length() - 1) : resultString;
 	}
 
 	/**

src/main/java/org/qortal/api/HTMLParser.java

@@ -82,7 +82,7 @@ public class HTMLParser {
     }
 
     public static boolean isHtmlFile(String path) {
-        if (path.endsWith(".html") || path.endsWith(".htm") || path.equals("")) {
+        if (path.endsWith(".html") || path.endsWith(".htm") || path.isEmpty()) {
             return true;
         }
         return false;

src/main/java/org/qortal/api/SearchMode.java

@@ -2,5 +2,5 @@ package org.qortal.api;
 
 public enum SearchMode {
     LATEST,
-    ALL;
+    ALL
 }

src/main/java/org/qortal/api/gateway/resource/GatewayResource.java

@@ -41,7 +41,7 @@ public class GatewayResource {
     private ArbitraryResourceStatus getStatus(Service service, String name, String identifier, Boolean build) {
 
         // If "build=true" has been specified in the query string, build the resource before returning its status
-        if (build != null && build == true) {
+        if (build != null && build) {
             try {
                 ArbitraryDataReader reader = new ArbitraryDataReader(name, ArbitraryDataFile.ResourceIdType.NAME, service, null);
                 if (!reader.isBuilding()) {
@@ -80,7 +80,7 @@ public class GatewayResource {
     
     private HttpServletResponse parsePath(String inPath, String qdnContext, String secret58, boolean includeResourceIdInPrefix, boolean async) {
 
-        if (inPath == null || inPath.equals("")) {
+        if (inPath == null || inPath.isEmpty()) {
             // Assume not a real file
             return ArbitraryDataRenderer.getResponse(response, 404, "Error 404: File Not Found");
         }
@@ -140,7 +140,7 @@ public class GatewayResource {
         }
 
         String prefix = StringUtils.join(prefixParts, "/");
-        if (prefix != null && prefix.length() > 0) {
+        if (prefix != null && !prefix.isEmpty()) {
             prefix = "/" + prefix;
         }
 

src/main/java/org/qortal/api/model/ConnectedPeer.java

@@ -17,7 +17,7 @@ public class ConnectedPeer {
 
     public enum Direction {
         INBOUND,
-        OUTBOUND;
+        OUTBOUND
     }
 
     public Direction direction;

src/main/java/org/qortal/api/model/PollVotes.java

@@ -20,17 +20,25 @@ public class PollVotes {
     @Schema(description = "Total number of votes")
     public Integer totalVotes;
 
+    @Schema(description = "Total weight of votes")
+    public Integer totalWeight;
+
     @Schema(description = "List of vote counts for each option")
     public List<OptionCount> voteCounts;
 
+    @Schema(description = "List of vote weights for each option")
+    public List<OptionWeight> voteWeights;
+
     // For JAX-RS
     protected PollVotes() {
     }
 
-    public PollVotes(List<VoteOnPollData> votes, Integer totalVotes, List<OptionCount> voteCounts) {
+    public PollVotes(List<VoteOnPollData> votes, Integer totalVotes, Integer totalWeight, List<OptionCount> voteCounts, List<OptionWeight> voteWeights) {
         this.votes = votes;
         this.totalVotes = totalVotes;
+        this.totalWeight = totalWeight;
         this.voteCounts = voteCounts;
+        this.voteWeights = voteWeights;
     }
 
     @Schema(description = "Vote info")
@@ -52,4 +60,24 @@ public class PollVotes {
             this.voteCount = voteCount;
         }
     }
+
+    @Schema(description = "Vote weights")
+    // All properties to be converted to JSON via JAX-RS
+    @XmlAccessorType(XmlAccessType.FIELD)
+    public static class OptionWeight {
+        @Schema(description = "Option name")
+        public String optionName;
+
+        @Schema(description = "Vote weight")
+        public Integer voteWeight;
+
+        // For JAX-RS
+        protected OptionWeight() {
+        }
+
+        public OptionWeight(String optionName, Integer voteWeight) {
+            this.optionName = optionName;
+            this.voteWeight = voteWeight;
+        }
+    }
 }

src/main/java/org/qortal/api/resource/AddressesResource.java

@@ -233,8 +233,7 @@ public class AddressesResource {
 					}
 
 				} catch (DataException e) {
-					continue;
-				}
+                }
 			}
 
 			// Sort by level

src/main/java/org/qortal/api/resource/ArbitraryResource.java

@@ -119,7 +119,7 @@ public class ArbitraryResource {
 
 			// Ensure that "default" and "identifier" parameters cannot coexist
 			boolean defaultRes = Boolean.TRUE.equals(defaultResource);
-			if (defaultRes == true && identifier != null) {
+			if (defaultRes && identifier != null) {
 				throw ApiExceptionFactory.INSTANCE.createCustomException(request, ApiError.INVALID_CRITERIA, "identifier cannot be specified when requesting a default resource");
 			}
 
@@ -491,7 +491,7 @@ public class ArbitraryResource {
 			
 			List<ArbitraryTransactionData> transactionDataList;
 
-			if (query == null || query.equals("")) {
+			if (query == null || query.isEmpty()) {
 				transactionDataList = ArbitraryDataStorageManager.getInstance().listAllHostedTransactions(repository, limit, offset);
 			} else {
 				transactionDataList = ArbitraryDataStorageManager.getInstance().searchHostedTransactions(repository,query, limit, offset);
@@ -1258,7 +1258,7 @@ public class ArbitraryResource {
 			}
 
 			// Finish here if user has requested a preview
-			if (preview != null && preview == true) {
+			if (preview != null && preview) {
 				return this.preview(path, service);
 			}
 

src/main/java/org/qortal/api/resource/BlocksResource.java

@@ -86,7 +86,7 @@ public class BlocksResource {
 		    // Check the database first
 			BlockData blockData = repository.getBlockRepository().fromSignature(signature);
 			if (blockData != null) {
-				if (includeOnlineSignatures == null || includeOnlineSignatures == false) {
+				if (includeOnlineSignatures == null || !includeOnlineSignatures) {
 					blockData.setOnlineAccountsSignatures(null);
 				}
 				return blockData;
@@ -95,7 +95,7 @@ public class BlocksResource {
             // Not found, so try the block archive
 			blockData = repository.getBlockArchiveRepository().fromSignature(signature);
 			if (blockData != null) {
-				if (includeOnlineSignatures == null || includeOnlineSignatures == false) {
+				if (includeOnlineSignatures == null || !includeOnlineSignatures) {
 					blockData.setOnlineAccountsSignatures(null);
 				}
 				return blockData;
@@ -304,7 +304,7 @@ public class BlocksResource {
 		try (final Repository repository = RepositoryManager.getRepository()) {
 			BlockData blockData = repository.getBlockRepository().getLastBlock();
 
-			if (includeOnlineSignatures == null || includeOnlineSignatures == false) {
+			if (includeOnlineSignatures == null || !includeOnlineSignatures) {
 				blockData.setOnlineAccountsSignatures(null);
 			}
 
@@ -474,7 +474,7 @@ public class BlocksResource {
 			// Firstly check the database
 			BlockData blockData = repository.getBlockRepository().fromHeight(height);
 			if (blockData != null) {
-				if (includeOnlineSignatures == null || includeOnlineSignatures == false) {
+				if (includeOnlineSignatures == null || !includeOnlineSignatures) {
 					blockData.setOnlineAccountsSignatures(null);
 				}
 				return blockData;
@@ -483,7 +483,7 @@ public class BlocksResource {
 			// Not found, so try the archive
 			blockData = repository.getBlockArchiveRepository().fromHeight(height);
 			if (blockData != null) {
-				if (includeOnlineSignatures == null || includeOnlineSignatures == false) {
+				if (includeOnlineSignatures == null || !includeOnlineSignatures) {
 					blockData.setOnlineAccountsSignatures(null);
 				}
 				return blockData;
@@ -596,7 +596,7 @@ public class BlocksResource {
 			if (height > 1) {
 				// Found match in Blocks table
 				blockData = repository.getBlockRepository().fromHeight(height);
-				if (includeOnlineSignatures == null || includeOnlineSignatures == false) {
+				if (includeOnlineSignatures == null || !includeOnlineSignatures) {
 					blockData.setOnlineAccountsSignatures(null);
 				}
 				return blockData;
@@ -614,7 +614,7 @@ public class BlocksResource {
 				throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.BLOCK_UNKNOWN);
 			}
 
-			if (includeOnlineSignatures == null || includeOnlineSignatures == false) {
+			if (includeOnlineSignatures == null || !includeOnlineSignatures) {
 				blockData.setOnlineAccountsSignatures(null);
 			}
 
@@ -651,7 +651,7 @@ public class BlocksResource {
 										 @QueryParam("includeOnlineSignatures") Boolean includeOnlineSignatures) {
 		try (final Repository repository = RepositoryManager.getRepository()) {
 			List<BlockData> blocks = new ArrayList<>();
-			boolean shouldReverse = (reverse != null && reverse == true);
+			boolean shouldReverse = (reverse != null && reverse);
 
 			int i = 0;
 			while (i < count) {
@@ -664,7 +664,7 @@ public class BlocksResource {
 						break;
 					}
 				}
-				if (includeOnlineSignatures == null || includeOnlineSignatures == false) {
+				if (includeOnlineSignatures == null || !includeOnlineSignatures) {
 					blockData.setOnlineAccountsSignatures(null);
 				}
 

src/main/java/org/qortal/api/resource/CrossChainBitcoinResource.java

@@ -17,8 +17,13 @@ import org.qortal.api.model.crosschain.AddressRequest;
 import org.qortal.api.model.crosschain.BitcoinSendRequest;
 import org.qortal.crosschain.AddressInfo;
 import org.qortal.crosschain.Bitcoin;
+import org.qortal.crosschain.ChainableServer;
+import org.qortal.crosschain.ElectrumX;
 import org.qortal.crosschain.ForeignBlockchainException;
+import org.qortal.crosschain.ServerConnectionInfo;
+import org.qortal.crosschain.ServerInfo;
 import org.qortal.crosschain.SimpleTransaction;
+import org.qortal.crosschain.ServerConfigurationInfo;
 
 import javax.servlet.http.HttpServletRequest;
 import javax.ws.rs.GET;
@@ -188,45 +193,6 @@ public class CrossChainBitcoinResource {
 		}
 	}
 
-	@POST
-	@Path("/unusedaddress")
-	@Operation(
-		summary = "Returns first unused address for hierarchical, deterministic BIP32 wallet",
-		description = "Supply BIP32 'm' private/public key in base58, starting with 'xprv'/'xpub' for mainnet, 'tprv'/'tpub' for testnet",
-		requestBody = @RequestBody(
-			required = true,
-			content = @Content(
-				mediaType = MediaType.TEXT_PLAIN,
-				schema = @Schema(
-					type = "string",
-					description = "BIP32 'm' private/public key in base58",
-					example = "tpubD6NzVbkrYhZ4XTPc4btCZ6SMgn8CxmWkj6VBVZ1tfcJfMq4UwAjZbG8U74gGSypL9XBYk2R2BLbDBe8pcEyBKM1edsGQEPKXNbEskZozeZc"
-				)
-			)
-		),
-		responses = {
-			@ApiResponse(
-				content = @Content(array = @ArraySchema( schema = @Schema( implementation = SimpleTransaction.class ) ) )
-			)
-		}
-	)
-	@ApiErrors({ApiError.INVALID_PRIVATE_KEY, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE})
-	@SecurityRequirement(name = "apiKey")
-	public String getUnusedBitcoinReceiveAddress(@HeaderParam(Security.API_KEY_HEADER) String apiKey, String key58) {
-		Security.checkApiCallAllowed(request);
-
-		Bitcoin bitcoin = Bitcoin.getInstance();
-
-		if (!bitcoin.isValidDeterministicKey(key58))
-			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_PRIVATE_KEY);
-
-		try {
-			return bitcoin.getUnusedReceiveAddress(key58);
-		} catch (ForeignBlockchainException e) {
-			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE);
-		}
-	}
-
 	@POST
 	@Path("/send")
 	@Operation(
@@ -283,4 +249,312 @@ public class CrossChainBitcoinResource {
 		return spendTransaction.getTxId().toString();
 	}
 
+	@GET
+	@Path("/serverinfos")
+	@Operation(
+			summary = "Returns current Bitcoin server configuration",
+			description = "Returns current Bitcoin server locations and use status",
+			responses = {
+					@ApiResponse(
+							content = @Content(
+									mediaType = MediaType.APPLICATION_JSON,
+									schema = @Schema(
+											implementation = ServerConfigurationInfo.class
+									)
+							)
+					)
+			}
+	)
+	public ServerConfigurationInfo getServerConfiguration() {
+
+		return CrossChainUtils.buildServerConfigurationInfo(Bitcoin.getInstance());
+	}
+
+	@GET
+	@Path("/serverconnectionhistory")
+	@Operation(
+			summary = "Returns Bitcoin server connection history",
+			description = "Returns Bitcoin server connection history",
+			responses = {
+					@ApiResponse(
+							content = @Content(array = @ArraySchema( schema = @Schema( implementation = ServerConnectionInfo.class ) ) )
+					)
+			}
+	)
+	public List<ServerConnectionInfo> getServerConnectionHistory() {
+
+		return CrossChainUtils.buildServerConnectionHistory(Bitcoin.getInstance());
+	}
+
+	@POST
+	@Path("/addserver")
+	@Operation(
+			summary = "Add server to list of Bitcoin servers",
+			description = "Add server to list of Bitcoin servers",
+			requestBody = @RequestBody(
+					required = true,
+					content = @Content(
+							mediaType = MediaType.APPLICATION_JSON,
+							schema = @Schema(
+									implementation = ServerInfo.class
+							)
+					)
+			),
+			responses = {
+					@ApiResponse(
+							description = "true if added, false if not added",
+							content = @Content(
+									schema = @Schema(
+											type = "string"
+									)
+							)
+					)
+			}
+
+	)
+	@ApiErrors({ApiError.INVALID_DATA})
+	@SecurityRequirement(name = "apiKey")
+	public String addServer(@HeaderParam(Security.API_KEY_HEADER) String apiKey, ServerInfo serverInfo) {
+		Security.checkApiCallAllowed(request);
+
+		try {
+			ElectrumX.Server server = new ElectrumX.Server(
+					serverInfo.getHostName(),
+					ChainableServer.ConnectionType.valueOf(serverInfo.getConnectionType()),
+					serverInfo.getPort()
+			);
+
+			if( CrossChainUtils.addServer( Bitcoin.getInstance(), server )) {
+				return "true";
+			}
+			else {
+				return "false";
+			}
+		}
+		catch (IllegalArgumentException | NullPointerException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_DATA);
+		}
+		catch (Exception e) {
+			return "false";
+		}
+	}
+
+	@POST
+	@Path("/removeserver")
+	@Operation(
+			summary = "Remove server from list of Bitcoin servers",
+			description = "Remove server from list of Bitcoin servers",
+			requestBody = @RequestBody(
+					required = true,
+					content = @Content(
+							mediaType = MediaType.APPLICATION_JSON,
+							schema = @Schema(
+									implementation = ServerInfo.class
+							)
+					)
+			),
+			responses = {
+					@ApiResponse(
+							description = "true if removed, otherwise",
+							content = @Content(
+									schema = @Schema(
+											type = "string"
+									)
+							)
+					)
+			}
+
+	)
+	@ApiErrors({ApiError.INVALID_DATA})
+	@SecurityRequirement(name = "apiKey")
+	public String removeServer(@HeaderParam(Security.API_KEY_HEADER) String apiKey, ServerInfo serverInfo) {
+		Security.checkApiCallAllowed(request);
+
+		try {
+			ElectrumX.Server server = new ElectrumX.Server(
+					serverInfo.getHostName(),
+					ChainableServer.ConnectionType.valueOf(serverInfo.getConnectionType()),
+					serverInfo.getPort()
+			);
+
+			if( CrossChainUtils.removeServer( Bitcoin.getInstance(), server ) ) {
+
+				return "true";
+			}
+			else {
+				return "false";
+			}
+		}
+		catch (IllegalArgumentException | NullPointerException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_DATA);
+		}
+		catch (Exception e) {
+			return "false";
+		}
+	}
+
+	@POST
+	@Path("/setcurrentserver")
+	@Operation(
+			summary = "Set current Bitcoin server",
+			description = "Set current Bitcoin server",
+			requestBody = @RequestBody(
+					required = true,
+					content = @Content(
+							mediaType = MediaType.APPLICATION_JSON,
+							schema = @Schema(
+									implementation = ServerInfo.class
+							)
+					)
+			),
+			responses = {
+					@ApiResponse(
+							description = "connection info",
+							content = @Content(
+									mediaType = MediaType.APPLICATION_JSON,
+									schema = @Schema(
+											implementation = ServerConnectionInfo.class
+									)
+							)
+					)
+			}
+
+	)
+	@ApiErrors({ApiError.INVALID_DATA})
+	@SecurityRequirement(name = "apiKey")
+	public ServerConnectionInfo setCurrentServer(@HeaderParam(Security.API_KEY_HEADER) String apiKey, ServerInfo serverInfo) {
+		Security.checkApiCallAllowed(request);
+
+		if( serverInfo.getConnectionType() == null ||
+				serverInfo.getHostName() == null) throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_DATA);
+		try {
+			return CrossChainUtils.setCurrentServer( Bitcoin.getInstance(), serverInfo );
+		}
+		catch (IllegalArgumentException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_DATA);
+		}
+		catch (Exception e) {
+			return new ServerConnectionInfo(
+					serverInfo,
+					CrossChainUtils.CORE_API_CALL,
+					true,
+					false,
+					System.currentTimeMillis(),
+					CrossChainUtils.getNotes(e));
+		}
+	}
+
+
+	@GET
+	@Path("/feekb")
+	@Operation(
+			summary = "Returns Bitcoin fee per Kb.",
+			description = "Returns Bitcoin fee per Kb.",
+			responses = {
+					@ApiResponse(
+							content = @Content(
+									schema = @Schema(
+											type = "number"
+									)
+							)
+					)
+			}
+	)
+	public String getBitcoinFeePerKb() {
+		Bitcoin bitcoin = Bitcoin.getInstance();
+
+		return String.valueOf(bitcoin.getFeePerKb().value);
+	}
+
+	@POST
+	@Path("/updatefeekb")
+	@Operation(
+			summary = "Sets Bitcoin fee per Kb.",
+			description = "Sets Bitcoin fee per Kb.",
+			requestBody = @RequestBody(
+					required = true,
+					content = @Content(
+							mediaType = MediaType.TEXT_PLAIN,
+							schema = @Schema(
+									type = "number",
+									description = "the fee per Kb",
+									example = "100"
+							)
+					)
+			),
+			responses = {
+					@ApiResponse(
+							content = @Content(mediaType = MediaType.TEXT_PLAIN, schema = @Schema(type = "number", description = "fee"))
+					)
+			}
+	)
+	@ApiErrors({ApiError.INVALID_PRIVATE_KEY, ApiError.INVALID_CRITERIA})
+	public String setBitcoinFeePerKb(@HeaderParam(Security.API_KEY_HEADER) String apiKey, String fee) {
+		Security.checkApiCallAllowed(request);
+
+		Bitcoin bitcoin = Bitcoin.getInstance();
+
+		try {
+			return CrossChainUtils.setFeePerKb(bitcoin, fee);
+		} catch (IllegalArgumentException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_CRITERIA);
+		}
+	}
+
+	@GET
+	@Path("/feeceiling")
+	@Operation(
+			summary = "Returns Bitcoin fee per Kb.",
+			description = "Returns Bitcoin fee per Kb.",
+			responses = {
+					@ApiResponse(
+							content = @Content(
+									schema = @Schema(
+											type = "number"
+									)
+							)
+					)
+			}
+	)
+	public String getBitcoinFeeCeiling() {
+		Bitcoin bitcoin = Bitcoin.getInstance();
+
+		return String.valueOf(bitcoin.getFeeCeiling());
+	}
+
+	@POST
+	@Path("/updatefeeceiling")
+	@Operation(
+			summary = "Sets Bitcoin fee ceiling.",
+			description = "Sets Bitcoin fee ceiling.",
+			requestBody = @RequestBody(
+					required = true,
+					content = @Content(
+							mediaType = MediaType.TEXT_PLAIN,
+							schema = @Schema(
+									type = "number",
+									description = "the fee",
+									example = "100"
+							)
+					)
+			),
+			responses = {
+					@ApiResponse(
+							content = @Content(mediaType = MediaType.TEXT_PLAIN, schema = @Schema(type = "number", description = "fee"))
+					)
+			}
+	)
+	@ApiErrors({ApiError.INVALID_PRIVATE_KEY, ApiError.INVALID_CRITERIA})
+	public String setBitcoinFeeCeiling(@HeaderParam(Security.API_KEY_HEADER) String apiKey, String fee) {
+		Security.checkApiCallAllowed(request);
+
+		Bitcoin bitcoin = Bitcoin.getInstance();
+
+		try {
+			return CrossChainUtils.setFeeCeiling(bitcoin, fee);
+		}
+		catch (IllegalArgumentException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_CRITERIA);
+		}
+	}
 }

src/main/java/org/qortal/api/resource/CrossChainDigibyteResource.java

@@ -16,9 +16,14 @@ import org.qortal.api.Security;
 import org.qortal.api.model.crosschain.AddressRequest;
 import org.qortal.api.model.crosschain.DigibyteSendRequest;
 import org.qortal.crosschain.AddressInfo;
-import org.qortal.crosschain.Digibyte;
+import org.qortal.crosschain.ChainableServer;
+import org.qortal.crosschain.ElectrumX;
 import org.qortal.crosschain.ForeignBlockchainException;
+import org.qortal.crosschain.Digibyte;
+import org.qortal.crosschain.ServerConnectionInfo;
+import org.qortal.crosschain.ServerInfo;
 import org.qortal.crosschain.SimpleTransaction;
+import org.qortal.crosschain.ServerConfigurationInfo;
 
 import javax.servlet.http.HttpServletRequest;
 import javax.ws.rs.GET;
@@ -188,45 +193,6 @@ public class CrossChainDigibyteResource {
 		}
 	}
 
-	@POST
-	@Path("/unusedaddress")
-	@Operation(
-		summary = "Returns first unused address for hierarchical, deterministic BIP32 wallet",
-		description = "Supply BIP32 'm' private/public key in base58, starting with 'xprv'/'xpub' for mainnet, 'tprv'/'tpub' for testnet",
-		requestBody = @RequestBody(
-			required = true,
-			content = @Content(
-				mediaType = MediaType.TEXT_PLAIN,
-				schema = @Schema(
-					type = "string",
-					description = "BIP32 'm' private/public key in base58",
-					example = "tpubD6NzVbkrYhZ4XTPc4btCZ6SMgn8CxmWkj6VBVZ1tfcJfMq4UwAjZbG8U74gGSypL9XBYk2R2BLbDBe8pcEyBKM1edsGQEPKXNbEskZozeZc"
-				)
-			)
-		),
-		responses = {
-			@ApiResponse(
-				content = @Content(array = @ArraySchema( schema = @Schema( implementation = SimpleTransaction.class ) ) )
-			)
-		}
-	)
-	@ApiErrors({ApiError.INVALID_PRIVATE_KEY, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE})
-	@SecurityRequirement(name = "apiKey")
-	public String getUnusedDigibyteReceiveAddress(@HeaderParam(Security.API_KEY_HEADER) String apiKey, String key58) {
-		Security.checkApiCallAllowed(request);
-
-		Digibyte digibyte = Digibyte.getInstance();
-
-		if (!digibyte.isValidDeterministicKey(key58))
-			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_PRIVATE_KEY);
-
-		try {
-			return digibyte.getUnusedReceiveAddress(key58);
-		} catch (ForeignBlockchainException e) {
-			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE);
-		}
-	}
-
 	@POST
 	@Path("/send")
 	@Operation(
@@ -283,4 +249,312 @@ public class CrossChainDigibyteResource {
 		return spendTransaction.getTxId().toString();
 	}
 
-}
+	@GET
+	@Path("/serverinfos")
+	@Operation(
+			summary = "Returns current Digibyte server configuration",
+			description = "Returns current Digibyte server locations and use status",
+			responses = {
+					@ApiResponse(
+							content = @Content(
+									mediaType = MediaType.APPLICATION_JSON,
+									schema = @Schema(
+											implementation = ServerConfigurationInfo.class
+									)
+							)
+					)
+			}
+	)
+	public ServerConfigurationInfo getServerConfiguration() {
+
+		return CrossChainUtils.buildServerConfigurationInfo(Digibyte.getInstance());
+	}
+
+	@GET
+	@Path("/serverconnectionhistory")
+	@Operation(
+			summary = "Returns Digibyte server connection history",
+			description = "Returns Digibyte server connection history",
+			responses = {
+					@ApiResponse(
+							content = @Content(array = @ArraySchema( schema = @Schema( implementation = ServerConnectionInfo.class ) ) )
+					)
+			}
+	)
+	public List<ServerConnectionInfo> getServerConnectionHistory() {
+
+		return CrossChainUtils.buildServerConnectionHistory(Digibyte.getInstance());
+	}
+
+	@POST
+	@Path("/addserver")
+	@Operation(
+			summary = "Add server to list of Digibyte servers",
+			description = "Add server to list of Digibyte servers",
+			requestBody = @RequestBody(
+					required = true,
+					content = @Content(
+							mediaType = MediaType.APPLICATION_JSON,
+							schema = @Schema(
+									implementation = ServerInfo.class
+							)
+					)
+			),
+			responses = {
+					@ApiResponse(
+							description = "true if added, false if not added",
+							content = @Content(
+									schema = @Schema(
+											type = "string"
+									)
+							)
+					)
+			}
+
+	)
+	@ApiErrors({ApiError.INVALID_DATA})
+	@SecurityRequirement(name = "apiKey")
+	public String addServer(@HeaderParam(Security.API_KEY_HEADER) String apiKey, ServerInfo serverInfo) {
+		Security.checkApiCallAllowed(request);
+
+		try {
+			ElectrumX.Server server = new ElectrumX.Server(
+					serverInfo.getHostName(),
+					ChainableServer.ConnectionType.valueOf(serverInfo.getConnectionType()),
+					serverInfo.getPort()
+			);
+
+			if( CrossChainUtils.addServer( Digibyte.getInstance(), server )) {
+				return "true";
+			}
+			else {
+				return "false";
+			}
+		}
+		catch (IllegalArgumentException | NullPointerException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_DATA);
+		}
+		catch (Exception e) {
+			return "false";
+		}
+	}
+
+	@POST
+	@Path("/removeserver")
+	@Operation(
+			summary = "Remove server from list of Digibyte servers",
+			description = "Remove server from list of Digibyte servers",
+			requestBody = @RequestBody(
+					required = true,
+					content = @Content(
+							mediaType = MediaType.APPLICATION_JSON,
+							schema = @Schema(
+									implementation = ServerInfo.class
+							)
+					)
+			),
+			responses = {
+					@ApiResponse(
+							description = "true if removed, otherwise",
+							content = @Content(
+									schema = @Schema(
+											type = "string"
+									)
+							)
+					)
+			}
+
+	)
+	@ApiErrors({ApiError.INVALID_DATA})
+	@SecurityRequirement(name = "apiKey")
+	public String removeServer(@HeaderParam(Security.API_KEY_HEADER) String apiKey, ServerInfo serverInfo) {
+		Security.checkApiCallAllowed(request);
+
+		try {
+			ElectrumX.Server server = new ElectrumX.Server(
+					serverInfo.getHostName(),
+					ChainableServer.ConnectionType.valueOf(serverInfo.getConnectionType()),
+					serverInfo.getPort()
+			);
+
+			if( CrossChainUtils.removeServer( Digibyte.getInstance(), server ) ) {
+
+				return "true";
+			}
+			else {
+				return "false";
+			}
+		}
+		catch (IllegalArgumentException | NullPointerException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_DATA);
+		}
+		catch (Exception e) {
+			return "false";
+		}
+	}
+
+	@POST
+	@Path("/setcurrentserver")
+	@Operation(
+			summary = "Set current Digibyte server",
+			description = "Set current Digibyte server",
+			requestBody = @RequestBody(
+					required = true,
+					content = @Content(
+							mediaType = MediaType.APPLICATION_JSON,
+							schema = @Schema(
+									implementation = ServerInfo.class
+							)
+					)
+			),
+			responses = {
+					@ApiResponse(
+							description = "connection info",
+							content = @Content(
+									mediaType = MediaType.APPLICATION_JSON,
+									schema = @Schema(
+											implementation = ServerConnectionInfo.class
+									)
+							)
+					)
+			}
+
+	)
+	@ApiErrors({ApiError.INVALID_DATA})
+	@SecurityRequirement(name = "apiKey")
+	public ServerConnectionInfo setCurrentServer(@HeaderParam(Security.API_KEY_HEADER) String apiKey, ServerInfo serverInfo) {
+		Security.checkApiCallAllowed(request);
+
+		if( serverInfo.getConnectionType() == null ||
+				serverInfo.getHostName() == null) throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_DATA);
+		try {
+			return CrossChainUtils.setCurrentServer( Digibyte.getInstance(), serverInfo );
+		}
+		catch (IllegalArgumentException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_DATA);
+		}
+		catch (Exception e) {
+			return new ServerConnectionInfo(
+					serverInfo,
+					CrossChainUtils.CORE_API_CALL,
+					true,
+					false,
+					System.currentTimeMillis(),
+					CrossChainUtils.getNotes(e));
+		}
+	}
+
+
+	@GET
+	@Path("/feekb")
+	@Operation(
+			summary = "Returns Digibyte fee per Kb.",
+			description = "Returns Digibyte fee per Kb.",
+			responses = {
+					@ApiResponse(
+							content = @Content(
+									schema = @Schema(
+											type = "number"
+									)
+							)
+					)
+			}
+	)
+	public String getDigibyteFeePerKb() {
+		Digibyte digibyte = Digibyte.getInstance();
+
+		return String.valueOf(digibyte.getFeePerKb().value);
+	}
+
+	@POST
+	@Path("/updatefeekb")
+	@Operation(
+			summary = "Sets Digibyte fee per Kb.",
+			description = "Sets Digibyte fee per Kb.",
+			requestBody = @RequestBody(
+					required = true,
+					content = @Content(
+							mediaType = MediaType.TEXT_PLAIN,
+							schema = @Schema(
+									type = "number",
+									description = "the fee per Kb",
+									example = "100"
+							)
+					)
+			),
+			responses = {
+					@ApiResponse(
+							content = @Content(mediaType = MediaType.TEXT_PLAIN, schema = @Schema(type = "number", description = "fee"))
+					)
+			}
+	)
+	@ApiErrors({ApiError.INVALID_PRIVATE_KEY, ApiError.INVALID_CRITERIA})
+	public String setDigibyteFeePerKb(@HeaderParam(Security.API_KEY_HEADER) String apiKey, String fee) {
+		Security.checkApiCallAllowed(request);
+
+		Digibyte digibyte = Digibyte.getInstance();
+
+		try {
+			return CrossChainUtils.setFeePerKb(digibyte, fee);
+		} catch (IllegalArgumentException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_CRITERIA);
+		}
+	}
+
+	@GET
+	@Path("/feeceiling")
+	@Operation(
+			summary = "Returns Digibyte fee per Kb.",
+			description = "Returns Digibyte fee per Kb.",
+			responses = {
+					@ApiResponse(
+							content = @Content(
+									schema = @Schema(
+											type = "number"
+									)
+							)
+					)
+			}
+	)
+	public String getDigibyteFeeCeiling() {
+		Digibyte digibyte = Digibyte.getInstance();
+
+		return String.valueOf(digibyte.getFeeCeiling());
+	}
+
+	@POST
+	@Path("/updatefeeceiling")
+	@Operation(
+			summary = "Sets Digibyte fee ceiling.",
+			description = "Sets Digibyte fee ceiling.",
+			requestBody = @RequestBody(
+					required = true,
+					content = @Content(
+							mediaType = MediaType.TEXT_PLAIN,
+							schema = @Schema(
+									type = "number",
+									description = "the fee",
+									example = "100"
+							)
+					)
+			),
+			responses = {
+					@ApiResponse(
+							content = @Content(mediaType = MediaType.TEXT_PLAIN, schema = @Schema(type = "number", description = "fee"))
+					)
+			}
+	)
+	@ApiErrors({ApiError.INVALID_PRIVATE_KEY, ApiError.INVALID_CRITERIA})
+	public String setDigibyteFeeCeiling(@HeaderParam(Security.API_KEY_HEADER) String apiKey, String fee) {
+		Security.checkApiCallAllowed(request);
+
+		Digibyte digibyte = Digibyte.getInstance();
+
+		try {
+			return CrossChainUtils.setFeeCeiling(digibyte, fee);
+		}
+		catch (IllegalArgumentException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_CRITERIA);
+		}
+	}
+}

src/main/java/org/qortal/api/resource/CrossChainDogecoinResource.java

@@ -16,9 +16,14 @@ import org.qortal.api.Security;
 import org.qortal.api.model.crosschain.AddressRequest;
 import org.qortal.api.model.crosschain.DogecoinSendRequest;
 import org.qortal.crosschain.AddressInfo;
-import org.qortal.crosschain.Dogecoin;
+import org.qortal.crosschain.ChainableServer;
+import org.qortal.crosschain.ElectrumX;
 import org.qortal.crosschain.ForeignBlockchainException;
+import org.qortal.crosschain.Dogecoin;
+import org.qortal.crosschain.ServerConnectionInfo;
+import org.qortal.crosschain.ServerInfo;
 import org.qortal.crosschain.SimpleTransaction;
+import org.qortal.crosschain.ServerConfigurationInfo;
 
 import javax.servlet.http.HttpServletRequest;
 import javax.ws.rs.GET;
@@ -188,45 +193,6 @@ public class CrossChainDogecoinResource {
 		}
 	}
 
-	@POST
-	@Path("/unusedaddress")
-	@Operation(
-		summary = "Returns first unused address for hierarchical, deterministic BIP32 wallet",
-		description = "Supply BIP32 'm' private/public key in base58, starting with 'xprv'/'xpub' for mainnet, 'tprv'/'tpub' for testnet",
-		requestBody = @RequestBody(
-			required = true,
-			content = @Content(
-				mediaType = MediaType.TEXT_PLAIN,
-				schema = @Schema(
-					type = "string",
-					description = "BIP32 'm' private/public key in base58",
-					example = "tpubD6NzVbkrYhZ4XTPc4btCZ6SMgn8CxmWkj6VBVZ1tfcJfMq4UwAjZbG8U74gGSypL9XBYk2R2BLbDBe8pcEyBKM1edsGQEPKXNbEskZozeZc"
-				)
-			)
-		),
-		responses = {
-			@ApiResponse(
-				content = @Content(array = @ArraySchema( schema = @Schema( implementation = SimpleTransaction.class ) ) )
-			)
-		}
-	)
-	@ApiErrors({ApiError.INVALID_PRIVATE_KEY, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE})
-	@SecurityRequirement(name = "apiKey")
-	public String getUnusedDogecoinReceiveAddress(@HeaderParam(Security.API_KEY_HEADER) String apiKey, String key58) {
-		Security.checkApiCallAllowed(request);
-
-		Dogecoin dogecoin = Dogecoin.getInstance();
-
-		if (!dogecoin.isValidDeterministicKey(key58))
-			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_PRIVATE_KEY);
-
-		try {
-			return dogecoin.getUnusedReceiveAddress(key58);
-		} catch (ForeignBlockchainException e) {
-			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE);
-		}
-	}
-
 	@POST
 	@Path("/send")
 	@Operation(
@@ -283,4 +249,312 @@ public class CrossChainDogecoinResource {
 		return spendTransaction.getTxId().toString();
 	}
 
-}
+	@GET
+	@Path("/serverinfos")
+	@Operation(
+			summary = "Returns current Dogecoin server configuration",
+			description = "Returns current Dogecoin server locations and use status",
+			responses = {
+					@ApiResponse(
+							content = @Content(
+									mediaType = MediaType.APPLICATION_JSON,
+									schema = @Schema(
+											implementation = ServerConfigurationInfo.class
+									)
+							)
+					)
+			}
+	)
+	public ServerConfigurationInfo getServerConfiguration() {
+
+		return CrossChainUtils.buildServerConfigurationInfo(Dogecoin.getInstance());
+	}
+
+	@GET
+	@Path("/serverconnectionhistory")
+	@Operation(
+			summary = "Returns Dogecoin server connection history",
+			description = "Returns Dogecoin server connection history",
+			responses = {
+					@ApiResponse(
+							content = @Content(array = @ArraySchema( schema = @Schema( implementation = ServerConnectionInfo.class ) ) )
+					)
+			}
+	)
+	public List<ServerConnectionInfo> getServerConnectionHistory() {
+
+		return CrossChainUtils.buildServerConnectionHistory(Dogecoin.getInstance());
+	}
+
+	@POST
+	@Path("/addserver")
+	@Operation(
+			summary = "Add server to list of Dogecoin servers",
+			description = "Add server to list of Dogecoin servers",
+			requestBody = @RequestBody(
+					required = true,
+					content = @Content(
+							mediaType = MediaType.APPLICATION_JSON,
+							schema = @Schema(
+									implementation = ServerInfo.class
+							)
+					)
+			),
+			responses = {
+					@ApiResponse(
+							description = "true if added, false if not added",
+							content = @Content(
+									schema = @Schema(
+											type = "string"
+									)
+							)
+					)
+			}
+
+	)
+	@ApiErrors({ApiError.INVALID_DATA})
+	@SecurityRequirement(name = "apiKey")
+	public String addServer(@HeaderParam(Security.API_KEY_HEADER) String apiKey, ServerInfo serverInfo) {
+		Security.checkApiCallAllowed(request);
+
+		try {
+			ElectrumX.Server server = new ElectrumX.Server(
+					serverInfo.getHostName(),
+					ChainableServer.ConnectionType.valueOf(serverInfo.getConnectionType()),
+					serverInfo.getPort()
+			);
+
+			if( CrossChainUtils.addServer( Dogecoin.getInstance(), server )) {
+				return "true";
+			}
+			else {
+				return "false";
+			}
+		}
+		catch (IllegalArgumentException | NullPointerException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_DATA);
+		}
+		catch (Exception e) {
+			return "false";
+		}
+	}
+
+	@POST
+	@Path("/removeserver")
+	@Operation(
+			summary = "Remove server from list of Dogecoin servers",
+			description = "Remove server from list of Dogecoin servers",
+			requestBody = @RequestBody(
+					required = true,
+					content = @Content(
+							mediaType = MediaType.APPLICATION_JSON,
+							schema = @Schema(
+									implementation = ServerInfo.class
+							)
+					)
+			),
+			responses = {
+					@ApiResponse(
+							description = "true if removed, otherwise",
+							content = @Content(
+									schema = @Schema(
+											type = "string"
+									)
+							)
+					)
+			}
+
+	)
+	@ApiErrors({ApiError.INVALID_DATA})
+	@SecurityRequirement(name = "apiKey")
+	public String removeServer(@HeaderParam(Security.API_KEY_HEADER) String apiKey, ServerInfo serverInfo) {
+		Security.checkApiCallAllowed(request);
+
+		try {
+			ElectrumX.Server server = new ElectrumX.Server(
+					serverInfo.getHostName(),
+					ChainableServer.ConnectionType.valueOf(serverInfo.getConnectionType()),
+					serverInfo.getPort()
+			);
+
+			if( CrossChainUtils.removeServer( Dogecoin.getInstance(), server ) ) {
+
+				return "true";
+			}
+			else {
+				return "false";
+			}
+		}
+		catch (IllegalArgumentException | NullPointerException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_DATA);
+		}
+		catch (Exception e) {
+			return "false";
+		}
+	}
+
+	@POST
+	@Path("/setcurrentserver")
+	@Operation(
+			summary = "Set current Dogecoin server",
+			description = "Set current Dogecoin server",
+			requestBody = @RequestBody(
+					required = true,
+					content = @Content(
+							mediaType = MediaType.APPLICATION_JSON,
+							schema = @Schema(
+									implementation = ServerInfo.class
+							)
+					)
+			),
+			responses = {
+					@ApiResponse(
+							description = "connection info",
+							content = @Content(
+									mediaType = MediaType.APPLICATION_JSON,
+									schema = @Schema(
+											implementation = ServerConnectionInfo.class
+									)
+							)
+					)
+			}
+
+	)
+	@ApiErrors({ApiError.INVALID_DATA})
+	@SecurityRequirement(name = "apiKey")
+	public ServerConnectionInfo setCurrentServer(@HeaderParam(Security.API_KEY_HEADER) String apiKey, ServerInfo serverInfo) {
+		Security.checkApiCallAllowed(request);
+
+		if( serverInfo.getConnectionType() == null ||
+				serverInfo.getHostName() == null) throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_DATA);
+		try {
+			return CrossChainUtils.setCurrentServer( Dogecoin.getInstance(), serverInfo );
+		}
+		catch (IllegalArgumentException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_DATA);
+		}
+		catch (Exception e) {
+			return new ServerConnectionInfo(
+					serverInfo,
+					CrossChainUtils.CORE_API_CALL,
+					true,
+					false,
+					System.currentTimeMillis(),
+					CrossChainUtils.getNotes(e));
+		}
+	}
+
+
+	@GET
+	@Path("/feekb")
+	@Operation(
+			summary = "Returns Dogecoin fee per Kb.",
+			description = "Returns Dogecoin fee per Kb.",
+			responses = {
+					@ApiResponse(
+							content = @Content(
+									schema = @Schema(
+											type = "number"
+									)
+							)
+					)
+			}
+	)
+	public String getDogecoinFeePerKb() {
+		Dogecoin dogecoin = Dogecoin.getInstance();
+
+		return String.valueOf(dogecoin.getFeePerKb().value);
+	}
+
+	@POST
+	@Path("/updatefeekb")
+	@Operation(
+			summary = "Sets Dogecoin fee per Kb.",
+			description = "Sets Dogecoin fee per Kb.",
+			requestBody = @RequestBody(
+					required = true,
+					content = @Content(
+							mediaType = MediaType.TEXT_PLAIN,
+							schema = @Schema(
+									type = "number",
+									description = "the fee per Kb",
+									example = "100"
+							)
+					)
+			),
+			responses = {
+					@ApiResponse(
+							content = @Content(mediaType = MediaType.TEXT_PLAIN, schema = @Schema(type = "number", description = "fee"))
+					)
+			}
+	)
+	@ApiErrors({ApiError.INVALID_PRIVATE_KEY, ApiError.INVALID_CRITERIA})
+	public String setDogecoinFeePerKb(@HeaderParam(Security.API_KEY_HEADER) String apiKey, String fee) {
+		Security.checkApiCallAllowed(request);
+
+		Dogecoin dogecoin = Dogecoin.getInstance();
+
+		try {
+			return CrossChainUtils.setFeePerKb(dogecoin, fee);
+		} catch (IllegalArgumentException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_CRITERIA);
+		}
+	}
+
+	@GET
+	@Path("/feeceiling")
+	@Operation(
+			summary = "Returns Dogecoin fee per Kb.",
+			description = "Returns Dogecoin fee per Kb.",
+			responses = {
+					@ApiResponse(
+							content = @Content(
+									schema = @Schema(
+											type = "number"
+									)
+							)
+					)
+			}
+	)
+	public String getDogecoinFeeCeiling() {
+		Dogecoin dogecoin = Dogecoin.getInstance();
+
+		return String.valueOf(dogecoin.getFeeCeiling());
+	}
+
+	@POST
+	@Path("/updatefeeceiling")
+	@Operation(
+			summary = "Sets Dogecoin fee ceiling.",
+			description = "Sets Dogecoin fee ceiling.",
+			requestBody = @RequestBody(
+					required = true,
+					content = @Content(
+							mediaType = MediaType.TEXT_PLAIN,
+							schema = @Schema(
+									type = "number",
+									description = "the fee",
+									example = "100"
+							)
+					)
+			),
+			responses = {
+					@ApiResponse(
+							content = @Content(mediaType = MediaType.TEXT_PLAIN, schema = @Schema(type = "number", description = "fee"))
+					)
+			}
+	)
+	@ApiErrors({ApiError.INVALID_PRIVATE_KEY, ApiError.INVALID_CRITERIA})
+	public String setDogecoinFeeCeiling(@HeaderParam(Security.API_KEY_HEADER) String apiKey, String fee) {
+		Security.checkApiCallAllowed(request);
+
+		Dogecoin dogecoin = Dogecoin.getInstance();
+
+		try {
+			return CrossChainUtils.setFeeCeiling(dogecoin, fee);
+		}
+		catch (IllegalArgumentException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_CRITERIA);
+		}
+	}
+}

src/main/java/org/qortal/api/resource/CrossChainLitecoinResource.java

@@ -16,9 +16,14 @@ import org.qortal.api.Security;
 import org.qortal.api.model.crosschain.AddressRequest;
 import org.qortal.api.model.crosschain.LitecoinSendRequest;
 import org.qortal.crosschain.AddressInfo;
+import org.qortal.crosschain.ChainableServer;
+import org.qortal.crosschain.ElectrumX;
 import org.qortal.crosschain.ForeignBlockchainException;
 import org.qortal.crosschain.Litecoin;
+import org.qortal.crosschain.ServerConnectionInfo;
+import org.qortal.crosschain.ServerInfo;
 import org.qortal.crosschain.SimpleTransaction;
+import org.qortal.crosschain.ServerConfigurationInfo;
 
 import javax.servlet.http.HttpServletRequest;
 import javax.ws.rs.GET;
@@ -188,45 +193,6 @@ public class CrossChainLitecoinResource {
 		}
 	}
 
-	@POST
-	@Path("/unusedaddress")
-	@Operation(
-		summary = "Returns first unused address for hierarchical, deterministic BIP32 wallet",
-		description = "Supply BIP32 'm' private/public key in base58, starting with 'xprv'/'xpub' for mainnet, 'tprv'/'tpub' for testnet",
-		requestBody = @RequestBody(
-			required = true,
-			content = @Content(
-				mediaType = MediaType.TEXT_PLAIN,
-				schema = @Schema(
-					type = "string",
-					description = "BIP32 'm' private/public key in base58",
-					example = "tpubD6NzVbkrYhZ4XTPc4btCZ6SMgn8CxmWkj6VBVZ1tfcJfMq4UwAjZbG8U74gGSypL9XBYk2R2BLbDBe8pcEyBKM1edsGQEPKXNbEskZozeZc"
-				)
-			)
-		),
-		responses = {
-			@ApiResponse(
-				content = @Content(array = @ArraySchema( schema = @Schema( implementation = SimpleTransaction.class ) ) )
-			)
-		}
-	)
-	@ApiErrors({ApiError.INVALID_PRIVATE_KEY, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE})
-	@SecurityRequirement(name = "apiKey")
-	public String getUnusedLitecoinReceiveAddress(@HeaderParam(Security.API_KEY_HEADER) String apiKey, String key58) {
-		Security.checkApiCallAllowed(request);
-
-		Litecoin litecoin = Litecoin.getInstance();
-
-		if (!litecoin.isValidDeterministicKey(key58))
-			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_PRIVATE_KEY);
-
-		try {
-			return litecoin.getUnusedReceiveAddress(key58);
-		} catch (ForeignBlockchainException e) {
-			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE);
-		}
-	}
-
 	@POST
 	@Path("/send")
 	@Operation(
@@ -283,4 +249,350 @@ public class CrossChainLitecoinResource {
 		return spendTransaction.getTxId().toString();
 	}
 
-}
+	@GET
+	@Path("/serverinfos")
+	@Operation(
+			summary = "Returns current Litecoin server configuration",
+			description = "Returns current Litecoin server locations and use status",
+			responses = {
+					@ApiResponse(
+							content = @Content(
+									mediaType = MediaType.APPLICATION_JSON,
+									schema = @Schema(
+											implementation = ServerConfigurationInfo.class
+									)
+							)
+					)
+			}
+	)
+	public ServerConfigurationInfo getServerConfiguration() {
+
+		return CrossChainUtils.buildServerConfigurationInfo(Litecoin.getInstance());
+	}
+
+	@GET
+	@Path("/serverconnectionhistory")
+	@Operation(
+			summary = "Returns Litecoin server connection history",
+			description = "Returns Litecoin server connection history",
+			responses = {
+					@ApiResponse(
+							content = @Content(array = @ArraySchema( schema = @Schema( implementation = ServerConnectionInfo.class ) ) )
+					)
+			}
+	)
+	public List<ServerConnectionInfo> getServerConnectionHistory() {
+
+		return CrossChainUtils.buildServerConnectionHistory(Litecoin.getInstance());
+	}
+
+	@POST
+	@Path("/addserver")
+	@Operation(
+			summary = "Add server to list of Litecoin servers",
+			description = "Add server to list of Litecoin servers",
+			requestBody = @RequestBody(
+					required = true,
+					content = @Content(
+							mediaType = MediaType.APPLICATION_JSON,
+							schema = @Schema(
+									implementation = ServerInfo.class
+							)
+					)
+			),
+			responses = {
+					@ApiResponse(
+							description = "true if added, false if not added",
+							content = @Content(
+									schema = @Schema(
+											type = "string"
+									)
+							)
+					)
+			}
+
+	)
+	@ApiErrors({ApiError.INVALID_DATA})
+	@SecurityRequirement(name = "apiKey")
+	public String addServer(@HeaderParam(Security.API_KEY_HEADER) String apiKey, ServerInfo serverInfo) {
+		Security.checkApiCallAllowed(request);
+
+		try {
+			ElectrumX.Server server = new ElectrumX.Server(
+					serverInfo.getHostName(),
+					ChainableServer.ConnectionType.valueOf(serverInfo.getConnectionType()),
+					serverInfo.getPort()
+			);
+
+			if( CrossChainUtils.addServer( Litecoin.getInstance(), server )) {
+				return "true";
+			}
+			else {
+				return "false";
+			}
+		}
+		catch (IllegalArgumentException | NullPointerException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_DATA);
+		}
+		catch (Exception e) {
+			return "false";
+		}
+	}
+
+	@POST
+	@Path("/removeserver")
+	@Operation(
+			summary = "Remove server from list of Litecoin servers",
+			description = "Remove server from list of Litecoin servers",
+			requestBody = @RequestBody(
+					required = true,
+					content = @Content(
+							mediaType = MediaType.APPLICATION_JSON,
+							schema = @Schema(
+									implementation = ServerInfo.class
+							)
+					)
+			),
+			responses = {
+					@ApiResponse(
+							description = "true if removed, otherwise",
+							content = @Content(
+									schema = @Schema(
+											type = "string"
+									)
+							)
+					)
+			}
+
+	)
+	@ApiErrors({ApiError.INVALID_DATA})
+	@SecurityRequirement(name = "apiKey")
+	public String removeServer(@HeaderParam(Security.API_KEY_HEADER) String apiKey, ServerInfo serverInfo) {
+		Security.checkApiCallAllowed(request);
+
+		try {
+			ElectrumX.Server server = new ElectrumX.Server(
+					serverInfo.getHostName(),
+					ChainableServer.ConnectionType.valueOf(serverInfo.getConnectionType()),
+					serverInfo.getPort()
+			);
+
+			if( CrossChainUtils.removeServer( Litecoin.getInstance(), server ) ) {
+
+				return "true";
+			}
+			else {
+				return "false";
+			}
+		}
+		catch (IllegalArgumentException | NullPointerException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_DATA);
+		}
+		catch (Exception e) {
+			return "false";
+		}
+	}
+
+	@POST
+	@Path("/setcurrentserver")
+	@Operation(
+			summary = "Set current Litecoin server",
+			description = "Set current Litecoin server",
+			requestBody = @RequestBody(
+					required = true,
+					content = @Content(
+							mediaType = MediaType.APPLICATION_JSON,
+							schema = @Schema(
+									implementation = ServerInfo.class
+							)
+					)
+			),
+			responses = {
+					@ApiResponse(
+							description = "connection info",
+							content = @Content(
+									mediaType = MediaType.APPLICATION_JSON,
+									schema = @Schema(
+											implementation = ServerConnectionInfo.class
+									)
+							)
+					)
+			}
+
+	)
+	@ApiErrors({ApiError.INVALID_DATA})
+	@SecurityRequirement(name = "apiKey")
+	public ServerConnectionInfo setCurrentServer(@HeaderParam(Security.API_KEY_HEADER) String apiKey, ServerInfo serverInfo) {
+		Security.checkApiCallAllowed(request);
+
+		if( serverInfo.getConnectionType() == null ||
+				serverInfo.getHostName() == null) throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_DATA);
+		try {
+			return CrossChainUtils.setCurrentServer( Litecoin.getInstance(), serverInfo );
+		}
+		catch (IllegalArgumentException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_DATA);
+		}
+		catch (Exception e) {
+			return new ServerConnectionInfo(
+					serverInfo,
+					CrossChainUtils.CORE_API_CALL,
+					true,
+					false,
+					System.currentTimeMillis(),
+					CrossChainUtils.getNotes(e));
+		}
+	}
+
+	@POST
+	@Path("/repair")
+	@Operation(
+			summary = "Sends all coins in wallet to primary receive address",
+			description = "Supply BIP32 'm' private/public key in base58, starting with 'xprv'/'xpub' for mainnet, 'tprv'/'tpub' for testnet",
+			requestBody = @RequestBody(
+					required = true,
+					content = @Content(
+							mediaType = MediaType.TEXT_PLAIN,
+							schema = @Schema(
+									type = "string",
+									description = "BIP32 'm' private/public key in base58",
+									example = "tpubD6NzVbkrYhZ4XTPc4btCZ6SMgn8CxmWkj6VBVZ1tfcJfMq4UwAjZbG8U74gGSypL9XBYk2R2BLbDBe8pcEyBKM1edsGQEPKXNbEskZozeZc"
+							)
+					)
+			),
+			responses = {
+					@ApiResponse(
+							content = @Content(mediaType = MediaType.TEXT_PLAIN, schema = @Schema(type = "string", description = "transaction hash"))
+					)
+			}
+	)
+	@ApiErrors({ApiError.INVALID_PRIVATE_KEY, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE})
+	@SecurityRequirement(name = "apiKey")
+	public String repairOldWallet(@HeaderParam(Security.API_KEY_HEADER) String apiKey, String key58) {
+		Security.checkApiCallAllowed(request);
+
+		Litecoin litecoin = Litecoin.getInstance();
+
+		if (!litecoin.isValidDeterministicKey(key58))
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_PRIVATE_KEY);
+
+		try {
+			return litecoin.repairOldWallet(key58);
+		} catch (ForeignBlockchainException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE);
+		}
+	}
+
+	@GET
+	@Path("/feekb")
+	@Operation(
+			summary = "Returns Litecoin fee per Kb.",
+			description = "Returns Litecoin fee per Kb.",
+			responses = {
+					@ApiResponse(
+							content = @Content(
+									schema = @Schema(
+											type = "number"
+									)
+							)
+					)
+			}
+	)
+	public String getLitecoinFeePerKb() {
+		Litecoin litecoin = Litecoin.getInstance();
+
+		return String.valueOf(litecoin.getFeePerKb().value);
+	}
+
+	@POST
+	@Path("/updatefeekb")
+	@Operation(
+			summary = "Sets Litecoin fee per Kb.",
+			description = "Sets Litecoin fee per Kb.",
+			requestBody = @RequestBody(
+					required = true,
+					content = @Content(
+							mediaType = MediaType.TEXT_PLAIN,
+							schema = @Schema(
+									type = "number",
+									description = "the fee per Kb",
+									example = "100"
+							)
+					)
+			),
+			responses = {
+					@ApiResponse(
+							content = @Content(mediaType = MediaType.TEXT_PLAIN, schema = @Schema(type = "number", description = "fee"))
+					)
+			}
+	)
+	@ApiErrors({ApiError.INVALID_PRIVATE_KEY, ApiError.INVALID_CRITERIA})
+	public String setLitecoinFeePerKb(@HeaderParam(Security.API_KEY_HEADER) String apiKey, String fee) {
+		Security.checkApiCallAllowed(request);
+
+		Litecoin litecoin = Litecoin.getInstance();
+
+		try {
+			return CrossChainUtils.setFeePerKb(litecoin, fee);
+		} catch (IllegalArgumentException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_CRITERIA);
+		}
+	}
+
+	@GET
+	@Path("/feeceiling")
+	@Operation(
+			summary = "Returns Litecoin fee per Kb.",
+			description = "Returns Litecoin fee per Kb.",
+			responses = {
+					@ApiResponse(
+							content = @Content(
+									schema = @Schema(
+											type = "number"
+									)
+							)
+					)
+			}
+	)
+	public String getLitecoinFeeCeiling() {
+		Litecoin litecoin = Litecoin.getInstance();
+
+		return String.valueOf(litecoin.getFeeCeiling());
+	}
+
+	@POST
+	@Path("/updatefeeceiling")
+	@Operation(
+			summary = "Sets Litecoin fee ceiling.",
+			description = "Sets Litecoin fee ceiling.",
+			requestBody = @RequestBody(
+					required = true,
+					content = @Content(
+							mediaType = MediaType.TEXT_PLAIN,
+							schema = @Schema(
+									type = "number",
+									description = "the fee",
+									example = "100"
+							)
+					)
+			),
+			responses = {
+					@ApiResponse(
+							content = @Content(mediaType = MediaType.TEXT_PLAIN, schema = @Schema(type = "number", description = "fee"))
+					)
+			}
+	)
+	@ApiErrors({ApiError.INVALID_PRIVATE_KEY, ApiError.INVALID_CRITERIA})
+	public String setLitecoinFeeCeiling(@HeaderParam(Security.API_KEY_HEADER) String apiKey, String fee) {
+		Security.checkApiCallAllowed(request);
+
+		Litecoin litecoin = Litecoin.getInstance();
+
+		try {
+			return CrossChainUtils.setFeeCeiling(litecoin, fee);
+		}
+		catch (IllegalArgumentException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_CRITERIA);
+		}
+	}
+}

src/main/java/org/qortal/api/resource/CrossChainPirateChainResource.java

@@ -13,9 +13,14 @@ import org.qortal.api.ApiErrors;
 import org.qortal.api.ApiExceptionFactory;
 import org.qortal.api.Security;
 import org.qortal.api.model.crosschain.PirateChainSendRequest;
+import org.qortal.crosschain.ChainableServer;
 import org.qortal.crosschain.ForeignBlockchainException;
 import org.qortal.crosschain.PirateChain;
+import org.qortal.crosschain.PirateLightClient;
+import org.qortal.crosschain.ServerConnectionInfo;
+import org.qortal.crosschain.ServerInfo;
 import org.qortal.crosschain.SimpleTransaction;
+import org.qortal.crosschain.ServerConfigurationInfo;
 
 import javax.servlet.http.HttpServletRequest;
 import javax.ws.rs.GET;
@@ -329,4 +334,312 @@ public class CrossChainPirateChainResource {
 			throw ApiExceptionFactory.INSTANCE.createCustomException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE, e.getMessage());
 		}
 	}
+
+	@GET
+	@Path("/serverinfos")
+	@Operation(
+			summary = "Returns current PirateChain server configuration",
+			description = "Returns current PirateChain server locations and use status",
+			responses = {
+					@ApiResponse(
+							content = @Content(
+									mediaType = MediaType.APPLICATION_JSON,
+									schema = @Schema(
+											implementation = ServerConfigurationInfo.class
+									)
+							)
+					)
+			}
+	)
+	public ServerConfigurationInfo getServerConfiguration() {
+
+		return CrossChainUtils.buildServerConfigurationInfo(PirateChain.getInstance());
+	}
+
+	@GET
+	@Path("/serverconnectionhistory")
+	@Operation(
+			summary = "Returns Pirate Chain server connection history",
+			description = "Returns Pirate Chain server connection history",
+			responses = {
+					@ApiResponse(
+							content = @Content(array = @ArraySchema( schema = @Schema( implementation = ServerConnectionInfo.class ) ) )
+					)
+			}
+	)
+	public List<ServerConnectionInfo> getServerConnectionHistory() {
+
+		return CrossChainUtils.buildServerConnectionHistory(PirateChain.getInstance());
+	}
+
+	@POST
+	@Path("/addserver")
+	@Operation(
+			summary = "Add server to list of Pirate Chain servers",
+			description = "Add server to list of Pirate Chain servers",
+			requestBody = @RequestBody(
+					required = true,
+					content = @Content(
+							mediaType = MediaType.APPLICATION_JSON,
+							schema = @Schema(
+									implementation = ServerInfo.class
+							)
+					)
+			),
+			responses = {
+					@ApiResponse(
+							description = "true if added, false if not added",
+							content = @Content(
+									schema = @Schema(
+											type = "string"
+									)
+							)
+					)
+			}
+
+	)
+	@ApiErrors({ApiError.INVALID_DATA})
+	@SecurityRequirement(name = "apiKey")
+	public String addServerInfo(@HeaderParam(Security.API_KEY_HEADER) String apiKey, ServerInfo serverInfo) {
+		Security.checkApiCallAllowed(request);
+
+		try {
+			PirateLightClient.Server server = new PirateLightClient.Server(
+					serverInfo.getHostName(),
+					ChainableServer.ConnectionType.valueOf(serverInfo.getConnectionType()),
+					serverInfo.getPort()
+			);
+
+			if( CrossChainUtils.addServer( PirateChain.getInstance(), server )) {
+				return "true";
+			}
+			else {
+				return "false";
+			}
+		}
+		catch (IllegalArgumentException | NullPointerException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_DATA);
+		}
+		catch (Exception e) {
+			return "false";
+		}
+	}
+
+	@POST
+	@Path("/removeserver")
+	@Operation(
+			summary = "Remove server from list of Pirate Chain servers",
+			description = "Remove server from list of Pirate Chain servers",
+			requestBody = @RequestBody(
+					required = true,
+					content = @Content(
+							mediaType = MediaType.APPLICATION_JSON,
+							schema = @Schema(
+									implementation = ServerInfo.class
+							)
+					)
+			),
+			responses = {
+					@ApiResponse(
+							description = "true if removed, otherwise",
+							content = @Content(
+									schema = @Schema(
+											type = "string"
+									)
+							)
+					)
+			}
+
+	)
+	@ApiErrors({ApiError.INVALID_DATA})
+	@SecurityRequirement(name = "apiKey")
+	public String removeServerInfo(@HeaderParam(Security.API_KEY_HEADER) String apiKey, ServerInfo serverInfo) {
+		Security.checkApiCallAllowed(request);
+
+		try {
+			PirateLightClient.Server server = new PirateLightClient.Server(
+					serverInfo.getHostName(),
+					ChainableServer.ConnectionType.valueOf(serverInfo.getConnectionType()),
+					serverInfo.getPort()
+			);
+
+			if( CrossChainUtils.removeServer( PirateChain.getInstance(), server ) ) {
+
+				return "true";
+			}
+			else {
+				return "false";
+			}
+		}
+		catch (IllegalArgumentException | NullPointerException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_DATA);
+		}
+		catch (Exception e) {
+			return "false";
+		}
+	}
+
+	@POST
+	@Path("/setcurrentserver")
+	@Operation(
+			summary = "Set current Pirate Chain server",
+			description = "Set current Pirate Chain server",
+			requestBody = @RequestBody(
+					required = true,
+					content = @Content(
+							mediaType = MediaType.APPLICATION_JSON,
+							schema = @Schema(
+									implementation = ServerInfo.class
+							)
+					)
+			),
+			responses = {
+					@ApiResponse(
+							description = "connection info",
+							content = @Content(
+									mediaType = MediaType.APPLICATION_JSON,
+									schema = @Schema(
+											implementation = ServerConnectionInfo.class
+									)
+							)
+					)
+			}
+
+	)
+	@ApiErrors({ApiError.INVALID_DATA})
+	@SecurityRequirement(name = "apiKey")
+	public ServerConnectionInfo setCurrentServerInfo(@HeaderParam(Security.API_KEY_HEADER) String apiKey, ServerInfo serverInfo) {
+		Security.checkApiCallAllowed(request);
+
+		if( serverInfo.getConnectionType() == null ||
+				serverInfo.getHostName() == null) throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_DATA);
+		try {
+			return CrossChainUtils.setCurrentServer( PirateChain.getInstance(), serverInfo );
+		}
+		catch (IllegalArgumentException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_DATA);
+		}
+		catch (Exception e) {
+			return new ServerConnectionInfo(
+					serverInfo,
+					CrossChainUtils.CORE_API_CALL,
+					true,
+					false,
+					System.currentTimeMillis(),
+					CrossChainUtils.getNotes(e));
+		}
+	}
+
+	@GET
+	@Path("/feekb")
+	@Operation(
+			summary = "Returns PirateChain fee per Kb.",
+			description = "Returns PirateChain fee per Kb.",
+			responses = {
+					@ApiResponse(
+							content = @Content(
+									schema = @Schema(
+											type = "number"
+									)
+							)
+					)
+			}
+	)
+	public String getPirateChainFeePerKb() {
+		PirateChain pirateChain = PirateChain.getInstance();
+
+		return String.valueOf(pirateChain.getFeePerKb().value);
+	}
+
+	@POST
+	@Path("/updatefeekb")
+	@Operation(
+			summary = "Sets PirateChain fee per Kb.",
+			description = "Sets PirateChain fee per Kb.",
+			requestBody = @RequestBody(
+					required = true,
+					content = @Content(
+							mediaType = MediaType.TEXT_PLAIN,
+							schema = @Schema(
+									type = "number",
+									description = "the fee per Kb",
+									example = "100"
+							)
+					)
+			),
+			responses = {
+					@ApiResponse(
+							content = @Content(mediaType = MediaType.TEXT_PLAIN, schema = @Schema(type = "number", description = "fee"))
+					)
+			}
+	)
+	@ApiErrors({ApiError.INVALID_PRIVATE_KEY, ApiError.INVALID_CRITERIA})
+	public String setPirateChainFeePerKb(@HeaderParam(Security.API_KEY_HEADER) String apiKey, String fee) {
+		Security.checkApiCallAllowed(request);
+
+		PirateChain pirateChain = PirateChain.getInstance();
+
+		try {
+			return CrossChainUtils.setFeePerKb(pirateChain, fee);
+		} catch (IllegalArgumentException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_CRITERIA);
+		}
+	}
+
+	@GET
+	@Path("/feeceiling")
+	@Operation(
+			summary = "Returns PirateChain fee per Kb.",
+			description = "Returns PirateChain fee per Kb.",
+			responses = {
+					@ApiResponse(
+							content = @Content(
+									schema = @Schema(
+											type = "number"
+									)
+							)
+					)
+			}
+	)
+	public String getPirateChainFeeCeiling() {
+		PirateChain pirateChain = PirateChain.getInstance();
+
+		return String.valueOf(pirateChain.getFeeCeiling());
+	}
+
+	@POST
+	@Path("/updatefeeceiling")
+	@Operation(
+			summary = "Sets PirateChain fee ceiling.",
+			description = "Sets PirateChain fee ceiling.",
+			requestBody = @RequestBody(
+					required = true,
+					content = @Content(
+							mediaType = MediaType.TEXT_PLAIN,
+							schema = @Schema(
+									type = "number",
+									description = "the fee",
+									example = "100"
+							)
+					)
+			),
+			responses = {
+					@ApiResponse(
+							content = @Content(mediaType = MediaType.TEXT_PLAIN, schema = @Schema(type = "number", description = "fee"))
+					)
+			}
+	)
+	@ApiErrors({ApiError.INVALID_PRIVATE_KEY, ApiError.INVALID_CRITERIA})
+	public String setPirateChainFeeCeiling(@HeaderParam(Security.API_KEY_HEADER) String apiKey, String fee) {
+		Security.checkApiCallAllowed(request);
+
+		PirateChain pirateChain = PirateChain.getInstance();
+
+		try {
+			return CrossChainUtils.setFeeCeiling(pirateChain, fee);
+		}
+		catch (IllegalArgumentException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_CRITERIA);
+		}
+	}
 }

src/main/java/org/qortal/api/resource/CrossChainRavencoinResource.java

@@ -16,9 +16,14 @@ import org.qortal.api.Security;
 import org.qortal.api.model.crosschain.AddressRequest;
 import org.qortal.api.model.crosschain.RavencoinSendRequest;
 import org.qortal.crosschain.AddressInfo;
+import org.qortal.crosschain.ChainableServer;
+import org.qortal.crosschain.ElectrumX;
 import org.qortal.crosschain.ForeignBlockchainException;
 import org.qortal.crosschain.Ravencoin;
+import org.qortal.crosschain.ServerConnectionInfo;
+import org.qortal.crosschain.ServerInfo;
 import org.qortal.crosschain.SimpleTransaction;
+import org.qortal.crosschain.ServerConfigurationInfo;
 
 import javax.servlet.http.HttpServletRequest;
 import javax.ws.rs.GET;
@@ -188,45 +193,6 @@ public class CrossChainRavencoinResource {
 		}
 	}
 
-	@POST
-	@Path("/unusedaddress")
-	@Operation(
-		summary = "Returns first unused address for hierarchical, deterministic BIP32 wallet",
-		description = "Supply BIP32 'm' private/public key in base58, starting with 'xprv'/'xpub' for mainnet, 'tprv'/'tpub' for testnet",
-		requestBody = @RequestBody(
-			required = true,
-			content = @Content(
-				mediaType = MediaType.TEXT_PLAIN,
-				schema = @Schema(
-					type = "string",
-					description = "BIP32 'm' private/public key in base58",
-					example = "tpubD6NzVbkrYhZ4XTPc4btCZ6SMgn8CxmWkj6VBVZ1tfcJfMq4UwAjZbG8U74gGSypL9XBYk2R2BLbDBe8pcEyBKM1edsGQEPKXNbEskZozeZc"
-				)
-			)
-		),
-		responses = {
-			@ApiResponse(
-				content = @Content(array = @ArraySchema( schema = @Schema( implementation = SimpleTransaction.class ) ) )
-			)
-		}
-	)
-	@ApiErrors({ApiError.INVALID_PRIVATE_KEY, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE})
-	@SecurityRequirement(name = "apiKey")
-	public String getUnusedRavencoinReceiveAddress(@HeaderParam(Security.API_KEY_HEADER) String apiKey, String key58) {
-		Security.checkApiCallAllowed(request);
-
-		Ravencoin ravencoin = Ravencoin.getInstance();
-
-		if (!ravencoin.isValidDeterministicKey(key58))
-			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_PRIVATE_KEY);
-
-		try {
-			return ravencoin.getUnusedReceiveAddress(key58);
-		} catch (ForeignBlockchainException e) {
-			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE);
-		}
-	}
-
 	@POST
 	@Path("/send")
 	@Operation(
@@ -283,4 +249,312 @@ public class CrossChainRavencoinResource {
 		return spendTransaction.getTxId().toString();
 	}
 
+	@GET
+	@Path("/serverinfos")
+	@Operation(
+			summary = "Returns current Ravencoin server configuration",
+			description = "Returns current Ravencoin server locations and use status",
+			responses = {
+					@ApiResponse(
+							content = @Content(
+									mediaType = MediaType.APPLICATION_JSON,
+									schema = @Schema(
+											implementation = ServerConfigurationInfo.class
+									)
+							)
+					)
+			}
+	)
+	public ServerConfigurationInfo getServerConfiguration() {
+
+		return CrossChainUtils.buildServerConfigurationInfo(Ravencoin.getInstance());
+	}
+
+	@GET
+	@Path("/serverconnectionhistory")
+	@Operation(
+			summary = "Returns Ravencoin server connection history",
+			description = "Returns Ravencoin server connection history",
+			responses = {
+					@ApiResponse(
+							content = @Content(array = @ArraySchema( schema = @Schema( implementation = ServerConnectionInfo.class ) ) )
+					)
+			}
+	)
+	public List<ServerConnectionInfo> getServerConnectionHistory() {
+
+		return CrossChainUtils.buildServerConnectionHistory(Ravencoin.getInstance());
+	}
+
+	@POST
+	@Path("/addserver")
+	@Operation(
+			summary = "Add server to list of Ravencoin servers",
+			description = "Add server to list of Ravencoin servers",
+			requestBody = @RequestBody(
+					required = true,
+					content = @Content(
+							mediaType = MediaType.APPLICATION_JSON,
+							schema = @Schema(
+									implementation = ServerInfo.class
+							)
+					)
+			),
+			responses = {
+					@ApiResponse(
+							description = "true if added, false if not added",
+							content = @Content(
+									schema = @Schema(
+											type = "string"
+									)
+							)
+					)
+			}
+
+	)
+	@ApiErrors({ApiError.INVALID_DATA})
+	@SecurityRequirement(name = "apiKey")
+	public String addServer(@HeaderParam(Security.API_KEY_HEADER) String apiKey, ServerInfo serverInfo) {
+		Security.checkApiCallAllowed(request);
+
+		try {
+			ElectrumX.Server server = new ElectrumX.Server(
+					serverInfo.getHostName(),
+					ChainableServer.ConnectionType.valueOf(serverInfo.getConnectionType()),
+					serverInfo.getPort()
+			);
+
+			if( CrossChainUtils.addServer( Ravencoin.getInstance(), server )) {
+				return "true";
+			}
+			else {
+				return "false";
+			}
+		}
+		catch (IllegalArgumentException | NullPointerException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_DATA);
+		}
+		catch (Exception e) {
+			return "false";
+		}
+	}
+
+	@POST
+	@Path("/removeserver")
+	@Operation(
+			summary = "Remove server from list of Ravencoin servers",
+			description = "Remove server from list of Ravencoin servers",
+			requestBody = @RequestBody(
+					required = true,
+					content = @Content(
+							mediaType = MediaType.APPLICATION_JSON,
+							schema = @Schema(
+									implementation = ServerInfo.class
+							)
+					)
+			),
+			responses = {
+					@ApiResponse(
+							description = "true if removed, otherwise",
+							content = @Content(
+									schema = @Schema(
+											type = "string"
+									)
+							)
+					)
+			}
+
+	)
+	@ApiErrors({ApiError.INVALID_DATA})
+	@SecurityRequirement(name = "apiKey")
+	public String removeServer(@HeaderParam(Security.API_KEY_HEADER) String apiKey, ServerInfo serverInfo) {
+		Security.checkApiCallAllowed(request);
+
+		try {
+			ElectrumX.Server server = new ElectrumX.Server(
+					serverInfo.getHostName(),
+					ChainableServer.ConnectionType.valueOf(serverInfo.getConnectionType()),
+					serverInfo.getPort()
+			);
+
+			if( CrossChainUtils.removeServer( Ravencoin.getInstance(), server ) ) {
+
+				return "true";
+			}
+			else {
+				return "false";
+			}
+		}
+		catch (IllegalArgumentException | NullPointerException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_DATA);
+		}
+		catch (Exception e) {
+			return "false";
+		}
+	}
+
+	@POST
+	@Path("/setcurrentserver")
+	@Operation(
+			summary = "Set current Ravencoin server",
+			description = "Set current Ravencoin server",
+			requestBody = @RequestBody(
+					required = true,
+					content = @Content(
+							mediaType = MediaType.APPLICATION_JSON,
+							schema = @Schema(
+									implementation = ServerInfo.class
+							)
+					)
+			),
+			responses = {
+					@ApiResponse(
+							description = "connection info",
+							content = @Content(
+									mediaType = MediaType.APPLICATION_JSON,
+									schema = @Schema(
+											implementation = ServerConnectionInfo.class
+									)
+							)
+					)
+			}
+
+	)
+	@ApiErrors({ApiError.INVALID_DATA})
+	@SecurityRequirement(name = "apiKey")
+	public ServerConnectionInfo setCurrentServer(@HeaderParam(Security.API_KEY_HEADER) String apiKey, ServerInfo serverInfo) {
+		Security.checkApiCallAllowed(request);
+
+		if( serverInfo.getConnectionType() == null ||
+				serverInfo.getHostName() == null) throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_DATA);
+		try {
+			return CrossChainUtils.setCurrentServer( Ravencoin.getInstance(), serverInfo );
+		}
+		catch (IllegalArgumentException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_DATA);
+		}
+		catch (Exception e) {
+			return new ServerConnectionInfo(
+					serverInfo,
+					CrossChainUtils.CORE_API_CALL,
+					true,
+					false,
+					System.currentTimeMillis(),
+					CrossChainUtils.getNotes(e));
+		}
+	}
+
+
+	@GET
+	@Path("/feekb")
+	@Operation(
+			summary = "Returns Ravencoin fee per Kb.",
+			description = "Returns Ravencoin fee per Kb.",
+			responses = {
+					@ApiResponse(
+							content = @Content(
+									schema = @Schema(
+											type = "number"
+									)
+							)
+					)
+			}
+	)
+	public String getRavencoinFeePerKb() {
+		Ravencoin ravencoin = Ravencoin.getInstance();
+
+		return String.valueOf(ravencoin.getFeePerKb().value);
+	}
+
+	@POST
+	@Path("/updatefeekb")
+	@Operation(
+			summary = "Sets Ravencoin fee per Kb.",
+			description = "Sets Ravencoin fee per Kb.",
+			requestBody = @RequestBody(
+					required = true,
+					content = @Content(
+							mediaType = MediaType.TEXT_PLAIN,
+							schema = @Schema(
+									type = "number",
+									description = "the fee per Kb",
+									example = "100"
+							)
+					)
+			),
+			responses = {
+					@ApiResponse(
+							content = @Content(mediaType = MediaType.TEXT_PLAIN, schema = @Schema(type = "number", description = "fee"))
+					)
+			}
+	)
+	@ApiErrors({ApiError.INVALID_PRIVATE_KEY, ApiError.INVALID_CRITERIA})
+	public String setRavencoinFeePerKb(@HeaderParam(Security.API_KEY_HEADER) String apiKey, String fee) {
+		Security.checkApiCallAllowed(request);
+
+		Ravencoin ravencoin = Ravencoin.getInstance();
+
+		try {
+			return CrossChainUtils.setFeePerKb(ravencoin, fee);
+		} catch (IllegalArgumentException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_CRITERIA);
+		}
+	}
+
+	@GET
+	@Path("/feeceiling")
+	@Operation(
+			summary = "Returns Ravencoin fee per Kb.",
+			description = "Returns Ravencoin fee per Kb.",
+			responses = {
+					@ApiResponse(
+							content = @Content(
+									schema = @Schema(
+											type = "number"
+									)
+							)
+					)
+			}
+	)
+	public String getRavencoinFeeCeiling() {
+		Ravencoin ravencoin = Ravencoin.getInstance();
+
+		return String.valueOf(ravencoin.getFeeCeiling());
+	}
+
+	@POST
+	@Path("/updatefeeceiling")
+	@Operation(
+			summary = "Sets Ravencoin fee ceiling.",
+			description = "Sets Ravencoin fee ceiling.",
+			requestBody = @RequestBody(
+					required = true,
+					content = @Content(
+							mediaType = MediaType.TEXT_PLAIN,
+							schema = @Schema(
+									type = "number",
+									description = "the fee",
+									example = "100"
+							)
+					)
+			),
+			responses = {
+					@ApiResponse(
+							content = @Content(mediaType = MediaType.TEXT_PLAIN, schema = @Schema(type = "number", description = "fee"))
+					)
+			}
+	)
+	@ApiErrors({ApiError.INVALID_PRIVATE_KEY, ApiError.INVALID_CRITERIA})
+	public String setRavencoinFeeCeiling(@HeaderParam(Security.API_KEY_HEADER) String apiKey, String fee) {
+		Security.checkApiCallAllowed(request);
+
+		Ravencoin ravencoin = Ravencoin.getInstance();
+
+		try {
+			return CrossChainUtils.setFeeCeiling(ravencoin, fee);
+		}
+		catch (IllegalArgumentException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_CRITERIA);
+		}
+	}
 }

src/main/java/org/qortal/api/resource/CrossChainResource.java

@@ -19,11 +19,14 @@ import org.qortal.api.model.CrossChainTradeSummary;
 import org.qortal.controller.tradebot.TradeBot;
 import org.qortal.crosschain.ACCT;
 import org.qortal.crosschain.AcctMode;
+import org.qortal.crosschain.Bitcoiny;
+import org.qortal.crosschain.ForeignBlockchainException;
 import org.qortal.crosschain.SupportedBlockchain;
 import org.qortal.crypto.Crypto;
 import org.qortal.data.at.ATData;
 import org.qortal.data.at.ATStateData;
 import org.qortal.data.crosschain.CrossChainTradeData;
+import org.qortal.data.crosschain.TransactionSummary;
 import org.qortal.data.transaction.BaseTransactionData;
 import org.qortal.data.transaction.MessageTransactionData;
 import org.qortal.data.transaction.TransactionData;
@@ -47,6 +50,7 @@ import javax.ws.rs.core.Context;
 import javax.ws.rs.core.MediaType;
 import java.util.*;
 import java.util.function.Supplier;
+import java.util.stream.Collectors;
 
 @Path("/crosschain")
 @Tag(name = "Cross-Chain")
@@ -372,7 +376,7 @@ public class CrossChainResource {
 		int maximumCount = maxtrades != null ? maxtrades : 10;
 		long minimumPeriod = 4 * 60 * 60 * 1000L; // ms
 		Boolean isFinished = Boolean.TRUE;
-		boolean useInversePrice = (inverse != null && inverse == true);
+		boolean useInversePrice = (inverse != null && inverse);
 
 		try (final Repository repository = RepositoryManager.getRepository()) {
 			Map<ByteArray, Supplier<ACCT>> acctsByCodeHash = SupportedBlockchain.getFilteredAcctMap(foreignBlockchain);
@@ -497,6 +501,111 @@ public class CrossChainResource {
 		}
 	}
 
+	@POST
+	@Path("/p2sh")
+	@Operation(
+			summary = "Returns P2SH Address",
+			description = "Get the P2SH address to lock foreign coin in a cross chain trade for QORT",
+			requestBody = @RequestBody(
+					required = true,
+					content = @Content(
+							mediaType = MediaType.TEXT_PLAIN,
+							schema = @Schema(
+									type = "string",
+									description = "the AT address",
+									example = "AKFnu9yBp7tUAc5HAphhfCxRZTYoeKXgUy"
+							)
+					)
+			),
+			responses = {
+					@ApiResponse(
+							content = @Content(mediaType = MediaType.TEXT_PLAIN, schema = @Schema(type = "string", description = "address"))
+					)
+			}
+	)
+	@ApiErrors({ApiError.ADDRESS_UNKNOWN, ApiError.INVALID_CRITERIA})
+	@SecurityRequirement(name = "apiKey")
+	public String getForeignP2SH(@HeaderParam(Security.API_KEY_HEADER) String apiKey, String atAddress) {
+		Security.checkApiCallAllowed(request);
+
+		try (final Repository repository = RepositoryManager.getRepository()) {
+			ATData atData = repository.getATRepository().fromATAddress(atAddress);
+			if (atData == null)
+				throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.ADDRESS_UNKNOWN);
+
+			ACCT acct = SupportedBlockchain.getAcctByCodeHash(atData.getCodeHash());
+
+			if( acct == null || !(acct.getBlockchain() instanceof Bitcoiny) )
+				throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_CRITERIA);
+
+			Bitcoiny bitcoiny = (Bitcoiny) acct.getBlockchain();
+
+			CrossChainTradeData crossChainTradeData = acct.populateTradeData(repository, atData);
+
+			Optional<String> p2sh
+					= CrossChainUtils.getP2ShAddressForAT(atAddress, repository, bitcoiny, crossChainTradeData);
+
+			if(p2sh.isPresent()){
+				return p2sh.get();
+			}
+			else{
+				throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.ADDRESS_UNKNOWN);
+			}
+		}
+		catch (DataException e) {
+			throw ApiExceptionFactory.INSTANCE.createCustomException(request, ApiError.REPOSITORY_ISSUE, e.getMessage());
+		}
+	}
+
+	@POST
+	@Path("/txactivity")
+	@Operation(
+			summary = "Returns Foreign Transaction Activity",
+			description = "Get the activity related to foreign coin trading",
+			responses = {
+					@ApiResponse(
+							content = @Content(
+									array = @ArraySchema(
+											schema = @Schema(
+													implementation = TransactionSummary.class
+											)
+									)
+							)
+					)
+			}
+	)
+	@ApiErrors({ApiError.INVALID_CRITERIA, ApiError.REPOSITORY_ISSUE, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE})
+	@SecurityRequirement(name = "apiKey")
+	public List<TransactionSummary> getForeignTransactionActivity(@HeaderParam(Security.API_KEY_HEADER) String apiKey, @Parameter(
+			description = "Limit to specific blockchain",
+			example = "LITECOIN",
+			schema = @Schema(implementation = SupportedBlockchain.class)
+	) @QueryParam("foreignBlockchain") SupportedBlockchain foreignBlockchain) {
+		Security.checkApiCallAllowed(request);
+
+		if (!(foreignBlockchain.getInstance() instanceof Bitcoiny))
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_CRITERIA);
+
+		Bitcoiny bitcoiny = (Bitcoiny) foreignBlockchain.getInstance() ;
+
+		org.bitcoinj.core.Context.propagate( bitcoiny.getBitcoinjContext() );
+
+		try (final Repository repository = RepositoryManager.getRepository()) {
+
+			// sort from last lock to first lock
+			return CrossChainUtils
+					.getForeignTradeSummaries(foreignBlockchain, repository, bitcoiny).stream()
+					.sorted(Comparator.comparing(TransactionSummary::getLockingTimestamp).reversed())
+					.collect(Collectors.toList());
+		}
+		catch (DataException e) {
+			throw ApiExceptionFactory.INSTANCE.createCustomException(request, ApiError.REPOSITORY_ISSUE, e.getMessage());
+		}
+		catch (ForeignBlockchainException e) {
+			throw ApiExceptionFactory.INSTANCE.createCustomException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE, e.getMessage());
+		}
+	}
+
 	private ATData fetchAtDataWithChecking(Repository repository, String atAddress) throws DataException {
 		ATData atData = repository.getATRepository().fromATAddress(atAddress);
 		if (atData == null)

src/main/java/org/qortal/api/resource/CrossChainUtils.java

@@ -0,0 +1,548 @@
+package org.qortal.api.resource;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.bitcoinj.core.Address;
+import org.bitcoinj.core.Coin;
+import org.bitcoinj.script.Script;
+import org.bitcoinj.script.ScriptBuilder;
+
+import org.qortal.crosschain.*;
+import org.qortal.data.at.ATData;
+import org.qortal.data.crosschain.*;
+import org.qortal.repository.DataException;
+import org.qortal.repository.Repository;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+
+public class CrossChainUtils {
+    private static final Logger LOGGER = LogManager.getLogger(CrossChainUtils.class);
+    public static final String CORE_API_CALL = "Core API Call";
+
+    public static ServerConfigurationInfo buildServerConfigurationInfo(Bitcoiny blockchain) {
+
+        BitcoinyBlockchainProvider blockchainProvider = blockchain.getBlockchainProvider();
+
+        // the only reason this is called is to ensure the current server is set on the blockchain provider,
+        // if there is an exception, then ignore it
+        try {
+            blockchainProvider.getCurrentHeight();
+        } catch (ForeignBlockchainException e) {
+            LOGGER.warn("Problems getting block height before building server configuration infos");
+        }
+
+        ChainableServer currentServer = blockchainProvider.getCurrentServer();
+
+        return new ServerConfigurationInfo(
+                buildInfos(blockchainProvider.getServers(), currentServer).stream()
+                        .sorted(Comparator.comparing(ServerInfo::isCurrent).reversed())
+                        .collect(Collectors.toList()),
+                buildInfos(blockchainProvider.getRemainingServers(), currentServer),
+                buildInfos(blockchainProvider.getUselessServers(), currentServer)
+            );
+    }
+
+    public static ServerInfo buildInfo(ChainableServer server, boolean isCurrent) {
+        return new ServerInfo(
+                server.averageResponseTime(),
+                server.getHostName(),
+                server.getPort(),
+                server.getConnectionType().toString(),
+                isCurrent);
+
+    }
+
+    public static List<ServerInfo> buildInfos(Collection<ChainableServer> servers, ChainableServer currentServer) {
+
+        List<ServerInfo> infos = new ArrayList<>( servers.size() );
+
+        for( ChainableServer server : servers )
+        {
+            infos.add(buildInfo(server, server.equals(currentServer)));
+        }
+
+        return infos;
+    }
+
+    /**
+     * Set Fee Per Kb
+     *
+     * @param bitcoiny the blockchain support
+     * @param fee the fee in satoshis
+     *
+     * @return the fee if valid
+     *
+     * @throws IllegalArgumentException if invalid
+     */
+    public static String setFeePerKb(Bitcoiny bitcoiny, String fee) throws IllegalArgumentException {
+
+        long satoshis = Long.parseLong(fee);
+        if( satoshis < 0 ) throw new IllegalArgumentException("can't set fee to negative number");
+
+        bitcoiny.setFeePerKb(Coin.valueOf(satoshis) );
+
+        return String.valueOf(bitcoiny.getFeePerKb().value);
+    }
+
+    /**
+     * Set Fee Ceiling
+     *
+     * @param bitcoiny the blockchain support
+     * @param fee the fee in satoshis
+     *
+     * @return the fee if valid
+     *
+     * @throws IllegalArgumentException if invalid
+     */
+    public static String setFeeCeiling(Bitcoiny bitcoiny, String fee)  throws IllegalArgumentException{
+
+        long satoshis = Long.parseLong(fee);
+        if( satoshis < 0 ) throw new IllegalArgumentException("can't set fee to negative number");
+
+        bitcoiny.setFeeCeiling( Long.parseLong(fee));
+
+        return String.valueOf(bitcoiny.getFeeCeiling());
+    }
+
+    /**
+     * Get P2Sh Address For AT
+     *
+     * @param atAddress the AT address
+     * @param repository the repository
+     * @param bitcoiny the blockchain data
+     * @param crossChainTradeData the trade data
+     *
+     * @return the p2sh address for the trade, if there is one
+     *
+     * @throws DataException
+     */
+    public static Optional<String> getP2ShAddressForAT(
+            String atAddress,
+            Repository repository,
+            Bitcoiny bitcoiny,
+            CrossChainTradeData crossChainTradeData) throws DataException {
+
+        // get the trade bot data for the AT address
+        Optional<TradeBotData> tradeBotDataOptional
+                = repository.getCrossChainRepository()
+                .getAllTradeBotData().stream()
+                .filter(data -> data.getAtAddress().equals(atAddress))
+                .findFirst();
+
+        if( tradeBotDataOptional.isEmpty() )
+            return Optional.empty();
+
+        TradeBotData tradeBotData = tradeBotDataOptional.get();
+
+        // return the p2sh address from the trade bot
+        return getP2ShFromTradeBot(bitcoiny, crossChainTradeData, tradeBotData);
+    }
+
+    /**
+     * Get Foreign Trade Summaries
+     *
+     * @param foreignBlockchain the blockchain traded on
+     * @param repository the repository
+     * @param bitcoiny data for the blockchain trade on
+     * @return
+     * @throws DataException
+     * @throws ForeignBlockchainException
+     */
+    public static List<TransactionSummary> getForeignTradeSummaries(
+            SupportedBlockchain foreignBlockchain,
+            Repository repository,
+            Bitcoiny bitcoiny) throws DataException, ForeignBlockchainException {
+
+        // get all the AT address for the given blockchain
+        List<String> atAddresses
+                = repository.getCrossChainRepository().getAllTradeBotData().stream()
+                    .filter(data -> foreignBlockchain.name().toLowerCase().equals(data.getForeignBlockchain().toLowerCase()))
+                    //.filter( data -> data.getForeignKey().equals( xpriv )) // TODO
+                    .map(data -> data.getAtAddress())
+                    .collect(Collectors.toList());
+
+        List<TransactionSummary> summaries = new ArrayList<>( atAddresses.size() * 2 );
+
+        // for each AT address, gather the data and get foreign trade summary
+        for( String atAddress: atAddresses) {
+
+            ATData atData = repository.getATRepository().fromATAddress(atAddress);
+
+            CrossChainTradeData crossChainTradeData = foreignBlockchain.getLatestAcct().populateTradeData(repository, atData);
+
+            Optional<String> address = getP2ShAddressForAT(atAddress,repository, bitcoiny, crossChainTradeData);
+
+            if( address.isPresent()){
+                summaries.add( getForeignTradeSummary( bitcoiny, address.get(), atAddress ) );
+            }
+        }
+
+        return summaries;
+    }
+
+    /**
+     * Add Server
+     *
+     * Add foreign blockchain server to list of candidates.
+     *
+     * @param bitcoiny the foreign blockchain
+     * @param server the server
+     *
+     * @return true if the add was successful, otherwise false
+     */
+    public static boolean addServer(Bitcoiny bitcoiny, ChainableServer server) {
+
+        return bitcoiny.getBlockchainProvider().addServer(server);
+    }
+
+    /**
+     * Remove Server
+     *
+     * Remove foreign blockchain server from list of candidates.
+     *
+     * @param bitcoiny the foreign blockchain
+     * @param server the server
+     *
+     * @return true if the removal was successful, otherwise false
+     */
+    public static boolean removeServer(Bitcoiny bitcoiny, ChainableServer server){
+
+        return bitcoiny.getBlockchainProvider().removeServer(server);
+    }
+
+    /**
+     * Set Current Server
+     *
+     * Set the server to use the intended foreign blockchain.
+     *
+     * @param bitcoiny the foreign blockchain
+     * @param serverInfo the server configuration information
+     *
+     * @return the server connection information
+     */
+    public static ServerConnectionInfo setCurrentServer(Bitcoiny bitcoiny, ServerInfo serverInfo) throws ForeignBlockchainException {
+
+        final BitcoinyBlockchainProvider blockchainProvider = bitcoiny.getBlockchainProvider();
+
+        ChainableServer server = blockchainProvider.getServer(
+                serverInfo.getHostName(),
+                ChainableServer.ConnectionType.valueOf(serverInfo.getConnectionType()),
+                serverInfo.getPort()
+        );
+
+        ChainableServerConnection connection = blockchainProvider.setCurrentServer(server, CORE_API_CALL).get();
+
+        return new ServerConnectionInfo(
+                new ServerInfo(
+                        0,
+                        serverInfo.getHostName(),
+                        serverInfo.getPort(),
+                        serverInfo.getConnectionType(),
+                        connection.isSuccess()
+                ),
+                CORE_API_CALL,
+                true,
+                connection.isSuccess() ,
+                System.currentTimeMillis(),
+                connection.getNotes()
+        );
+    }
+
+    /**
+     * Get P2Sh From Trade Bot
+     *
+     * Get P2Sh address from the trade bot
+     *
+     * @param bitcoiny the blockchain for the trade
+     * @param crossChainTradeData the cross cahin data for the trade
+     * @param tradeBotData the data from the trade bot
+     *
+     * @return the address, original format
+     */
+    private static Optional<String> getP2ShFromTradeBot(
+            Bitcoiny bitcoiny,
+            CrossChainTradeData crossChainTradeData,
+            TradeBotData tradeBotData) {
+
+        // Pirate Chain does not support this
+        if( SupportedBlockchain.PIRATECHAIN.name().equals(tradeBotData.getForeignBlockchain())) return Optional.empty();
+
+        // need to get the trade PKH from the trade bot
+        if( tradeBotData.getTradeForeignPublicKeyHash() == null ) return Optional.empty();
+
+        // need to get the lock time from the trade bot
+        if( tradeBotData.getLockTimeA() == null ) return Optional.empty();
+
+        // need to get the creator PKH from the trade bot
+        if( crossChainTradeData.creatorForeignPKH == null ) return  Optional.empty();
+
+        // need to get the secret from the trade bot
+        if( tradeBotData.getHashOfSecret() == null ) return Optional.empty();
+
+        // if we have the necessary data from the trade bot,
+        // then build the redeem script necessary to facilitate the trade
+        byte[] redeemScriptBytes
+                = BitcoinyHTLC.buildScript(
+                    tradeBotData.getTradeForeignPublicKeyHash(),
+                    tradeBotData.getLockTimeA(),
+                    crossChainTradeData.creatorForeignPKH,
+                    tradeBotData.getHashOfSecret()
+            );
+
+
+        String p2shAddress = bitcoiny.deriveP2shAddress(redeemScriptBytes);
+
+        return Optional.of(p2shAddress);
+    }
+
+    /**
+     * Get Foreign Trade Summary
+     *
+     * @param bitcoiny the blockchain the trade occurred on
+     * @param p2shAddress the p2sh address
+     * @param atAddress the AT address the p2sh address is derived from
+     *
+     * @return the summary
+     *
+     * @throws ForeignBlockchainException
+     */
+    public static TransactionSummary getForeignTradeSummary(Bitcoiny bitcoiny, String p2shAddress, String atAddress)
+            throws ForeignBlockchainException {
+        Script outputScript = ScriptBuilder.createOutputScript(
+                Address.fromString(bitcoiny.getNetworkParameters(), p2shAddress));
+
+        List<TransactionHash> hashes
+                = bitcoiny.getAddressTransactions( outputScript.getProgram(), true);
+
+        TransactionSummary summary;
+
+        if(hashes.isEmpty()){
+            summary
+                    = new TransactionSummary(
+                            atAddress,
+                            p2shAddress,
+                    "N/A",
+                    "N/A",
+                    0,
+                    0,
+                    0,
+                    0,
+                    "N/A",
+                    0,
+                    0,
+                    0,
+                    0);
+        }
+        else if( hashes.size() == 1) {
+            AtomicTransactionData data = buildTransactionData(bitcoiny, hashes.get(0));
+            summary = new TransactionSummary(
+                    atAddress,
+                    p2shAddress,
+                    "N/A",
+                    data.hash.txHash,
+                    data.timestamp,
+                    data.totalAmount,
+                    getTotalInput(bitcoiny, data.inputs) - data.totalAmount,
+                    data.size,
+                    "N/A",
+                    0,
+                    0,
+                    0,
+                    0);
+        }
+        // otherwise assuming there is 2 and only 2 hashes
+        else {
+            List<AtomicTransactionData> atomicTransactionDataList = new ArrayList<>(2);
+
+            // hashes -> data
+            for( TransactionHash hash : hashes){
+                atomicTransactionDataList.add(buildTransactionData(bitcoiny,hash));
+            }
+
+            // sort the transaction data by time
+            List<AtomicTransactionData> sorted
+                    = atomicTransactionDataList.stream()
+                    .sorted((data1, data2) -> data1.timestamp.compareTo(data2.timestamp))
+                    .collect(Collectors.toList());
+
+            // build the summary using the first 2 transactions
+            summary = buildForeignTradeSummary(atAddress, p2shAddress, sorted.get(0), sorted.get(1), bitcoiny);
+        }
+        return summary;
+    }
+
+    /**
+     * Build Foreign Trade Summary
+     *
+     * @param p2shValue the p2sh address, original format
+     * @param lockingTransaction the transaction lock the foreighn coin
+     * @param unlockingTransaction the transaction to unlock the foreign coin
+     * @param bitcoiny the blockchain the trade occurred on
+     *
+     * @return
+     *
+     * @throws ForeignBlockchainException
+     */
+    private static TransactionSummary buildForeignTradeSummary(
+            String atAddress,
+            String p2shValue,
+            AtomicTransactionData lockingTransaction,
+            AtomicTransactionData unlockingTransaction,
+            Bitcoiny bitcoiny) throws ForeignBlockchainException {
+
+        // get sum of the relevant inputs for each transaction
+        long lockingTotalInput = getTotalInput(bitcoiny, lockingTransaction.inputs);
+        long unlockingTotalInput = getTotalInput(bitcoiny, unlockingTransaction.inputs);
+
+        // find the address that has output that matches the total input
+        Optional<Map.Entry<List<String>, Long>> addressValue
+                = lockingTransaction.valueByAddress.entrySet().stream()
+                .filter(entry -> entry.getValue() == unlockingTotalInput).findFirst();
+
+        // set that matching address, if found
+        String p2shAddress;
+        if( addressValue.isPresent() && addressValue.get().getKey().size() == 1 ){
+            p2shAddress = addressValue.get().getKey().get(0);
+        }
+        else {
+            p2shAddress = "N/A";
+        }
+
+        // build summaries with prepared values
+        // the fees are the total amount subtracted by the total transaction input
+        return new TransactionSummary(
+                atAddress,
+                p2shValue,
+                p2shAddress,
+                lockingTransaction.hash.txHash,
+                lockingTransaction.timestamp,
+                lockingTransaction.totalAmount,
+                lockingTotalInput - lockingTransaction.totalAmount,
+                lockingTransaction.size,
+                unlockingTransaction.hash.txHash,
+                unlockingTransaction.timestamp,
+                unlockingTransaction.totalAmount,
+                unlockingTotalInput - unlockingTransaction.totalAmount,
+                unlockingTransaction.size
+                );
+
+    }
+
+    /**
+     * Build Transaction Data
+     *
+     * @param bitcoiny the coin for the transaction
+     * @param hash the hash for the transaction
+     *
+     * @return the data for the transaction
+     *
+     * @throws ForeignBlockchainException
+     */
+    private static AtomicTransactionData  buildTransactionData( Bitcoiny bitcoiny, TransactionHash hash)
+            throws ForeignBlockchainException {
+
+            BitcoinyTransaction transaction = bitcoiny.getTransaction(hash.txHash);
+
+            // destination address list -> value
+            Map<List<String>, Long> valueByAddress = new HashMap<>();
+
+            // for each output in the transaction, index by address list
+            for( BitcoinyTransaction.Output output : transaction.outputs) {
+                valueByAddress.put(output.addresses, output.value);
+            }
+
+            return new AtomicTransactionData(
+                    hash,
+                    transaction.timestamp,
+                    transaction.inputs,
+                    valueByAddress,
+                    transaction.totalAmount,
+                    transaction.size);
+    }
+
+    /**
+     * Get Total Input
+     *
+     * Get the sum of all the inputs used in a list of inputs.
+     *
+     * @param bitcoiny the coin the inputs belong to
+     * @param inputs the inputs
+     *
+     * @return the sum
+     *
+     * @throws ForeignBlockchainException
+     */
+    private static long getTotalInput(Bitcoiny bitcoiny, List<BitcoinyTransaction.Input> inputs)
+            throws ForeignBlockchainException {
+
+        long totalInputOut = 0;
+
+        // for each input, add to total input,
+        // get the indexed transaction output value and add to total value
+        for( BitcoinyTransaction.Input input : inputs){
+
+            BitcoinyTransaction inputOut = bitcoiny.getTransaction(input.outputTxHash);
+            BitcoinyTransaction.Output output = inputOut.outputs.get(input.outputVout);
+            totalInputOut += output.value;
+        }
+        return totalInputOut;
+    }
+
+    /**
+     * Get Notes
+     *
+     * Build notes from an exception thrown.
+     *
+     * @param e the exception
+     *
+     * @return the exception message or the exception class name
+     */
+    public static String getNotes(Exception e) {
+        return e.getMessage() + " (" + e.getClass().getSimpleName() + ")";
+    }
+
+    /**
+     * Build Server Connection History
+     *
+     * @param bitcoiny the foreign blockchain
+     *
+     * @return the history of connections from latest to first
+     */
+    public static List<ServerConnectionInfo> buildServerConnectionHistory(Bitcoiny bitcoiny) {
+
+        return bitcoiny.getBlockchainProvider().getServerConnections().stream()
+                .sorted(Comparator.comparing(ChainableServerConnection::getCurrentTimeMillis).reversed())
+                .map(
+                    connection -> new ServerConnectionInfo(
+                            serverToServerInfo( connection.getServer()),
+                            connection.getRequestedBy(),
+                            connection.isOpen(),
+                            connection.isSuccess(),
+                            connection.getCurrentTimeMillis(),
+                            connection.getNotes()
+                    )
+                )
+                .collect(Collectors.toList());
+    }
+
+    /**
+     * Server To Server Info
+     *
+     * Make a server info object from a server object.
+     *
+     * @param server the server
+     *
+     * @return the server info
+     */
+    private static ServerInfo serverToServerInfo(ChainableServer server) {
+
+        return new ServerInfo(
+                0,
+                server.getHostName(),
+                server.getPort(),
+                server.getConnectionType().toString(),
+                false);
+    }
+}

src/main/java/org/qortal/api/resource/PollsResource.java

@@ -13,6 +13,8 @@ import org.qortal.api.ApiErrors;
 import org.qortal.api.ApiException;
 import org.qortal.api.ApiExceptionFactory;
 import org.qortal.api.model.PollVotes;
+import org.qortal.crypto.Crypto;
+import org.qortal.data.account.AccountData;
 import org.qortal.data.transaction.CreatePollTransactionData;
 import org.qortal.data.transaction.VoteOnPollTransactionData;
 import org.qortal.data.voting.PollData;
@@ -129,12 +131,25 @@ public class PollsResource {
                     for (PollOptionData optionData : pollData.getPollOptions()) {
                             voteCountMap.put(optionData.getOptionName(), 0);
                     }
+                    // Initialize map for counting vote weights
+                    Map<String, Integer> voteWeightMap = new HashMap<>();
+                    for (PollOptionData optionData : pollData.getPollOptions()) {
+                            voteWeightMap.put(optionData.getOptionName(), 0);
+                    }
 
                     int totalVotes = 0;
+                    int totalWeight = 0;
                     for (VoteOnPollData vote : votes) {
+                            String voter = Crypto.toAddress(vote.getVoterPublicKey());
+                            AccountData voterData = repository.getAccountRepository().getAccount(voter);
+                            int voteWeight = voterData.getBlocksMinted() + voterData.getBlocksMintedPenalty();
+                            if (voteWeight < 0) voteWeight = 0;
+                            totalWeight += voteWeight;
+
                             String selectedOption = pollData.getPollOptions().get(vote.getOptionIndex()).getOptionName();
                             if (voteCountMap.containsKey(selectedOption)) {
                                     voteCountMap.put(selectedOption, voteCountMap.get(selectedOption) + 1);
+                                    voteWeightMap.put(selectedOption, voteWeightMap.get(selectedOption) + voteWeight);
                                     totalVotes++;
                             }
                     }
@@ -143,11 +158,15 @@ public class PollsResource {
                     List<PollVotes.OptionCount> voteCounts = voteCountMap.entrySet().stream()
                         .map(entry -> new PollVotes.OptionCount(entry.getKey(), entry.getValue()))
                         .collect(Collectors.toList());
+                    // Convert map to list of WeightInfo
+                    List<PollVotes.OptionWeight> voteWeights = voteWeightMap.entrySet().stream()
+                        .map(entry -> new PollVotes.OptionWeight(entry.getKey(), entry.getValue()))
+                        .collect(Collectors.toList());
     
                     if (onlyCounts != null && onlyCounts) {
-                        return new PollVotes(null, totalVotes, voteCounts);
+                        return new PollVotes(null, totalVotes, totalWeight, voteCounts, voteWeights);
                     } else {
-                        return new PollVotes(votes, totalVotes, voteCounts);
+                        return new PollVotes(votes, totalVotes, totalWeight, voteCounts, voteWeights);
                     }
             } catch (ApiException e) {
                     throw e;

src/main/java/org/qortal/api/resource/TransactionsResource.java

@@ -330,8 +330,8 @@ public class TransactionsResource {
 	public enum ConfirmationStatus {
 		CONFIRMED,
 		UNCONFIRMED,
-		BOTH;
-	}
+		BOTH
+    }
 
 	@GET
 	@Path("/search")

src/main/java/org/qortal/api/restricted/resource/AdminResource.java

@@ -24,8 +24,9 @@ import org.qortal.api.model.ActivitySummary;
 import org.qortal.api.model.NodeInfo;
 import org.qortal.api.model.NodeStatus;
 import org.qortal.block.BlockChain;
-import org.qortal.controller.AutoUpdate;
+import org.qortal.controller.BootstrapNode;
 import org.qortal.controller.Controller;
+import org.qortal.controller.RestartNode;
 import org.qortal.controller.Synchronizer;
 import org.qortal.controller.Synchronizer.SynchronizationResult;
 import org.qortal.controller.repository.BlockArchiveRebuilder;
@@ -250,7 +251,38 @@ public class AdminResource {
 				// Not important
 			}
 
-			AutoUpdate.attemptRestart();
+			RestartNode.attemptToRestart();
+
+		}).start();
+
+		return "true";
+	}
+
+	@GET
+	@Path("/bootstrap")
+	@Operation(
+		summary = "Bootstrap",
+		description = "Delete and download new database archive",
+		responses = {
+			@ApiResponse(
+				description = "\"true\"",
+				content = @Content(mediaType = MediaType.TEXT_PLAIN, schema = @Schema(type = "string"))
+			)
+		}
+	)
+	@SecurityRequirement(name = "apiKey")
+	public String bootstrap(@HeaderParam(Security.API_KEY_HEADER) String apiKey) {
+		Security.checkApiCallAllowed(request);
+
+		new Thread(() -> {
+			// Short sleep to allow HTTP response body to be emitted
+			try {
+				Thread.sleep(1000);
+			} catch (InterruptedException e) {
+				// Not important
+			}
+
+			BootstrapNode.attemptToBootstrap();
 
 		}).start();
 
@@ -268,10 +300,7 @@ public class AdminResource {
 		}
 	)
 	@ApiErrors({ApiError.REPOSITORY_ISSUE})
-	@SecurityRequirement(name = "apiKey")
-	public ActivitySummary summary(@HeaderParam(Security.API_KEY_HEADER) String apiKey) {
-		Security.checkApiCallAllowed(request);
-
+	public ActivitySummary summary() {
 		ActivitySummary summary = new ActivitySummary();
 		
 		long now = NTP.getTime();

src/main/java/org/qortal/api/websocket/AdminStatusWebSocket.java

@@ -31,7 +31,7 @@ public class AdminStatusWebSocket extends ApiWebSocket implements Listener {
 			return;
 		}
 
-		EventBus.INSTANCE.addListener(this::listen);
+		EventBus.INSTANCE.addListener(this);
 	}
 
 	@Override

src/main/java/org/qortal/api/websocket/BlocksWebSocket.java

@@ -28,7 +28,7 @@ public class BlocksWebSocket extends ApiWebSocket implements Listener {
 	public void configure(WebSocketServletFactory factory) {
 		factory.register(BlocksWebSocket.class);
 
-		EventBus.INSTANCE.addListener(this::listen);
+		EventBus.INSTANCE.addListener(this);
 	}
 
 	@Override

src/main/java/org/qortal/api/websocket/PresenceWebSocket.java

@@ -86,7 +86,7 @@ public class PresenceWebSocket extends ApiWebSocket implements Listener {
 			return;
 		}
 
-		EventBus.INSTANCE.addListener(this::listen);
+		EventBus.INSTANCE.addListener(this);
 	}
 
 	@Override

src/main/java/org/qortal/api/websocket/TradeBotWebSocket.java

@@ -43,7 +43,7 @@ public class TradeBotWebSocket extends ApiWebSocket implements Listener {
 			// No output this time
 		}
 
-		EventBus.INSTANCE.addListener(this::listen);
+		EventBus.INSTANCE.addListener(this);
 	}
 
 	@Override

src/main/java/org/qortal/api/websocket/TradeOffersWebSocket.java

@@ -67,7 +67,7 @@ public class TradeOffersWebSocket extends ApiWebSocket implements Listener {
 			return;
 		}
 
-		EventBus.INSTANCE.addListener(this::listen);
+		EventBus.INSTANCE.addListener(this);
 	}
 
 	@Override

src/main/java/org/qortal/api/websocket/TradePresenceWebSocket.java

@@ -29,7 +29,7 @@ public class TradePresenceWebSocket extends ApiWebSocket implements Listener {
 
 		populateCurrentInfo();
 
-		EventBus.INSTANCE.addListener(this::listen);
+		EventBus.INSTANCE.addListener(this);
 	}
 
 	@Override

src/main/java/org/qortal/arbitrary/ArbitraryDataBuilder.java

@@ -104,7 +104,7 @@ public class ArbitraryDataBuilder {
         if (latestPut.getMethod() != Method.PUT) {
             throw new DataException("Expected PUT but received PATCH");
         }
-        if (transactionDataList.size() == 0) {
+        if (transactionDataList.isEmpty()) {
             throw new DataException(String.format("No transactions found for name %s, service %s, " +
                             "identifier: %s, since %d", name, service, this.identifierString(), latestPut.getTimestamp()));
         }
@@ -176,7 +176,7 @@ public class ArbitraryDataBuilder {
     }
 
     private void findLatestSignature() throws DataException {
-        if (this.transactions.size() == 0) {
+        if (this.transactions.isEmpty()) {
             throw new DataException("Unable to find latest signature from empty transaction list");
         }
 

src/main/java/org/qortal/arbitrary/ArbitraryDataFile.java

@@ -58,6 +58,9 @@ public class ArbitraryDataFile {
     public static int SHORT_DIGEST_LENGTH = 8;
 
     protected Path filePath;
+    protected byte[] fileContent;
+    private boolean useTemporaryFile;
+
     protected String hash58;
     protected byte[] signature;
     private ArrayList<ArbitraryDataFileChunk> chunks;
@@ -90,8 +93,14 @@ public class ArbitraryDataFile {
         this.signature = signature;
         LOGGER.trace(String.format("File digest: %s, size: %d bytes", this.hash58, fileContent.length));
 
+        this.fileContent = fileContent;
+        this.useTemporaryFile = useTemporaryFile;
+    }
+
+    public void save() throws DataException {
+
         Path outputFilePath;
-        if (useTemporaryFile) {
+        if (this.useTemporaryFile) {
             try {
                 outputFilePath = Files.createTempFile("qortalRawData", null);
                 outputFilePath.toFile().deleteOnExit();
@@ -149,6 +158,7 @@ public class ArbitraryDataFile {
 
             case RAW_DATA:
                 arbitraryDataFile = ArbitraryDataFile.fromRawData(data, signature);
+                arbitraryDataFile.save();
                 break;
         }
 
@@ -324,6 +334,7 @@ public class ArbitraryDataFile {
                             out.flush();
 
                             ArbitraryDataFileChunk chunk = new ArbitraryDataFileChunk(out.toByteArray(), this.signature);
+                            chunk.save();
                             ValidationResult validationResult = chunk.isValid();
                             if (validationResult == ValidationResult.OK) {
                                 this.chunks.add(chunk);
@@ -343,7 +354,7 @@ public class ArbitraryDataFile {
 
     public boolean join() {
         // Ensure we have chunks
-        if (this.chunks != null && this.chunks.size() > 0) {
+        if (this.chunks != null && !this.chunks.isEmpty()) {
 
             // Create temporary path for joined file
             // Use the user-specified temp dir, as it is deterministic, and is more likely to be located on reusable storage hardware
@@ -406,6 +417,10 @@ public class ArbitraryDataFile {
     }
 
     public boolean delete(int attempts) {
+        if (this.filePath == null) {
+            return false;
+        }
+
         // Keep trying to delete the data until it is deleted, or we reach 10 attempts
         for (int i=0; i<attempts; i++) {
             if (this.delete()) {
@@ -424,7 +439,7 @@ public class ArbitraryDataFile {
         boolean success = false;
 
         // Delete the individual chunks
-        if (this.chunks != null && this.chunks.size() > 0) {
+        if (this.chunks != null && !this.chunks.isEmpty()) {
             Iterator iterator = this.chunks.iterator();
             while (iterator.hasNext()) {
                 ArbitraryDataFileChunk chunk = (ArbitraryDataFileChunk) iterator.next();
@@ -467,6 +482,10 @@ public class ArbitraryDataFile {
     }
 
     public byte[] getBytes() {
+        if (this.fileContent != null) {
+            return this.fileContent;
+        }
+
         try {
             return Files.readAllBytes(this.filePath);
         } catch (IOException e) {
@@ -690,7 +709,7 @@ public class ArbitraryDataFile {
     }
 
     public byte[] chunkHashes() throws DataException {
-        if (this.chunks != null && this.chunks.size() > 0) {
+        if (this.chunks != null && !this.chunks.isEmpty()) {
             // Return null if we only have one chunk, with the same hash as the parent
             if (Arrays.equals(this.digest(), this.chunks.get(0).digest())) {
                 return null;
@@ -717,7 +736,7 @@ public class ArbitraryDataFile {
     public List<byte[]> chunkHashList() {
         List<byte[]> chunks = new ArrayList<>();
 
-        if (this.chunks != null && this.chunks.size() > 0) {
+        if (this.chunks != null && !this.chunks.isEmpty()) {
             // Return null if we only have one chunk, with the same hash as the parent
             if (Arrays.equals(this.digest(), this.chunks.get(0).digest())) {
                 return null;
@@ -801,7 +820,7 @@ public class ArbitraryDataFile {
         String outputString = "";
         if (this.chunkCount() > 0) {
             for (ArbitraryDataFileChunk chunk : this.chunks) {
-                if (outputString.length() > 0) {
+                if (!outputString.isEmpty()) {
                     outputString = outputString.concat(",");
                 }
                 outputString = outputString.concat(chunk.digest58());

src/main/java/org/qortal/arbitrary/ArbitraryDataReader.java

@@ -73,7 +73,7 @@ public class ArbitraryDataReader {
         }
 
         // If identifier is a blank string, or reserved keyword "default", treat it as null
-        if (identifier == null || identifier.equals("") || identifier.equals("default")) {
+        if (identifier == null || identifier.isEmpty() || identifier.equals("default")) {
             identifier = null;
         }
 

src/main/java/org/qortal/arbitrary/ArbitraryDataRenderer.java

@@ -199,7 +199,7 @@ public class ArbitraryDataRenderer {
     }
 
     private String getFilename(String directory, String userPath) {
-        if (userPath == null || userPath.endsWith("/") || userPath.equals("")) {
+        if (userPath == null || userPath.endsWith("/") || userPath.isEmpty()) {
             // Locate index file
             List<String> indexFiles = ArbitraryDataRenderer.indexFiles();
             for (String indexFile : indexFiles) {

src/main/java/org/qortal/arbitrary/ArbitraryDataResource.java

@@ -52,7 +52,7 @@ public class ArbitraryDataResource {
         this.service = service;
 
         // If identifier is a blank string, or reserved keyword "default", treat it as null
-        if (identifier == null || identifier.equals("") || identifier.equals("default")) {
+        if (identifier == null || identifier.isEmpty() || identifier.equals("default")) {
             identifier = null;
         }
         this.identifier = identifier;

src/main/java/org/qortal/arbitrary/ArbitraryDataTransactionBuilder.java

@@ -81,7 +81,7 @@ public class ArbitraryDataTransactionBuilder {
         this.service = service;
 
         // If identifier is a blank string, or reserved keyword "default", treat it as null
-        if (identifier == null || identifier.equals("") || identifier.equals("default")) {
+        if (identifier == null || identifier.isEmpty() || identifier.equals("default")) {
             identifier = null;
         }
         this.identifier = identifier;

src/main/java/org/qortal/arbitrary/ArbitraryDataWriter.java

@@ -78,7 +78,7 @@ public class ArbitraryDataWriter {
         this.compression = compression;
 
         // If identifier is a blank string, or reserved keyword "default", treat it as null
-        if (identifier == null || identifier.equals("") || identifier.equals("default")) {
+        if (identifier == null || identifier.isEmpty() || identifier.equals("default")) {
             identifier = null;
         }
         this.identifier = identifier;

src/main/java/org/qortal/at/AT.java

@@ -132,7 +132,7 @@ public class AT {
 		// Nothing happened?
 		if (state.getSteps() == 0 && Arrays.equals(stateHash, latestAtStateData.getStateHash()))
 			// We currently want to execute frozen ATs, to maintain backwards support.
-			if (state.isFrozen() == false)
+			if (!state.isFrozen())
 				// this.atStateData will be null
 				return Collections.emptyList();
 

src/main/java/org/qortal/at/QortalATAPI.java

@@ -522,6 +522,10 @@ public class QortalATAPI extends API {
 
 	/** Returns AT account's lastReference */
 	private byte[] getLastReference() {
+		// If we have transactions already, then use signature from last transaction
+		if (!this.transactions.isEmpty())
+			return this.transactions.get(this.transactions.size() - 1).getTransactionData().getSignature();
+
 		try {
 			// Look up AT's account's last reference from repository
 			Account atAccount = this.getATAccount();

src/main/java/org/qortal/block/Block.java

@@ -1061,8 +1061,10 @@ public class Block {
 			return ValidationResult.MINTER_NOT_ACCEPTED;
 
 		long expectedTimestamp = calcTimestamp(parentBlockData, this.blockData.getMinterPublicKey(), minterLevel);
-		if (this.blockData.getTimestamp() != expectedTimestamp)
+		if (this.blockData.getTimestamp() != expectedTimestamp) {
+			LOGGER.debug(String.format("timestamp mismatch! block had %s but we expected %s", this.blockData.getTimestamp(), expectedTimestamp));
 			return ValidationResult.TIMESTAMP_INCORRECT;
+		}
 
 		return ValidationResult.OK;
 	}
@@ -1084,7 +1086,7 @@ public class Block {
 
 		// Online accounts should only be included in designated blocks; all others must be empty
 		if (!this.isOnlineAccountsBlock()) {
-			if (this.blockData.getOnlineAccountsCount() != 0 || accountIndexes.size() != 0) {
+			if (this.blockData.getOnlineAccountsCount() != 0 || !accountIndexes.isEmpty()) {
 				return ValidationResult.ONLINE_ACCOUNTS_INVALID;
 			}
 			// Not a designated online accounts block and account count is 0. Everything is correct so no need to validate further.
@@ -1309,6 +1311,9 @@ public class Block {
 					if (!transaction.isConfirmable()) {
 						return ValidationResult.TRANSACTION_NOT_CONFIRMABLE;
 					}
+					if (!transaction.isConfirmableAtHeight(this.blockData.getHeight())) {
+						return ValidationResult.TRANSACTION_NOT_CONFIRMABLE;
+					}
 				}
 
 				// Check transaction isn't already included in a block
@@ -1545,12 +1550,22 @@ public class Block {
 				processBlockRewards();
 			}
 
-			if (this.blockData.getHeight() == 212937)
+			if (this.blockData.getHeight() == 212937) {
 				// Apply fix for block 212937
 				Block212937.processFix(this);
+			}
 
-			else if (this.blockData.getHeight() == BlockChain.getInstance().getSelfSponsorshipAlgoV1Height())
+			if (this.blockData.getHeight() == BlockChain.getInstance().getSelfSponsorshipAlgoV1Height()) {
 				SelfSponsorshipAlgoV1Block.processAccountPenalties(this);
+			}
+
+			if (this.blockData.getHeight() == BlockChain.getInstance().getSelfSponsorshipAlgoV2Height()) {
+				SelfSponsorshipAlgoV2Block.processAccountPenalties(this);
+			}
+
+			if (this.blockData.getHeight() == BlockChain.getInstance().getSelfSponsorshipAlgoV3Height()) {
+				SelfSponsorshipAlgoV3Block.processAccountPenalties(this);
+			}
 		}
 
 		// We're about to (test-)process a batch of transactions,
@@ -1835,13 +1850,23 @@ public class Block {
 			// Invalidate expandedAccounts as they may have changed due to orphaning TRANSFER_PRIVS transactions, etc.
 			this.cachedExpandedAccounts = null;
 
-			if (this.blockData.getHeight() == 212937)
+			if (this.blockData.getHeight() == 212937) {
 				// Revert fix for block 212937
 				Block212937.orphanFix(this);
+			}
 
-			else if (this.blockData.getHeight() == BlockChain.getInstance().getSelfSponsorshipAlgoV1Height())
+			if (this.blockData.getHeight() == BlockChain.getInstance().getSelfSponsorshipAlgoV1Height()) {
 				SelfSponsorshipAlgoV1Block.orphanAccountPenalties(this);
+			}
 
+			if (this.blockData.getHeight() == BlockChain.getInstance().getSelfSponsorshipAlgoV2Height()) {
+				SelfSponsorshipAlgoV2Block.orphanAccountPenalties(this);
+			}
+
+			if (this.blockData.getHeight() == BlockChain.getInstance().getSelfSponsorshipAlgoV3Height()) {
+				SelfSponsorshipAlgoV3Block.orphanAccountPenalties(this);
+			}
+			
 			// Account levels and block rewards are only processed/orphaned on block reward distribution blocks
 			if (this.isRewardDistributionBlock()) {
 				// Block rewards, including transaction fees, removed after transactions undone
@@ -2088,7 +2113,7 @@ public class Block {
 		return Block.isOnlineAccountsBlock(this.getBlockData().getHeight());
 	}
 
-	private static boolean isOnlineAccountsBlock(int height) {
+	public static boolean isOnlineAccountsBlock(int height) {
 		// After feature trigger, only certain blocks contain online accounts
 		if (height >= BlockChain.getInstance().getBlockRewardBatchStartHeight()) {
 			final int leadingBlockCount = BlockChain.getInstance().getBlockRewardBatchAccountsBlockCount();
@@ -2539,5 +2564,4 @@ public class Block {
 			LOGGER.info(() -> String.format("Unable to log block debugging info: %s", e.getMessage()));
 		}
 	}
-
 }

src/main/java/org/qortal/block/BlockChain.java

@@ -73,9 +73,14 @@ public class BlockChain {
 		increaseOnlineAccountsDifficultyTimestamp,
 		onlineAccountMinterLevelValidationHeight,
 		selfSponsorshipAlgoV1Height,
+		selfSponsorshipAlgoV2Height,
+		selfSponsorshipAlgoV3Height,
 		feeValidationFixTimestamp,
 		chatReferenceTimestamp,
-		arbitraryOptionalFeeTimestamp;
+		arbitraryOptionalFeeTimestamp,
+		unconfirmableRewardSharesHeight,
+		disableTransferPrivsTimestamp,
+		enableTransferPrivsTimestamp
 	}
 
 	// Custom transaction fees
@@ -198,6 +203,7 @@ public class BlockChain {
 
 	/** Minimum time to retain online account signatures (ms) for block validity checks. */
 	private long onlineAccountSignaturesMinLifetime;
+
 	/** Maximum time to retain online account signatures (ms) for block validity checks, to allow for clock variance. */
 	private long onlineAccountSignaturesMaxLifetime;
 
@@ -208,6 +214,15 @@ public class BlockChain {
 	/** Snapshot timestamp for self sponsorship algo V1 */
 	private long selfSponsorshipAlgoV1SnapshotTimestamp;
 
+	/** Snapshot timestamp for self sponsorship algo V2 */
+	private long selfSponsorshipAlgoV2SnapshotTimestamp;
+
+	/** Snapshot timestamp for self sponsorship algo V3 */
+	private long selfSponsorshipAlgoV3SnapshotTimestamp;
+
+	/** Reference timestamp for self sponsorship algo V1 block height */
+	private long referenceTimestampBlock;
+
 	/** Feature-trigger timestamp to modify behaviour of various transactions that support mempow */
 	private long mempowTransactionUpdatesTimestamp;
 
@@ -224,6 +239,8 @@ public class BlockChain {
 	 * data and to base online accounts decisions on. */
 	private int blockRewardBatchAccountsBlockCount;
 
+	private String penaltyFixHash;
+
 	/** Max reward shares by block height */
 	public static class MaxRewardSharesByTimestamp {
 		public long timestamp;
@@ -266,7 +283,7 @@ public class BlockChain {
 		try {
 			// Create JAXB context aware of Settings
 			jc = JAXBContextFactory.createContext(new Class[] {
-				BlockChain.class, GenesisBlock.GenesisInfo.class
+					BlockChain.class, GenesisBlock.GenesisInfo.class
 			}, null);
 
 			// Create unmarshaller
@@ -394,12 +411,29 @@ public class BlockChain {
 		return this.blockRewardBatchAccountsBlockCount;
 	}
 
+	public String getPenaltyFixHash() {
+		return this.penaltyFixHash;
+	}
 
-	// Self sponsorship algo
+	// Self sponsorship algo V1
 	public long getSelfSponsorshipAlgoV1SnapshotTimestamp() {
 		return this.selfSponsorshipAlgoV1SnapshotTimestamp;
 	}
 
+	// Self sponsorship algo V2
+	public long getSelfSponsorshipAlgoV2SnapshotTimestamp() {
+		return this.selfSponsorshipAlgoV2SnapshotTimestamp;
+	}
+
+	// Self sponsorship algo V3
+	public long getSelfSponsorshipAlgoV3SnapshotTimestamp() {
+		return this.selfSponsorshipAlgoV3SnapshotTimestamp;
+	}
+
+	// Self sponsorship algo V3
+	public long getReferenceTimestampBlock() {
+		return this.referenceTimestampBlock;
+	}
 	// Feature-trigger timestamp to modify behaviour of various transactions that support mempow
 	public long getMemPoWTransactionUpdatesTimestamp() {
 		return this.mempowTransactionUpdatesTimestamp;
@@ -540,6 +574,14 @@ public class BlockChain {
 		return this.featureTriggers.get(FeatureTrigger.selfSponsorshipAlgoV1Height.name()).intValue();
 	}
 
+	public int getSelfSponsorshipAlgoV2Height() {
+		return this.featureTriggers.get(FeatureTrigger.selfSponsorshipAlgoV2Height.name()).intValue();
+	}
+
+	public int getSelfSponsorshipAlgoV3Height() {
+		return this.featureTriggers.get(FeatureTrigger.selfSponsorshipAlgoV3Height.name()).intValue();
+	}
+
 	public long getOnlineAccountMinterLevelValidationHeight() {
 		return this.featureTriggers.get(FeatureTrigger.onlineAccountMinterLevelValidationHeight.name()).intValue();
 	}
@@ -556,6 +598,17 @@ public class BlockChain {
 		return this.featureTriggers.get(FeatureTrigger.arbitraryOptionalFeeTimestamp.name()).longValue();
 	}
 
+	public int getUnconfirmableRewardSharesHeight() {
+		return this.featureTriggers.get(FeatureTrigger.unconfirmableRewardSharesHeight.name()).intValue();
+	}
+
+	public long getDisableTransferPrivsTimestamp() {
+		return this.featureTriggers.get(FeatureTrigger.disableTransferPrivsTimestamp.name()).longValue();
+	}
+
+	public long getEnableTransferPrivsTimestamp() {
+		return this.featureTriggers.get(FeatureTrigger.enableTransferPrivsTimestamp.name()).longValue();
+	}
 
 	// More complex getters for aspects that change by height or timestamp
 
@@ -742,7 +795,7 @@ public class BlockChain {
 
 	/**
 	 * Some sort of start-up/initialization/checking method.
-	 * 
+	 *
 	 * @throws SQLException
 	 */
 	public static void validate() throws DataException {

src/main/java/org/qortal/block/SelfSponsorshipAlgoV1Block.java

@@ -28,7 +28,6 @@ public final class SelfSponsorshipAlgoV1Block {
 
 	private static final Logger LOGGER = LogManager.getLogger(SelfSponsorshipAlgoV1Block.class);
 
-
 	private SelfSponsorshipAlgoV1Block() {
 		/* Do not instantiate */
 	}
@@ -133,4 +132,4 @@ public final class SelfSponsorshipAlgoV1Block {
 		return Base58.encode(Crypto.digest(StringUtils.join(penaltyAddresses).getBytes(StandardCharsets.UTF_8)));
 	}
 
-}
+}

src/main/java/org/qortal/block/SelfSponsorshipAlgoV2Block.java

@@ -0,0 +1,143 @@
+package org.qortal.block;
+
+import org.apache.commons.lang3.StringUtils;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.qortal.account.SelfSponsorshipAlgoV2;
+import org.qortal.api.model.AccountPenaltyStats;
+import org.qortal.crypto.Crypto;
+import org.qortal.data.account.AccountData;
+import org.qortal.data.account.AccountPenaltyData;
+import org.qortal.repository.DataException;
+import org.qortal.repository.Repository;
+import org.qortal.utils.Base58;
+
+import java.nio.charset.StandardCharsets;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * Self Sponsorship AlgoV2 Block
+ * <p>
+ * Selected block for the initial run on the "self sponsorship detection algorithm"
+ */
+public final class SelfSponsorshipAlgoV2Block {
+
+	private static final Logger LOGGER = LogManager.getLogger(SelfSponsorshipAlgoV2Block.class);
+
+	private SelfSponsorshipAlgoV2Block() {
+		/* Do not instantiate */
+	}
+
+	public static void processAccountPenalties(Block block) throws DataException {
+		LOGGER.info("Process Self Sponsorship Algo V2 - this will take a while...");
+		logPenaltyStats(block.repository);
+		long startTime = System.currentTimeMillis();
+		Set<AccountPenaltyData> penalties = getAccountPenalties(block.repository, -5000000);
+		block.repository.getAccountRepository().updateBlocksMintedPenalties(penalties);
+		long totalTime = System.currentTimeMillis() - startTime;
+		String hash = getHash(penalties.stream().map(p -> p.getAddress()).collect(Collectors.toList()));
+		LOGGER.info("{} penalty addresses processed (hash: {}). Total time taken: {} seconds", penalties.size(), hash, (int)(totalTime / 1000.0f));
+		logPenaltyStats(block.repository);
+
+		int updatedCount = updateAccountLevels(block.repository, penalties);
+		LOGGER.info("Account levels updated for {} penalty addresses", updatedCount);
+	}
+
+	public static void orphanAccountPenalties(Block block) throws DataException {
+		LOGGER.info("Orphan Self Sponsorship Algo V2 - this will take a while...");
+		logPenaltyStats(block.repository);
+		long startTime = System.currentTimeMillis();
+		Set<AccountPenaltyData> penalties = getAccountPenalties(block.repository, 5000000);
+		block.repository.getAccountRepository().updateBlocksMintedPenalties(penalties);
+		long totalTime = System.currentTimeMillis() - startTime;
+		String hash = getHash(penalties.stream().map(p -> p.getAddress()).collect(Collectors.toList()));
+		LOGGER.info("{} penalty addresses orphaned (hash: {}). Total time taken: {} seconds", penalties.size(), hash, (int)(totalTime / 1000.0f));
+		logPenaltyStats(block.repository);
+
+		int updatedCount = updateAccountLevels(block.repository, penalties);
+		LOGGER.info("Account levels updated for {} penalty addresses", updatedCount);
+	}
+
+	private static Set<AccountPenaltyData> getAccountPenalties(Repository repository, int penalty) throws DataException {
+		Set<AccountPenaltyData> penalties = new LinkedHashSet<>();
+		List<AccountData> penalizedAddresses = repository.getAccountRepository().getPenaltyAccounts();
+		List<String> assetAddresses = repository.getTransactionRepository().getConfirmedTransferAssetCreators();
+
+		for (AccountData penalizedAddress : penalizedAddresses) {
+			//System.out.println(String.format("address: %s", address));
+			SelfSponsorshipAlgoV2 selfSponsorshipAlgoV2 = new SelfSponsorshipAlgoV2(repository, penalizedAddress.getAddress(), false);
+			selfSponsorshipAlgoV2.run();
+			//System.out.println(String.format("Penalty addresses: %d", selfSponsorshipAlgoV2.getPenaltyAddresses().size()));
+			for (String penaltyAddress : selfSponsorshipAlgoV2.getPenaltyAddresses()) {
+				penalties.add(new AccountPenaltyData(penaltyAddress, penalty));
+			}
+		}
+
+		for (String assetAddress : assetAddresses) {
+			//System.out.println(String.format("address: %s", address));
+			SelfSponsorshipAlgoV2 selfSponsorshipAlgoV2 = new SelfSponsorshipAlgoV2(repository, assetAddress, true);
+			selfSponsorshipAlgoV2.run();
+			//System.out.println(String.format("Penalty addresses: %d", selfSponsorshipAlgoV2.getPenaltyAddresses().size()));
+			for (String penaltyAddress : selfSponsorshipAlgoV2.getPenaltyAddresses()) {
+				penalties.add(new AccountPenaltyData(penaltyAddress, penalty));
+			}
+		}
+
+		return penalties;
+	}
+
+	private static int updateAccountLevels(Repository repository, Set<AccountPenaltyData> accountPenalties) throws DataException {
+		final List<Integer> cumulativeBlocksByLevel = BlockChain.getInstance().getCumulativeBlocksByLevel();
+		final int maximumLevel = cumulativeBlocksByLevel.size() - 1;
+
+		int updatedCount = 0;
+
+		for (AccountPenaltyData penaltyData : accountPenalties) {
+			AccountData accountData = repository.getAccountRepository().getAccount(penaltyData.getAddress());
+			final int effectiveBlocksMinted = accountData.getBlocksMinted() + accountData.getBlocksMintedAdjustment() + accountData.getBlocksMintedPenalty();
+
+			// Shortcut for penalties
+			if (effectiveBlocksMinted < 0) {
+				accountData.setLevel(0);
+				repository.getAccountRepository().setLevel(accountData);
+				updatedCount++;
+				LOGGER.trace(() -> String.format("Block minter %s dropped to level %d", accountData.getAddress(), accountData.getLevel()));
+				continue;
+			}
+
+			for (int newLevel = maximumLevel; newLevel >= 0; --newLevel) {
+				if (effectiveBlocksMinted >= cumulativeBlocksByLevel.get(newLevel)) {
+					accountData.setLevel(newLevel);
+					repository.getAccountRepository().setLevel(accountData);
+					updatedCount++;
+					LOGGER.trace(() -> String.format("Block minter %s increased to level %d", accountData.getAddress(), accountData.getLevel()));
+					break;
+				}
+			}
+		}
+
+		return updatedCount;
+	}
+
+	private static void logPenaltyStats(Repository repository) {
+		try {
+			LOGGER.info(getPenaltyStats(repository));
+
+		} catch (DataException e) {}
+	}
+
+	private static AccountPenaltyStats getPenaltyStats(Repository repository) throws DataException {
+		List<AccountData> accounts = repository.getAccountRepository().getPenaltyAccounts();
+		return AccountPenaltyStats.fromAccounts(accounts);
+	}
+
+	public static String getHash(List<String> penaltyAddresses) {
+		if (penaltyAddresses == null || penaltyAddresses.isEmpty()) {
+			return null;
+		}
+		Collections.sort(penaltyAddresses);
+		return Base58.encode(Crypto.digest(StringUtils.join(penaltyAddresses).getBytes(StandardCharsets.UTF_8)));
+	}
+
+}

src/main/java/org/qortal/block/SelfSponsorshipAlgoV3Block.java

@@ -0,0 +1,136 @@
+package org.qortal.block;
+
+import org.apache.commons.lang3.StringUtils;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.qortal.account.SelfSponsorshipAlgoV3;
+import org.qortal.api.model.AccountPenaltyStats;
+import org.qortal.crypto.Crypto;
+import org.qortal.data.account.AccountData;
+import org.qortal.data.account.AccountPenaltyData;
+import org.qortal.repository.DataException;
+import org.qortal.repository.Repository;
+import org.qortal.utils.Base58;
+
+import java.nio.charset.StandardCharsets;
+import java.util.Collections;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+/**
+ * Self Sponsorship AlgoV3 Block
+ * <p>
+ * Selected block for the initial run on the "self sponsorship detection algorithm"
+ */
+public final class SelfSponsorshipAlgoV3Block {
+
+	private static final Logger LOGGER = LogManager.getLogger(SelfSponsorshipAlgoV3Block.class);
+
+	private SelfSponsorshipAlgoV3Block() {
+		/* Do not instantiate */
+	}
+
+	public static void processAccountPenalties(Block block) throws DataException {
+		LOGGER.info("Process Self Sponsorship Algo V3 - this will take a while...");
+		logPenaltyStats(block.repository);
+		long startTime = System.currentTimeMillis();
+		Set<AccountPenaltyData> penalties = getAccountPenalties(block.repository, -5000000);
+		block.repository.getAccountRepository().updateBlocksMintedPenalties(penalties);
+		long totalTime = System.currentTimeMillis() - startTime;
+		String hash = getHash(penalties.stream().map(p -> p.getAddress()).collect(Collectors.toList()));
+		LOGGER.info("{} penalty addresses processed (hash: {}). Total time taken: {} seconds", penalties.size(), hash, (int)(totalTime / 1000.0f));
+		logPenaltyStats(block.repository);
+
+		int updatedCount = updateAccountLevels(block.repository, penalties);
+		LOGGER.info("Account levels updated for {} penalty addresses", updatedCount);
+	}
+
+	public static void orphanAccountPenalties(Block block) throws DataException {
+		LOGGER.info("Orphan Self Sponsorship Algo V3 - this will take a while...");
+		logPenaltyStats(block.repository);
+		long startTime = System.currentTimeMillis();
+		Set<AccountPenaltyData> penalties = getAccountPenalties(block.repository, 5000000);
+		block.repository.getAccountRepository().updateBlocksMintedPenalties(penalties);
+		long totalTime = System.currentTimeMillis() - startTime;
+		String hash = getHash(penalties.stream().map(p -> p.getAddress()).collect(Collectors.toList()));
+		LOGGER.info("{} penalty addresses orphaned (hash: {}). Total time taken: {} seconds", penalties.size(), hash, (int)(totalTime / 1000.0f));
+		logPenaltyStats(block.repository);
+
+		int updatedCount = updateAccountLevels(block.repository, penalties);
+		LOGGER.info("Account levels updated for {} penalty addresses", updatedCount);
+	}
+
+	public static Set<AccountPenaltyData> getAccountPenalties(Repository repository, int penalty) throws DataException {
+		final long snapshotTimestampV1 = BlockChain.getInstance().getSelfSponsorshipAlgoV1SnapshotTimestamp();
+		final long snapshotTimestampV3 = BlockChain.getInstance().getSelfSponsorshipAlgoV3SnapshotTimestamp();
+		Set<AccountPenaltyData> penalties = new LinkedHashSet<>();
+		List<String> addresses = repository.getTransactionRepository().getConfirmedRewardShareCreatorsExcludingSelfShares();
+		for (String address : addresses) {
+			//System.out.println(String.format("address: %s", address));
+			SelfSponsorshipAlgoV3 selfSponsorshipAlgoV3 = new SelfSponsorshipAlgoV3(repository, address, snapshotTimestampV1, snapshotTimestampV3, false);
+			selfSponsorshipAlgoV3.run();
+			//System.out.println(String.format("Penalty addresses: %d", selfSponsorshipAlgoV3.getPenaltyAddresses().size()));
+
+			for (String penaltyAddress : selfSponsorshipAlgoV3.getPenaltyAddresses()) {
+				penalties.add(new AccountPenaltyData(penaltyAddress, penalty));
+			}
+		}
+		return penalties;
+	}
+
+	private static int updateAccountLevels(Repository repository, Set<AccountPenaltyData> accountPenalties) throws DataException {
+		final List<Integer> cumulativeBlocksByLevel = BlockChain.getInstance().getCumulativeBlocksByLevel();
+		final int maximumLevel = cumulativeBlocksByLevel.size() - 1;
+
+		int updatedCount = 0;
+
+		for (AccountPenaltyData penaltyData : accountPenalties) {
+			AccountData accountData = repository.getAccountRepository().getAccount(penaltyData.getAddress());
+			final int effectiveBlocksMinted = accountData.getBlocksMinted() + accountData.getBlocksMintedAdjustment() + accountData.getBlocksMintedPenalty();
+
+			// Shortcut for penalties
+			if (effectiveBlocksMinted < 0) {
+				accountData.setLevel(0);
+				repository.getAccountRepository().setLevel(accountData);
+				updatedCount++;
+				LOGGER.trace(() -> String.format("Block minter %s dropped to level %d", accountData.getAddress(), accountData.getLevel()));
+				continue;
+			}
+
+			for (int newLevel = maximumLevel; newLevel >= 0; --newLevel) {
+				if (effectiveBlocksMinted >= cumulativeBlocksByLevel.get(newLevel)) {
+					accountData.setLevel(newLevel);
+					repository.getAccountRepository().setLevel(accountData);
+					updatedCount++;
+					LOGGER.trace(() -> String.format("Block minter %s increased to level %d", accountData.getAddress(), accountData.getLevel()));
+					break;
+				}
+			}
+		}
+
+		return updatedCount;
+	}
+
+	private static void logPenaltyStats(Repository repository) {
+		try {
+			LOGGER.info(getPenaltyStats(repository));
+
+		} catch (DataException e) {}
+	}
+
+	private static AccountPenaltyStats getPenaltyStats(Repository repository) throws DataException {
+		List<AccountData> accounts = repository.getAccountRepository().getPenaltyAccounts();
+		return AccountPenaltyStats.fromAccounts(accounts);
+	}
+
+	public static String getHash(List<String> penaltyAddresses) {
+		if (penaltyAddresses == null || penaltyAddresses.isEmpty()) {
+			return null;
+		}
+		Collections.sort(penaltyAddresses);
+		return Base58.encode(Crypto.digest(StringUtils.join(penaltyAddresses).getBytes(StandardCharsets.UTF_8)));
+	}
+
+}

src/main/java/org/qortal/controller/AutoUpdate.java

@@ -291,78 +291,4 @@ public class AutoUpdate extends Thread {
 			return true; // repo was okay, even if applying update failed
 		}
 	}
-
-	public static boolean attemptRestart() {
-		LOGGER.info(String.format("Restarting node..."));
-
-		// Give repository a chance to backup in case things go badly wrong (if enabled)
-		if (Settings.getInstance().getRepositoryBackupInterval() > 0) {
-			try {
-				// Timeout if the database isn't ready for backing up after 60 seconds
-				long timeout = 60 * 1000L;
-				RepositoryManager.backup(true, "backup", timeout);
-
-			} catch (TimeoutException e) {
-				LOGGER.info("Attempt to backup repository failed due to timeout: {}", e.getMessage());
-				// Continue with the node restart anyway...
-			}
-		}
-
-		// Call ApplyUpdate to end this process (unlocking current JAR so it can be replaced)
-		String javaHome = System.getProperty("java.home");
-		LOGGER.debug(String.format("Java home: %s", javaHome));
-
-		Path javaBinary = Paths.get(javaHome, "bin", "java");
-		LOGGER.debug(String.format("Java binary: %s", javaBinary));
-
-		try {
-			List<String> javaCmd = new ArrayList<>();
-			// Java runtime binary itself
-			javaCmd.add(javaBinary.toString());
-
-			// JVM arguments
-			javaCmd.addAll(ManagementFactory.getRuntimeMXBean().getInputArguments());
-
-			// Disable, but retain, any -agentlib JVM arg as sub-process might fail if it tries to reuse same port
-			javaCmd = javaCmd.stream()
-					.map(arg -> arg.replace("-agentlib", AGENTLIB_JVM_HOLDER_ARG))
-					.collect(Collectors.toList());
-
-			// Remove JNI options as they won't be supported by command-line 'java'
-			// These are typically added by the AdvancedInstaller Java launcher EXE
-			javaCmd.removeAll(Arrays.asList("abort", "exit", "vfprintf"));
-
-			// Call ApplyUpdate using JAR
-			javaCmd.addAll(Arrays.asList("-cp", JAR_FILENAME, ApplyUpdate.class.getCanonicalName()));
-
-			// Add command-line args saved from start-up
-			String[] savedArgs = Controller.getInstance().getSavedArgs();
-			if (savedArgs != null)
-				javaCmd.addAll(Arrays.asList(savedArgs));
-
-			LOGGER.info(String.format("Restarting node with: %s", String.join(" ", javaCmd)));
-
-			SysTray.getInstance().showMessage(Translator.INSTANCE.translate("SysTray", "AUTO_UPDATE"), //TODO
-					Translator.INSTANCE.translate("SysTray", "APPLYING_UPDATE_AND_RESTARTING"), //TODO
-					MessageType.INFO);
-
-			ProcessBuilder processBuilder = new ProcessBuilder(javaCmd);
-
-			// New process will inherit our stdout and stderr
-			processBuilder.redirectOutput(ProcessBuilder.Redirect.INHERIT);
-			processBuilder.redirectError(ProcessBuilder.Redirect.INHERIT);
-
-			Process process = processBuilder.start();
-
-			// Nothing to pipe to new process, so close output stream (process's stdin)
-			process.getOutputStream().close();
-
-			return true; // restarting node OK
-		} catch (Exception e) {
-			LOGGER.error(String.format("Failed to restart node: %s", e.getMessage()));
-
-			return true; // repo was okay, even if applying update failed
-		}
-	}
-
 }

src/main/java/org/qortal/controller/BlockMinter.java

@@ -159,8 +159,7 @@ public class BlockMinter extends Thread {
 						int level = mintingAccount.getEffectiveMintingLevel();
 						if (level < BlockChain.getInstance().getMinAccountLevelForBlockSubmissions()) {
 							madi.remove();
-							continue;
-						}
+                        }
 					}
 
 					// Needs a mutable copy of the unmodifiableList
@@ -172,7 +171,7 @@ public class BlockMinter extends Thread {
 
 					// Disregard peers that don't have a recent block, but only if we're not in recovery mode.
 					// In that mode, we want to allow minting on top of older blocks, to recover stalled networks.
-					if (Synchronizer.getInstance().getRecoveryMode() == false)
+					if (!Synchronizer.getInstance().getRecoveryMode())
 						peers.removeIf(Controller.hasNoRecentBlock);
 
 					// Don't mint if we don't have enough up-to-date peers as where would the transactions/consensus come from?
@@ -197,7 +196,7 @@ public class BlockMinter extends Thread {
 
 					// If our latest block isn't recent then we need to synchronize instead of minting, unless we're in recovery mode.
 					if (!peers.isEmpty() && lastBlockData.getTimestamp() < minLatestBlockTimestamp)
-						if (Synchronizer.getInstance().getRecoveryMode() == false && recoverInvalidBlock == false)
+						if (!Synchronizer.getInstance().getRecoveryMode() && !recoverInvalidBlock)
 							continue;
 
 					// There are enough peers with a recent block and our latest block is recent
@@ -474,6 +473,7 @@ public class BlockMinter extends Thread {
 
 		Iterator<TransactionData> unconfirmedTransactionsIterator = unconfirmedTransactions.iterator();
 		final long newBlockTimestamp = newBlock.getBlockData().getTimestamp();
+		final int newBlockHeight = newBlock.getBlockData().getHeight();
 		while (unconfirmedTransactionsIterator.hasNext()) {
 			TransactionData transactionData = unconfirmedTransactionsIterator.next();
 
@@ -481,6 +481,12 @@ public class BlockMinter extends Thread {
 			// Ignore transactions that have expired before this block - they will be cleaned up later
 			if (transactionData.getTimestamp() > newBlockTimestamp || Transaction.getDeadline(transactionData) <= newBlockTimestamp)
 				unconfirmedTransactionsIterator.remove();
+
+			// Ignore transactions that are unconfirmable at this block height
+			Transaction transaction = Transaction.fromData(repository, transactionData);
+			if (!transaction.isConfirmableAtHeight(newBlockHeight)) {
+				unconfirmedTransactionsIterator.remove();
+			}
 		}
 
 		// Sign to create block's signature, needed by Block.isValid()

src/main/java/org/qortal/controller/BootstrapNode.java

@@ -0,0 +1,103 @@
+package org.qortal.controller;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.qortal.ApplyBootstrap;
+import org.qortal.globalization.Translator;
+import org.qortal.gui.SysTray;
+import org.qortal.repository.RepositoryManager;
+import org.qortal.settings.Settings;
+
+import java.awt.TrayIcon.MessageType;
+import java.lang.management.ManagementFactory;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.TimeoutException;
+import java.util.stream.Collectors;
+
+/* NOTE: It is CRITICAL that we use OpenJDK and not Java SE because our uber jar repacks BouncyCastle which, in turn, unsigns BC causing it to be rejected as a security provider by Java SE. */
+
+public class BootstrapNode {
+
+	public static final String JAR_FILENAME = "qortal.jar";
+	public static final String AGENTLIB_JVM_HOLDER_ARG = "-DQORTAL_agentlib=";
+
+	private static final Logger LOGGER = LogManager.getLogger(BootstrapNode.class);
+
+	public static boolean attemptToBootstrap() {
+		LOGGER.info(String.format("Bootstrapping node..."));
+
+		// Give repository a chance to backup in case things go badly wrong (if enabled)
+		if (Settings.getInstance().getRepositoryBackupInterval() > 0) {
+			try {
+				// Timeout if the database isn't ready for backing up after 60 seconds
+				long timeout = 60 * 1000L;
+				RepositoryManager.backup(true, "backup", timeout);
+
+			} catch (TimeoutException e) {
+				LOGGER.info("Attempt to backup repository failed due to timeout: {}", e.getMessage());
+				// Continue with the bootstrap anyway...
+			}
+		}
+
+		// Call ApplyBootstrap to end this process
+		String javaHome = System.getProperty("java.home");
+		LOGGER.debug(String.format("Java home: %s", javaHome));
+
+		Path javaBinary = Paths.get(javaHome, "bin", "java");
+		LOGGER.debug(String.format("Java binary: %s", javaBinary));
+
+		try {
+			List<String> javaCmd = new ArrayList<>();
+
+			// Java runtime binary itself
+			javaCmd.add(javaBinary.toString());
+
+			// JVM arguments
+			javaCmd.addAll(ManagementFactory.getRuntimeMXBean().getInputArguments());
+
+			// Disable, but retain, any -agentlib JVM arg as sub-process might fail if it tries to reuse same port
+			javaCmd = javaCmd.stream()
+					.map(arg -> arg.replace("-agentlib", AGENTLIB_JVM_HOLDER_ARG))
+					.collect(Collectors.toList());
+
+			// Remove JNI options as they won't be supported by command-line 'java'
+			// These are typically added by the AdvancedInstaller Java launcher EXE
+			javaCmd.removeAll(Arrays.asList("abort", "exit", "vfprintf"));
+
+			// Call ApplyBootstrap using JAR
+			javaCmd.addAll(Arrays.asList("-cp", JAR_FILENAME, ApplyBootstrap.class.getCanonicalName()));
+
+			// Add command-line args saved from start-up
+			String[] savedArgs = Controller.getInstance().getSavedArgs();
+			if (savedArgs != null)
+				javaCmd.addAll(Arrays.asList(savedArgs));
+
+			LOGGER.info(String.format("Restarting node with: %s", String.join(" ", javaCmd)));
+
+			SysTray.getInstance().showMessage(Translator.INSTANCE.translate("SysTray", "BOOTSTRAP_NODE"),
+					Translator.INSTANCE.translate("SysTray", "APPLYING_BOOTSTRAP_AND_RESTARTING"),
+					MessageType.INFO);
+
+			ProcessBuilder processBuilder = new ProcessBuilder(javaCmd);
+
+			// New process will inherit our stdout and stderr
+			processBuilder.redirectOutput(ProcessBuilder.Redirect.INHERIT);
+			processBuilder.redirectError(ProcessBuilder.Redirect.INHERIT);
+
+			Process process = processBuilder.start();
+
+			// Nothing to pipe to new process, so close output stream (process's stdin)
+			process.getOutputStream().close();
+
+			return true; // restarting node OK
+		} catch (Exception e) {
+			LOGGER.error(String.format("Failed to restart node: %s", e.getMessage()));
+
+			return true; // repo was okay, even if applying bootstrap failed
+		}
+	}
+}

src/main/java/org/qortal/controller/ChatNotifier.java

@@ -17,7 +17,7 @@ public class ChatNotifier {
 		void notify(ChatTransactionData chatTransactionData);
 	}
 
-	private Map<Session, Listener> listenersBySession = new HashMap<>();
+	private final Map<Session, Listener> listenersBySession = new HashMap<>();
 
 	private ChatNotifier() {
 	}

src/main/java/org/qortal/controller/Controller.java

@@ -564,6 +564,34 @@ public class Controller extends Thread {
 
 		// If GUI is enabled, we're no longer starting up but actually running now
 		Gui.getInstance().notifyRunning();
+
+		// Check every 10 minutes to see if the block minter is running
+		Timer timer = new Timer();
+
+		timer.schedule(new TimerTask() {
+			@Override
+			public void run() {
+				if (blockMinter.isAlive()) {
+					LOGGER.debug("Block minter is running? {}", blockMinter.isAlive());
+				} else if (!blockMinter.isAlive()) {
+					LOGGER.debug("Block minter is running? {}", blockMinter.isAlive());
+					blockMinter.shutdown();
+
+					try {
+						// Wait 10 seconds before restart
+						TimeUnit.SECONDS.sleep(10);
+
+						// Start new block minter thread
+						LOGGER.info("Restarting block minter");
+						blockMinter.start();
+					} catch (InterruptedException e) {
+						// Couldn't start new block minter thread
+						LOGGER.info("Starting block minter failed {}", e);
+						throw new RuntimeException(e);
+					}
+				}
+			}
+		}, 10*60*1000, 10*60*1000);
 	}
 
 	/** Called by AdvancedInstaller's launch EXE in single-instance mode, when an instance is already running. */
@@ -571,7 +599,6 @@ public class Controller extends Thread {
 		// Return as we don't want to run more than one instance
 	}
 
-
 	// Main thread
 
 	@Override
@@ -775,7 +802,7 @@ public class Controller extends Thread {
 
 	public static final Predicate<Peer> hasOldVersion = peer -> {
 		final String minPeerVersion = Settings.getInstance().getMinPeerVersion();
-		return peer.isAtLeastVersion(minPeerVersion) == false;
+		return !peer.isAtLeastVersion(minPeerVersion);
 	};
 
 	public static final Predicate<Peer> hasInvalidSigner = peer -> {
@@ -1921,8 +1948,7 @@ public class Controller extends Thread {
 			// Disregard peers that don't have a recent block
 			if (peerChainTipData.getTimestamp() == null || peerChainTipData.getTimestamp() < minLatestBlockTimestamp) {
 				iterator.remove();
-				continue;
-			}
+            }
 		}
 
 		return peers;
@@ -2002,5 +2028,4 @@ public class Controller extends Thread {
 	public StatsSnapshot getStatsSnapshot() {
 		return this.stats;
 	}
-
 }

src/main/java/org/qortal/controller/OnlineAccountsManager.java

@@ -538,7 +538,6 @@ public class OnlineAccountsManager {
 
                     if (++i > 1 + 1) {
                         iterator.remove();
-                        continue;
                     }
                 }
             } catch (DataException e) {

src/main/java/org/qortal/controller/RestartNode.java

@@ -0,0 +1,102 @@
+package org.qortal.controller;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.qortal.ApplyRestart;
+import org.qortal.globalization.Translator;
+import org.qortal.gui.SysTray;
+import org.qortal.repository.RepositoryManager;
+import org.qortal.settings.Settings;
+
+import java.awt.TrayIcon.MessageType;
+import java.lang.management.ManagementFactory;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.TimeoutException;
+import java.util.stream.Collectors;
+
+/* NOTE: It is CRITICAL that we use OpenJDK and not Java SE because our uber jar repacks BouncyCastle which, in turn, unsigns BC causing it to be rejected as a security provider by Java SE. */
+
+public class RestartNode {
+
+	public static final String JAR_FILENAME = "qortal.jar";
+	public static final String AGENTLIB_JVM_HOLDER_ARG = "-DQORTAL_agentlib=";
+
+	private static final Logger LOGGER = LogManager.getLogger(RestartNode.class);
+
+	public static boolean attemptToRestart() {
+		LOGGER.info(String.format("Restarting node..."));
+
+		// Give repository a chance to backup in case things go badly wrong (if enabled)
+		if (Settings.getInstance().getRepositoryBackupInterval() > 0) {
+			try {
+				// Timeout if the database isn't ready for backing up after 60 seconds
+				long timeout = 60 * 1000L;
+				RepositoryManager.backup(true, "backup", timeout);
+
+			} catch (TimeoutException e) {
+				LOGGER.info("Attempt to backup repository failed due to timeout: {}", e.getMessage());
+				// Continue with the node restart anyway...
+			}
+		}
+
+		// Call ApplyRestart to end this process
+		String javaHome = System.getProperty("java.home");
+		LOGGER.debug(String.format("Java home: %s", javaHome));
+
+		Path javaBinary = Paths.get(javaHome, "bin", "java");
+		LOGGER.debug(String.format("Java binary: %s", javaBinary));
+
+		try {
+			List<String> javaCmd = new ArrayList<>();
+			// Java runtime binary itself
+			javaCmd.add(javaBinary.toString());
+
+			// JVM arguments
+			javaCmd.addAll(ManagementFactory.getRuntimeMXBean().getInputArguments());
+
+			// Disable, but retain, any -agentlib JVM arg as sub-process might fail if it tries to reuse same port
+			javaCmd = javaCmd.stream()
+					.map(arg -> arg.replace("-agentlib", AGENTLIB_JVM_HOLDER_ARG))
+					.collect(Collectors.toList());
+
+			// Remove JNI options as they won't be supported by command-line 'java'
+			// These are typically added by the AdvancedInstaller Java launcher EXE
+			javaCmd.removeAll(Arrays.asList("abort", "exit", "vfprintf"));
+
+			// Call ApplyRestart using JAR
+			javaCmd.addAll(Arrays.asList("-cp", JAR_FILENAME, ApplyRestart.class.getCanonicalName()));
+
+			// Add command-line args saved from start-up
+			String[] savedArgs = Controller.getInstance().getSavedArgs();
+			if (savedArgs != null)
+				javaCmd.addAll(Arrays.asList(savedArgs));
+
+			LOGGER.debug(String.format("Restarting node with: %s", String.join(" ", javaCmd)));
+
+			SysTray.getInstance().showMessage(Translator.INSTANCE.translate("SysTray", "RESTARTING_NODE"),
+					Translator.INSTANCE.translate("SysTray", "APPLYING_RESTARTING_NODE"),
+					MessageType.INFO);
+
+			ProcessBuilder processBuilder = new ProcessBuilder(javaCmd);
+
+			// New process will inherit our stdout and stderr
+			processBuilder.redirectOutput(ProcessBuilder.Redirect.INHERIT);
+			processBuilder.redirectError(ProcessBuilder.Redirect.INHERIT);
+
+			Process process = processBuilder.start();
+
+			// Nothing to pipe to new process, so close output stream (process's stdin)
+			process.getOutputStream().close();
+
+			return true; // restarting node OK
+		} catch (Exception e) {
+			LOGGER.error(String.format("Failed to restart node: %s", e.getMessage()));
+
+			return true; // repo was okay, even if applying restart failed
+		}
+	}
+}

src/main/java/org/qortal/controller/Synchronizer.java

@@ -90,8 +90,8 @@ public class Synchronizer extends Thread {
 	private static Synchronizer instance;
 
 	public enum SynchronizationResult {
-		OK, NOTHING_TO_DO, GENESIS_ONLY, NO_COMMON_BLOCK, TOO_DIVERGENT, NO_REPLY, INFERIOR_CHAIN, INVALID_DATA, NO_BLOCKCHAIN_LOCK, REPOSITORY_ISSUE, SHUTTING_DOWN, CHAIN_TIP_TOO_OLD;
-	}
+		OK, NOTHING_TO_DO, GENESIS_ONLY, NO_COMMON_BLOCK, TOO_DIVERGENT, NO_REPLY, INFERIOR_CHAIN, INVALID_DATA, NO_BLOCKCHAIN_LOCK, REPOSITORY_ISSUE, SHUTTING_DOWN, CHAIN_TIP_TOO_OLD
+    }
 
 	public static class NewChainTipEvent implements Event {
 		private final BlockData priorChainTip;
@@ -258,7 +258,7 @@ public class Synchronizer extends Thread {
 		peers.removeIf(Controller.hasNoRecentBlock);
 
 		final int peersRemoved = peersBeforeComparison - peers.size();
-		if (peersRemoved > 0 && peers.size() > 0)
+		if (peersRemoved > 0 && !peers.isEmpty())
 			LOGGER.debug(String.format("Ignoring %d peers on inferior chains. Peers remaining: %d", peersRemoved, peers.size()));
 
 		if (peers.isEmpty())
@@ -392,7 +392,7 @@ public class Synchronizer extends Thread {
 	private boolean checkRecoveryModeForPeers(List<Peer> qualifiedPeers) {
 		List<Peer> handshakedPeers = Network.getInstance().getImmutableHandshakedPeers();
 
-		if (handshakedPeers.size() > 0) {
+		if (!handshakedPeers.isEmpty()) {
 			// There is at least one handshaked peer
 			if (qualifiedPeers.isEmpty()) {
 				// There are no 'qualified' peers - i.e. peers that have a recent block we can sync to
@@ -406,7 +406,7 @@ public class Synchronizer extends Thread {
 				// If enough time has passed, enter recovery mode, which lifts some restrictions on who we can sync with and when we can mint
 				long recoveryModeTimeout = Settings.getInstance().getRecoveryModeTimeout();
 				if (NTP.getTime() - timePeersLastAvailable > recoveryModeTimeout) {
-					if (recoveryMode == false) {
+					if (!recoveryMode) {
 						LOGGER.info(String.format("Peers have been unavailable for %d minutes. Entering recovery mode...", recoveryModeTimeout/60/1000));
 						recoveryMode = true;
 					}
@@ -445,7 +445,7 @@ public class Synchronizer extends Thread {
 		try (final Repository repository = RepositoryManager.getRepository()) {
 			try {
 
-				if (peers.size() == 0)
+				if (peers.isEmpty())
 					return SynchronizationResult.NOTHING_TO_DO;
 
 				// If our latest block is very old, it's best that we don't try and determine the best peers to sync to.
@@ -663,7 +663,7 @@ public class Synchronizer extends Thread {
 							}
 						}
 
-						if (useCachedSummaries == false) {
+						if (!useCachedSummaries) {
 							if (summariesRequired > 0) {
 								LOGGER.trace(String.format("Requesting %d block summar%s from peer %s after common block %.8s. Peer height: %d", summariesRequired, (summariesRequired != 1 ? "ies" : "y"), peer, Base58.encode(commonBlockSummary.getSignature()), peerHeight));
 
@@ -701,7 +701,7 @@ public class Synchronizer extends Thread {
 
 						// Reduce minChainLength if needed. If we don't have any blocks, this peer will be excluded from chain weight comparisons later in the process, so we shouldn't update minChainLength
 						List <BlockSummaryData> peerBlockSummaries = peer.getCommonBlockData().getBlockSummariesAfterCommonBlock();
-						if (peerBlockSummaries != null && peerBlockSummaries.size() > 0)
+						if (peerBlockSummaries != null && !peerBlockSummaries.isEmpty())
 							if (peerBlockSummaries.size() < minChainLength)
 								minChainLength = peerBlockSummaries.size();
 					}
@@ -728,7 +728,7 @@ public class Synchronizer extends Thread {
 
 					// Calculate our chain weight
 					BigInteger ourChainWeight = BigInteger.valueOf(0);
-					if (ourBlockSummaries.size() > 0)
+					if (!ourBlockSummaries.isEmpty())
 						ourChainWeight = Block.calcChainWeight(commonBlockSummary.getHeight(), commonBlockSummary.getSignature(), ourBlockSummaries, maxHeightForChainWeightComparisons);
 
 					LOGGER.debug(String.format("Our chain weight based on %d blocks is %s", (usingSameLengthChainWeight ? minChainLength : ourBlockSummaries.size()), accurateFormatter.format(ourChainWeight)));
@@ -780,7 +780,7 @@ public class Synchronizer extends Thread {
 					}
 
 					// Now that we have selected the best peers, compare them against each other and remove any with lower weights
-					if (superiorPeersForComparison.size() > 0) {
+					if (!superiorPeersForComparison.isEmpty()) {
 						BigInteger bestChainWeight = null;
 						for (Peer peer : superiorPeersForComparison) {
 							// Increase bestChainWeight if needed
@@ -1290,7 +1290,7 @@ public class Synchronizer extends Thread {
 						cachedCommonBlockData.setBlockSummariesAfterCommonBlock(null);
 
                     // If we have already received newer blocks from this peer that what we have already, go ahead and apply them
-                    if (peerBlocks.size() > 0) {
+                    if (!peerBlocks.isEmpty()) {
 						final BlockData ourLatestBlockData = repository.getBlockRepository().getLastBlock();
 						final Block peerLatestBlock = peerBlocks.get(peerBlocks.size() - 1);
 						final Long minLatestBlockTimestamp = Controller.getMinimumLatestBlockTimestamp();
@@ -1352,7 +1352,7 @@ public class Synchronizer extends Thread {
 
 				if (retryCount >= maxRetries) {
 					// If we have already received newer blocks from this peer that what we have already, go ahead and apply them
-					if (peerBlocks.size() > 0) {
+					if (!peerBlocks.isEmpty()) {
 						final BlockData ourLatestBlockData = repository.getBlockRepository().getLastBlock();
 						final Block peerLatestBlock = peerBlocks.get(peerBlocks.size() - 1);
 						final Long minLatestBlockTimestamp = Controller.getMinimumLatestBlockTimestamp();

src/main/java/org/qortal/controller/arbitrary/ArbitraryDataCleanupManager.java

@@ -208,8 +208,7 @@ public class ArbitraryDataCleanupManager extends Thread {
 									Base58.encode(arbitraryTransactionData.getSignature())));
 
 							ArbitraryTransactionUtils.convertFileToChunks(arbitraryTransactionData, now, STALE_FILE_TIMEOUT);
-							continue;
-						}
+                        }
 					}
 
 				} catch (DataException e) {
@@ -284,8 +283,7 @@ public class ArbitraryDataCleanupManager extends Thread {
 				}
 
 			} catch (DataException e) {
-				continue;
-			}
+            }
 		}
 
 		return pathList;

src/main/java/org/qortal/controller/arbitrary/ArbitraryDataFileListManager.java

@@ -605,7 +605,7 @@ public class ArbitraryDataFileListManager {
                         }
 
                         // Add the chunk hashes
-                        if (arbitraryDataFile.getChunkHashes().size() > 0) {
+                        if (!arbitraryDataFile.getChunkHashes().isEmpty()) {
                             requestedHashes.addAll(arbitraryDataFile.getChunkHashes());
                         }
                         // Add complete file if there are no hashes
@@ -641,7 +641,7 @@ public class ArbitraryDataFileListManager {
         }
 
         // We should only respond if we have at least one hash
-        if (hashes.size() > 0) {
+        if (!hashes.isEmpty()) {
 
             // Firstly we should keep track of the requesting peer, to allow for potential direct connections later
             ArbitraryDataFileManager.getInstance().addRecentDataRequest(requestingPeer);

src/main/java/org/qortal/controller/arbitrary/ArbitraryDataFileManager.java

@@ -43,7 +43,7 @@ public class ArbitraryDataFileManager extends Thread {
     /**
      * Map to keep track of hashes that we might need to relay
      */
-    public List<ArbitraryRelayInfo> arbitraryRelayMap = Collections.synchronizedList(new ArrayList<>());
+    public final List<ArbitraryRelayInfo> arbitraryRelayMap = Collections.synchronizedList(new ArrayList<>());
 
     /**
      * List to keep track of any arbitrary data file hash responses
@@ -53,7 +53,7 @@ public class ArbitraryDataFileManager extends Thread {
     /**
      * List to keep track of peers potentially available for direct connections, based on recent requests
      */
-    private List<ArbitraryDirectConnectionInfo> directConnectionInfo = Collections.synchronizedList(new ArrayList<>());
+    private final List<ArbitraryDirectConnectionInfo> directConnectionInfo = Collections.synchronizedList(new ArrayList<>());
 
     /**
      * Map to keep track of peers requesting QDN data that we hold.
@@ -242,13 +242,14 @@ public class ArbitraryDataFileManager extends Thread {
         boolean isRelayRequest = (requestingPeer != null);
         if (isRelayRequest) {
             if (!fileAlreadyExists) {
-                // File didn't exist locally before the request, and it's a forwarding request, so delete it
-                LOGGER.debug("Deleting file {} because it was needed for forwarding only", Base58.encode(hash));
-
-                // Keep trying to delete the data until it is deleted, or we reach 10 attempts
+                // File didn't exist locally before the request, and it's a forwarding request, so delete it if it exists.
+                // It shouldn't exist on the filesystem yet, but leaving this here just in case.
                 arbitraryDataFile.delete(10);
             }
         }
+        else {
+            arbitraryDataFile.save();
+        }
 
         // If this is a metadata file then we need to update the cache
         if (arbitraryTransactionData != null && arbitraryTransactionData.getMetadataHash() != null) {

src/main/java/org/qortal/controller/arbitrary/ArbitraryDataManager.java

@@ -230,8 +230,7 @@ public class ArbitraryDataManager extends Thread {
 					// Remove transactions that we already have local data for
 					if (hasLocalData(arbitraryTransaction)) {
 						iterator.remove();
-						continue;
-					}
+                    }
 				}
 
 				if (signatures.isEmpty()) {
@@ -313,8 +312,7 @@ public class ArbitraryDataManager extends Thread {
 					// Remove transactions that we already have local data for
 					if (hasLocalMetadata(arbitraryTransaction)) {
 						iterator.remove();
-						continue;
-					}
+                    }
 				}
 
 				if (signatures.isEmpty()) {

src/main/java/org/qortal/controller/arbitrary/ArbitraryDataStorageManager.java

@@ -291,7 +291,6 @@ public class ArbitraryDataStorageManager extends Thread {
                 arbitraryTransactionDataList.add(arbitraryTransactionData);
 
             } catch (DataException e) {
-                continue;
             }
         }
 
@@ -345,7 +344,6 @@ public class ArbitraryDataStorageManager extends Thread {
                }
 
             } catch (Exception e) {
-                continue;
             }
         }
 

src/main/java/org/qortal/controller/arbitrary/ArbitraryMetadataManager.java

@@ -334,11 +334,17 @@ public class ArbitraryMetadataManager {
             }
             ArbitraryTransactionData arbitraryTransactionData = (ArbitraryTransactionData) transactionData;
 
+            // Check if the name is blocked
+            boolean isBlocked = (arbitraryTransactionData == null || ListUtils.isNameBlocked(arbitraryTransactionData.getName()));
+
+            // Save if not blocked
+            ArbitraryDataFile arbitraryMetadataFile = arbitraryMetadataMessage.getArbitraryMetadataFile();
+            if (!isBlocked && arbitraryMetadataFile != null) {
+                arbitraryMetadataFile.save();
+            }
+
             // Forwarding
             if (isRelayRequest && Settings.getInstance().isRelayModeEnabled()) {
-
-                // Check if the name is blocked
-                boolean isBlocked = (arbitraryTransactionData == null || ListUtils.isNameBlocked(arbitraryTransactionData.getName()));
                 if (!isBlocked) {
                     Peer requestingPeer = request.getB();
                     if (requestingPeer != null) {

src/main/java/org/qortal/controller/repository/NamesDatabaseIntegrityCheck.java

@@ -207,7 +207,7 @@ public class NamesDatabaseIntegrityCheck {
                         // FUTURE: check database integrity for names that have been updated and then the original name re-registered
                         else if (Objects.equals(updateNameTransactionData.getName(), registeredName)) {
                             String newName = updateNameTransactionData.getNewName();
-                            if (newName == null || newName.length() == 0) {
+                            if (newName == null || newName.isEmpty()) {
                                 // If new name is blank (or maybe null, just to be safe), it means that it stayed the same
                                 newName = registeredName;
                             }

src/main/java/org/qortal/controller/tradebot/TradeBot.java

@@ -724,8 +724,7 @@ public class TradeBot implements Listener {
 
 			} catch (DataException e) {
 				LOGGER.info("Unable to determine failed state of AT {}", crossChainTradeData.qortalAtAddress);
-				continue;
-			}
+            }
 		}
 
 		return updatedCrossChainTrades;

src/main/java/org/qortal/crosschain/AddressInfo.java

@@ -21,15 +21,18 @@ public class AddressInfo {
 
     private int transactionCount;
 
+    private boolean isSpendable;
+
     public AddressInfo() {
     }
 
-    public AddressInfo(String address, List<Integer> path, long value, String pathAsString, int transactionCount) {
+    public AddressInfo(String address, List<Integer> path, long value, String pathAsString, int transactionCount, boolean isSpendable) {
         this.address = address;
         this.path = path;
         this.value = value;
         this.pathAsString = pathAsString;
         this.transactionCount = transactionCount;
+        this.isSpendable = isSpendable;
     }
 
     public String getAddress() {
@@ -52,17 +55,21 @@ public class AddressInfo {
         return transactionCount;
     }
 
+    public boolean isSpendable() {
+        return isSpendable;
+    }
+
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;
         AddressInfo that = (AddressInfo) o;
-        return value == that.value && transactionCount == that.transactionCount && Objects.equals(address, that.address) && Objects.equals(path, that.path) && Objects.equals(pathAsString, that.pathAsString);
+        return value == that.value && transactionCount == that.transactionCount && isSpendable == that.isSpendable && address.equals(that.address) && path.equals(that.path) && pathAsString.equals(that.pathAsString);
     }
 
     @Override
     public int hashCode() {
-        return Objects.hash(address, path, value, pathAsString, transactionCount);
+        return Objects.hash(address, path, value, pathAsString, transactionCount, isSpendable);
     }
 
     @Override
@@ -73,6 +80,7 @@ public class AddressInfo {
                 ", value=" + value +
                 ", pathAsString='" + pathAsString + '\'' +
                 ", transactionCount=" + transactionCount +
+                ", isSpendable=" + isSpendable +
                 '}';
     }
 }

src/main/java/org/qortal/crosschain/Bitcoin.java

@@ -7,7 +7,7 @@ import org.bitcoinj.params.MainNetParams;
 import org.bitcoinj.params.RegTestParams;
 import org.bitcoinj.params.TestNet3Params;
 import org.qortal.crosschain.ElectrumX.Server;
-import org.qortal.crosschain.ElectrumX.Server.ConnectionType;
+import org.qortal.crosschain.ChainableServer.ConnectionType;
 import org.qortal.settings.Settings;
 
 import java.util.Arrays;
@@ -22,8 +22,6 @@ public class Bitcoin extends Bitcoiny {
 	private static final long MINIMUM_ORDER_AMOUNT = 100000; // 0.001 BTC minimum order, due to high fees
 
 	// Temporary values until a dynamic fee system is written.
-	private static final long OLD_FEE_AMOUNT = 4_000L; // Not 5000 so that existing P2SH-B can output 1000, avoiding dust issue, leaving 4000 for fees.
-	private static final long NEW_FEE_TIMESTAMP = 1598280000000L; // milliseconds since epoch
 	private static final long NEW_FEE_AMOUNT = 6_000L;
 
 	private static final long NON_MAINNET_FEE = 1000L; // enough for TESTNET3 and should be OK for REGTEST
@@ -46,74 +44,62 @@ public class Bitcoin extends Bitcoiny {
 				return Arrays.asList(
 					// Servers chosen on NO BASIS WHATSOEVER from various sources!
 					// Status verified at https://1209k.com/bitcoin-eye/ele.php?chain=btc
-					new Server("104.248.139.211", Server.ConnectionType.SSL, 50002),
+					new Server("104.198.149.61", Server.ConnectionType.SSL, 50002),
 					new Server("128.0.190.26", Server.ConnectionType.SSL, 50002),
-					new Server("142.93.6.38", Server.ConnectionType.SSL, 50002),
 					new Server("157.245.172.236", Server.ConnectionType.SSL, 50002),
-					new Server("167.172.226.175", Server.ConnectionType.SSL, 50002),
-					new Server("167.172.42.31", Server.ConnectionType.SSL, 50002),
-					new Server("178.62.80.20", Server.ConnectionType.SSL, 50002),
-					new Server("185.64.116.15", Server.ConnectionType.SSL, 50002),
-					new Server("188.165.206.215", Server.ConnectionType.SSL, 50002),
-					new Server("188.165.211.112", Server.ConnectionType.SSL, 50002),
-					new Server("2azzarita.hopto.org", Server.ConnectionType.SSL, 50002),
-					new Server("2electrumx.hopto.me", Server.ConnectionType.SSL, 56022),
-					new Server("2ex.digitaleveryware.com", Server.ConnectionType.SSL, 50002),
-					new Server("65.39.140.37", Server.ConnectionType.SSL, 50002),
-					new Server("68.183.188.105", Server.ConnectionType.SSL, 50002),
-					new Server("71.73.14.254", Server.ConnectionType.SSL, 50002),
-					new Server("94.23.247.135", Server.ConnectionType.SSL, 50002),
-					new Server("assuredly.not.fyi", Server.ConnectionType.SSL, 50002),
-					new Server("ax101.blockeng.ch", Server.ConnectionType.SSL, 50002),
-					new Server("ax102.blockeng.ch", Server.ConnectionType.SSL, 50002),
+					new Server("260.whyza.net", Server.ConnectionType.SSL, 50002),
+					new Server("34.136.93.37", Server.ConnectionType.SSL, 50002),
+					new Server("34.67.22.216", Server.ConnectionType.SSL, 50002),
+					new Server("34.68.133.78", Server.ConnectionType.SSL, 50002),
+					new Server("alviss.coinjoined.com", Server.ConnectionType.SSL, 50002),
 					new Server("b.1209k.com", Server.ConnectionType.SSL, 50002),
 					new Server("b6.1209k.com", Server.ConnectionType.SSL, 50002),
 					new Server("bitcoin.dermichi.com", Server.ConnectionType.SSL, 50002),
 					new Server("bitcoin.lu.ke", Server.ConnectionType.SSL, 50002),
 					new Server("bitcoin.lukechilds.co", Server.ConnectionType.SSL, 50002),
 					new Server("blkhub.net", Server.ConnectionType.SSL, 50002),
-					new Server("btc.electroncash.dk", Server.ConnectionType.SSL, 60002),
+					new Server("btc.aftrek.org", Server.ConnectionType.SSL, 50002),
+					new Server("btc.hodler.ninja", Server.ConnectionType.SSL, 50002),
 					new Server("btc.ocf.sh", Server.ConnectionType.SSL, 50002),
 					new Server("btce.iiiiiii.biz", Server.ConnectionType.SSL, 50002),
 					new Server("caleb.vegas", Server.ConnectionType.SSL, 50002),
+					new Server("d762li0k0g.d.firewalla.org", Server.ConnectionType.SSL, 50002),
+					new Server("de.poiuty.com", Server.ConnectionType.SSL, 50002),
+					new Server("dijon.anties.org", Server.ConnectionType.SSL, 50002),
 					new Server("eai.coincited.net", Server.ConnectionType.SSL, 50002),
-					new Server("electrum.bhoovd.com", Server.ConnectionType.SSL, 50002),
 					new Server("electrum.bitaroo.net", Server.ConnectionType.SSL, 50002),
-					new Server("electrum.bitcoinlizard.net", Server.ConnectionType.SSL, 50002),
-					new Server("electrum.blockstream.info", Server.ConnectionType.SSL, 50002),
+					new Server("electrum.bitrefill.com", Server.ConnectionType.SSL, 50002),
+					new Server("electrum.brainshome.de", Server.ConnectionType.SSL, 50002),
 					new Server("electrum.emzy.de", Server.ConnectionType.SSL, 50002),
-					new Server("electrum.exan.tech", Server.ConnectionType.SSL, 50002),
+					new Server("electrum.kcicom.net", Server.ConnectionType.SSL, 50002),
 					new Server("electrum.kendigisland.xyz", Server.ConnectionType.SSL, 50002),
-					new Server("electrum.mmitech.info", Server.ConnectionType.SSL, 50002),
-					new Server("electrum.petrkr.net", Server.ConnectionType.SSL, 50002),
-					new Server("electrum.stippy.com", Server.ConnectionType.SSL, 50002),
 					new Server("electrum.thomasfischbach.de", Server.ConnectionType.SSL, 50002),
+					new Server("electrum-btc.leblancnet.us", Server.ConnectionType.SSL, 50002),
 					new Server("electrum0.snel.it", Server.ConnectionType.SSL, 50002),
-					new Server("electrum1.cipig.net", Server.ConnectionType.SSL, 50002),
-					new Server("electrum2.cipig.net", Server.ConnectionType.SSL, 50002),
-					new Server("electrum3.cipig.net", Server.ConnectionType.SSL, 50002),
-					new Server("electrumx.alexridevski.net", Server.ConnectionType.SSL, 50002),
+					new Server("electrum1.cipig.net", Server.ConnectionType.SSL, 20000),
+					new Server("electrum2.cipig.net", Server.ConnectionType.SSL, 20000),
+					new Server("electrum3.cipig.net", Server.ConnectionType.SSL, 20000),
+					new Server("electrumx.blockfinance-eco.li", Server.ConnectionType.SSL, 50002),
+					new Server("electrumx.indoor.app", Server.ConnectionType.SSL, 50002),
+					new Server("electrumx.iodata.org", Server.ConnectionType.SSL, 50002),
 					new Server("electrumx-core.1209k.com", Server.ConnectionType.SSL, 50002),
 					new Server("elx.bitske.com", Server.ConnectionType.SSL, 50002),
-					new Server("ex03.axalgo.com", Server.ConnectionType.SSL, 50002),
-					new Server("ex05.axalgo.com", Server.ConnectionType.SSL, 50002),
-					new Server("ex07.axalgo.com", Server.ConnectionType.SSL, 50002),
+					new Server("exs.dyshek.org", Server.ConnectionType.SSL, 50002),
 					new Server("fortress.qtornado.com", Server.ConnectionType.SSL, 50002),
-					new Server("fulcrum.grey.pw", Server.ConnectionType.SSL, 50002),
-					new Server("fulcrum.sethforprivacy.com", Server.ConnectionType.SSL, 51002),
 					new Server("guichet.centure.cc", Server.ConnectionType.SSL, 50002),
+					new Server("hodl.artyomk13.me", Server.ConnectionType.SSL, 50002),
 					new Server("hodlers.beer", Server.ConnectionType.SSL, 50002),
 					new Server("kareoke.qoppa.org", Server.ConnectionType.SSL, 50002),
 					new Server("kirsche.emzy.de", Server.ConnectionType.SSL, 50002),
+					new Server("kittyserver.ddnsfree.com", Server.ConnectionType.SSL, 50002),
+					new Server("lille.anties.org", Server.ConnectionType.SSL, 50002),
+					new Server("marseille.anties.org", Server.ConnectionType.SSL, 50002),
 					new Server("node1.btccuracao.com", Server.ConnectionType.SSL, 50002),
 					new Server("osr1ex1.compumundohipermegared.one", Server.ConnectionType.SSL, 50002),
-					new Server("smmalis37.ddns.net", Server.ConnectionType.SSL, 50002),
-					new Server("ulrichard.ch", Server.ConnectionType.SSL, 50002),
-					new Server("vmd104012.contaboserver.net", Server.ConnectionType.SSL, 50002),
-					new Server("vmd104014.contaboserver.net", Server.ConnectionType.SSL, 50002),
+					new Server("paris.anties.org", Server.ConnectionType.SSL, 50002),
+					new Server("ragtor.duckdns.org", Server.ConnectionType.SSL, 50002),
+					new Server("stavver.dyshek.org", Server.ConnectionType.SSL, 50002),
 					new Server("vmd63185.contaboserver.net", Server.ConnectionType.SSL, 50002),
-					new Server("vmd71287.contaboserver.net", Server.ConnectionType.SSL, 50002),
-					new Server("vmd84592.contaboserver.net", Server.ConnectionType.SSL, 50002),
 					new Server("xtrum.com", Server.ConnectionType.SSL, 50002)
 				);
 			}
@@ -125,11 +111,7 @@ public class Bitcoin extends Bitcoiny {
 
 			@Override
 			public long getP2shFee(Long timestamp) {
-				// TODO: This will need to be replaced with something better in the near future!
-				if (timestamp != null && timestamp < NEW_FEE_TIMESTAMP)
-					return OLD_FEE_AMOUNT;
-
-				return NEW_FEE_AMOUNT;
+				return this.getFeeCeiling();
 			}
 		},
 		TEST3 {
@@ -141,12 +123,17 @@ public class Bitcoin extends Bitcoiny {
 			@Override
 			public Collection<ElectrumX.Server> getServers() {
 				return Arrays.asList(
-					new Server("tn.not.fyi", Server.ConnectionType.SSL, 55002),
-					new Server("electrumx-test.1209k.com", Server.ConnectionType.SSL, 50002),
-					new Server("testnet.qtornado.com", Server.ConnectionType.SSL, 51002),
-					new Server("testnet.aranguren.org", Server.ConnectionType.TCP, 51001),
+					new Server("bitcoin.devmole.eu", Server.ConnectionType.TCP, 5000),
+					new Server("bitcoin.stagemole.eu", Server.ConnectionType.TCP, 5000),
+					new Server("blockstream.info", Server.ConnectionType.SSL, 993),
+					new Server("electrum.blockstream.info", Server.ConnectionType.SSL, 60002),
+					new Server("electrum1.cipig.net", Server.ConnectionType.TCP, 10068),
+					new Server("electrum2.cipig.net", Server.ConnectionType.TCP, 10068),
+					new Server("electrum3.cipig.net", Server.ConnectionType.TCP, 10068),
 					new Server("testnet.aranguren.org", Server.ConnectionType.SSL, 51002),
-					new Server("testnet.hsmiths.com", Server.ConnectionType.SSL, 53012)
+					new Server("testnet.hsmiths.com", Server.ConnectionType.SSL, 53012),
+					new Server("testnet.qtornado.com", Server.ConnectionType.SSL, 51002),
+					new Server("v22019051929289916.bestsrv.de", Server.ConnectionType.SSL, 50002)
 				);
 			}
 
@@ -186,6 +173,16 @@ public class Bitcoin extends Bitcoiny {
 			}
 		};
 
+		private long feeCeiling = NEW_FEE_AMOUNT;
+
+		public long getFeeCeiling() {
+			return feeCeiling;
+		}
+
+		public void setFeeCeiling(long feeCeiling) {
+			this.feeCeiling = feeCeiling;
+		}
+
 		public abstract NetworkParameters getParams();
 		public abstract Collection<ElectrumX.Server> getServers();
 		public abstract String getGenesisHash();
@@ -199,7 +196,7 @@ public class Bitcoin extends Bitcoiny {
 	// Constructors and instance
 
 	private Bitcoin(BitcoinNet bitcoinNet, BitcoinyBlockchainProvider blockchain, Context bitcoinjContext, String currencyCode) {
-		super(blockchain, bitcoinjContext, currencyCode);
+		super(blockchain, bitcoinjContext, currencyCode, bitcoinjContext.getFeePerKb());
 		this.bitcoinNet = bitcoinNet;
 
 		LOGGER.info(() -> String.format("Starting Bitcoin support using %s", this.bitcoinNet.name()));
@@ -244,6 +241,16 @@ public class Bitcoin extends Bitcoiny {
 		return this.bitcoinNet.getP2shFee(timestamp);
 	}
 
+	@Override
+	public long getFeeCeiling() {
+		return this.bitcoinNet.getFeeCeiling();
+	}
+
+	@Override
+	public void setFeeCeiling(long fee) {
+
+		this.bitcoinNet.setFeeCeiling( fee );
+	}
 	/**
  	* Returns bitcoinj transaction sending <tt>amount</tt> to <tt>recipient</tt> using 20 sat/byte fee.
  	*

src/main/java/org/qortal/crosschain/Bitcoiny.java

@@ -11,6 +11,7 @@ import org.bitcoinj.crypto.DeterministicKey;
 import org.bitcoinj.script.Script.ScriptType;
 import org.bitcoinj.script.ScriptBuilder;
 import org.bitcoinj.wallet.DeterministicKeyChain;
+import org.bitcoinj.wallet.KeyChain;
 import org.bitcoinj.wallet.SendRequest;
 import org.bitcoinj.wallet.Wallet;
 import org.qortal.api.model.SimpleForeignTransaction;
@@ -52,12 +53,15 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 	/** Byte offset into raw block headers to block timestamp. */
 	private static final int TIMESTAMP_OFFSET = 4 + 32 + 32;
 
+	protected Coin feePerKb;
+
 	// Constructors and instance
 
-	protected Bitcoiny(BitcoinyBlockchainProvider blockchainProvider, Context bitcoinjContext, String currencyCode) {
+	protected Bitcoiny(BitcoinyBlockchainProvider blockchainProvider, Context bitcoinjContext, String currencyCode, Coin feePerKb) {
 		this.blockchainProvider = blockchainProvider;
 		this.bitcoinjContext = bitcoinjContext;
 		this.currencyCode = currencyCode;
+		this.feePerKb = feePerKb;
 
 		this.params = this.bitcoinjContext.getParams();
 	}
@@ -166,7 +170,11 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 
 	/** Returns fee per transaction KB. To be overridden for testnet/regtest. */
 	public Coin getFeePerKb() {
-		return this.bitcoinjContext.getFeePerKb();
+		return this.feePerKb;
+	}
+
+	public void setFeePerKb(Coin feePerKb) {
+		this.feePerKb = feePerKb;
 	}
 
 	/** Returns minimum order size in sats. To be overridden for coins that need to restrict order size. */
@@ -335,6 +343,30 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 		}
 	}
 
+	/**
+	 * Get Spending Candidate Addresses
+	 *
+	 * @param key58 public master key
+	 * @return the addresses this instance will look at when building a spend
+	 * @throws ForeignBlockchainException
+	 */
+	public List<String> getSpendingCandidateAddresses(String key58) throws ForeignBlockchainException {
+
+		Wallet wallet = Wallet.fromWatchingKeyB58(this.params, key58, DeterministicHierarchy.BIP32_STANDARDISATION_TIME_SECS);
+		wallet.setUTXOProvider(new WalletAwareUTXOProvider(this, wallet));
+
+		// from Wallet.getStoredOutputsFromUTXOProvider()
+		List<ECKey> spendingKeys = wallet.getImportedKeys();
+		spendingKeys.addAll(wallet.getActiveKeyChain().getLeafKeys());
+
+		List<String> spendingCandidateAddresses
+				= spendingKeys.stream()
+					.map(spendingKey -> Address.fromKey(this.params, spendingKey, ScriptType.P2PKH ).toString())
+					.collect(Collectors.toList());
+
+		return spendingCandidateAddresses;
+	}
+
 	/**
 	 * Returns bitcoinj transaction sending <tt>amount</tt> to <tt>recipient</tt> using default fees.
 	 *
@@ -478,8 +510,10 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 	public List<AddressInfo> getWalletAddressInfos(String key58) throws ForeignBlockchainException {
 		List<AddressInfo> infos = new ArrayList<>();
 
-		for(DeterministicKey key : getWalletKeys(key58)) {
-			infos.add(buildAddressInfo(key));
+		List<String> candidates = this.getSpendingCandidateAddresses(key58);
+
+		for(DeterministicKey key : getOldWalletKeys(key58)) {
+			infos.add(buildAddressInfo(key, candidates));
 		}
 
 		return infos.stream()
@@ -487,7 +521,7 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 				.collect(Collectors.toList());
 	}
 
-	public AddressInfo buildAddressInfo(DeterministicKey key) throws ForeignBlockchainException  {
+	public AddressInfo buildAddressInfo(DeterministicKey key, List<String> candidates) throws ForeignBlockchainException  {
 
 		Address address = Address.fromKey(this.params, key, ScriptType.P2PKH);
 
@@ -498,7 +532,8 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 				toIntegerList( key.getPath()),
 				summingUnspentOutputs(address.toString()),
 				key.getPathAsString(),
-				transactionCount);
+				transactionCount,
+				candidates.contains(address.toString()));
 	}
 
 	private static  List<Integer> toIntegerList(ImmutableList<ChildNumber> path) {
@@ -564,11 +599,23 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 		}
 	}
 
-	private List<DeterministicKey> getWalletKeys(String key58) throws ForeignBlockchainException {
+	/**
+	 * Get Old Wallet Keys
+	 *
+	 * Get wallet keys using the old key generation algorithm. This is used for diagnosing and repairing wallets
+	 * created before 2024.
+	 *
+	 * @param masterPrivateKey
+	 *
+	 * @return the keys
+	 *
+	 * @throws ForeignBlockchainException
+	 */
+	private List<DeterministicKey> getOldWalletKeys(String masterPrivateKey) throws ForeignBlockchainException {
 		synchronized (this) {
 			Context.propagate(bitcoinjContext);
 
-			Wallet wallet = walletFromDeterministicKey58(key58);
+			Wallet wallet = walletFromDeterministicKey58(masterPrivateKey);
 			DeterministicKeyChain keyChain = wallet.getActiveKeyChain();
 
 			keyChain.setLookaheadSize(Bitcoiny.WALLET_KEY_LOOKAHEAD_INCREMENT);
@@ -693,7 +740,7 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 	}
 
 	/**
-	 * Returns first unused receive address given 'm' BIP32 key.
+	 * Returns first unused receive address given a BIP32 key.
 	 *
 	 * @param key58 BIP32/HD extended Bitcoin private/public key
 	 * @return P2PKH address
@@ -705,68 +752,22 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 		Wallet wallet = walletFromDeterministicKey58(key58);
 		DeterministicKeyChain keyChain = wallet.getActiveKeyChain();
 
-		keyChain.setLookaheadSize(Bitcoiny.WALLET_KEY_LOOKAHEAD_INCREMENT);
-		keyChain.maybeLookAhead();
-
-		final int keyChainPathSize = keyChain.getAccountPath().size();
-		List<DeterministicKey> keys = new ArrayList<>(keyChain.getLeafKeys());
-
-		int ki = 0;
 		do {
-			for (; ki < keys.size(); ++ki) {
-				DeterministicKey dKey = keys.get(ki);
-				List<ChildNumber> dKeyPath = dKey.getPath();
+			// the next receive funds address
+			Address address = Address.fromKey(this.params, keyChain.getKey(KeyChain.KeyPurpose.RECEIVE_FUNDS), ScriptType.P2PKH);
 
-				// If keyChain is based on 'm', then make sure dKey is m/0/ki - i.e. a 'receive' address, not 'change' (m/1/ki)
-				if (dKeyPath.size() != keyChainPathSize + 2 || dKeyPath.get(dKeyPath.size() - 2) != ChildNumber.ZERO)
-					continue;
+			// if zero transactions, return address
+			if(getAddressTransactions(ScriptBuilder.createOutputScript(address).getProgram(), true).isEmpty())
+				return address.toString();
 
-				// Check unspent
-				Address address = Address.fromKey(this.params, dKey, ScriptType.P2PKH);
-				byte[] script = ScriptBuilder.createOutputScript(address).getProgram();
-
-				List<UnspentOutput> unspentOutputs = this.blockchainProvider.getUnspentOutputs(script, false);
-
-				/*
-				 * If there are no unspent outputs then either:
-				 * a) all the outputs have been spent
-				 * b) address has never been used
-				 *
-				 * For case (a) we want to remember not to check this address (key) again.
-				 */
-
-				if (unspentOutputs.isEmpty()) {
-					// If this is a known key that has been spent before, then we can skip asking for transaction history
-					if (this.spentKeys.contains(dKey)) {
-						wallet.getActiveKeyChain().markKeyAsUsed(dKey);
-						continue;
-					}
-
-					// Ask for transaction history - if it's empty then key has never been used
-					List<TransactionHash> historicTransactionHashes = this.blockchainProvider.getAddressTransactions(script, false);
-
-					if (!historicTransactionHashes.isEmpty()) {
-						// Fully spent key - case (a)
-						this.spentKeys.add(dKey);
-						wallet.getActiveKeyChain().markKeyAsUsed(dKey);
-						continue;
-					}
-
-					// Key never been used - case (b)
-					return address.toString();
-				}
-
-				// Key has unspent outputs, hence used, so no good to us
-				this.spentKeys.remove(dKey);
-			}
-
-			// Generate some more keys
-			keys.addAll(generateMoreKeys(keyChain));
-
-			// Process new keys
+			// else try the next receive funds address
 		} while (true);
 	}
 
+	public abstract long getFeeCeiling();
+
+	public abstract void setFeeCeiling(long fee);
+
 	// UTXOProvider support
 
 	static class WalletAwareUTXOProvider implements UTXOProvider {
@@ -1020,4 +1021,52 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 			return Wallet.fromWatchingKeyB58(this.params, key58, DeterministicHierarchy.BIP32_STANDARDISATION_TIME_SECS);
 	}
 
+	/**
+	 * Repair Wallet
+	 *
+	 * Repair wallets generated before 2024 by moving all the address balances to the first address.
+	 *
+	 * @param privateMasterKey
+	 *
+	 * @return the transaction Id of the spend operation that moves the balances or the exception name if an exception
+	 * is thrown
+	 *
+	 * @throws ForeignBlockchainException
+	 */
+	public String repairOldWallet(String privateMasterKey) throws ForeignBlockchainException {
+
+		// create a deterministic wallet to satisfy the bitcoinj API
+		Wallet wallet = Wallet.createDeterministic(this.bitcoinjContext, ScriptType.P2PKH);
+
+		// use the blockchain resources of this instance for UTXO provision
+		wallet.setUTXOProvider(new BitcoinyUTXOProvider( this ));
+
+		// import in each that is generated using the old key generation algorithm
+		List<DeterministicKey> walletKeys = getOldWalletKeys(privateMasterKey);
+
+		for( DeterministicKey key : walletKeys) {
+			wallet.importKey(ECKey.fromPrivate(key.getPrivKey()));
+		}
+
+		// get the primary receive address
+		Address firstAddress = Address.fromKey(this.params, walletKeys.get(0), ScriptType.P2PKH);
+
+		// send all the imported coins to the primary receive address
+		SendRequest sendRequest = SendRequest.emptyWallet(firstAddress);
+		sendRequest.feePerKb = this.getFeePerKb();
+
+		try {
+			// allow the wallet to build the send request transaction and broadcast
+			wallet.completeTx(sendRequest);
+			broadcastTransaction(sendRequest.tx);
+
+			// return the transaction Id
+			return sendRequest.tx.getTxId().toString();
+		}
+		catch( Exception e ) {
+			// log error and return exception name
+			LOGGER.error(e.getMessage(), e);
+			return e.getClass().getSimpleName();
+		}
+	}
 }

src/main/java/org/qortal/crosschain/BitcoinyBlockchainProvider.java

@@ -3,11 +3,14 @@ package org.qortal.crosschain;
 import cash.z.wallet.sdk.rpc.CompactFormats.CompactBlock;
 
 import java.util.List;
+import java.util.Optional;
+import java.util.Set;
 
 public abstract class BitcoinyBlockchainProvider {
 
 	public static final boolean INCLUDE_UNCONFIRMED = true;
 	public static final boolean EXCLUDE_UNCONFIRMED = false;
+	public static final String EMPTY = "";
 
 	/** Sets the blockchain using this provider instance */
 	public abstract void setBlockchain(Bitcoiny blockchain);
@@ -59,4 +62,69 @@ public abstract class BitcoinyBlockchainProvider {
 	/** Broadcasts raw, serialized, transaction bytes to network, returning success/failure. */
 	public abstract void broadcastTransaction(byte[] rawTransaction) throws ForeignBlockchainException;
 
+	public abstract Set<ChainableServer> getServers();
+
+	public abstract List<ChainableServer> getRemainingServers();
+
+	public abstract Set<ChainableServer> getUselessServers();
+
+	public abstract ChainableServer getCurrentServer();
+
+	/**
+	 * Add Server
+	 *
+	 * Add server to list of candidate servers.
+	 *
+	 * @param server the server
+	 *
+	 * @return true if added, otherwise false
+	 */
+	public abstract boolean addServer( ChainableServer server );
+
+	/**
+	 * Remove Server
+	 *
+	 * Remove server from list of candidate servers.
+	 *
+	 * @param server the server
+	 *
+	 * @return true if removed, otherwise false
+	 */
+	public abstract boolean removeServer( ChainableServer server );
+
+	/**
+	 * Set Current Server
+	 *
+	 * Set server to be used for this foreign blockchain.
+	 *
+	 * @param server the server
+	 * @param requestedBy who requested this setting
+	 *
+	 * @return the connection that was made
+	 *
+	 * @throws ForeignBlockchainException
+	 */
+	public abstract Optional<ChainableServerConnection> setCurrentServer(ChainableServer server, String requestedBy) throws ForeignBlockchainException;
+
+	/**
+	 * Get Server Connections
+	 *
+	 * Get the server connections made to this foreign blockchain,
+	 *
+	 * @return the server connections
+	 */
+	public abstract List<ChainableServerConnection> getServerConnections();
+
+	/**
+	 * Get Server
+	 *
+	 * Get a server for this foreign blockchain.
+	 *
+	 * @param hostName the host URL
+	 * @param type the type of connection (TCP, SSL)
+	 * @param port the port
+	 *
+	 * @return the server
+	 */
+	public abstract ChainableServer getServer(String hostName, ChainableServer.ConnectionType type, int port);
 }

src/main/java/org/qortal/crosschain/BitcoinyUTXOProvider.java

@@ -0,0 +1,80 @@
+package org.qortal.crosschain;
+
+import org.bitcoinj.core.*;
+import org.bitcoinj.script.Script;
+import org.bitcoinj.script.ScriptBuilder;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Class BitcoinyUTXOProvider
+ *
+ * Uses Bitcoiny resources for UTXO provision.
+ */
+public class BitcoinyUTXOProvider implements UTXOProvider {
+
+    private Bitcoiny bitcoiny;
+
+    public BitcoinyUTXOProvider(Bitcoiny bitcoiny) {
+        this.bitcoiny = bitcoiny;
+    }
+
+    @Override
+    public List<UTXO> getOpenTransactionOutputs(List<ECKey> keys) throws UTXOProviderException {
+        try {
+            List<UTXO> utxos = new ArrayList<>();
+
+            for( ECKey key : keys) {
+                Address address = Address.fromKey(this.bitcoiny.params, key, Script.ScriptType.P2PKH);
+                byte[] script = ScriptBuilder.createOutputScript(address).getProgram();
+
+                // collection UTXO's for all confirmed unspent outputs
+                for (UnspentOutput output : this.bitcoiny.blockchainProvider.getUnspentOutputs(script, false)) {
+                    utxos.add(toUTXO(output));
+                }
+            }
+            return utxos;
+        } catch (ForeignBlockchainException e) {
+            throw new UTXOProviderException(e);
+        }
+    }
+
+    /**
+     * Convert Unspent Output to a UTXO
+     *
+     * @param unspentOutput
+     *
+     * @return the UTXO
+     *
+     * @throws ForeignBlockchainException
+     */
+    private UTXO toUTXO(UnspentOutput unspentOutput) throws ForeignBlockchainException {
+        List<TransactionOutput> transactionOutputs = this.bitcoiny.getOutputs(unspentOutput.hash);
+
+        TransactionOutput transactionOutput = transactionOutputs.get(unspentOutput.index);
+
+        return new UTXO(
+                        Sha256Hash.wrap(unspentOutput.hash),
+                        unspentOutput.index,
+                        Coin.valueOf(unspentOutput.value),
+                        unspentOutput.height,
+                false,
+                        transactionOutput.getScriptPubKey()
+        );
+    }
+
+    @Override
+    public int getChainHeadHeight() throws UTXOProviderException {
+        try {
+            return this.bitcoiny.blockchainProvider.getCurrentHeight();
+        } catch (ForeignBlockchainException e) {
+            throw new UTXOProviderException(e);
+        }
+    }
+
+    @Override
+    public NetworkParameters getParams() {
+        return this.bitcoiny.params;
+    }
+}

src/main/java/org/qortal/crosschain/ChainableServer.java

@@ -0,0 +1,15 @@
+package org.qortal.crosschain;
+
+public interface ChainableServer {
+    public void addResponseTime(long responseTime);
+
+    public long averageResponseTime();
+
+    public String getHostName();
+
+    public int getPort();
+
+    public ConnectionType getConnectionType();
+
+    public enum ConnectionType {TCP, SSL}
+}

src/main/java/org/qortal/crosschain/ChainableServerConnection.java

@@ -0,0 +1,71 @@
+package org.qortal.crosschain;
+
+import java.util.Objects;
+
+public class ChainableServerConnection {
+
+    private ChainableServer server;
+    private String requestedBy;
+    private boolean open;
+    private boolean success;
+    private long currentTimeMillis;
+    private String notes;
+
+    public ChainableServerConnection(ChainableServer server, String requestedBy, boolean open, boolean success, long currentTimeMillis, String notes) {
+        this.server = server;
+        this.requestedBy = requestedBy;
+        this.open = open;
+        this.success = success;
+        this.currentTimeMillis = currentTimeMillis;
+        this.notes = notes;
+    }
+
+    public ChainableServer getServer() {
+        return server;
+    }
+
+    public String getRequestedBy() {
+        return requestedBy;
+    }
+
+    public boolean isOpen() {
+        return open;
+    }
+
+    public boolean isSuccess() {
+        return success;
+    }
+
+    public long getCurrentTimeMillis() {
+        return currentTimeMillis;
+    }
+
+    public String getNotes() {
+        return notes;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        ChainableServerConnection that = (ChainableServerConnection) o;
+        return currentTimeMillis == that.currentTimeMillis && Objects.equals(server, that.server);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(server, currentTimeMillis);
+    }
+
+    @Override
+    public String toString() {
+        return "ChainableServerConnection{" +
+                "server=" + server +
+                ", requestedBy='" + requestedBy + '\'' +
+                ", open=" + open +
+                ", success=" + success +
+                ", currentTimeMillis=" + currentTimeMillis +
+                ", notes='" + notes + '\'' +
+                '}';
+    }
+}

src/main/java/org/qortal/crosschain/ChainableServerConnectionRecorder.java

@@ -0,0 +1,45 @@
+package org.qortal.crosschain;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+
+public class ChainableServerConnectionRecorder {
+
+    private List<ChainableServerConnection> connections;
+    private int limit;
+
+    public ChainableServerConnectionRecorder(int limit) {
+        this.connections = new ArrayList<>(limit);
+        this.limit = limit;
+    }
+
+    public ChainableServerConnection recordConnection(
+            ChainableServer server, String requestedBy, boolean open, boolean success, String notes) {
+
+        ChainableServerConnection connection
+                = new ChainableServerConnection(server, requestedBy, open, success, System.currentTimeMillis(), notes);
+
+        connections.add(connection);
+
+        if( connections.size() > limit) {
+            ChainableServerConnection firstConnection
+                    = connections.stream().sorted(Comparator.comparing(ChainableServerConnection::getCurrentTimeMillis))
+                    .findFirst().get();
+            connections.remove(firstConnection);
+        }
+        return connection;
+    }
+
+    public int getLimit() {
+        return limit;
+    }
+
+    public void setLimit(int limit) {
+        this.limit = limit;
+    }
+
+    public List<ChainableServerConnection> getConnections() {
+        return this.connections;
+    }
+}

src/main/java/org/qortal/crosschain/Digibyte.java

@@ -7,7 +7,7 @@ import org.bitcoinj.params.RegTestParams;
 import org.bitcoinj.params.TestNet3Params;
 import org.libdohj.params.DigibyteMainNetParams;
 import org.qortal.crosschain.ElectrumX.Server;
-import org.qortal.crosschain.ElectrumX.Server.ConnectionType;
+import org.qortal.crosschain.ChainableServer.ConnectionType;
 import org.qortal.settings.Settings;
 
 import java.util.Arrays;
@@ -46,10 +46,6 @@ public class Digibyte extends Bitcoiny {
 					// Servers chosen on NO BASIS WHATSOEVER from various sources!
 					// Status verified at https://1209k.com/bitcoin-eye/ele.php?chain=dgb
 					new Server("electrum.qortal.link", Server.ConnectionType.SSL, 55002),
-					new Server("electrum1-dgb.qortal.online", Server.ConnectionType.SSL, 50002),
-					new Server("electrum2-dgb.qortal.online", Server.ConnectionType.SSL, 50002),
-					new Server("electrum3-dgb.qortal.online", Server.ConnectionType.SSL, 40002),
-					new Server("electrum4-dgb.qortal.online", Server.ConnectionType.SSL, 40002),
 					new Server("electrum1.cipig.net", Server.ConnectionType.SSL, 20059),
 					new Server("electrum2.cipig.net", Server.ConnectionType.SSL, 20059),
 					new Server("electrum3.cipig.net", Server.ConnectionType.SSL, 20059)
@@ -63,8 +59,7 @@ public class Digibyte extends Bitcoiny {
 
 			@Override
 			public long getP2shFee(Long timestamp) {
-				// TODO: This will need to be replaced with something better in the near future!
-				return MAINNET_FEE;
+				return this.getFeeCeiling();
 			}
 		},
 		TEST3 {
@@ -114,6 +109,16 @@ public class Digibyte extends Bitcoiny {
 			}
 		};
 
+		private long feeCeiling = MAINNET_FEE;
+
+		public long getFeeCeiling() {
+			return feeCeiling;
+		}
+
+		public void setFeeCeiling(long feeCeiling) {
+			this.feeCeiling = feeCeiling;
+		}
+
 		public abstract NetworkParameters getParams();
 		public abstract Collection<Server> getServers();
 		public abstract String getGenesisHash();
@@ -127,7 +132,7 @@ public class Digibyte extends Bitcoiny {
 	// Constructors and instance
 
 	private Digibyte(DigibyteNet digibyteNet, BitcoinyBlockchainProvider blockchain, Context bitcoinjContext, String currencyCode) {
-		super(blockchain, bitcoinjContext, currencyCode);
+		super(blockchain, bitcoinjContext, currencyCode, DEFAULT_FEE_PER_KB);
 		this.digibyteNet = digibyteNet;
 
 		LOGGER.info(() -> String.format("Starting Digibyte support using %s", this.digibyteNet.name()));
@@ -156,11 +161,6 @@ public class Digibyte extends Bitcoiny {
 
 	// Actual useful methods for use by other classes
 
-	@Override
-	public Coin getFeePerKb() {
-		return DEFAULT_FEE_PER_KB;
-	}
-
 	@Override
 	public long getMinimumOrderAmount() {
 		return MINIMUM_ORDER_AMOUNT;
@@ -177,4 +177,14 @@ public class Digibyte extends Bitcoiny {
 		return this.digibyteNet.getP2shFee(timestamp);
 	}
 
+	@Override
+	public long getFeeCeiling() {
+		return this.digibyteNet.getFeeCeiling();
+	}
+
+	@Override
+	public void setFeeCeiling(long fee) {
+
+		this.digibyteNet.setFeeCeiling( fee );
+	}
 }

src/main/java/org/qortal/crosschain/Dogecoin.java

@@ -6,7 +6,7 @@ import org.bitcoinj.core.NetworkParameters;
 import org.libdohj.params.DogecoinMainNetParams;
 import org.libdohj.params.DogecoinTestNet3Params;
 import org.qortal.crosschain.ElectrumX.Server;
-import org.qortal.crosschain.ElectrumX.Server.ConnectionType;
+import org.qortal.crosschain.ChainableServer.ConnectionType;
 import org.qortal.settings.Settings;
 
 import java.util.Arrays;
@@ -45,11 +45,8 @@ public class Dogecoin extends Bitcoiny {
 				return Arrays.asList(
 					// Servers chosen on NO BASIS WHATSOEVER from various sources!
 					// Status verified at https://1209k.com/bitcoin-eye/ele.php?chain=doge
+					new Server("dogecoin.stackwallet.com", Server.ConnectionType.SSL, 50022),
 					new Server("electrum.qortal.link", Server.ConnectionType.SSL, 54002),
-					new Server("electrum1-doge.qortal.online", Server.ConnectionType.SSL, 50002),
-					new Server("electrum2-doge.qortal.online", Server.ConnectionType.SSL, 50002),
-					new Server("electrum3-doge.qortal.online", Server.ConnectionType.SSL, 30002),
-					new Server("electrum4-doge.qortal.online", Server.ConnectionType.SSL, 30002),
 					new Server("electrum1.cipig.net", Server.ConnectionType.SSL, 20060),
 					new Server("electrum2.cipig.net", Server.ConnectionType.SSL, 20060),
 					new Server("electrum3.cipig.net", Server.ConnectionType.SSL, 20060)
@@ -63,8 +60,7 @@ public class Dogecoin extends Bitcoiny {
 
 			@Override
 			public long getP2shFee(Long timestamp) {
-				// TODO: This will need to be replaced with something better in the near future!
-				return MAINNET_FEE;
+				return this.getFeeCeiling();
 			}
 		},
 		TEST3 {
@@ -114,6 +110,16 @@ public class Dogecoin extends Bitcoiny {
 			}
 		};
 
+		private long feeCeiling = MAINNET_FEE;
+
+		public long getFeeCeiling() {
+			return feeCeiling;
+		}
+
+		public void setFeeCeiling(long feeCeiling) {
+			this.feeCeiling = feeCeiling;
+		}
+
 		public abstract NetworkParameters getParams();
 		public abstract Collection<Server> getServers();
 		public abstract String getGenesisHash();
@@ -127,7 +133,7 @@ public class Dogecoin extends Bitcoiny {
 	// Constructors and instance
 
 	private Dogecoin(DogecoinNet dogecoinNet, BitcoinyBlockchainProvider blockchain, Context bitcoinjContext, String currencyCode) {
-		super(blockchain, bitcoinjContext, currencyCode);
+		super(blockchain, bitcoinjContext, currencyCode, DEFAULT_FEE_PER_KB);
 		this.dogecoinNet = dogecoinNet;
 
 		LOGGER.info(() -> String.format("Starting Dogecoin support using %s", this.dogecoinNet.name()));
@@ -156,11 +162,6 @@ public class Dogecoin extends Bitcoiny {
 
 	// Actual useful methods for use by other classes
 
-	@Override
-	public Coin getFeePerKb() {
-		return DEFAULT_FEE_PER_KB;
-	}
-
 	@Override
 	public long getMinimumOrderAmount() {
 		return MINIMUM_ORDER_AMOUNT;
@@ -177,4 +178,14 @@ public class Dogecoin extends Bitcoiny {
 		return this.dogecoinNet.getP2shFee(timestamp);
 	}
 
+	@Override
+	public long getFeeCeiling() {
+		return this.dogecoinNet.getFeeCeiling();
+	}
+
+	@Override
+	public void setFeeCeiling(long fee) {
+
+		this.dogecoinNet.setFeeCeiling( fee );
+	}
 }

src/main/java/org/qortal/crosschain/ElectrumX.java

@@ -8,6 +8,7 @@ import org.apache.logging.log4j.Logger;
 import org.json.simple.JSONArray;
 import org.json.simple.JSONObject;
 import org.json.simple.JSONValue;
+import org.qortal.api.resource.CrossChainUtils;
 import org.qortal.crypto.Crypto;
 import org.qortal.crypto.TrustlessSSLSocketFactory;
 import org.qortal.utils.BitTwiddling;
@@ -26,6 +27,7 @@ import java.util.regex.Pattern;
 /** ElectrumX network support for querying Bitcoiny-related info like block headers, transaction outputs, etc. */
 public class ElectrumX extends BitcoinyBlockchainProvider {
 
+	public static final String NULL_RESPONSE_FROM_ELECTRUM_X_SERVER = "Null response from ElectrumX server";
 	private static final Logger LOGGER = LogManager.getLogger(ElectrumX.class);
 	private static final Random RANDOM = new Random();
 
@@ -43,12 +45,15 @@ public class ElectrumX extends BitcoinyBlockchainProvider {
 	private static final String VERBOSE_TRANSACTIONS_UNSUPPORTED_MESSAGE = "verbose transactions are currently unsupported";
 
 	private static final int RESPONSE_TIME_READINGS = 5;
-	private static final long MAX_AVG_RESPONSE_TIME = 1000L; // ms
+	private static final long MAX_AVG_RESPONSE_TIME = 2000L; // ms
+	public static final String MINIMUM_VERSION_ERROR = "MINIMUM VERSION ERROR";
+	public static final String EXPECTED_GENESIS_ERROR = "EXPECTED GENESIS ERROR";
 
-	public static class Server {
+	private ChainableServerConnectionRecorder recorder = new ChainableServerConnectionRecorder(100);
+
+	public static class Server implements ChainableServer {
 		String hostname;
 
-		public enum ConnectionType { TCP, SSL }
 		ConnectionType connectionType;
 
 		int port;
@@ -60,6 +65,7 @@ public class ElectrumX extends BitcoinyBlockchainProvider {
 			this.port = port;
 		}
 
+		@Override
 		public void addResponseTime(long responseTime) {
 			while (this.responseTimes.size() > RESPONSE_TIME_READINGS) {
 				this.responseTimes.remove(0);
@@ -67,6 +73,7 @@ public class ElectrumX extends BitcoinyBlockchainProvider {
 			this.responseTimes.add(responseTime);
 		}
 
+		@Override
 		public long averageResponseTime() {
 			if (this.responseTimes.size() < RESPONSE_TIME_READINGS) {
 				// Not enough readings yet
@@ -79,6 +86,21 @@ public class ElectrumX extends BitcoinyBlockchainProvider {
 			return 0L;
 		}
 
+		@Override
+		public String getHostName() {
+			return this.hostname;
+		}
+
+		@Override
+		public int getPort() {
+			return this.port;
+		}
+
+		@Override
+		public ConnectionType getConnectionType() {
+			return this.connectionType;
+		}
+
 		@Override
 		public boolean equals(Object other) {
 			if (other == this)
@@ -104,9 +126,9 @@ public class ElectrumX extends BitcoinyBlockchainProvider {
 			return String.format("%s:%s:%d", this.connectionType.name(), this.hostname, this.port);
 		}
 	}
-	private Set<Server> servers = new HashSet<>();
-	private List<Server> remainingServers = new ArrayList<>();
-	private Set<Server> uselessServers = Collections.synchronizedSet(new HashSet<>());
+	private Set<ChainableServer> servers = new HashSet<>();
+	private List<ChainableServer> remainingServers = new ArrayList<>();
+	private Set<ChainableServer> uselessServers = Collections.synchronizedSet(new HashSet<>());
 
 	private final String netId;
 	private final String expectedGenesisHash;
@@ -114,13 +136,13 @@ public class ElectrumX extends BitcoinyBlockchainProvider {
 	private Bitcoiny blockchain;
 
 	private final Object serverLock = new Object();
-	private Server currentServer;
+	private ChainableServer currentServer;
 	private Socket socket;
 	private Scanner scanner;
 	private int nextId = 1;
 
 	private static final int TX_CACHE_SIZE = 1000;
-	@SuppressWarnings("serial")
+
 	private final Map<String, BitcoinyTransaction> transactionCache = Collections.synchronizedMap(new LinkedHashMap<>(TX_CACHE_SIZE + 1, 0.75F, true) {
 		// This method is called just after a new entry has been added
 		@Override
@@ -200,10 +222,10 @@ public class ElectrumX extends BitcoinyBlockchainProvider {
 		if (!(countObj instanceof Long) || !(hexObj instanceof String))
 			throw new ForeignBlockchainException.NetworkException("Missing/invalid 'count' or 'hex' entries in JSON from ElectrumX blockchain.block.headers RPC");
 
-		Long returnedCount = (Long) countObj;
+		long returnedCount = (Long) countObj;
 		String hex = (String) hexObj;
 
-		List<byte[]> rawBlockHeaders = new ArrayList<>(returnedCount.intValue());
+		List<byte[]> rawBlockHeaders = new ArrayList<>((int) returnedCount);
 
 		byte[] raw = HashCode.fromString(hex).asBytes();
 
@@ -405,7 +427,7 @@ public class ElectrumX extends BitcoinyBlockchainProvider {
 					Server uselessServer = (Server) e.getServer();
 					LOGGER.trace(() -> String.format("Server %s doesn't support verbose transactions - barring use of that server", uselessServer));
 					this.uselessServers.add(uselessServer);
-					this.closeServer(uselessServer);
+					this.closeServer(uselessServer, this.getClass().getSimpleName(), CrossChainUtils.getNotes(e));
 					continue;
 				}
 
@@ -479,12 +501,13 @@ public class ElectrumX extends BitcoinyBlockchainProvider {
 				// Update: it turns out that they were just using a different key - "address" instead of "addresses"
 				// The code below can remain in place, just in case a peer returns a missing address in the future
 				if (addresses == null || addresses.isEmpty()) {
+					final String message = String.format("No output addresses returned for transaction %s", txHash);
 					if (this.currentServer != null) {
 						this.uselessServers.add(this.currentServer);
-						this.closeServer(this.currentServer);
+						this.closeServer(this.currentServer, this.getClass().getSimpleName(), message);
 					}
 					LOGGER.info("No output addresses returned for transaction {}", txHash);
-					throw new ForeignBlockchainException(String.format("No output addresses returned for transaction %s", txHash));
+					throw new ForeignBlockchainException(message);
 				}
 
 				outputs.add(new BitcoinyTransaction.Output(scriptPubKey, value, addresses));
@@ -569,7 +592,7 @@ public class ElectrumX extends BitcoinyBlockchainProvider {
 
 		Object peers = this.connectedRpc("server.peers.subscribe");
 
-		for (Object rawPeer : (JSONArray) peers) {
+		for (Object rawPeer : (JSONArray) Objects.requireNonNull(peers)) {
 			JSONArray peer = (JSONArray) rawPeer;
 			if (peer.size() < 3)
 				// We're expecting at least 3 fields for each peer entry: IP, hostname, features
@@ -638,8 +661,9 @@ public class ElectrumX extends BitcoinyBlockchainProvider {
 				if (!this.remainingServers.isEmpty()) {
 					long averageResponseTime = this.currentServer.averageResponseTime();
 					if (averageResponseTime > MAX_AVG_RESPONSE_TIME) {
-						LOGGER.info("Slow average response time {}ms from {} - trying another server...", averageResponseTime, this.currentServer.hostname);
-						this.closeServer();
+						String message = String.format("Slow average response time %dms from %s - trying another server...", averageResponseTime, this.currentServer.getHostName());
+						LOGGER.info(message);
+						this.closeServer(this.getClass().getSimpleName(), message);
 						break;
 					}
 				}
@@ -647,8 +671,9 @@ public class ElectrumX extends BitcoinyBlockchainProvider {
 				if (response != null)
 					return response;
 
+				LOGGER.info(NULL_RESPONSE_FROM_ELECTRUM_X_SERVER);
 				// Didn't work, try another server...
-				this.closeServer();
+				this.closeServer(this.getClass().getSimpleName(), NULL_RESPONSE_FROM_ELECTRUM_X_SERVER);
 			}
 
 			// Failed to perform RPC - maybe lack of servers?
@@ -663,57 +688,64 @@ public class ElectrumX extends BitcoinyBlockchainProvider {
 			return true;
 
 		while (!this.remainingServers.isEmpty()) {
-			Server server = this.remainingServers.remove(RANDOM.nextInt(this.remainingServers.size()));
-			LOGGER.trace(() -> String.format("Connecting to %s", server));
-
-			try {
-				SocketAddress endpoint = new InetSocketAddress(server.hostname, server.port);
-				int timeout = 5000; // ms
-
-				this.socket = new Socket();
-				this.socket.connect(endpoint, timeout);
-				this.socket.setTcpNoDelay(true);
-
-				if (server.connectionType == Server.ConnectionType.SSL) {
-					SSLSocketFactory factory = TrustlessSSLSocketFactory.getSocketFactory();
-					this.socket = factory.createSocket(this.socket, server.hostname, server.port, true);
-				}
-
-				this.scanner = new Scanner(this.socket.getInputStream());
-				this.scanner.useDelimiter("\n");
-
-				// All connections need to start with a version negotiation
-				this.connectedRpc("server.version");
-
-				// Check connection is suitable by asking for server features, including genesis block hash
-				JSONObject featuresJson = (JSONObject) this.connectedRpc("server.features");
-
-				if (featuresJson == null || Double.valueOf((String) featuresJson.get("protocol_min")) < MIN_PROTOCOL_VERSION)
-					continue;
-
-				if (this.expectedGenesisHash != null && !((String) featuresJson.get("genesis_hash")).equals(this.expectedGenesisHash))
-					continue;
-
-				// Ask for more servers
-				Set<Server> moreServers = serverPeersSubscribe();
-				// Discard duplicate servers we already know
-				moreServers.removeAll(this.servers);
-				// Add to both lists
-				this.remainingServers.addAll(moreServers);
-				this.servers.addAll(moreServers);
-
-				LOGGER.debug(() -> String.format("Connected to %s", server));
-				this.currentServer = server;
-				return true;
-			} catch (IOException | ForeignBlockchainException | ClassCastException | NullPointerException e) {
-				// Didn't work, try another server...
-				closeServer();
-			}
+			ChainableServer server = this.remainingServers.remove(RANDOM.nextInt(this.remainingServers.size()));
+			Optional<ChainableServerConnection> chainableServerConnection = makeConnection(server, this.getClass().getSimpleName());
+			if(chainableServerConnection.isPresent() && chainableServerConnection.get().isSuccess() ) return true;
 		}
 
 		return false;
 	}
 
+	private Optional<ChainableServerConnection> makeConnection(ChainableServer server, String requestedBy) {
+		LOGGER.info(() -> String.format("Connecting to %s", server));
+
+		try {
+			SocketAddress endpoint = new InetSocketAddress(server.getHostName(), server.getPort());
+			int timeout = 5000; // ms
+
+			this.socket = new Socket();
+			this.socket.connect(endpoint, timeout);
+			this.socket.setTcpNoDelay(true);
+
+			if (server.getConnectionType() == Server.ConnectionType.SSL) {
+				SSLSocketFactory factory = TrustlessSSLSocketFactory.getSocketFactory();
+				this.socket = factory.createSocket(this.socket, server.getHostName(), server.getPort(), true);
+			}
+
+			this.scanner = new Scanner(this.socket.getInputStream());
+			this.scanner.useDelimiter("\n");
+
+			// All connections need to start with a version negotiation
+			this.connectedRpc("server.version");
+
+			// Check connection is suitable by asking for server features, including genesis block hash
+			JSONObject featuresJson = (JSONObject) this.connectedRpc("server.features");
+
+			if (featuresJson == null || Double.parseDouble((String) featuresJson.get("protocol_min")) < MIN_PROTOCOL_VERSION)
+				return Optional.of( recorder.recordConnection(server, requestedBy, true,  false, MINIMUM_VERSION_ERROR) );
+
+			if (this.expectedGenesisHash != null && !((String) featuresJson.get("genesis_hash")).equals(this.expectedGenesisHash))
+				return Optional.of( recorder.recordConnection(server, requestedBy, true, false, EXPECTED_GENESIS_ERROR) );
+
+			// Ask for more servers
+			Set<Server> moreServers = serverPeersSubscribe();
+
+			// Discard duplicate servers we already know
+			moreServers.removeAll(this.servers);
+
+			// Add all servers to both lists
+			this.remainingServers.addAll(moreServers);
+			this.servers.addAll(moreServers);
+
+			LOGGER.info(() -> String.format("Connected to %s", server));
+			this.currentServer = server;
+			return Optional.of( this.recorder.recordConnection( server, requestedBy, true, true, EMPTY) );
+		} catch (IOException | ForeignBlockchainException | ClassCastException | NullPointerException e) {
+			// Didn't work, try another server...
+			return Optional.of( this.recorder.recordConnection( server, requestedBy, true, false, CrossChainUtils.getNotes(e)));
+		}
+	}
+
 	/**
 	 * Perform RPC using currently connected server.
 	 * <p>
@@ -830,12 +862,19 @@ public class ElectrumX extends BitcoinyBlockchainProvider {
 
 	/**
 	 * Closes connection to <tt>server</tt> if it is currently connected server.
+	 *
 	 * @param server
+	 * @param notes
 	 */
-	private void closeServer(Server server) {
+	private Optional<ChainableServerConnection> closeServer(ChainableServer server, String requestedBy, String notes) {
+
+		ChainableServerConnection chainableServerConnection;
+
 		synchronized (this.serverLock) {
 			if (this.currentServer == null || !this.currentServer.equals(server))
-				return;
+				return Optional.empty();
+
+			chainableServerConnection = this.recorder.recordConnection(server, requestedBy, false, true, notes);
 
 			if (this.socket != null && !this.socket.isClosed())
 				try {
@@ -848,13 +887,63 @@ public class ElectrumX extends BitcoinyBlockchainProvider {
 			this.scanner = null;
 			this.currentServer = null;
 		}
+
+		return Optional.of( chainableServerConnection );
 	}
 
 	/** Closes connection to currently connected server (if any). */
-	private void closeServer() {
+	private Optional<ChainableServerConnection> closeServer(String requestedBy, String notes) {
 		synchronized (this.serverLock) {
-			this.closeServer(this.currentServer);
+			return this.closeServer(this.currentServer, requestedBy, notes);
 		}
 	}
 
+	@Override
+	public Set<ChainableServer> getServers() {
+		LOGGER.info("getting servers");
+		return servers;
+	}
+
+	@Override
+	public List<ChainableServer> getRemainingServers() {
+		return remainingServers;
+	}
+
+	@Override
+	public Set<ChainableServer> getUselessServers() {
+		return uselessServers;
+	}
+
+	@Override
+	public ChainableServer getCurrentServer() {
+		return currentServer;
+	}
+
+	@Override
+	public boolean addServer(ChainableServer server) {
+		return this.servers.add(server);
+	}
+
+	@Override
+	public boolean removeServer(ChainableServer server) {
+		boolean removedServer = this.servers.remove(server);
+		boolean removedRemaining = this.remainingServers.remove(server);
+
+		return removedServer || removedRemaining;
+	}
+
+	@Override
+	public Optional<ChainableServerConnection> setCurrentServer(ChainableServer server, String requestedBy) {
+		return this.makeConnection(server, requestedBy);
+	}
+
+	@Override
+	public List<ChainableServerConnection> getServerConnections() {
+		return this.recorder.getConnections();
+	}
+
+	@Override
+	public ChainableServer getServer(String hostName, ChainableServer.ConnectionType type, int port) {
+		return new ElectrumX.Server(hostName, type, port);
+	}
 }

src/main/java/org/qortal/crosschain/Litecoin.java

@@ -7,7 +7,7 @@ import org.libdohj.params.LitecoinMainNetParams;
 import org.libdohj.params.LitecoinRegTestParams;
 import org.libdohj.params.LitecoinTestNet3Params;
 import org.qortal.crosschain.ElectrumX.Server;
-import org.qortal.crosschain.ElectrumX.Server.ConnectionType;
+import org.qortal.crosschain.ChainableServer.ConnectionType;
 import org.qortal.settings.Settings;
 
 import java.util.Arrays;
@@ -45,13 +45,9 @@ public class Litecoin extends Bitcoiny {
 				return Arrays.asList(
 					// Servers chosen on NO BASIS WHATSOEVER from various sources!
 					// Status verified at https://1209k.com/bitcoin-eye/ele.php?chain=ltc
-					new Server("electrum.qortal.link", Server.ConnectionType.SSL, 50002),
-					new Server("electrum1-ltc.qortal.online", Server.ConnectionType.SSL, 50002),
-					new Server("electrum2-ltc.qortal.online", Server.ConnectionType.SSL, 50002),
-					new Server("electrum3-ltc.qortal.online", Server.ConnectionType.SSL, 20002),
-					new Server("electrum4-ltc.qortal.online", Server.ConnectionType.SSL, 20002),
 					new Server("backup.electrum-ltc.org", Server.ConnectionType.SSL, 443),
 					new Server("electrum.ltc.xurious.com", Server.ConnectionType.SSL, 50002),
+					new Server("electrum.qortal.link", Server.ConnectionType.SSL, 50002),
 					new Server("electrum-ltc.petrkr.net", Server.ConnectionType.SSL, 60002),
 					new Server("electrum1.cipig.net", Server.ConnectionType.SSL, 20063),
 					new Server("electrum2.cipig.net", Server.ConnectionType.SSL, 20063),
@@ -67,8 +63,7 @@ public class Litecoin extends Bitcoiny {
 
 			@Override
 			public long getP2shFee(Long timestamp) {
-				// TODO: This will need to be replaced with something better in the near future!
-				return MAINNET_FEE;
+				return this.getFeeCeiling();
 			}
 		},
 		TEST3 {
@@ -80,9 +75,7 @@ public class Litecoin extends Bitcoiny {
 			@Override
 			public Collection<ElectrumX.Server> getServers() {
 				return Arrays.asList(
-					new Server("electrum-ltc.bysh.me", Server.ConnectionType.TCP, 51001),
 					new Server("electrum-ltc.bysh.me", Server.ConnectionType.SSL, 51002),
-					new Server("electrum.ltc.xurious.com", Server.ConnectionType.TCP, 51001),
 					new Server("electrum.ltc.xurious.com", Server.ConnectionType.SSL, 51002)
 				);
 			}
@@ -123,6 +116,16 @@ public class Litecoin extends Bitcoiny {
 			}
 		};
 
+		private long feeCeiling = MAINNET_FEE;
+
+		public long getFeeCeiling() {
+			return feeCeiling;
+		}
+
+		public void setFeeCeiling(long feeCeiling) {
+			this.feeCeiling = feeCeiling;
+		}
+
 		public abstract NetworkParameters getParams();
 		public abstract Collection<ElectrumX.Server> getServers();
 		public abstract String getGenesisHash();
@@ -136,7 +139,7 @@ public class Litecoin extends Bitcoiny {
 	// Constructors and instance
 
 	private Litecoin(LitecoinNet litecoinNet, BitcoinyBlockchainProvider blockchain, Context bitcoinjContext, String currencyCode) {
-		super(blockchain, bitcoinjContext, currencyCode);
+		super(blockchain, bitcoinjContext, currencyCode, DEFAULT_FEE_PER_KB);
 		this.litecoinNet = litecoinNet;
 
 		LOGGER.info(() -> String.format("Starting Litecoin support using %s", this.litecoinNet.name()));
@@ -165,12 +168,6 @@ public class Litecoin extends Bitcoiny {
 
 	// Actual useful methods for use by other classes
 
-	/** Default Litecoin fee is lower than Bitcoin: only 10sats/byte. */
-	@Override
-	public Coin getFeePerKb() {
-		return DEFAULT_FEE_PER_KB;
-	}
-
 	@Override
 	public long getMinimumOrderAmount() {
 		return MINIMUM_ORDER_AMOUNT;
@@ -187,4 +184,14 @@ public class Litecoin extends Bitcoiny {
 		return this.litecoinNet.getP2shFee(timestamp);
 	}
 
+	@Override
+	public long getFeeCeiling() {
+		return this.litecoinNet.getFeeCeiling();
+	}
+
+	@Override
+	public void setFeeCeiling(long fee) {
+
+		this.litecoinNet.setFeeCeiling( fee );
+	}
 }

src/main/java/org/qortal/crosschain/PirateChain.java

@@ -13,7 +13,7 @@ import org.libdohj.params.PirateChainMainNetParams;
 import org.qortal.api.model.crosschain.PirateChainSendRequest;
 import org.qortal.controller.PirateChainWalletController;
 import org.qortal.crosschain.PirateLightClient.Server;
-import org.qortal.crosschain.PirateLightClient.Server.ConnectionType;
+import org.qortal.crosschain.ChainableServer.ConnectionType;
 import org.qortal.crypto.Crypto;
 import org.qortal.settings.Settings;
 import org.qortal.transform.TransformationException;
@@ -51,12 +51,12 @@ public class PirateChain extends Bitcoiny {
 			public Collection<Server> getServers() {
 				return Arrays.asList(
 					// Servers chosen on NO BASIS WHATSOEVER from various sources!
+					new Server("lightd.pirate.black", Server.ConnectionType.SSL, 443),
 					new Server("wallet-arrr1.qortal.online", Server.ConnectionType.SSL, 443),
 					new Server("wallet-arrr2.qortal.online", Server.ConnectionType.SSL, 443),
 					new Server("wallet-arrr3.qortal.online", Server.ConnectionType.SSL, 443),
 					new Server("wallet-arrr4.qortal.online", Server.ConnectionType.SSL, 443),
-					new Server("wallet-arrr5.qortal.online", Server.ConnectionType.SSL, 443),
-					new Server("lightd.pirate.black", Server.ConnectionType.SSL, 443)
+					new Server("wallet-arrr5.qortal.online", Server.ConnectionType.SSL, 443)
 				);
 			}
 
@@ -67,8 +67,7 @@ public class PirateChain extends Bitcoiny {
 
 			@Override
 			public long getP2shFee(Long timestamp) {
-				// TODO: This will need to be replaced with something better in the near future!
-				return MAINNET_FEE;
+				return this.getFeeCeiling();
 			}
 		},
 		TEST3 {
@@ -118,6 +117,16 @@ public class PirateChain extends Bitcoiny {
 			}
 		};
 
+		private long feeCeiling = MAINNET_FEE;
+
+		public long getFeeCeiling() {
+			return feeCeiling;
+		}
+
+		public void setFeeCeiling(long feeCeiling) {
+			this.feeCeiling = feeCeiling;
+		}
+
 		public abstract NetworkParameters getParams();
 		public abstract Collection<Server> getServers();
 		public abstract String getGenesisHash();
@@ -131,7 +140,7 @@ public class PirateChain extends Bitcoiny {
 	// Constructors and instance
 
 	private PirateChain(PirateChainNet pirateChainNet, BitcoinyBlockchainProvider blockchain, Context bitcoinjContext, String currencyCode) {
-		super(blockchain, bitcoinjContext, currencyCode);
+		super(blockchain, bitcoinjContext, currencyCode, DEFAULT_FEE_PER_KB);
 		this.pirateChainNet = pirateChainNet;
 
 		LOGGER.info(() -> String.format("Starting Pirate Chain support using %s", this.pirateChainNet.name()));
@@ -160,12 +169,6 @@ public class PirateChain extends Bitcoiny {
 
 	// Actual useful methods for use by other classes
 
-	/** Default Litecoin fee is lower than Bitcoin: only 10sats/byte. */
-	@Override
-	public Coin getFeePerKb() {
-		return DEFAULT_FEE_PER_KB;
-	}
-
 	@Override
 	public long getMinimumOrderAmount() {
 		return MINIMUM_ORDER_AMOUNT;
@@ -182,6 +185,16 @@ public class PirateChain extends Bitcoiny {
 		return this.pirateChainNet.getP2shFee(timestamp);
 	}
 
+	@Override
+	public long getFeeCeiling() {
+		return this.pirateChainNet.getFeeCeiling();
+	}
+
+	@Override
+	public void setFeeCeiling(long fee) {
+
+		this.pirateChainNet.setFeeCeiling( fee );
+	}
 	/**
 	 * Returns confirmed balance, based on passed payment script.
 	 * <p>

src/main/java/org/qortal/crosschain/PirateLightClient.java

@@ -14,6 +14,7 @@ import org.json.simple.JSONArray;
 import org.json.simple.JSONObject;
 import org.json.simple.parser.JSONParser;
 import org.json.simple.parser.ParseException;
+import org.qortal.api.resource.CrossChainUtils;
 import org.qortal.settings.Settings;
 import org.qortal.transform.TransformationException;
 
@@ -30,10 +31,9 @@ public class PirateLightClient extends BitcoinyBlockchainProvider {
 	private static final int RESPONSE_TIME_READINGS = 5;
 	private static final long MAX_AVG_RESPONSE_TIME = 500L; // ms
 
-	public static class Server {
+	public static class Server implements ChainableServer{
 		String hostname;
 
-		public enum ConnectionType { TCP, SSL }
 		ConnectionType connectionType;
 
 		int port;
@@ -64,6 +64,21 @@ public class PirateLightClient extends BitcoinyBlockchainProvider {
 			return 0L;
 		}
 
+		@Override
+		public String getHostName() {
+			return this.hostname;
+		}
+
+		@Override
+		public int getPort() {
+			return this.port;
+		}
+
+		@Override
+		public ChainableServer.ConnectionType getConnectionType() {
+			return this.connectionType;
+		}
+
 		@Override
 		public boolean equals(Object other) {
 			if (other == this)
@@ -89,9 +104,9 @@ public class PirateLightClient extends BitcoinyBlockchainProvider {
 			return String.format("%s:%s:%d", this.connectionType.name(), this.hostname, this.port);
 		}
 	}
-	private Set<Server> servers = new HashSet<>();
-	private List<Server> remainingServers = new ArrayList<>();
-	private Set<Server> uselessServers = Collections.synchronizedSet(new HashSet<>());
+	private Set<ChainableServer> servers = new HashSet<>();
+	private List<ChainableServer> remainingServers = new ArrayList<>();
+	private Set<ChainableServer> uselessServers = Collections.synchronizedSet(new HashSet<>());
 
 	private final String netId;
 	private final String expectedGenesisHash;
@@ -99,7 +114,7 @@ public class PirateLightClient extends BitcoinyBlockchainProvider {
 	private Bitcoiny blockchain;
 
 	private final Object serverLock = new Object();
-	private Server currentServer;
+	private ChainableServer currentServer;
 	private ManagedChannel channel;
 	private int nextId = 1;
 
@@ -113,6 +128,8 @@ public class PirateLightClient extends BitcoinyBlockchainProvider {
 		}
 	});
 
+	private ChainableServerConnectionRecorder recorder = new ChainableServerConnectionRecorder(100);
+
 	// Constructors
 
 	public PirateLightClient(String netId, String genesisHash, Collection<Server> initialServerList, Map<Server.ConnectionType, Integer> defaultPorts) {
@@ -429,12 +446,13 @@ public class PirateLightClient extends BitcoinyBlockchainProvider {
 				// Update: it turns out that they were just using a different key - "address" instead of "addresses"
 				// The code below can remain in place, just in case a peer returns a missing address in the future
 				if (addresses == null || addresses.isEmpty()) {
+					final String message = String.format("No output addresses returned for transaction %s", txHash);
 					if (this.currentServer != null) {
 						this.uselessServers.add(this.currentServer);
-						this.closeServer(this.currentServer);
+						this.closeServer(this.currentServer, message, this.getClass().getSimpleName());
 					}
-					LOGGER.info("No output addresses returned for transaction {}", txHash);
-					throw new ForeignBlockchainException(String.format("No output addresses returned for transaction %s", txHash));
+					LOGGER.info(message);
+					throw new ForeignBlockchainException(message);
 				}
 
 				outputs.add(new BitcoinyTransaction.Output(scriptPubKey, value, addresses));
@@ -525,6 +543,60 @@ public class PirateLightClient extends BitcoinyBlockchainProvider {
 			throw new ForeignBlockchainException.NetworkException(String.format("Unexpected error code from Pirate Chain broadcastTransaction gRPC: %d", sendResponse.getErrorCode()));
 	}
 
+	@Override
+	public Set<ChainableServer> getServers() {
+		return this.servers;
+	}
+
+	@Override
+	public List<ChainableServer> getRemainingServers() {
+		return this.remainingServers;
+	}
+
+	@Override
+	public Set<ChainableServer> getUselessServers() {
+		return this.uselessServers;
+	}
+
+	@Override
+	public ChainableServer getCurrentServer() { return this.currentServer; }
+
+	@Override
+	public boolean addServer(ChainableServer server) {
+		return this.servers.add(server);
+	}
+
+	@Override
+	public boolean removeServer(ChainableServer server) {
+		boolean removedServer = this.servers.remove(server);
+		boolean removedRemaining = this.remainingServers.remove(server);
+
+		return removedServer || removedRemaining;
+	}
+
+	@Override
+	public Optional<ChainableServerConnection> setCurrentServer(ChainableServer server, String requestedBy) throws ForeignBlockchainException {
+
+		closeServer( requestedBy, "Connecting to different server by request." );
+		Optional<ChainableServerConnection> connection = makeConnection(server, requestedBy);
+
+		if( !connection.isPresent() || !connection.get().isSuccess() ) {
+			haveConnection();
+		}
+
+		return connection;
+	}
+
+	@Override
+	public List<ChainableServerConnection> getServerConnections() {
+		return this.recorder.getConnections();
+	}
+
+	@Override
+	public ChainableServer getServer(String hostName, ChainableServer.ConnectionType type, int port) {
+		return new PirateLightClient.Server(hostName, type, port);
+	}
+
 	// Class-private utility methods
 
 
@@ -544,8 +616,9 @@ public class PirateLightClient extends BitcoinyBlockchainProvider {
 				if (!this.remainingServers.isEmpty()) {
 					long averageResponseTime = this.currentServer.averageResponseTime();
 					if (averageResponseTime > MAX_AVG_RESPONSE_TIME) {
-						LOGGER.info("Slow average response time {}ms from {} - trying another server...", averageResponseTime, this.currentServer.hostname);
-						this.closeServer();
+						String message = String.format("Slow average response time %dms from %s - trying another server...", averageResponseTime, this.currentServer.getHostName());
+						LOGGER.info(message);
+						this.closeServer(this.getClass().getSimpleName(), message);
 						continue;
 					}
 				}
@@ -568,19 +641,28 @@ public class PirateLightClient extends BitcoinyBlockchainProvider {
 			return true;
 
 		while (!this.remainingServers.isEmpty()) {
-			Server server = this.remainingServers.remove(RANDOM.nextInt(this.remainingServers.size()));
-			LOGGER.trace(() -> String.format("Connecting to %s", server));
+			ChainableServer server = this.remainingServers.remove(RANDOM.nextInt(this.remainingServers.size()));
 
-			try {
-				this.channel = ManagedChannelBuilder.forAddress(server.hostname, server.port).build();
+			Optional<ChainableServerConnection> chainableServerConnection = makeConnection(server, this.getClass().getSimpleName());
+			if( chainableServerConnection.isPresent() && chainableServerConnection.get().isSuccess() ) return true;
+		}
 
-				CompactTxStreamerGrpc.CompactTxStreamerBlockingStub stub = CompactTxStreamerGrpc.newBlockingStub(this.channel);
-				LightdInfo lightdInfo = stub.getLightdInfo(Empty.newBuilder().build());
+		return false;
+	}
 
-				if (lightdInfo == null || lightdInfo.getBlockHeight() <= 0)
-					continue;
+	private Optional<ChainableServerConnection> makeConnection(ChainableServer server, String requestedBy) {
+		LOGGER.info(() -> String.format("Connecting to %s", server));
 
-				// TODO: find a way to verify that the server is using the expected chain
+		try {
+			this.channel = ManagedChannelBuilder.forAddress(server.getHostName(), server.getPort()).build();
+
+			CompactTxStreamerGrpc.CompactTxStreamerBlockingStub stub = CompactTxStreamerGrpc.newBlockingStub(this.channel);
+			LightdInfo lightdInfo = stub.getLightdInfo(Empty.newBuilder().build());
+
+			if (lightdInfo == null || lightdInfo.getBlockHeight() <= 0)
+				return Optional.of( this.recorder.recordConnection(server, requestedBy,true, false, "lightd info issues") );
+
+			// TODO: find a way to verify that the server is using the expected chain
 
 //				if (featuresJson == null || Double.valueOf((String) featuresJson.get("protocol_min")) < MIN_PROTOCOL_VERSION)
 //					continue;
@@ -588,28 +670,31 @@ public class PirateLightClient extends BitcoinyBlockchainProvider {
 //				if (this.expectedGenesisHash != null && !((String) featuresJson.get("genesis_hash")).equals(this.expectedGenesisHash))
 //					continue;
 
-				LOGGER.debug(() -> String.format("Connected to %s", server));
-				this.currentServer = server;
-				return true;
-			} catch (Exception e) {
-				// Didn't work, try another server...
-				closeServer();
-			}
+			LOGGER.info(() -> String.format("Connected to %s", server));
+			this.currentServer = server;
+			return Optional.of( this.recorder.recordConnection(server, requestedBy,true, true, EMPTY) );
+		} catch (Exception e) {
+			// Didn't work, try another server...
+			return Optional.of( this.recorder.recordConnection( server, requestedBy, true, false, CrossChainUtils.getNotes(e)));
 		}
-
-		return false;
 	}
-
 	/**
 	 * Closes connection to <tt>server</tt> if it is currently connected server.
+	 *
 	 * @param server
+	 * @param requestedBy
 	 */
-	private void closeServer(Server server) {
+	private Optional<ChainableServerConnection> closeServer(ChainableServer server, String notes, String requestedBy) {
+
+		final ChainableServerConnection connection;
+
 		synchronized (this.serverLock) {
 			if (this.currentServer == null || !this.currentServer.equals(server) || this.channel == null) {
-				return;
+				return Optional.empty();
 			}
 
+			connection = this.recorder.recordConnection(server, requestedBy, false, true, notes);
+
 			// Close the gRPC managed-channel if not shut down already.
 			if (!this.channel.isShutdown()) {
 				try {
@@ -637,12 +722,14 @@ public class PirateLightClient extends BitcoinyBlockchainProvider {
 			this.channel = null;
 			this.currentServer = null;
 		}
+
+		return Optional.of( connection );
 	}
 
 	/** Closes connection to currently connected server (if any). */
-	private void closeServer() {
+	private Optional<ChainableServerConnection> closeServer(String requestedBy, String notes) {
 		synchronized (this.serverLock) {
-			this.closeServer(this.currentServer);
+			return this.closeServer(this.currentServer, notes, requestedBy);
 		}
 	}
 

src/main/java/org/qortal/crosschain/Ravencoin.java

@@ -7,7 +7,7 @@ import org.bitcoinj.params.RegTestParams;
 import org.bitcoinj.params.TestNet3Params;
 import org.libdohj.params.RavencoinMainNetParams;
 import org.qortal.crosschain.ElectrumX.Server;
-import org.qortal.crosschain.ElectrumX.Server.ConnectionType;
+import org.qortal.crosschain.ChainableServer.ConnectionType;
 import org.qortal.settings.Settings;
 
 import java.util.Arrays;
@@ -46,10 +46,6 @@ public class Ravencoin extends Bitcoiny {
 					// Servers chosen on NO BASIS WHATSOEVER from various sources!
 					// Status verified at https://1209k.com/bitcoin-eye/ele.php?chain=rvn
 					new Server("electrum.qortal.link", Server.ConnectionType.SSL, 56002),
-					new Server("electrum1-rvn.qortal.online", Server.ConnectionType.SSL, 50002),
-					new Server("electrum2-rvn.qortal.online", Server.ConnectionType.SSL, 50002),
-					new Server("electrum3-rvn.qortal.online", Server.ConnectionType.SSL, 50002),
-					new Server("electrum4-rvn.qortal.online", Server.ConnectionType.SSL, 50002),
 					new Server("electrum1.cipig.net", Server.ConnectionType.SSL, 20051),
 					new Server("electrum2.cipig.net", Server.ConnectionType.SSL, 20051),
 					new Server("electrum3.cipig.net", Server.ConnectionType.SSL, 20051),
@@ -65,8 +61,7 @@ public class Ravencoin extends Bitcoiny {
 
 			@Override
 			public long getP2shFee(Long timestamp) {
-				// TODO: This will need to be replaced with something better in the near future!
-				return MAINNET_FEE;
+				return this.getFeeCeiling();
 			}
 		},
 		TEST3 {
@@ -116,6 +111,16 @@ public class Ravencoin extends Bitcoiny {
 			}
 		};
 
+		private long feeCeiling = MAINNET_FEE;
+
+		public long getFeeCeiling() {
+			return feeCeiling;
+		}
+
+		public void setFeeCeiling(long feeCeiling) {
+			this.feeCeiling = feeCeiling;
+		}
+
 		public abstract NetworkParameters getParams();
 		public abstract Collection<Server> getServers();
 		public abstract String getGenesisHash();
@@ -129,7 +134,7 @@ public class Ravencoin extends Bitcoiny {
 	// Constructors and instance
 
 	private Ravencoin(RavencoinNet ravencoinNet, BitcoinyBlockchainProvider blockchain, Context bitcoinjContext, String currencyCode) {
-		super(blockchain, bitcoinjContext, currencyCode);
+		super(blockchain, bitcoinjContext, currencyCode, DEFAULT_FEE_PER_KB);
 		this.ravencoinNet = ravencoinNet;
 
 		LOGGER.info(() -> String.format("Starting Ravencoin support using %s", this.ravencoinNet.name()));
@@ -158,11 +163,6 @@ public class Ravencoin extends Bitcoiny {
 
 	// Actual useful methods for use by other classes
 
-	@Override
-	public Coin getFeePerKb() {
-		return DEFAULT_FEE_PER_KB;
-	}
-
 	@Override
 	public long getMinimumOrderAmount() {
 		return MINIMUM_ORDER_AMOUNT;
@@ -179,4 +179,14 @@ public class Ravencoin extends Bitcoiny {
 		return this.ravencoinNet.getP2shFee(timestamp);
 	}
 
+	@Override
+	public long getFeeCeiling() {
+		return this.ravencoinNet.getFeeCeiling();
+	}
+
+	@Override
+	public void setFeeCeiling(long fee) {
+
+		this.ravencoinNet.setFeeCeiling( fee );
+	}
 }

src/main/java/org/qortal/crosschain/ServerConfigurationInfo.java

@@ -0,0 +1,60 @@
+package org.qortal.crosschain;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import java.util.List;
+import java.util.Objects;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+public class ServerConfigurationInfo {
+
+    private List<ServerInfo> servers;
+    private List<ServerInfo> remainingServers;
+    private List<ServerInfo> uselessServers;
+
+    public ServerConfigurationInfo() {
+    }
+
+    public ServerConfigurationInfo(
+            List<ServerInfo> servers,
+            List<ServerInfo> remainingServers,
+            List<ServerInfo> uselessServers) {
+        this.servers = servers;
+        this.remainingServers = remainingServers;
+        this.uselessServers = uselessServers;
+    }
+
+    public List<ServerInfo> getServers() {
+        return servers;
+    }
+
+    public List<ServerInfo> getRemainingServers() {
+        return remainingServers;
+    }
+
+    public List<ServerInfo> getUselessServers() {
+        return uselessServers;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        ServerConfigurationInfo that = (ServerConfigurationInfo) o;
+        return Objects.equals(servers, that.servers) && Objects.equals(remainingServers, that.remainingServers) && Objects.equals(uselessServers, that.uselessServers);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(servers, remainingServers, uselessServers);
+    }
+
+    @Override
+    public String toString() {
+        return "ServerConfigurationInfo{" +
+                "servers=" + servers +
+                ", remainingServers=" + remainingServers +
+                ", uselessServers=" + uselessServers +
+                '}';
+    }
+}

src/main/java/org/qortal/crosschain/ServerConnectionInfo.java

@@ -0,0 +1,82 @@
+package org.qortal.crosschain;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import java.util.Objects;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+public class ServerConnectionInfo {
+
+    private ServerInfo serverInfo;
+
+    private String requestedBy;
+
+    private boolean open;
+
+    private boolean success;
+
+    private long timeInMillis;
+
+    private String notes;
+
+    public ServerConnectionInfo() {
+    }
+
+    public ServerConnectionInfo(ServerInfo serverInfo, String requestedBy, boolean open, boolean success, long timeInMillis, String notes) {
+        this.serverInfo = serverInfo;
+        this.requestedBy = requestedBy;
+        this.open = open;
+        this.success = success;
+        this.timeInMillis = timeInMillis;
+        this.notes = notes;
+    }
+
+    public ServerInfo getServerInfo() {
+        return serverInfo;
+    }
+
+    public String getRequestedBy() {
+        return requestedBy;
+    }
+
+    public boolean isOpen() {
+        return open;
+    }
+
+    public boolean isSuccess() {
+        return success;
+    }
+
+    public long getTimeInMillis() {
+        return timeInMillis;
+    }
+
+    public String getNotes() {
+        return notes;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        ServerConnectionInfo that = (ServerConnectionInfo) o;
+        return timeInMillis == that.timeInMillis && Objects.equals(serverInfo, that.serverInfo);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(serverInfo, timeInMillis);
+    }
+
+    @Override
+    public String toString() {
+        return "ServerConnectionInfo{" +
+                "serverInfo=" + serverInfo +
+                ", requestedBy='" + requestedBy + '\'' +
+                ", open=" + open +
+                ", success=" + success +
+                ", timeInMillis=" + timeInMillis +
+                ", notes='" + notes + '\'' +
+                '}';
+    }
+}

src/main/java/org/qortal/crosschain/ServerInfo.java

@@ -0,0 +1,74 @@
+package org.qortal.crosschain;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import java.util.Objects;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+public class ServerInfo {
+
+        private long averageResponseTime;
+
+        private String hostName;
+
+        private int port;
+
+        private String connectionType;
+
+        private boolean isCurrent;
+
+        public ServerInfo() {
+        }
+
+        public ServerInfo(long averageResponseTime, String hostName, int port, String connectionType, boolean isCurrent) {
+                this.averageResponseTime = averageResponseTime;
+                this.hostName = hostName;
+                this.port = port;
+                this.connectionType = connectionType;
+                this.isCurrent = isCurrent;
+        }
+
+        public long getAverageResponseTime() {
+                return averageResponseTime;
+        }
+
+        public String getHostName() {
+                return hostName;
+        }
+
+        public int getPort() {
+                return port;
+        }
+
+        public String getConnectionType() {
+                return connectionType;
+        }
+
+        public boolean isCurrent() {
+                return isCurrent;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+                if (this == o) return true;
+                if (o == null || getClass() != o.getClass()) return false;
+                ServerInfo that = (ServerInfo) o;
+                return averageResponseTime == that.averageResponseTime && port == that.port && isCurrent == that.isCurrent && Objects.equals(hostName, that.hostName) && Objects.equals(connectionType, that.connectionType);
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(averageResponseTime, hostName, port, connectionType, isCurrent);
+        }
+
+        @Override
+        public String toString() {
+                return "ServerInfo{" +
+                        "averageResponseTime=" + averageResponseTime +
+                        ", hostName='" + hostName + '\'' +
+                        ", port=" + port +
+                        ", connectionType='" + connectionType + '\'' +
+                        ", isCurrent=" + isCurrent +
+                        '}';
+        }
+}

src/main/java/org/qortal/crypto/TrustlessSSLSocketFactory.java

@@ -1,33 +1,33 @@
 package org.qortal.crypto;
 
-import javax.net.ssl.SSLContext;
-import javax.net.ssl.SSLSocketFactory;
-import javax.net.ssl.TrustManager;
-import javax.net.ssl.X509TrustManager;
+import javax.net.ssl.*;
 import java.security.cert.X509Certificate;
 
 public abstract class TrustlessSSLSocketFactory {
 
-	// Create a trust manager that does not validate certificate chains
+	/**
+	 * Creates a SSLSocketFactory that ignore certificate chain validation because ElectrumX servers use mostly
+	 * self signed certificates.
+	 */
 	private static final TrustManager[] TRUSTLESS_MANAGER = new TrustManager[] {
 		new X509TrustManager() {
-			public java.security.cert.X509Certificate[] getAcceptedIssuers() {
-				return new X509Certificate[0];
+			public X509Certificate[] getAcceptedIssuers() {
+				return null;
 			}
-
-			public void checkClientTrusted(java.security.cert.X509Certificate[] certs, String authType) {
+			public void checkClientTrusted(X509Certificate[] certs, String authType) {
 			}
-
-			public void checkServerTrusted(java.security.cert.X509Certificate[] certs, String authType) {
+			public void checkServerTrusted(X509Certificate[] certs, String authType) {
 			}
 		}
 	};
 
-	// Install the all-trusting trust manager
+	/**
+	 * Install the all-trusting trust manager.
+	 */
 	private static final SSLContext sc;
 	static {
 		try {
-			sc = SSLContext.getInstance("TLSv1.3");
+			sc = SSLContext.getInstance("SSL");
 			sc.init(null, TRUSTLESS_MANAGER, new java.security.SecureRandom());
 		} catch (Exception e) {
 			throw new RuntimeException(e);
@@ -37,5 +37,4 @@ public abstract class TrustlessSSLSocketFactory {
 	public static SSLSocketFactory getSocketFactory() {
 		return sc.getSocketFactory();
 	}
-
 }

src/main/java/org/qortal/data/crosschain/AtomicTransactionData.java

@@ -0,0 +1,32 @@
+package org.qortal.data.crosschain;
+
+import org.qortal.crosschain.BitcoinyTransaction;
+import org.qortal.crosschain.TransactionHash;
+
+import java.util.List;
+import java.util.Map;
+
+public class AtomicTransactionData {
+    public final TransactionHash hash;
+    public final Integer timestamp;
+    public final List<BitcoinyTransaction.Input> inputs;
+    public final Map<List<String>, Long> valueByAddress;
+    public final long totalAmount;
+    public final int size;
+
+    public AtomicTransactionData(
+            TransactionHash hash,
+            Integer timestamp,
+            List<BitcoinyTransaction.Input> inputs,
+            Map<List<String>, Long> valueByAddress,
+            long totalAmount,
+            int size) {
+        
+        this.hash = hash;
+        this.timestamp = timestamp;
+        this.inputs = inputs;
+        this.valueByAddress = valueByAddress;
+        this.totalAmount = totalAmount;
+        this.size = size;
+    }
+}

src/main/java/org/qortal/data/crosschain/TransactionSummary.java

@@ -0,0 +1,106 @@
+package org.qortal.data.crosschain;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+public class TransactionSummary {
+
+    private String atAddress;
+    private String p2shValue;
+    private String p2shAddress;
+    private String lockingHash;
+    private Integer lockingTimestamp;
+    private long lockingTotalAmount;
+    private long lockingFee;
+    private int lockingSize;
+    private String unlockingHash;
+    private Integer unlockingTimestamp;
+    private long unlockingTotalAmount;
+    private long unlockingFee;
+    private int unlockingSize;
+
+    public TransactionSummary(){}
+    
+    public TransactionSummary(
+            String atAddress,
+            String p2shValue,
+            String p2shAddress,
+            String lockingHash,
+            Integer lockingTimestamp,
+            long lockingTotalAmount,
+            long lockingFee,
+            int lockingSize,
+            String unlockingHash,
+            Integer unlockingTimestamp,
+            long unlockingTotalAmount,
+            long unlockingFee,
+            int unlockingSize) {
+
+        this.atAddress = atAddress;
+        this.p2shValue = p2shValue;
+        this.p2shAddress = p2shAddress;
+        this.lockingHash = lockingHash;
+        this.lockingTimestamp = lockingTimestamp;
+        this.lockingTotalAmount = lockingTotalAmount;
+        this.lockingFee = lockingFee;
+        this.lockingSize = lockingSize;
+        this.unlockingHash = unlockingHash;
+        this.unlockingTimestamp = unlockingTimestamp;
+        this.unlockingTotalAmount = unlockingTotalAmount;
+        this.unlockingFee = unlockingFee;
+        this.unlockingSize = unlockingSize;
+    }
+
+    public String getAtAddress() {
+        return atAddress;
+    }
+
+    public String getP2shValue() {
+        return p2shValue;
+    }
+
+    public String getP2shAddress() {
+        return p2shAddress;
+    }
+
+    public String getLockingHash() {
+        return lockingHash;
+    }
+
+    public Integer getLockingTimestamp() {
+        return lockingTimestamp;
+    }
+
+    public long getLockingTotalAmount() {
+        return lockingTotalAmount;
+    }
+
+    public long getLockingFee() {
+        return lockingFee;
+    }
+
+    public int getLockingSize() {
+        return lockingSize;
+    }
+
+    public String getUnlockingHash() {
+        return unlockingHash;
+    }
+
+    public Integer getUnlockingTimestamp() {
+        return unlockingTimestamp;
+    }
+
+    public long getUnlockingTotalAmount() {
+        return unlockingTotalAmount;
+    }
+
+    public long getUnlockingFee() {
+        return unlockingFee;
+    }
+
+    public int getUnlockingSize() {
+        return unlockingSize;
+    }
+}

src/main/java/org/qortal/data/transaction/ArbitraryTransactionData.java

@@ -25,8 +25,8 @@ public class ArbitraryTransactionData extends TransactionData {
 	// "data" field types
 	public enum DataType {
 		RAW_DATA,
-		DATA_HASH;
-	}
+		DATA_HASH
+    }
 
 	// Methods
 	public enum Method {

src/main/java/org/qortal/gui/SysTray.java

@@ -4,8 +4,6 @@ import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.qortal.controller.Controller;
 import org.qortal.globalization.Translator;
-import org.qortal.settings.Settings;
-import org.qortal.utils.RandomizeList;
 import org.qortal.utils.URLViewer;
 
 import javax.swing.*;
@@ -18,14 +16,11 @@ import java.awt.event.WindowEvent;
 import java.awt.event.WindowFocusListener;
 import java.io.IOException;
 import java.io.InputStream;
-import java.net.InetSocketAddress;
 import java.net.URL;
-import java.nio.channels.SocketChannel;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.nio.file.StandardCopyOption;
-import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 
@@ -140,14 +135,6 @@ public class SysTray {
 			}
 		});
 
-		/* JMenuItem openUi = new JMenuItem(Translator.INSTANCE.translate("SysTray", "OPEN_UI"));
-		openUi.addActionListener(actionEvent -> {
-			destroyHiddenDialog();
-
-			new OpenUiWorker().execute();
-		});
-		menu.add(openUi); */
-
 		JMenuItem openTimeCheck = new JMenuItem(Translator.INSTANCE.translate("SysTray", "CHECK_TIME_ACCURACY"));
 		openTimeCheck.addActionListener(actionEvent -> {
 			destroyHiddenDialog();
@@ -190,48 +177,6 @@ public class SysTray {
 		return menu;
 	}
 
-	static class OpenUiWorker extends SwingWorker<Void, Void> {
-		@Override
-		protected Void doInBackground() {
-			List<String> uiServers = new ArrayList<>();
-
-			String[] remoteUiServers = Settings.getInstance().getRemoteUiServers();
-			uiServers.addAll(Arrays.asList(remoteUiServers));
-			// Randomize remote servers
-			uiServers = RandomizeList.randomize(uiServers);
-
-			// Prepend local servers
-			String[] localUiServers = Settings.getInstance().getLocalUiServers();
-			uiServers.addAll(0, Arrays.asList(localUiServers));
-
-			// Check each server in turn before opening browser tab
-			int uiPort = Settings.getInstance().getUiServerPort();
-			for (String uiServer : uiServers) {
-				InetSocketAddress socketAddress = new InetSocketAddress(uiServer, uiPort);
-
-				// If we couldn't resolve try next
-				if (socketAddress.isUnresolved())
-					continue;
-
-				try (SocketChannel socketChannel = SocketChannel.open()) {
-					socketChannel.socket().connect(socketAddress, 100);
-
-					// If we reach here, then socket connected to UI server!
-					URLViewer.openWebpage(new URL(String.format("http://%s:%d", uiServer, uiPort)));
-
-					return null;
-				} catch (IOException e) {
-					// try next server
-				} catch (Exception e) {
-					LOGGER.error("Unable to open UI website in browser");
-					return null;
-				}
-			}
-
-			return null;
-		}
-	}
-
 	static class SynchronizeClockWorker extends SwingWorker<Void, Void> {
 		@Override
 		protected Void doInBackground() {

src/main/java/org/qortal/network/Handshake.java

@@ -70,15 +70,15 @@ public enum Handshake {
 			peer.setPeersVersion(versionString, version);
 
 			// Ensure the peer is running at least the version specified in MIN_PEER_VERSION
-			if (peer.isAtLeastVersion(MIN_PEER_VERSION) == false) {
+			if (!peer.isAtLeastVersion(MIN_PEER_VERSION)) {
 				LOGGER.debug(String.format("Ignoring peer %s because it is on an old version (%s)", peer, versionString));
 				return null;
 			}
 
-			if (Settings.getInstance().getAllowConnectionsWithOlderPeerVersions() == false) {
+			if (!Settings.getInstance().getAllowConnectionsWithOlderPeerVersions()) {
 				// Ensure the peer is running at least the minimum version allowed for connections
 				final String minPeerVersion = Settings.getInstance().getMinPeerVersion();
-				if (peer.isAtLeastVersion(minPeerVersion) == false) {
+				if (!peer.isAtLeastVersion(minPeerVersion)) {
 					LOGGER.debug(String.format("Ignoring peer %s because it is on an old version (%s)", peer, versionString));
 					return null;
 				}

src/main/java/org/qortal/network/Network.java

@@ -810,7 +810,7 @@ public class Network {
                 .filter(peer -> peer.hasReachedMaxConnectionAge())
                 .collect(Collectors.toList());
 
-        if (peersToDisconnect != null && peersToDisconnect.size() > 0) {
+        if (peersToDisconnect != null && !peersToDisconnect.isEmpty()) {
             for (Peer peer : peersToDisconnect) {
                 LOGGER.debug("Forcing disconnection of peer {} because connection age ({} ms) " +
                         "has reached the maximum ({} ms)", peer, peer.getConnectionAge(), peer.getMaxConnectionAge());

src/main/java/org/qortal/network/Peer.java

@@ -859,7 +859,7 @@ public class Peer {
             }
         }
 
-        if (logStats && this.receivedMessageStats.size() > 0) {
+        if (logStats && !this.receivedMessageStats.isEmpty()) {
             StringBuilder statsBuilder = new StringBuilder(1024);
             statsBuilder.append("peer ").append(this).append(" message stats:\n=received=");
             appendMessageStats(statsBuilder, this.receivedMessageStats);

src/main/java/org/qortal/repository/TransactionRepository.java

@@ -205,6 +205,15 @@ public interface TransactionRepository {
 	 */
 	public List<String> getConfirmedRewardShareCreatorsExcludingSelfShares() throws DataException;
 
+	/**
+	 * Returns list of transfer asset transaction creators.
+	 * This uses confirmed transactions only.
+	 *
+	 * @return
+	 * @throws DataException
+	 */
+	public List<String> getConfirmedTransferAssetCreators() throws DataException;
+
 	/**
 	 * Returns list of transactions pending approval, with optional txGgroupId filtering.
 	 * <p>

src/main/java/org/qortal/repository/hsqldb/HSQLDBArbitraryRepository.java

@@ -1024,7 +1024,7 @@ public class HSQLDBArbitraryRepository implements ArbitraryRepository {
 		String tag5 = null;
 
 		if (tags != null) {
-			if (tags.size() > 0) tag1 = tags.get(0);
+			if (!tags.isEmpty()) tag1 = tags.get(0);
 			if (tags.size() > 1) tag2 = tags.get(1);
 			if (tags.size() > 2) tag3 = tags.get(2);
 			if (tags.size() > 3) tag4 = tags.get(3);

src/main/java/org/qortal/repository/hsqldb/HSQLDBChatRepository.java

@@ -69,10 +69,10 @@ public class HSQLDBChatRepository implements ChatRepository {
 			bindParams.add(chatReferenceBytes);
 		}
 
-		if (hasChatReference != null && hasChatReference == true) {
+		if (hasChatReference != null && hasChatReference) {
 			whereClauses.add("chat_reference IS NOT NULL");
 		}
-		else if (hasChatReference != null && hasChatReference == false) {
+		else if (hasChatReference != null && !hasChatReference) {
 			whereClauses.add("chat_reference IS NULL");
 		}
 

src/main/java/org/qortal/repository/hsqldb/HSQLDBDatabaseUpdates.java

@@ -1047,6 +1047,11 @@ public class HSQLDBDatabaseUpdates {
 					stmt.execute("CREATE INDEX ArbitraryIdentifierIndex ON ArbitraryTransactions (identifier)");
 					break;
 
+				case 49:
+					// Update blocks minted penalty
+					stmt.execute("UPDATE Accounts SET blocks_minted_penalty = -5000000 WHERE blocks_minted_penalty < 0");
+					break;
+
 				default:
 					// nothing to do
 					return false;