Bump version to 4.6.1

Reduced connection error to a warning. Removed unnecessary return val…

README.md

@@ -1,4 +1,19 @@
-# Qortal Project - Official Repo
+# Qortal Project - Qortal Core - Primary Repository
+The Qortal Core is the blockchain and node component of the overall project. It contains the primary API, and ability to make calls to create transactions, and interact with the Qortal Blockchain Network. 
+
+In order to run the Qortal Core, a machine with java 11+ installed is required. Minimum RAM specs will vary depending on settings, but as low as 4GB of RAM should be acceptable in most scenarios. 
+
+Qortal is a complete infrastructure platform with a blockchain backend, it is capable of indefinite web and application hosting with no continual fees, replacement of DNS and centralized name systems and communications systems, and is the foundation of the next generation digital infrastructure of the world. Qortal is unique in nearly every way, and was written from scratch to address as many concerns from both the existing 'blockchain space' and the 'typical internet' as possible, while maintaining a system that is easy to use and able to run on 'any' computer. 
+
+Qortal contains extensive functionality geared toward complete decentralization of the digital world. Removal of 'middlemen' of any kind from all transactions, and ability to publish websites and applications that require no continual fees, on a name that is truly owned by the account that registered it, or purchased it from another. A single name on Qortal is capable of being both a namespace and a 'username'. That single name can have an application, website, public and private data, communications, authentication, the namespace itself and more, which can subsequently be sold to anyone else without the need to change any type of 'hosting' or DNS entries that do not exist, email that doesn't exist, etc. Maintaining the same functionality as those replaced features of web 2.0. 
+
+Over time Qortal has progressed into a fully featured environment catering to any and all types of people and organizations, and will continue to advance as time goes on. Brining more features, capability, device support, and availale replacements for web2.0. Ultimately building a new, completely user-controlled digital world without limits. 
+
+Qortal has no owner, no company on top of it, and is completely community built, run, and funded. A community-established and run group of developers known as the 'dev-group' or Qortal Development Group, make group_approval based decisions for the project's future. If you are a developer interested in assisting with the project, you meay reach out to the Qortal Development Group in any of the available Qortal community locations. Either on the Qortal network itself, or on one of the temporary centralized social media locations. 
+
+Building the future one block at a time. Welcome to Qortal. 
+
+# Building the Qortal Core from Source
 
 ## Build / run
 
@@ -10,3 +25,21 @@
 - Run JAR in same working directory as *settings.json*: `java -jar target/qortal-1.0.jar`
 - Wrap in shell script, add JVM flags, redirection, backgrounding, etc. as necessary.
 - Or use supplied example shell script: *start.sh*
+
+# Using a pre-built Qortal 'jar' binary
+
+If you would prefer to utilize a released version of Qortal, you may do so by downloading one of the available releases from the releases page, that are also linked on https://qortal.org and https://qortal.dev. 
+
+# Learning Q-App Development
+
+https://qortal.dev contains dev documentation for building JS/React (and other client-side languages) applications or 'Q-Apps' on Qortal. Q-Apps are published on Registered Qortal Names, and aside from a single Name Registration fee, and a fraction of QORT for a publish transaction, require zero continual costs. These applications get more redundant with each new access from a new Qortal Node, making your application faster for the next user to download, and stronger as time goes on. Q-Apps live indefinitely in the history of the blockchain-secured Qortal Data Network (QDN).
+
+# How to learn more
+
+If the project interests you, you may learn more from the various web2 and QDN based websites focused on introductory information. 
+
+https://qortal.org - primary internet presence 
+https://qortal.dev - secondary and development focused website with links to many new developments and documentation
+https://wiki.qortal.org - community built and managed wiki with detailed information regarding the project
+
+links to telegram and discord communities are at the top of https://qortal.org as well. 

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,13 +3,14 @@
   <groupId>org.ciyam</groupId>
   <artifactId>AT</artifactId>
   <versioning>
-    <release>1.4.1</release>
+    <release>1.4.2</release>
     <versions>
       <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>20231212092227</lastUpdated>
+    <lastUpdated>20240426084210</lastUpdated>
   </versioning>
 </metadata>

pom.xml

@@ -3,59 +3,61 @@
 	<modelVersion>4.0.0</modelVersion>
 	<groupId>org.qortal</groupId>
 	<artifactId>qortal</artifactId>
-	<version>4.5.1</version>
+	<version>4.6.1</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.5.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.25.0</commons-compress.version>
-		<commons-lang3.version>3.14.0</commons-lang3.version>
+		<commons-text.version>1.12.0</commons-text.version>
+		<commons-io.version>2.17.0</commons-io.version>
+		<commons-compress.version>1.27.1</commons-compress.version>
+		<commons-lang3.version>3.17.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.61.1</grpc.version>
-		<guava.version>33.0.0-jre</guava.version>
+		<grpc.version>1.68.1</grpc.version>
+		<guava.version>33.3.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.2</icu4j.version>
+		<icu4j.version>76.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.54.v20240208</jetty.version>
+		<jersey.version>2.42</jersey.version>
+		<jetty.version>9.4.56.v20240826</jetty.version>
 		<json-simple.version>1.1.1</json-simple.version>
-		<json.version>20240205</json.version>
-		<jsoup.version>1.17.2</jsoup.version>
-		<junit-jupiter-engine.version>5.10.0</junit-jupiter-engine.version>
+		<json.version>20240303</json.version>
+		<jsoup.version>1.18.1</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.22.1</log4j.version>
+		<log4j.version>2.23.1</log4j.version>
 		<mail.version>1.5.0-b01</mail.version>
-		<maven-compiler-plugin.version>3.12.1</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.17.1</maven-plugin.version>
+		<maven-reproducible-build-plugin.version>0.17</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.5</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.25.2</protobuf.version>
+		<maven-shade-plugin.version>3.6.0</maven-shade-plugin.version>
+		<maven-surefire-plugin.version>3.5.2</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.10.3</swagger-ui.version>
+		<swagger-ui.version>5.17.14</swagger-ui.version>
 		<upnp.version>1.2</upnp.version>
-		<versions-maven-plugin.version>2.16.2</versions-maven-plugin.version>
-		<xz.version>1.9</xz.version>
+		<xz.version>1.10</xz.version>
 	</properties>
 	<build>
 		<sourceDirectory>src/main/java</sourceDirectory>
@@ -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/ApplyRestart.java

@@ -1,14 +1,17 @@
 package org.qortal;
 
+import org.apache.commons.io.FileUtils;
 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.Controller;
 import org.qortal.controller.RestartNode;
 import org.qortal.settings.Settings;
 
+import java.io.File;
 import java.io.IOException;
 import java.lang.management.ManagementFactory;
 import java.nio.file.Files;
@@ -16,6 +19,8 @@ import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.security.Security;
 import java.util.*;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.ReentrantLock;
 import java.util.stream.Collectors;
 
 import static org.qortal.controller.RestartNode.AGENTLIB_JVM_HOLDER_ARG;
@@ -38,7 +43,7 @@ public class ApplyRestart {
 	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 long CHECK_INTERVAL = 30 * 1000L; // ms
 	private static final int MAX_ATTEMPTS = 12;
 
 	public static void main(String[] args) {
@@ -51,21 +56,38 @@ public class ApplyRestart {
 		else
 			Settings.getInstance();
 
-		LOGGER.info("Applying restart...");
+		LOGGER.info("Applying restart this can take up to 5 minutes...");
 
 		// Shutdown node using API
 		if (!shutdownNode())
 			return;
 
-		// Restart node
-		restartNode(args);
+		try {
+			// Give some time for shutdown
+			TimeUnit.SECONDS.sleep(60);
 
-		LOGGER.info("Restarting...");
+			// Remove blockchain lock if exist
+			ReentrantLock blockchainLock = Controller.getInstance().getBlockchainLock();
+			if (blockchainLock.isLocked())
+				blockchainLock.unlock();
+
+			// Remove blockchain lock file if still exist
+			TimeUnit.SECONDS.sleep(60);
+			deleteLock();
+
+			// Restart node
+			TimeUnit.SECONDS.sleep(15);
+			restartNode(args);
+
+			LOGGER.info("Restarting...");
+		} catch (InterruptedException e) {
+			LOGGER.error("Unable to restart", e);
+		}
 	}
 
 	private static boolean shutdownNode() {
 		String baseUri = "http://localhost:" + Settings.getInstance().getApiPort() + "/";
-		LOGGER.info(() -> String.format("Shutting down node using API via %s", baseUri));
+		LOGGER.debug(() -> 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;
@@ -95,10 +117,17 @@ public class ApplyRestart {
 			String response = ApiRequest.perform(baseUri + "admin/stop", params);
 			if (response == null) {
 				// No response - consider node shut down
+				try {
+					TimeUnit.SECONDS.sleep(30);
+				} catch (InterruptedException e) {
+					throw new RuntimeException(e);
+				}
+
 				if (apiKeyNewlyGenerated) {
 					// API key was newly generated for restarting node, so we need to remove it
 					ApplyRestart.removeGeneratedApiKey();
 				}
+
 				return true;
 			}
 
@@ -134,7 +163,22 @@ public class ApplyRestart {
 			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());
+		}
+	}
+
+	private static void deleteLock() {
+		// Get the repository path from settings
+		String repositoryPath = Settings.getInstance().getRepositoryPath();
+		LOGGER.debug(String.format("Repository path is: %s", repositoryPath));
+
+		try {
+			Path root = Paths.get(repositoryPath);
+			File lockFile = new File(root.resolve("blockchain.lck").toUri());
+			LOGGER.debug("Lockfile is: {}", lockFile);
+			FileUtils.forceDelete(FileUtils.getFile(lockFile));
+		} catch (IOException e) {
+			LOGGER.debug("Error deleting blockchain lock file: {}", e.getMessage());
 		}
 	}
 
@@ -150,9 +194,10 @@ public class ApplyRestart {
 
 		List<String> javaCmd;
 		if (Files.exists(exeLauncher)) {
-			javaCmd = Arrays.asList(exeLauncher.toString());
+			javaCmd = List.of(exeLauncher.toString());
 		} else {
 			javaCmd = new ArrayList<>();
+
 			// Java runtime binary itself
 			javaCmd.add(javaBinary.toString());
 

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

@@ -7,7 +7,10 @@ import org.qortal.controller.LiteNode;
 import org.qortal.data.account.AccountBalanceData;
 import org.qortal.data.account.AccountData;
 import org.qortal.data.account.RewardShareData;
+import org.qortal.data.naming.NameData;
 import org.qortal.repository.DataException;
+import org.qortal.repository.GroupRepository;
+import org.qortal.repository.NameRepository;
 import org.qortal.repository.Repository;
 import org.qortal.settings.Settings;
 import org.qortal.utils.Base58;
@@ -15,6 +18,8 @@ import org.qortal.utils.Base58;
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
 
+import java.util.List;
+
 import static org.qortal.utils.Amounts.prettyAmount;
 
 @XmlAccessorType(XmlAccessType.NONE) // Stops JAX-RS errors when unmarshalling blockchain config
@@ -193,26 +198,65 @@ public class Account {
 
 	/** Returns whether account can be considered a "minting account".
 	 * <p>
-	 * To be considered a "minting account", the account needs to pass at least one of these tests:<br>
+	 * To be considered a "minting account", the account needs to pass all of these tests:<br>
 	 * <ul>
 	 * <li>account's level is at least <tt>minAccountLevelToMint</tt> from blockchain config</li>
-	 * <li>account has 'founder' flag set</li>
+	 * <li>account's address have registered a name</li>
+	 * <li>account's address is member of minter group</li>
 	 * </ul>
-	 * 
+	 *
 	 * @return true if account can be considered "minting account"
 	 * @throws DataException
 	 */
 	public boolean canMint() throws DataException {
 		AccountData accountData = this.repository.getAccountRepository().getAccount(this.address);
+		NameRepository nameRepository = this.repository.getNameRepository();
+		GroupRepository groupRepository = this.repository.getGroupRepository();
+
+		int blockchainHeight = this.repository.getBlockRepository().getBlockchainHeight();
+		int nameCheckHeight = BlockChain.getInstance().getOnlyMintWithNameHeight();
+		int levelToMint = BlockChain.getInstance().getMinAccountLevelToMint();
+		int level = accountData.getLevel();
+		int groupIdToMint = BlockChain.getInstance().getMintingGroupId();
+		int groupCheckHeight = BlockChain.getInstance().getGroupMemberCheckHeight();
+
+		String myAddress = accountData.getAddress();
+		List<NameData> myName = nameRepository.getNamesByOwner(myAddress);
+		boolean isMember = groupRepository.memberExists(groupIdToMint, myAddress);
+
 		if (accountData == null)
 			return false;
 
-		Integer level = accountData.getLevel();
-		if (level != null && level >= BlockChain.getInstance().getMinAccountLevelToMint())
+		// Can only mint if level is at least minAccountLevelToMint< from blockchain config
+		if (blockchainHeight < nameCheckHeight && level >= levelToMint)
 			return true;
 
-		// Founders can always mint, unless they have a penalty
-		if (Account.isFounder(accountData.getFlags()) && accountData.getBlocksMintedPenalty() == 0)
+		// Can only mint if have registered a name
+		if (blockchainHeight >= nameCheckHeight && blockchainHeight < groupCheckHeight && level >= levelToMint && !myName.isEmpty())
+			return true;
+
+		// Can only mint if have registered a name and is member of minter group id
+		if (blockchainHeight >= groupCheckHeight && level >= levelToMint && !myName.isEmpty() && isMember)
+			return true;
+
+		// Founders needs to pass same tests like minters
+		if (blockchainHeight < nameCheckHeight &&
+				Account.isFounder(accountData.getFlags()) &&
+				accountData.getBlocksMintedPenalty() == 0)
+			return true;
+
+		if (blockchainHeight >= nameCheckHeight &&
+				blockchainHeight < groupCheckHeight &&
+				Account.isFounder(accountData.getFlags()) &&
+				accountData.getBlocksMintedPenalty() == 0 &&
+				!myName.isEmpty())
+			return true;
+
+		if (blockchainHeight >= groupCheckHeight &&
+				Account.isFounder(accountData.getFlags()) &&
+				accountData.getBlocksMintedPenalty() == 0 &&
+				!myName.isEmpty() &&
+				isMember)
 			return true;
 
 		return false;

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 {

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

@@ -344,7 +344,7 @@ public class SelfSponsorshipAlgoV3 {
             return true;
         }
         transactionDataList.removeIf(t -> t.getTimestamp() <= this.snapshotTimestampV1 || t.getTimestamp() >= this.snapshotTimestampV3);
-        return transactionDataList.size() == 0;
+        return transactionDataList.isEmpty();
     }
 
     private static List<TransactionData> fetchTransactions(Repository repository, List<TransactionType> txTypes, String address, boolean reverse) throws DataException {

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/crosschain/BitcoinyTBDRequest.java

@@ -0,0 +1,692 @@
+package org.qortal.api.model.crosschain;
+
+import org.qortal.crosschain.ServerInfo;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import java.util.Arrays;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+public class BitcoinyTBDRequest {
+
+    /**
+     * Target Timespan
+     *
+     * extracted from /src/chainparams.cpp class
+     * consensus.nPowTargetTimespan
+     */
+    private int targetTimespan;
+
+    /**
+     * Target Spacing
+     *
+     * extracted from /src/chainparams.cpp class
+     * consensus.nPowTargetSpacing
+     */
+    private int targetSpacing;
+
+    /**
+     * Packet Magic
+     *
+     * extracted from /src/chainparams.cpp class
+     * Concatenate the 4 values in pchMessageStart, then convert the hex to decimal.
+     *
+     * Ex. litecoin
+     * pchMessageStart[0] = 0xfb;
+     * pchMessageStart[1] = 0xc0;
+     * pchMessageStart[2] = 0xb6;
+     * pchMessageStart[3] = 0xdb;
+     * packetMagic = 0xfbc0b6db = 4223710939
+     */
+    private long packetMagic;
+
+    /**
+     * Port
+     *
+     * extracted from /src/chainparams.cpp class
+     * nDefaultPort
+     */
+    private int port;
+
+    /**
+     * Address Header
+     *
+     * extracted from /src/chainparams.cpp class
+     * base58Prefixes[PUBKEY_ADDRESS] from Main Network
+     */
+    private int addressHeader;
+
+    /**
+     * P2sh Header
+     *
+     * extracted from /src/chainparams.cpp class
+     * base58Prefixes[SCRIPT_ADDRESS] from Main Network
+     */
+    private int p2shHeader;
+
+    /**
+     * Segwit Address Hrp
+     *
+     * HRP -> Human Readable Parts
+     *
+     * extracted from /src/chainparams.cpp class
+     * bech32_hrp
+     */
+    private String segwitAddressHrp;
+
+    /**
+     * Dumped Private Key Header
+     *
+     * extracted from /src/chainparams.cpp class
+     * base58Prefixes[SECRET_KEY] from Main Network
+     * This is usually, but not always ... addressHeader + 128
+     */
+    private int dumpedPrivateKeyHeader;
+
+    /**
+     * Subsidy Decreased Block Count
+     *
+     * extracted from /src/chainparams.cpp class
+     * consensus.nSubsidyHalvingInterval
+     *
+     * Digibyte does not support this, because they do halving differently.
+     */
+    private int subsidyDecreaseBlockCount;
+
+    /**
+     * Expected Genesis Hash
+     *
+     * extracted from /src/chainparams.cpp class
+     * consensus.hashGenesisBlock
+     * Remove '0x' prefix
+     */
+    private String expectedGenesisHash;
+
+    /**
+     * Common Script Pub Key
+     *
+     * extracted from /src/chainparams.cpp class
+     * This is the key commonly used to sign alerts for altcoins. Bitcoin and Digibyte are know exceptions.
+     */
+    public static final String SCRIPT_PUB_KEY = "040184710fa689ad5023690c80f3a49c8f13f8d45b8c857fbcbc8bc4a8e4d3eb4b10f4d4604fa08dce601aaf0f470216fe1b51850b4acf21b179c45070ac7b03a9";
+
+    /**
+     * The Script Pub Key
+     *
+     * extracted from /src/chainparams.cpp class
+     * The key to sign alerts.
+     *
+     * const CScript genesisOutputScript = CScript() << ParseHex("040184710fa689ad5023690c80f3a49c8f13f8d45b8c857fbcbc8bc4a8e4d3eb4b10f4d4604fa08dce601aaf0f470216fe1b51850b4acf21b179c45070ac7b03a9") << OP_CHECKSIG;
+     *
+     * ie LTC = 040184710fa689ad5023690c80f3a49c8f13f8d45b8c857fbcbc8bc4a8e4d3eb4b10f4d4604fa08dce601aaf0f470216fe1b51850b4acf21b179c45070ac7b03a9
+     *
+     * this may be the same value as scripHex
+     */
+    private String pubKey;
+
+    /**
+     * DNS Seeds
+     *
+     * extracted from /src/chainparams.cpp class
+     * vSeeds
+     */
+    private String[] dnsSeeds;
+
+    /**
+     * BIP32 Header P2PKH Pub
+     *
+     * extracted from /src/chainparams.cpp class
+     * Concatenate the 4 values in base58Prefixes[EXT_PUBLIC_KEY]
+     * base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x88, 0xB2, 0x1E} = 0x0488B21E
+     */
+    private int bip32HeaderP2PKHpub;
+
+    /**
+     * BIP32 Header P2PKH Priv
+     *
+     * extracted from /src/chainparams.cpp class
+     * Concatenate the 4 values in base58Prefixes[EXT_SECRET_KEY]
+     * base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x88, 0xAD, 0xE4} = 0x0488ADE4
+     */
+    private int bip32HeaderP2PKHpriv;
+
+    /**
+     * Address Header (Testnet)
+     *
+     * extracted from /src/chainparams.cpp class
+     * base58Prefixes[PUBKEY_ADDRESS] from Testnet
+     */
+    private int addressHeaderTestnet;
+
+    /**
+     * BIP32 Header P2PKH Pub (Testnet)
+     *
+     * extracted from /src/chainparams.cpp class
+     * Concatenate the 4 values in base58Prefixes[EXT_PUBLIC_KEY]
+     * base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x88, 0xB2, 0x1E} = 0x0488B21E
+     */
+    private int bip32HeaderP2PKHpubTestnet;
+
+    /**
+     * BIP32 Header P2PKH Priv (Testnet)
+     *
+     * extracted from /src/chainparams.cpp class
+     * Concatenate the 4 values in base58Prefixes[EXT_SECRET_KEY]
+     * base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x88, 0xAD, 0xE4} = 0x0488ADE4
+     */
+    private int bip32HeaderP2PKHprivTestnet;
+
+    /**
+     * Id
+     *
+     * "org.litecoin.production" for LTC
+     * I'm guessing this just has to match others for trading purposes.
+     */
+    private String id;
+
+    /**
+     * Majority Enforce Block Upgrade
+     *
+     * All coins are setting this to 750, except DOGE is setting this to 1500.
+     */
+    private int majorityEnforceBlockUpgrade;
+
+    /**
+     * Majority Reject Block Outdated
+     *
+     * All coins are setting this to 950, except DOGE is setting this to 1900.
+     */
+    private int majorityRejectBlockOutdated;
+
+    /**
+     * Majority Window
+     *
+     * All coins are setting this to 1000, except DOGE is setting this to 2000.
+     */
+    private int majorityWindow;
+
+    /**
+     * Code
+     *
+     * "LITE" for LTC
+     * Currency code for full unit.
+     */
+    private String code;
+
+    /**
+     * mCode
+     *
+     * "mLITE" for LTC
+     * Currency code for milli unit.
+     */
+    private String mCode;
+
+    /**
+     * Base Code
+     *
+     * "Liteoshi" for LTC
+     * Currency code for base unit.
+     */
+    private String baseCode;
+
+    /**
+     * Min Non Dust Output
+     *
+     * 100000 for LTC, web search for minimum transaction fee per kB
+     */
+    private int minNonDustOutput;
+
+    /**
+     * URI Scheme
+     *
+     * uriScheme = "litecoin" for LTC
+     * Do a web search to find this value.
+     */
+    private String uriScheme;
+
+    /**
+     * Protocol Version Minimum
+     *
+     * 70002 for LTC
+     * extracted from /src/protocol.h class
+     */
+    private int protocolVersionMinimum;
+
+    /**
+     * Protocol Version Current
+     *
+     * 70003 for LTC
+     * extracted from /src/protocol.h class
+     */
+    private int protocolVersionCurrent;
+
+    /**
+     * Has Max Money
+     *
+     * false for DOGE, true for BTC and LTC
+     */
+    private boolean hasMaxMoney;
+
+    /**
+     * Max Money
+     *
+     * 84000000 for LTC, 21000000 for BTC
+     * extracted from src/amount.h class
+     */
+    private long maxMoney;
+
+    /**
+     * Currency Code
+     *
+     * The trading symbol, ie LTC, BTC, DOGE
+     */
+    private String currencyCode;
+
+    /**
+     * Minimum Order Amount
+     *
+     * web search, LTC minimumOrderAmount = 1000000, 0.01 LTC minimum order to avoid dust errors
+     */
+    private long minimumOrderAmount;
+
+    /**
+     * Fee Per Kb
+     *
+     * web search, LTC feePerKb = 10000, 0.0001 LTC per 1000 bytes
+     */
+    private long feePerKb;
+
+    /**
+     * Network Name
+     *
+     * ie Litecoin-MAIN
+     */
+    private String networkName;
+
+    /**
+     * Fee Ceiling
+     *
+     *  web search, LTC fee ceiling = 1000L
+     */
+    private long feeCeiling;
+
+    /**
+     * Extended Public Key
+     *
+     * xpub for operations that require wallet watching
+     */
+    private String extendedPublicKey;
+
+    /**
+     * Send Amount
+     *
+     * The amount to send in base units. Also, requires sending fee per byte, receiving address and sender's extended private key.
+     */
+    private long sendAmount;
+
+    /**
+     * Sending Fee Per Byte
+     *
+     * The fee to include on a send request in base units. Also, requires receiving address, sender's extended private key and send amount.
+     */
+    private long sendingFeePerByte;
+
+    /**
+     * Receiving Address
+     *
+     * The receiving address for a send request. Also, requires send amount, sender's extended private key and sending fee per byte.
+     */
+    private String receivingAddress;
+
+    /**
+     * Extended Private Key
+     *
+     * xpriv address for a send request. Also, requires receiving address, send amount and sending fee per byte.
+     */
+    private String extendedPrivateKey;
+
+    /**
+     * Server Info
+     *
+     * For adding, removing, setting current server requests.
+     */
+    private ServerInfo serverInfo;
+
+    /**
+     * Script Sig
+     *
+     * extracted from /src/chainparams.cpp class
+     * pszTimestamp
+     *
+     * transform this value - https://bitcoin.stackexchange.com/questions/13122/scriptsig-coinbase-structure-of-the-genesis-block
+     * ie LTC = 04ffff001d0104404e592054696d65732030352f4f63742f32303131205374657665204a6f62732c204170706c65e280997320566973696f6e6172792c2044696573206174203536
+     * ie DOGE = 04ffff001d0104084e696e746f6e646f
+     */
+    private String scriptSig;
+
+    /**
+     * Script Hex
+     *
+     * extracted from /src/chainparams.cpp class
+     * genesisOutputScript
+     *
+     * ie LTC = 040184710fa689ad5023690c80f3a49c8f13f8d45b8c857fbcbc8bc4a8e4d3eb4b10f4d4604fa08dce601aaf0f470216fe1b51850b4acf21b179c45070ac7b03a9
+     *
+     * this may be the same value as pubKey
+     */
+    private String scriptHex;
+
+    /**
+     * Reward
+     *
+     * extracted from /src/chainparams.cpp class
+     * CreateGenesisBlock(..., [reward] * COIN)
+     *
+     * ie LTC = 50, BTC = 50, DOGE = 88
+     */
+    private int reward;
+
+    /**
+     * Genesis Creation Version
+     */
+    private int genesisCreationVersion;
+
+    /**
+     * Genesis Block Version
+     */
+    private long genesisBlockVersion;
+
+    /**
+     * Genesis Time
+     *
+     * extracted from /src/chainparams.cpp class
+     * CreateGenesisBlock(nTime, ...)
+     *
+     * ie LTC = 1317972665
+     */
+    private long genesisTime;
+
+    /**
+     * Difficulty Target
+     *
+     * extracted from /src/chainparams.cpp class
+     * CreateGenesisBlock(genesisTime, nonce, difficultyTarget, 1, reward * COIN);
+     *
+     * convert from hex to decimal
+     *
+     * ie LTC = 0x1e0ffff0 = 504365040
+     */
+    private long difficultyTarget;
+
+    /**
+     * Merkle Hex
+     */
+    private String merkleHex;
+
+    /**
+     * Nonce
+     *
+     * extracted from /src/chainparams.cpp class
+     * CreateGenesisBlock(genesisTime, nonce, difficultyTarget, 1, reward * COIN);
+     *
+     * ie LTC = 2084524493
+     */
+    private long nonce;
+
+
+    public int getTargetTimespan() {
+        return targetTimespan;
+    }
+
+    public int getTargetSpacing() {
+        return targetSpacing;
+    }
+
+    public long getPacketMagic() {
+        return packetMagic;
+    }
+
+    public int getPort() {
+        return port;
+    }
+
+    public int getAddressHeader() {
+        return addressHeader;
+    }
+
+    public int getP2shHeader() {
+        return p2shHeader;
+    }
+
+    public String getSegwitAddressHrp() {
+        return segwitAddressHrp;
+    }
+
+    public int getDumpedPrivateKeyHeader() {
+        return dumpedPrivateKeyHeader;
+    }
+
+    public int getSubsidyDecreaseBlockCount() {
+        return subsidyDecreaseBlockCount;
+    }
+
+    public String getExpectedGenesisHash() {
+        return expectedGenesisHash;
+    }
+
+    public String getPubKey() {
+        return pubKey;
+    }
+
+    public String[] getDnsSeeds() {
+        return dnsSeeds;
+    }
+
+    public int getBip32HeaderP2PKHpub() {
+        return bip32HeaderP2PKHpub;
+    }
+
+    public int getBip32HeaderP2PKHpriv() {
+        return bip32HeaderP2PKHpriv;
+    }
+
+    public int getAddressHeaderTestnet() {
+        return addressHeaderTestnet;
+    }
+
+    public int getBip32HeaderP2PKHpubTestnet() {
+        return bip32HeaderP2PKHpubTestnet;
+    }
+
+    public int getBip32HeaderP2PKHprivTestnet() {
+        return bip32HeaderP2PKHprivTestnet;
+    }
+
+    public String getId() {
+        return  this.id;
+    }
+
+    public int getMajorityEnforceBlockUpgrade() {
+        return this.majorityEnforceBlockUpgrade;
+    }
+
+    public int getMajorityRejectBlockOutdated() {
+        return this.majorityRejectBlockOutdated;
+    }
+
+    public int getMajorityWindow() {
+        return this.majorityWindow;
+    }
+
+    public String getCode() {
+        return this.code;
+    }
+
+    public String getmCode() {
+        return this.mCode;
+    }
+
+    public String getBaseCode() {
+        return this.baseCode;
+    }
+
+    public int getMinNonDustOutput() {
+        return this.minNonDustOutput;
+    }
+
+    public String getUriScheme() {
+        return this.uriScheme;
+    }
+
+    public int getProtocolVersionMinimum() {
+        return this.protocolVersionMinimum;
+    }
+
+    public int getProtocolVersionCurrent() {
+        return this.protocolVersionCurrent;
+    }
+
+    public boolean isHasMaxMoney() {
+        return this.hasMaxMoney;
+    }
+
+    public long getMaxMoney() {
+        return this.maxMoney;
+    }
+
+    public String getCurrencyCode() {
+        return this.currencyCode;
+    }
+
+    public long getMinimumOrderAmount() {
+        return this.minimumOrderAmount;
+    }
+
+    public long getFeePerKb() {
+        return this.feePerKb;
+    }
+
+    public String getNetworkName() {
+        return this.networkName;
+    }
+
+    public long getFeeCeiling() {
+        return this.feeCeiling;
+    }
+
+    public String getExtendedPublicKey() {
+        return this.extendedPublicKey;
+    }
+
+    public long getSendAmount() {
+        return this.sendAmount;
+    }
+
+    public long getSendingFeePerByte() {
+        return this.sendingFeePerByte;
+    }
+
+    public String getReceivingAddress() {
+        return this.receivingAddress;
+    }
+
+    public String getExtendedPrivateKey() {
+        return this.extendedPrivateKey;
+    }
+
+    public ServerInfo getServerInfo() {
+        return this.serverInfo;
+    }
+
+    public String getScriptSig() {
+        return this.scriptSig;
+    }
+
+    public String getScriptHex() {
+        return this.scriptHex;
+    }
+
+    public int getReward() {
+        return this.reward;
+    }
+
+    public int getGenesisCreationVersion() {
+        return this.genesisCreationVersion;
+    }
+
+    public long getGenesisBlockVersion() {
+        return this.genesisBlockVersion;
+    }
+
+    public long getGenesisTime() {
+        return this.genesisTime;
+    }
+
+    public long getDifficultyTarget() {
+        return this.difficultyTarget;
+    }
+
+    public String getMerkleHex() {
+        return this.merkleHex;
+    }
+
+    public long getNonce() {
+        return this.nonce;
+    }
+
+    @Override
+    public String toString() {
+        return "BitcoinyTBDRequest{" +
+                "targetTimespan=" + targetTimespan +
+                ", targetSpacing=" + targetSpacing +
+                ", packetMagic=" + packetMagic +
+                ", port=" + port +
+                ", addressHeader=" + addressHeader +
+                ", p2shHeader=" + p2shHeader +
+                ", segwitAddressHrp='" + segwitAddressHrp + '\'' +
+                ", dumpedPrivateKeyHeader=" + dumpedPrivateKeyHeader +
+                ", subsidyDecreaseBlockCount=" + subsidyDecreaseBlockCount +
+                ", expectedGenesisHash='" + expectedGenesisHash + '\'' +
+                ", pubKey='" + pubKey + '\'' +
+                ", dnsSeeds=" + Arrays.toString(dnsSeeds) +
+                ", bip32HeaderP2PKHpub=" + bip32HeaderP2PKHpub +
+                ", bip32HeaderP2PKHpriv=" + bip32HeaderP2PKHpriv +
+                ", addressHeaderTestnet=" + addressHeaderTestnet +
+                ", bip32HeaderP2PKHpubTestnet=" + bip32HeaderP2PKHpubTestnet +
+                ", bip32HeaderP2PKHprivTestnet=" + bip32HeaderP2PKHprivTestnet +
+                ", id='" + id + '\'' +
+                ", majorityEnforceBlockUpgrade=" + majorityEnforceBlockUpgrade +
+                ", majorityRejectBlockOutdated=" + majorityRejectBlockOutdated +
+                ", majorityWindow=" + majorityWindow +
+                ", code='" + code + '\'' +
+                ", mCode='" + mCode + '\'' +
+                ", baseCode='" + baseCode + '\'' +
+                ", minNonDustOutput=" + minNonDustOutput +
+                ", uriScheme='" + uriScheme + '\'' +
+                ", protocolVersionMinimum=" + protocolVersionMinimum +
+                ", protocolVersionCurrent=" + protocolVersionCurrent +
+                ", hasMaxMoney=" + hasMaxMoney +
+                ", maxMoney=" + maxMoney +
+                ", currencyCode='" + currencyCode + '\'' +
+                ", minimumOrderAmount=" + minimumOrderAmount +
+                ", feePerKb=" + feePerKb +
+                ", networkName='" + networkName + '\'' +
+                ", feeCeiling=" + feeCeiling +
+                ", extendedPublicKey='" + extendedPublicKey + '\'' +
+                ", sendAmount=" + sendAmount +
+                ", sendingFeePerByte=" + sendingFeePerByte +
+                ", receivingAddress='" + receivingAddress + '\'' +
+                ", extendedPrivateKey='" + extendedPrivateKey + '\'' +
+                ", serverInfo=" + serverInfo +
+                ", scriptSig='" + scriptSig + '\'' +
+                ", scriptHex='" + scriptHex + '\'' +
+                ", reward=" + reward +
+                ", genesisCreationVersion=" + genesisCreationVersion +
+                ", genesisBlockVersion=" + genesisBlockVersion +
+                ", genesisTime=" + genesisTime +
+                ", difficultyTarget=" + difficultyTarget +
+                ", merkleHex='" + merkleHex + '\'' +
+                ", nonce=" + nonce +
+                '}';
+    }
+}

src/main/java/org/qortal/api/model/crosschain/TradeBotRespondRequests.java

@@ -0,0 +1,68 @@
+package org.qortal.api.model.crosschain;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlElement;
+import java.util.List;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+public class TradeBotRespondRequests {
+
+	@Schema(description = "Foreign blockchain private key, e.g. BIP32 'm' key for Bitcoin/Litecoin starting with 'xprv'",
+			example = "xprv___________________________________________________________________________________________________________")
+	public String foreignKey;
+
+	@Schema(description = "List of address matches")
+	@XmlElement(name = "addresses")
+	public List<String> addresses;
+
+	@Schema(description = "Qortal address for receiving QORT from AT", example = "Qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq")
+	public String receivingAddress;
+
+	public TradeBotRespondRequests() {
+	}
+
+	public TradeBotRespondRequests(String foreignKey, List<String> addresses, String receivingAddress) {
+		this.foreignKey = foreignKey;
+		this.addresses = addresses;
+		this.receivingAddress = receivingAddress;
+	}
+
+	@Schema(description = "Address Match")
+	// All properties to be converted to JSON via JAX-RS
+	@XmlAccessorType(XmlAccessType.FIELD)
+	public static class AddressMatch {
+		@Schema(description = "AT Address")
+		public String atAddress;
+
+		@Schema(description = "Receiving Address")
+		public String receivingAddress;
+
+		// For JAX-RS
+		protected AddressMatch() {
+		}
+
+		public AddressMatch(String atAddress, String receivingAddress) {
+			this.atAddress = atAddress;
+			this.receivingAddress = receivingAddress;
+		}
+
+		@Override
+		public String toString() {
+			return "AddressMatch{" +
+					"atAddress='" + atAddress + '\'' +
+					", receivingAddress='" + receivingAddress + '\'' +
+					'}';
+		}
+	}
+
+	@Override
+	public String toString() {
+		return "TradeBotRespondRequests{" +
+				"foreignKey='" + foreignKey + '\'' +
+				", addresses=" + addresses +
+				'}';
+	}
+}

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

@@ -20,9 +20,7 @@ import org.qortal.asset.Asset;
 import org.qortal.controller.LiteNode;
 import org.qortal.controller.OnlineAccountsManager;
 import org.qortal.crypto.Crypto;
-import org.qortal.data.account.AccountData;
-import org.qortal.data.account.AccountPenaltyData;
-import org.qortal.data.account.RewardShareData;
+import org.qortal.data.account.*;
 import org.qortal.data.network.OnlineAccountData;
 import org.qortal.data.network.OnlineAccountLevel;
 import org.qortal.data.transaction.PublicizeTransactionData;
@@ -52,6 +50,7 @@ import java.math.BigDecimal;
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.List;
+import java.util.Optional;
 import java.util.stream.Collectors;
 
 @Path("/addresses")
@@ -233,8 +232,7 @@ public class AddressesResource {
 					}
 
 				} catch (DataException e) {
-					continue;
-				}
+                }
 			}
 
 			// Sort by level
@@ -328,11 +326,8 @@ public class AddressesResource {
 			)
 		}
 	)
-	@ApiErrors({ApiError.INVALID_PUBLIC_KEY, ApiError.NON_PRODUCTION, ApiError.REPOSITORY_ISSUE})
+	@ApiErrors({ApiError.INVALID_PUBLIC_KEY, ApiError.REPOSITORY_ISSUE})
 	public String fromPublicKey(@PathParam("publickey") String publicKey58) {
-		if (Settings.getInstance().isApiRestricted())
-			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.NON_PRODUCTION);
-
 		// Decode public key
 		byte[] publicKey;
 		try {
@@ -631,4 +626,160 @@ public class AddressesResource {
 		}
 	}
 
-}
+	@GET
+	@Path("/sponsorship/{address}")
+	@Operation(
+			summary = "Returns sponsorship statistics for an account",
+			description = "Returns sponsorship statistics for an account, excluding the recipients that get real reward shares",
+			responses = {
+					@ApiResponse(
+							description = "the statistics",
+							content = @Content(mediaType = MediaType.APPLICATION_JSON, schema = @Schema(implementation = SponsorshipReport.class))
+					)
+			}
+	)
+	@ApiErrors({ApiError.INVALID_ADDRESS, ApiError.ADDRESS_UNKNOWN,  ApiError.REPOSITORY_ISSUE})
+	public SponsorshipReport getSponsorshipReport(
+			@PathParam("address") String address,
+			@QueryParam(("realRewardShareRecipient")) String[] realRewardShareRecipients) {
+		if (!Crypto.isValidAddress(address))
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_ADDRESS);
+
+		try (final Repository repository = RepositoryManager.getRepository()) {
+			SponsorshipReport report = repository.getAccountRepository().getSponsorshipReport(address, realRewardShareRecipients);
+			// Not found?
+			if (report == null)
+				throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.ADDRESS_UNKNOWN);
+
+			return report;
+		} catch (DataException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.REPOSITORY_ISSUE, e);
+		}
+	}
+
+	@GET
+	@Path("/sponsorship/{address}/sponsor")
+	@Operation(
+			summary = "Returns sponsorship statistics for an account's sponsor",
+			description = "Returns sponsorship statistics for an account's sponsor, excluding the recipients that get real reward shares",
+			responses = {
+					@ApiResponse(
+							description = "the statistics",
+							content = @Content(mediaType = MediaType.APPLICATION_JSON, schema = @Schema(implementation = SponsorshipReport.class))
+					)
+			}
+	)
+	@ApiErrors({ApiError.INVALID_ADDRESS, ApiError.ADDRESS_UNKNOWN,  ApiError.REPOSITORY_ISSUE})
+	public SponsorshipReport getSponsorshipReportForSponsor(
+			@PathParam("address") String address,
+			@QueryParam("realRewardShareRecipient") String[] realRewardShareRecipients) {
+		if (!Crypto.isValidAddress(address))
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_ADDRESS);
+
+		try (final Repository repository = RepositoryManager.getRepository()) {
+
+			// get sponsor
+			Optional<String> sponsor = repository.getAccountRepository().getSponsor(address);
+
+			// if there is not sponsor, throw error
+			if(sponsor.isEmpty()) throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.ADDRESS_UNKNOWN);
+
+			// get report for sponsor
+			SponsorshipReport report = repository.getAccountRepository().getSponsorshipReport(sponsor.get(), realRewardShareRecipients);
+
+			// Not found?
+			if (report == null)
+				throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.ADDRESS_UNKNOWN);
+
+			return report;
+		} catch (DataException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.REPOSITORY_ISSUE, e);
+		}
+	}
+
+	@GET
+	@Path("/mintership/{address}")
+	@Operation(
+			summary = "Returns mintership statistics for an account",
+			description = "Returns mintership statistics for an account",
+			responses = {
+					@ApiResponse(
+							description = "the statistics",
+							content = @Content(mediaType = MediaType.APPLICATION_JSON, schema = @Schema(implementation = MintershipReport.class))
+					)
+			}
+	)
+	@ApiErrors({ApiError.INVALID_ADDRESS, ApiError.ADDRESS_UNKNOWN,  ApiError.REPOSITORY_ISSUE})
+	public MintershipReport getMintershipReport(@PathParam("address") String address,
+												@QueryParam("realRewardShareRecipient") String[] realRewardShareRecipients ) {
+		if (!Crypto.isValidAddress(address))
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_ADDRESS);
+
+		try (final Repository repository = RepositoryManager.getRepository()) {
+
+			// get sponsorship report for minter, fetch a list of one minter
+			SponsorshipReport report = repository.getAccountRepository().getMintershipReport(address, account -> List.of(account));
+
+			// Not found?
+			if (report == null)
+				throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.ADDRESS_UNKNOWN);
+
+			// since the report is for one minter, must get sponsee count separately
+			int sponseeCount = repository.getAccountRepository().getSponseeAddresses(address, realRewardShareRecipients).size();
+
+			// since the report is for one minter, must get the first name from a array of names that should be size 1
+			String name = report.getNames().length > 0 ? report.getNames()[0] : null;
+
+			// transform sponsorship report to mintership report
+			MintershipReport mintershipReport
+				= new MintershipReport(
+					report.getAddress(),
+					report.getLevel(),
+					report.getBlocksMinted(),
+					report.getAdjustments(),
+					report.getPenalties(),
+					report.isTransfer(),
+					name,
+					sponseeCount,
+					report.getAvgBalance(),
+					report.getArbitraryCount(),
+					report.getTransferAssetCount(),
+					report.getTransferPrivsCount(),
+					report.getSellCount(),
+					report.getSellAmount(),
+					report.getBuyCount(),
+					report.getBuyAmount()
+			);
+
+			return mintershipReport;
+		} catch (DataException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.REPOSITORY_ISSUE, e);
+		}
+	}
+
+	@GET
+	@Path("/levels/{minLevel}")
+	@Operation(
+			summary = "Return accounts with levels greater than or equal to input",
+			responses = {
+					@ApiResponse(
+							description = "online accounts",
+							content = @Content(mediaType = MediaType.APPLICATION_JSON, array = @ArraySchema(schema = @Schema(implementation = AddressLevelPairing.class)))
+					)
+			}
+	)
+	@ApiErrors({ApiError.REPOSITORY_ISSUE})
+
+	public List<AddressLevelPairing> getAddressLevelPairings(@PathParam("minLevel") int minLevel) {
+
+		try (final Repository repository = RepositoryManager.getRepository()) {
+
+			// get the level address pairings
+			List<AddressLevelPairing> pairings = repository.getAccountRepository().getAddressLevelPairings(minLevel);
+
+			return pairings;
+		} catch (DataException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.REPOSITORY_ISSUE, e);
+		}
+	}
+}

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");
 			}
 
@@ -227,6 +227,49 @@ public class ArbitraryResource {
 		}
 	}
 
+	@GET
+	@Path("/resources/searchsimple")
+	@Operation(
+			summary = "Search arbitrary resources available on chain, optionally filtered by service.",
+			responses = {
+					@ApiResponse(
+							content = @Content(mediaType = MediaType.APPLICATION_JSON, schema = @Schema(implementation = ArbitraryResourceData.class))
+					)
+			}
+	)
+	@ApiErrors({ApiError.REPOSITORY_ISSUE})
+	public List<ArbitraryResourceData> searchResourcesSimple(
+			@QueryParam("service") Service service,
+			@Parameter(description = "Identifier (searches identifier field only)") @QueryParam("identifier") String identifier,
+			@Parameter(description = "Name (searches name field only)") @QueryParam("name") List<String> names,
+			@Parameter(description = "Prefix only (if true, only the beginning of fields are matched)") @QueryParam("prefix") Boolean prefixOnly,
+			@Parameter(description = "Case insensitive (ignore leter case on search)") @QueryParam("caseInsensitive") Boolean caseInsensitive,
+			@Parameter(description = "Creation date before timestamp") @QueryParam("before") Long before,
+			@Parameter(description = "Creation date after timestamp") @QueryParam("after") Long after,
+			@Parameter(ref = "limit") @QueryParam("limit") Integer limit,
+			@Parameter(ref = "offset") @QueryParam("offset") Integer offset,
+			@Parameter(ref = "reverse") @QueryParam("reverse") Boolean reverse) {
+
+		try (final Repository repository = RepositoryManager.getRepository()) {
+
+			boolean usePrefixOnly = Boolean.TRUE.equals(prefixOnly);
+			boolean ignoreCase = Boolean.TRUE.equals(caseInsensitive);
+
+			List<ArbitraryResourceData> resources = repository.getArbitraryRepository()
+					.searchArbitraryResourcesSimple(service, identifier, names, usePrefixOnly,
+							before, after, limit, offset, reverse, ignoreCase);
+
+			if (resources == null) {
+				return new ArrayList<>();
+			}
+
+			return resources;
+
+		} catch (DataException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.REPOSITORY_ISSUE, e);
+		}
+	}
+
 	@GET
 	@Path("/resource/status/{service}/{name}")
 	@Operation(
@@ -491,7 +534,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 +1301,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,7 +17,11 @@ 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;
 
@@ -265,4 +269,292 @@ public class CrossChainBitcoinResource {
 
 		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,8 +16,12 @@ 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;
 
@@ -265,4 +269,292 @@ public class CrossChainDigibyteResource {
 
 		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,8 +16,12 @@ 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;
 
@@ -265,4 +269,292 @@ public class CrossChainDogecoinResource {
 
 		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/CrossChainHtlcResource.java

@@ -157,7 +157,7 @@ public class CrossChainHtlcResource {
 			htlcStatus.bitcoinP2shAddress = p2shAddress;
 			htlcStatus.bitcoinP2shBalance = BigDecimal.valueOf(p2shBalance, 8);
 
-			List<TransactionOutput> fundingOutputs = bitcoiny.getUnspentOutputs(p2shAddress.toString());
+			List<TransactionOutput> fundingOutputs = bitcoiny.getUnspentOutputs(p2shAddress.toString(), false);
 
 			if (p2shBalance > 0L && !fundingOutputs.isEmpty()) {
 				htlcStatus.canRedeem = now >= medianBlockTime * 1000L;
@@ -401,7 +401,7 @@ public class CrossChainHtlcResource {
 				case FUNDED: {
 					Coin redeemAmount = Coin.valueOf(crossChainTradeData.expectedForeignAmount);
 					ECKey redeemKey = ECKey.fromPrivate(decodedTradePrivateKey);
-					List<TransactionOutput> fundingOutputs = bitcoiny.getUnspentOutputs(p2shAddressA);
+					List<TransactionOutput> fundingOutputs = bitcoiny.getUnspentOutputs(p2shAddressA, false);
 
 					Transaction p2shRedeemTransaction = BitcoinyHTLC.buildRedeemTransaction(bitcoiny.getNetworkParameters(), redeemAmount, redeemKey,
 							fundingOutputs, redeemScriptA, decodedSecret, foreignBlockchainReceivingAccountInfo);
@@ -664,7 +664,7 @@ public class CrossChainHtlcResource {
 							// ElectrumX coins
 
 							ECKey refundKey = ECKey.fromPrivate(tradeBotData.getTradePrivateKey());
-							List<TransactionOutput> fundingOutputs = bitcoiny.getUnspentOutputs(p2shAddressA);
+							List<TransactionOutput> fundingOutputs = bitcoiny.getUnspentOutputs(p2shAddressA, false);
 
 							// Validate the destination foreign blockchain address
 							Address receiving = Address.fromString(bitcoiny.getNetworkParameters(), receiveAddress);

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

@@ -16,8 +16,12 @@ 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;
 
@@ -266,6 +270,180 @@ public class CrossChainLitecoinResource {
 		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(
@@ -304,4 +482,117 @@ public class CrossChainLitecoinResource {
 			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,8 +13,12 @@ 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;
 
@@ -351,4 +355,291 @@ public class CrossChainPirateChainResource {
 
 		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,8 +16,12 @@ 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;
 
@@ -265,4 +269,292 @@ public class CrossChainRavencoinResource {
 
 		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/CrossChainTradeBotResource.java

@@ -17,13 +17,16 @@ import org.qortal.api.ApiExceptionFactory;
 import org.qortal.api.Security;
 import org.qortal.api.model.crosschain.TradeBotCreateRequest;
 import org.qortal.api.model.crosschain.TradeBotRespondRequest;
+import org.qortal.api.model.crosschain.TradeBotRespondRequests;
 import org.qortal.asset.Asset;
 import org.qortal.controller.Controller;
 import org.qortal.controller.tradebot.AcctTradeBot;
 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.ForeignBlockchain;
+import org.qortal.crosschain.PirateChain;
 import org.qortal.crosschain.SupportedBlockchain;
 import org.qortal.crypto.Crypto;
 import org.qortal.data.at.ATData;
@@ -42,8 +45,10 @@ import javax.servlet.http.HttpServletRequest;
 import javax.ws.rs.*;
 import javax.ws.rs.core.Context;
 import javax.ws.rs.core.MediaType;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
+import java.util.Optional;
 import java.util.stream.Collectors;
 
 @Path("/crosschain/tradebot")
@@ -187,6 +192,39 @@ public class CrossChainTradeBotResource {
 	public String tradeBotResponder(@HeaderParam(Security.API_KEY_HEADER) String apiKey, TradeBotRespondRequest tradeBotRespondRequest) {
 		Security.checkApiCallAllowed(request);
 
+		return createTradeBotResponse(tradeBotRespondRequest);
+	}
+
+	@POST
+	@Path("/respondmultiple")
+	@Operation(
+			summary = "Respond to multiple trade offers. NOTE: WILL SPEND FUNDS!)",
+			description = "Start a new trade-bot entry to respond to chosen trade offers. Pirate Chain is not supported and will throw an invalid criteria error.",
+			requestBody = @RequestBody(
+					required = true,
+					content = @Content(
+							mediaType = MediaType.APPLICATION_JSON,
+							schema = @Schema(
+									implementation = TradeBotRespondRequests.class
+							)
+					)
+			),
+			responses = {
+					@ApiResponse(
+							content = @Content(mediaType = MediaType.TEXT_PLAIN, schema = @Schema(type = "string"))
+					)
+			}
+	)
+	@ApiErrors({ApiError.INVALID_PRIVATE_KEY, ApiError.INVALID_ADDRESS, ApiError.INVALID_CRITERIA, ApiError.FOREIGN_BLOCKCHAIN_BALANCE_ISSUE, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE, ApiError.REPOSITORY_ISSUE})
+	@SuppressWarnings("deprecation")
+	@SecurityRequirement(name = "apiKey")
+	public String tradeBotResponderMultiple(@HeaderParam(Security.API_KEY_HEADER) String apiKey, TradeBotRespondRequests tradeBotRespondRequest) {
+		Security.checkApiCallAllowed(request);
+
+		return createTradeBotResponseMultiple(tradeBotRespondRequest);
+	}
+
+	private String createTradeBotResponse(TradeBotRespondRequest tradeBotRespondRequest) {
 		final String atAddress = tradeBotRespondRequest.atAddress;
 
 		// We prefer foreignKey to deprecated xprv58
@@ -257,6 +295,99 @@ public class CrossChainTradeBotResource {
 		}
 	}
 
+	private String createTradeBotResponseMultiple(TradeBotRespondRequests respondRequests) {
+		try (final Repository repository = RepositoryManager.getRepository()) {
+
+			if (respondRequests.foreignKey == null)
+				throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_PRIVATE_KEY);
+
+			List<CrossChainTradeData> crossChainTradeDataList = new ArrayList<>(respondRequests.addresses.size());
+			Optional<ACCT> acct = Optional.empty();
+
+			for(String atAddress : respondRequests.addresses ) {
+
+				if (atAddress == null || !Crypto.isValidAtAddress(atAddress))
+					throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_ADDRESS);
+
+				if (respondRequests.receivingAddress == null || !Crypto.isValidAddress(respondRequests.receivingAddress))
+					throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_ADDRESS);
+
+				final Long minLatestBlockTimestamp = NTP.getTime() - (60 * 60 * 1000L);
+				if (!Controller.getInstance().isUpToDate(minLatestBlockTimestamp))
+					throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.BLOCKCHAIN_NEEDS_SYNC);
+
+				// Extract data from cross-chain trading AT
+				ATData atData = fetchAtDataWithChecking(repository, atAddress);
+
+				// TradeBot uses AT's code hash to map to ACCT
+				ACCT acctUsingAtData = TradeBot.getInstance().getAcctUsingAtData(atData);
+				if (acctUsingAtData == null)
+					throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_ADDRESS);
+				// if the optional is empty,
+				// then ensure the ACCT blockchain is a Bitcoiny blockchain, but not Pirate Chain and fill the optional
+				// Even though the Pirate Chain protocol does support multi send,
+				// the Pirate Chain API we are using does not support multi send
+				else if( acct.isEmpty() ) {
+					if( !(acctUsingAtData.getBlockchain() instanceof Bitcoiny) ||
+							acctUsingAtData.getBlockchain() instanceof PirateChain )
+						throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_CRITERIA);
+					acct = Optional.of(acctUsingAtData);
+				}
+				// if the optional is filled, then ensure it is equal to the AT in this iteration
+				else if( !acctUsingAtData.getCodeBytesHash().equals(acct.get().getCodeBytesHash()) )
+					throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_CRITERIA);
+
+				if (!acctUsingAtData.getBlockchain().isValidWalletKey(respondRequests.foreignKey))
+					throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_PRIVATE_KEY);
+
+				CrossChainTradeData crossChainTradeData = acctUsingAtData.populateTradeData(repository, atData);
+				if (crossChainTradeData == null)
+					throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_ADDRESS);
+
+				if (crossChainTradeData.mode != AcctMode.OFFERING)
+					throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_CRITERIA);
+
+				// Check if there is a buy or a cancel request in progress for this trade
+				List<Transaction.TransactionType> txTypes = List.of(Transaction.TransactionType.MESSAGE);
+				List<TransactionData> unconfirmed = repository.getTransactionRepository().getUnconfirmedTransactions(txTypes, null, 0, 0, false);
+				for (TransactionData transactionData : unconfirmed) {
+					MessageTransactionData messageTransactionData = (MessageTransactionData) transactionData;
+					if (Objects.equals(messageTransactionData.getRecipient(), atAddress)) {
+						// There is a pending request for this trade, so block this buy attempt to reduce the risk of refunds
+						throw ApiExceptionFactory.INSTANCE.createCustomException(request, ApiError.INVALID_CRITERIA, "Trade has an existing buy request or is pending cancellation.");
+					}
+				}
+
+				crossChainTradeDataList.add(crossChainTradeData);
+			}
+
+			AcctTradeBot.ResponseResult result
+					= TradeBot.getInstance().startResponseMultiple(
+						repository,
+						acct.get(),
+						crossChainTradeDataList,
+						respondRequests.receivingAddress,
+						respondRequests.foreignKey,
+						(Bitcoiny) acct.get().getBlockchain());
+
+			switch (result) {
+				case OK:
+					return "true";
+
+				case BALANCE_ISSUE:
+					throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_BALANCE_ISSUE);
+
+				case NETWORK_ISSUE:
+					throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE);
+
+				default:
+					return "false";
+			}
+		} catch (DataException e) {
+			throw ApiExceptionFactory.INSTANCE.createCustomException(request, ApiError.REPOSITORY_ISSUE, e.getMessage());
+		}
+	}
+
 	@DELETE
 	@Operation(
 		summary = "Delete completed trade",

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

@@ -1,23 +1,49 @@
 package org.qortal.api.resource;
 
+import com.google.common.primitives.Bytes;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
-import org.qortal.crosschain.*;
+import org.bitcoinj.core.Address;
+import org.bitcoinj.core.Coin;
+import org.bitcoinj.script.Script;
+import org.bitcoinj.script.ScriptBuilder;
+
+import org.bouncycastle.util.Strings;
+import org.json.simple.JSONObject;
+import org.qortal.api.model.crosschain.BitcoinyTBDRequest;
+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 org.qortal.utils.BitTwiddling;
+
+import java.util.*;
+import java.util.stream.Collectors;
 
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
 
 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),
+                buildInfos(blockchainProvider.getServers(), currentServer).stream()
+                        .sorted(Comparator.comparing(ServerInfo::isCurrent).reversed())
+                        .collect(Collectors.toList()),
                 buildInfos(blockchainProvider.getRemainingServers(), currentServer),
                 buildInfos(blockchainProvider.getUselessServers(), currentServer)
             );
@@ -44,4 +70,566 @@ public class CrossChainUtils {
 
         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);
+    }
+
+    /**
+     * Get Bitcoiny TBD (To Be Determined)
+     *
+     * @param bitcoinyTBDRequest the parameters for the Bitcoiny TBD
+     * @return the Bitcoiny TBD
+     * @throws DataException
+     */
+    public static BitcoinyTBD getBitcoinyTBD(BitcoinyTBDRequest bitcoinyTBDRequest) throws DataException {
+
+        try {
+            DeterminedNetworkParams networkParams = new DeterminedNetworkParams(bitcoinyTBDRequest);
+
+            BitcoinyTBD bitcoinyTBD
+                    = BitcoinyTBD.getInstance(bitcoinyTBDRequest.getCode())
+                        .orElse(BitcoinyTBD.buildInstance(
+                                bitcoinyTBDRequest,
+                                networkParams)
+                        );
+
+            return bitcoinyTBD;
+        } catch (Exception e) {
+            LOGGER.error(e.getMessage(), e);
+        }
+
+        return null;
+    }
+
+    /**
+     * Get Version Decimal
+     *
+     * @param jsonObject the JSON object with the version attribute
+     * @param attribute the attribute that hold the version value
+     * @return the version as a decimal number, discarding
+     * @throws NumberFormatException
+     */
+    public static double getVersionDecimal(JSONObject jsonObject, String attribute) throws NumberFormatException {
+        String versionString = (String) jsonObject.get(attribute);
+        return Double.parseDouble(reduceDelimeters(versionString, 1, '.'));
+    }
+
+    /**
+     * Reduce Delimeters
+     *
+     * @param value the raw string
+     * @param max the max number of the delimeter
+     * @param delimeter the delimeter
+     * @return the processed value with the max number of delimeters
+     */
+    public static String reduceDelimeters(String value, int max, char delimeter) {
+
+        if( max < 1 ) return value;
+
+        String[] splits = Strings.split(value, delimeter);
+
+        StringBuffer buffer = new StringBuffer(splits[0]);
+
+        int limit = Math.min(max + 1, splits.length);
+
+        for( int index = 1; index < limit; index++) {
+            buffer.append(delimeter);
+            buffer.append(splits[index]);
+        }
+
+        return buffer.toString();
+    }
+
+    /** Returns
+
+
+    /**
+     * Build Offer Message
+     *
+     * @param partnerBitcoinPKH
+     * @param hashOfSecretA
+     * @param lockTimeA
+     * @return  'offer' MESSAGE payload for trade partner to send to AT creator's trade address
+     */
+    public static byte[] buildOfferMessage(byte[] partnerBitcoinPKH, byte[] hashOfSecretA, int lockTimeA) {
+        byte[] lockTimeABytes = BitTwiddling.toBEByteArray((long) lockTimeA);
+        return Bytes.concat(partnerBitcoinPKH, hashOfSecretA, lockTimeABytes);
+    }
+}

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

@@ -35,6 +35,7 @@ import org.qortal.data.account.RewardShareData;
 import org.qortal.network.Network;
 import org.qortal.network.Peer;
 import org.qortal.network.PeerAddress;
+import org.qortal.repository.ReindexManager;
 import org.qortal.repository.DataException;
 import org.qortal.repository.Repository;
 import org.qortal.repository.RepositoryManager;
@@ -894,6 +895,50 @@ public class AdminResource {
 		}
 	}
 
+	@POST
+	@Path("/repository/reindex")
+	@Operation(
+			summary = "Reindex repository",
+			description = "Rebuilds all transactions and balances from archived blocks. Warning: takes around 1 week, and the core will not function normally during this time. If 'false' is returned, the database may be left in an inconsistent state, requiring another reindex or a bootstrap to correct it.",
+			responses = {
+					@ApiResponse(
+							description = "\"true\"",
+							content = @Content(mediaType = MediaType.TEXT_PLAIN, schema = @Schema(type = "string"))
+					)
+			}
+	)
+	@ApiErrors({ApiError.REPOSITORY_ISSUE, ApiError.BLOCKCHAIN_NEEDS_SYNC})
+	@SecurityRequirement(name = "apiKey")
+	public String reindex(@HeaderParam(Security.API_KEY_HEADER) String apiKey) {
+		Security.checkApiCallAllowed(request);
+
+		if (Synchronizer.getInstance().isSynchronizing())
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.BLOCKCHAIN_NEEDS_SYNC);
+
+		try {
+			ReentrantLock blockchainLock = Controller.getInstance().getBlockchainLock();
+
+			blockchainLock.lockInterruptibly();
+
+			try {
+				ReindexManager reindexManager = new ReindexManager();
+				reindexManager.reindex();
+				return "true";
+
+			} catch (DataException e) {
+				LOGGER.info("DataException when reindexing: {}", e.getMessage());
+
+			} finally {
+				blockchainLock.unlock();
+			}
+		} catch (InterruptedException e) {
+			// We couldn't lock blockchain to perform reindex
+			return "false";
+		}
+
+		return "false";
+	}
+
 	@DELETE
 	@Path("/repository")
 	@Operation(
@@ -966,8 +1011,6 @@ public class AdminResource {
 		}
 	}
 
-
-
 	@POST
 	@Path("/apikey/generate")
 	@Operation(

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/arbitrary/misc/Service.java

@@ -167,7 +167,7 @@ public enum Service {
     COMMENT(1800, true, 500*1024L, true, false, null),
     CHAIN_COMMENT(1810, true, 239L, true, false, null),
     MAIL(1900, true, 1024*1024L, true, false, null),
-    MAIL_PRIVATE(1901, true, 1024*1024L, true, true, null),
+    MAIL_PRIVATE(1901, true, 5*1024*1024L, true, true, null),
     MESSAGE(1910, true, 1024*1024L, true, false, null),
     MESSAGE_PRIVATE(1911, true, 1024*1024L, true, true, null);
 

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/block/Block.java

@@ -29,6 +29,7 @@ import org.qortal.repository.ATRepository;
 import org.qortal.repository.DataException;
 import org.qortal.repository.Repository;
 import org.qortal.repository.TransactionRepository;
+import org.qortal.settings.Settings;
 import org.qortal.transaction.AtTransaction;
 import org.qortal.transaction.Transaction;
 import org.qortal.transaction.Transaction.ApprovalStatus;
@@ -104,6 +105,7 @@ public class Block {
 	protected Repository repository;
 	protected BlockData blockData;
 	protected PublicKeyAccount minter;
+	boolean isTestnet = Settings.getInstance().isTestNet();
 
 	// Other properties
 	private static final Logger LOGGER = LogManager.getLogger(Block.class);
@@ -1086,7 +1088,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.
@@ -1281,13 +1283,20 @@ public class Block {
 			// Create repository savepoint here so we can rollback to it after testing transactions
 			repository.setSavepoint();
 
-			if (this.blockData.getHeight() == 212937) {
-				// Apply fix for block 212937 but fix will be rolled back before we exit method
-				Block212937.processFix(this);
-			}
-			else if (InvalidNameRegistrationBlocks.isAffectedBlock(this.blockData.getHeight())) {
-				// Apply fix for affected name registration blocks, but fix will be rolled back before we exit method
-				InvalidNameRegistrationBlocks.processFix(this);
+			if (!isTestnet) {
+				if (this.blockData.getHeight() == 212937) {
+					// Apply fix for block 212937 but fix will be rolled back before we exit method
+					Block212937.processFix(this);
+				} else if (this.blockData.getHeight() == 1333492) {
+					// Apply fix for block 1333492 but fix will be rolled back before we exit method
+					Block1333492.processFix(this);
+				} else if (InvalidNameRegistrationBlocks.isAffectedBlock(this.blockData.getHeight())) {
+					// Apply fix for affected name registration blocks, but fix will be rolled back before we exit method
+					InvalidNameRegistrationBlocks.processFix(this);
+				} else if (InvalidBalanceBlocks.isAffectedBlock(this.blockData.getHeight())) {
+					// Apply fix for affected balance blocks, but fix will be rolled back before we exit method
+					InvalidBalanceBlocks.processFix(this);
+				}
 			}
 
 			for (Transaction transaction : this.getTransactions()) {
@@ -1550,21 +1559,23 @@ public class Block {
 				processBlockRewards();
 			}
 
-			if (this.blockData.getHeight() == 212937) {
-				// Apply fix for block 212937
-				Block212937.processFix(this);
-			}
-
-			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);
+			if (!isTestnet) {
+				if (this.blockData.getHeight() == 212937) {
+					// Apply fix for block 212937
+					Block212937.processFix(this);
+				} else if (this.blockData.getHeight() == 1333492) {
+					// Apply fix for block 1333492
+					Block1333492.processFix(this);
+				} else if (InvalidBalanceBlocks.isAffectedBlock(this.blockData.getHeight())) {
+					// Apply fix for affected balance blocks
+					InvalidBalanceBlocks.processFix(this);
+				} else if (this.blockData.getHeight() == BlockChain.getInstance().getSelfSponsorshipAlgoV1Height()) {
+					SelfSponsorshipAlgoV1Block.processAccountPenalties(this);
+				} else if (this.blockData.getHeight() == BlockChain.getInstance().getSelfSponsorshipAlgoV2Height()) {
+					SelfSponsorshipAlgoV2Block.processAccountPenalties(this);
+				} else if (this.blockData.getHeight() == BlockChain.getInstance().getSelfSponsorshipAlgoV3Height()) {
+					SelfSponsorshipAlgoV3Block.processAccountPenalties(this);
+				}
 			}
 		}
 
@@ -1850,21 +1861,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) {
-				// Revert fix for block 212937
-				Block212937.orphanFix(this);
-			}
-
-			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);
+			if (!isTestnet) {
+				if (this.blockData.getHeight() == 212937) {
+					// Revert fix for block 212937
+					Block212937.orphanFix(this);
+				} else if (this.blockData.getHeight() == 1333492) {
+					// Revert fix for block 1333492
+					Block1333492.orphanFix(this);
+				} else if (InvalidBalanceBlocks.isAffectedBlock(this.blockData.getHeight())) {
+					// Revert fix for affected balance blocks
+					InvalidBalanceBlocks.orphanFix(this);
+				} else if (this.blockData.getHeight() == BlockChain.getInstance().getSelfSponsorshipAlgoV1Height()) {
+					SelfSponsorshipAlgoV1Block.orphanAccountPenalties(this);
+				} else if (this.blockData.getHeight() == BlockChain.getInstance().getSelfSponsorshipAlgoV2Height()) {
+					SelfSponsorshipAlgoV2Block.orphanAccountPenalties(this);
+				} else if (this.blockData.getHeight() == BlockChain.getInstance().getSelfSponsorshipAlgoV3Height()) {
+					SelfSponsorshipAlgoV3Block.orphanAccountPenalties(this);
+				}
 			}
 			
 			// Account levels and block rewards are only processed/orphaned on block reward distribution blocks

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

@@ -0,0 +1,101 @@
+package org.qortal.block;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.eclipse.persistence.jaxb.JAXBContextFactory;
+import org.eclipse.persistence.jaxb.UnmarshallerProperties;
+import org.qortal.data.account.AccountBalanceData;
+import org.qortal.repository.DataException;
+
+import javax.xml.bind.JAXBContext;
+import javax.xml.bind.JAXBException;
+import javax.xml.bind.UnmarshalException;
+import javax.xml.bind.Unmarshaller;
+import javax.xml.transform.stream.StreamSource;
+import java.io.InputStream;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * Block 1333492
+ * <p>
+ * As described in InvalidBalanceBlocks.java, legacy bugs caused a small drift in account balances.
+ * This block adjusts any remaining differences between a clean reindex/resync and a recent bootstrap.
+ * <p>
+ * The block height 1333492 isn't significant - it's simply the height of a recent bootstrap at the
+ * time of development, so that the account balances could be accessed and compared against the same
+ * block in a reindexed db.
+ * <p>
+ * As with InvalidBalanceBlocks, the discrepancies are insignificant, except for a single
+ * account which has a 3.03 QORT discrepancy. This was due to the account being the first recipient
+ * of a name sale and encountering an early bug in this area.
+ * <p>
+ * The total offset for this block is 3.02816514 QORT.
+ */
+public final class Block1333492 {
+
+	private static final Logger LOGGER = LogManager.getLogger(Block1333492.class);
+	private static final String ACCOUNT_DELTAS_SOURCE = "block-1333492-deltas.json";
+
+	private static final List<AccountBalanceData> accountDeltas = readAccountDeltas();
+
+	private Block1333492() {
+		/* Do not instantiate */
+	}
+
+	@SuppressWarnings("unchecked")
+	private static List<AccountBalanceData> readAccountDeltas() {
+		Unmarshaller unmarshaller;
+
+		try {
+			// Create JAXB context aware of classes we need to unmarshal
+			JAXBContext jc = JAXBContextFactory.createContext(new Class[] {
+				AccountBalanceData.class
+			}, null);
+
+			// Create unmarshaller
+			unmarshaller = jc.createUnmarshaller();
+
+			// Set the unmarshaller media type to JSON
+			unmarshaller.setProperty(UnmarshallerProperties.MEDIA_TYPE, "application/json");
+
+			// Tell unmarshaller that there's no JSON root element in the JSON input
+			unmarshaller.setProperty(UnmarshallerProperties.JSON_INCLUDE_ROOT, false);
+		} catch (JAXBException e) {
+			String message = "Failed to setup unmarshaller to read block 1333492 deltas";
+			LOGGER.error(message, e);
+			throw new RuntimeException(message, e);
+		}
+
+		ClassLoader classLoader = BlockChain.class.getClassLoader();
+		InputStream in = classLoader.getResourceAsStream(ACCOUNT_DELTAS_SOURCE);
+		StreamSource jsonSource = new StreamSource(in);
+
+		try  {
+			// Attempt to unmarshal JSON stream to BlockChain config
+			return (List<AccountBalanceData>) unmarshaller.unmarshal(jsonSource, AccountBalanceData.class).getValue();
+		} catch (UnmarshalException e) {
+			String message = "Failed to parse block 1333492 deltas";
+			LOGGER.error(message, e);
+			throw new RuntimeException(message, e);
+		} catch (JAXBException e) {
+			String message = "Unexpected JAXB issue while processing block 1333492 deltas";
+			LOGGER.error(message, e);
+			throw new RuntimeException(message, e);
+		}
+	}
+
+	public static void processFix(Block block) throws DataException {
+		block.repository.getAccountRepository().modifyAssetBalances(accountDeltas);
+	}
+
+	public static void orphanFix(Block block) throws DataException {
+		// Create inverse deltas
+		List<AccountBalanceData> inverseDeltas = accountDeltas.stream()
+				.map(delta -> new AccountBalanceData(delta.getAddress(), delta.getAssetId(), 0 - delta.getBalance()))
+				.collect(Collectors.toList());
+
+		block.repository.getAccountRepository().modifyAssetBalances(inverseDeltas);
+	}
+
+}

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

@@ -80,7 +80,12 @@ public class BlockChain {
 		arbitraryOptionalFeeTimestamp,
 		unconfirmableRewardSharesHeight,
 		disableTransferPrivsTimestamp,
-		enableTransferPrivsTimestamp
+		enableTransferPrivsTimestamp,
+		cancelSellNameValidationTimestamp,
+		disableRewardshareHeight,
+		enableRewardshareHeight,
+		onlyMintWithNameHeight,
+		groupMemberCheckHeight
 	}
 
 	// Custom transaction fees
@@ -200,6 +205,7 @@ public class BlockChain {
 	private int minAccountLevelToRewardShare;
 	private int maxRewardSharesPerFounderMintingAccount;
 	private int founderEffectiveMintingLevel;
+	private int mintingGroupId;
 
 	/** Minimum time to retain online account signatures (ms) for block validity checks. */
 	private long onlineAccountSignaturesMinLifetime;
@@ -397,7 +403,6 @@ public class BlockChain {
 		return this.onlineAccountsModulusV2Timestamp;
 	}
 
-
 	/* Block reward batching */
 	public long getBlockRewardBatchStartHeight() {
 		return this.blockRewardBatchStartHeight;
@@ -524,6 +529,10 @@ public class BlockChain {
 		return this.onlineAccountSignaturesMaxLifetime;
 	}
 
+	public int getMintingGroupId() {
+		return this.mintingGroupId;
+	}
+
 	public CiyamAtSettings getCiyamAtSettings() {
 		return this.ciyamAtSettings;
 	}
@@ -610,6 +619,26 @@ public class BlockChain {
 		return this.featureTriggers.get(FeatureTrigger.enableTransferPrivsTimestamp.name()).longValue();
 	}
 
+	public long getCancelSellNameValidationTimestamp() {
+		return this.featureTriggers.get(FeatureTrigger.cancelSellNameValidationTimestamp.name()).longValue();
+	}
+
+	public int getDisableRewardshareHeight() {
+		return this.featureTriggers.get(FeatureTrigger.disableRewardshareHeight.name()).intValue();
+	}
+
+	public int getEnableRewardshareHeight() {
+		return this.featureTriggers.get(FeatureTrigger.enableRewardshareHeight.name()).intValue();
+	}
+
+	public int getOnlyMintWithNameHeight() {
+		return this.featureTriggers.get(FeatureTrigger.onlyMintWithNameHeight.name()).intValue();
+	}
+
+	public int getGroupMemberCheckHeight() {
+		return this.featureTriggers.get(FeatureTrigger.groupMemberCheckHeight.name()).intValue();
+	}
+
 	// More complex getters for aspects that change by height or timestamp
 
 	public long getRewardAtHeight(int ourHeight) {
@@ -805,10 +834,12 @@ public class BlockChain {
 		boolean isLite = Settings.getInstance().isLite();
 		boolean canBootstrap = Settings.getInstance().getBootstrap();
 		boolean needsArchiveRebuild = false;
+		int checkHeight = 0;
 		BlockData chainTip;
 
 		try (final Repository repository = RepositoryManager.getRepository()) {
 			chainTip = repository.getBlockRepository().getLastBlock();
+			checkHeight = repository.getBlockRepository().getBlockchainHeight();
 
 			// Ensure archive is (at least partially) intact, and force a bootstrap if it isn't
 			if (!isTopOnly && archiveEnabled && canBootstrap) {
@@ -824,6 +855,17 @@ public class BlockChain {
 				}
 			}
 
+			if (!canBootstrap) {
+				if (checkHeight > 2) {
+					LOGGER.info("Retrieved block 2 from archive. Syncing from genesis block resumed!");
+				} else {
+					needsArchiveRebuild = (repository.getBlockArchiveRepository().fromHeight(2) == null);
+					if (needsArchiveRebuild) {
+						LOGGER.info("Couldn't retrieve block 2 from archive. Bootstrapping is disabled. Syncing from genesis block!");
+					}
+				}
+			}
+
 			// Validate checkpoints
 			// Limited to topOnly nodes for now, in order to reduce risk, and to solve a real-world problem with divergent topOnly nodes
 			// TODO: remove the isTopOnly conditional below once this feature has had more testing time
@@ -856,11 +898,12 @@ public class BlockChain {
 
 		// Check first block is Genesis Block
 		if (!isGenesisBlockValid() || needsArchiveRebuild) {
-			try {
-				rebuildBlockchain();
-
-			} catch (InterruptedException e) {
-				throw new DataException(String.format("Interrupted when trying to rebuild blockchain: %s", e.getMessage()));
+			if (checkHeight < 3) {
+				try {
+					rebuildBlockchain();
+				} catch (InterruptedException e) {
+					throw new DataException(String.format("Interrupted when trying to rebuild blockchain: %s", e.getMessage()));
+				}
 			}
 		}
 
@@ -1001,5 +1044,4 @@ public class BlockChain {
 			blockchainLock.unlock();
 		}
 	}
-
 }

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

@@ -0,0 +1,134 @@
+package org.qortal.block;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.eclipse.persistence.jaxb.JAXBContextFactory;
+import org.eclipse.persistence.jaxb.UnmarshallerProperties;
+import org.qortal.data.account.AccountBalanceData;
+import org.qortal.repository.DataException;
+
+import javax.xml.bind.JAXBContext;
+import javax.xml.bind.JAXBException;
+import javax.xml.bind.UnmarshalException;
+import javax.xml.bind.Unmarshaller;
+import javax.xml.transform.stream.StreamSource;
+import java.io.InputStream;
+import java.util.*;
+import java.util.stream.Collectors;
+
+
+/**
+ * Due to various bugs - which have been fixed - a small amount of balance drift occurred
+ * in the chainstate of running nodes and bootstraps, when compared with a clean sync from genesis.
+ * This resulted in a significant number of invalid transactions in the chain history due to
+ * subtle balance discrepancies. The sum of all discrepancies that resulted in an invalid
+ * transaction is 0.00198322 QORT, so despite the large quantity of transactions, they
+ * represent an insignificant amount when summed.
+ * <p>
+ * This class is responsible for retroactively fixing all the past transactions which
+ * are invalid due to the balance discrepancies.
+ */
+
+
+public final class InvalidBalanceBlocks {
+
+	private static final Logger LOGGER = LogManager.getLogger(InvalidBalanceBlocks.class);
+
+	private static final String ACCOUNT_DELTAS_SOURCE = "invalid-transaction-balance-deltas.json";
+
+	private static final List<AccountBalanceData> accountDeltas = readAccountDeltas();
+	private static final List<Integer> affectedHeights = getAffectedHeights();
+
+	private InvalidBalanceBlocks() {
+		/* Do not instantiate */
+	}
+
+	@SuppressWarnings("unchecked")
+	private static List<AccountBalanceData> readAccountDeltas() {
+		Unmarshaller unmarshaller;
+
+		try {
+			// Create JAXB context aware of classes we need to unmarshal
+			JAXBContext jc = JAXBContextFactory.createContext(new Class[] {
+					AccountBalanceData.class
+			}, null);
+
+			// Create unmarshaller
+			unmarshaller = jc.createUnmarshaller();
+
+			// Set the unmarshaller media type to JSON
+			unmarshaller.setProperty(UnmarshallerProperties.MEDIA_TYPE, "application/json");
+
+			// Tell unmarshaller that there's no JSON root element in the JSON input
+			unmarshaller.setProperty(UnmarshallerProperties.JSON_INCLUDE_ROOT, false);
+		} catch (JAXBException e) {
+			String message = "Failed to setup unmarshaller to read block 212937 deltas";
+			LOGGER.error(message, e);
+			throw new RuntimeException(message, e);
+		}
+
+		ClassLoader classLoader = BlockChain.class.getClassLoader();
+		InputStream in = classLoader.getResourceAsStream(ACCOUNT_DELTAS_SOURCE);
+		StreamSource jsonSource = new StreamSource(in);
+
+		try  {
+			// Attempt to unmarshal JSON stream to BlockChain config
+			return (List<AccountBalanceData>) unmarshaller.unmarshal(jsonSource, AccountBalanceData.class).getValue();
+		} catch (UnmarshalException e) {
+			String message = "Failed to parse balance deltas";
+			LOGGER.error(message, e);
+			throw new RuntimeException(message, e);
+		} catch (JAXBException e) {
+			String message = "Unexpected JAXB issue while processing balance deltas";
+			LOGGER.error(message, e);
+			throw new RuntimeException(message, e);
+		}
+	}
+
+	private static List<Integer> getAffectedHeights() {
+		List<Integer> heights = new ArrayList<>();
+		for (AccountBalanceData accountBalanceData : accountDeltas) {
+			if (!heights.contains(accountBalanceData.getHeight())) {
+				heights.add(accountBalanceData.getHeight());
+			}
+		}
+		return heights;
+	}
+
+	private static List<AccountBalanceData> getAccountDeltasAtHeight(int height) {
+		return accountDeltas.stream().filter(a -> a.getHeight() == height).collect(Collectors.toList());
+	}
+
+	public static boolean isAffectedBlock(int height) {
+		return affectedHeights.contains(Integer.valueOf(height));
+	}
+
+	public static void processFix(Block block) throws DataException {
+		Integer blockHeight = block.getBlockData().getHeight();
+		List<AccountBalanceData> deltas = getAccountDeltasAtHeight(blockHeight);
+		if (deltas == null) {
+			throw new DataException(String.format("Unable to lookup invalid balance data for block height %d", blockHeight));
+		}
+
+		block.repository.getAccountRepository().modifyAssetBalances(deltas);
+
+		LOGGER.info("Applied balance patch for block {}", blockHeight);
+	}
+
+	public static void orphanFix(Block block) throws DataException {
+		Integer blockHeight = block.getBlockData().getHeight();
+		List<AccountBalanceData> deltas = getAccountDeltasAtHeight(blockHeight);
+		if (deltas == null) {
+			throw new DataException(String.format("Unable to lookup invalid balance data for block height %d", blockHeight));
+		}
+
+		// Create inverse delta(s)
+		for (AccountBalanceData accountBalanceData : deltas) {
+			AccountBalanceData inverseBalanceData = new AccountBalanceData(accountBalanceData.getAddress(), accountBalanceData.getAssetId(), -accountBalanceData.getBalance());
+			block.repository.getAccountRepository().modifyAssetBalances(List.of(inverseBalanceData));
+		}
+
+		LOGGER.info("Reverted balance patch for block {}", blockHeight);
+	}
+
+}

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

@@ -64,6 +64,7 @@ public class BlockMinter extends Thread {
 	@Override
 	public void run() {
 		Thread.currentThread().setName("BlockMinter");
+		Thread.currentThread().setPriority(MAX_PRIORITY);
 
 		if (Settings.getInstance().isTopOnly() || Settings.getInstance().isLite()) {
 			// Top only and lite nodes do not sign blocks
@@ -159,8 +160,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 +172,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 +197,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

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

@@ -13,6 +13,7 @@ import org.qortal.block.Block;
 import org.qortal.block.BlockChain;
 import org.qortal.block.BlockChain.BlockTimingByHeight;
 import org.qortal.controller.arbitrary.*;
+import org.qortal.controller.hsqldb.HSQLDBDataCacheManager;
 import org.qortal.controller.repository.NamesDatabaseIntegrityCheck;
 import org.qortal.controller.repository.PruneManager;
 import org.qortal.controller.tradebot.TradeBot;
@@ -32,8 +33,10 @@ import org.qortal.gui.Gui;
 import org.qortal.gui.SysTray;
 import org.qortal.network.Network;
 import org.qortal.network.Peer;
+import org.qortal.network.PeerAddress;
 import org.qortal.network.message.*;
 import org.qortal.repository.*;
+import org.qortal.repository.hsqldb.HSQLDBRepository;
 import org.qortal.repository.hsqldb.HSQLDBRepositoryFactory;
 import org.qortal.settings.Settings;
 import org.qortal.transaction.Transaction;
@@ -48,8 +51,11 @@ import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStream;
+import java.net.InetSocketAddress;
+import java.net.UnknownHostException;
 import java.nio.file.Path;
 import java.nio.file.Paths;
+import java.security.SecureRandom;
 import java.security.Security;
 import java.time.LocalDateTime;
 import java.time.ZoneOffset;
@@ -95,7 +101,7 @@ public class Controller extends Thread {
 	private final long buildTimestamp; // seconds
 	private final String[] savedArgs;
 
-	private ExecutorService callbackExecutor = Executors.newFixedThreadPool(3);
+	private ExecutorService callbackExecutor = Executors.newFixedThreadPool(4);
 	private volatile boolean notifyGroupMembershipChange = false;
 
 	/** Latest blocks on our chain. Note: tail/last is the latest block. */
@@ -402,8 +408,17 @@ public class Controller extends Thread {
 			RepositoryManager.setRequestedCheckpoint(Boolean.TRUE);
 
 			try (final Repository repository = RepositoryManager.getRepository()) {
-				RepositoryManager.rebuildTransactionSequences(repository);
+				// RepositoryManager.rebuildTransactionSequences(repository);
 				ArbitraryDataCacheManager.getInstance().buildArbitraryResourcesCache(repository, false);
+
+				if( Settings.getInstance().isDbCacheEnabled() ) {
+					LOGGER.info("Db Cache Starting ...");
+					HSQLDBDataCacheManager hsqldbDataCacheManager = new HSQLDBDataCacheManager((HSQLDBRepository) repositoryFactory.getRepository());
+					hsqldbDataCacheManager.start();
+				}
+				else {
+					LOGGER.info("Db Cache Disabled");
+				}
 			}
 		} catch (DataException e) {
 			// If exception has no cause or message then repository is in use by some other process.
@@ -485,7 +500,6 @@ public class Controller extends Thread {
 			@Override
 			public void run() {
 				Thread.currentThread().setName("Shutdown hook");
-
 				Controller.getInstance().shutdown();
 			}
 		});
@@ -564,6 +578,124 @@ public class Controller extends Thread {
 
 		// If GUI is enabled, we're no longer starting up but actually running now
 		Gui.getInstance().notifyRunning();
+
+		if (Settings.getInstance().isAutoRestartEnabled()) {
+			// Check every 10 minutes if we have enough connected peers
+			Timer checkConnectedPeers = new Timer();
+
+			checkConnectedPeers.schedule(new TimerTask() {
+				@Override
+				public void run() {
+					// Get the connected peers
+					int myConnectedPeers = Network.getInstance().getImmutableHandshakedPeers().size();
+					LOGGER.debug("Node have {} connected peers", myConnectedPeers);
+					if (myConnectedPeers == 0) {
+						// Restart node if we have 0 peers
+						LOGGER.info("Node have no connected peers, restarting node");
+						try {
+							RestartNode.attemptToRestart();
+						} catch (Exception e) {
+							LOGGER.error("Unable to restart the node", e);
+						}
+					}
+				}
+			}, 10*60*1000, 10*60*1000);
+		}
+
+		// Check every 10 minutes to see if the block minter is running
+		Timer checkBlockMinter = new Timer();
+
+		checkBlockMinter.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);
+
+		// Check if we need sync from genesis and start syncing
+		Timer syncFromGenesis = new Timer();
+		syncFromGenesis.schedule(new TimerTask() {
+			@Override
+			public void run() {
+				LOGGER.debug("Start sync from genesis check.");
+				boolean canBootstrap = Settings.getInstance().getBootstrap();
+				boolean needsArchiveRebuild = false;
+				int checkHeight = 0;
+				Repository repository = null;
+
+				try {
+					repository = RepositoryManager.getRepository();
+					needsArchiveRebuild = (repository.getBlockArchiveRepository().fromHeight(2) == null);
+					checkHeight = repository.getBlockRepository().getBlockchainHeight();
+				} catch (DataException e) {
+					throw new RuntimeException(e);
+				}
+
+				if (canBootstrap || !needsArchiveRebuild || checkHeight > 3) {
+					LOGGER.debug("Bootstrapping is enabled or we have more than 2 blocks, cancel sync from genesis check.");
+					syncFromGenesis.cancel();
+					return;
+				}
+
+				if (needsArchiveRebuild && !canBootstrap) {
+					LOGGER.info("Start syncing from genesis!");
+					List<Peer> seeds = new ArrayList<>(Network.getInstance().getImmutableHandshakedPeers());
+
+					// Check if have a qualified peer to sync
+					if (seeds.isEmpty()) {
+						LOGGER.info("No connected peers, will try again later.");
+						return;
+					}
+
+					int index = new SecureRandom().nextInt(seeds.size());
+					String syncNode = String.valueOf(seeds.get(index));
+					PeerAddress peerAddress = PeerAddress.fromString(syncNode);
+					InetSocketAddress resolvedAddress = null;
+
+					try {
+						resolvedAddress = peerAddress.toSocketAddress();
+					} catch (UnknownHostException e) {
+						throw new RuntimeException(e);
+					}
+
+					InetSocketAddress finalResolvedAddress = resolvedAddress;
+					Peer targetPeer = seeds.stream().filter(peer -> peer.getResolvedAddress().equals(finalResolvedAddress)).findFirst().orElse(null);
+					Synchronizer.SynchronizationResult syncResult;
+
+					try {
+						do {
+							try {
+								syncResult = Synchronizer.getInstance().actuallySynchronize(targetPeer, true);
+							} catch (InterruptedException e) {
+								throw new RuntimeException(e);
+							}
+						}
+						while (syncResult == Synchronizer.SynchronizationResult.OK);
+					} finally {
+						// We are syncing now, so can cancel the check
+						syncFromGenesis.cancel();
+					}
+				}
+			}
+		}, 3*60*1000, 3*60*1000);
 	}
 
 	/** Called by AdvancedInstaller's launch EXE in single-instance mode, when an instance is already running. */
@@ -571,7 +703,6 @@ public class Controller extends Thread {
 		// Return as we don't want to run more than one instance
 	}
 
-
 	// Main thread
 
 	@Override
@@ -775,7 +906,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 +2052,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 +2132,4 @@ public class Controller extends Thread {
 	public StatsSnapshot getStatsSnapshot() {
 		return this.stats;
 	}
-
 }

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

@@ -80,7 +80,7 @@ public class OnlineAccountsManager {
     // one for the transition period.
     private static long[] POW_VERIFY_WORK_BUFFER = new long[getPoWBufferSize() / 8];
 
-    private final ScheduledExecutorService executor = Executors.newScheduledThreadPool(4, new NamedThreadFactory("OnlineAccounts"));
+    private final ScheduledExecutorService executor = Executors.newScheduledThreadPool(4, new NamedThreadFactory("OnlineAccounts", Thread.NORM_PRIORITY));
     private volatile boolean isStopping = false;
 
     private final Set<OnlineAccountData> onlineAccountsImportQueue = ConcurrentHashMap.newKeySet();
@@ -538,7 +538,6 @@ public class OnlineAccountsManager {
 
                     if (++i > 1 + 1) {
                         iterator.remove();
-                        continue;
                     }
                 }
             } catch (DataException e) {

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

@@ -65,6 +65,7 @@ public class PirateChainWalletController extends Thread {
     @Override
     public void run() {
         Thread.currentThread().setName("Pirate Chain Wallet Controller");
+        Thread.currentThread().setPriority(MIN_PRIORITY);
 
         try {
             while (running && !Controller.isStopping()) {

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

@@ -2,7 +2,7 @@ package org.qortal.controller;
 
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
-import org.qortal.ApplyRestart;;
+import org.qortal.ApplyRestart;
 import org.qortal.globalization.Translator;
 import org.qortal.gui.SysTray;
 import org.qortal.repository.RepositoryManager;

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;
@@ -118,8 +118,12 @@ public class Synchronizer extends Thread {
 	}
 
 	public static Synchronizer getInstance() {
-		if (instance == null)
+		if (instance == null) {
 			instance = new Synchronizer();
+			instance.setPriority(Settings.getInstance().getSynchronizerThreadPriority());
+
+			LOGGER.info("thread priority = " + instance.getPriority());
+		}
 
 		return instance;
 	}
@@ -258,7 +262,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 +396,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 +410,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 +449,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 +667,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 +705,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 +732,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 +784,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 +1294,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 +1356,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/ArbitraryDataBuilderThread.java

@@ -14,6 +14,7 @@ import java.io.IOException;
 import java.util.Comparator;
 import java.util.Map;
 
+import static java.lang.Thread.NORM_PRIORITY;
 import static org.qortal.data.arbitrary.ArbitraryResourceStatus.Status.NOT_PUBLISHED;
 
 
@@ -28,6 +29,7 @@ public class ArbitraryDataBuilderThread implements Runnable {
     @Override
     public void run() {
         Thread.currentThread().setName("Arbitrary Data Builder Thread");
+        Thread.currentThread().setPriority(NORM_PRIORITY);
         ArbitraryDataBuildManager buildManager = ArbitraryDataBuildManager.getInstance();
 
         while (!Controller.isStopping()) {

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

@@ -41,6 +41,7 @@ public class ArbitraryDataCacheManager extends Thread {
     @Override
     public void run() {
         Thread.currentThread().setName("Arbitrary Data Cache Manager");
+        Thread.currentThread().setPriority(NORM_PRIORITY);
 
         try {
             while (!Controller.isStopping()) {

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

@@ -71,6 +71,7 @@ public class ArbitraryDataCleanupManager extends Thread {
 	@Override
 	public void run() {
 		Thread.currentThread().setName("Arbitrary Data Cleanup Manager");
+		Thread.currentThread().setPriority(NORM_PRIORITY);
 
 		// Paginate queries when fetching arbitrary transactions
 		final int limit = 100;
@@ -208,8 +209,7 @@ public class ArbitraryDataCleanupManager extends Thread {
 									Base58.encode(arbitraryTransactionData.getSignature())));
 
 							ArbitraryTransactionUtils.convertFileToChunks(arbitraryTransactionData, now, STALE_FILE_TIMEOUT);
-							continue;
-						}
+                        }
 					}
 
 				} catch (DataException e) {
@@ -284,8 +284,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/ArbitraryDataFileRequestThread.java

@@ -17,6 +17,8 @@ import java.util.Arrays;
 import java.util.Comparator;
 import java.util.Iterator;
 
+import static java.lang.Thread.NORM_PRIORITY;
+
 public class ArbitraryDataFileRequestThread implements Runnable {
 
     private static final Logger LOGGER = LogManager.getLogger(ArbitraryDataFileRequestThread.class);
@@ -28,6 +30,7 @@ public class ArbitraryDataFileRequestThread implements Runnable {
     @Override
     public void run() {
         Thread.currentThread().setName("Arbitrary Data File Request Thread");
+        Thread.currentThread().setPriority(NORM_PRIORITY);
 
         try {
             while (!Controller.isStopping()) {

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

@@ -91,6 +91,7 @@ public class ArbitraryDataManager extends Thread {
 	@Override
 	public void run() {
 		Thread.currentThread().setName("Arbitrary Data Manager");
+		Thread.currentThread().setPriority(NORM_PRIORITY);
 
 		// Create data directory in case it doesn't exist yet
 		this.createDataDirectory();
@@ -230,8 +231,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 +313,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/ArbitraryDataRenderManager.java

@@ -36,6 +36,7 @@ public class ArbitraryDataRenderManager extends Thread {
     @Override
     public void run() {
         Thread.currentThread().setName("Arbitrary Data Render Manager");
+        Thread.currentThread().setPriority(NORM_PRIORITY);
 
         try {
             while (!isStopping) {

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

@@ -72,6 +72,8 @@ public class ArbitraryDataStorageManager extends Thread {
     @Override
     public void run() {
         Thread.currentThread().setName("Arbitrary Data Storage Manager");
+        Thread.currentThread().setPriority(NORM_PRIORITY);
+
         try {
             while (!isStopping) {
                 Thread.sleep(1000);
@@ -291,7 +293,6 @@ public class ArbitraryDataStorageManager extends Thread {
                 arbitraryTransactionDataList.add(arbitraryTransactionData);
 
             } catch (DataException e) {
-                continue;
             }
         }
 
@@ -345,7 +346,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/hsqldb/HSQLDBDataCacheManager.java

@@ -0,0 +1,27 @@
+package org.qortal.controller.hsqldb;
+
+import org.qortal.data.arbitrary.ArbitraryResourceCache;
+import org.qortal.repository.RepositoryManager;
+import org.qortal.repository.hsqldb.HSQLDBCacheUtils;
+import org.qortal.repository.hsqldb.HSQLDBRepository;
+import org.qortal.settings.Settings;
+
+public class HSQLDBDataCacheManager extends Thread{
+
+    private HSQLDBRepository respository;
+
+    public HSQLDBDataCacheManager(HSQLDBRepository respository) {
+        this.respository = respository;
+    }
+
+    @Override
+    public void run() {
+        Thread.currentThread().setName("HSQLDB Data Cache Manager");
+
+        HSQLDBCacheUtils.startCaching(
+            Settings.getInstance().getDbCacheThreadPriority(),
+            Settings.getInstance().getDbCacheFrequency(),
+            this.respository
+        );
+    }
+}

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

@@ -11,6 +11,8 @@ import org.qortal.repository.RepositoryManager;
 import org.qortal.settings.Settings;
 import org.qortal.utils.NTP;
 
+import static java.lang.Thread.MIN_PRIORITY;
+
 public class AtStatesPruner implements Runnable {
 
 	private static final Logger LOGGER = LogManager.getLogger(AtStatesPruner.class);
@@ -46,72 +48,81 @@ public class AtStatesPruner implements Runnable {
 			repository.saveChanges();
 
 			while (!Controller.isStopping()) {
-				repository.discardChanges();
+				try {
+					repository.discardChanges();
 
-				Thread.sleep(Settings.getInstance().getAtStatesPruneInterval());
+					Thread.sleep(Settings.getInstance().getAtStatesPruneInterval());
 
-				BlockData chainTip = Controller.getInstance().getChainTip();
-				if (chainTip == null || NTP.getTime() == null)
-					continue;
+					BlockData chainTip = Controller.getInstance().getChainTip();
+					if (chainTip == null || NTP.getTime() == null)
+						continue;
 
-				// Don't even attempt if we're mid-sync as our repository requests will be delayed for ages
-				if (Synchronizer.getInstance().isSynchronizing())
-					continue;
+					// Don't even attempt if we're mid-sync as our repository requests will be delayed for ages
+					if (Synchronizer.getInstance().isSynchronizing())
+						continue;
 
-				// Prune AT states for all blocks up until our latest minus pruneBlockLimit
-				final int ourLatestHeight = chainTip.getHeight();
-				int upperPrunableHeight = ourLatestHeight - Settings.getInstance().getPruneBlockLimit();
+					// Prune AT states for all blocks up until our latest minus pruneBlockLimit
+					final int ourLatestHeight = chainTip.getHeight();
+					int upperPrunableHeight = ourLatestHeight - Settings.getInstance().getPruneBlockLimit();
 
-				// In archive mode we are only allowed to trim blocks that have already been archived
-				if (archiveMode) {
-					upperPrunableHeight = repository.getBlockArchiveRepository().getBlockArchiveHeight() - 1;
+					// In archive mode we are only allowed to trim blocks that have already been archived
+					if (archiveMode) {
+						upperPrunableHeight = repository.getBlockArchiveRepository().getBlockArchiveHeight() - 1;
 
-					// TODO: validate that the actual archived data exists before pruning it?
-				}
+						// TODO: validate that the actual archived data exists before pruning it?
+					}
 
-				int upperBatchHeight = pruneStartHeight + Settings.getInstance().getAtStatesPruneBatchSize();
-				int upperPruneHeight = Math.min(upperBatchHeight, upperPrunableHeight);
+					int upperBatchHeight = pruneStartHeight + Settings.getInstance().getAtStatesPruneBatchSize();
+					int upperPruneHeight = Math.min(upperBatchHeight, upperPrunableHeight);
 
-				if (pruneStartHeight >= upperPruneHeight)
-					continue;
+					if (pruneStartHeight >= upperPruneHeight)
+						continue;
 
-				LOGGER.debug(String.format("Pruning AT states between blocks %d and %d...", pruneStartHeight, upperPruneHeight));
+					LOGGER.info(String.format("Pruning AT states between blocks %d and %d...", pruneStartHeight, upperPruneHeight));
 
-				int numAtStatesPruned = repository.getATRepository().pruneAtStates(pruneStartHeight, upperPruneHeight);
-				repository.saveChanges();
-				int numAtStateDataRowsTrimmed = repository.getATRepository().trimAtStates(
-						pruneStartHeight, upperPruneHeight, Settings.getInstance().getAtStatesTrimLimit());
-				repository.saveChanges();
-
-				if (numAtStatesPruned > 0 || numAtStateDataRowsTrimmed > 0) {
-					final int finalPruneStartHeight = pruneStartHeight;
-					LOGGER.debug(() -> String.format("Pruned %d AT state%s between blocks %d and %d",
-							numAtStatesPruned, (numAtStatesPruned != 1 ? "s" : ""),
-							finalPruneStartHeight, upperPruneHeight));
-				} else {
-					// Can we move onto next batch?
-					if (upperPrunableHeight > upperBatchHeight) {
-						pruneStartHeight = upperBatchHeight;
-						repository.getATRepository().setAtPruneHeight(pruneStartHeight);
-						maxLatestAtStatesHeight = PruneManager.getMaxHeightForLatestAtStates(repository);
-						repository.getATRepository().rebuildLatestAtStates(maxLatestAtStatesHeight);
-						repository.saveChanges();
+					int numAtStatesPruned = repository.getATRepository().pruneAtStates(pruneStartHeight, upperPruneHeight);
+					repository.saveChanges();
+					int numAtStateDataRowsTrimmed = repository.getATRepository().trimAtStates(
+							pruneStartHeight, upperPruneHeight, Settings.getInstance().getAtStatesTrimLimit());
+					repository.saveChanges();
 
+					if (numAtStatesPruned > 0 || numAtStateDataRowsTrimmed > 0) {
 						final int finalPruneStartHeight = pruneStartHeight;
-						LOGGER.debug(() -> String.format("Bumping AT state base prune height to %d", finalPruneStartHeight));
+						LOGGER.info(() -> String.format("Pruned %d AT state%s between blocks %d and %d",
+								numAtStatesPruned, (numAtStatesPruned != 1 ? "s" : ""),
+								finalPruneStartHeight, upperPruneHeight));
+					} else {
+						// Can we move onto next batch?
+						if (upperPrunableHeight > upperBatchHeight) {
+							pruneStartHeight = upperBatchHeight;
+							repository.getATRepository().setAtPruneHeight(pruneStartHeight);
+							maxLatestAtStatesHeight = PruneManager.getMaxHeightForLatestAtStates(repository);
+							repository.getATRepository().rebuildLatestAtStates(maxLatestAtStatesHeight);
+							repository.saveChanges();
+
+							final int finalPruneStartHeight = pruneStartHeight;
+							LOGGER.info(() -> String.format("Bumping AT state base prune height to %d", finalPruneStartHeight));
+						}
+						else {
+							// We've pruned up to the upper prunable height
+							// Back off for a while to save CPU for syncing
+							repository.discardChanges();
+							Thread.sleep(5*60*1000L);
+						}
+					}
+				} catch (InterruptedException e) {
+					if(Controller.isStopping()) {
+						LOGGER.info("AT States Pruning Shutting Down");
 					}
 					else {
-						// We've pruned up to the upper prunable height
-						// Back off for a while to save CPU for syncing
-						repository.discardChanges();
-						Thread.sleep(5*60*1000L);
+						LOGGER.warn("AT States Pruning interrupted. Trying again. Report this error immediately to the developers.", e);
 					}
+				} catch (Exception e) {
+					LOGGER.warn("AT States Pruning stopped working. Trying again. Report this error immediately to the developers.", e);
 				}
 			}
-		} catch (DataException e) {
-			LOGGER.warn(String.format("Repository issue trying to prune AT states: %s", e.getMessage()));
-		} catch (InterruptedException e) {
-			// Time to exit
+		} catch (Exception e) {
+			LOGGER.error("AT States Pruning is not working! Not trying again. Restart ASAP. Report this error immediately to the developers.", e);
 		}
 	}
 

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

@@ -11,6 +11,8 @@ import org.qortal.repository.RepositoryManager;
 import org.qortal.settings.Settings;
 import org.qortal.utils.NTP;
 
+import static java.lang.Thread.MIN_PRIORITY;
+
 public class AtStatesTrimmer implements Runnable {
 
 	private static final Logger LOGGER = LogManager.getLogger(AtStatesTrimmer.class);
@@ -33,57 +35,66 @@ public class AtStatesTrimmer implements Runnable {
 			repository.saveChanges();
 
 			while (!Controller.isStopping()) {
-				repository.discardChanges();
+				try {
+					repository.discardChanges();
 
-				Thread.sleep(Settings.getInstance().getAtStatesTrimInterval());
+					Thread.sleep(Settings.getInstance().getAtStatesTrimInterval());
 
-				BlockData chainTip = Controller.getInstance().getChainTip();
-				if (chainTip == null || NTP.getTime() == null)
-					continue;
+					BlockData chainTip = Controller.getInstance().getChainTip();
+					if (chainTip == null || NTP.getTime() == null)
+						continue;
 
-				// Don't even attempt if we're mid-sync as our repository requests will be delayed for ages
-				if (Synchronizer.getInstance().isSynchronizing())
-					continue;
+					// Don't even attempt if we're mid-sync as our repository requests will be delayed for ages
+					if (Synchronizer.getInstance().isSynchronizing())
+						continue;
 
-				long currentTrimmableTimestamp = NTP.getTime() - Settings.getInstance().getAtStatesMaxLifetime();
-				// We want to keep AT states near the tip of our copy of blockchain so we can process/orphan nearby blocks
-				long chainTrimmableTimestamp = chainTip.getTimestamp() - Settings.getInstance().getAtStatesMaxLifetime();
+					long currentTrimmableTimestamp = NTP.getTime() - Settings.getInstance().getAtStatesMaxLifetime();
+					// We want to keep AT states near the tip of our copy of blockchain so we can process/orphan nearby blocks
+					long chainTrimmableTimestamp = chainTip.getTimestamp() - Settings.getInstance().getAtStatesMaxLifetime();
 
-				long upperTrimmableTimestamp = Math.min(currentTrimmableTimestamp, chainTrimmableTimestamp);
-				int upperTrimmableHeight = repository.getBlockRepository().getHeightFromTimestamp(upperTrimmableTimestamp);
+					long upperTrimmableTimestamp = Math.min(currentTrimmableTimestamp, chainTrimmableTimestamp);
+					int upperTrimmableHeight = repository.getBlockRepository().getHeightFromTimestamp(upperTrimmableTimestamp);
 
-				int upperBatchHeight = trimStartHeight + Settings.getInstance().getAtStatesTrimBatchSize();
-				int upperTrimHeight = Math.min(upperBatchHeight, upperTrimmableHeight);
+					int upperBatchHeight = trimStartHeight + Settings.getInstance().getAtStatesTrimBatchSize();
+					int upperTrimHeight = Math.min(upperBatchHeight, upperTrimmableHeight);
 
-				if (trimStartHeight >= upperTrimHeight)
-					continue;
+					if (trimStartHeight >= upperTrimHeight)
+						continue;
 
-				int numAtStatesTrimmed = repository.getATRepository().trimAtStates(trimStartHeight, upperTrimHeight, Settings.getInstance().getAtStatesTrimLimit());
-				repository.saveChanges();
-
-				if (numAtStatesTrimmed > 0) {
-					final int finalTrimStartHeight = trimStartHeight;
-					LOGGER.debug(() -> String.format("Trimmed %d AT state%s between blocks %d and %d",
-							numAtStatesTrimmed, (numAtStatesTrimmed != 1 ? "s" : ""),
-							finalTrimStartHeight, upperTrimHeight));
-				} else {
-					// Can we move onto next batch?
-					if (upperTrimmableHeight > upperBatchHeight) {
-						trimStartHeight = upperBatchHeight;
-						repository.getATRepository().setAtTrimHeight(trimStartHeight);
-						maxLatestAtStatesHeight = PruneManager.getMaxHeightForLatestAtStates(repository);
-						repository.getATRepository().rebuildLatestAtStates(maxLatestAtStatesHeight);
-						repository.saveChanges();
+					int numAtStatesTrimmed = repository.getATRepository().trimAtStates(trimStartHeight, upperTrimHeight, Settings.getInstance().getAtStatesTrimLimit());
+					repository.saveChanges();
 
+					if (numAtStatesTrimmed > 0) {
 						final int finalTrimStartHeight = trimStartHeight;
-						LOGGER.debug(() -> String.format("Bumping AT state base trim height to %d", finalTrimStartHeight));
+						LOGGER.info(() -> String.format("Trimmed %d AT state%s between blocks %d and %d",
+								numAtStatesTrimmed, (numAtStatesTrimmed != 1 ? "s" : ""),
+								finalTrimStartHeight, upperTrimHeight));
+					} else {
+						// Can we move onto next batch?
+						if (upperTrimmableHeight > upperBatchHeight) {
+							trimStartHeight = upperBatchHeight;
+							repository.getATRepository().setAtTrimHeight(trimStartHeight);
+							maxLatestAtStatesHeight = PruneManager.getMaxHeightForLatestAtStates(repository);
+							repository.getATRepository().rebuildLatestAtStates(maxLatestAtStatesHeight);
+							repository.saveChanges();
+
+							final int finalTrimStartHeight = trimStartHeight;
+							LOGGER.info(() -> String.format("Bumping AT state base trim height to %d", finalTrimStartHeight));
+						}
 					}
+				} catch (InterruptedException e) {
+					if(Controller.isStopping()) {
+						LOGGER.info("AT States Trimming Shutting Down");
+					}
+					else {
+						LOGGER.warn("AT States Trimming interrupted. Trying again. Report this error immediately to the developers.", e);
+					}
+				} catch (Exception e) {
+					LOGGER.warn("AT States Trimming stopped working. Trying again. Report this error immediately to the developers.", e);
 				}
 			}
-		} catch (DataException e) {
-			LOGGER.warn(String.format("Repository issue trying to trim AT states: %s", e.getMessage()));
-		} catch (InterruptedException e) {
-			// Time to exit
+		} catch (Exception e) {
+			LOGGER.error("AT States Trimming is not working! Not trying again. Restart ASAP. Report this error immediately to the developers.", e);
 		}
 	}
 

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

@@ -15,11 +15,13 @@ import org.qortal.utils.NTP;
 
 import java.io.IOException;
 
+import static java.lang.Thread.NORM_PRIORITY;
+
 public class BlockArchiver implements Runnable {
 
 	private static final Logger LOGGER = LogManager.getLogger(BlockArchiver.class);
 
-	private static final long INITIAL_SLEEP_PERIOD = 5 * 60 * 1000L + 1234L; // ms
+	private static final long INITIAL_SLEEP_PERIOD = 15 * 60 * 1000L; // ms
 
 	public void run() {
 		Thread.currentThread().setName("Block archiver");
@@ -45,71 +47,78 @@ public class BlockArchiver implements Runnable {
 			LOGGER.info("Starting block archiver from height {}...", startHeight);
 
 			while (!Controller.isStopping()) {
-				repository.discardChanges();
-
-				Thread.sleep(Settings.getInstance().getArchiveInterval());
-
-				BlockData chainTip = Controller.getInstance().getChainTip();
-				if (chainTip == null || NTP.getTime() == null) {
-					continue;
-				}
-
-				// Don't even attempt if we're mid-sync as our repository requests will be delayed for ages
-				if (Synchronizer.getInstance().isSynchronizing()) {
-					continue;
-				}
-
-				// Don't attempt to archive if we're not synced yet
-				final Long minLatestBlockTimestamp = Controller.getMinimumLatestBlockTimestamp();
-				if (minLatestBlockTimestamp == null || chainTip.getTimestamp() < minLatestBlockTimestamp) {
-					continue;
-				}
-
-
-				// Build cache of blocks
 				try {
-					final int maximumArchiveHeight = BlockArchiveWriter.getMaxArchiveHeight(repository);
-					BlockArchiveWriter writer = new BlockArchiveWriter(startHeight, maximumArchiveHeight, repository);
-					BlockArchiveWriter.BlockArchiveWriteResult result = writer.write();
-					switch (result) {
-						case OK:
-							// Increment block archive height
-							startHeight += writer.getWrittenCount();
-							repository.getBlockArchiveRepository().setBlockArchiveHeight(startHeight);
-							repository.saveChanges();
-							break;
+					repository.discardChanges();
 
-						case STOPPING:
-							return;
+					Thread.sleep(Settings.getInstance().getArchiveInterval());
 
-							// We've reached the limit of the blocks we can archive
-							// Sleep for a while to allow more to become available
-						case NOT_ENOUGH_BLOCKS:
-							// We didn't reach our file size target, so that must mean that we don't have enough blocks
-							// yet or something went wrong. Sleep for a while and then try again.
-							repository.discardChanges();
-							Thread.sleep(60 * 60 * 1000L); // 1 hour
-							break;
-
-						case BLOCK_NOT_FOUND:
-							// We tried to archive a block that didn't exist. This is a major failure and likely means
-							// that a bootstrap or re-sync is needed. Try again every minute until then.
-							LOGGER.info("Error: block not found when building archive. If this error persists, " +
-									"a bootstrap or re-sync may be needed.");
-							repository.discardChanges();
-							Thread.sleep( 60 * 1000L); // 1 minute
-							break;
+					BlockData chainTip = Controller.getInstance().getChainTip();
+					if (chainTip == null || NTP.getTime() == null) {
+						continue;
 					}
 
-				} catch (IOException | TransformationException e) {
-					LOGGER.info("Caught exception when creating block cache", e);
-				}
+					// Don't even attempt if we're mid-sync as our repository requests will be delayed for ages
+					if (Synchronizer.getInstance().isSynchronizing()) {
+						continue;
+					}
 
+					// Don't attempt to archive if we're not synced yet
+					final Long minLatestBlockTimestamp = Controller.getMinimumLatestBlockTimestamp();
+					if (minLatestBlockTimestamp == null || chainTip.getTimestamp() < minLatestBlockTimestamp) {
+						continue;
+					}
+
+					// Build cache of blocks
+					try {
+						final int maximumArchiveHeight = BlockArchiveWriter.getMaxArchiveHeight(repository);
+						BlockArchiveWriter writer = new BlockArchiveWriter(startHeight, maximumArchiveHeight, repository);
+						BlockArchiveWriter.BlockArchiveWriteResult result = writer.write();
+						switch (result) {
+							case OK:
+								// Increment block archive height
+								startHeight += writer.getWrittenCount();
+								repository.getBlockArchiveRepository().setBlockArchiveHeight(startHeight);
+								repository.saveChanges();
+								break;
+
+							case STOPPING:
+								return;
+
+								// We've reached the limit of the blocks we can archive
+								// Sleep for a while to allow more to become available
+							case NOT_ENOUGH_BLOCKS:
+								// We didn't reach our file size target, so that must mean that we don't have enough blocks
+								// yet or something went wrong. Sleep for a while and then try again.
+								repository.discardChanges();
+								Thread.sleep(2 * 60 * 60 * 1000L); // 1 hour
+								break;
+
+							case BLOCK_NOT_FOUND:
+								// We tried to archive a block that didn't exist. This is a major failure and likely means
+								// that a bootstrap or re-sync is needed. Try again every minute until then.
+								LOGGER.info("Error: block not found when building archive. If this error persists, " +
+										"a bootstrap or re-sync may be needed.");
+								repository.discardChanges();
+								Thread.sleep(60 * 1000L); // 1 minute
+								break;
+						}
+
+					} catch (IOException | TransformationException e) {
+						LOGGER.info("Caught exception when creating block cache", e);
+					}
+				} catch (InterruptedException e) {
+					if(Controller.isStopping()) {
+						LOGGER.info("Block Archiving Shutting Down");
+					}
+					else {
+						LOGGER.warn("Block Archiving interrupted. Trying again. Report this error immediately to the developers.", e);
+					}
+				} catch (Exception e) {
+					LOGGER.warn("Block Archiving stopped working. Trying again. Report this error immediately to the developers.", e);
+				}
 			}
-		} catch (DataException e) {
-			LOGGER.info("Caught exception when creating block cache", e);
-		} catch (InterruptedException e) {
-			// Do nothing
+		} catch (Exception e) {
+			LOGGER.error("Block Archiving is not working! Not trying again. Restart ASAP. Report this error immediately to the developers.", e);
 		}
 
 	}

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

@@ -11,6 +11,8 @@ import org.qortal.repository.RepositoryManager;
 import org.qortal.settings.Settings;
 import org.qortal.utils.NTP;
 
+import static java.lang.Thread.NORM_PRIORITY;
+
 public class BlockPruner implements Runnable {
 
 	private static final Logger LOGGER = LogManager.getLogger(BlockPruner.class);
@@ -48,72 +50,81 @@ public class BlockPruner implements Runnable {
 			}
 
 			while (!Controller.isStopping()) {
-				repository.discardChanges();
+				try {
+					repository.discardChanges();
 
-				Thread.sleep(Settings.getInstance().getBlockPruneInterval());
+					Thread.sleep(Settings.getInstance().getBlockPruneInterval());
 
-				BlockData chainTip = Controller.getInstance().getChainTip();
-				if (chainTip == null || NTP.getTime() == null)
-					continue;
+					BlockData chainTip = Controller.getInstance().getChainTip();
+					if (chainTip == null || NTP.getTime() == null)
+						continue;
 
-				// Don't even attempt if we're mid-sync as our repository requests will be delayed for ages
-				if (Synchronizer.getInstance().isSynchronizing()) {
-					continue;
-				}
+					// Don't even attempt if we're mid-sync as our repository requests will be delayed for ages
+					if (Synchronizer.getInstance().isSynchronizing()) {
+						continue;
+					}
 
-				// Don't attempt to prune if we're not synced yet
-				final Long minLatestBlockTimestamp = Controller.getMinimumLatestBlockTimestamp();
-				if (minLatestBlockTimestamp == null || chainTip.getTimestamp() < minLatestBlockTimestamp) {
-					continue;
-				}
+					// Don't attempt to prune if we're not synced yet
+					final Long minLatestBlockTimestamp = Controller.getMinimumLatestBlockTimestamp();
+					if (minLatestBlockTimestamp == null || chainTip.getTimestamp() < minLatestBlockTimestamp) {
+						continue;
+					}
 
-				// Prune all blocks up until our latest minus pruneBlockLimit
-				final int ourLatestHeight = chainTip.getHeight();
-				int upperPrunableHeight = ourLatestHeight - Settings.getInstance().getPruneBlockLimit();
+					// Prune all blocks up until our latest minus pruneBlockLimit
+					final int ourLatestHeight = chainTip.getHeight();
+					int upperPrunableHeight = ourLatestHeight - Settings.getInstance().getPruneBlockLimit();
 
-				// In archive mode we are only allowed to trim blocks that have already been archived
-				if (archiveMode) {
-					upperPrunableHeight = repository.getBlockArchiveRepository().getBlockArchiveHeight() - 1;
-				}
+					// In archive mode we are only allowed to trim blocks that have already been archived
+					if (archiveMode) {
+						upperPrunableHeight = repository.getBlockArchiveRepository().getBlockArchiveHeight() - 1;
+					}
 
-				int upperBatchHeight = pruneStartHeight + Settings.getInstance().getBlockPruneBatchSize();
-				int upperPruneHeight = Math.min(upperBatchHeight, upperPrunableHeight);
+					int upperBatchHeight = pruneStartHeight + Settings.getInstance().getBlockPruneBatchSize();
+					int upperPruneHeight = Math.min(upperBatchHeight, upperPrunableHeight);
 
-				if (pruneStartHeight >= upperPruneHeight) {
-					continue;
-				}
+					if (pruneStartHeight >= upperPruneHeight) {
+						continue;
+					}
 
-				LOGGER.debug(String.format("Pruning blocks between %d and %d...", pruneStartHeight, upperPruneHeight));
+					LOGGER.info(String.format("Pruning blocks between %d and %d...", pruneStartHeight, upperPruneHeight));
 
-				int numBlocksPruned = repository.getBlockRepository().pruneBlocks(pruneStartHeight, upperPruneHeight);
-				repository.saveChanges();
-
-				if (numBlocksPruned > 0) {
-					LOGGER.debug(String.format("Pruned %d block%s between %d and %d",
-							numBlocksPruned, (numBlocksPruned != 1 ? "s" : ""),
-							pruneStartHeight, upperPruneHeight));
-				} else {
-					final int nextPruneHeight = upperPruneHeight + 1;
-					repository.getBlockRepository().setBlockPruneHeight(nextPruneHeight);
+					int numBlocksPruned = repository.getBlockRepository().pruneBlocks(pruneStartHeight, upperPruneHeight);
 					repository.saveChanges();
-					LOGGER.debug(String.format("Bumping block base prune height to %d", pruneStartHeight));
 
-					// Can we move onto next batch?
-					if (upperPrunableHeight > nextPruneHeight) {
-						pruneStartHeight = nextPruneHeight;
+					if (numBlocksPruned > 0) {
+						LOGGER.info(String.format("Pruned %d block%s between %d and %d",
+								numBlocksPruned, (numBlocksPruned != 1 ? "s" : ""),
+								pruneStartHeight, upperPruneHeight));
+					} else {
+						final int nextPruneHeight = upperPruneHeight + 1;
+						repository.getBlockRepository().setBlockPruneHeight(nextPruneHeight);
+						repository.saveChanges();
+						LOGGER.info(String.format("Bumping block base prune height to %d", pruneStartHeight));
+
+						// Can we move onto next batch?
+						if (upperPrunableHeight > nextPruneHeight) {
+							pruneStartHeight = nextPruneHeight;
+						}
+						else {
+							// We've pruned up to the upper prunable height
+							// Back off for a while to save CPU for syncing
+							repository.discardChanges();
+							Thread.sleep(10*60*1000L);
+						}
+					}
+				} catch (InterruptedException e) {
+					if(Controller.isStopping()) {
+						LOGGER.info("Block Pruning Shutting Down");
 					}
 					else {
-						// We've pruned up to the upper prunable height
-						// Back off for a while to save CPU for syncing
-						repository.discardChanges();
-						Thread.sleep(10*60*1000L);
+						LOGGER.warn("Block Pruning interrupted. Trying again. Report this error immediately to the developers.", e);
 					}
+				} catch (Exception e) {
+					LOGGER.warn("Block Pruning stopped working. Trying again. Report this error immediately to the developers.", e);
 				}
 			}
-		} catch (DataException e) {
-			LOGGER.warn(String.format("Repository issue trying to prune blocks: %s", e.getMessage()));
-		} catch (InterruptedException e) {
-			// Time to exit
+		} catch (Exception e) {
+			LOGGER.error("Block Pruning is not working! Not trying again. Restart ASAP. Report this error immediately to the developers.", e);
 		}
 	}
 

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/repository/OnlineAccountsSignaturesTrimmer.java

@@ -12,6 +12,8 @@ import org.qortal.repository.RepositoryManager;
 import org.qortal.settings.Settings;
 import org.qortal.utils.NTP;
 
+import static java.lang.Thread.NORM_PRIORITY;
+
 public class OnlineAccountsSignaturesTrimmer implements Runnable {
 
 	private static final Logger LOGGER = LogManager.getLogger(OnlineAccountsSignaturesTrimmer.class);
@@ -33,53 +35,62 @@ public class OnlineAccountsSignaturesTrimmer implements Runnable {
 			int trimStartHeight = repository.getBlockRepository().getOnlineAccountsSignaturesTrimHeight();
 
 			while (!Controller.isStopping()) {
-				repository.discardChanges();
+				try {
+					repository.discardChanges();
 
-				Thread.sleep(Settings.getInstance().getOnlineSignaturesTrimInterval());
+					Thread.sleep(Settings.getInstance().getOnlineSignaturesTrimInterval());
 
-				BlockData chainTip = Controller.getInstance().getChainTip();
-				if (chainTip == null || NTP.getTime() == null)
-					continue;
+					BlockData chainTip = Controller.getInstance().getChainTip();
+					if (chainTip == null || NTP.getTime() == null)
+						continue;
 
-				// Don't even attempt if we're mid-sync as our repository requests will be delayed for ages
-				if (Synchronizer.getInstance().isSynchronizing())
-					continue;
+					// Don't even attempt if we're mid-sync as our repository requests will be delayed for ages
+					if (Synchronizer.getInstance().isSynchronizing())
+						continue;
 
-				// Trim blockchain by removing 'old' online accounts signatures
-				long upperTrimmableTimestamp = NTP.getTime() - BlockChain.getInstance().getOnlineAccountSignaturesMaxLifetime();
-				int upperTrimmableHeight = repository.getBlockRepository().getHeightFromTimestamp(upperTrimmableTimestamp);
+					// Trim blockchain by removing 'old' online accounts signatures
+					long upperTrimmableTimestamp = NTP.getTime() - BlockChain.getInstance().getOnlineAccountSignaturesMaxLifetime();
+					int upperTrimmableHeight = repository.getBlockRepository().getHeightFromTimestamp(upperTrimmableTimestamp);
 
-				int upperBatchHeight = trimStartHeight + Settings.getInstance().getOnlineSignaturesTrimBatchSize();
-				int upperTrimHeight = Math.min(upperBatchHeight, upperTrimmableHeight);
+					int upperBatchHeight = trimStartHeight + Settings.getInstance().getOnlineSignaturesTrimBatchSize();
+					int upperTrimHeight = Math.min(upperBatchHeight, upperTrimmableHeight);
 
-				if (trimStartHeight >= upperTrimHeight)
-					continue;
+					if (trimStartHeight >= upperTrimHeight)
+						continue;
 
-				int numSigsTrimmed = repository.getBlockRepository().trimOldOnlineAccountsSignatures(trimStartHeight, upperTrimHeight);
-				repository.saveChanges();
-
-				if (numSigsTrimmed > 0) {
-					final int finalTrimStartHeight = trimStartHeight;
-					LOGGER.debug(() -> String.format("Trimmed %d online accounts signature%s between blocks %d and %d",
-							numSigsTrimmed, (numSigsTrimmed != 1 ? "s" : ""),
-							finalTrimStartHeight, upperTrimHeight));
-				} else {
-					// Can we move onto next batch?
-					if (upperTrimmableHeight > upperBatchHeight) {
-						trimStartHeight = upperBatchHeight;
-
-						repository.getBlockRepository().setOnlineAccountsSignaturesTrimHeight(trimStartHeight);
-						repository.saveChanges();
+					int numSigsTrimmed = repository.getBlockRepository().trimOldOnlineAccountsSignatures(trimStartHeight, upperTrimHeight);
+					repository.saveChanges();
 
+					if (numSigsTrimmed > 0) {
 						final int finalTrimStartHeight = trimStartHeight;
-						LOGGER.debug(() -> String.format("Bumping online accounts signatures base trim height to %d", finalTrimStartHeight));
+						LOGGER.info(() -> String.format("Trimmed %d online accounts signature%s between blocks %d and %d",
+								numSigsTrimmed, (numSigsTrimmed != 1 ? "s" : ""),
+								finalTrimStartHeight, upperTrimHeight));
+					} else {
+						// Can we move onto next batch?
+						if (upperTrimmableHeight > upperBatchHeight) {
+							trimStartHeight = upperBatchHeight;
+
+							repository.getBlockRepository().setOnlineAccountsSignaturesTrimHeight(trimStartHeight);
+							repository.saveChanges();
+
+							final int finalTrimStartHeight = trimStartHeight;
+							LOGGER.info(() -> String.format("Bumping online accounts signatures base trim height to %d", finalTrimStartHeight));
+						}
 					}
+				} catch (InterruptedException e) {
+					if(Controller.isStopping()) {
+						LOGGER.info("Online Accounts Signatures Trimming Shutting Down");
+					}
+					else {
+						LOGGER.warn("Online Accounts Signatures Trimming interrupted. Trying again. Report this error immediately to the developers.", e);
+					}
+				} catch (Exception e) {
+					LOGGER.warn("Online Accounts Signatures Trimming stopped working. Trying again. Report this error immediately to the developers.", e);
 				}
 			}
-		} catch (DataException e) {
-			LOGGER.warn(String.format("Repository issue trying to trim online accounts signatures: %s", e.getMessage()));
-		} catch (InterruptedException e) {
-			// Time to exit
+		} catch (Exception e) {
+			LOGGER.error("Online Accounts Signatures Trimming is not working! Not trying again. Restart ASAP. Report this error immediately to the developers.", e);
 		}
 	}
 

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

@@ -40,7 +40,7 @@ public class PruneManager {
     }
 
     public void start() {
-        this.executorService = Executors.newCachedThreadPool(new DaemonThreadFactory());
+        this.executorService = Executors.newCachedThreadPool(new DaemonThreadFactory(Settings.getInstance().getPruningThreadPriority()));
 
         if (Settings.getInstance().isTopOnly()) {
             // Top-only-sync

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

@@ -7,6 +7,7 @@ import org.bitcoinj.script.Script.ScriptType;
 import org.qortal.account.PrivateKeyAccount;
 import org.qortal.account.PublicKeyAccount;
 import org.qortal.api.model.crosschain.TradeBotCreateRequest;
+import org.qortal.api.resource.CrossChainUtils;
 import org.qortal.asset.Asset;
 import org.qortal.crosschain.*;
 import org.qortal.crypto.Crypto;
@@ -527,7 +528,7 @@ public class BitcoinACCTv1TradeBot implements AcctTradeBot {
 		// P2SH-A funding confirmed
 
 		// Attempt to send MESSAGE to Bob's Qortal trade address
-		byte[] messageData = BitcoinACCTv1.buildOfferMessage(tradeBotData.getTradeForeignPublicKeyHash(), tradeBotData.getHashOfSecret(), tradeBotData.getLockTimeA());
+		byte[] messageData = CrossChainUtils.buildOfferMessage(tradeBotData.getTradeForeignPublicKeyHash(), tradeBotData.getHashOfSecret(), tradeBotData.getLockTimeA());
 		String messageRecipient = crossChainTradeData.qortalCreatorTradeAddress;
 
 		boolean isMessageAlreadySent = repository.getMessageRepository().exists(tradeBotData.getTradeNativePublicKey(), messageRecipient, messageData);
@@ -893,7 +894,7 @@ public class BitcoinACCTv1TradeBot implements AcctTradeBot {
 		// Redeem P2SH-B using secret-B
 		Coin redeemAmount = Coin.valueOf(P2SH_B_OUTPUT_AMOUNT); // An actual amount to avoid dust filter, remaining used as fees. The real funds are in P2SH-A.
 		ECKey redeemKey = ECKey.fromPrivate(tradeBotData.getTradePrivateKey());
-		List<TransactionOutput> fundingOutputs = bitcoin.getUnspentOutputs(p2shAddressB);
+		List<TransactionOutput> fundingOutputs = bitcoin.getUnspentOutputs(p2shAddressB, false);
 		byte[] receivingAccountInfo = tradeBotData.getReceivingAccountInfo();
 
 		Transaction p2shRedeemTransaction = BitcoinyHTLC.buildRedeemTransaction(bitcoin.getNetworkParameters(), redeemAmount, redeemKey,
@@ -1063,7 +1064,7 @@ public class BitcoinACCTv1TradeBot implements AcctTradeBot {
 			case FUNDED: {
 				Coin redeemAmount = Coin.valueOf(crossChainTradeData.expectedForeignAmount - P2SH_B_OUTPUT_AMOUNT);
 				ECKey redeemKey = ECKey.fromPrivate(tradeBotData.getTradePrivateKey());
-				List<TransactionOutput> fundingOutputs = bitcoin.getUnspentOutputs(p2shAddressA);
+				List<TransactionOutput> fundingOutputs = bitcoin.getUnspentOutputs(p2shAddressA, false);
 
 				Transaction p2shRedeemTransaction = BitcoinyHTLC.buildRedeemTransaction(bitcoin.getNetworkParameters(), redeemAmount, redeemKey,
 						fundingOutputs, redeemScriptA, secretA, receivingAccountInfo);
@@ -1135,7 +1136,7 @@ public class BitcoinACCTv1TradeBot implements AcctTradeBot {
 			case FUNDED:{
 				Coin refundAmount = Coin.valueOf(P2SH_B_OUTPUT_AMOUNT); // An actual amount to avoid dust filter, remaining used as fees.
 				ECKey refundKey = ECKey.fromPrivate(tradeBotData.getTradePrivateKey());
-				List<TransactionOutput> fundingOutputs = bitcoin.getUnspentOutputs(p2shAddressB);
+				List<TransactionOutput> fundingOutputs = bitcoin.getUnspentOutputs(p2shAddressB, false);
 
 				// Determine receive address for refund
 				String receiveAddress = bitcoin.getUnusedReceiveAddress(tradeBotData.getForeignKey());
@@ -1201,7 +1202,7 @@ public class BitcoinACCTv1TradeBot implements AcctTradeBot {
 			case FUNDED:{
 				Coin refundAmount = Coin.valueOf(crossChainTradeData.expectedForeignAmount - P2SH_B_OUTPUT_AMOUNT);
 				ECKey refundKey = ECKey.fromPrivate(tradeBotData.getTradePrivateKey());
-				List<TransactionOutput> fundingOutputs = bitcoin.getUnspentOutputs(p2shAddressA);
+				List<TransactionOutput> fundingOutputs = bitcoin.getUnspentOutputs(p2shAddressA, false);
 
 				// Determine receive address for refund
 				String receiveAddress = bitcoin.getUnusedReceiveAddress(tradeBotData.getForeignKey());

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

@@ -7,7 +7,9 @@ import org.bitcoinj.script.Script.ScriptType;
 import org.qortal.account.PrivateKeyAccount;
 import org.qortal.account.PublicKeyAccount;
 import org.qortal.api.model.crosschain.TradeBotCreateRequest;
+import org.qortal.api.resource.CrossChainUtils;
 import org.qortal.asset.Asset;
+import org.qortal.controller.tradebot.TradeStates.State;
 import org.qortal.crosschain.*;
 import org.qortal.crypto.Crypto;
 import org.qortal.data.at.ATData;
@@ -30,12 +32,8 @@ import org.qortal.utils.NTP;
 
 import java.util.Arrays;
 import java.util.List;
-import java.util.Map;
 import java.util.stream.Collectors;
 
-import static java.util.Arrays.stream;
-import static java.util.stream.Collectors.toMap;
-
 /**
  * Performing cross-chain trading steps on behalf of user.
  * <p>
@@ -50,45 +48,6 @@ public class BitcoinACCTv3TradeBot implements AcctTradeBot {
 
 	private static final Logger LOGGER = LogManager.getLogger(BitcoinACCTv3TradeBot.class);
 
-	public enum State implements TradeBot.StateNameAndValueSupplier {
-		BOB_WAITING_FOR_AT_CONFIRM(10, false, false),
-		BOB_WAITING_FOR_MESSAGE(15, true, true),
-		BOB_WAITING_FOR_AT_REDEEM(25, true, true),
-		BOB_DONE(30, false, false),
-		BOB_REFUNDED(35, false, false),
-
-		ALICE_WAITING_FOR_AT_LOCK(85, true, true),
-		ALICE_DONE(95, false, false),
-		ALICE_REFUNDING_A(105, true, true),
-		ALICE_REFUNDED(110, false, false);
-
-		private static final Map<Integer, State> map = stream(State.values()).collect(toMap(state -> state.value, state -> state));
-
-		public final int value;
-		public final boolean requiresAtData;
-		public final boolean requiresTradeData;
-
-		State(int value, boolean requiresAtData, boolean requiresTradeData) {
-			this.value = value;
-			this.requiresAtData = requiresAtData;
-			this.requiresTradeData = requiresTradeData;
-		}
-
-		public static State valueOf(int value) {
-			return map.get(value);
-		}
-
-		@Override
-		public String getState() {
-			return this.name();
-		}
-
-		@Override
-		public int getStateValue() {
-			return this.value;
-		}
-	}
-
 	/** Maximum time Bob waits for his AT creation transaction to be confirmed into a block. (milliseconds) */
 	private static final long MAX_AT_CONFIRMATION_PERIOD = 24 * 60 * 60 * 1000L; // ms
 
@@ -313,7 +272,7 @@ public class BitcoinACCTv3TradeBot implements AcctTradeBot {
 		}
 
 		// Attempt to send MESSAGE to Bob's Qortal trade address
-		byte[] messageData = BitcoinACCTv3.buildOfferMessage(tradeBotData.getTradeForeignPublicKeyHash(), tradeBotData.getHashOfSecret(), tradeBotData.getLockTimeA());
+		byte[] messageData = CrossChainUtils.buildOfferMessage(tradeBotData.getTradeForeignPublicKeyHash(), tradeBotData.getHashOfSecret(), tradeBotData.getLockTimeA());
 		String messageRecipient = crossChainTradeData.qortalCreatorTradeAddress;
 
 		boolean isMessageAlreadySent = repository.getMessageRepository().exists(tradeBotData.getTradeNativePublicKey(), messageRecipient, messageData);
@@ -793,7 +752,7 @@ public class BitcoinACCTv3TradeBot implements AcctTradeBot {
 			case FUNDED: {
 				Coin redeemAmount = Coin.valueOf(crossChainTradeData.expectedForeignAmount);
 				ECKey redeemKey = ECKey.fromPrivate(tradeBotData.getTradePrivateKey());
-				List<TransactionOutput> fundingOutputs = bitcoin.getUnspentOutputs(p2shAddressA);
+				List<TransactionOutput> fundingOutputs = bitcoin.getUnspentOutputs(p2shAddressA, false);
 
 				Transaction p2shRedeemTransaction = BitcoinyHTLC.buildRedeemTransaction(bitcoin.getNetworkParameters(), redeemAmount, redeemKey,
 						fundingOutputs, redeemScriptA, secretA, receivingAccountInfo);
@@ -857,7 +816,7 @@ public class BitcoinACCTv3TradeBot implements AcctTradeBot {
 			case FUNDED:{
 				Coin refundAmount = Coin.valueOf(crossChainTradeData.expectedForeignAmount);
 				ECKey refundKey = ECKey.fromPrivate(tradeBotData.getTradePrivateKey());
-				List<TransactionOutput> fundingOutputs = bitcoin.getUnspentOutputs(p2shAddressA);
+				List<TransactionOutput> fundingOutputs = bitcoin.getUnspentOutputs(p2shAddressA, false);
 
 				// Determine receive address for refund
 				String receiveAddress = bitcoin.getUnusedReceiveAddress(tradeBotData.getForeignKey());

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

@@ -7,6 +7,7 @@ import org.bitcoinj.script.Script.ScriptType;
 import org.qortal.account.PrivateKeyAccount;
 import org.qortal.account.PublicKeyAccount;
 import org.qortal.api.model.crosschain.TradeBotCreateRequest;
+import org.qortal.api.resource.CrossChainUtils;
 import org.qortal.asset.Asset;
 import org.qortal.crosschain.*;
 import org.qortal.crypto.Crypto;
@@ -30,11 +31,9 @@ import org.qortal.utils.NTP;
 
 import java.util.Arrays;
 import java.util.List;
-import java.util.Map;
 import java.util.stream.Collectors;
 
-import static java.util.Arrays.stream;
-import static java.util.stream.Collectors.toMap;
+import org.qortal.controller.tradebot.TradeStates.State;
 
 /**
  * Performing cross-chain trading steps on behalf of user.
@@ -50,45 +49,6 @@ public class DigibyteACCTv3TradeBot implements AcctTradeBot {
 
 	private static final Logger LOGGER = LogManager.getLogger(DigibyteACCTv3TradeBot.class);
 
-	public enum State implements TradeBot.StateNameAndValueSupplier {
-		BOB_WAITING_FOR_AT_CONFIRM(10, false, false),
-		BOB_WAITING_FOR_MESSAGE(15, true, true),
-		BOB_WAITING_FOR_AT_REDEEM(25, true, true),
-		BOB_DONE(30, false, false),
-		BOB_REFUNDED(35, false, false),
-
-		ALICE_WAITING_FOR_AT_LOCK(85, true, true),
-		ALICE_DONE(95, false, false),
-		ALICE_REFUNDING_A(105, true, true),
-		ALICE_REFUNDED(110, false, false);
-
-		private static final Map<Integer, State> map = stream(State.values()).collect(toMap(state -> state.value, state -> state));
-
-		public final int value;
-		public final boolean requiresAtData;
-		public final boolean requiresTradeData;
-
-		State(int value, boolean requiresAtData, boolean requiresTradeData) {
-			this.value = value;
-			this.requiresAtData = requiresAtData;
-			this.requiresTradeData = requiresTradeData;
-		}
-
-		public static State valueOf(int value) {
-			return map.get(value);
-		}
-
-		@Override
-		public String getState() {
-			return this.name();
-		}
-
-		@Override
-		public int getStateValue() {
-			return this.value;
-		}
-	}
-
 	/** Maximum time Bob waits for his AT creation transaction to be confirmed into a block. (milliseconds) */
 	private static final long MAX_AT_CONFIRMATION_PERIOD = 24 * 60 * 60 * 1000L; // ms
 
@@ -313,7 +273,7 @@ public class DigibyteACCTv3TradeBot implements AcctTradeBot {
 		}
 
 		// Attempt to send MESSAGE to Bob's Qortal trade address
-		byte[] messageData = DigibyteACCTv3.buildOfferMessage(tradeBotData.getTradeForeignPublicKeyHash(), tradeBotData.getHashOfSecret(), tradeBotData.getLockTimeA());
+		byte[] messageData = CrossChainUtils.buildOfferMessage(tradeBotData.getTradeForeignPublicKeyHash(), tradeBotData.getHashOfSecret(), tradeBotData.getLockTimeA());
 		String messageRecipient = crossChainTradeData.qortalCreatorTradeAddress;
 
 		boolean isMessageAlreadySent = repository.getMessageRepository().exists(tradeBotData.getTradeNativePublicKey(), messageRecipient, messageData);
@@ -793,7 +753,7 @@ public class DigibyteACCTv3TradeBot implements AcctTradeBot {
 			case FUNDED: {
 				Coin redeemAmount = Coin.valueOf(crossChainTradeData.expectedForeignAmount);
 				ECKey redeemKey = ECKey.fromPrivate(tradeBotData.getTradePrivateKey());
-				List<TransactionOutput> fundingOutputs = digibyte.getUnspentOutputs(p2shAddressA);
+				List<TransactionOutput> fundingOutputs = digibyte.getUnspentOutputs(p2shAddressA, false);
 
 				Transaction p2shRedeemTransaction = BitcoinyHTLC.buildRedeemTransaction(digibyte.getNetworkParameters(), redeemAmount, redeemKey,
 						fundingOutputs, redeemScriptA, secretA, receivingAccountInfo);
@@ -857,7 +817,7 @@ public class DigibyteACCTv3TradeBot implements AcctTradeBot {
 			case FUNDED:{
 				Coin refundAmount = Coin.valueOf(crossChainTradeData.expectedForeignAmount);
 				ECKey refundKey = ECKey.fromPrivate(tradeBotData.getTradePrivateKey());
-				List<TransactionOutput> fundingOutputs = digibyte.getUnspentOutputs(p2shAddressA);
+				List<TransactionOutput> fundingOutputs = digibyte.getUnspentOutputs(p2shAddressA, false);
 
 				// Determine receive address for refund
 				String receiveAddress = digibyte.getUnusedReceiveAddress(tradeBotData.getForeignKey());

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

@@ -7,6 +7,7 @@ import org.bitcoinj.script.Script.ScriptType;
 import org.qortal.account.PrivateKeyAccount;
 import org.qortal.account.PublicKeyAccount;
 import org.qortal.api.model.crosschain.TradeBotCreateRequest;
+import org.qortal.api.resource.CrossChainUtils;
 import org.qortal.asset.Asset;
 import org.qortal.crosschain.*;
 import org.qortal.crypto.Crypto;
@@ -313,7 +314,7 @@ public class DogecoinACCTv1TradeBot implements AcctTradeBot {
 		}
 
 		// Attempt to send MESSAGE to Bob's Qortal trade address
-		byte[] messageData = DogecoinACCTv1.buildOfferMessage(tradeBotData.getTradeForeignPublicKeyHash(), tradeBotData.getHashOfSecret(), tradeBotData.getLockTimeA());
+		byte[] messageData = CrossChainUtils.buildOfferMessage(tradeBotData.getTradeForeignPublicKeyHash(), tradeBotData.getHashOfSecret(), tradeBotData.getLockTimeA());
 		String messageRecipient = crossChainTradeData.qortalCreatorTradeAddress;
 
 		boolean isMessageAlreadySent = repository.getMessageRepository().exists(tradeBotData.getTradeNativePublicKey(), messageRecipient, messageData);
@@ -793,7 +794,7 @@ public class DogecoinACCTv1TradeBot implements AcctTradeBot {
 			case FUNDED: {
 				Coin redeemAmount = Coin.valueOf(crossChainTradeData.expectedForeignAmount);
 				ECKey redeemKey = ECKey.fromPrivate(tradeBotData.getTradePrivateKey());
-				List<TransactionOutput> fundingOutputs = dogecoin.getUnspentOutputs(p2shAddressA);
+				List<TransactionOutput> fundingOutputs = dogecoin.getUnspentOutputs(p2shAddressA, false);
 
 				Transaction p2shRedeemTransaction = BitcoinyHTLC.buildRedeemTransaction(dogecoin.getNetworkParameters(), redeemAmount, redeemKey,
 						fundingOutputs, redeemScriptA, secretA, receivingAccountInfo);
@@ -857,7 +858,7 @@ public class DogecoinACCTv1TradeBot implements AcctTradeBot {
 			case FUNDED:{
 				Coin refundAmount = Coin.valueOf(crossChainTradeData.expectedForeignAmount);
 				ECKey refundKey = ECKey.fromPrivate(tradeBotData.getTradePrivateKey());
-				List<TransactionOutput> fundingOutputs = dogecoin.getUnspentOutputs(p2shAddressA);
+				List<TransactionOutput> fundingOutputs = dogecoin.getUnspentOutputs(p2shAddressA, false);
 
 				// Determine receive address for refund
 				String receiveAddress = dogecoin.getUnusedReceiveAddress(tradeBotData.getForeignKey());

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

@@ -7,6 +7,7 @@ import org.bitcoinj.script.Script.ScriptType;
 import org.qortal.account.PrivateKeyAccount;
 import org.qortal.account.PublicKeyAccount;
 import org.qortal.api.model.crosschain.TradeBotCreateRequest;
+import org.qortal.api.resource.CrossChainUtils;
 import org.qortal.asset.Asset;
 import org.qortal.crosschain.*;
 import org.qortal.crypto.Crypto;
@@ -30,11 +31,9 @@ import org.qortal.utils.NTP;
 
 import java.util.Arrays;
 import java.util.List;
-import java.util.Map;
 import java.util.stream.Collectors;
 
-import static java.util.Arrays.stream;
-import static java.util.stream.Collectors.toMap;
+import org.qortal.controller.tradebot.TradeStates.State;
 
 /**
  * Performing cross-chain trading steps on behalf of user.
@@ -50,45 +49,6 @@ public class DogecoinACCTv3TradeBot implements AcctTradeBot {
 
 	private static final Logger LOGGER = LogManager.getLogger(DogecoinACCTv3TradeBot.class);
 
-	public enum State implements TradeBot.StateNameAndValueSupplier {
-		BOB_WAITING_FOR_AT_CONFIRM(10, false, false),
-		BOB_WAITING_FOR_MESSAGE(15, true, true),
-		BOB_WAITING_FOR_AT_REDEEM(25, true, true),
-		BOB_DONE(30, false, false),
-		BOB_REFUNDED(35, false, false),
-
-		ALICE_WAITING_FOR_AT_LOCK(85, true, true),
-		ALICE_DONE(95, false, false),
-		ALICE_REFUNDING_A(105, true, true),
-		ALICE_REFUNDED(110, false, false);
-
-		private static final Map<Integer, State> map = stream(State.values()).collect(toMap(state -> state.value, state -> state));
-
-		public final int value;
-		public final boolean requiresAtData;
-		public final boolean requiresTradeData;
-
-		State(int value, boolean requiresAtData, boolean requiresTradeData) {
-			this.value = value;
-			this.requiresAtData = requiresAtData;
-			this.requiresTradeData = requiresTradeData;
-		}
-
-		public static State valueOf(int value) {
-			return map.get(value);
-		}
-
-		@Override
-		public String getState() {
-			return this.name();
-		}
-
-		@Override
-		public int getStateValue() {
-			return this.value;
-		}
-	}
-
 	/** Maximum time Bob waits for his AT creation transaction to be confirmed into a block. (milliseconds) */
 	private static final long MAX_AT_CONFIRMATION_PERIOD = 24 * 60 * 60 * 1000L; // ms
 
@@ -313,7 +273,7 @@ public class DogecoinACCTv3TradeBot implements AcctTradeBot {
 		}
 
 		// Attempt to send MESSAGE to Bob's Qortal trade address
-		byte[] messageData = DogecoinACCTv3.buildOfferMessage(tradeBotData.getTradeForeignPublicKeyHash(), tradeBotData.getHashOfSecret(), tradeBotData.getLockTimeA());
+		byte[] messageData = CrossChainUtils.buildOfferMessage(tradeBotData.getTradeForeignPublicKeyHash(), tradeBotData.getHashOfSecret(), tradeBotData.getLockTimeA());
 		String messageRecipient = crossChainTradeData.qortalCreatorTradeAddress;
 
 		boolean isMessageAlreadySent = repository.getMessageRepository().exists(tradeBotData.getTradeNativePublicKey(), messageRecipient, messageData);
@@ -793,7 +753,7 @@ public class DogecoinACCTv3TradeBot implements AcctTradeBot {
 			case FUNDED: {
 				Coin redeemAmount = Coin.valueOf(crossChainTradeData.expectedForeignAmount);
 				ECKey redeemKey = ECKey.fromPrivate(tradeBotData.getTradePrivateKey());
-				List<TransactionOutput> fundingOutputs = dogecoin.getUnspentOutputs(p2shAddressA);
+				List<TransactionOutput> fundingOutputs = dogecoin.getUnspentOutputs(p2shAddressA, false);
 
 				Transaction p2shRedeemTransaction = BitcoinyHTLC.buildRedeemTransaction(dogecoin.getNetworkParameters(), redeemAmount, redeemKey,
 						fundingOutputs, redeemScriptA, secretA, receivingAccountInfo);
@@ -857,7 +817,7 @@ public class DogecoinACCTv3TradeBot implements AcctTradeBot {
 			case FUNDED:{
 				Coin refundAmount = Coin.valueOf(crossChainTradeData.expectedForeignAmount);
 				ECKey refundKey = ECKey.fromPrivate(tradeBotData.getTradePrivateKey());
-				List<TransactionOutput> fundingOutputs = dogecoin.getUnspentOutputs(p2shAddressA);
+				List<TransactionOutput> fundingOutputs = dogecoin.getUnspentOutputs(p2shAddressA, false);
 
 				// Determine receive address for refund
 				String receiveAddress = dogecoin.getUnusedReceiveAddress(tradeBotData.getForeignKey());

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

@@ -7,6 +7,7 @@ import org.bitcoinj.script.Script.ScriptType;
 import org.qortal.account.PrivateKeyAccount;
 import org.qortal.account.PublicKeyAccount;
 import org.qortal.api.model.crosschain.TradeBotCreateRequest;
+import org.qortal.api.resource.CrossChainUtils;
 import org.qortal.asset.Asset;
 import org.qortal.crosschain.*;
 import org.qortal.crypto.Crypto;
@@ -312,7 +313,7 @@ public class LitecoinACCTv1TradeBot implements AcctTradeBot {
 		}
 
 		// Attempt to send MESSAGE to Bob's Qortal trade address
-		byte[] messageData = LitecoinACCTv1.buildOfferMessage(tradeBotData.getTradeForeignPublicKeyHash(), tradeBotData.getHashOfSecret(), tradeBotData.getLockTimeA());
+		byte[] messageData = CrossChainUtils.buildOfferMessage(tradeBotData.getTradeForeignPublicKeyHash(), tradeBotData.getHashOfSecret(), tradeBotData.getLockTimeA());
 		String messageRecipient = crossChainTradeData.qortalCreatorTradeAddress;
 
 		boolean isMessageAlreadySent = repository.getMessageRepository().exists(tradeBotData.getTradeNativePublicKey(), messageRecipient, messageData);
@@ -756,7 +757,7 @@ public class LitecoinACCTv1TradeBot implements AcctTradeBot {
 			case FUNDED: {
 				Coin redeemAmount = Coin.valueOf(crossChainTradeData.expectedForeignAmount);
 				ECKey redeemKey = ECKey.fromPrivate(tradeBotData.getTradePrivateKey());
-				List<TransactionOutput> fundingOutputs = litecoin.getUnspentOutputs(p2shAddressA);
+				List<TransactionOutput> fundingOutputs = litecoin.getUnspentOutputs(p2shAddressA, false);
 
 				Transaction p2shRedeemTransaction = BitcoinyHTLC.buildRedeemTransaction(litecoin.getNetworkParameters(), redeemAmount, redeemKey,
 						fundingOutputs, redeemScriptA, secretA, receivingAccountInfo);
@@ -820,7 +821,7 @@ public class LitecoinACCTv1TradeBot implements AcctTradeBot {
 			case FUNDED:{
 				Coin refundAmount = Coin.valueOf(crossChainTradeData.expectedForeignAmount);
 				ECKey refundKey = ECKey.fromPrivate(tradeBotData.getTradePrivateKey());
-				List<TransactionOutput> fundingOutputs = litecoin.getUnspentOutputs(p2shAddressA);
+				List<TransactionOutput> fundingOutputs = litecoin.getUnspentOutputs(p2shAddressA, false);
 
 				// Determine receive address for refund
 				String receiveAddress = litecoin.getUnusedReceiveAddress(tradeBotData.getForeignKey());

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

@@ -7,6 +7,7 @@ import org.bitcoinj.script.Script.ScriptType;
 import org.qortal.account.PrivateKeyAccount;
 import org.qortal.account.PublicKeyAccount;
 import org.qortal.api.model.crosschain.TradeBotCreateRequest;
+import org.qortal.api.resource.CrossChainUtils;
 import org.qortal.asset.Asset;
 import org.qortal.crosschain.*;
 import org.qortal.crypto.Crypto;
@@ -30,12 +31,9 @@ import org.qortal.utils.NTP;
 
 import java.util.Arrays;
 import java.util.List;
-import java.util.Map;
 import java.util.stream.Collectors;
 
-import static java.util.Arrays.stream;
-import static java.util.stream.Collectors.toMap;
-
+import org.qortal.controller.tradebot.TradeStates.State;
 /**
  * Performing cross-chain trading steps on behalf of user.
  * <p>
@@ -50,45 +48,6 @@ public class LitecoinACCTv3TradeBot implements AcctTradeBot {
 
 	private static final Logger LOGGER = LogManager.getLogger(LitecoinACCTv3TradeBot.class);
 
-	public enum State implements TradeBot.StateNameAndValueSupplier {
-		BOB_WAITING_FOR_AT_CONFIRM(10, false, false),
-		BOB_WAITING_FOR_MESSAGE(15, true, true),
-		BOB_WAITING_FOR_AT_REDEEM(25, true, true),
-		BOB_DONE(30, false, false),
-		BOB_REFUNDED(35, false, false),
-
-		ALICE_WAITING_FOR_AT_LOCK(85, true, true),
-		ALICE_DONE(95, false, false),
-		ALICE_REFUNDING_A(105, true, true),
-		ALICE_REFUNDED(110, false, false);
-
-		private static final Map<Integer, State> map = stream(State.values()).collect(toMap(state -> state.value, state -> state));
-
-		public final int value;
-		public final boolean requiresAtData;
-		public final boolean requiresTradeData;
-
-		State(int value, boolean requiresAtData, boolean requiresTradeData) {
-			this.value = value;
-			this.requiresAtData = requiresAtData;
-			this.requiresTradeData = requiresTradeData;
-		}
-
-		public static State valueOf(int value) {
-			return map.get(value);
-		}
-
-		@Override
-		public String getState() {
-			return this.name();
-		}
-
-		@Override
-		public int getStateValue() {
-			return this.value;
-		}
-	}
-
 	/** Maximum time Bob waits for his AT creation transaction to be confirmed into a block. (milliseconds) */
 	private static final long MAX_AT_CONFIRMATION_PERIOD = 24 * 60 * 60 * 1000L; // ms
 
@@ -313,7 +272,7 @@ public class LitecoinACCTv3TradeBot implements AcctTradeBot {
 		}
 
 		// Attempt to send MESSAGE to Bob's Qortal trade address
-		byte[] messageData = LitecoinACCTv3.buildOfferMessage(tradeBotData.getTradeForeignPublicKeyHash(), tradeBotData.getHashOfSecret(), tradeBotData.getLockTimeA());
+		byte[] messageData = CrossChainUtils.buildOfferMessage(tradeBotData.getTradeForeignPublicKeyHash(), tradeBotData.getHashOfSecret(), tradeBotData.getLockTimeA());
 		String messageRecipient = crossChainTradeData.qortalCreatorTradeAddress;
 
 		boolean isMessageAlreadySent = repository.getMessageRepository().exists(tradeBotData.getTradeNativePublicKey(), messageRecipient, messageData);
@@ -793,7 +752,7 @@ public class LitecoinACCTv3TradeBot implements AcctTradeBot {
 			case FUNDED: {
 				Coin redeemAmount = Coin.valueOf(crossChainTradeData.expectedForeignAmount);
 				ECKey redeemKey = ECKey.fromPrivate(tradeBotData.getTradePrivateKey());
-				List<TransactionOutput> fundingOutputs = litecoin.getUnspentOutputs(p2shAddressA);
+				List<TransactionOutput> fundingOutputs = litecoin.getUnspentOutputs(p2shAddressA, false);
 
 				Transaction p2shRedeemTransaction = BitcoinyHTLC.buildRedeemTransaction(litecoin.getNetworkParameters(), redeemAmount, redeemKey,
 						fundingOutputs, redeemScriptA, secretA, receivingAccountInfo);
@@ -857,7 +816,7 @@ public class LitecoinACCTv3TradeBot implements AcctTradeBot {
 			case FUNDED:{
 				Coin refundAmount = Coin.valueOf(crossChainTradeData.expectedForeignAmount);
 				ECKey refundKey = ECKey.fromPrivate(tradeBotData.getTradePrivateKey());
-				List<TransactionOutput> fundingOutputs = litecoin.getUnspentOutputs(p2shAddressA);
+				List<TransactionOutput> fundingOutputs = litecoin.getUnspentOutputs(p2shAddressA, false);
 
 				// Determine receive address for refund
 				String receiveAddress = litecoin.getUnusedReceiveAddress(tradeBotData.getForeignKey());

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

@@ -9,6 +9,7 @@ import org.bitcoinj.core.Coin;
 import org.qortal.account.PrivateKeyAccount;
 import org.qortal.account.PublicKeyAccount;
 import org.qortal.api.model.crosschain.TradeBotCreateRequest;
+import org.qortal.api.resource.CrossChainUtils;
 import org.qortal.asset.Asset;
 import org.qortal.crosschain.*;
 import org.qortal.crypto.Crypto;
@@ -32,11 +33,9 @@ import org.qortal.utils.NTP;
 
 import java.util.Arrays;
 import java.util.List;
-import java.util.Map;
 import java.util.stream.Collectors;
 
-import static java.util.Arrays.stream;
-import static java.util.stream.Collectors.toMap;
+import org.qortal.controller.tradebot.TradeStates.State;
 
 /**
  * Performing cross-chain trading steps on behalf of user.
@@ -52,45 +51,6 @@ public class PirateChainACCTv3TradeBot implements AcctTradeBot {
 
 	private static final Logger LOGGER = LogManager.getLogger(PirateChainACCTv3TradeBot.class);
 
-	public enum State implements TradeBot.StateNameAndValueSupplier {
-		BOB_WAITING_FOR_AT_CONFIRM(10, false, false),
-		BOB_WAITING_FOR_MESSAGE(15, true, true),
-		BOB_WAITING_FOR_AT_REDEEM(25, true, true),
-		BOB_DONE(30, false, false),
-		BOB_REFUNDED(35, false, false),
-
-		ALICE_WAITING_FOR_AT_LOCK(85, true, true),
-		ALICE_DONE(95, false, false),
-		ALICE_REFUNDING_A(105, true, true),
-		ALICE_REFUNDED(110, false, false);
-
-		private static final Map<Integer, State> map = stream(State.values()).collect(toMap(state -> state.value, state -> state));
-
-		public final int value;
-		public final boolean requiresAtData;
-		public final boolean requiresTradeData;
-
-		State(int value, boolean requiresAtData, boolean requiresTradeData) {
-			this.value = value;
-			this.requiresAtData = requiresAtData;
-			this.requiresTradeData = requiresTradeData;
-		}
-
-		public static State valueOf(int value) {
-			return map.get(value);
-		}
-
-		@Override
-		public String getState() {
-			return this.name();
-		}
-
-		@Override
-		public int getStateValue() {
-			return this.value;
-		}
-	}
-
 	/** Maximum time Bob waits for his AT creation transaction to be confirmed into a block. (milliseconds) */
 	private static final long MAX_AT_CONFIRMATION_PERIOD = 24 * 60 * 60 * 1000L; // ms
 
@@ -317,7 +277,7 @@ public class PirateChainACCTv3TradeBot implements AcctTradeBot {
 		}
 
 		// Attempt to send MESSAGE to Bob's Qortal trade address
-		byte[] messageData = PirateChainACCTv3.buildOfferMessage(tradeBotData.getTradeForeignPublicKey(), tradeBotData.getHashOfSecret(), tradeBotData.getLockTimeA());
+		byte[] messageData = CrossChainUtils.buildOfferMessage(tradeBotData.getTradeForeignPublicKey(), tradeBotData.getHashOfSecret(), tradeBotData.getLockTimeA());
 		String messageRecipient = crossChainTradeData.qortalCreatorTradeAddress;
 
 		boolean isMessageAlreadySent = repository.getMessageRepository().exists(tradeBotData.getTradeNativePublicKey(), messageRecipient, messageData);

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

@@ -7,6 +7,7 @@ import org.bitcoinj.script.Script.ScriptType;
 import org.qortal.account.PrivateKeyAccount;
 import org.qortal.account.PublicKeyAccount;
 import org.qortal.api.model.crosschain.TradeBotCreateRequest;
+import org.qortal.api.resource.CrossChainUtils;
 import org.qortal.asset.Asset;
 import org.qortal.crosschain.*;
 import org.qortal.crypto.Crypto;
@@ -30,11 +31,9 @@ import org.qortal.utils.NTP;
 
 import java.util.Arrays;
 import java.util.List;
-import java.util.Map;
 import java.util.stream.Collectors;
 
-import static java.util.Arrays.stream;
-import static java.util.stream.Collectors.toMap;
+import org.qortal.controller.tradebot.TradeStates.State;
 
 /**
  * Performing cross-chain trading steps on behalf of user.
@@ -50,45 +49,6 @@ public class RavencoinACCTv3TradeBot implements AcctTradeBot {
 
 	private static final Logger LOGGER = LogManager.getLogger(RavencoinACCTv3TradeBot.class);
 
-	public enum State implements TradeBot.StateNameAndValueSupplier {
-		BOB_WAITING_FOR_AT_CONFIRM(10, false, false),
-		BOB_WAITING_FOR_MESSAGE(15, true, true),
-		BOB_WAITING_FOR_AT_REDEEM(25, true, true),
-		BOB_DONE(30, false, false),
-		BOB_REFUNDED(35, false, false),
-
-		ALICE_WAITING_FOR_AT_LOCK(85, true, true),
-		ALICE_DONE(95, false, false),
-		ALICE_REFUNDING_A(105, true, true),
-		ALICE_REFUNDED(110, false, false);
-
-		private static final Map<Integer, State> map = stream(State.values()).collect(toMap(state -> state.value, state -> state));
-
-		public final int value;
-		public final boolean requiresAtData;
-		public final boolean requiresTradeData;
-
-		State(int value, boolean requiresAtData, boolean requiresTradeData) {
-			this.value = value;
-			this.requiresAtData = requiresAtData;
-			this.requiresTradeData = requiresTradeData;
-		}
-
-		public static State valueOf(int value) {
-			return map.get(value);
-		}
-
-		@Override
-		public String getState() {
-			return this.name();
-		}
-
-		@Override
-		public int getStateValue() {
-			return this.value;
-		}
-	}
-
 	/** Maximum time Bob waits for his AT creation transaction to be confirmed into a block. (milliseconds) */
 	private static final long MAX_AT_CONFIRMATION_PERIOD = 24 * 60 * 60 * 1000L; // ms
 
@@ -313,7 +273,7 @@ public class RavencoinACCTv3TradeBot implements AcctTradeBot {
 		}
 
 		// Attempt to send MESSAGE to Bob's Qortal trade address
-		byte[] messageData = RavencoinACCTv3.buildOfferMessage(tradeBotData.getTradeForeignPublicKeyHash(), tradeBotData.getHashOfSecret(), tradeBotData.getLockTimeA());
+		byte[] messageData = CrossChainUtils.buildOfferMessage(tradeBotData.getTradeForeignPublicKeyHash(), tradeBotData.getHashOfSecret(), tradeBotData.getLockTimeA());
 		String messageRecipient = crossChainTradeData.qortalCreatorTradeAddress;
 
 		boolean isMessageAlreadySent = repository.getMessageRepository().exists(tradeBotData.getTradeNativePublicKey(), messageRecipient, messageData);
@@ -793,7 +753,7 @@ public class RavencoinACCTv3TradeBot implements AcctTradeBot {
 			case FUNDED: {
 				Coin redeemAmount = Coin.valueOf(crossChainTradeData.expectedForeignAmount);
 				ECKey redeemKey = ECKey.fromPrivate(tradeBotData.getTradePrivateKey());
-				List<TransactionOutput> fundingOutputs = ravencoin.getUnspentOutputs(p2shAddressA);
+				List<TransactionOutput> fundingOutputs = ravencoin.getUnspentOutputs(p2shAddressA, false);
 
 				Transaction p2shRedeemTransaction = BitcoinyHTLC.buildRedeemTransaction(ravencoin.getNetworkParameters(), redeemAmount, redeemKey,
 						fundingOutputs, redeemScriptA, secretA, receivingAccountInfo);
@@ -857,7 +817,7 @@ public class RavencoinACCTv3TradeBot implements AcctTradeBot {
 			case FUNDED:{
 				Coin refundAmount = Coin.valueOf(crossChainTradeData.expectedForeignAmount);
 				ECKey refundKey = ECKey.fromPrivate(tradeBotData.getTradePrivateKey());
-				List<TransactionOutput> fundingOutputs = ravencoin.getUnspentOutputs(p2shAddressA);
+				List<TransactionOutput> fundingOutputs = ravencoin.getUnspentOutputs(p2shAddressA, false);
 
 				// Determine receive address for refund
 				String receiveAddress = ravencoin.getUnusedReceiveAddress(tradeBotData.getForeignKey());

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

@@ -215,6 +215,41 @@ public class TradeBot implements Listener {
 		return acctTradeBot.startResponse(repository, atData, acct, crossChainTradeData, foreignKey, receivingAddress);
 	}
 
+	/**
+	 * Creates a trade-bot entries from the 'Alice' viewpoint,
+	 * i.e. matching foreign blockchain currency to existing QORT offers.
+	 * <p>
+	 * Requires chosen trade offers from Bob, passed by <tt>crossChainTradeData</tt>
+	 * and access to a foreign blockchain wallet via <tt>foreignKey</tt>.
+	 * <p>
+	 * @param repository
+	 * @param crossChainTradeDataList chosen trade OFFERs that Alice wants to match
+	 * @param receiveAddress Alice's Qortal address to receive her QORT
+	 * @param foreignKey foreign blockchain wallet key
+	 * @param bitcoiny
+	 * @throws DataException
+	 */
+	public ResponseResult startResponseMultiple(
+			Repository repository,
+			ACCT acct,
+			List<CrossChainTradeData> crossChainTradeDataList,
+			String receiveAddress,
+			String foreignKey,
+			Bitcoiny bitcoiny) throws DataException {
+		AcctTradeBot acctTradeBot = findTradeBotForAcct(acct);
+		if (acctTradeBot == null) {
+			LOGGER.debug(() -> String.format("Couldn't find ACCT trade-bot for %s", acct.getBlockchain()));
+			return ResponseResult.NETWORK_ISSUE;
+		}
+
+		for( CrossChainTradeData tradeData : crossChainTradeDataList) {
+			// Check Alice doesn't already have an existing, on-going trade-bot entry for this AT.
+			if (repository.getCrossChainRepository().existsTradeWithAtExcludingStates(tradeData.qortalAtAddress, acctTradeBot.getEndStates()))
+				return ResponseResult.TRADE_ALREADY_EXISTS;
+		}
+		return TradeBotUtils.startResponseMultiple(repository, acct, crossChainTradeDataList, receiveAddress, foreignKey, bitcoiny);
+	}
+
 	public boolean deleteEntry(Repository repository, byte[] tradePrivateKey) throws DataException {
 		TradeBotData tradeBotData = repository.getCrossChainRepository().getTradeBotData(tradePrivateKey);
 		if (tradeBotData == null)
@@ -724,8 +759,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/controller/tradebot/TradeBotUtils.java

@@ -0,0 +1,217 @@
+package org.qortal.controller.tradebot;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.bitcoinj.core.Transaction;
+import org.qortal.account.PrivateKeyAccount;
+import org.qortal.api.resource.CrossChainUtils;
+import org.qortal.crosschain.ACCT;
+import org.qortal.crosschain.Bitcoiny;
+import org.qortal.crosschain.BitcoinyHTLC;
+import org.qortal.crosschain.ForeignBlockchainException;
+import org.qortal.crypto.Crypto;
+import org.qortal.data.crosschain.CrossChainTradeData;
+import org.qortal.data.crosschain.TradeBotData;
+import org.qortal.data.transaction.MessageTransactionData;
+import org.qortal.group.Group;
+import org.qortal.repository.DataException;
+import org.qortal.repository.Repository;
+import org.qortal.repository.RepositoryManager;
+import org.qortal.transaction.MessageTransaction;
+import org.qortal.utils.Base58;
+import org.qortal.utils.NTP;
+import org.qortal.transaction.Transaction.ValidationResult;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.qortal.controller.tradebot.TradeStates.State;
+
+public class TradeBotUtils {
+
+    private static final Logger LOGGER = LogManager.getLogger(TradeBotUtils.class);
+    /**
+     * Creates trade-bot entries from the 'Alice' viewpoint, i.e. matching Bitcoiny coin to existing offers.
+     * <p>
+     * Requires chosen trade offers from Bob, passed by <tt>crossChainTradeData</tt>
+     * and access to a Blockchain wallet via <tt>foreignKey</tt>.
+     * <p>
+     * The <tt>crossChainTradeData</tt> contains the current trade offers state
+     * as extracted from the AT's data segment.
+     * <p>
+     * Access to a funded wallet is via a Blockchain BIP32 hierarchical deterministic key,
+     * passed via <tt>foreignKey</tt>.
+     * <b>This key will be stored in your node's database</b>
+     * to allow trade-bot to create/fund the necessary P2SH transactions!
+     * However, due to the nature of BIP32 keys, it is possible to give the trade-bot
+     * only a subset of wallet access (see BIP32 for more details).
+     * <p>
+     * As an example, the foreignKey can be extract from a <i>legacy, password-less</i>
+     * Electrum wallet by going to the console tab and entering:<br>
+     * <tt>wallet.keystore.xprv</tt><br>
+     * which should result in a base58 string starting with either 'xprv' (for Blockchain main-net)
+     * or 'tprv' for (Blockchain test-net).
+     * <p>
+     * It is envisaged that the value in <tt>foreignKey</tt> will actually come from a Qortal-UI-managed wallet.
+     * <p>
+     * If sufficient funds are available, <b>this method will actually fund the P2SH-A</b>
+     * with the Blockchain amount expected by 'Bob'.
+     * <p>
+     * If the Blockchain transaction is successfully broadcast to the network then
+     * we also send a MESSAGE to Bob's trade-bot to let them know; one message for each trade.
+     * <p>
+     * The trade-bot entries are saved to the repository and the cross-chain trading process commences.
+     * <p>
+     *
+     * @param repository for backing up the trade bot data
+     * @param crossChainTradeDataList chosen trade OFFERs that Alice wants to match
+     * @param receiveAddress Alice's Qortal address
+     * @param foreignKey              funded wallet xprv in base58
+     * @param bitcoiny the bitcoiny chain to match the sell offer with
+     * @return true if P2SH-A funding transaction successfully broadcast to Blockchain network, false otherwise
+     * @throws DataException
+     */
+    public static AcctTradeBot.ResponseResult startResponseMultiple(
+            Repository repository,
+            ACCT acct,
+            List<CrossChainTradeData> crossChainTradeDataList,
+            String receiveAddress,
+            String foreignKey,
+            Bitcoiny bitcoiny) throws DataException {
+
+        // Check we have enough funds via foreignKey to fund P2SH to cover expectedForeignAmount
+        long now = NTP.getTime();
+        long p2shFee;
+        try {
+            p2shFee = bitcoiny.getP2shFee(now);
+        } catch (ForeignBlockchainException e) {
+            LOGGER.debug("Couldn't estimate blockchain transaction fees?");
+            return AcctTradeBot.ResponseResult.NETWORK_ISSUE;
+        }
+
+        Map<String, Long> valueByP2shAddress = new HashMap<>(crossChainTradeDataList.size());
+
+        class DataCombiner{
+            CrossChainTradeData crossChainTradeData;
+            TradeBotData tradeBotData;
+            String p2shAddress;
+
+            public DataCombiner(CrossChainTradeData crossChainTradeData, TradeBotData tradeBotData, String p2shAddress) {
+                this.crossChainTradeData = crossChainTradeData;
+                this.tradeBotData = tradeBotData;
+                this.p2shAddress = p2shAddress;
+            }
+        }
+
+        List<DataCombiner> dataToProcess = new ArrayList<>();
+
+        for(CrossChainTradeData crossChainTradeData : crossChainTradeDataList) {
+            byte[] tradePrivateKey = TradeBot.generateTradePrivateKey();
+            byte[] secretA = TradeBot.generateSecret();
+            byte[] hashOfSecretA = Crypto.hash160(secretA);
+
+            byte[] tradeNativePublicKey = TradeBot.deriveTradeNativePublicKey(tradePrivateKey);
+            byte[] tradeNativePublicKeyHash = Crypto.hash160(tradeNativePublicKey);
+            String tradeNativeAddress = Crypto.toAddress(tradeNativePublicKey);
+
+            byte[] tradeForeignPublicKey = TradeBot.deriveTradeForeignPublicKey(tradePrivateKey);
+            byte[] tradeForeignPublicKeyHash = Crypto.hash160(tradeForeignPublicKey);
+            // We need to generate lockTime-A: add tradeTimeout to now
+            int lockTimeA = (crossChainTradeData.tradeTimeout * 60) + (int) (now / 1000L);
+            byte[] receivingPublicKeyHash = Base58.decode(receiveAddress); // Actually the whole address, not just PKH
+
+            TradeBotData tradeBotData = new TradeBotData(tradePrivateKey, acct.getClass().getSimpleName(),
+                    State.ALICE_WAITING_FOR_AT_LOCK.name(), State.ALICE_WAITING_FOR_AT_LOCK.value,
+                    receiveAddress,
+                    crossChainTradeData.qortalAtAddress,
+                    now,
+                    crossChainTradeData.qortAmount,
+                    tradeNativePublicKey, tradeNativePublicKeyHash, tradeNativeAddress,
+                    secretA, hashOfSecretA,
+                    crossChainTradeData.foreignBlockchain,
+                    tradeForeignPublicKey, tradeForeignPublicKeyHash,
+                    crossChainTradeData.expectedForeignAmount,
+                    foreignKey, null, lockTimeA, receivingPublicKeyHash);
+
+            // Attempt to backup the trade bot data
+            // Include tradeBotData as an additional parameter, since it's not in the repository yet
+            TradeBot.backupTradeBotData(repository, Arrays.asList(tradeBotData));
+
+            // Fee for redeem/refund is subtracted from P2SH-A balance.
+            // Do not include fee for funding transaction as this is covered by buildSpend()
+            long amountA = crossChainTradeData.expectedForeignAmount + p2shFee /*redeeming/refunding P2SH-A*/;
+
+            // P2SH-A to be funded
+            byte[] redeemScriptBytes = BitcoinyHTLC.buildScript(tradeForeignPublicKeyHash, lockTimeA, crossChainTradeData.creatorForeignPKH, hashOfSecretA);
+            String p2shAddress = bitcoiny.deriveP2shAddress(redeemScriptBytes);
+
+            valueByP2shAddress.put(p2shAddress, amountA);
+
+            dataToProcess.add(new DataCombiner(crossChainTradeData, tradeBotData, p2shAddress));
+        }
+
+        // Build transaction for funding P2SH-A
+        Transaction p2shFundingTransaction = bitcoiny.buildSpendMultiple(foreignKey, valueByP2shAddress, null);
+        if (p2shFundingTransaction == null) {
+            LOGGER.debug("Unable to build P2SH-A funding transaction - lack of funds?");
+            return AcctTradeBot.ResponseResult.BALANCE_ISSUE;
+        }
+
+        try {
+            bitcoiny.broadcastTransaction(p2shFundingTransaction);
+        } catch (ForeignBlockchainException e) {
+            // We couldn't fund P2SH-A at this time
+            LOGGER.debug("Couldn't broadcast P2SH-A funding transaction?");
+            return AcctTradeBot.ResponseResult.NETWORK_ISSUE;
+        }
+
+        for(DataCombiner datumToProcess : dataToProcess ) {
+            // Attempt to send MESSAGE to Bob's Qortal trade address
+            TradeBotData tradeBotData = datumToProcess.tradeBotData;
+
+            byte[] messageData = CrossChainUtils.buildOfferMessage(tradeBotData.getTradeForeignPublicKeyHash(), tradeBotData.getHashOfSecret(), tradeBotData.getLockTimeA());
+            CrossChainTradeData crossChainTradeData = datumToProcess.crossChainTradeData;
+            String messageRecipient = crossChainTradeData.qortalCreatorTradeAddress;
+
+            boolean isMessageAlreadySent = repository.getMessageRepository().exists(tradeBotData.getTradeNativePublicKey(), messageRecipient, messageData);
+            if (!isMessageAlreadySent) {
+                // Do this in a new thread so caller doesn't have to wait for computeNonce()
+                // In the unlikely event that the transaction doesn't validate then the buy won't happen and eventually Alice's AT will be refunded
+                new Thread(() -> {
+                    try (final Repository threadsRepository = RepositoryManager.getRepository()) {
+                        PrivateKeyAccount sender = new PrivateKeyAccount(threadsRepository, tradeBotData.getTradePrivateKey());
+                        MessageTransaction messageTransaction = MessageTransaction.build(threadsRepository, sender, Group.NO_GROUP, messageRecipient, messageData, false, false);
+
+                        LOGGER.info("Computing nonce at difficulty {} for AT {} and recipient {}", messageTransaction.getPoWDifficulty(), tradeBotData.getAtAddress(), messageRecipient);
+                        messageTransaction.computeNonce();
+                        MessageTransactionData newMessageTransactionData = (MessageTransactionData) messageTransaction.getTransactionData();
+                        LOGGER.info("Computed nonce {} at difficulty {}", newMessageTransactionData.getNonce(), messageTransaction.getPoWDifficulty());
+                        messageTransaction.sign(sender);
+
+                        // reset repository state to prevent deadlock
+                        threadsRepository.discardChanges();
+
+                        if (messageTransaction.isSignatureValid()) {
+                            ValidationResult result = messageTransaction.importAsUnconfirmed();
+
+                            if (result != ValidationResult.OK) {
+                                LOGGER.warn(() -> String.format("Unable to send MESSAGE to Bob's trade-bot %s: %s", messageRecipient, result.name()));
+                            }
+                        } else {
+                            LOGGER.warn(() -> String.format("Unable to send MESSAGE to Bob's trade-bot %s: signature invalid", messageRecipient));
+                        }
+                    } catch (DataException e) {
+                        LOGGER.warn(() -> String.format("Unable to send MESSAGE to Bob's trade-bot %s: %s", messageRecipient, e.getMessage()));
+                    }
+                }, "TradeBot response").start();
+            }
+
+            TradeBot.updateTradeBotState(repository, tradeBotData, () -> String.format("Funding P2SH-A %s. Messaged Bob. Waiting for AT-lock", datumToProcess.p2shAddress));
+        }
+
+        return AcctTradeBot.ResponseResult.OK;
+    }
+}

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

@@ -0,0 +1,47 @@
+package org.qortal.controller.tradebot;
+
+import java.util.Map;
+
+import static java.util.Arrays.stream;
+import static java.util.stream.Collectors.toMap;
+
+public class TradeStates {
+    public enum State implements TradeBot.StateNameAndValueSupplier {
+        BOB_WAITING_FOR_AT_CONFIRM(10, false, false),
+        BOB_WAITING_FOR_MESSAGE(15, true, true),
+        BOB_WAITING_FOR_AT_REDEEM(25, true, true),
+        BOB_DONE(30, false, false),
+        BOB_REFUNDED(35, false, false),
+
+        ALICE_WAITING_FOR_AT_LOCK(85, true, true),
+        ALICE_DONE(95, false, false),
+        ALICE_REFUNDING_A(105, true, true),
+        ALICE_REFUNDED(110, false, false);
+
+        private static final Map<Integer, State> map = stream(State.values()).collect(toMap(state -> state.value, state -> state));
+
+        public final int value;
+        public final boolean requiresAtData;
+        public final boolean requiresTradeData;
+
+        State(int value, boolean requiresAtData, boolean requiresTradeData) {
+            this.value = value;
+            this.requiresAtData = requiresAtData;
+            this.requiresTradeData = requiresTradeData;
+        }
+
+        public static State valueOf(int value) {
+            return map.get(value);
+        }
+
+        @Override
+        public String getState() {
+            return this.name();
+        }
+
+        @Override
+        public int getStateValue() {
+            return this.value;
+        }
+    }
+}

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

@@ -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
@@ -113,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 {
@@ -179,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();
@@ -192,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()));
@@ -237,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/BitcoinACCTv1.java

@@ -802,12 +802,6 @@ public class BitcoinACCTv1 implements ACCT {
 		return tradeData;
 	}
 
-	/** Returns 'offer' MESSAGE payload for trade partner to send to AT creator's trade address. */
-	public static byte[] buildOfferMessage(byte[] partnerBitcoinPKH, byte[] hashOfSecretA, int lockTimeA) {
-		byte[] lockTimeABytes = BitTwiddling.toBEByteArray((long) lockTimeA);
-		return Bytes.concat(partnerBitcoinPKH, hashOfSecretA, lockTimeABytes);
-	}
-
 	/** Returns info extracted from 'offer' MESSAGE payload sent by trade partner to AT creator's trade address, or null if not valid. */
 	public static OfferMessageData extractOfferMessageData(byte[] messageData) {
 		if (messageData == null || messageData.length != OFFER_MESSAGE_LENGTH)

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

@@ -751,12 +751,6 @@ public class BitcoinACCTv3 implements ACCT {
 		return tradeData;
 	}
 
-	/** Returns 'offer' MESSAGE payload for trade partner to send to AT creator's trade address. */
-	public static byte[] buildOfferMessage(byte[] partnerBitcoinPKH, byte[] hashOfSecretA, int lockTimeA) {
-		byte[] lockTimeABytes = BitTwiddling.toBEByteArray((long) lockTimeA);
-		return Bytes.concat(partnerBitcoinPKH, hashOfSecretA, lockTimeABytes);
-	}
-
 	/** Returns info extracted from 'offer' MESSAGE payload sent by trade partner to AT creator's trade address, or null if not valid. */
 	public static OfferMessageData extractOfferMessageData(byte[] messageData) {
 		if (messageData == null || messageData.length != OFFER_MESSAGE_LENGTH)

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

@@ -53,12 +53,22 @@ 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;
+
+	/**
+	 * Blockchain Cache
+	 *
+	 * To store blockchain data and reduce redundant RPCs to the ElectrumX servers
+	 */
+	private final BlockchainCache blockchainCache = new BlockchainCache();
+
 	// 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();
 	}
@@ -167,7 +177,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. */
@@ -201,8 +215,8 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 	 * @throws ForeignBlockchainException if there was an error.
 	 */
 	// TODO: don't return bitcoinj-based objects like TransactionOutput, use BitcoinyTransaction.Output instead
-	public List<TransactionOutput> getUnspentOutputs(String base58Address) throws ForeignBlockchainException {
-		List<UnspentOutput> unspentOutputs = this.blockchainProvider.getUnspentOutputs(addressToScriptPubKey(base58Address), false);
+	public List<TransactionOutput> getUnspentOutputs(String base58Address, boolean includeUnconfirmed) throws ForeignBlockchainException {
+		List<UnspentOutput> unspentOutputs = this.blockchainProvider.getUnspentOutputs(addressToScriptPubKey(base58Address), includeUnconfirmed);
 
 		List<TransactionOutput> unspentTransactionOutputs = new ArrayList<>();
 		for (UnspentOutput unspentOutput : unspentOutputs) {
@@ -336,6 +350,45 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 		}
 	}
 
+	/**
+	 * Returns bitcoinj transaction sending the recipient's amount to each recipient given.
+	 *
+	 *
+	 * @param xprv58 the private master key
+	 * @param amountByRecipient each amount to send indexed by the recipient to send to
+	 * @param feePerByte the satoshis per byte
+	 *
+	 * @return the completed transaction, ready to broadcast
+	 */
+	public Transaction buildSpendMultiple(String xprv58, Map<String, Long> amountByRecipient, Long feePerByte) {
+		Context.propagate(bitcoinjContext);
+
+		Wallet wallet = Wallet.fromSpendingKeyB58(this.params, xprv58, DeterministicHierarchy.BIP32_STANDARDISATION_TIME_SECS);
+		wallet.setUTXOProvider(new WalletAwareUTXOProvider(this, wallet));
+
+		Transaction transaction = new Transaction(this.params);
+
+		for(Map.Entry<String, Long> amountForRecipient : amountByRecipient.entrySet()) {
+			Address destination = Address.fromString(this.params, amountForRecipient.getKey());
+			transaction.addOutput(Coin.valueOf(amountForRecipient.getValue()), destination);
+		}
+
+		SendRequest sendRequest = SendRequest.forTx(transaction);
+
+		if (feePerByte != null)
+			sendRequest.feePerKb = Coin.valueOf(feePerByte * 1000L); // Note: 1000 not 1024
+		else
+			// Allow override of default for TestNet3, etc.
+			sendRequest.feePerKb = this.getFeePerKb();
+
+		try {
+			wallet.completeTx(sendRequest);
+			return sendRequest.tx;
+		} catch (InsufficientMoneyException e) {
+			return null;
+		}
+	}
+
 	/**
 	 * Get Spending Candidate Addresses
 	 *
@@ -384,7 +437,7 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 		List<TransactionOutput> allUnspentOutputs = new ArrayList<>();
 		Set<String> walletAddresses = this.getWalletAddresses(key58);
 		for (String address : walletAddresses) {
-			allUnspentOutputs.addAll(this.getUnspentOutputs(address));
+			allUnspentOutputs.addAll(this.getUnspentOutputs(address, true));
 		}
 		for (TransactionOutput output : allUnspentOutputs) {
 			if (!output.isAvailableForSpending()) {
@@ -458,13 +511,27 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 					byte[] script = ScriptBuilder.createOutputScript(address).getProgram();
 
 					// Ask for transaction history - if it's empty then key has never been used
-					List<TransactionHash> historicTransactionHashes = this.getAddressTransactions(script, false);
+					List<TransactionHash> historicTransactionHashes = this.getAddressTransactions(script, true);
 
 					if (!historicTransactionHashes.isEmpty()) {
 						areAllKeysUnused = false;
 
-						for (TransactionHash transactionHash : historicTransactionHashes)
-							walletTransactions.add(this.getTransaction(transactionHash.txHash));
+						for (TransactionHash transactionHash : historicTransactionHashes) {
+
+							Optional<BitcoinyTransaction> walletTransaction
+									= this.blockchainCache.getTransactionByHash( transactionHash.txHash );
+
+							// if the wallet transaction is already cached
+							if(walletTransaction.isPresent() ) {
+								walletTransactions.add( walletTransaction.get() );
+							}
+							// otherwise get the transaction from the blockchain server
+							else {
+								BitcoinyTransaction transaction = getTransaction(transactionHash.txHash);
+								walletTransactions.add( transaction );
+								this.blockchainCache.addTransactionByHash(transactionHash.txHash, transaction);
+							}
+						}
 					}
 				}
 
@@ -556,17 +623,25 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 				for (; ki < keys.size(); ++ki) {
 					DeterministicKey dKey = keys.get(ki);
 
-					// Check for transactions
 					Address address = Address.fromKey(this.params, dKey, ScriptType.P2PKH);
 					keySet.add(address.toString());
-					byte[] script = ScriptBuilder.createOutputScript(address).getProgram();
 
-					// Ask for transaction history - if it's empty then key has never been used
-					List<TransactionHash> historicTransactionHashes = this.getAddressTransactions(script, false);
-
-					if (!historicTransactionHashes.isEmpty()) {
+					// if the key already has a verified transaction history
+					if( this.blockchainCache.keyHasHistory( dKey ) ){
 						areAllKeysUnused = false;
 					}
+					else {
+						// Check for transactions
+						byte[] script = ScriptBuilder.createOutputScript(address).getProgram();
+
+						// Ask for transaction history - if it's empty then key has never been used
+						List<TransactionHash> historicTransactionHashes = this.getAddressTransactions(script, true);
+
+						if (!historicTransactionHashes.isEmpty()) {
+							areAllKeysUnused = false;
+							this.blockchainCache.addKeyWithHistory(dKey);
+						}
+					}
 				}
 
 				if (areAllKeysUnused) {
@@ -621,19 +696,26 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 			do {
 				boolean areAllKeysUnused = true;
 
-				for (; ki < keys.size(); ++ki) {
+				for (; areAllKeysUnused && ki < keys.size(); ++ki) {
 					DeterministicKey dKey = keys.get(ki);
 
-					// Check for transactions
-					Address address = Address.fromKey(this.params, dKey, ScriptType.P2PKH);
-					byte[] script = ScriptBuilder.createOutputScript(address).getProgram();
-
-					// Ask for transaction history - if it's empty then key has never been used
-					List<TransactionHash> historicTransactionHashes = this.getAddressTransactions(script, false);
-
-					if (!historicTransactionHashes.isEmpty()) {
+					// if the key already has a verified transaction history
+					if( this.blockchainCache.keyHasHistory(dKey)) {
 						areAllKeysUnused = false;
 					}
+					else {
+						// Check for transactions
+						Address address = Address.fromKey(this.params, dKey, ScriptType.P2PKH);
+						byte[] script = ScriptBuilder.createOutputScript(address).getProgram();
+
+						// Ask for transaction history - if it's empty then key has never been used
+						List<TransactionHash> historicTransactionHashes = this.getAddressTransactions(script, true);
+
+						if (!historicTransactionHashes.isEmpty()) {
+							areAllKeysUnused = false;
+							this.blockchainCache.addKeyWithHistory(dKey);
+						}
+					}
 				}
 
 				if (areAllKeysUnused) {
@@ -750,13 +832,17 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 			Address address = Address.fromKey(this.params, keyChain.getKey(KeyChain.KeyPurpose.RECEIVE_FUNDS), ScriptType.P2PKH);
 
 			// if zero transactions, return address
-			if( 0 == getAddressTransactions(ScriptBuilder.createOutputScript(address).getProgram(), true).size() )
+			if(getAddressTransactions(ScriptBuilder.createOutputScript(address).getProgram(), true).isEmpty())
 				return address.toString();
 
 			// 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 {
@@ -792,7 +878,7 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 
 					List<UnspentOutput> unspentOutputs;
 					try {
-						unspentOutputs = this.bitcoiny.blockchainProvider.getUnspentOutputs(script, false);
+						unspentOutputs = this.bitcoiny.blockchainProvider.getUnspentOutputs(script, true);
 					} catch (ForeignBlockchainException e) {
 						throw new UTXOProviderException(String.format("Unable to fetch unspent outputs for %s", address));
 					}
@@ -882,7 +968,7 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 	}
 
 	private Long summingUnspentOutputs(String walletAddress) throws ForeignBlockchainException {
-		return this.getUnspentOutputs(walletAddress).stream()
+		return this.getUnspentOutputs(walletAddress, true).stream()
 				.map(TransactionOutput::getValue)
 				.mapToLong(Coin::longValue)
 				.sum();

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

@@ -3,12 +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);
@@ -67,4 +69,62 @@ public abstract class BitcoinyBlockchainProvider {
 	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/BitcoinyTBD.java

@@ -0,0 +1,151 @@
+package org.qortal.crosschain;
+
+import org.bitcoinj.core.Coin;
+import org.bitcoinj.core.Context;
+import org.bitcoinj.core.NetworkParameters;
+import org.qortal.api.model.crosschain.BitcoinyTBDRequest;
+import org.qortal.crosschain.ChainableServer.ConnectionType;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.EnumMap;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+public class BitcoinyTBD extends Bitcoiny {
+
+	private static HashMap<String, BitcoinyTBDRequest> requestsById = new HashMap<>();
+
+	private long minimumOrderAmount;
+
+	private static Map<String, BitcoinyTBD> instanceByCode = new HashMap<>();
+
+	private final NetTBD netTBD;
+
+	/**
+	 * Default ElectrumX Ports
+	 *
+	 * These are the defualts for all Bitcoin forks.
+	 */
+	private static final Map<ConnectionType, Integer> DEFAULT_ELECTRUMX_PORTS = new EnumMap<>(ConnectionType.class);
+	static {
+		DEFAULT_ELECTRUMX_PORTS.put(ConnectionType.TCP, 50001);
+		DEFAULT_ELECTRUMX_PORTS.put(ConnectionType.SSL, 50002);
+	}
+
+	/**
+	 * Constructor
+	 *
+	 * @param netTBD network access to the blockchain provider
+	 * @param blockchain blockchain provider
+	 * @param bitcoinjContext
+	 * @param currencyCode the trading symbol, ie LTC
+	 * @param minimumOrderAmount web search, LTC minimumOrderAmount = 1000000, 0.01 LTC minimum order to avoid dust errors
+	 * @param feePerKb web search, LTC feePerKb = 10000, 0.0001 LTC per 1000 bytes
+	 */
+	private BitcoinyTBD(
+			NetTBD netTBD,
+			BitcoinyBlockchainProvider blockchain,
+			Context bitcoinjContext,
+			String currencyCode,
+			long minimumOrderAmount,
+			long feePerKb) {
+
+		super(blockchain, bitcoinjContext, currencyCode, Coin.valueOf( feePerKb));
+
+		this.netTBD = netTBD;
+		this.minimumOrderAmount = minimumOrderAmount;
+
+		LOGGER.info(() -> String.format("Starting BitcoinyTBD support using %s", this.netTBD.getName()));
+	}
+
+	/**
+	 * Get Instance
+	 *
+	 * @param currencyCode the trading symbol, ie LTC
+	 *
+	 * @return the instance
+	 */
+	public static synchronized Optional<BitcoinyTBD> getInstance(String currencyCode) {
+
+		return Optional.ofNullable(instanceByCode.get(currencyCode));
+	}
+
+	/**
+	 * Build Instance
+	 *
+	 * @param bitcoinyTBDRequest
+	 * @param networkParams
+	 * @return the instance
+	 */
+	public static synchronized  BitcoinyTBD buildInstance(
+			BitcoinyTBDRequest bitcoinyTBDRequest,
+			NetworkParameters networkParams
+			) {
+
+		NetTBD netTBD
+				= new NetTBD(
+				bitcoinyTBDRequest.getNetworkName(),
+				bitcoinyTBDRequest.getFeeCeiling(),
+				networkParams,
+				Collections.emptyList(),
+				bitcoinyTBDRequest.getExpectedGenesisHash()
+		);
+
+		BitcoinyBlockchainProvider electrumX = new ElectrumX(netTBD.getName(), netTBD.getGenesisHash(), netTBD.getServers(), DEFAULT_ELECTRUMX_PORTS);
+		Context bitcoinjContext = new Context(netTBD.getParams());
+
+		BitcoinyTBD instance
+				= new BitcoinyTBD(
+						netTBD,
+						electrumX,
+						bitcoinjContext,
+						bitcoinyTBDRequest.getCurrencyCode(),
+						bitcoinyTBDRequest.getMinimumOrderAmount(),
+						bitcoinyTBDRequest.getFeePerKb());
+		electrumX.setBlockchain(instance);
+
+		instanceByCode.put(bitcoinyTBDRequest.getCurrencyCode(), instance);
+		requestsById.put(bitcoinyTBDRequest.getId(), bitcoinyTBDRequest);
+
+		return instance;
+	}
+
+	public static List<BitcoinyTBDRequest> getRequests() {
+
+		Collection<BitcoinyTBDRequest> requests = requestsById.values();
+
+		List<BitcoinyTBDRequest> list = new ArrayList<>( requests.size() );
+
+		list.addAll( requests );
+
+		return list;
+	}
+
+	@Override
+	public long getMinimumOrderAmount() {
+
+		return minimumOrderAmount;
+	}
+
+	@Override
+	public long getP2shFee(Long timestamp) throws ForeignBlockchainException {
+
+		return this.netTBD.getFeeCeiling();
+	}
+
+	@Override
+	public long getFeeCeiling() {
+
+		return this.netTBD.getFeeCeiling();
+	}
+
+	@Override
+	public void setFeeCeiling(long fee) {
+
+		this.netTBD.setFeeCeiling( fee );
+	}
+}

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

@@ -30,7 +30,7 @@ public class BitcoinyUTXOProvider implements UTXOProvider {
                 byte[] script = ScriptBuilder.createOutputScript(address).getProgram();
 
                 // collection UTXO's for all confirmed unspent outputs
-                for (UnspentOutput output : this.bitcoiny.blockchainProvider.getUnspentOutputs(script, false)) {
+                for (UnspentOutput output : this.bitcoiny.blockchainProvider.getUnspentOutputs(script, true)) {
                     utxos.add(toUTXO(output));
                 }
             }

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

@@ -0,0 +1,89 @@
+package org.qortal.crosschain;
+
+import org.bitcoinj.crypto.DeterministicKey;
+import org.qortal.settings.Settings;
+
+import java.util.Optional;
+import java.util.Queue;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentLinkedDeque;
+
+/**
+ * Class BlockchainCache
+ *
+ * Cache blockchain information to reduce redundant RPCs to the ElectrumX servers.
+ */
+public class BlockchainCache {
+
+    /**
+     * Keys With History
+     *
+     * Deterministic Keys with any transaction history.
+     */
+    private Queue<DeterministicKey> keysWithHistory = new ConcurrentLinkedDeque<>();
+
+    /**
+     * Transactions By Hash
+     *
+     * Transaction Hash -> Transaction
+     */
+    private ConcurrentHashMap<String, BitcoinyTransaction> transactionByHash = new ConcurrentHashMap<>();
+
+    /**
+     * Cache Limit
+     *
+     * If this limit is reached, the cache will be cleared or reduced.
+     */
+    private static final int CACHE_LIMIT = Settings.getInstance().getBlockchainCacheLimit();
+
+    /**
+     * Add Key With History
+     *
+     * @param key a deterministic key with a verified history
+     */
+    public void addKeyWithHistory(DeterministicKey key) {
+
+        if( this.keysWithHistory.size() > CACHE_LIMIT ) {
+            this.keysWithHistory.remove();
+        }
+
+        this.keysWithHistory.add(key);
+    }
+
+    /**
+     * Key Has History?
+     *
+     * @param key the deterministic key
+     *
+     * @return true if the key has a history, otherwise false
+     */
+    public boolean keyHasHistory( DeterministicKey key ) {
+        return this.keysWithHistory.contains(key);
+    }
+
+    /**
+     * Add Transaction By Hash
+     *
+     * @param hash the transaction hash
+     * @param transaction the transaction
+     */
+    public void addTransactionByHash( String hash, BitcoinyTransaction transaction ) {
+
+        if( this.transactionByHash.size() > CACHE_LIMIT ) {
+            this.transactionByHash.clear();
+        }
+
+        this.transactionByHash.put(hash, transaction);
+    }
+
+    /**
+     * Get Transaction By Hash
+     *
+     * @param hash the transaction hash
+     *
+     * @return the transaction, empty if the hash is not in the cache
+     */
+    public Optional<BitcoinyTransaction> getTransactionByHash( String hash ) {
+        return Optional.ofNullable( this.transactionByHash.get(hash) );
+    }
+}

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/DeterminedNetworkParams.java

@@ -0,0 +1,387 @@
+package org.qortal.crosschain;
+
+import org.apache.logging.log4j.LogManager;
+import org.bitcoinj.core.*;
+import org.bitcoinj.store.BlockStore;
+import org.bitcoinj.store.BlockStoreException;
+import org.bitcoinj.utils.MonetaryFormat;
+import org.bouncycastle.util.encoders.Hex;
+import org.libdohj.core.AltcoinNetworkParameters;
+import org.libdohj.core.AltcoinSerializer;
+import org.qortal.api.model.crosschain.BitcoinyTBDRequest;
+import org.qortal.repository.DataException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import java.math.BigInteger;
+
+import static org.bitcoinj.core.Coin.COIN;
+
+/**
+ * Common parameters Bitcoin fork networks.
+ */
+public class DeterminedNetworkParams extends NetworkParameters implements AltcoinNetworkParameters {
+
+    private static final org.apache.logging.log4j.Logger LOGGER = LogManager.getLogger(DeterminedNetworkParams.class);
+
+    public static final long MAX_TARGET_COMPACT_BITS = 0x1e0fffffL;
+    /**
+     *  Standard format for the LITE denomination.
+     */
+    private MonetaryFormat fullUnit;
+
+    /**
+     * Standard format for the mLITE denomination.
+     * */
+    private MonetaryFormat mUnit;
+
+    /**
+     * Base Unit
+     *
+     * The equivalent for Satoshi for Bitcoin
+     */
+    private MonetaryFormat baseUnit;
+
+     /**
+     * The maximum money to be generated
+     */
+    public final Coin maxMoney;
+
+    /**
+     * Currency code for full unit.
+     * */
+    private String code = "LITE";
+
+    /**
+     *  Currency code for milli Unit.
+     *  */
+    private String mCode = "mLITE";
+
+    /**
+     * Currency code for base unit.
+     * */
+    private String baseCode = "Liteoshi";
+
+
+    private int protocolVersionMinimum;
+    private int protocolVersionCurrent;
+
+    private static final Coin BASE_SUBSIDY = COIN.multiply(50);
+
+    protected Logger log = LoggerFactory.getLogger(DeterminedNetworkParams.class);
+
+    private int minNonDustOutput;
+
+    private String uriScheme;
+
+    private boolean hasMaxMoney;
+
+    public DeterminedNetworkParams( BitcoinyTBDRequest request ) throws DataException {
+        super();
+
+        if( request.getTargetTimespan() > 0 && request.getTargetSpacing() > 0 )
+            this.interval = request.getTargetTimespan() / request.getTargetSpacing();
+
+        this.targetTimespan = request.getTargetTimespan();
+
+        // this compact value is used for every Bitcoin fork for no documented reason
+        this.maxTarget = Utils.decodeCompactBits(MAX_TARGET_COMPACT_BITS);
+
+        this.packetMagic = request.getPacketMagic();
+
+        this.id = request.getId();
+        this.port = request.getPort();
+        this.addressHeader = request.getAddressHeader();
+        this.p2shHeader = request.getP2shHeader();
+        this.segwitAddressHrp = request.getSegwitAddressHrp();
+
+        this.dumpedPrivateKeyHeader = request.getDumpedPrivateKeyHeader();
+
+        LOGGER.info( "Creating Genesis Block ...");
+
+        //this.genesisBlock = CoinParamsUtil.createGenesisBlockFromRequest(this, request);
+
+        LOGGER.info("Created Genesis Block: genesisBlock = " + genesisBlock );
+
+        // this is 100 for each coin from what I can tell
+        this.spendableCoinbaseDepth = 100;
+
+        this.subsidyDecreaseBlockCount = request.getSubsidyDecreaseBlockCount();
+
+//        String genesisHash = genesisBlock.getHashAsString();
+//
+//        LOGGER.info("genesisHash = " + genesisHash);
+//
+//        LOGGER.info("request = " + request);
+//
+//        checkState(genesisHash.equals(request.getExpectedGenesisHash()));
+        this.alertSigningKey = Hex.decode(request.getPubKey());
+
+        this.majorityEnforceBlockUpgrade = request.getMajorityEnforceBlockUpgrade();
+        this.majorityRejectBlockOutdated = request.getMajorityRejectBlockOutdated();
+        this.majorityWindow = request.getMajorityWindow();
+
+        this.dnsSeeds = request.getDnsSeeds();
+
+        this.bip32HeaderP2PKHpub = request.getBip32HeaderP2PKHpub();
+        this.bip32HeaderP2PKHpriv = request.getBip32HeaderP2PKHpriv();
+
+        this.code = request.getCode();
+        this.mCode = request.getmCode();
+        this.baseCode = request.getBaseCode();
+
+        this.fullUnit = MonetaryFormat.BTC.noCode()
+                .code(0, this.code)
+                .code(3, this.mCode)
+                .code(7, this.baseCode);
+        this.mUnit = fullUnit.shift(3).minDecimals(2).optionalDecimals(2);
+        this.baseUnit = fullUnit.shift(7).minDecimals(0).optionalDecimals(2);
+
+        this.protocolVersionMinimum = request.getProtocolVersionMinimum();
+        this.protocolVersionCurrent = request.getProtocolVersionCurrent();
+
+        this.minNonDustOutput = request.getMinNonDustOutput();
+
+        this.uriScheme = request.getUriScheme();
+
+        this.hasMaxMoney = request.isHasMaxMoney();
+
+        this.maxMoney = COIN.multiply(request.getMaxMoney());
+    }
+
+    @Override
+    public Coin getBlockSubsidy(final int height) {
+        // return BASE_SUBSIDY.shiftRight(height / getSubsidyDecreaseBlockCount());
+        // return something concerning Digishield for Dogecoin
+        // return something different for Digibyte validation.cpp::GetBlockSubsidy
+        // we may not need to support this
+        throw new UnsupportedOperationException();
+    }
+
+    /**
+     * Get the hash to use for a block.
+     */
+    @Override
+    public Sha256Hash getBlockDifficultyHash(Block block) {
+
+        return ((AltcoinBlock) block).getScryptHash();
+    }
+
+    @Override
+    public boolean isTestNet() {
+        return false;
+    }
+
+    public MonetaryFormat getMonetaryFormat() {
+
+        return this.fullUnit;
+    }
+
+    @Override
+    public Coin getMaxMoney() {
+
+        return this.maxMoney;
+    }
+
+    @Override
+    public Coin getMinNonDustOutput() {
+
+        return Coin.valueOf(this.minNonDustOutput);
+    }
+
+    @Override
+    public String getUriScheme() {
+
+        return this.uriScheme;
+    }
+
+    @Override
+    public boolean hasMaxMoney() {
+
+        return this.hasMaxMoney;
+    }
+
+
+    @Override
+    public String getPaymentProtocolId() {
+        return this.id;
+    }
+
+    @Override
+    public void checkDifficultyTransitions(StoredBlock storedPrev, Block nextBlock, BlockStore blockStore)
+        throws VerificationException, BlockStoreException {
+        try {
+            final long newTargetCompact = calculateNewDifficultyTarget(storedPrev, nextBlock, blockStore);
+            final long receivedTargetCompact = nextBlock.getDifficultyTarget();
+
+            if (newTargetCompact != receivedTargetCompact)
+                throw new VerificationException("Network provided difficulty bits do not match what was calculated: " +
+                        newTargetCompact + " vs " + receivedTargetCompact);
+        } catch (CheckpointEncounteredException ex) {
+            // Just have to take it on trust then
+        }
+    }
+
+    /**
+     * Get the difficulty target expected for the next block. This includes all
+     * the weird cases for Litecoin such as testnet blocks which can be maximum
+     * difficulty if the block interval is high enough.
+     *
+     * @throws CheckpointEncounteredException if a checkpoint is encountered while
+     * calculating difficulty target, and therefore no conclusive answer can
+     * be provided.
+     */
+    public long calculateNewDifficultyTarget(StoredBlock storedPrev, Block nextBlock, BlockStore blockStore)
+        throws VerificationException, BlockStoreException, CheckpointEncounteredException {
+        final Block prev = storedPrev.getHeader();
+        final int previousHeight = storedPrev.getHeight();
+        final int retargetInterval = this.getInterval();
+
+        // Is this supposed to be a difficulty transition point?
+        if ((storedPrev.getHeight() + 1) % retargetInterval != 0) {
+            if (this.allowMinDifficultyBlocks()) {
+                // Special difficulty rule for testnet:
+                // If the new block's timestamp is more than 5 minutes
+                // then allow mining of a min-difficulty block.
+                if (nextBlock.getTimeSeconds() > prev.getTimeSeconds() + getTargetSpacing() * 2) {
+                    return Utils.encodeCompactBits(maxTarget);
+                } else {
+                    // Return the last non-special-min-difficulty-rules-block
+                    StoredBlock cursor = storedPrev;
+
+                    while (cursor.getHeight() % retargetInterval != 0
+                            && cursor.getHeader().getDifficultyTarget() == Utils.encodeCompactBits(this.getMaxTarget())) {
+                        StoredBlock prevCursor = cursor.getPrev(blockStore);
+                        if (prevCursor == null) {
+                            break;
+                        }
+                        cursor = prevCursor;
+                    }
+
+                    return cursor.getHeader().getDifficultyTarget();
+                }
+            }
+
+            // No ... so check the difficulty didn't actually change.
+            return prev.getDifficultyTarget();
+        }
+
+        // We need to find a block far back in the chain. It's OK that this is expensive because it only occurs every
+        // two weeks after the initial block chain download.
+        StoredBlock cursor = storedPrev;
+        int goBack = retargetInterval - 1;
+
+        // Litecoin: This fixes an issue where a 51% attack can change difficulty at will.
+        // Go back the full period unless it's the first retarget after genesis.
+        // Code based on original by Art Forz
+        if (cursor.getHeight()+1 != retargetInterval)
+            goBack = retargetInterval;
+
+        for (int i = 0; i < goBack; i++) {
+            if (cursor == null) {
+                // This should never happen. If it does, it means we are following an incorrect or busted chain.
+                throw new VerificationException(
+                        "Difficulty transition point but we did not find a way back to the genesis block.");
+            }
+            cursor = blockStore.get(cursor.getHeader().getPrevBlockHash());
+        }
+
+        //We used checkpoints...
+        if (cursor == null) {
+            log.debug("Difficulty transition: Hit checkpoint!");
+            throw new CheckpointEncounteredException();
+        }
+
+        Block blockIntervalAgo = cursor.getHeader();
+        return this.calculateNewDifficultyTargetInner(previousHeight, prev.getTimeSeconds(),
+            prev.getDifficultyTarget(), blockIntervalAgo.getTimeSeconds(),
+            nextBlock.getDifficultyTarget());
+    }
+
+    /**
+     * Calculate the difficulty target expected for the next block after a normal
+     * recalculation interval. Does not handle special cases such as testnet blocks
+     * being setting the target to maximum for blocks after a long interval.
+     *
+     * @param previousHeight height of the block immediately before the retarget.
+     * @param prev the block immediately before the retarget block.
+     * @param nextBlock the block the retarget happens at.
+     * @param blockIntervalAgo The last retarget block.
+     * @return New difficulty target as compact bytes.
+     */
+    protected long calculateNewDifficultyTargetInner(int previousHeight, final Block prev,
+            final Block nextBlock, final Block blockIntervalAgo) {
+        return this.calculateNewDifficultyTargetInner(previousHeight, prev.getTimeSeconds(),
+            prev.getDifficultyTarget(), blockIntervalAgo.getTimeSeconds(),
+            nextBlock.getDifficultyTarget());
+    }
+
+    /**
+     *
+     * @param previousHeight Height of the block immediately previous to the one we're calculating difficulty of.
+     * @param previousBlockTime Time of the block immediately previous to the one we're calculating difficulty of.
+     * @param lastDifficultyTarget Compact difficulty target of the last retarget block.
+     * @param lastRetargetTime Time of the last difficulty retarget.
+     * @param nextDifficultyTarget The expected difficulty target of the next
+     * block, used for determining precision of the result.
+     * @return New difficulty target as compact bytes.
+     */
+    protected long calculateNewDifficultyTargetInner(int previousHeight, long previousBlockTime,
+        final long lastDifficultyTarget, final long lastRetargetTime,
+        final long nextDifficultyTarget) {
+        final int retargetTimespan = this.getTargetTimespan();
+        int actualTime = (int) (previousBlockTime - lastRetargetTime);
+        final int minTimespan = retargetTimespan / 4;
+        final int maxTimespan = retargetTimespan * 4;
+
+        actualTime = Math.min(maxTimespan, Math.max(minTimespan, actualTime));
+
+        BigInteger newTarget = Utils.decodeCompactBits(lastDifficultyTarget);
+        newTarget = newTarget.multiply(BigInteger.valueOf(actualTime));
+        newTarget = newTarget.divide(BigInteger.valueOf(retargetTimespan));
+
+        if (newTarget.compareTo(this.getMaxTarget()) > 0) {
+            log.info("Difficulty hit proof of work limit: {}", newTarget.toString(16));
+            newTarget = this.getMaxTarget();
+        }
+
+        int accuracyBytes = (int) (nextDifficultyTarget >>> 24) - 3;
+
+        // The calculated difficulty is to a higher precision than received, so reduce here.
+        BigInteger mask = BigInteger.valueOf(0xFFFFFFL).shiftLeft(accuracyBytes * 8);
+        newTarget = newTarget.and(mask);
+        return Utils.encodeCompactBits(newTarget);
+    }
+
+    @Override
+    public AltcoinSerializer getSerializer(boolean parseRetain) {
+        return new AltcoinSerializer(this, parseRetain);
+    }
+
+    @Override
+    public int getProtocolVersionNum(final ProtocolVersion version) {
+        switch (version) {
+            case PONG:
+            case BLOOM_FILTER:
+                return version.getBitcoinProtocolVersion();
+            case CURRENT:
+                return protocolVersionCurrent;
+            case MINIMUM:
+            default:
+                return protocolVersionMinimum;
+        }
+    }
+
+    /**
+     * Whether this network has special rules to enable minimum difficulty blocks
+     * after a long interval between two blocks (i.e. testnet).
+     */
+    public boolean allowMinDifficultyBlocks() {
+        return this.isTestNet();
+    }
+
+    public int getTargetSpacing() {
+        return this.getTargetTimespan() / this.getInterval();
+    }
+
+    private static class CheckpointEncounteredException extends Exception {  }
+}

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

@@ -59,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 {
@@ -110,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();
@@ -123,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()));
@@ -152,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;
@@ -173,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 );
+	}
 }