Update pom.xml - Deps

Corrections for NTP slipage at start up

.github/workflows/pr-testing.yml

@@ -1,7 +1,7 @@
 name: PR testing
 
 on:
-  pull_request:
+  push:
     branches: [ master ]
 
 jobs:
@@ -22,6 +22,10 @@ jobs:
         java-version: '11'
         distribution: 'adopt'
 
+    - name: Load custom deps
+      run: |
+        mvn install -DskipTests=true --file pom.xml
+
     - name: Run all tests
       run: |
         mvn -B clean test -DskipTests=false --file pom.xml

README.md

@@ -1,12 +1,56 @@
-# 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. 
 
-## Build / run
+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
 
 - Requires Java 11. OpenJDK 11 recommended over Java SE.
 - Install Maven
 - Use Maven to fetch dependencies and build: `mvn clean package`
+- Update Maven dependencies: `mvn install` 
 - Built JAR should be something like `target/qortal-1.0.jar`
 - Create basic *settings.json* file: `echo '{}' > settings.json`
 - 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*
+
+## IntelliJ IDEA Configuration
+
+- Run -> Edit Configurations
+- Add New Application
+- Name: qortal
+- SDK: java 11
+- Main Class: org.qortal.controller.Controller
+- Program arguments: settings.json -Dlog4j.configurationFile=log4j2.properties -ea
+- Environment variables: Djava.net.preferIPv4Stack=false
+
+# Using a pre-built Qortal 'jar' binary
+
+If you 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. 

WindowsInstaller/Install Files/AppData/settings.json

@@ -1,3 +1,4 @@
 {
-  "apiDocumentationEnabled": true
+  "apiDocumentationEnabled": true,
+  "apiWhitelistEnabled": false
 }

WindowsInstaller/README.md

@@ -2,7 +2,9 @@
 
 ## Prerequisites
 
-* AdvancedInstaller v19.4 or better, and enterprise licence if translations are required
+* AdvancedInstaller v19.4 or better, and enterprise licence. 
+* Qortal has an open source license, however it currently (as of December 2024) only supports up to version 19. (We may need to reach out to Advanced Installer again to obtain a new license at some point, if needed. 
+* Reach out to @crowetic for links to the installer install files, and license. 
 * Installed AdoptOpenJDK v17 64bit, full JDK *not* JRE
 
 ## General build instructions
@@ -10,6 +12,12 @@
 If this is your first time opening the `qortal.aip` file then you might need to adjust
 configured paths, or create a dummy `D:` drive with the expected layout.
 
+Opening the aip file from within a clone of the qortal repo also works, if you have a separate windows machine setup to do the build. 
+
+You May need to change the location of the 'jre64' files inside Advanced Installer, if it is set to a path that your build machine doesn't have. 
+
+The Java Memory Arguments can be set manually, but as of December 2024 they have been reset back to system defaults. This should include G1GC Garbage Collector.
+
 Typical build procedure:
 
 * Place the `qortal.jar` file in `Install-Files\`

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

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
-    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
-  <modelVersion>4.0.0</modelVersion>
-  <groupId>org.ciyam</groupId>
-  <artifactId>AT</artifactId>
-  <version>1.3.7</version>
-  <description>POM was created from install:install-file</description>
-</project>

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

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
-    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
-  <modelVersion>4.0.0</modelVersion>
-  <groupId>org.ciyam</groupId>
-  <artifactId>AT</artifactId>
-  <version>1.3.8</version>
-  <description>POM was created from install:install-file</description>
-</project>

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

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
-    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
-  <modelVersion>4.0.0</modelVersion>
-  <groupId>org.ciyam</groupId>
-  <artifactId>AT</artifactId>
-  <version>1.4.0</version>
-  <description>POM was created from install:install-file</description>
-</project>

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

@@ -1,123 +0,0 @@
-<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.1</version>
-	<packaging>jar</packaging>
-
-	<properties>
-		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-		<skipTests>false</skipTests>
-		<bouncycastle.version>1.69</bouncycastle.version>
-		<junit.version>4.13.2</junit.version>
-		<maven-compiler-plugin.version>3.11.0</maven-compiler-plugin.version>
-		<maven-jar-plugin.version>3.3.0</maven-jar-plugin.version>
-		<maven-javadoc-plugin.version>3.6.3</maven-javadoc-plugin.version>
-		<maven-source-plugin.version>3.3.0</maven-source-plugin.version>
-		<maven-surefire-plugin.version>3.2.2</maven-surefire-plugin.version>
-	</properties>
-
-	<build>
-		<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

@@ -1,15 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<metadata>
-  <groupId>org.ciyam</groupId>
-  <artifactId>AT</artifactId>
-  <versioning>
-    <release>1.4.1</release>
-    <versions>
-      <version>1.3.7</version>
-      <version>1.3.8</version>
-      <version>1.4.0</version>
-      <version>1.4.1</version>
-    </versions>
-    <lastUpdated>20231212092227</lastUpdated>
-  </versioning>
-</metadata>

lib/org/hsqldb/hsqldb/2.7.4/Notes.txt

@@ -0,0 +1,5 @@
+This is the production hsqldb-2.7.4 with the manifest file updated 
+
+Sealed: false
+
+Allows the addition of the custom Qortal HSQLDBPool and Monitoring Classes

pom.xml

@@ -3,59 +3,69 @@
 	<modelVersion>4.0.0</modelVersion>
 	<groupId>org.qortal</groupId>
 	<artifactId>qortal</artifactId>
-	<version>4.5.1</version>
+	<version>5.1.0</version> <!-- Version must be <X.Y.Z> -->
 	<packaging>jar</packaging>
 	<properties>
-		<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>
+		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+		<skipJUnitTests>true</skipJUnitTests>
+		
+		<altcoinj.version>d7cf6ac</altcoinj.version> <!-- BC v16 / Updated Abstract Classes / alertSigningKey -->
+		<bitcoinj.version>0.16.3</bitcoinj.version>
+		<bouncycastle.version>1.73</bouncycastle.version>
 		<build.timestamp>${maven.build.timestamp}</build.timestamp>
-		<ciyam-at.version>1.4.1</ciyam-at.version>
+		<ciyam-at.version>1b731d1</ciyam-at.version> <!-- This is the hash for v1.4.3 -->
 		<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-net.version>3.9.0</commons-net.version> v5.2.0 coming soon -->
+		<commons-text.version>1.12.0</commons-text.version>
+		<commons-io.version>2.18.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>
+		<!-- <grpc.version>1.68.3</grpc.version> v5.2.0 coming soon -->
+		<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>
-		<java-diff-utils.version>4.12</java-diff-utils.version>
+		<hsqldb.version>2.7.4</hsqldb.version>
+		<icu4j.version>76.1</icu4j.version>
+		<java-diff-utils.version>4.15</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>
+		<!-- <jetty.version>9.4.57.v20241219</jetty.version> v5.2.0 Coming Soon -->
 		<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.18.0</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-install-plugin.version>3.1.3</maven-install-plugin.version>
+		<maven-surefire-plugin.version>3.5.2</maven-surefire-plugin.version>
+		<!-- <maven-surefire-plugin.version>3.5.3</maven-surefire-plugin.version> v5.2.0 Coming Soon -->
+		<protobuf.version>3.25.3</protobuf.version>
+		<!-- <protobuf.version>3.25.7</protobuf.version> v 5.1 -->
 		<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.2.30</swagger-api.version> need code upgrade Future Release -->
+		<!-- <swagger-api.version>2.1.13</swagger-api.version> need code upgrade Future Release -->
 		<swagger-api.version>2.0.10</swagger-api.version>
-		<swagger-ui.version>5.10.3</swagger-ui.version>
+		<swagger-ui.version>5.18.2</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 +80,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 +248,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 +278,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>
@@ -287,20 +297,48 @@
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-jar-plugin</artifactId>
 				<version>${maven-jar-plugin.version}</version>
-				<configuration>
-					<archive>
-						<manifest>
-							<addDefaultEntries>false</addDefaultEntries>
-							<addDefaultImplementationEntries>true</addDefaultImplementationEntries>
-						</manifest>
-						<manifestEntries>
-							<Last-Commit-Id>${git.commit.id.full}</Last-Commit-Id>
-							<Last-Commit-Time>${git.commit.time}</Last-Commit-Time>
-							<Reproducible-Build>true</Reproducible-Build>
-						</manifestEntries>
-					</archive>
-				</configuration>
+				<executions>
+					<execution>
+						<configuration>
+							<archive>
+								<manifest>
+									<addDefaultEntries>false</addDefaultEntries>
+									<addDefaultImplementationEntries>true</addDefaultImplementationEntries>
+								</manifest>
+								<manifestEntries>
+									<Last-Commit-Id>${git.commit.id.full}</Last-Commit-Id>
+									<Last-Commit-Time>${git.commit.time}</Last-Commit-Time>
+									<Reproducible-Build>true</Reproducible-Build>
+								</manifestEntries>
+							</archive>
+						</configuration>
+					</execution>
+				</executions>
 			</plugin>
+			<!-- Copy modified hsqldb.jar to install / modified MANIFEST.MF-->
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-install-plugin</artifactId>
+				<version>${maven-install-plugin.version}</version>
+				<configuration>
+					<groupId>org.hsqldb</groupId>
+					<artifactId>hsqldb</artifactId>
+					<version>${hsqldb.version}</version>
+					<packaging>jar</packaging>
+				</configuration>
+				<executions>
+					<execution>
+						<phase>install</phase>
+						<goals>
+							<goal>install-file</goal>
+						</goals>
+						<configuration>
+							<file>${project.basedir}/lib/org/hsqldb/hsqldb/${hsqldb.version}/hsqldb.jar</file>
+						</configuration>
+					</execution>
+				</executions>
+			</plugin>
+
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-shade-plugin</artifactId>
@@ -350,10 +388,11 @@
 					</execution>
 				</executions>
 			</plugin>
+			<!-- Removed, now use Maven reproducible by default v4.0, IntelliJ v2025.1 and later -->
 			<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>
@@ -372,7 +411,7 @@
 				<artifactId>maven-surefire-plugin</artifactId>
 				<version>${maven-surefire-plugin.version}</version>
 				<configuration>
-					<skipTests>${skipTests}</skipTests>
+					<skipTests>${skipJUnitTests}</skipTests>
 				</configuration>
 			</plugin>
 		</plugins>
@@ -388,15 +427,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 +440,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 +475,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,11 +483,11 @@
 		<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>
-		<!-- HSQLDB for repository -->
+		<!-- HSQLDB for repository should use local version with Sealed: false -->
 		<dependency>
 			<groupId>org.hsqldb</groupId>
 			<artifactId>hsqldb</artifactId>
@@ -468,7 +495,7 @@
 		</dependency>
 		<!-- CIYAM AT (automated transactions) -->
 		<dependency>
-			<groupId>org.ciyam</groupId>
+			<groupId>com.github.iceburst</groupId>
 			<artifactId>AT</artifactId>
 			<version>${ciyam-at.version}</version>
 		</dependency>
@@ -486,7 +513,7 @@
 		</dependency>
 		<!-- For Litecoin, etc. support, requires bitcoinj -->
 		<dependency>
-			<groupId>com.github.qortal</groupId>
+			<groupId>com.github.iceburst</groupId>
 			<artifactId>altcoinj</artifactId>
 			<version>${altcoinj.version}</version>
 		</dependency>
@@ -731,12 +758,12 @@
 		<!-- BouncyCastle for crypto, including TLS secure networking -->
 		<dependency>
 			<groupId>org.bouncycastle</groupId>
-			<artifactId>bcprov-jdk15on</artifactId>
+			<artifactId>bcprov-jdk15to18</artifactId>
 			<version>${bouncycastle.version}</version>
 		</dependency>
 		<dependency>
 			<groupId>org.bouncycastle</groupId>
-			<artifactId>bctls-jdk15on</artifactId>
+			<artifactId>bctls-jdk15to18</artifactId>
 			<version>${bouncycastle.version}</version>
 		</dependency>
 		<dependency>
@@ -780,5 +807,10 @@
 			<artifactId>jaxb-runtime</artifactId>
 			<version>${jaxb-runtime.version}</version>
 		</dependency>
+		<dependency>
+<groupId>org.apache.tika</groupId>
+<artifactId>tika-core</artifactId>
+<version>3.1.0</version> 
+</dependency>
 	</dependencies>
 </project>

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/hsqldb/jdbc/HSQLDBPoolMonitored.java

@@ -0,0 +1,173 @@
+package org.hsqldb.jdbc;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.hsqldb.jdbc.pool.JDBCPooledConnection;
+import org.qortal.data.system.DbConnectionInfo;
+import org.qortal.repository.hsqldb.HSQLDBRepositoryFactory;
+
+import javax.sql.ConnectionEvent;
+import javax.sql.PooledConnection;
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.Comparator;
+import java.util.List;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Collectors;
+
+/**
+ * Class HSQLDBPoolMonitored
+ *
+ * This class uses the same logic as HSQLDBPool. The only difference is it monitors the state of every connection
+ * to the database. This is used for debugging purposes only.
+ */
+public class HSQLDBPoolMonitored extends HSQLDBPool {
+
+	private static final Logger LOGGER = LogManager.getLogger(HSQLDBRepositoryFactory.class);
+
+	private static final String EMPTY = "Empty";
+	private static final String AVAILABLE = "Available";
+	private static final String ALLOCATED = "Allocated";
+
+	private ConcurrentHashMap<Integer, DbConnectionInfo> infoByIndex;
+
+	public HSQLDBPoolMonitored(int poolSize) {
+		super(poolSize);
+
+		this.infoByIndex = new ConcurrentHashMap<>(poolSize);
+	}
+
+	/**
+	 * Tries to retrieve a new connection using the properties that have already been
+	 * set.
+	 *
+	 * @return  a connection to the data source, or null if no spare connections in pool
+	 * @exception SQLException if a database access error occurs
+	 */
+	public Connection tryConnection() throws SQLException {
+		for (int i = 0; i < states.length(); i++) {
+			if (states.compareAndSet(i, RefState.available, RefState.allocated)) {
+				JDBCPooledConnection pooledConnection = connections[i];
+
+				if (pooledConnection == null)
+					// Probably shutdown situation
+					return null;
+
+				infoByIndex.put(i, new DbConnectionInfo(System.currentTimeMillis(), Thread.currentThread().getName(), ALLOCATED));
+
+				return pooledConnection.getConnection();
+			}
+
+			if (states.compareAndSet(i, RefState.empty, RefState.allocated)) {
+				try {
+					JDBCPooledConnection pooledConnection = (JDBCPooledConnection) source.getPooledConnection();
+
+					if (pooledConnection == null)
+						// Probably shutdown situation
+						return null;
+
+					pooledConnection.addConnectionEventListener(this);
+					pooledConnection.addStatementEventListener(this);
+					connections[i] = pooledConnection;
+
+					infoByIndex.put(i, new DbConnectionInfo(System.currentTimeMillis(), Thread.currentThread().getName(), ALLOCATED));
+
+					return pooledConnection.getConnection();
+				} catch (SQLException e) {
+					states.set(i, RefState.empty);
+					infoByIndex.put(i, new DbConnectionInfo(System.currentTimeMillis(), Thread.currentThread().getName(), EMPTY));
+				}
+			}
+		}
+
+		return null;
+	}
+
+	public Connection getConnection() throws SQLException {
+		int var1 = 300;
+		if (this.source.loginTimeout != 0) {
+			var1 = this.source.loginTimeout * 10;
+		}
+
+		if (this.closed) {
+			throw new SQLException("connection pool is closed");
+		} else {
+			for(int var2 = 0; var2 < var1; ++var2) {
+				for(int var3 = 0; var3 < this.states.length(); ++var3) {
+					if (this.states.compareAndSet(var3, 1, 2)) {
+						infoByIndex.put(var3, new DbConnectionInfo(System.currentTimeMillis(), Thread.currentThread().getName(), ALLOCATED));
+						return this.connections[var3].getConnection();
+					}
+
+					if (this.states.compareAndSet(var3, 0, 2)) {
+						try {
+							JDBCPooledConnection var4 = (JDBCPooledConnection)this.source.getPooledConnection();
+							var4.addConnectionEventListener(this);
+							var4.addStatementEventListener(this);
+							this.connections[var3] = var4;
+
+							infoByIndex.put(var3, new DbConnectionInfo(System.currentTimeMillis(), Thread.currentThread().getName(), ALLOCATED));
+
+							return this.connections[var3].getConnection();
+						} catch (SQLException var6) {
+							this.states.set(var3, 0);
+							infoByIndex.put(var3, new DbConnectionInfo(System.currentTimeMillis(), Thread.currentThread().getName(), EMPTY));
+						}
+					}
+				}
+
+				try {
+					Thread.sleep(100L);
+				} catch (InterruptedException var5) {
+				}
+			}
+
+			throw JDBCUtil.invalidArgument();
+		}
+	}
+
+	public void connectionClosed(ConnectionEvent event) {
+		PooledConnection connection = (PooledConnection) event.getSource();
+
+		for (int i = 0; i < connections.length; i++) {
+			if (connections[i] == connection) {
+				states.set(i, RefState.available);
+				infoByIndex.put(i, new DbConnectionInfo(System.currentTimeMillis(), Thread.currentThread().getName(), AVAILABLE));
+				break;
+			}
+		}
+	}
+
+	public void connectionErrorOccurred(ConnectionEvent event) {
+		PooledConnection connection = (PooledConnection) event.getSource();
+
+		for (int i = 0; i < connections.length; i++) {
+			if (connections[i] == connection) {
+				states.set(i, RefState.allocated);
+				connections[i] = null;
+				states.set(i, RefState.empty);
+				infoByIndex.put(i, new DbConnectionInfo(System.currentTimeMillis(), Thread.currentThread().getName(), EMPTY));
+				break;
+			}
+		}
+	}
+
+	public List<DbConnectionInfo> getDbConnectionsStates() {
+
+		return infoByIndex.values().stream()
+			.sorted(Comparator.comparingLong(DbConnectionInfo::getUpdated))
+			.collect(Collectors.toList());
+	}
+
+	private int findConnectionIndex(ConnectionEvent connectionEvent) {
+		PooledConnection pooledConnection = (PooledConnection) connectionEvent.getSource();
+
+		for(int i = 0; i < this.connections.length; ++i) {
+			if (this.connections[i] == pooledConnection) {
+				return i;
+			}
+		}
+
+		return -1;
+	}
+}

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

@@ -2,19 +2,31 @@ package org.qortal.account;
 
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
+import org.qortal.api.resource.TransactionsResource;
 import org.qortal.block.BlockChain;
 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.data.transaction.TransactionData;
 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;
+import org.qortal.utils.Groups;
 
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
 
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
 import static org.qortal.utils.Amounts.prettyAmount;
 
 @XmlAccessorType(XmlAccessType.NONE) // Stops JAX-RS errors when unmarshalling blockchain config
@@ -193,27 +205,85 @@ 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 some 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 has registered a name</li>
+	 * <li>account's address is a member of the minter group</li>
 	 * </ul>
-	 * 
+	 *
+	 * @param isGroupValidated true if this account has already been validated for MINTER Group membership
 	 * @return true if account can be considered "minting account"
 	 * @throws DataException
 	 */
-	public boolean canMint() throws DataException {
+	public boolean canMint(boolean isGroupValidated) throws DataException {
 		AccountData accountData = this.repository.getAccountRepository().getAccount(this.address);
-		if (accountData == null)
-			return false;
+		NameRepository nameRepository = this.repository.getNameRepository();
+		GroupRepository groupRepository = this.repository.getGroupRepository();
+		String myAddress = accountData.getAddress();
 
-		Integer level = accountData.getLevel();
-		if (level != null && level >= BlockChain.getInstance().getMinAccountLevelToMint())
-			return true;
+		int blockchainHeight = this.repository.getBlockRepository().getBlockchainHeight();
 
-		// Founders can always mint, unless they have a penalty
-		if (Account.isFounder(accountData.getFlags()) && accountData.getBlocksMintedPenalty() == 0)
-			return true;
+		int levelToMint;
+
+		if( blockchainHeight >= BlockChain.getInstance().getIgnoreLevelForRewardShareHeight() ) {
+			levelToMint = 0;
+		}
+		else {
+			levelToMint = BlockChain.getInstance().getMinAccountLevelToMint();
+		}
+
+		int level = accountData.getLevel();
+		List<Integer> groupIdsToMint = Groups.getGroupIdsToMint( BlockChain.getInstance(), blockchainHeight );
+		int nameCheckHeight = BlockChain.getInstance().getOnlyMintWithNameHeight();
+		int groupCheckHeight = BlockChain.getInstance().getGroupMemberCheckHeight();
+		int removeNameCheckHeight = BlockChain.getInstance().getRemoveOnlyMintWithNameHeight();
+
+		// Can only mint if:
+		// Account's level is at least minAccountLevelToMint from blockchain config
+		if (blockchainHeight < nameCheckHeight) {
+			if (Account.isFounder(accountData.getFlags())) {
+				return accountData.getBlocksMintedPenalty() == 0;
+			} else {
+				return level >= levelToMint;
+			}
+		}
+
+		// Can only mint on onlyMintWithNameHeight from blockchain config if:
+		// Account's level is at least minAccountLevelToMint from blockchain config
+		// Account's address has registered a name
+		if (blockchainHeight >= nameCheckHeight && blockchainHeight < groupCheckHeight) {
+			List<NameData> myName = nameRepository.getNamesByOwner(myAddress);
+			if (Account.isFounder(accountData.getFlags())) {
+				return accountData.getBlocksMintedPenalty() == 0 && !myName.isEmpty();
+			} else {
+				return level >= levelToMint && !myName.isEmpty();
+			}
+		}
+
+		// Can only mint on groupMemberCheckHeight from blockchain config if:
+		// Account's level is at least minAccountLevelToMint from blockchain config
+		// Account's address has registered a name
+		// Account's address is a member of the minter group
+		if (blockchainHeight >= groupCheckHeight && blockchainHeight < removeNameCheckHeight) {
+			List<NameData> myName = nameRepository.getNamesByOwner(myAddress);
+			if (Account.isFounder(accountData.getFlags())) {
+				return accountData.getBlocksMintedPenalty() == 0 && !myName.isEmpty() && (isGroupValidated || Groups.memberExistsInAnyGroup(groupRepository, groupIdsToMint, myAddress));
+			} else {
+				return level >= levelToMint && !myName.isEmpty() && (isGroupValidated || Groups.memberExistsInAnyGroup(groupRepository, groupIdsToMint, myAddress));
+			}
+		}
+
+		// Can only mint on removeOnlyMintWithNameHeight from blockchain config if:
+		// Account's level is at least minAccountLevelToMint from blockchain config
+		// Account's address is a member of the minter group
+		if (blockchainHeight >= removeNameCheckHeight) {
+			if (Account.isFounder(accountData.getFlags())) {
+				return accountData.getBlocksMintedPenalty() == 0 && (isGroupValidated || Groups.memberExistsInAnyGroup(groupRepository, groupIdsToMint, myAddress));
+			} else {
+				return level >= levelToMint && (isGroupValidated || Groups.memberExistsInAnyGroup(groupRepository, groupIdsToMint, myAddress));
+			}
+		}
 
 		return false;
 	}
@@ -228,7 +298,6 @@ public class Account {
 		return this.repository.getAccountRepository().getBlocksMintedPenaltyCount(this.address);
 	}
 
-
 	/** Returns whether account can build reward-shares.
 	 * <p>
 	 * To be able to create reward-shares, the account needs to pass at least one of these tests:<br>
@@ -242,6 +311,7 @@ public class Account {
 	 */
 	public boolean canRewardShare() throws DataException {
 		AccountData accountData = this.repository.getAccountRepository().getAccount(this.address);
+
 		if (accountData == null)
 			return false;
 
@@ -252,6 +322,9 @@ public class Account {
 		if (Account.isFounder(accountData.getFlags()) && accountData.getBlocksMintedPenalty() == 0)
 			return true;
 
+		if( this.repository.getBlockRepository().getBlockchainHeight() >= BlockChain.getInstance().getIgnoreLevelForRewardShareHeight() )
+			return true;
+
 		return false;
 	}
 
@@ -295,10 +368,164 @@ public class Account {
 	}
 
 	/**
-	 * Returns 'effective' minting level, or zero if reward-share does not exist.
+	 * Get Primary Name
+	 *
+	 * @return the primary name for this address if present, otherwise empty
+	 *
+	 * @throws DataException
+	 */
+	public Optional<String> getPrimaryName() throws DataException {
+
+		return this.repository.getNameRepository().getPrimaryName(this.address);
+	}
+
+	/**
+	 * Remove Primary Name
+	 *
+	 * @throws DataException
+	 */
+	public void removePrimaryName() throws DataException {
+		this.repository.getNameRepository().removePrimaryName(this.address);
+	}
+
+	/**
+	 * Reset Primary Name
+	 *
+	 * Set primary name based on the names (and their history) this account owns.
+	 *
+	 * @param confirmationStatus the status of the transactions for the determining the primary name
+	 *
+	 * @return the primary name, empty if their isn't one
+	 *
+	 * @throws DataException
+	 */
+	public Optional<String> resetPrimaryName(TransactionsResource.ConfirmationStatus confirmationStatus) throws DataException {
+		Optional<String> primaryName = determinePrimaryName(confirmationStatus);
+
+		if(primaryName.isPresent()) {
+			return setPrimaryName(primaryName.get());
+		}
+		else {
+			return primaryName;
+		}
+	}
+
+	/**
+	 * Determine Primary Name
+	 *
+	 * Determine primary name based on a list of registered names.
+	 *
+	 * @param confirmationStatus the status of the transactions for this determination
+	 *
+	 * @return the primary name, empty if there is no primary name
+	 *
+	 * @throws DataException
+	 */
+	public Optional<String> determinePrimaryName(TransactionsResource.ConfirmationStatus confirmationStatus) throws DataException {
+
+		// all registered names for the owner
+		List<NameData> names = this.repository.getNameRepository().getNamesByOwner(this.address);
+
+		Optional<String> primaryName;
+
+		// if no registered names, the no primary name possible
+		if (names.isEmpty()) {
+			primaryName = Optional.empty();
+		}
+		// if names
+		else {
+			// if one name, then that is the primary name
+			if (names.size() == 1) {
+				primaryName = Optional.of( names.get(0).getName() );
+			}
+			// if more than one name, then seek the earliest name acquisition that was never released
+			else {
+				Map<String, TransactionData> txByName = new HashMap<>(names.size());
+
+				// for each name, get the latest transaction
+				for (NameData nameData : names) {
+
+					// since the name is currently registered to the owner,
+					// we assume the latest transaction involving this name was the transaction that the acquired
+					// name through registration, purchase or update
+					Optional<TransactionData> latestTransaction
+							= this.repository
+							.getTransactionRepository()
+							.getTransactionsInvolvingName(
+									nameData.getName(),
+									confirmationStatus
+							)
+							.stream()
+							.sorted(Comparator.comparing(
+									TransactionData::getTimestamp).reversed()
+							)
+							.findFirst(); // first is the last, since it was reversed
+
+					// if there is a latest transaction, expected for all registered names
+					if (latestTransaction.isPresent()) {
+						txByName.put(nameData.getName(), latestTransaction.get());
+					}
+					// if there is no latest transaction, then
+					else {
+						LOGGER.warn("No matching transaction for name: " + nameData.getName());
+					}
+				}
+
+				// get the first name aqcuistion for this address
+				Optional<Map.Entry<String, TransactionData>> firstNameEntry
+						= txByName.entrySet().stream().sorted(Comparator.comparing(entry -> entry.getValue().getTimestamp())).findFirst();
+
+				// if their is a name acquisition, then the first one is the primary name
+				if (firstNameEntry.isPresent()) {
+					primaryName = Optional.of( firstNameEntry.get().getKey() );
+				}
+				// if there is no nameacquistion, then there is no primary name
+				else {
+					primaryName =  Optional.empty();
+				}
+			}
+		}
+		return primaryName;
+	}
+
+	/**
+	 * Set Primary Name
+	 *
+	 * @param primaryName the primary to set to this address
+	 *
+	 * @return the primary name if successful, empty if unsuccessful
+	 *
+	 * @throws DataException
+	 */
+	public Optional<String> setPrimaryName( String primaryName ) throws DataException {
+		int changed = this.repository.getNameRepository().setPrimaryName(this.address, primaryName);
+
+		return changed > 0 ? Optional.of(primaryName) : Optional.empty();
+	}
+
+	/**
+	 * Returns reward-share minting address, or unknown if reward-share does not exist.
 	 * 
 	 * @param repository
 	 * @param rewardSharePublicKey
+	 * @return address or unknown
+	 * @throws DataException
+	 */
+	public static String getRewardShareMintingAddress(Repository repository, byte[] rewardSharePublicKey) throws DataException {
+		// Find actual minter address
+		RewardShareData rewardShareData = repository.getAccountRepository().getRewardShare(rewardSharePublicKey);
+
+		if (rewardShareData == null)
+			return "Unknown";
+
+		return rewardShareData.getMinter();
+	}
+
+	/**
+	 * Returns 'effective' minting level, or zero if reward-share does not exist.
+	 *
+	 * @param repository
+	 * @param rewardSharePublicKey
 	 * @return 0+
 	 * @throws DataException
 	 */
@@ -311,6 +538,7 @@ public class Account {
 		Account rewardShareMinter = new Account(repository, rewardShareData.getMinter());
 		return rewardShareMinter.getEffectiveMintingLevel();
 	}
+
 	/**
 	 * Returns 'effective' minting level, with a fix for the zero level.
 	 * <p>

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

@@ -1,17 +1,41 @@
 package org.qortal.account;
 
+import org.bouncycastle.crypto.generators.Ed25519KeyPairGenerator;
+import org.bouncycastle.crypto.params.Ed25519KeyGenerationParameters;
 import org.bouncycastle.crypto.params.Ed25519PublicKeyParameters;
 import org.qortal.crypto.Crypto;
 import org.qortal.data.account.AccountData;
 import org.qortal.repository.Repository;
 
+import java.security.SecureRandom;
+
 public class PublicKeyAccount extends Account {
 
 	protected final byte[] publicKey;
 	protected final Ed25519PublicKeyParameters edPublicKeyParams;
 
+	/** <p>Constructor for generating a PublicKeyAccount</p>
+	 *
+	 * @param repository Block Chain
+	 * @param publicKey 32 byte Public Key
+	 * @since v4.7.3
+	 */
 	public PublicKeyAccount(Repository repository, byte[] publicKey) {
-		this(repository, new Ed25519PublicKeyParameters(publicKey, 0));
+		super(repository, Crypto.toAddress(publicKey));
+
+		Ed25519PublicKeyParameters t = null;
+		try {
+			t = new Ed25519PublicKeyParameters(publicKey, 0);
+		} catch (Exception e) {
+			var gen = new Ed25519KeyPairGenerator();
+			gen.init(new Ed25519KeyGenerationParameters(new SecureRandom()));
+			var keyPair = gen.generateKeyPair();
+			t = (Ed25519PublicKeyParameters) keyPair.getPublic();
+		} finally {
+			this.edPublicKeyParams = t;
+		}
+
+		this.publicKey = publicKey;
 	}
 
 	protected PublicKeyAccount(Repository repository, Ed25519PublicKeyParameters edPublicKeyParams) {

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

@@ -46,6 +46,7 @@ public class ApiService {
 	private ApiService() {
 		this.config = new ResourceConfig();
 		this.config.packages("org.qortal.api.resource", "org.qortal.api.restricted.resource");
+		this.config.register(org.glassfish.jersey.media.multipart.MultiPartFeature.class);
 		this.config.register(OpenApiResource.class);
 		this.config.register(ApiDefinition.class);
 		this.config.register(AnnotationPostProcessor.class);
@@ -194,8 +195,10 @@ public class ApiService {
 
 			context.addServlet(AdminStatusWebSocket.class, "/websockets/admin/status");
 			context.addServlet(BlocksWebSocket.class, "/websockets/blocks");
+			context.addServlet(DataMonitorSocket.class, "/websockets/datamonitor");
 			context.addServlet(ActiveChatsWebSocket.class, "/websockets/chat/active/*");
 			context.addServlet(ChatMessagesWebSocket.class, "/websockets/chat/messages");
+			context.addServlet(UnsignedFeesSocket.class, "/websockets/crosschain/unsignedfees");
 			context.addServlet(TradeOffersWebSocket.class, "/websockets/crosschain/tradeoffers");
 			context.addServlet(TradeBotWebSocket.class, "/websockets/crosschain/tradebot");
 			context.addServlet(TradePresenceWebSocket.class, "/websockets/crosschain/tradepresence");

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

@@ -40,6 +40,7 @@ public class DevProxyService {
 	private DevProxyService() {
 		this.config = new ResourceConfig();
 		this.config.packages("org.qortal.api.proxy.resource", "org.qortal.api.resource");
+		this.config.register(org.glassfish.jersey.media.multipart.MultiPartFeature.class);
 		this.config.register(OpenApiResource.class);
 		this.config.register(ApiDefinition.class);
 		this.config.register(AnnotationPostProcessor.class);

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

@@ -39,6 +39,7 @@ public class DomainMapService {
 	private DomainMapService() {
 		this.config = new ResourceConfig();
 		this.config.packages("org.qortal.api.resource", "org.qortal.api.domainmap.resource");
+		this.config.register(org.glassfish.jersey.media.multipart.MultiPartFeature.class);
 		this.config.register(OpenApiResource.class);
 		this.config.register(ApiDefinition.class);
 		this.config.register(AnnotationPostProcessor.class);

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

@@ -39,6 +39,7 @@ public class GatewayService {
 	private GatewayService() {
 		this.config = new ResourceConfig();
 		this.config.packages("org.qortal.api.resource", "org.qortal.api.gateway.resource");
+		this.config.register(org.glassfish.jersey.media.multipart.MultiPartFeature.class);
 		this.config.register(OpenApiResource.class);
 		this.config.register(ApiDefinition.class);
 		this.config.register(AnnotationPostProcessor.class);

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

@@ -1,14 +1,13 @@
 package org.qortal.api;
 
+
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.jsoup.Jsoup;
 import org.jsoup.nodes.Document;
 import org.jsoup.select.Elements;
 import org.qortal.arbitrary.misc.Service;
-
 import java.util.Objects;
-
 public class HTMLParser {
 
     private static final Logger LOGGER = LogManager.getLogger(HTMLParser.class);
@@ -22,10 +21,11 @@ public class HTMLParser {
     private String identifier;
     private String path;
     private String theme;
+    private String lang;
     private boolean usingCustomRouting;
 
     public HTMLParser(String resourceId, String inPath, String prefix, boolean includeResourceIdInPrefix, byte[] data,
-                      String qdnContext, Service service, String identifier, String theme, boolean usingCustomRouting) {
+                      String qdnContext, Service service, String identifier, String theme, boolean usingCustomRouting,  String lang) {
         String inPathWithoutFilename = inPath.contains("/") ? inPath.substring(0, inPath.lastIndexOf('/')) : String.format("/%s",inPath);
         this.qdnBase = includeResourceIdInPrefix ? String.format("%s/%s", prefix, resourceId) : prefix;
         this.qdnBaseWithPath = includeResourceIdInPrefix ? String.format("%s/%s%s", prefix, resourceId, inPathWithoutFilename) : String.format("%s%s", prefix, inPathWithoutFilename);
@@ -36,6 +36,7 @@ public class HTMLParser {
         this.identifier = identifier;
         this.path = inPath;
         this.theme = theme;
+        this.lang = lang;
         this.usingCustomRouting = usingCustomRouting;
     }
 
@@ -61,9 +62,13 @@ public class HTMLParser {
             String identifier = this.identifier != null ? this.identifier.replace("\\", "").replace("\"","\\\"") : "";
             String path = this.path != null ? this.path.replace("\\", "").replace("\"","\\\"") : "";
             String theme = this.theme != null ? this.theme.replace("\\", "").replace("\"","\\\"") : "";
+            String lang = this.lang != null ? this.lang.replace("\\", "").replace("\"", "\\\"") : "";
             String qdnBase = this.qdnBase != null ? this.qdnBase.replace("\\", "").replace("\"","\\\"") : "";
             String qdnBaseWithPath = this.qdnBaseWithPath != null ? this.qdnBaseWithPath.replace("\\", "").replace("\"","\\\"") : "";
-            String qdnContextVar = String.format("<script>var _qdnContext=\"%s\"; var _qdnTheme=\"%s\"; var _qdnService=\"%s\"; var _qdnName=\"%s\"; var _qdnIdentifier=\"%s\"; var _qdnPath=\"%s\"; var _qdnBase=\"%s\"; var _qdnBaseWithPath=\"%s\";</script>", qdnContext, theme, service, name, identifier, path, qdnBase, qdnBaseWithPath);
+            String qdnContextVar = String.format(
+                "<script>var _qdnContext=\"%s\"; var _qdnTheme=\"%s\"; var _qdnLang=\"%s\"; var _qdnService=\"%s\"; var _qdnName=\"%s\"; var _qdnIdentifier=\"%s\"; var _qdnPath=\"%s\"; var _qdnBase=\"%s\"; var _qdnBaseWithPath=\"%s\";</script>",
+                qdnContext, theme, lang, service, name, identifier, path, qdnBase, qdnBaseWithPath
+              );
             head.get(0).prepend(qdnContextVar);
 
             // Add base href tag
@@ -82,7 +87,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/ApiOnlineAccount.java

@@ -1,7 +1,13 @@
 package org.qortal.api.model;
 
+import org.qortal.account.Account;
+import org.qortal.repository.DataException;
+import org.qortal.repository.RepositoryManager;
+import org.qortal.repository.Repository;
+
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlElement;
 
 // All properties to be converted to JSON via JAXB
 @XmlAccessorType(XmlAccessType.FIELD)
@@ -47,4 +53,31 @@ public class ApiOnlineAccount {
 		return this.recipientAddress;
 	}
 
+	public int getMinterLevelFromPublicKey() {
+		try (final Repository repository = RepositoryManager.getRepository()) {
+			return Account.getRewardShareEffectiveMintingLevel(repository, this.rewardSharePublicKey);
+		} catch (DataException e) {
+			return 0;
+		}
+	}
+
+	public boolean getIsMember() {
+		try (final Repository repository = RepositoryManager.getRepository()) {
+			return repository.getGroupRepository().memberExists(694, getMinterAddress());
+		} catch (DataException e) {
+			return false;
+		}
+	}
+
+	// JAXB special
+	
+	@XmlElement(name = "minterLevel")
+	protected int getMinterLevel() {
+		return getMinterLevelFromPublicKey();
+	}
+
+	@XmlElement(name = "isMinterMember")
+	protected boolean getMinterMember() {
+		return getIsMember();
+	}
 }

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

@@ -9,6 +9,7 @@ import java.math.BigInteger;
 public class BlockMintingInfo {
 
 	public byte[] minterPublicKey;
+	public String minterAddress;
 	public int minterLevel;
 	public int onlineAccountsCount;
 	public BigDecimal maxDistance;
@@ -19,5 +20,4 @@ public class BlockMintingInfo {
 
 	public BlockMintingInfo() {
 	}
-
 }

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

@@ -0,0 +1,72 @@
+package org.qortal.api.model;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import org.qortal.data.crosschain.CrossChainTradeData;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
+
+// All properties to be converted to JSON via JAXB
+@XmlAccessorType(XmlAccessType.FIELD)
+public class CrossChainTradeLedgerEntry {
+
+	private String market;
+
+	private String currency;
+
+	@XmlJavaTypeAdapter(value = org.qortal.api.AmountTypeAdapter.class)
+	private long quantity;
+
+	@XmlJavaTypeAdapter(value = org.qortal.api.AmountTypeAdapter.class)
+	private long feeAmount;
+
+	private String feeCurrency;
+
+	@XmlJavaTypeAdapter(value = org.qortal.api.AmountTypeAdapter.class)
+	private long totalPrice;
+
+	private long tradeTimestamp;
+
+	protected CrossChainTradeLedgerEntry() {
+		/* For JAXB */
+	}
+
+	public CrossChainTradeLedgerEntry(String market, String currency, long quantity, long feeAmount, String feeCurrency, long totalPrice, long tradeTimestamp) {
+		this.market = market;
+		this.currency = currency;
+		this.quantity = quantity;
+		this.feeAmount = feeAmount;
+		this.feeCurrency = feeCurrency;
+		this.totalPrice = totalPrice;
+		this.tradeTimestamp = tradeTimestamp;
+	}
+
+	public String getMarket() {
+		return market;
+	}
+
+	public String getCurrency() {
+		return currency;
+	}
+
+	public long getQuantity() {
+		return quantity;
+	}
+
+	public long getFeeAmount() {
+		return feeAmount;
+	}
+
+	public String getFeeCurrency() {
+		return feeCurrency;
+	}
+
+	public long getTotalPrice() {
+		return totalPrice;
+	}
+
+	public long getTradeTimestamp() {
+		return tradeTimestamp;
+	}
+}

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

@@ -0,0 +1,50 @@
+package org.qortal.api.model;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import java.util.Objects;
+
+// All properties to be converted to JSON via JAXB
+@XmlAccessorType(XmlAccessType.FIELD)
+public class DatasetStatus {
+
+    private String name;
+
+    private long count;
+
+    public DatasetStatus() {}
+
+    public DatasetStatus(String name, long count) {
+        this.name = name;
+        this.count = count;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public long getCount() {
+        return count;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        DatasetStatus that = (DatasetStatus) o;
+        return count == that.count && Objects.equals(name, that.name);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name, count);
+    }
+
+    @Override
+    public String toString() {
+        return "DatasetStatus{" +
+                "name='" + name + '\'' +
+                ", count=" + count +
+                '}';
+    }
+}

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 Required
+     *
+     *  web search, LTC fee required = 1000L
+     */
+    private long feeRequired;
+
+    /**
+     * 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 getFeeRequired() {
+        return this.feeRequired;
+    }
+
+    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 + '\'' +
+                ", feeRequired=" + feeRequired +
+                ", 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/proxy/resource/DevProxyServerResource.java

@@ -142,10 +142,20 @@ public class DevProxyServerResource {
             }
         }
 
+        String lang = request.getParameter("lang");
+        if (lang == null || lang.isBlank()) {
+            lang = "en"; // fallback
+        }
+
+        String theme = request.getParameter("theme");
+        if (theme == null || theme.isBlank()) {
+            theme = "light";
+        }
+
         // Parse and modify output if needed
         if (HTMLParser.isHtmlFile(filename)) {
             // HTML file - needs to be parsed
-            HTMLParser htmlParser = new HTMLParser("", inPath, "", false, data, "proxy", Service.APP, null, "light", true);
+            HTMLParser htmlParser = new HTMLParser("", inPath, "", false, data, "proxy", Service.APP, null, theme , true, lang);
             htmlParser.addAdditionalHeaderTags();
             response.addHeader("Content-Security-Policy", "default-src 'self' 'unsafe-inline' 'unsafe-eval'; media-src 'self' data: blob:; img-src 'self' data: blob:; connect-src 'self' ws:; font-src 'self' data:;");
             response.setContentType(con.getContentType());

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

@@ -16,9 +16,13 @@ import org.qortal.api.model.AggregatedOrder;
 import org.qortal.api.model.TradeWithOrderInfo;
 import org.qortal.api.resource.TransactionsResource.ConfirmationStatus;
 import org.qortal.asset.Asset;
+import org.qortal.controller.hsqldb.HSQLDBBalanceRecorder;
 import org.qortal.crypto.Crypto;
 import org.qortal.data.account.AccountBalanceData;
 import org.qortal.data.account.AccountData;
+import org.qortal.data.account.AddressAmountData;
+import org.qortal.data.account.BlockHeightRange;
+import org.qortal.data.account.BlockHeightRangeAddressAmounts;
 import org.qortal.data.asset.AssetData;
 import org.qortal.data.asset.OrderData;
 import org.qortal.data.asset.RecentTradeData;
@@ -33,6 +37,7 @@ import org.qortal.transaction.Transaction;
 import org.qortal.transaction.Transaction.ValidationResult;
 import org.qortal.transform.TransformationException;
 import org.qortal.transform.transaction.*;
+import org.qortal.utils.BalanceRecorderUtils;
 import org.qortal.utils.Base58;
 
 import javax.servlet.http.HttpServletRequest;
@@ -42,6 +47,7 @@ import javax.ws.rs.core.MediaType;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
+import java.util.Optional;
 import java.util.stream.Collectors;
 
 @Path("/assets")
@@ -179,6 +185,122 @@ public class AssetsResource {
 		}
 	}
 
+	@GET
+	@Path("/balancedynamicranges")
+	@Operation(
+			summary = "Get balance dynamic ranges listed.",
+			description = ".",
+			responses = {
+					@ApiResponse(
+							content = @Content(
+									array = @ArraySchema(
+											schema = @Schema(
+													implementation = BlockHeightRange.class
+											)
+									)
+							)
+					)
+			}
+	)
+	public List<BlockHeightRange> getBalanceDynamicRanges(
+			@Parameter(ref = "offset") @QueryParam("offset") Integer offset,
+			@Parameter(ref = "limit") @QueryParam("limit") Integer limit,
+			@Parameter(ref = "reverse") @QueryParam("reverse") Boolean reverse) {
+
+		Optional<HSQLDBBalanceRecorder> recorder = HSQLDBBalanceRecorder.getInstance();
+
+		if( recorder.isPresent()) {
+			return recorder.get().getRanges(offset, limit, reverse);
+		}
+		else {
+			return new ArrayList<>(0);
+		}
+	}
+
+	@GET
+	@Path("/balancedynamicrange/{height}")
+	@Operation(
+			summary = "Get balance dynamic range for a given height.",
+			description = ".",
+			responses = {
+					@ApiResponse(
+							content = @Content(
+										schema = @Schema(
+												implementation = BlockHeightRange.class
+										)
+							)
+					)
+			}
+	)
+	@ApiErrors({
+			ApiError.INVALID_CRITERIA, ApiError.INVALID_DATA
+	})
+	public BlockHeightRange getBalanceDynamicRange(@PathParam("height") int height) {
+
+		Optional<HSQLDBBalanceRecorder> recorder = HSQLDBBalanceRecorder.getInstance();
+
+		if( recorder.isPresent()) {
+			Optional<BlockHeightRange> range = recorder.get().getRange(height);
+
+			if( range.isPresent() ) {
+				return range.get();
+			}
+			else {
+				throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_CRITERIA);
+			}
+		}
+		else {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_DATA);
+		}
+	}
+
+	@GET
+	@Path("/balancedynamicamounts/{begin}/{end}")
+	@Operation(
+			summary = "Get balance dynamic ranges address amounts listed.",
+			description = ".",
+			responses = {
+					@ApiResponse(
+							content = @Content(
+									array = @ArraySchema(
+											schema = @Schema(
+													implementation = AddressAmountData.class
+											)
+									)
+							)
+					)
+			}
+	)
+	@ApiErrors({
+			ApiError.INVALID_CRITERIA, ApiError.INVALID_DATA
+	})
+	public List<AddressAmountData> getBalanceDynamicAddressAmounts(
+			@PathParam("begin") int begin,
+			@PathParam("end") int end,
+			@Parameter(ref = "offset") @QueryParam("offset") Integer offset,
+			@Parameter(ref = "limit") @QueryParam("limit") Integer limit) {
+
+		Optional<HSQLDBBalanceRecorder> recorder = HSQLDBBalanceRecorder.getInstance();
+
+		if( recorder.isPresent()) {
+			Optional<BlockHeightRangeAddressAmounts> addressAmounts = recorder.get().getAddressAmounts(new BlockHeightRange(begin, end, false));
+
+			if( addressAmounts.isPresent() ) {
+				return addressAmounts.get().getAmounts().stream()
+					.sorted(BalanceRecorderUtils.ADDRESS_AMOUNT_DATA_COMPARATOR.reversed())
+					.skip(offset)
+					.limit(limit)
+					.collect(Collectors.toList());
+			}
+			else {
+				throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_CRITERIA);
+			}
+		}
+		else {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_DATA);
+		}
+	}
+
 	@GET
 	@Path("/openorders/{assetid}/{otherassetid}")
 	@Operation(

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

@@ -19,6 +19,8 @@ import org.qortal.crypto.Crypto;
 import org.qortal.data.account.AccountData;
 import org.qortal.data.block.BlockData;
 import org.qortal.data.block.BlockSummaryData;
+import org.qortal.data.block.DecodedOnlineAccountData;
+import org.qortal.data.network.OnlineAccountData;
 import org.qortal.data.transaction.TransactionData;
 import org.qortal.repository.BlockArchiveReader;
 import org.qortal.repository.DataException;
@@ -27,6 +29,7 @@ import org.qortal.repository.RepositoryManager;
 import org.qortal.transform.TransformationException;
 import org.qortal.transform.block.BlockTransformer;
 import org.qortal.utils.Base58;
+import org.qortal.utils.Blocks;
 import org.qortal.utils.Triple;
 
 import javax.servlet.http.HttpServletRequest;
@@ -45,6 +48,7 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Comparator;
 import java.util.List;
+import java.util.Set;
 
 @Path("/blocks")
 @Tag(name = "Blocks")
@@ -86,7 +90,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 +99,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 +308,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 +478,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 +487,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;
@@ -542,6 +546,7 @@ public class BlocksResource {
 				}
 			}
 
+			String minterAddress = Account.getRewardShareMintingAddress(repository, blockData.getMinterPublicKey());
 			int minterLevel = Account.getRewardShareEffectiveMintingLevel(repository, blockData.getMinterPublicKey());
 			if (minterLevel == 0)
 				// This may be unavailable when requesting a trimmed block
@@ -554,6 +559,7 @@ public class BlocksResource {
 
 			BlockMintingInfo blockMintingInfo = new BlockMintingInfo();
 			blockMintingInfo.minterPublicKey = blockData.getMinterPublicKey();
+			blockMintingInfo.minterAddress = minterAddress;
 			blockMintingInfo.minterLevel = minterLevel;
 			blockMintingInfo.onlineAccountsCount = blockData.getOnlineAccountsCount();
 			blockMintingInfo.maxDistance = new BigDecimal(block.MAX_DISTANCE);
@@ -596,7 +602,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 +620,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 +657,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 +670,7 @@ public class BlocksResource {
 						break;
 					}
 				}
-				if (includeOnlineSignatures == null || includeOnlineSignatures == false) {
+				if (includeOnlineSignatures == null || !includeOnlineSignatures) {
 					blockData.setOnlineAccountsSignatures(null);
 				}
 
@@ -888,4 +894,49 @@ public class BlocksResource {
 		}
 	}
 
-}
+	@GET
+	@Path("/onlineaccounts/{height}")
+	@Operation(
+			summary = "Get online accounts for block",
+			description = "Returns the online accounts who submitted signatures for this block",
+			responses = {
+					@ApiResponse(
+							description = "online accounts",
+							content = @Content(
+									array = @ArraySchema(
+											schema = @Schema(
+													implementation = DecodedOnlineAccountData.class
+											)
+									)
+							)
+					)
+			}
+	)
+	@ApiErrors({
+			ApiError.BLOCK_UNKNOWN, ApiError.REPOSITORY_ISSUE
+	})
+	public Set<DecodedOnlineAccountData> getOnlineAccounts(@PathParam("height") int height) {
+
+		try (final Repository repository = RepositoryManager.getRepository()) {
+
+			// get block from database
+			BlockData blockData = repository.getBlockRepository().fromHeight(height);
+
+			// if block data is not in the database, then try the archive
+			if (blockData == null) {
+				blockData = repository.getBlockArchiveRepository().fromHeight(height);
+
+				// if the block is not in the database or the archive, then the block is unknown
+				if( blockData == null ) {
+					throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.BLOCK_UNKNOWN);
+				}
+			}
+
+			Set<DecodedOnlineAccountData> onlineAccounts = Blocks.getDecodedOnlineAccountsForBlock(repository, blockData);
+
+			return onlineAccounts;
+		} catch (DataException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.REPOSITORY_ISSUE);
+		}
+	}
+}

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

@@ -234,17 +234,21 @@ public class ChatResource {
 		}
 	)
 	@ApiErrors({ApiError.INVALID_CRITERIA, ApiError.INVALID_ADDRESS, ApiError.REPOSITORY_ISSUE})
-	public ActiveChats getActiveChats(@PathParam("address") String address, @QueryParam("encoding") Encoding encoding) {
+	public ActiveChats getActiveChats(
+		@PathParam("address") String address,
+		@QueryParam("encoding") Encoding encoding,
+		@QueryParam("haschatreference") Boolean hasChatReference
+	) {
 		if (address == null || !Crypto.isValidAddress(address))
 			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_ADDRESS);
-
+	
 		try (final Repository repository = RepositoryManager.getRepository()) {
-			return repository.getChatRepository().getActiveChats(address, encoding);
+			return repository.getChatRepository().getActiveChats(address, encoding, hasChatReference);
 		} catch (DataException e) {
 			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.REPOSITORY_ISSUE, e);
 		}
 	}
-
+	
 	@POST
 	@Operation(
 		summary = "Build raw, unsigned, CHAT transaction",

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("/feerequired")
+	@Operation(
+			summary = "The total fee required for unlocking BTC to the trade offer creator.",
+			description = "This is in sats for a transaction that is approximately 300 kB in size.",
+			responses = {
+					@ApiResponse(
+							content = @Content(
+									schema = @Schema(
+											type = "number"
+									)
+							)
+					)
+			}
+	)
+	public String getBitcoinFeeRequired() {
+		Bitcoin bitcoin = Bitcoin.getInstance();
+
+		return String.valueOf(bitcoin.getFeeRequired());
+	}
+
+	@POST
+	@Path("/updatefeerequired")
+	@Operation(
+			summary = "The total fee required for unlocking BTC to the trade offer creator.",
+			description = "This is in sats for a transaction that is approximately 300 kB in size.",
+			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 setBitcoinFeeRequired(@HeaderParam(Security.API_KEY_HEADER) String apiKey, String fee) {
+		Security.checkApiCallAllowed(request);
+
+		Bitcoin bitcoin = Bitcoin.getInstance();
+
+		try {
+			return CrossChainUtils.setFeeRequired(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("/feerequired")
+	@Operation(
+			summary = "The total fee required for unlocking DGB to the trade offer creator.",
+			description = "This is in sats for a transaction that is approximately 300 kB in size.",
+			responses = {
+					@ApiResponse(
+							content = @Content(
+									schema = @Schema(
+											type = "number"
+									)
+							)
+					)
+			}
+	)
+	public String getDigibyteFeeRequired() {
+		Digibyte digibyte = Digibyte.getInstance();
+
+		return String.valueOf(digibyte.getFeeRequired());
+	}
+
+	@POST
+	@Path("/updatefeerequired")
+	@Operation(
+			summary = "The total fee required for unlocking DGB to the trade offer creator.",
+			description = "This is in sats for a transaction that is approximately 300 kB in size.",
+			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 setDigibyteFeeRequired(@HeaderParam(Security.API_KEY_HEADER) String apiKey, String fee) {
+		Security.checkApiCallAllowed(request);
+
+		Digibyte digibyte = Digibyte.getInstance();
+
+		try {
+			return CrossChainUtils.setFeeRequired(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("/feerequired")
+	@Operation(
+			summary = "The total fee required for unlocking DOGE to the trade offer creator.",
+			description = "This is in sats for a transaction that is approximately 300 kB in size.",
+			responses = {
+					@ApiResponse(
+							content = @Content(
+									schema = @Schema(
+											type = "number"
+									)
+							)
+					)
+			}
+	)
+	public String getDogecoinFeeRequired() {
+		Dogecoin dogecoin = Dogecoin.getInstance();
+
+		return String.valueOf(dogecoin.getFeeRequired());
+	}
+
+	@POST
+	@Path("/updatefeerequired")
+	@Operation(
+			summary = "The total fee required for unlocking DOGE to the trade offer creator.",
+			description = "This is in sats for a transaction that is approximately 300 kB in size.",
+			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 setDogecoinFeeRequired(@HeaderParam(Security.API_KEY_HEADER) String apiKey, String fee) {
+		Security.checkApiCallAllowed(request);
+
+		Dogecoin dogecoin = Dogecoin.getInstance();
+
+		try {
+			return CrossChainUtils.setFeeRequired(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("/feerequired")
+	@Operation(
+			summary = "The total fee required for unlocking LTC to the trade offer creator.",
+			description = "This is in sats for a transaction that is approximately 300 kB in size.",
+			responses = {
+					@ApiResponse(
+							content = @Content(
+									schema = @Schema(
+											type = "number"
+									)
+							)
+					)
+			}
+	)
+	public String getLitecoinFeeRequired() {
+		Litecoin litecoin = Litecoin.getInstance();
+
+		return String.valueOf(litecoin.getFeeRequired());
+	}
+
+	@POST
+	@Path("/updatefeerequired")
+	@Operation(
+			summary = "The total fee required for unlocking LTC to the trade offer creator.",
+			description = "This is in sats for a transaction that is approximately 300 kB in size.",
+			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 setLitecoinFeeRequired(@HeaderParam(Security.API_KEY_HEADER) String apiKey, String fee) {
+		Security.checkApiCallAllowed(request);
+
+		Litecoin litecoin = Litecoin.getInstance();
+
+		try {
+			return CrossChainUtils.setFeeRequired(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("/feerequired")
+	@Operation(
+			summary = "The total fee required for unlocking ARRR to the trade offer creator.",
+			description = "The total fee required for unlocking ARRR to the trade offer creator.",
+			responses = {
+					@ApiResponse(
+							content = @Content(
+									schema = @Schema(
+											type = "number"
+									)
+							)
+					)
+			}
+	)
+	public String getPirateChainFeeRequired() {
+		PirateChain pirateChain = PirateChain.getInstance();
+
+		return String.valueOf(pirateChain.getFeeRequired());
+	}
+
+	@POST
+	@Path("/updatefeerequired")
+	@Operation(
+			summary = "The total fee required for unlocking ARRR to the trade offer creator.",
+			description = "This is in sats for a transaction that is approximately 300 kB in size.",
+			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 setPirateChainFeeRequired(@HeaderParam(Security.API_KEY_HEADER) String apiKey, String fee) {
+		Security.checkApiCallAllowed(request);
+
+		PirateChain pirateChain = PirateChain.getInstance();
+
+		try {
+			return CrossChainUtils.setFeeRequired(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("/feerequired")
+	@Operation(
+			summary = "The total fee required for unlocking RVN to the trade offer creator.",
+			description = "This is in sats for a transaction that is approximately 300 kB in size.",
+			responses = {
+					@ApiResponse(
+							content = @Content(
+									schema = @Schema(
+											type = "number"
+									)
+							)
+					)
+			}
+	)
+	public String getRavencoinFeeRequired() {
+		Ravencoin ravencoin = Ravencoin.getInstance();
+
+		return String.valueOf(ravencoin.getFeeRequired());
+	}
+
+	@POST
+	@Path("/updatefeerequired")
+	@Operation(
+			summary = "The total fee required for unlocking RVN to the trade offer creator.",
+			description = "This is in sats for a transaction that is approximately 300 kB in size.",
+			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 setRavencoinFeeRequired(@HeaderParam(Security.API_KEY_HEADER) String apiKey, String fee) {
+		Security.checkApiCallAllowed(request);
+
+		Ravencoin ravencoin = Ravencoin.getInstance();
+
+		try {
+			return CrossChainUtils.setFeeRequired(ravencoin, fee);
+		}
+		catch (IllegalArgumentException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_CRITERIA);
+		}
+	}
 }

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

@@ -10,20 +10,30 @@ import io.swagger.v3.oas.annotations.parameters.RequestBody;
 import io.swagger.v3.oas.annotations.responses.ApiResponse;
 import io.swagger.v3.oas.annotations.security.SecurityRequirement;
 import io.swagger.v3.oas.annotations.tags.Tag;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.glassfish.jersey.media.multipart.ContentDisposition;
 import org.qortal.api.ApiError;
 import org.qortal.api.ApiErrors;
 import org.qortal.api.ApiExceptionFactory;
 import org.qortal.api.Security;
 import org.qortal.api.model.CrossChainCancelRequest;
+import org.qortal.api.model.CrossChainTradeLedgerEntry;
 import org.qortal.api.model.CrossChainTradeSummary;
+import org.qortal.controller.ForeignFeesManager;
 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.crosschain.ForeignFeeDecodedData;
+import org.qortal.data.crosschain.ForeignFeeEncodedData;
 import org.qortal.data.transaction.BaseTransactionData;
 import org.qortal.data.transaction.MessageTransactionData;
 import org.qortal.data.transaction.TransactionData;
@@ -41,20 +51,36 @@ import org.qortal.utils.Base58;
 import org.qortal.utils.ByteArray;
 import org.qortal.utils.NTP;
 
+import javax.servlet.ServletContext;
 import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
 import javax.ws.rs.*;
 import javax.ws.rs.core.Context;
+import javax.ws.rs.core.HttpHeaders;
 import javax.ws.rs.core.MediaType;
+import java.io.IOException;
 import java.util.*;
 import java.util.function.Supplier;
+import java.util.stream.Collectors;
+
+
 
 @Path("/crosschain")
 @Tag(name = "Cross-Chain")
 public class CrossChainResource {
 
+	private static final Logger LOGGER = LogManager.getLogger(CrossChainResource.class);
+
 	@Context
 	HttpServletRequest request;
 
+	@Context
+	HttpServletResponse response;
+
+	@Context
+	ServletContext context;
+
+
 	@GET
 	@Path("/tradeoffers")
 	@Operation(
@@ -251,6 +277,12 @@ public class CrossChainResource {
 				description = "Only return trades that completed on/after this timestamp (milliseconds since epoch)",
 				example = "1597310000000"
 			) @QueryParam("minimumTimestamp") Long minimumTimestamp,
+			@Parameter(
+				description = "Optionally filter by buyer Qortal public key"
+			) @QueryParam("buyerPublicKey") String buyerPublicKey58,
+			@Parameter(
+				description = "Optionally filter by seller Qortal public key"
+			) @QueryParam("sellerPublicKey") String sellerPublicKey58,
 			@Parameter( ref = "limit") @QueryParam("limit") Integer limit,
 			@Parameter( ref = "offset" ) @QueryParam("offset") Integer offset,
 			@Parameter( ref = "reverse" ) @QueryParam("reverse") Boolean reverse) {
@@ -262,6 +294,10 @@ public class CrossChainResource {
 		if (minimumTimestamp != null && minimumTimestamp <= 0)
 			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_CRITERIA);
 
+		// Decode public keys
+		byte[] buyerPublicKey = decodePublicKey(buyerPublicKey58);
+		byte[] sellerPublicKey = decodePublicKey(sellerPublicKey58);
+
 		final Boolean isFinished = Boolean.TRUE;
 
 		try (final Repository repository = RepositoryManager.getRepository()) {
@@ -292,7 +328,7 @@ public class CrossChainResource {
 				byte[] codeHash = acctInfo.getKey().value;
 				ACCT acct = acctInfo.getValue().get();
 
-				List<ATStateData> atStates = repository.getATRepository().getMatchingFinalATStates(codeHash,
+				List<ATStateData> atStates = repository.getATRepository().getMatchingFinalATStates(codeHash, buyerPublicKey, sellerPublicKey,
 						isFinished, acct.getModeByteOffset(), (long) AcctMode.REDEEMED.value, minimumFinalHeight,
 						limit, offset, reverse);
 
@@ -331,6 +367,215 @@ public class CrossChainResource {
 		}
 	}
 
+	@POST
+	@Path("/signedfees")
+	@Operation(
+		summary = "",
+		description = "",
+		requestBody = @RequestBody(
+			required = true,
+				content = @Content(
+					mediaType = MediaType.APPLICATION_JSON,
+					array = @ArraySchema(
+						schema = @Schema(
+								implementation = ForeignFeeEncodedData.class
+						)
+					)
+				)
+		),
+		responses = {
+			@ApiResponse(
+				description = "true on success",
+				content = @Content(
+					mediaType = MediaType.TEXT_PLAIN,
+					schema = @Schema(
+							type = "boolean"
+					)
+				)
+			)
+		}
+	)
+	public String postSignedForeignFees(List<ForeignFeeEncodedData> signedFees) {
+
+		LOGGER.info("signedFees = " + signedFees);
+
+		try {
+			ForeignFeesManager.getInstance().addSignedFees(signedFees);
+
+			return "true";
+		}
+		catch( Exception e ) {
+
+			LOGGER.error(e.getMessage(), e);
+
+			return "false";
+		}
+	}
+
+	@GET
+	@Path("/unsignedfees/{address}")
+	@Operation(
+		summary = "",
+		description = "",
+		responses = {
+			@ApiResponse(
+				content = @Content(
+					array = @ArraySchema(
+						schema = @Schema(
+							implementation = ForeignFeeEncodedData.class
+						)
+					)
+				)
+			)
+		}
+	)
+	@ApiErrors({ApiError.INVALID_CRITERIA, ApiError.REPOSITORY_ISSUE})
+	public List<ForeignFeeEncodedData> getUnsignedFees(@PathParam("address") String address) {
+
+		List<ForeignFeeEncodedData> unsignedFeesForAddress = ForeignFeesManager.getInstance().getUnsignedFeesForAddress(address);
+
+		LOGGER.info("address = " + address);
+		LOGGER.info("returning unsigned = " + unsignedFeesForAddress);
+		return unsignedFeesForAddress;
+	}
+
+	@GET
+	@Path("/signedfees")
+	@Operation(
+		summary = "",
+		description = "",
+		responses = {
+			@ApiResponse(
+				content = @Content(
+					array = @ArraySchema(
+						schema = @Schema(
+							implementation = ForeignFeeDecodedData.class
+						)
+					)
+				)
+			)
+		}
+	)
+	@ApiErrors({ApiError.INVALID_CRITERIA, ApiError.REPOSITORY_ISSUE})
+	public List<ForeignFeeDecodedData> getSignedFees() {
+
+		return ForeignFeesManager.getInstance().getSignedFees();
+	}
+
+	/**
+	 * Decode Public Key
+	 *
+	 * @param publicKey58 the public key in a string
+	 *
+	 * @return the public key in bytes
+	 */
+	private byte[] decodePublicKey(String publicKey58) {
+
+		if( publicKey58 == null ) return null;
+		if( publicKey58.isEmpty() ) return new byte[0];
+
+		byte[] publicKey;
+		try {
+			publicKey = Base58.decode(publicKey58);
+		} catch (NumberFormatException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_PUBLIC_KEY, e);
+		}
+
+		// Correct size for public key?
+		if (publicKey.length != Transformer.PUBLIC_KEY_LENGTH)
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_PUBLIC_KEY);
+
+		return publicKey;
+	}
+
+	@GET
+	@Path("/ledger/{publicKey}")
+	@Operation(
+			summary = "Accounting entries for all trades.",
+			description = "Returns accounting entries for all completed cross-chain trades",
+			responses = {
+					@ApiResponse(
+							content = @Content(
+									schema = @Schema(
+											type = "string",
+											format = "byte"
+									)
+							)
+					)
+			}
+	)
+	@ApiErrors({ApiError.INVALID_CRITERIA, ApiError.REPOSITORY_ISSUE})
+	public HttpServletResponse getLedgerEntries(
+			@PathParam("publicKey") String publicKey58,
+			@Parameter(
+					description = "Only return trades that completed on/after this timestamp (milliseconds since epoch)",
+					example = "1597310000000"
+			) @QueryParam("minimumTimestamp") Long minimumTimestamp) {
+
+		byte[] publicKey = decodePublicKey(publicKey58);
+
+		// minimumTimestamp (if given) needs to be positive
+		if (minimumTimestamp != null && minimumTimestamp <= 0)
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_CRITERIA);
+
+		try (final Repository repository = RepositoryManager.getRepository()) {
+			Integer minimumFinalHeight = null;
+
+			if (minimumTimestamp != null) {
+				minimumFinalHeight = repository.getBlockRepository().getHeightFromTimestamp(minimumTimestamp);
+				// If not found in the block repository it will return either 0 or 1
+				if (minimumFinalHeight == 0 || minimumFinalHeight == 1) {
+					// Try the archive
+					minimumFinalHeight = repository.getBlockArchiveRepository().getHeightFromTimestamp(minimumTimestamp);
+				}
+
+				if (minimumFinalHeight == 0)
+					// We don't have any blocks since minimumTimestamp, let alone trades, so nothing to return
+					return response;
+
+				// height returned from repository is for block BEFORE timestamp
+				// but we want trades AFTER timestamp so bump height accordingly
+				minimumFinalHeight++;
+			}
+
+			List<CrossChainTradeLedgerEntry> crossChainTradeLedgerEntries = new ArrayList<>();
+
+			Map<ByteArray, Supplier<ACCT>> acctsByCodeHash = SupportedBlockchain.getAcctMap();
+
+			// collect ledger entries for each ACCT
+			for (Map.Entry<ByteArray, Supplier<ACCT>> acctInfo : acctsByCodeHash.entrySet()) {
+				byte[] codeHash = acctInfo.getKey().value;
+				ACCT acct = acctInfo.getValue().get();
+
+				// collect buys and sells
+				CrossChainUtils.collectLedgerEntries(publicKey, repository, minimumFinalHeight, crossChainTradeLedgerEntries, codeHash, acct, true);
+				CrossChainUtils.collectLedgerEntries(publicKey, repository, minimumFinalHeight, crossChainTradeLedgerEntries, codeHash, acct, false);
+			}
+
+			crossChainTradeLedgerEntries.sort((a, b) -> Longs.compare(a.getTradeTimestamp(), b.getTradeTimestamp()));
+
+			response.setStatus(HttpServletResponse.SC_OK);
+			response.setContentType("text/csv");
+			response.setHeader(
+				HttpHeaders.CONTENT_DISPOSITION,
+				ContentDisposition
+					.type("attachment")
+					.fileName(CrossChainUtils.createLedgerFileName(Crypto.toAddress(publicKey)))
+					.build()
+					.toString()
+			);
+
+			CrossChainUtils.writeToLedger( response.getWriter(), crossChainTradeLedgerEntries);
+
+			return response;
+		} catch (DataException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.REPOSITORY_ISSUE, e);
+		} catch (IOException e) {
+			response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
+			return response;
+		}
+	}
+
 	@GET
 	@Path("/price/{blockchain}")
 	@Operation(
@@ -372,7 +617,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 +742,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,65 @@
 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.CrossChainTradeLedgerEntry;
+import org.qortal.api.model.crosschain.BitcoinyTBDRequest;
+import org.qortal.asset.Asset;
+import org.qortal.crosschain.*;
+import org.qortal.data.account.AccountBalanceData;
+import org.qortal.data.at.ATData;
+import org.qortal.data.at.ATStateData;
+import org.qortal.data.crosschain.*;
+import org.qortal.event.EventBus;
+import org.qortal.event.LockingFeeUpdateEvent;
+import org.qortal.event.RequiredFeeUpdateEvent;
+import org.qortal.repository.DataException;
+import org.qortal.repository.Repository;
+import org.qortal.utils.Amounts;
+import org.qortal.utils.BitTwiddling;
+
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.Writer;
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.*;
+import java.util.function.Function;
+import java.util.stream.Collectors;
 
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
 
 public class CrossChainUtils {
+    public static final String QORT_CURRENCY_CODE = "QORT";
     private static final Logger LOGGER = LogManager.getLogger(CrossChainUtils.class);
+    public static final String CORE_API_CALL = "Core API Call";
+    public static final String QORTAL_EXCHANGE_LABEL = "Qortal";
 
     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 +86,739 @@ 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) );
+
+        EventBus.INSTANCE.notify(new LockingFeeUpdateEvent());
+
+        return String.valueOf(bitcoiny.getFeePerKb().value);
+    }
+
+    /**
+     * Set Fee Required
+     *
+     * @param bitcoiny the blockchain support
+     * @param fee the fee in satoshis
+     *
+     * @return the fee if valid
+     *
+     * @throws IllegalArgumentException if invalid
+     */
+    public static String setFeeRequired(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.setFeeRequired( Long.parseLong(fee));
+
+        EventBus.INSTANCE.notify(new RequiredFeeUpdateEvent(bitcoiny));
+
+        return String.valueOf(bitcoiny.getFeeRequired());
+    }
+
+    /**
+     * 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);
+    }
+
+    public static ChainableServer getCurrentServer( Bitcoiny bitcoiny ) {
+        return bitcoiny.getBlockchainProvider().getCurrentServer();
+    }
+    /**
+     * 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);
+    }
+
+    /**
+     * Write To Ledger
+     *
+     * @param writer the writer to the ledger
+     * @param entries the entries to write to the ledger
+     *
+     * @throws IOException
+     */
+    public static void writeToLedger(Writer writer, List<CrossChainTradeLedgerEntry> entries) throws IOException {
+
+        BufferedWriter bufferedWriter = new BufferedWriter(writer);
+
+        StringJoiner header = new StringJoiner(",");
+        header.add("Market");
+        header.add("Currency");
+        header.add("Quantity");
+        header.add("Commission Paid");
+        header.add("Commission Currency");
+        header.add("Total Price");
+        header.add("Date Time");
+        header.add("Exchange");
+
+        bufferedWriter.append(header.toString());
+
+        DateFormat dateFormatter = new SimpleDateFormat("yyyyMMdd HH:mm");
+        dateFormatter.setTimeZone(TimeZone.getTimeZone("UTC"));
+
+        for( CrossChainTradeLedgerEntry entry : entries ) {
+            StringJoiner joiner = new StringJoiner(",");
+
+            joiner.add(entry.getMarket());
+            joiner.add(entry.getCurrency());
+            joiner.add(String.valueOf(Amounts.prettyAmount(entry.getQuantity())));
+            joiner.add(String.valueOf(Amounts.prettyAmount(entry.getFeeAmount())));
+            joiner.add(entry.getFeeCurrency());
+            joiner.add(String.valueOf(Amounts.prettyAmount(entry.getTotalPrice())));
+            joiner.add(dateFormatter.format(new Date(entry.getTradeTimestamp())));
+            joiner.add(QORTAL_EXCHANGE_LABEL);
+
+            bufferedWriter.newLine();
+            bufferedWriter.append(joiner.toString());
+        }
+
+        bufferedWriter.newLine();
+        bufferedWriter.flush();
+    }
+
+    /**
+     * Create Ledger File Name
+     *
+     * Create a file name the includes timestamp and address.
+     *
+     * @param address the address
+     *
+     * @return the file name created
+     */
+    public static String createLedgerFileName(String address) {
+        DateFormat dateFormatter = new SimpleDateFormat("yyyyMMddHHmmss");
+        String fileName = "ledger-" + address + "-" + dateFormatter.format(new Date());
+        return fileName;
+    }
+
+    /**
+     * Collect Ledger Entries
+     *
+     * @param publicKey the public key for the ledger entries, buy and sell
+     * @param repository the data repository
+     * @param minimumFinalHeight the minimum block height for entries to be collected
+     * @param entries the ledger entries to add to
+     * @param codeHash code hash for the entry blockchain
+     * @param acct the ACCT for the entry blockchain
+     * @param isBuy true collecting entries for a buy, otherwise false
+     *
+     * @throws DataException
+     */
+    public static void collectLedgerEntries(
+            byte[] publicKey,
+            Repository repository,
+            Integer minimumFinalHeight,
+            List<CrossChainTradeLedgerEntry> entries,
+            byte[] codeHash,
+            ACCT acct,
+            boolean isBuy) throws DataException {
+
+        // get all the final AT states for the code hash (foreign coin)
+        List<ATStateData> atStates
+            = repository.getATRepository().getMatchingFinalATStates(
+                codeHash,
+                isBuy ? publicKey : null,
+                !isBuy ? publicKey : null,
+                Boolean.TRUE, acct.getModeByteOffset(),
+                (long) AcctMode.REDEEMED.value,
+                minimumFinalHeight,
+                null, null, false
+        );
+
+        String foreignBlockchainCurrencyCode = acct.getBlockchain().getCurrencyCode();
+
+        // for each trade, build ledger entry, collect ledger entry
+        for (ATStateData atState : atStates) {
+            CrossChainTradeData crossChainTradeData = acct.populateTradeData(repository, atState);
+
+            // We also need block timestamp for use as trade timestamp
+            long localTimestamp = repository.getBlockRepository().getTimestampFromHeight(atState.getHeight());
+
+            if (localTimestamp == 0) {
+                // Try the archive
+                localTimestamp = repository.getBlockArchiveRepository().getTimestampFromHeight(atState.getHeight());
+            }
+
+            CrossChainTradeLedgerEntry ledgerEntry
+                = new CrossChainTradeLedgerEntry(
+                    isBuy ? QORT_CURRENCY_CODE : foreignBlockchainCurrencyCode,
+                    isBuy ? foreignBlockchainCurrencyCode : QORT_CURRENCY_CODE,
+                    isBuy ? crossChainTradeData.qortAmount : crossChainTradeData.expectedForeignAmount,
+                    0,
+                    foreignBlockchainCurrencyCode,
+                    isBuy ? crossChainTradeData.expectedForeignAmount : crossChainTradeData.qortAmount,
+                    localTimestamp);
+
+            entries.add(ledgerEntry);
+        }
+    }
+
+    public static List<CrossChainTradeData> populateTradeDataList(Repository repository, ACCT acct, List<ATData> atDataList) throws DataException {
+
+        if(atDataList.isEmpty()) return new ArrayList<>(0);
+
+        List<ATStateData> latestATStates
+            = repository.getATRepository()
+                .getLatestATStates(
+                    atDataList.stream()
+                        .map(ATData::getATAddress)
+                        .collect(Collectors.toList())
+                );
+
+        Map<String, ATStateData> atStateDataByAtAddress
+            = latestATStates.stream().collect(Collectors.toMap(ATStateData::getATAddress, Function.identity()));
+
+        Map<String, ATData> atDataByAtAddress
+                = atDataList.stream().collect(Collectors.toMap(ATData::getATAddress, Function.identity()));
+
+        Map<String, Long> balanceByAtAddress
+            = repository
+                .getAccountRepository()
+                .getBalances(new ArrayList<>(atDataByAtAddress.keySet()), Asset.QORT)
+                .stream().collect(Collectors.toMap(AccountBalanceData::getAddress, AccountBalanceData::getBalance));
+
+        List<CrossChainTradeData> crossChainTradeDataList = new ArrayList<>(latestATStates.size());
+
+        for( ATStateData atStateData : latestATStates ) {
+            ATData atData = atDataByAtAddress.get(atStateData.getATAddress());
+            crossChainTradeDataList.add(
+                acct.populateTradeData(
+                    repository,
+                    atData.getCreatorPublicKey(),
+                    atData.getCreation(),
+                    atStateData,
+                    OptionalLong.of(balanceByAtAddress.get(atStateData.getATAddress()))
+                )
+            );
+        }
+
+        return crossChainTradeDataList;
+    }
+}

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

@@ -33,6 +33,7 @@ import javax.ws.rs.*;
 import javax.ws.rs.core.Context;
 import javax.ws.rs.core.MediaType;
 import java.util.List;
+import java.util.Optional;
 import java.util.stream.Collectors;
 
 @Path("/names")
@@ -104,6 +105,45 @@ public class NamesResource {
 		}
 	}
 
+	@GET
+	@Path("/primary/{address}")
+	@Operation(
+			summary = "primary name owned by address",
+			responses = {
+					@ApiResponse(
+							description = "registered primary name info",
+							content = @Content(
+									mediaType = MediaType.APPLICATION_JSON,
+									schema = @Schema(implementation = NameSummary.class)
+							)
+					)
+			}
+	)
+	@ApiErrors({ApiError.INVALID_ADDRESS, ApiError.REPOSITORY_ISSUE, ApiError.UNAUTHORIZED})
+	public NameSummary getPrimaryNameByAddress(@PathParam("address") String address) {
+		if (!Crypto.isValidAddress(address))
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_ADDRESS);
+
+		try (final Repository repository = RepositoryManager.getRepository()) {
+
+			if (Settings.getInstance().isLite()) {
+				throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.UNAUTHORIZED);
+			}
+			else {
+				Optional<String> primaryName = repository.getNameRepository().getPrimaryName(address);
+
+				if(primaryName.isPresent()) {
+					return new NameSummary(new NameData(primaryName.get(), address));
+				}
+				else {
+					return new NameSummary((new NameData(null, address)));
+				}
+			}
+		} catch (DataException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.REPOSITORY_ISSUE, e);
+		}
+	}
+
 	@GET
 	@Path("/{name}")
 	@Operation(

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

@@ -32,13 +32,16 @@ import org.qortal.controller.Synchronizer.SynchronizationResult;
 import org.qortal.controller.repository.BlockArchiveRebuilder;
 import org.qortal.data.account.MintingAccountData;
 import org.qortal.data.account.RewardShareData;
+import org.qortal.data.system.DbConnectionInfo;
 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;
 import org.qortal.settings.Settings;
+import org.qortal.data.system.SystemInfo;
 import org.qortal.utils.Base58;
 import org.qortal.utils.NTP;
 
@@ -51,6 +54,7 @@ import java.net.InetSocketAddress;
 import java.net.UnknownHostException;
 import java.nio.file.Files;
 import java.nio.file.Paths;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
@@ -458,7 +462,7 @@ public class AdminResource {
 
 			// Qortal: check reward-share's minting account is still allowed to mint
 			Account rewardShareMintingAccount = new Account(repository, rewardShareData.getMinter());
-			if (!rewardShareMintingAccount.canMint())
+			if (!rewardShareMintingAccount.canMint(false))
 				throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.CANNOT_MINT);
 
 			MintingAccountData mintingAccountData = new MintingAccountData(mintingAccount.getPrivateKey(), mintingAccount.getPublicKey());
@@ -894,6 +898,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 +1014,6 @@ public class AdminResource {
 		}
 	}
 
-
-
 	@POST
 	@Path("/apikey/generate")
 	@Operation(
@@ -1021,4 +1067,29 @@ public class AdminResource {
 		return "true";
 	}
 
-}
+	@GET
+	@Path("/systeminfo")
+	@Operation(
+			summary = "System Information",
+			description = "System memory usage and available processors.",
+			responses = {
+					@ApiResponse(
+							description = "memory usage and available processors",
+							content = @Content(mediaType = MediaType.APPLICATION_JSON, schema = @Schema(implementation = SystemInfo.class))
+					)
+			}
+	)
+	@ApiErrors({ApiError.REPOSITORY_ISSUE})
+	public SystemInfo getSystemInformation() {
+
+		SystemInfo info
+			= new SystemInfo(
+				Runtime.getRuntime().freeMemory(),
+				Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory(),
+				Runtime.getRuntime().totalMemory(),
+				Runtime.getRuntime().maxMemory(),
+				Runtime.getRuntime().availableProcessors());
+
+		return info;
+	}
+}

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

@@ -71,33 +71,33 @@ public class RenderResource {
     @Path("/signature/{signature}")
     @SecurityRequirement(name = "apiKey")
     public HttpServletResponse getIndexBySignature(@PathParam("signature") String signature,
-                                                   @QueryParam("theme") String theme) {
+                                                   @QueryParam("theme") String theme, @QueryParam("lang") String lang) {
         if (!Settings.getInstance().isQDNAuthBypassEnabled())
             Security.requirePriorAuthorization(request, signature, Service.WEBSITE, null);
 
-        return this.get(signature, ResourceIdType.SIGNATURE, null, null, "/", null, "/render/signature", true, true, theme);
+        return this.get(signature, ResourceIdType.SIGNATURE, null, null, "/", null, "/render/signature", true, true, theme, lang);
     }
 
     @GET
     @Path("/signature/{signature}/{path:.*}")
     @SecurityRequirement(name = "apiKey")
     public HttpServletResponse getPathBySignature(@PathParam("signature") String signature, @PathParam("path") String inPath,
-                                                  @QueryParam("theme") String theme) {
+                                                  @QueryParam("theme") String theme, @QueryParam("lang") String lang) {
         if (!Settings.getInstance().isQDNAuthBypassEnabled())
             Security.requirePriorAuthorization(request, signature, Service.WEBSITE, null);
 
-        return this.get(signature, ResourceIdType.SIGNATURE, null, null, inPath,null, "/render/signature", true, true, theme);
+        return this.get(signature, ResourceIdType.SIGNATURE, null, null, inPath,null, "/render/signature", true, true, theme, lang);
     }
 
     @GET
     @Path("/hash/{hash}")
     @SecurityRequirement(name = "apiKey")
     public HttpServletResponse getIndexByHash(@PathParam("hash") String hash58, @QueryParam("secret") String secret58,
-                                              @QueryParam("theme") String theme) {
+                                              @QueryParam("theme") String theme,  @QueryParam("lang") String lang) {
         if (!Settings.getInstance().isQDNAuthBypassEnabled())
             Security.requirePriorAuthorization(request, hash58, Service.WEBSITE, null);
 
-        return this.get(hash58, ResourceIdType.FILE_HASH, Service.ARBITRARY_DATA, null, "/", secret58, "/render/hash", true, false, theme);
+        return this.get(hash58, ResourceIdType.FILE_HASH, Service.ARBITRARY_DATA, null, "/", secret58, "/render/hash", true, false, theme, lang);
     }
 
     @GET
@@ -105,11 +105,11 @@ public class RenderResource {
     @SecurityRequirement(name = "apiKey")
     public HttpServletResponse getPathByHash(@PathParam("hash") String hash58, @PathParam("path") String inPath,
                                              @QueryParam("secret") String secret58,
-                                             @QueryParam("theme") String theme) {
+                                             @QueryParam("theme") String theme, @QueryParam("lang") String lang) {
         if (!Settings.getInstance().isQDNAuthBypassEnabled())
             Security.requirePriorAuthorization(request, hash58, Service.WEBSITE, null);
 
-        return this.get(hash58, ResourceIdType.FILE_HASH, Service.ARBITRARY_DATA, null, inPath, secret58, "/render/hash", true, false, theme);
+        return this.get(hash58, ResourceIdType.FILE_HASH, Service.ARBITRARY_DATA, null, inPath, secret58, "/render/hash", true, false, theme, lang);
     }
 
     @GET
@@ -119,12 +119,12 @@ public class RenderResource {
                                              @PathParam("name") String name,
                                              @PathParam("path") String inPath,
                                              @QueryParam("identifier") String identifier,
-                                             @QueryParam("theme") String theme) {
+                                             @QueryParam("theme") String theme, @QueryParam("lang") String lang) {
         if (!Settings.getInstance().isQDNAuthBypassEnabled())
             Security.requirePriorAuthorization(request, name, service, null);
 
         String prefix = String.format("/render/%s", service);
-        return this.get(name, ResourceIdType.NAME, service, identifier, inPath, null, prefix, true, true, theme);
+        return this.get(name, ResourceIdType.NAME, service, identifier, inPath, null, prefix, true, true, theme, lang);
     }
 
     @GET
@@ -133,18 +133,18 @@ public class RenderResource {
     public HttpServletResponse getIndexByName(@PathParam("service") Service service,
                                               @PathParam("name") String name,
                                               @QueryParam("identifier") String identifier,
-                                              @QueryParam("theme") String theme) {
+                                              @QueryParam("theme") String theme, @QueryParam("lang") String lang) {
         if (!Settings.getInstance().isQDNAuthBypassEnabled())
             Security.requirePriorAuthorization(request, name, service, null);
 
         String prefix = String.format("/render/%s", service);
-        return this.get(name, ResourceIdType.NAME, service, identifier, "/", null, prefix, true, true, theme);
+        return this.get(name, ResourceIdType.NAME, service, identifier, "/", null, prefix, true, true, theme, lang);
     }
 
 
 
     private HttpServletResponse get(String resourceId, ResourceIdType resourceIdType, Service service, String identifier,
-                                    String inPath, String secret58, String prefix, boolean includeResourceIdInPrefix, boolean async, String theme) {
+                                    String inPath, String secret58, String prefix, boolean includeResourceIdInPrefix, boolean async, String theme, String lang) {
 
         ArbitraryDataRenderer renderer = new ArbitraryDataRenderer(resourceId, resourceIdType, service, identifier, inPath,
                 secret58, prefix, includeResourceIdInPrefix, async, "render", request, response, context);
@@ -152,6 +152,9 @@ public class RenderResource {
         if (theme != null) {
             renderer.setTheme(theme);
         }
+        if (lang != null) {
+            renderer.setLang(lang);
+        }
         return renderer.render();
     }
 

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

@@ -77,7 +77,9 @@ public class ActiveChatsWebSocket extends ApiWebSocket {
 		}
 
 		try (final Repository repository = RepositoryManager.getRepository()) {
-			ActiveChats activeChats = repository.getChatRepository().getActiveChats(ourAddress, getTargetEncoding(session));
+			Boolean hasChatReference = getHasChatReference(session);
+
+			ActiveChats activeChats = repository.getChatRepository().getActiveChats(ourAddress, getTargetEncoding(session), hasChatReference);
 
 			StringWriter stringWriter = new StringWriter();
 
@@ -103,4 +105,20 @@ public class ActiveChatsWebSocket extends ApiWebSocket {
 		return Encoding.valueOf(encoding);
 	}
 
+	private Boolean getHasChatReference(Session session) {
+		Map<String, List<String>> queryParams = session.getUpgradeRequest().getParameterMap();
+		List<String> hasChatReferenceList = queryParams.get("haschatreference");
+	
+		// Return null if not specified
+		if (hasChatReferenceList != null && hasChatReferenceList.size() == 1) {
+			String value = hasChatReferenceList.get(0).toLowerCase();
+			if (value.equals("true")) {
+				return true;
+			} else if (value.equals("false")) {
+				return false;
+			}
+		}
+		return null; // Ignored if not present
+	}
+
 }

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

@@ -0,0 +1,102 @@
+package org.qortal.api.websocket;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.eclipse.jetty.websocket.api.Session;
+import org.eclipse.jetty.websocket.api.WebSocketException;
+import org.eclipse.jetty.websocket.api.annotations.OnWebSocketClose;
+import org.eclipse.jetty.websocket.api.annotations.OnWebSocketConnect;
+import org.eclipse.jetty.websocket.api.annotations.OnWebSocketError;
+import org.eclipse.jetty.websocket.api.annotations.OnWebSocketMessage;
+import org.eclipse.jetty.websocket.api.annotations.WebSocket;
+import org.eclipse.jetty.websocket.servlet.WebSocketServletFactory;
+import org.qortal.api.ApiError;
+import org.qortal.controller.Controller;
+import org.qortal.data.arbitrary.DataMonitorInfo;
+import org.qortal.event.DataMonitorEvent;
+import org.qortal.event.Event;
+import org.qortal.event.EventBus;
+import org.qortal.event.Listener;
+import org.qortal.repository.DataException;
+import org.qortal.repository.Repository;
+import org.qortal.repository.RepositoryManager;
+import org.qortal.utils.Base58;
+
+import java.io.IOException;
+import java.io.StringWriter;
+import java.util.List;
+
+@WebSocket
+@SuppressWarnings("serial")
+public class DataMonitorSocket extends ApiWebSocket implements Listener {
+
+	private static final Logger LOGGER = LogManager.getLogger(DataMonitorSocket.class);
+
+	@Override
+	public void configure(WebSocketServletFactory factory) {
+		LOGGER.info("configure");
+
+		factory.register(DataMonitorSocket.class);
+
+		EventBus.INSTANCE.addListener(this);
+	}
+
+	@Override
+	public void listen(Event event) {
+		if (!(event instanceof DataMonitorEvent))
+			return;
+
+		DataMonitorEvent dataMonitorEvent = (DataMonitorEvent) event;
+
+		for (Session session : getSessions())
+			sendDataEventSummary(session, buildInfo(dataMonitorEvent));
+	}
+
+	private DataMonitorInfo buildInfo(DataMonitorEvent dataMonitorEvent) {
+
+		return new DataMonitorInfo(
+			dataMonitorEvent.getTimestamp(),
+			dataMonitorEvent.getIdentifier(),
+			dataMonitorEvent.getName(),
+			dataMonitorEvent.getService(),
+			dataMonitorEvent.getDescription(),
+			dataMonitorEvent.getTransactionTimestamp(),
+			dataMonitorEvent.getLatestPutTimestamp()
+		);
+	}
+
+	@OnWebSocketConnect
+	@Override
+	public void onWebSocketConnect(Session session) {
+		super.onWebSocketConnect(session);
+	}
+
+	@OnWebSocketClose
+	@Override
+	public void onWebSocketClose(Session session, int statusCode, String reason) {
+		super.onWebSocketClose(session, statusCode, reason);
+	}
+
+	@OnWebSocketError
+	public void onWebSocketError(Session session, Throwable throwable) {
+		/* We ignore errors for now, but method here to silence log spam */
+	}
+
+	@OnWebSocketMessage
+	public void onWebSocketMessage(Session session, String message) {
+		LOGGER.info("onWebSocketMessage: message = " + message);
+	}
+
+	private void sendDataEventSummary(Session session, DataMonitorInfo dataMonitorInfo) {
+		StringWriter stringWriter = new StringWriter();
+
+		try {
+			marshall(stringWriter, dataMonitorInfo);
+
+			session.getRemote().sendStringByFuture(stringWriter.toString());
+		} catch (IOException | WebSocketException e) {
+			// No output this time
+		}
+	}
+
+}

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
@@ -98,7 +98,7 @@ public class TradeOffersWebSocket extends ApiWebSocket implements Listener {
 						byte[] codeHash = acctInfo.getKey().value;
 						ACCT acct = acctInfo.getValue().get();
 
-						List<ATStateData> atStates = repository.getATRepository().getMatchingFinalATStates(codeHash,
+						List<ATStateData> atStates = repository.getATRepository().getMatchingFinalATStates(codeHash, null, null,
 								isFinished, dataByteOffset, expectedValue, minimumFinalHeight,
 								null, null, null);
 
@@ -259,7 +259,7 @@ public class TradeOffersWebSocket extends ApiWebSocket implements Listener {
 				ACCT acct = acctInfo.getValue().get();
 
 				Integer dataByteOffset = acct.getModeByteOffset();
-				List<ATStateData> initialAtStates = repository.getATRepository().getMatchingFinalATStates(codeHash,
+				List<ATStateData> initialAtStates = repository.getATRepository().getMatchingFinalATStates(codeHash, null, null,
 					isFinished, dataByteOffset, expectedValue, minimumFinalHeight,
 					null, null, null);
 
@@ -298,7 +298,7 @@ public class TradeOffersWebSocket extends ApiWebSocket implements Listener {
 				byte[] codeHash = acctInfo.getKey().value;
 				ACCT acct = acctInfo.getValue().get();
 
-				List<ATStateData> historicAtStates = repository.getATRepository().getMatchingFinalATStates(codeHash,
+				List<ATStateData> historicAtStates = repository.getATRepository().getMatchingFinalATStates(codeHash, null, null,
 					isFinished, dataByteOffset, expectedValue, minimumFinalHeight,
 					null, null, null);
 

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/api/websocket/UnsignedFeesSocket.java

@@ -0,0 +1,83 @@
+package org.qortal.api.websocket;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.eclipse.jetty.websocket.api.Session;
+import org.eclipse.jetty.websocket.api.WebSocketException;
+import org.eclipse.jetty.websocket.api.annotations.OnWebSocketClose;
+import org.eclipse.jetty.websocket.api.annotations.OnWebSocketConnect;
+import org.eclipse.jetty.websocket.api.annotations.OnWebSocketError;
+import org.eclipse.jetty.websocket.api.annotations.OnWebSocketMessage;
+import org.eclipse.jetty.websocket.api.annotations.WebSocket;
+import org.eclipse.jetty.websocket.servlet.WebSocketServletFactory;
+import org.qortal.data.crosschain.UnsignedFeeEvent;
+import org.qortal.event.Event;
+import org.qortal.event.EventBus;
+import org.qortal.event.FeeWaitingEvent;
+import org.qortal.event.Listener;
+
+import java.io.IOException;
+import java.io.StringWriter;
+
+@WebSocket
+@SuppressWarnings("serial")
+public class UnsignedFeesSocket extends ApiWebSocket implements Listener {
+
+	private static final Logger LOGGER = LogManager.getLogger(UnsignedFeesSocket.class);
+
+	@Override
+	public void configure(WebSocketServletFactory factory) {
+		LOGGER.info("configure");
+
+		factory.register(UnsignedFeesSocket.class);
+
+		EventBus.INSTANCE.addListener(this);
+	}
+
+	@Override
+	public void listen(Event event) {
+		if (!(event instanceof FeeWaitingEvent))
+			return;
+
+		for (Session session : getSessions()) {
+			FeeWaitingEvent feeWaitingEvent = (FeeWaitingEvent) event;
+			sendUnsignedFeeEvent(session, new UnsignedFeeEvent(feeWaitingEvent.isPositive(), feeWaitingEvent.getAddress()));
+		}
+	}
+
+
+	@OnWebSocketConnect
+	@Override
+	public void onWebSocketConnect(Session session) {
+		super.onWebSocketConnect(session);
+	}
+
+	@OnWebSocketClose
+	@Override
+	public void onWebSocketClose(Session session, int statusCode, String reason) {
+		super.onWebSocketClose(session, statusCode, reason);
+	}
+
+	@OnWebSocketError
+	public void onWebSocketError(Session session, Throwable throwable) {
+		/* We ignore errors for now, but method here to silence log spam */
+	}
+
+	@OnWebSocketMessage
+	public void onWebSocketMessage(Session session, String message) {
+		LOGGER.info("onWebSocketMessage: message = " + message);
+	}
+
+	private void sendUnsignedFeeEvent(Session session, UnsignedFeeEvent unsignedFeeEvent) {
+		StringWriter stringWriter = new StringWriter();
+
+		try {
+			marshall(stringWriter, unsignedFeeEvent);
+
+			session.getRemote().sendStringByFuture(stringWriter.toString());
+		} catch (IOException | WebSocketException e) {
+			// No output this time
+		}
+	}
+
+}

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

@@ -4,9 +4,12 @@ import org.qortal.repository.DataException;
 import org.qortal.utils.Base58;
 
 import java.io.IOException;
+import java.io.InputStream;
 import java.nio.charset.StandardCharsets;
+import java.nio.file.FileSystem;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.nio.file.Paths;
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
 import java.util.Arrays;
@@ -23,37 +26,53 @@ public class ArbitraryDataDigest {
     }
 
     public void compute() throws IOException, DataException {
-        List<Path> allPaths = Files.walk(path).filter(Files::isRegularFile).sorted().collect(Collectors.toList());
+        List<Path> allPaths = Files.walk(path)
+            .filter(Files::isRegularFile)
+            .sorted()
+            .collect(Collectors.toList());
+    
         Path basePathAbsolute = this.path.toAbsolutePath();
-
+    
         MessageDigest sha256;
         try {
             sha256 = MessageDigest.getInstance("SHA-256");
         } catch (NoSuchAlgorithmException e) {
             throw new DataException("SHA-256 hashing algorithm unavailable");
         }
-
+    
         for (Path path : allPaths) {
             // We need to work with paths relative to the base path, to ensure the same hash
             // is generated on different systems
             Path relativePath = basePathAbsolute.relativize(path.toAbsolutePath());
-
+    
             // Exclude Qortal folder since it can be different each time
             // We only care about hashing the actual user data
             if (relativePath.startsWith(".qortal/")) {
                 continue;
             }
-
+    
+            // Account for \ VS / : Linux VS Windows
+            String pathString = relativePath.toString();
+            if (relativePath.getFileSystem().toString().contains("Windows")) {
+                pathString = pathString.replace("\\", "/");
+            }
+    
             // Hash path
-            byte[] filePathBytes = relativePath.toString().getBytes(StandardCharsets.UTF_8);
+            byte[] filePathBytes = pathString.getBytes(StandardCharsets.UTF_8);
             sha256.update(filePathBytes);
-
-            // Hash contents
-            byte[] fileContent = Files.readAllBytes(path);
-            sha256.update(fileContent);
+    
+            try (InputStream in = Files.newInputStream(path)) {
+                byte[] buffer = new byte[65536]; // 64 KB
+                int bytesRead;
+                while ((bytesRead = in.read(buffer)) != -1) {
+                    sha256.update(buffer, 0, bytesRead);
+                }
+            }
         }
+    
         this.hash = sha256.digest();
     }
+    
 
     public boolean isHashValid(byte[] hash) {
         return Arrays.equals(hash, this.hash);

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

@@ -52,12 +52,15 @@ public class ArbitraryDataFile {
 
     private static final Logger LOGGER = LogManager.getLogger(ArbitraryDataFile.class);
 
-    public static final long MAX_FILE_SIZE = 500 * 1024 * 1024; // 500MiB
+    public static final long MAX_FILE_SIZE = 2L * 1024 * 1024 * 1024; // 2 GiB
     protected static final int MAX_CHUNK_SIZE = 1 * 1024 * 1024; // 1MiB
     public static final int CHUNK_SIZE = 512 * 1024; // 0.5MiB
     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;
         }
 
@@ -439,7 +439,15 @@ public class ArbitraryDataReader {
             // Ensure the complete hash matches the joined chunks
             if (!Arrays.equals(arbitraryDataFile.digest(), transactionData.getData())) {
                 // Delete the invalid file
-                arbitraryDataFile.delete();
+                LOGGER.info("Deleting invalid file: path = " + arbitraryDataFile.getFilePath());
+
+                if( arbitraryDataFile.delete() ) {
+                    LOGGER.info("Deleted invalid file successfully: path = " + arbitraryDataFile.getFilePath());
+                }
+                else {
+                    LOGGER.warn("Could not delete invalid file: path = " + arbitraryDataFile.getFilePath());
+                }
+
                 throw new DataException("Unable to validate complete file hash");
             }
         }

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

@@ -1,6 +1,7 @@
 package org.qortal.arbitrary;
 
 import com.google.common.io.Resources;
+
 import org.apache.commons.io.FileUtils;
 import org.apache.commons.lang3.ArrayUtils;
 import org.apache.logging.log4j.LogManager;
@@ -15,11 +16,13 @@ import org.qortal.settings.Settings;
 import javax.servlet.ServletContext;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
+
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.net.URL;
+
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.nio.file.NoSuchFileException;
@@ -37,6 +40,7 @@ public class ArbitraryDataRenderer {
     private final Service service;
     private final String identifier;
     private String theme = "light";
+    private String lang = "en"; 
     private String inPath;
     private final String secret58;
     private final String prefix;
@@ -166,9 +170,16 @@ public class ArbitraryDataRenderer {
             if (HTMLParser.isHtmlFile(filename)) {
                 // HTML file - needs to be parsed
                 byte[] data = Files.readAllBytes(filePath); // TODO: limit file size that can be read into memory
-                HTMLParser htmlParser = new HTMLParser(resourceId, inPath, prefix, includeResourceIdInPrefix, data, qdnContext, service, identifier, theme, usingCustomRouting);
+                String encodedResourceId;
+
+                if (resourceIdType == ResourceIdType.NAME) {
+                    encodedResourceId = resourceId.replace(" ", "%20");
+                } else {
+                    encodedResourceId = resourceId;
+                }
+                HTMLParser htmlParser = new HTMLParser(encodedResourceId, inPath, prefix, includeResourceIdInPrefix, data, qdnContext, service, identifier, theme, usingCustomRouting, lang);
                 htmlParser.addAdditionalHeaderTags();
-                response.addHeader("Content-Security-Policy", "default-src 'self' 'unsafe-inline' 'unsafe-eval'; media-src 'self' data: blob:; img-src 'self' data: blob:;");
+               response.addHeader("Content-Security-Policy", "default-src 'self' 'unsafe-inline' 'unsafe-eval'; font-src 'self' data:; media-src 'self' data: blob:; img-src 'self' data: blob:; connect-src 'self' wss: blob:;");
                 response.setContentType(context.getMimeType(filename));
                 response.setContentLength(htmlParser.getData().length);
                 response.getOutputStream().write(htmlParser.getData());
@@ -199,7 +210,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) {
@@ -256,5 +267,8 @@ public class ArbitraryDataRenderer {
     public void setTheme(String theme) {
         this.theme = theme;
     }
+    public void setLang(String lang) {
+        this.lang = lang;
+    }    
 
 }

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

@@ -29,6 +29,7 @@ import org.qortal.utils.FilesystemUtils;
 import org.qortal.utils.NTP;
 
 import java.io.IOException;
+import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.List;
@@ -81,7 +82,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;
@@ -197,7 +198,7 @@ public class ArbitraryDataTransactionBuilder {
 
             // We can't use PATCH for on-chain data because this requires the .qortal directory, which can't be put on chain
             final boolean isSingleFileResource = FilesystemUtils.isSingleFileResource(this.path, false);
-            final boolean shouldUseOnChainData = (isSingleFileResource && AES.getEncryptedFileSize(FilesystemUtils.getSingleFileContents(path).length) <= ArbitraryTransaction.MAX_DATA_SIZE);
+            final boolean shouldUseOnChainData = (isSingleFileResource && AES.getEncryptedFileSize(Files.size(path)) <= ArbitraryTransaction.MAX_DATA_SIZE);
             if (shouldUseOnChainData) {
                 LOGGER.info("Data size is small enough to go on chain - using PUT");
                 return Method.PUT;
@@ -245,7 +246,7 @@ public class ArbitraryDataTransactionBuilder {
 
             // Single file resources are handled differently, especially for very small data payloads, as these go on chain
             final boolean isSingleFileResource = FilesystemUtils.isSingleFileResource(path, false);
-            final boolean shouldUseOnChainData = (isSingleFileResource && AES.getEncryptedFileSize(FilesystemUtils.getSingleFileContents(path).length) <= ArbitraryTransaction.MAX_DATA_SIZE);
+            final boolean shouldUseOnChainData = (isSingleFileResource && AES.getEncryptedFileSize(Files.size(path)) <= ArbitraryTransaction.MAX_DATA_SIZE);
 
             // Use zip compression if data isn't going on chain
             Compression compression = shouldUseOnChainData ? Compression.NONE : Compression.ZIP;

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

@@ -37,7 +37,7 @@ public enum Service {
             if (files != null && files[0] != null) {
                 final String extension = FilenameUtils.getExtension(files[0].getName()).toLowerCase();
                 // We must allow blank file extensions because these are used by data published from a plaintext or base64-encoded string
-                final List<String> allowedExtensions = Arrays.asList("zip", "pdf", "txt", "odt", "ods", "doc", "docx", "xls", "xlsx", "ppt", "pptx", "");
+                final List<String> allowedExtensions = Arrays.asList("qortal", "zip", "pdf", "txt", "odt", "ods", "doc", "docx", "xls", "xlsx", "ppt", "pptx", "");
                 if (extension == null || !allowedExtensions.contains(extension)) {
                     return ValidationResult.INVALID_FILE_EXTENSION;
                 }
@@ -62,7 +62,17 @@ public enum Service {
 
             // Custom validation function to require an index HTML file in the root directory
             List<String> fileNames = ArbitraryDataRenderer.indexFiles();
-            String[] files = path.toFile().list();
+            List<String> files;
+
+            // single files are paackaged differently
+            if( path.toFile().isFile() ) {
+                files = new ArrayList<>(1);
+                files.add(path.getFileName().toString());
+            }
+            else {
+                files = new ArrayList<>(Arrays.asList(path.toFile().list()));
+            }
+
             if (files != null) {
                 for (String file : files) {
                     Path fileName = Paths.get(file).getFileName();
@@ -167,7 +177,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

@@ -23,12 +23,12 @@ import org.qortal.data.at.ATStateData;
 import org.qortal.data.block.BlockData;
 import org.qortal.data.block.BlockSummaryData;
 import org.qortal.data.block.BlockTransactionData;
+import org.qortal.data.group.GroupAdminData;
 import org.qortal.data.network.OnlineAccountData;
 import org.qortal.data.transaction.TransactionData;
-import org.qortal.repository.ATRepository;
-import org.qortal.repository.DataException;
-import org.qortal.repository.Repository;
-import org.qortal.repository.TransactionRepository;
+import org.qortal.group.Group;
+import org.qortal.repository.*;
+import org.qortal.settings.Settings;
 import org.qortal.transaction.AtTransaction;
 import org.qortal.transaction.Transaction;
 import org.qortal.transaction.Transaction.ApprovalStatus;
@@ -39,6 +39,7 @@ import org.qortal.transform.block.BlockTransformer;
 import org.qortal.transform.transaction.TransactionTransformer;
 import org.qortal.utils.Amounts;
 import org.qortal.utils.Base58;
+import org.qortal.utils.Groups;
 import org.qortal.utils.NTP;
 
 import java.io.ByteArrayOutputStream;
@@ -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);
@@ -142,11 +144,14 @@ public class Block {
 		private final Account mintingAccount;
 		private final AccountData mintingAccountData;
 		private final boolean isMinterFounder;
+		private final boolean isMinterMember;
 
 		private final Account recipientAccount;
 		private final AccountData recipientAccountData;
 
-		ExpandedAccount(Repository repository, RewardShareData rewardShareData) throws DataException {
+		final BlockChain blockChain = BlockChain.getInstance();
+
+		ExpandedAccount(Repository repository, RewardShareData rewardShareData, int blockHeight) throws DataException {
 			this.rewardShareData = rewardShareData;
 			this.sharePercent = this.rewardShareData.getSharePercent();
 
@@ -155,6 +160,12 @@ public class Block {
 			this.isMinterFounder = Account.isFounder(mintingAccountData.getFlags());
 
 			this.isRecipientAlsoMinter = this.rewardShareData.getRecipient().equals(this.mintingAccount.getAddress());
+			this.isMinterMember
+				= Groups.memberExistsInAnyGroup(
+					repository.getGroupRepository(),
+					Groups.getGroupIdsToMint(BlockChain.getInstance(), blockHeight),
+					this.mintingAccount.getAddress()
+			);
 
 			if (this.isRecipientAlsoMinter) {
 				// Self-share: minter is also recipient
@@ -167,6 +178,19 @@ public class Block {
 			}
 		}
 
+		/**
+		 * Get Effective Minting Level
+		 *
+		 * @return the effective minting level, if a data exception is thrown, it catches the exception and returns a zero
+		 */
+		public int getEffectiveMintingLevel() {
+			try {
+				return this.mintingAccount.getEffectiveMintingLevel();
+			} catch (DataException e) {
+				return 0;
+			}
+		}
+
 		public Account getMintingAccount() {
 			return this.mintingAccount;
 		}
@@ -179,19 +203,23 @@ public class Block {
 		 * <p>
 		 * This is a method, not a final variable, because account's level can change between construction and call,
 		 * e.g. during Block.process() where account levels are bumped right before Block.distributeBlockReward().
-		 * 
+		 *
 		 *  @return account-level share "bin" from blockchain config, or null if founder / none found
 		 */
 		public AccountLevelShareBin getShareBin(int blockHeight) {
-			if (this.isMinterFounder)
+			if (this.isMinterFounder && blockHeight < BlockChain.getInstance().getAdminsReplaceFoundersHeight())
 				return null;
 
 			final int accountLevel = this.mintingAccountData.getLevel();
 			if (accountLevel <= 0)
 				return null; // level 0 isn't included in any share bins
 
+			if (blockHeight >= blockChain.getFixBatchRewardHeight()) {
+				if (!this.isMinterMember)
+					return null; // not member of minter group isn't included in any share bins
+			}
+
 			// Select the correct set of share bins based on block height
-			final BlockChain blockChain = BlockChain.getInstance();
 			final AccountLevelShareBin[] shareBinsByLevel = (blockHeight >= blockChain.getSharesByLevelV2Height()) ?
 					blockChain.getShareBinsByAccountLevelV2() : blockChain.getShareBinsByAccountLevelV1();
 
@@ -260,7 +288,7 @@ public class Block {
 	 * Constructs new Block without loading transactions and AT states.
 	 * <p>
 	 * Transactions and AT states are loaded on first call to getTransactions() or getATStates() respectively.
-	 * 
+	 *
 	 * @param repository
 	 * @param blockData
 	 */
@@ -331,7 +359,7 @@ public class Block {
 
 	/**
 	 * Constructs new Block with empty transaction list, using passed minter account.
-	 * 
+	 *
 	 * @param repository
 	 * @param blockData
 	 * @param minter
@@ -349,7 +377,7 @@ public class Block {
 	 * This constructor typically used when minting a new block.
 	 * <p>
 	 * Note that CIYAM ATs will be executed and AT-Transactions prepended to this block, along with AT state data and fees.
-	 * 
+	 *
 	 * @param repository
 	 * @param parentBlockData
 	 * @param minter
@@ -375,7 +403,7 @@ public class Block {
 		byte[] encodedOnlineAccounts = new byte[0];
 		int onlineAccountsCount = 0;
 		byte[] onlineAccountsSignatures = null;
-		
+
 		if (isBatchRewardDistributionBlock(height)) {
 			// Batch reward distribution block - copy online accounts from recent block with highest online accounts count
 
@@ -396,7 +424,9 @@ public class Block {
 			onlineAccounts.removeIf(a -> a.getNonce() == null || a.getNonce() < 0);
 
 			// After feature trigger, remove any online accounts that are level 0
-			if (height >= BlockChain.getInstance().getOnlineAccountMinterLevelValidationHeight()) {
+			// but only if they are before the ignore level feature trigger
+			if (height < BlockChain.getInstance().getIgnoreLevelForRewardShareHeight() &&
+					height >= BlockChain.getInstance().getOnlineAccountMinterLevelValidationHeight()) {
 				onlineAccounts.removeIf(a -> {
 					try {
 						return Account.getRewardShareEffectiveMintingLevel(repository, a.getPublicKey()) == 0;
@@ -407,6 +437,21 @@ public class Block {
 				});
 			}
 
+			// After feature trigger, remove any online accounts that are not minter group member
+			if (height >= BlockChain.getInstance().getGroupMemberCheckHeight()) {
+				onlineAccounts.removeIf(a -> {
+					try {
+						List<Integer> groupIdsToMint = Groups.getGroupIdsToMint(BlockChain.getInstance(), height);
+						String address = Account.getRewardShareMintingAddress(repository, a.getPublicKey());
+						boolean isMinterGroupMember = Groups.memberExistsInAnyGroup(repository.getGroupRepository(), groupIdsToMint, address);
+						return !isMinterGroupMember;
+					} catch (DataException e) {
+						// Something went wrong, so remove the account
+						return true;
+					}
+				});
+			}
+
 			if (onlineAccounts.isEmpty()) {
 				LOGGER.debug("No online accounts - not even our own?");
 				return null;
@@ -510,7 +555,7 @@ public class Block {
 	 * Mints new block using this block as template, but with different minting account.
 	 * <p>
 	 * NOTE: uses the same transactions list, AT states, etc.
-	 * 
+	 *
 	 * @param minter
 	 * @return
 	 * @throws DataException
@@ -596,7 +641,7 @@ public class Block {
 
 	/**
 	 * Return composite block signature (minterSignature + transactionsSignature).
-	 * 
+	 *
 	 * @return byte[], or null if either component signature is null.
 	 */
 	public byte[] getSignature() {
@@ -611,7 +656,7 @@ public class Block {
 	 * <p>
 	 * We're starting with version 4 as a nod to being newer than successor Qora,
 	 * whose latest block version was 3.
-	 * 
+	 *
 	 * @return 1, 2, 3 or 4
 	 */
 	public int getNextBlockVersion() {
@@ -625,7 +670,7 @@ public class Block {
 	 * Return block's transactions.
 	 * <p>
 	 * If the block was loaded from repository then it's possible this method will call the repository to fetch the transactions if not done already.
-	 * 
+	 *
 	 * @return
 	 * @throws DataException
 	 */
@@ -659,7 +704,7 @@ public class Block {
 	 * If the block was loaded from repository then it's possible this method will call the repository to fetch the AT states if not done already.
 	 * <p>
 	 * <b>Note:</b> AT states fetched from repository only contain summary info, not actual data like serialized state data or AT creation timestamps!
-	 * 
+	 *
 	 * @return
 	 * @throws DataException
 	 */
@@ -695,7 +740,7 @@ public class Block {
 	 * <p>
 	 * Typically called as part of Block.process() or Block.orphan()
 	 * so ideally after any calls to Block.isValid().
-	 * 
+	 *
 	 * @throws DataException
 	 */
 	public List<ExpandedAccount> getExpandedAccounts() throws DataException {
@@ -713,10 +758,12 @@ public class Block {
 
 		List<ExpandedAccount> expandedAccounts = new ArrayList<>();
 
-		for (RewardShareData rewardShare : this.cachedOnlineRewardShares)
-			expandedAccounts.add(new ExpandedAccount(repository, rewardShare));
+		for (RewardShareData rewardShare : this.cachedOnlineRewardShares) {
+			expandedAccounts.add(new ExpandedAccount(repository, rewardShare, this.blockData.getHeight()));
+		}
 
 		this.cachedExpandedAccounts = expandedAccounts;
+		LOGGER.trace(() -> String.format("Online reward-shares after expanded accounts %s", this.cachedOnlineRewardShares));
 
 		return this.cachedExpandedAccounts;
 	}
@@ -725,7 +772,7 @@ public class Block {
 
 	/**
 	 * Load parent block's data from repository via this block's reference.
-	 * 
+	 *
 	 * @return parent's BlockData, or null if no parent found
 	 * @throws DataException
 	 */
@@ -739,7 +786,7 @@ public class Block {
 
 	/**
 	 * Load child block's data from repository via this block's signature.
-	 * 
+	 *
 	 * @return child's BlockData, or null if no parent found
 	 * @throws DataException
 	 */
@@ -759,7 +806,7 @@ public class Block {
 	 * Used when constructing a new block during minting.
 	 * <p>
 	 * Requires block's {@code minter} being a {@code PrivateKeyAccount} so block's transactions signature can be recalculated.
-	 * 
+	 *
 	 * @param transactionData
 	 * @return true if transaction successfully added to block, false otherwise
 	 * @throws IllegalStateException
@@ -812,7 +859,7 @@ public class Block {
 	 * Used when constructing a new block during minting.
 	 * <p>
 	 * Requires block's {@code minter} being a {@code PrivateKeyAccount} so block's transactions signature can be recalculated.
-	 * 
+	 *
 	 * @param transactionData
 	 * @throws IllegalStateException
 	 *             if block's {@code minter} is not a {@code PrivateKeyAccount}.
@@ -857,7 +904,7 @@ public class Block {
 	 * previous block's minter signature + minter's public key + (encoded) online-accounts data
 	 * <p>
 	 * (Previous block's minter signature is extracted from this block's reference).
-	 * 
+	 *
 	 * @throws IllegalStateException
 	 *             if block's {@code minter} is not a {@code PrivateKeyAccount}.
 	 * @throws RuntimeException
@@ -874,7 +921,7 @@ public class Block {
 	 * Recalculate block's transactions signature.
 	 * <p>
 	 * Requires block's {@code minter} being a {@code PrivateKeyAccount}.
-	 * 
+	 *
 	 * @throws IllegalStateException
 	 *             if block's {@code minter} is not a {@code PrivateKeyAccount}.
 	 * @throws RuntimeException
@@ -996,7 +1043,7 @@ public class Block {
 	 * Recalculate block's minter and transactions signatures, thus giving block full signature.
 	 * <p>
 	 * Note: Block instance must have been constructed with a <tt>PrivateKeyAccount</tt> minter or this call will throw an <tt>IllegalStateException</tt>.
-	 * 
+	 *
 	 * @throws IllegalStateException
 	 *             if block's {@code minter} is not a {@code PrivateKeyAccount}.
 	 */
@@ -1009,7 +1056,7 @@ public class Block {
 
 	/**
 	 * Returns whether this block's signatures are valid.
-	 * 
+	 *
 	 * @return true if both minter and transaction signatures are valid, false otherwise
 	 */
 	public boolean isSignatureValid() {
@@ -1033,7 +1080,7 @@ public class Block {
 	 * <p>
 	 * Used by BlockMinter to check whether it's time to mint a new block,
 	 * and also used by Block.isValid for checks (if not a testchain).
-	 * 
+	 *
 	 * @return ValidationResult.OK if timestamp valid, or some other ValidationResult otherwise.
 	 * @throws DataException
 	 */
@@ -1086,7 +1133,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.
@@ -1122,14 +1169,32 @@ public class Block {
 		if (onlineRewardShares == null)
 			return ValidationResult.ONLINE_ACCOUNT_UNKNOWN;
 
-		// After feature trigger, require all online account minters to be greater than level 0
-		if (this.getBlockData().getHeight() >= BlockChain.getInstance().getOnlineAccountMinterLevelValidationHeight()) {
-			List<ExpandedAccount> expandedAccounts = this.getExpandedAccounts();
+		// After feature trigger, require all online account minters to be greater than level 0,
+		// but only if it is before the feature trigger where we ignore level again
+		if (this.blockData.getHeight() < BlockChain.getInstance().getIgnoreLevelForRewardShareHeight() &&
+			this.getBlockData().getHeight() >= BlockChain.getInstance().getOnlineAccountMinterLevelValidationHeight()) {
+			List<ExpandedAccount> expandedAccounts
+					= this.getExpandedAccounts().stream()
+					.filter(expandedAccount -> expandedAccount.isMinterMember)
+					.collect(Collectors.toList());
+
 			for (ExpandedAccount account : expandedAccounts) {
 				if (account.getMintingAccount().getEffectiveMintingLevel() == 0)
 					return ValidationResult.ONLINE_ACCOUNTS_INVALID;
+
+				if (this.getBlockData().getHeight() >= BlockChain.getInstance().getFixBatchRewardHeight()) {
+					if (!account.isMinterMember)
+						return ValidationResult.ONLINE_ACCOUNTS_INVALID;
+				}
 			}
 		}
+		else if (this.blockData.getHeight() >= BlockChain.getInstance().getIgnoreLevelForRewardShareHeight()){
+			Optional<ExpandedAccount> anyInvalidAccount
+					= this.getExpandedAccounts().stream()
+					.filter(account -> !account.isMinterMember)
+					.findAny();
+			if( anyInvalidAccount.isPresent() ) return ValidationResult.ONLINE_ACCOUNTS_INVALID;
+		}
 
 		// If block is past a certain age then we simply assume the signatures were correct
 		long signatureRequirementThreshold = NTP.getTime() - BlockChain.getInstance().getOnlineAccountSignaturesMinLifetime();
@@ -1213,7 +1278,7 @@ public class Block {
 	 * <p>
 	 * Checks block's transactions by testing their validity then processing them.<br>
 	 * Hence uses a repository savepoint during execution.
-	 * 
+	 *
 	 * @return ValidationResult.OK if block is valid, or some other ValidationResult otherwise.
 	 * @throws DataException
 	 */
@@ -1256,6 +1321,7 @@ public class Block {
 
 		// Online Accounts
 		ValidationResult onlineAccountsResult = this.areOnlineAccountsValid();
+		LOGGER.trace("Accounts valid = {}", onlineAccountsResult);
 		if (onlineAccountsResult != ValidationResult.OK)
 			return onlineAccountsResult;
 
@@ -1281,13 +1347,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()) {
@@ -1337,7 +1410,7 @@ public class Block {
 				// Check transaction can even be processed
 				validationResult = transaction.isProcessable();
 				if (validationResult != Transaction.ValidationResult.OK) {
-					LOGGER.info(String.format("Error during transaction validation, tx %s: %s", Base58.encode(transactionData.getSignature()), validationResult.name()));
+					LOGGER.debug(String.format("Error during transaction validation, tx %s: %s", Base58.encode(transactionData.getSignature()), validationResult.name()));
 					return ValidationResult.TRANSACTION_INVALID;
 				}
 
@@ -1377,7 +1450,7 @@ public class Block {
 	 * <p>
 	 * NOTE: will execute ATs locally if not already done.<br>
 	 * This is so we have locally-generated AT states for comparison.
-	 * 
+	 *
 	 * @return OK, or some AT-related validation result
 	 * @throws DataException
 	 */
@@ -1453,11 +1526,11 @@ public class Block {
 	 * Note: this method does not store new AT state data into repository - that is handled by <tt>process()</tt>.
 	 * <p>
 	 * This method is not needed if fetching an existing block from the repository as AT state data will be loaded from repository as well.
-	 * 
+	 *
 	 * @see #isValid()
-	 * 
+	 *
 	 * @throws DataException
-	 * 
+	 *
 	 */
 	private void executeATs() throws DataException {
 		// We're expecting a lack of AT state data at this point.
@@ -1509,7 +1582,7 @@ public class Block {
 			return false;
 
 		Account mintingAccount = new PublicKeyAccount(this.repository, rewardShareData.getMinterPublicKey());
-		return mintingAccount.canMint();
+		return mintingAccount.canMint(false);
 	}
 
 	/**
@@ -1529,7 +1602,7 @@ public class Block {
 
 	/**
 	 * Process block, and its transactions, adding them to the blockchain.
-	 * 
+	 *
 	 * @throws DataException
 	 */
 	public void process() throws DataException {
@@ -1538,6 +1611,7 @@ public class Block {
 		this.blockData.setHeight(blockchainHeight + 1);
 
 		LOGGER.trace(() -> String.format("Processing block %d", this.blockData.getHeight()));
+		LOGGER.trace(() -> String.format("Online Reward Shares in process %s", this.cachedOnlineRewardShares));
 
 		if (this.blockData.getHeight() > 1) {
 
@@ -1550,21 +1624,25 @@ 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);
+				} else if (this.blockData.getHeight() == BlockChain.getInstance().getMultipleNamesPerAccountHeight()) {
+					PrimaryNamesBlock.processNames(this.repository);
+				}
 			}
 		}
 
@@ -1607,7 +1685,17 @@ public class Block {
 		final List<Integer> cumulativeBlocksByLevel = BlockChain.getInstance().getCumulativeBlocksByLevel();
 		final int maximumLevel = cumulativeBlocksByLevel.size() - 1;
 
-		final List<ExpandedAccount> expandedAccounts = this.getExpandedAccounts();
+		final List<ExpandedAccount> expandedAccounts;
+
+		if (this.getBlockData().getHeight() < BlockChain.getInstance().getFixBatchRewardHeight()) {
+			expandedAccounts = this.getExpandedAccounts().stream().collect(Collectors.toList());
+		}
+		else {
+			expandedAccounts
+				= this.getExpandedAccounts().stream()
+					.filter(expandedAccount -> expandedAccount.isMinterMember)
+					.collect(Collectors.toList());
+		}
 
 		Set<AccountData> allUniqueExpandedAccounts = new HashSet<>();
 		for (ExpandedAccount expandedAccount : expandedAccounts) {
@@ -1635,11 +1723,19 @@ public class Block {
 			accountData.setBlocksMinted(accountData.getBlocksMinted() + 1);
 			LOGGER.trace(() -> String.format("Block minter %s up to %d minted block%s", accountData.getAddress(), accountData.getBlocksMinted(), (accountData.getBlocksMinted() != 1 ? "s" : "")));
 
-			final int effectiveBlocksMinted = accountData.getBlocksMinted() + accountData.getBlocksMintedAdjustment() + accountData.getBlocksMintedPenalty();
+			int blocksMintedAdjustment
+				=
+				(this.blockData.getHeight() > BlockChain.getInstance().getMintedBlocksAdjustmentRemovalHeight())
+				?
+				0
+				:
+				accountData.getBlocksMintedAdjustment();
+
+			final int effectiveBlocksMinted = accountData.getBlocksMinted() + blocksMintedAdjustment + accountData.getBlocksMintedPenalty();
 
 			for (int newLevel = maximumLevel; newLevel >= 0; --newLevel)
 				if (effectiveBlocksMinted >= cumulativeBlocksByLevel.get(newLevel)) {
-					if (newLevel > accountData.getLevel()) {
+					if (newLevel != accountData.getLevel()) {
 						// Account has increased in level!
 						accountData.setLevel(newLevel);
 						bumpedAccounts.put(accountData.getAddress(), newLevel);
@@ -1828,7 +1924,7 @@ public class Block {
 
 	/**
 	 * Removes block from blockchain undoing transactions and adding them to unconfirmed pile.
-	 * 
+	 *
 	 * @throws DataException
 	 */
 	public void orphan() throws DataException {
@@ -1850,23 +1946,27 @@ 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 (!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);
+				} else if (this.blockData.getHeight() == BlockChain.getInstance().getMultipleNamesPerAccountHeight()) {
+					PrimaryNamesBlock.orphanNames( this.repository );
+				}
 			}
 
-			if (this.blockData.getHeight() == BlockChain.getInstance().getSelfSponsorshipAlgoV1Height()) {
-				SelfSponsorshipAlgoV1Block.orphanAccountPenalties(this);
-			}
-
-			if (this.blockData.getHeight() == BlockChain.getInstance().getSelfSponsorshipAlgoV2Height()) {
-				SelfSponsorshipAlgoV2Block.orphanAccountPenalties(this);
-			}
-
-			if (this.blockData.getHeight() == BlockChain.getInstance().getSelfSponsorshipAlgoV3Height()) {
-				SelfSponsorshipAlgoV3Block.orphanAccountPenalties(this);
-			}
-			
 			// Account levels and block rewards are only processed/orphaned on block reward distribution blocks
 			if (this.isRewardDistributionBlock()) {
 				// Block rewards, including transaction fees, removed after transactions undone
@@ -2005,7 +2105,17 @@ public class Block {
 		final List<Integer> cumulativeBlocksByLevel = BlockChain.getInstance().getCumulativeBlocksByLevel();
 		final int maximumLevel = cumulativeBlocksByLevel.size() - 1;
 
-		final List<ExpandedAccount> expandedAccounts = this.getExpandedAccounts();
+		final List<ExpandedAccount> expandedAccounts;
+
+		if (this.getBlockData().getHeight() < BlockChain.getInstance().getFixBatchRewardHeight()) {
+			expandedAccounts = this.getExpandedAccounts().stream().collect(Collectors.toList());
+		}
+		else {
+			expandedAccounts
+				= this.getExpandedAccounts().stream()
+					.filter(expandedAccount -> expandedAccount.isMinterMember)
+					.collect(Collectors.toList());
+		}
 
 		Set<AccountData> allUniqueExpandedAccounts = new HashSet<>();
 		for (ExpandedAccount expandedAccount : expandedAccounts) {
@@ -2029,11 +2139,19 @@ public class Block {
 			accountData.setBlocksMinted(accountData.getBlocksMinted() - 1);
 			LOGGER.trace(() -> String.format("Block minter %s down to %d minted block%s", accountData.getAddress(), accountData.getBlocksMinted(), (accountData.getBlocksMinted() != 1 ? "s" : "")));
 
-			final int effectiveBlocksMinted = accountData.getBlocksMinted() + accountData.getBlocksMintedAdjustment() + accountData.getBlocksMintedPenalty();
+			int blocksMintedAdjustment
+				=
+				(this.blockData.getHeight() -1 > BlockChain.getInstance().getMintedBlocksAdjustmentRemovalHeight())
+				?
+				0
+				:
+				accountData.getBlocksMintedAdjustment();
+
+			final int effectiveBlocksMinted = accountData.getBlocksMinted() + blocksMintedAdjustment + accountData.getBlocksMintedPenalty();
 
 			for (int newLevel = maximumLevel; newLevel >= 0; --newLevel)
 				if (effectiveBlocksMinted >= cumulativeBlocksByLevel.get(newLevel)) {
-					if (newLevel < accountData.getLevel()) {
+					if (newLevel != accountData.getLevel()) {
 						// Account has decreased in level!
 						accountData.setLevel(newLevel);
 						repository.getAccountRepository().setLevel(accountData);
@@ -2200,6 +2318,7 @@ public class Block {
 		List<AccountBalanceData> accountBalanceDeltas = balanceChanges.entrySet().stream()
 				.map(entry -> new AccountBalanceData(entry.getKey(), Asset.QORT, entry.getValue()))
 				.collect(Collectors.toList());
+		LOGGER.trace("Account Balance Deltas: {}", accountBalanceDeltas);
 		this.repository.getAccountRepository().modifyAssetBalances(accountBalanceDeltas);
 	}
 
@@ -2208,34 +2327,44 @@ public class Block {
 		List<BlockRewardCandidate> rewardCandidates = new ArrayList<>();
 
 		// All online accounts
-		final List<ExpandedAccount> expandedAccounts = this.getExpandedAccounts();
+		final List<ExpandedAccount> expandedAccounts;
+
+		if (this.getBlockData().getHeight() < BlockChain.getInstance().getFixBatchRewardHeight()) {
+			expandedAccounts = this.getExpandedAccounts().stream().collect(Collectors.toList());
+		}
+		else {
+			expandedAccounts
+				= this.getExpandedAccounts().stream()
+					.filter(expandedAccount -> expandedAccount.isMinterMember)
+					.collect(Collectors.toList());
+		}
 
 		/*
 		 * Distribution rules:
-		 * 
+		 *
 		 * Distribution is based on the minting account of 'online' reward-shares.
-		 * 
+		 *
 		 * If ANY founders are online, then they receive the leftover non-distributed reward.
 		 * If NO founders are online, then account-level-based rewards are scaled up so 100% of reward is allocated.
-		 * 
+		 *
 		 * If ANY non-maxxed legacy QORA holders exist then they are always allocated their fixed share (e.g. 20%).
-		 * 
+		 *
 		 * There has to be either at least one 'online' account for blocks to be minted
 		 * so there is always either one account-level-based or founder reward candidate.
-		 * 
+		 *
 		 * Examples:
-		 * 
+		 *
 		 * With at least one founder online:
 		 * Level 1/2 accounts: 5%
 		 * Legacy QORA holders: 20%
 		 * Founders: ~75%
-		 * 
+		 *
 		 * No online founders:
 		 * Level 1/2 accounts: 5%
 		 * Level 5/6 accounts: 15%
 		 * Legacy QORA holders: 20%
 		 * Total: 40%
-		 * 
+		 *
 		 * After scaling account-level-based shares to fill 100%:
 		 * Level 1/2 accounts: 20%
 		 * Level 5/6 accounts: 60%
@@ -2251,7 +2380,6 @@ public class Block {
 		// Select the correct set of share bins based on block height
 		List<AccountLevelShareBin> accountLevelShareBinsForBlock = (this.blockData.getHeight() >= BlockChain.getInstance().getSharesByLevelV2Height()) ?
 				BlockChain.getInstance().getAccountLevelShareBinsV2() : BlockChain.getInstance().getAccountLevelShareBinsV1();
-
 		// Determine reward candidates based on account level
 		// This needs a deep copy, so the shares can be modified when tiers aren't activated yet
 		List<AccountLevelShareBin> accountLevelShareBins = new ArrayList<>();
@@ -2334,7 +2462,7 @@ public class Block {
 		final long qoraHoldersShare = BlockChain.getInstance().getQoraHoldersShareAtHeight(this.blockData.getHeight());
 
 		// Perform account-level-based reward scaling if appropriate
-		if (!haveFounders) {
+		if (!haveFounders && this.blockData.getHeight() < BlockChain.getInstance().getAdminsReplaceFoundersHeight() ) {
 			// Recalculate distribution ratios based on candidates
 
 			// Nothing shared? This shouldn't happen
@@ -2370,18 +2498,103 @@ public class Block {
 		}
 
 		// Add founders as reward candidate if appropriate
-		if (haveFounders) {
+		if (haveFounders && this.blockData.getHeight() < BlockChain.getInstance().getAdminsReplaceFoundersHeight()) {
 			// Yes: add to reward candidates list
 			BlockRewardDistributor founderDistributor = (distributionAmount, balanceChanges) -> distributeBlockRewardShare(distributionAmount, onlineFounderAccounts, balanceChanges);
 
 			final long foundersShare = 1_00000000 - totalShares;
 			BlockRewardCandidate rewardCandidate = new BlockRewardCandidate("Founders", foundersShare, founderDistributor);
 			rewardCandidates.add(rewardCandidate);
+			LOGGER.info("logging foundersShare prior to reward modifications {}",foundersShare);
+		}
+		else if (this.blockData.getHeight() >= BlockChain.getInstance().getAdminsReplaceFoundersHeight()) {
+			try (final Repository repository = RepositoryManager.getRepository()) {
+				GroupRepository groupRepository = repository.getGroupRepository();
+
+				List<Integer> mintingGroupIds = Groups.getGroupIdsToMint(BlockChain.getInstance(), this.blockData.getHeight());
+
+				// all minter admins
+				List<String> minterAdmins = Groups.getAllAdmins(groupRepository, mintingGroupIds);
+
+				// all minter admins that are online
+				List<ExpandedAccount> onlineMinterAdminAccounts
+					= expandedAccounts.stream()
+						.filter(expandedAccount ->  minterAdmins.contains(expandedAccount.getMintingAccount().getAddress()))
+						.collect(Collectors.toList());
+
+				long minterAdminShare;
+
+				if( onlineMinterAdminAccounts.isEmpty() ) {
+					minterAdminShare = 0;
+				}
+				else {
+					BlockRewardDistributor minterAdminDistributor
+							= (distributionAmount, balanceChanges)
+							->
+							distributeBlockRewardShare(distributionAmount, onlineMinterAdminAccounts, balanceChanges);
+
+					long adminShare = 1_00000000 - totalShares;
+					LOGGER.info("initial total Shares: {}", totalShares);
+					LOGGER.info("logging adminShare after hardfork, this is the primary reward that will be split {}", adminShare);
+
+					minterAdminShare = adminShare / 2;
+					BlockRewardCandidate minterAdminRewardCandidate
+							= new BlockRewardCandidate("Minter Admins", minterAdminShare, minterAdminDistributor);
+					rewardCandidates.add(minterAdminRewardCandidate);
+
+					totalShares += minterAdminShare;
+				}
+
+				LOGGER.info("MINTER ADMIN SHARE: {}",minterAdminShare);
+
+				// all dev admins
+				List<String> devAdminAddresses
+						= groupRepository.getGroupAdmins(1).stream()
+						.map(GroupAdminData::getAdmin)
+						.collect(Collectors.toList());
+
+				LOGGER.info("Removing NULL Account Address, Dev Admin Count = {}", devAdminAddresses.size());
+				devAdminAddresses.removeIf( address -> Group.NULL_OWNER_ADDRESS.equals(address) );
+				LOGGER.info("Removed NULL Account Address, Dev Admin Count = {}", devAdminAddresses.size());
+
+				BlockRewardDistributor devAdminDistributor
+					= (distributionAmount, balanceChanges) -> distributeToAccounts(distributionAmount, devAdminAddresses, balanceChanges);
+
+				long devAdminShare = 1_00000000 - totalShares;
+				LOGGER.info("DEV ADMIN SHARE: {}",devAdminShare);
+				BlockRewardCandidate devAdminRewardCandidate
+					= new BlockRewardCandidate("Dev Admins", devAdminShare,devAdminDistributor);
+				rewardCandidates.add(devAdminRewardCandidate);
+			}
 		}
 
 		return rewardCandidates;
 	}
 
+	/**
+	 * Distribute To Accounts
+	 *
+	 * Merges distribute shares to a map of distribution shares.
+	 *
+	 * @param distributionAmount the amount to distribute
+	 * @param accountAddressess the addresses to distribute to
+	 * @param balanceChanges the map of distribution shares, this gets appended to
+	 *
+	 * @return the total amount mapped to addresses for distribution
+	 */
+	public static long distributeToAccounts(long distributionAmount, List<String> accountAddressess, Map<String, Long> balanceChanges) {
+
+		if( accountAddressess.isEmpty() ) return 0;
+
+		long distibutionShare = distributionAmount / accountAddressess.size();
+
+		for(String accountAddress : accountAddressess ) {
+			balanceChanges.merge(accountAddress, distibutionShare, Long::sum);
+		}
+
+		return distibutionShare * accountAddressess.size();
+	}
+
 	private static long distributeBlockRewardShare(long distributionAmount, List<ExpandedAccount> accounts, Map<String, Long> balanceChanges) {
 		// Collate all expanded accounts by minting account
 		Map<String, List<ExpandedAccount>> accountsByMinter = new HashMap<>();
@@ -2541,9 +2754,11 @@ public class Block {
 				return;
 
 			int minterLevel = Account.getRewardShareEffectiveMintingLevel(this.repository, this.getMinter().getPublicKey());
+			String minterAddress = Account.getRewardShareMintingAddress(this.repository, this.getMinter().getPublicKey());
 
 			LOGGER.debug(String.format("======= BLOCK %d (%.8s) =======", this.getBlockData().getHeight(), Base58.encode(this.getSignature())));
 			LOGGER.debug(String.format("Timestamp: %d", this.getBlockData().getTimestamp()));
+			LOGGER.debug(String.format("Minter address: %s", minterAddress));
 			LOGGER.debug(String.format("Minter level: %d", minterLevel));
 			LOGGER.debug(String.format("Online accounts: %d", this.getBlockData().getOnlineAccountsCount()));
 			LOGGER.debug(String.format("AT count: %d", this.getBlockData().getATCount()));

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

@@ -71,6 +71,7 @@ public class BlockChain {
 		transactionV6Timestamp,
 		disableReferenceTimestamp,
 		increaseOnlineAccountsDifficultyTimestamp,
+		decreaseOnlineAccountsDifficultyTimestamp,
 		onlineAccountMinterLevelValidationHeight,
 		selfSponsorshipAlgoV1Height,
 		selfSponsorshipAlgoV2Height,
@@ -80,7 +81,20 @@ public class BlockChain {
 		arbitraryOptionalFeeTimestamp,
 		unconfirmableRewardSharesHeight,
 		disableTransferPrivsTimestamp,
-		enableTransferPrivsTimestamp
+		enableTransferPrivsTimestamp,
+		cancelSellNameValidationTimestamp,
+		disableRewardshareHeight,
+		enableRewardshareHeight,
+		onlyMintWithNameHeight,
+		removeOnlyMintWithNameHeight,
+		groupMemberCheckHeight,
+		fixBatchRewardHeight,
+		adminsReplaceFoundersHeight,
+		nullGroupMembershipHeight,
+		ignoreLevelForRewardShareHeight,
+		adminQueryFixHeight,
+		multipleNamesPerAccountHeight,
+		mintedBlocksAdjustmentRemovalHeight
 	}
 
 	// Custom transaction fees
@@ -100,7 +114,8 @@ public class BlockChain {
 	/** Whether to use legacy, broken RIPEMD160 implementation when converting public keys to addresses. */
 	private boolean useBrokenMD160ForAddresses = false;
 
-	/** Whether only one registered name is allowed per account. */
+	/** This should get ignored and overwritten in the oneNamePerAccount(int blockchainHeight) method,
+	 * because it is based on block height, not based on the genesis block.*/
 	private boolean oneNamePerAccount = false;
 
 	/** Checkpoints */
@@ -201,6 +216,13 @@ public class BlockChain {
 	private int maxRewardSharesPerFounderMintingAccount;
 	private int founderEffectiveMintingLevel;
 
+	public static class IdsForHeight {
+		public int height;
+		public List<Integer> ids;
+	}
+
+	private List<IdsForHeight> mintingGroupIds;
+
 	/** Minimum time to retain online account signatures (ms) for block validity checks. */
 	private long onlineAccountSignaturesMinLifetime;
 
@@ -211,6 +233,10 @@ public class BlockChain {
 	 * featureTriggers because unit tests need to set this value via Reflection. */
 	private long onlineAccountsModulusV2Timestamp;
 
+	/** Feature trigger timestamp for ONLINE_ACCOUNTS_MODULUS time interval decrease. Can't use
+	 * featureTriggers because unit tests need to set this value via Reflection. */
+	private long onlineAccountsModulusV3Timestamp;
+
 	/** Snapshot timestamp for self sponsorship algo V1 */
 	private long selfSponsorshipAlgoV1SnapshotTimestamp;
 
@@ -397,6 +423,9 @@ public class BlockChain {
 		return this.onlineAccountsModulusV2Timestamp;
 	}
 
+	public long getOnlineAccountsModulusV3Timestamp() {
+		return this.onlineAccountsModulusV3Timestamp;
+	}
 
 	/* Block reward batching */
 	public long getBlockRewardBatchStartHeight() {
@@ -448,8 +477,9 @@ public class BlockChain {
 		return this.useBrokenMD160ForAddresses;
 	}
 
-	public boolean oneNamePerAccount() {
-		return this.oneNamePerAccount;
+	public boolean oneNamePerAccount(int blockchainHeight) {
+		// this is not set on a simple blockchain setting, it is based on a feature trigger height
+		return blockchainHeight < this.getMultipleNamesPerAccountHeight();
 	}
 
 	public List<Checkpoint> getCheckpoints() {
@@ -524,6 +554,10 @@ public class BlockChain {
 		return this.onlineAccountSignaturesMaxLifetime;
 	}
 
+	public List<IdsForHeight> getMintingGroupIds() {
+		return mintingGroupIds;
+	}
+
 	public CiyamAtSettings getCiyamAtSettings() {
 		return this.ciyamAtSettings;
 	}
@@ -570,6 +604,10 @@ public class BlockChain {
 		return this.featureTriggers.get(FeatureTrigger.increaseOnlineAccountsDifficultyTimestamp.name()).longValue();
 	}
 
+	public long getDecreaseOnlineAccountsDifficultyTimestamp() {
+		return this.featureTriggers.get(FeatureTrigger.decreaseOnlineAccountsDifficultyTimestamp.name()).longValue();
+	}
+
 	public int getSelfSponsorshipAlgoV1Height() {
 		return this.featureTriggers.get(FeatureTrigger.selfSponsorshipAlgoV1Height.name()).intValue();
 	}
@@ -610,6 +648,58 @@ 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 getRemoveOnlyMintWithNameHeight() {
+		return this.featureTriggers.get(FeatureTrigger.removeOnlyMintWithNameHeight.name()).intValue();
+	}
+
+	public int getGroupMemberCheckHeight() {
+		return this.featureTriggers.get(FeatureTrigger.groupMemberCheckHeight.name()).intValue();
+	}
+
+	public int getFixBatchRewardHeight() {
+		return this.featureTriggers.get(FeatureTrigger.fixBatchRewardHeight.name()).intValue();
+	}
+
+	public int getAdminsReplaceFoundersHeight() {
+		return this.featureTriggers.get(FeatureTrigger.adminsReplaceFoundersHeight.name()).intValue();
+	}
+
+	public int getNullGroupMembershipHeight() {
+		return this.featureTriggers.get(FeatureTrigger.nullGroupMembershipHeight.name()).intValue();
+	}
+
+	public int getIgnoreLevelForRewardShareHeight() {
+		return this.featureTriggers.get(FeatureTrigger.ignoreLevelForRewardShareHeight.name()).intValue();
+	}
+
+	public int getAdminQueryFixHeight() {
+		return this.featureTriggers.get(FeatureTrigger.adminQueryFixHeight.name()).intValue();
+	}
+
+	public int getMultipleNamesPerAccountHeight() {
+		return this.featureTriggers.get(FeatureTrigger.multipleNamesPerAccountHeight.name()).intValue();
+	}
+
+	public int getMintedBlocksAdjustmentRemovalHeight() {
+		return this.featureTriggers.get(FeatureTrigger.mintedBlocksAdjustmentRemovalHeight.name()).intValue();
+	}
+
 	// More complex getters for aspects that change by height or timestamp
 
 	public long getRewardAtHeight(int ourHeight) {
@@ -805,10 +895,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 +916,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 +959,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 +1105,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/block/PrimaryNamesBlock.java

@@ -0,0 +1,47 @@
+package org.qortal.block;
+
+import org.qortal.account.Account;
+import org.qortal.api.resource.TransactionsResource;
+import org.qortal.data.naming.NameData;
+import org.qortal.repository.DataException;
+import org.qortal.repository.Repository;
+
+import java.util.Set;
+import java.util.stream.Collectors;
+
+/**
+ * Class PrimaryNamesBlock
+ */
+public class PrimaryNamesBlock {
+
+    /**
+     * Process Primary Names
+     *
+     * @param repository
+     * @throws DataException
+     */
+    public static void processNames(Repository repository) throws DataException {
+
+        Set<String> addressesWithNames
+            = repository.getNameRepository().getAllNames().stream()
+                .map(NameData::getOwner).collect(Collectors.toSet());
+
+        // for each address with a name, set primary name to the address
+        for( String address : addressesWithNames ) {
+
+            Account account = new Account(repository, address);
+            account.resetPrimaryName(TransactionsResource.ConfirmationStatus.CONFIRMED);
+        }
+    }
+
+    /**
+     * Orphan the Primary Names Block
+     *
+     * @param repository
+     * @throws DataException
+     */
+    public static void orphanNames(Repository repository) throws DataException {
+
+        repository.getNameRepository().clearPrimaryNames();
+    }
+}

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
@@ -96,365 +97,375 @@ public class BlockMinter extends Thread {
 
 		final boolean isSingleNodeTestnet = Settings.getInstance().isSingleNodeTestnet();
 
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			// Going to need this a lot...
-			BlockRepository blockRepository = repository.getBlockRepository();
-
-			// Flags for tracking change in whether minting is possible,
-			// so we can notify Controller, and further update SysTray, etc.
-			boolean isMintingPossible = false;
-			boolean wasMintingPossible = isMintingPossible;
+		// Flags for tracking change in whether minting is possible,
+		// so we can notify Controller, and further update SysTray, etc.
+		boolean isMintingPossible = false;
+		boolean wasMintingPossible = isMintingPossible;
+		try {
 			while (running) {
-				if (isMintingPossible != wasMintingPossible)
-					Controller.getInstance().onMintingPossibleChange(isMintingPossible);
+				// recreate repository for new loop iteration
+				try (final Repository repository = RepositoryManager.getRepository()) {
 
-				wasMintingPossible = isMintingPossible;
+					// Going to need this a lot...
+					BlockRepository blockRepository = repository.getBlockRepository();
 
-				try {
-					// Free up any repository locks
-					repository.discardChanges();
+					if (isMintingPossible != wasMintingPossible)
+						Controller.getInstance().onMintingPossibleChange(isMintingPossible);
 
-					// Sleep for a while.
-					// It's faster on single node testnets, to allow lots of blocks to be minted quickly.
-					Thread.sleep(isSingleNodeTestnet ? 50 : 1000);
-
-					isMintingPossible = false;
-
-					final Long now = NTP.getTime();
-					if (now == null)
-						continue;
-
-					final Long minLatestBlockTimestamp = Controller.getMinimumLatestBlockTimestamp();
-					if (minLatestBlockTimestamp == null)
-						continue;
-
-					List<MintingAccountData> mintingAccountsData = repository.getAccountRepository().getMintingAccounts();
-					// No minting accounts?
-					if (mintingAccountsData.isEmpty())
-						continue;
-
-					// Disregard minting accounts that are no longer valid, e.g. by transfer/loss of founder flag or account level
-					// Note that minting accounts are actually reward-shares in Qortal
-					Iterator<MintingAccountData> madi = mintingAccountsData.iterator();
-					while (madi.hasNext()) {
-						MintingAccountData mintingAccountData = madi.next();
-
-						RewardShareData rewardShareData = repository.getAccountRepository().getRewardShare(mintingAccountData.getPublicKey());
-						if (rewardShareData == null) {
-							// Reward-share doesn't exist - probably cancelled but not yet removed from node's list of minting accounts
-							madi.remove();
-							continue;
-						}
-
-						Account mintingAccount = new Account(repository, rewardShareData.getMinter());
-						if (!mintingAccount.canMint()) {
-							// Minting-account component of reward-share can no longer mint - disregard
-							madi.remove();
-							continue;
-						}
-
-						// Optional (non-validated) prevention of block submissions below a defined level.
-						// This is an unvalidated version of Blockchain.minAccountLevelToMint
-						// and exists only to reduce block candidates by default.
-						int level = mintingAccount.getEffectiveMintingLevel();
-						if (level < BlockChain.getInstance().getMinAccountLevelForBlockSubmissions()) {
-							madi.remove();
-							continue;
-						}
-					}
-
-					// Needs a mutable copy of the unmodifiableList
-					List<Peer> peers = new ArrayList<>(Network.getInstance().getImmutableHandshakedPeers());
-					BlockData lastBlockData = blockRepository.getLastBlock();
-
-					// Disregard peers that have "misbehaved" recently
-					peers.removeIf(Controller.hasMisbehaved);
-
-					// 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)
-						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?
-					if (peers.size() < Settings.getInstance().getMinBlockchainPeers())
-						continue;
-
-					// If we are stuck on an invalid block, we should allow an alternative to be minted
-					boolean recoverInvalidBlock = false;
-					if (Synchronizer.getInstance().timeInvalidBlockLastReceived != null) {
-						// We've had at least one invalid block
-						long timeSinceLastValidBlock = NTP.getTime() - Synchronizer.getInstance().timeValidBlockLastReceived;
-						long timeSinceLastInvalidBlock = NTP.getTime() - Synchronizer.getInstance().timeInvalidBlockLastReceived;
-						if (timeSinceLastValidBlock > INVALID_BLOCK_RECOVERY_TIMEOUT) {
-							if (timeSinceLastInvalidBlock < INVALID_BLOCK_RECOVERY_TIMEOUT) {
-								// Last valid block was more than 10 mins ago, but we've had an invalid block since then
-								// Assume that the chain has stalled because there is no alternative valid candidate
-								// Enter recovery mode to allow alternative, valid candidates to be minted
-								recoverInvalidBlock = true;
-							}
-						}
-					}
-
-					// 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)
-							continue;
-
-					// There are enough peers with a recent block and our latest block is recent
-					// so go ahead and mint a block if possible.
-					isMintingPossible = true;
-
-					// Check blockchain hasn't changed
-					if (previousBlockData == null || !Arrays.equals(previousBlockData.getSignature(), lastBlockData.getSignature())) {
-						previousBlockData = lastBlockData;
-						newBlocks.clear();
-
-						// Reduce log timeout
-						logTimeout = 10 * 1000L;
-
-						// Last low weight block is no longer valid
-						parentSignatureForLastLowWeightBlock = null;
-					}
-
-					// Discard accounts we have already built blocks with
-					mintingAccountsData.removeIf(mintingAccountData -> newBlocks.stream().anyMatch(newBlock -> Arrays.equals(newBlock.getBlockData().getMinterPublicKey(), mintingAccountData.getPublicKey())));
-
-					// Do we need to build any potential new blocks?
-					List<PrivateKeyAccount> newBlocksMintingAccounts = mintingAccountsData.stream().map(accountData -> new PrivateKeyAccount(repository, accountData.getPrivateKey())).collect(Collectors.toList());
-
-					// We might need to sit the next block out, if one of our minting accounts signed the previous one
-					// Skip this check for single node testnets, since they definitely need to mint every block
-					byte[] previousBlockMinter = previousBlockData.getMinterPublicKey();
-					boolean mintedLastBlock = mintingAccountsData.stream().anyMatch(mintingAccount -> Arrays.equals(mintingAccount.getPublicKey(), previousBlockMinter));
-					if (mintedLastBlock && !isSingleNodeTestnet) {
-						LOGGER.trace(String.format("One of our keys signed the last block, so we won't sign the next one"));
-						continue;
-					}
-
-					if (parentSignatureForLastLowWeightBlock != null) {
-						// The last iteration found a higher weight block in the network, so sleep for a while
-						// to allow is to sync the higher weight chain. We are sleeping here rather than when
-						// detected as we don't want to hold the blockchain lock open.
-						LOGGER.info("Sleeping for 10 seconds...");
-						Thread.sleep(10 * 1000L);
-					}
-
-					for (PrivateKeyAccount mintingAccount : newBlocksMintingAccounts) {
-						// First block does the AT heavy-lifting
-						if (newBlocks.isEmpty()) {
-							Block newBlock = Block.mint(repository, previousBlockData, mintingAccount);
-							if (newBlock == null) {
-								// For some reason we can't mint right now
-								moderatedLog(() -> LOGGER.info("Couldn't build a to-be-minted block"));
-								continue;
-							}
-
-							newBlocks.add(newBlock);
-						} else {
-							// The blocks for other minters require less effort...
-							Block newBlock = newBlocks.get(0).remint(mintingAccount);
-							if (newBlock == null) {
-								// For some reason we can't mint right now
-								moderatedLog(() -> LOGGER.error("Couldn't rebuild a to-be-minted block"));
-								continue;
-							}
-
-							newBlocks.add(newBlock);
-						}
-					}
-
-					// No potential block candidates?
-					if (newBlocks.isEmpty())
-						continue;
-
-					// Make sure we're the only thread modifying the blockchain
-					ReentrantLock blockchainLock = Controller.getInstance().getBlockchainLock();
-					if (!blockchainLock.tryLock(30, TimeUnit.SECONDS)) {
-						LOGGER.debug("Couldn't acquire blockchain lock even after waiting 30 seconds");
-						continue;
-					}
-
-					boolean newBlockMinted = false;
-					Block newBlock = null;
+					wasMintingPossible = isMintingPossible;
 
 					try {
-						// Clear repository session state so we have latest view of data
+						// reset the repository, to the repository recreated for this loop iteration
+						for( Block newBlock : newBlocks ) newBlock.setRepository(repository);
+
+						// Free up any repository locks
 						repository.discardChanges();
 
-						// Now that we have blockchain lock, do final check that chain hasn't changed
-						BlockData latestBlockData = blockRepository.getLastBlock();
-						if (!Arrays.equals(lastBlockData.getSignature(), latestBlockData.getSignature()))
+						// Sleep for a while.
+						// It's faster on single node testnets, to allow lots of blocks to be minted quickly.
+						Thread.sleep(isSingleNodeTestnet ? 50 : 1000);
+
+						isMintingPossible = false;
+
+						final Long now = NTP.getTime();
+						if (now == null)
 							continue;
 
-						List<Block> goodBlocks = new ArrayList<>();
-						boolean wasInvalidBlockDiscarded = false;
-						Iterator<Block> newBlocksIterator = newBlocks.iterator();
+						final Long minLatestBlockTimestamp = Controller.getMinimumLatestBlockTimestamp();
+						if (minLatestBlockTimestamp == null)
+							continue;
 
-						while (newBlocksIterator.hasNext()) {
-							Block testBlock = newBlocksIterator.next();
+						List<MintingAccountData> mintingAccountsData = repository.getAccountRepository().getMintingAccounts();
+						// No minting accounts?
+						if (mintingAccountsData.isEmpty())
+							continue;
 
-							// Is new block's timestamp valid yet?
-							// We do a separate check as some timestamp checks are skipped for testchains
-							if (testBlock.isTimestampValid() != ValidationResult.OK)
+						// Disregard minting accounts that are no longer valid, e.g. by transfer/loss of founder flag or account level
+						// Note that minting accounts are actually reward-shares in Qortal
+						Iterator<MintingAccountData> madi = mintingAccountsData.iterator();
+						while (madi.hasNext()) {
+							MintingAccountData mintingAccountData = madi.next();
+
+							RewardShareData rewardShareData = repository.getAccountRepository().getRewardShare(mintingAccountData.getPublicKey());
+							if (rewardShareData == null) {
+								// Reward-share doesn't exist - probably cancelled but not yet removed from node's list of minting accounts
+								madi.remove();
+								continue;
+							}
+
+							Account mintingAccount = new Account(repository, rewardShareData.getMinter());
+							if (!mintingAccount.canMint(true)) {
+								// Minting-account component of reward-share can no longer mint - disregard
+								madi.remove();
+								continue;
+							}
+
+							// Optional (non-validated) prevention of block submissions below a defined level.
+							// This is an unvalidated version of Blockchain.minAccountLevelToMint
+							// and exists only to reduce block candidates by default.
+							int level = mintingAccount.getEffectiveMintingLevel();
+							if (level < BlockChain.getInstance().getMinAccountLevelForBlockSubmissions()) {
+								madi.remove();
+							}
+						}
+
+						// Needs a mutable copy of the unmodifiableList
+						List<Peer> peers = new ArrayList<>(Network.getInstance().getImmutableHandshakedPeers());
+						BlockData lastBlockData = blockRepository.getLastBlock();
+
+						// Disregard peers that have "misbehaved" recently
+						peers.removeIf(Controller.hasMisbehaved);
+
+						// 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())
+							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?
+						if (peers.size() < Settings.getInstance().getMinBlockchainPeers())
+							continue;
+
+						// If we are stuck on an invalid block, we should allow an alternative to be minted
+						boolean recoverInvalidBlock = false;
+						if (Synchronizer.getInstance().timeInvalidBlockLastReceived != null) {
+							// We've had at least one invalid block
+							long timeSinceLastValidBlock = NTP.getTime() - Synchronizer.getInstance().timeValidBlockLastReceived;
+							long timeSinceLastInvalidBlock = NTP.getTime() - Synchronizer.getInstance().timeInvalidBlockLastReceived;
+							if (timeSinceLastValidBlock > INVALID_BLOCK_RECOVERY_TIMEOUT) {
+								if (timeSinceLastInvalidBlock < INVALID_BLOCK_RECOVERY_TIMEOUT) {
+									// Last valid block was more than 10 mins ago, but we've had an invalid block since then
+									// Assume that the chain has stalled because there is no alternative valid candidate
+									// Enter recovery mode to allow alternative, valid candidates to be minted
+									recoverInvalidBlock = true;
+								}
+							}
+						}
+
+						// 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() && !recoverInvalidBlock)
 								continue;
 
-							testBlock.preProcess();
+						// There are enough peers with a recent block and our latest block is recent
+						// so go ahead and mint a block if possible.
+						isMintingPossible = true;
 
-							// Is new block valid yet? (Before adding unconfirmed transactions)
-							ValidationResult result = testBlock.isValid();
-							if (result != ValidationResult.OK) {
-								moderatedLog(() -> LOGGER.error(String.format("To-be-minted block invalid '%s' before adding transactions?", result.name())));
+						// Check blockchain hasn't changed
+						if (previousBlockData == null || !Arrays.equals(previousBlockData.getSignature(), lastBlockData.getSignature())) {
+							previousBlockData = lastBlockData;
+							newBlocks.clear();
 
-								newBlocksIterator.remove();
-								wasInvalidBlockDiscarded = true;
-								/*
-								 * Bail out fast so that we loop around from the top again.
-								 * This gives BlockMinter the possibility to remint this candidate block using another block from newBlocks,
-								 * via the Blocks.remint() method, which avoids having to re-process Block ATs all over again.
-								 * Particularly useful if some aspect of Blocks changes due a timestamp-based feature-trigger (see BlockChain class).
-								 */
-								break;
-							}
+							// Reduce log timeout
+							logTimeout = 10 * 1000L;
 
-							goodBlocks.add(testBlock);
+							// Last low weight block is no longer valid
+							parentSignatureForLastLowWeightBlock = null;
 						}
 
-						if (wasInvalidBlockDiscarded || goodBlocks.isEmpty())
+						// Discard accounts we have already built blocks with
+						mintingAccountsData.removeIf(mintingAccountData -> newBlocks.stream().anyMatch(newBlock -> Arrays.equals(newBlock.getBlockData().getMinterPublicKey(), mintingAccountData.getPublicKey())));
+
+						// Do we need to build any potential new blocks?
+						List<PrivateKeyAccount> newBlocksMintingAccounts = mintingAccountsData.stream().map(accountData -> new PrivateKeyAccount(repository, accountData.getPrivateKey())).collect(Collectors.toList());
+
+						// We might need to sit the next block out, if one of our minting accounts signed the previous one
+						// Skip this check for single node testnets, since they definitely need to mint every block
+						byte[] previousBlockMinter = previousBlockData.getMinterPublicKey();
+						boolean mintedLastBlock = mintingAccountsData.stream().anyMatch(mintingAccount -> Arrays.equals(mintingAccount.getPublicKey(), previousBlockMinter));
+						if (mintedLastBlock && !isSingleNodeTestnet) {
+							LOGGER.trace(String.format("One of our keys signed the last block, so we won't sign the next one"));
 							continue;
-
-						// Pick best block
-						final int parentHeight = previousBlockData.getHeight();
-						final byte[] parentBlockSignature = previousBlockData.getSignature();
-
-						BigInteger bestWeight = null;
-
-						for (int bi = 0; bi < goodBlocks.size(); ++bi) {
-							BlockData blockData = goodBlocks.get(bi).getBlockData();
-
-							BlockSummaryData blockSummaryData = new BlockSummaryData(blockData);
-							int minterLevel = Account.getRewardShareEffectiveMintingLevel(repository, blockData.getMinterPublicKey());
-							blockSummaryData.setMinterLevel(minterLevel);
-
-							BigInteger blockWeight = Block.calcBlockWeight(parentHeight, parentBlockSignature, blockSummaryData);
-
-							if (bestWeight == null || blockWeight.compareTo(bestWeight) < 0) {
-								newBlock = goodBlocks.get(bi);
-								bestWeight = blockWeight;
-							}
 						}
 
-						try {
-							if (this.higherWeightChainExists(repository, bestWeight)) {
+						if (parentSignatureForLastLowWeightBlock != null) {
+							// The last iteration found a higher weight block in the network, so sleep for a while
+							// to allow is to sync the higher weight chain. We are sleeping here rather than when
+							// detected as we don't want to hold the blockchain lock open.
+							LOGGER.info("Sleeping for 10 seconds...");
+							Thread.sleep(10 * 1000L);
+						}
 
-								// Check if the base block has updated since the last time we were here
-								if (parentSignatureForLastLowWeightBlock == null || timeOfLastLowWeightBlock == null ||
-										!Arrays.equals(parentSignatureForLastLowWeightBlock, previousBlockData.getSignature())) {
-									// We've switched to a different chain, so reset the timer
-									timeOfLastLowWeightBlock = NTP.getTime();
-								}
-								parentSignatureForLastLowWeightBlock = previousBlockData.getSignature();
-
-								// If less than 30 seconds has passed since first detection the higher weight chain,
-								// we should skip our block submission to give us the opportunity to sync to the better chain
-								if (NTP.getTime() - timeOfLastLowWeightBlock < 30 * 1000L) {
-									LOGGER.info("Higher weight chain found in peers, so not signing a block this round");
-									LOGGER.info("Time since detected: {}", NTP.getTime() - timeOfLastLowWeightBlock);
+						for (PrivateKeyAccount mintingAccount : newBlocksMintingAccounts) {
+							// First block does the AT heavy-lifting
+							if (newBlocks.isEmpty()) {
+								Block newBlock = Block.mint(repository, previousBlockData, mintingAccount);
+								if (newBlock == null) {
+									// For some reason we can't mint right now
+									moderatedLog(() -> LOGGER.info("Couldn't build a to-be-minted block"));
 									continue;
-								} else {
-									// More than 30 seconds have passed, so we should submit our block candidate anyway.
-									LOGGER.info("More than 30 seconds passed, so proceeding to submit block candidate...");
 								}
+
+								newBlocks.add(newBlock);
 							} else {
-								LOGGER.debug("No higher weight chain found in peers");
+								// The blocks for other minters require less effort...
+								Block newBlock = newBlocks.get(0).remint(mintingAccount);
+								if (newBlock == null) {
+									// For some reason we can't mint right now
+									moderatedLog(() -> LOGGER.error("Couldn't rebuild a to-be-minted block"));
+									continue;
+								}
+
+								newBlocks.add(newBlock);
 							}
-						} catch (DataException e) {
-							LOGGER.debug("Unable to check for a higher weight chain. Proceeding anyway...");
 						}
 
-						// Discard any uncommitted changes as a result of the higher weight chain detection
-						repository.discardChanges();
+						// No potential block candidates?
+						if (newBlocks.isEmpty())
+							continue;
 
-						// Clear variables that track low weight blocks
-						parentSignatureForLastLowWeightBlock = null;
-						timeOfLastLowWeightBlock = null;
-
-						Long unconfirmedStartTime = NTP.getTime();
-
-						// Add unconfirmed transactions
-						addUnconfirmedTransactions(repository, newBlock);
-
-						LOGGER.info(String.format("Adding %d unconfirmed transactions took %d ms", newBlock.getTransactions().size(), (NTP.getTime()-unconfirmedStartTime)));
-
-						// Sign to create block's signature
-						newBlock.sign();
-
-						// Is newBlock still valid?
-						ValidationResult validationResult = newBlock.isValid();
-						if (validationResult != ValidationResult.OK) {
-							// No longer valid? Report and discard
-							LOGGER.error(String.format("To-be-minted block now invalid '%s' after adding unconfirmed transactions?", validationResult.name()));
-
-							// Rebuild block candidates, just to be sure
-							newBlocks.clear();
+						// Make sure we're the only thread modifying the blockchain
+						ReentrantLock blockchainLock = Controller.getInstance().getBlockchainLock();
+						if (!blockchainLock.tryLock(30, TimeUnit.SECONDS)) {
+							LOGGER.debug("Couldn't acquire blockchain lock even after waiting 30 seconds");
 							continue;
 						}
 
-						// Add to blockchain - something else will notice and broadcast new block to network
+						boolean newBlockMinted = false;
+						Block newBlock = null;
+
 						try {
-							newBlock.process();
+							// Clear repository session state so we have latest view of data
+							repository.discardChanges();
 
-							repository.saveChanges();
+							// Now that we have blockchain lock, do final check that chain hasn't changed
+							BlockData latestBlockData = blockRepository.getLastBlock();
+							if (!Arrays.equals(lastBlockData.getSignature(), latestBlockData.getSignature()))
+								continue;
 
-							LOGGER.info(String.format("Minted new block: %d", newBlock.getBlockData().getHeight()));
+							List<Block> goodBlocks = new ArrayList<>();
+							boolean wasInvalidBlockDiscarded = false;
+							Iterator<Block> newBlocksIterator = newBlocks.iterator();
 
-							RewardShareData rewardShareData = repository.getAccountRepository().getRewardShare(newBlock.getBlockData().getMinterPublicKey());
+							while (newBlocksIterator.hasNext()) {
+								Block testBlock = newBlocksIterator.next();
 
-							if (rewardShareData != null) {
-								LOGGER.info(String.format("Minted block %d, sig %.8s, parent sig: %.8s by %s on behalf of %s",
-										newBlock.getBlockData().getHeight(),
-										Base58.encode(newBlock.getBlockData().getSignature()),
-										Base58.encode(newBlock.getParent().getSignature()),
-										rewardShareData.getMinter(),
-										rewardShareData.getRecipient()));
-							} else {
-								LOGGER.info(String.format("Minted block %d, sig %.8s, parent sig: %.8s by %s",
-										newBlock.getBlockData().getHeight(),
-										Base58.encode(newBlock.getBlockData().getSignature()),
-										Base58.encode(newBlock.getParent().getSignature()),
-										newBlock.getMinter().getAddress()));
+								// Is new block's timestamp valid yet?
+								// We do a separate check as some timestamp checks are skipped for testchains
+								if (testBlock.isTimestampValid() != ValidationResult.OK)
+									continue;
+
+								testBlock.preProcess();
+
+								// Is new block valid yet? (Before adding unconfirmed transactions)
+								ValidationResult result = testBlock.isValid();
+								if (result != ValidationResult.OK) {
+									moderatedLog(() -> LOGGER.error(String.format("To-be-minted block invalid '%s' before adding transactions?", result.name())));
+
+									newBlocksIterator.remove();
+									wasInvalidBlockDiscarded = true;
+									/*
+									 * Bail out fast so that we loop around from the top again.
+									 * This gives BlockMinter the possibility to remint this candidate block using another block from newBlocks,
+									 * via the Blocks.remint() method, which avoids having to re-process Block ATs all over again.
+									 * Particularly useful if some aspect of Blocks changes due a timestamp-based feature-trigger (see BlockChain class).
+									 */
+									break;
+								}
+
+								goodBlocks.add(testBlock);
 							}
 
-							// Notify network after we're released blockchain lock
-							newBlockMinted = true;
+							if (wasInvalidBlockDiscarded || goodBlocks.isEmpty())
+								continue;
 
-							// Notify Controller
-							repository.discardChanges(); // clear transaction status to prevent deadlocks
-							Controller.getInstance().onNewBlock(newBlock.getBlockData());
-						} catch (DataException e) {
-							// Unable to process block - report and discard
-							LOGGER.error("Unable to process newly minted block?", e);
-							newBlocks.clear();
-						} catch (ArithmeticException e) {
-							// Unable to process block - report and discard
-							LOGGER.error("Unable to process newly minted block?", e);
-							newBlocks.clear();
+							// Pick best block
+							final int parentHeight = previousBlockData.getHeight();
+							final byte[] parentBlockSignature = previousBlockData.getSignature();
+
+							BigInteger bestWeight = null;
+
+							for (int bi = 0; bi < goodBlocks.size(); ++bi) {
+								BlockData blockData = goodBlocks.get(bi).getBlockData();
+
+								BlockSummaryData blockSummaryData = new BlockSummaryData(blockData);
+								int minterLevel = Account.getRewardShareEffectiveMintingLevel(repository, blockData.getMinterPublicKey());
+								blockSummaryData.setMinterLevel(minterLevel);
+
+								BigInteger blockWeight = Block.calcBlockWeight(parentHeight, parentBlockSignature, blockSummaryData);
+
+								if (bestWeight == null || blockWeight.compareTo(bestWeight) < 0) {
+									newBlock = goodBlocks.get(bi);
+									bestWeight = blockWeight;
+								}
+							}
+
+							try {
+								if (this.higherWeightChainExists(repository, bestWeight)) {
+
+									// Check if the base block has updated since the last time we were here
+									if (parentSignatureForLastLowWeightBlock == null || timeOfLastLowWeightBlock == null ||
+											!Arrays.equals(parentSignatureForLastLowWeightBlock, previousBlockData.getSignature())) {
+										// We've switched to a different chain, so reset the timer
+										timeOfLastLowWeightBlock = NTP.getTime();
+									}
+									parentSignatureForLastLowWeightBlock = previousBlockData.getSignature();
+
+									// If less than 30 seconds has passed since first detection the higher weight chain,
+									// we should skip our block submission to give us the opportunity to sync to the better chain
+									if (NTP.getTime() - timeOfLastLowWeightBlock < 30 * 1000L) {
+										LOGGER.info("Higher weight chain found in peers, so not signing a block this round");
+										LOGGER.info("Time since detected: {}", NTP.getTime() - timeOfLastLowWeightBlock);
+										continue;
+									} else {
+										// More than 30 seconds have passed, so we should submit our block candidate anyway.
+										LOGGER.info("More than 30 seconds passed, so proceeding to submit block candidate...");
+									}
+								} else {
+									LOGGER.debug("No higher weight chain found in peers");
+								}
+							} catch (DataException e) {
+								LOGGER.debug("Unable to check for a higher weight chain. Proceeding anyway...");
+							}
+
+							// Discard any uncommitted changes as a result of the higher weight chain detection
+							repository.discardChanges();
+
+							// Clear variables that track low weight blocks
+							parentSignatureForLastLowWeightBlock = null;
+							timeOfLastLowWeightBlock = null;
+
+							Long unconfirmedStartTime = NTP.getTime();
+
+							// Add unconfirmed transactions
+							addUnconfirmedTransactions(repository, newBlock);
+
+							LOGGER.info(String.format("Adding %d unconfirmed transactions took %d ms", newBlock.getTransactions().size(), (NTP.getTime() - unconfirmedStartTime)));
+
+							// Sign to create block's signature
+							newBlock.sign();
+
+							// Is newBlock still valid?
+							ValidationResult validationResult = newBlock.isValid();
+							if (validationResult != ValidationResult.OK) {
+								// No longer valid? Report and discard
+								LOGGER.error(String.format("To-be-minted block now invalid '%s' after adding unconfirmed transactions?", validationResult.name()));
+
+								// Rebuild block candidates, just to be sure
+								newBlocks.clear();
+								continue;
+							}
+
+							// Add to blockchain - something else will notice and broadcast new block to network
+							try {
+								newBlock.process();
+
+								repository.saveChanges();
+
+								LOGGER.info(String.format("Minted new block: %d", newBlock.getBlockData().getHeight()));
+
+								RewardShareData rewardShareData = repository.getAccountRepository().getRewardShare(newBlock.getBlockData().getMinterPublicKey());
+
+								if (rewardShareData != null) {
+									LOGGER.info(String.format("Minted block %d, sig %.8s, parent sig: %.8s by %s on behalf of %s",
+											newBlock.getBlockData().getHeight(),
+											Base58.encode(newBlock.getBlockData().getSignature()),
+											Base58.encode(newBlock.getParent().getSignature()),
+											rewardShareData.getMinter(),
+											rewardShareData.getRecipient()));
+								} else {
+									LOGGER.info(String.format("Minted block %d, sig %.8s, parent sig: %.8s by %s",
+											newBlock.getBlockData().getHeight(),
+											Base58.encode(newBlock.getBlockData().getSignature()),
+											Base58.encode(newBlock.getParent().getSignature()),
+											newBlock.getMinter().getAddress()));
+								}
+
+								// Notify network after we're released blockchain lock
+								newBlockMinted = true;
+
+								// Notify Controller
+								repository.discardChanges(); // clear transaction status to prevent deadlocks
+								Controller.getInstance().onNewBlock(newBlock.getBlockData());
+							} catch (DataException e) {
+								// Unable to process block - report and discard
+								LOGGER.error("Unable to process newly minted block?", e);
+								newBlocks.clear();
+							} catch (ArithmeticException e) {
+								// Unable to process block - report and discard
+								LOGGER.error("Unable to process newly minted block?", e);
+								newBlocks.clear();
+							}
+						} finally {
+							blockchainLock.unlock();
 						}
-					} finally {
-						blockchainLock.unlock();
-					}
 
-					if (newBlockMinted) {
-						// Broadcast our new chain to network
-						Network.getInstance().broadcastOurChain();
-					}
+						if (newBlockMinted) {
+							// Broadcast our new chain to network
+							Network.getInstance().broadcastOurChain();
+						}
 
-				} catch (InterruptedException e) {
-					// We've been interrupted - time to exit
-					return;
+					} catch (InterruptedException e) {
+						// We've been interrupted - time to exit
+						return;
+					}
+				} catch (DataException e) {
+					LOGGER.warn("Repository issue while running block minter - NO LONGER MINTING", e);
+				} catch (Exception e) {
+					LOGGER.error(e.getMessage(), e);
 				}
 			}
-		} catch (DataException e) {
-			LOGGER.warn("Repository issue while running block minter - NO LONGER MINTING", e);
+		} catch (Exception e) {
+			LOGGER.error(e.getMessage(), e);
 		}
 	}
 

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,8 @@ 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.HSQLDBBalanceRecorder;
+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,6 +34,7 @@ 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.HSQLDBRepositoryFactory;
@@ -43,13 +46,18 @@ import org.qortal.utils.*;
 
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
+
 import java.awt.TrayIcon.MessageType;
 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.Files;
 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;
@@ -64,6 +72,7 @@ import java.util.concurrent.locks.ReentrantLock;
 import java.util.function.Function;
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 public class Controller extends Thread {
 
@@ -95,7 +104,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. */
@@ -388,6 +397,9 @@ public class Controller extends Thread {
 
 		Controller.newInstance(args);
 
+
+		cleanChunkUploadTempDir(); // cleanup leftover chunks from streaming to disk
+
 		LOGGER.info("Starting NTP");
 		Long ntpOffset = Settings.getInstance().getTestNtpOffset();
 		if (ntpOffset != null)
@@ -397,14 +409,44 @@ public class Controller extends Thread {
 
 		LOGGER.info("Starting repository");
 		try {
-			RepositoryFactory repositoryFactory = new HSQLDBRepositoryFactory(getRepositoryUrl());
+			HSQLDBRepositoryFactory repositoryFactory = new HSQLDBRepositoryFactory(getRepositoryUrl());
 			RepositoryManager.setRepositoryFactory(repositoryFactory);
 			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();
+				hsqldbDataCacheManager.start();
+			}
+			else {
+				LOGGER.info("Db Cache Disabled");
+			}
+
+			LOGGER.info("Arbitrary Indexing Starting ...");
+			ArbitraryIndexUtils.startCaching(
+				Settings.getInstance().getArbitraryIndexingPriority(),
+				Settings.getInstance().getArbitraryIndexingFrequency()
+			);
+
+			if( Settings.getInstance().isBalanceRecorderEnabled() ) {
+				Optional<HSQLDBBalanceRecorder> recorder = HSQLDBBalanceRecorder.getInstance();
+
+				if( recorder.isPresent() ) {
+					LOGGER.info("Balance Recorder Starting ...");
+					recorder.get().start();
+				}
+				else {
+					LOGGER.info("Balance Recorder won't start.");
+				}
+			}
+			else {
+				LOGGER.info("Balance Recorder Disabled");
+			}
 		} catch (DataException e) {
 			// If exception has no cause or message then repository is in use by some other process.
 			if (e.getCause() == null && e.getMessage() == null) {
@@ -485,7 +527,6 @@ public class Controller extends Thread {
 			@Override
 			public void run() {
 				Thread.currentThread().setName("Shutdown hook");
-
 				Controller.getInstance().shutdown();
 			}
 		});
@@ -510,9 +551,25 @@ public class Controller extends Thread {
 		ArbitraryDataStorageManager.getInstance().start();
 		ArbitraryDataRenderManager.getInstance().start();
 
+		// start rebuild arbitrary resource cache timer task
+		if( Settings.getInstance().isRebuildArbitraryResourceCacheTaskEnabled() ) {
+			new Timer().schedule(
+				new RebuildArbitraryResourceCacheTask(),
+				Settings.getInstance().getRebuildArbitraryResourceCacheTaskDelay() * RebuildArbitraryResourceCacheTask.MILLIS_IN_MINUTE,
+				Settings.getInstance().getRebuildArbitraryResourceCacheTaskPeriod() * RebuildArbitraryResourceCacheTask.MILLIS_IN_HOUR
+			);
+		}
+
+
 		LOGGER.info("Starting online accounts manager");
 		OnlineAccountsManager.getInstance().start();
 
+		LOGGER.info("Starting foreign fees manager");
+		ForeignFeesManager.getInstance().start();
+
+		LOGGER.info("Starting follower");
+		Follower.getInstance().start();
+
 		LOGGER.info("Starting transaction importer");
 		TransactionImporter.getInstance().start();
 
@@ -564,6 +621,122 @@ 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;
+
+				try (final Repository 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 +744,6 @@ public class Controller extends Thread {
 		// Return as we don't want to run more than one instance
 	}
 
-
 	// Main thread
 
 	@Override
@@ -775,7 +947,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 -> {
@@ -968,6 +1140,9 @@ public class Controller extends Thread {
 				LOGGER.info("Shutting down online accounts manager");
 				OnlineAccountsManager.getInstance().shutdown();
 
+				LOGGER.info("Shutting down foreign fees manager");
+				ForeignFeesManager.getInstance().shutdown();
+
 				LOGGER.info("Shutting down transaction importer");
 				TransactionImporter.getInstance().shutdown();
 
@@ -1312,6 +1487,14 @@ public class Controller extends Thread {
 				OnlineAccountsManager.getInstance().onNetworkOnlineAccountsV3Message(peer, message);
 				break;
 
+			case GET_FOREIGN_FEES:
+				ForeignFeesManager.getInstance().onNetworkGetForeignFeesMessage(peer, message);
+				break;
+
+			case FOREIGN_FEES:
+				ForeignFeesManager.getInstance().onNetworkForeignFeesMessage(peer, message);
+				break;
+
 			case GET_ARBITRARY_DATA:
 				// Not currently supported
 				break;
@@ -1921,8 +2104,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;
@@ -1999,8 +2181,25 @@ public class Controller extends Thread {
 		return now - offset;
 	}
 
+	private static void cleanChunkUploadTempDir() {
+		Path uploadsTemp = Paths.get("uploads-temp");
+		if (!Files.exists(uploadsTemp)) {
+			return;
+		}
+	
+		try (Stream<Path> paths = Files.walk(uploadsTemp)) {
+			paths.sorted(Comparator.reverseOrder())
+				 .map(Path::toFile)
+				 .forEach(File::delete);
+	
+			LOGGER.info("Cleaned up all temporary uploads in {}", uploadsTemp);
+		} catch (IOException e) {
+			LOGGER.warn("Failed to clean up uploads-temp directory", e);
+		}
+	}
+	
+
 	public StatsSnapshot getStatsSnapshot() {
 		return this.stats;
 	}
-
 }

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

@@ -13,6 +13,7 @@ import org.qortal.crypto.MemoryPoW;
 import org.qortal.crypto.Qortal25519Extras;
 import org.qortal.data.account.MintingAccountData;
 import org.qortal.data.account.RewardShareData;
+import org.qortal.data.group.GroupMemberData;
 import org.qortal.data.network.OnlineAccountData;
 import org.qortal.network.Network;
 import org.qortal.network.Peer;
@@ -24,6 +25,7 @@ import org.qortal.repository.Repository;
 import org.qortal.repository.RepositoryManager;
 import org.qortal.settings.Settings;
 import org.qortal.utils.Base58;
+import org.qortal.utils.Groups;
 import org.qortal.utils.NTP;
 import org.qortal.utils.NamedThreadFactory;
 
@@ -44,6 +46,7 @@ public class OnlineAccountsManager {
      */
     private static final long ONLINE_TIMESTAMP_MODULUS_V1 = 5 * 60 * 1000L;
     private static final long ONLINE_TIMESTAMP_MODULUS_V2 = 30 * 60 * 1000L;
+    private static final long ONLINE_TIMESTAMP_MODULUS_V3 = 10 * 60 * 1000L;
 
     /**
      * How many 'current' timestamp-sets of online accounts we cache.
@@ -67,12 +70,13 @@ public class OnlineAccountsManager {
     private static final long ONLINE_ACCOUNTS_COMPUTE_INITIAL_SLEEP_INTERVAL = 30 * 1000L; // ms
 
     // MemoryPoW - mainnet
-    public static final int POW_BUFFER_SIZE = 1 * 1024 * 1024; // bytes
+    public static final int POW_BUFFER_SIZE = 1024 * 1024; // bytes
     public static final int POW_DIFFICULTY_V1 = 18; // leading zero bits
     public static final int POW_DIFFICULTY_V2 = 19; // leading zero bits
+    public static final int POW_DIFFICULTY_V3 = 6; // leading zero bits
 
     // MemoryPoW - testnet
-    public static final int POW_BUFFER_SIZE_TESTNET = 1 * 1024 * 1024; // bytes
+    public static final int POW_BUFFER_SIZE_TESTNET = 1024 * 1024; // bytes
     public static final int POW_DIFFICULTY_TESTNET = 5; // leading zero bits
 
     // IMPORTANT: if we ever need to dynamically modify the buffer size using a feature trigger, the
@@ -80,7 +84,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();
@@ -106,11 +110,15 @@ public class OnlineAccountsManager {
 
     public static long getOnlineTimestampModulus() {
         Long now = NTP.getTime();
-        if (now != null && now >= BlockChain.getInstance().getOnlineAccountsModulusV2Timestamp()) {
+        if (now != null && now >= BlockChain.getInstance().getOnlineAccountsModulusV2Timestamp() && now < BlockChain.getInstance().getOnlineAccountsModulusV3Timestamp()) {
             return ONLINE_TIMESTAMP_MODULUS_V2;
         }
+        if (now != null && now >= BlockChain.getInstance().getOnlineAccountsModulusV3Timestamp()) {
+            return ONLINE_TIMESTAMP_MODULUS_V3;
+        }
         return ONLINE_TIMESTAMP_MODULUS_V1;
     }
+
     public static Long getCurrentOnlineAccountTimestamp() {
         Long now = NTP.getTime();
         if (now == null)
@@ -135,9 +143,12 @@ public class OnlineAccountsManager {
         if (Settings.getInstance().isTestNet())
             return POW_DIFFICULTY_TESTNET;
 
-        if (timestamp >= BlockChain.getInstance().getIncreaseOnlineAccountsDifficultyTimestamp())
+        if (timestamp >= BlockChain.getInstance().getIncreaseOnlineAccountsDifficultyTimestamp() && timestamp < BlockChain.getInstance().getDecreaseOnlineAccountsDifficultyTimestamp())
             return POW_DIFFICULTY_V2;
 
+        if (timestamp >= BlockChain.getInstance().getDecreaseOnlineAccountsDifficultyTimestamp())
+            return POW_DIFFICULTY_V3;
+
         return POW_DIFFICULTY_V1;
     }
 
@@ -215,6 +226,15 @@ public class OnlineAccountsManager {
         Set<OnlineAccountData> onlineAccountsToAdd = new HashSet<>();
         Set<OnlineAccountData> onlineAccountsToRemove = new HashSet<>();
         try (final Repository repository = RepositoryManager.getRepository()) {
+
+            int blockHeight = repository.getBlockRepository().getBlockchainHeight();
+
+            List<String> mintingGroupMemberAddresses
+                = Groups.getAllMembers(
+                    repository.getGroupRepository(),
+                    Groups.getGroupIdsToMint(BlockChain.getInstance(), blockHeight)
+            );
+
             for (OnlineAccountData onlineAccountData : this.onlineAccountsImportQueue) {
                 if (isStopping)
                     return;
@@ -227,7 +247,7 @@ public class OnlineAccountsManager {
                     continue;
                 }
 
-                boolean isValid = this.isValidCurrentAccount(repository, onlineAccountData);
+                boolean isValid = this.isValidCurrentAccount(repository, mintingGroupMemberAddresses, onlineAccountData);
                 if (isValid)
                     onlineAccountsToAdd.add(onlineAccountData);
 
@@ -306,7 +326,7 @@ public class OnlineAccountsManager {
         return inplaceArray;
     }
 
-    private static boolean isValidCurrentAccount(Repository repository, OnlineAccountData onlineAccountData) throws DataException {
+    private static boolean isValidCurrentAccount(Repository repository, List<String> mintingGroupMemberAddresses, OnlineAccountData onlineAccountData) throws DataException {
         final Long now = NTP.getTime();
         if (now == null)
             return false;
@@ -341,9 +361,14 @@ public class OnlineAccountsManager {
             LOGGER.trace(() -> String.format("Rejecting unknown online reward-share public key %s", Base58.encode(rewardSharePublicKey)));
             return false;
         }
+        // reject account address that are not in the MINTER Group
+        else if( !mintingGroupMemberAddresses.contains(rewardShareData.getMinter())) {
+            LOGGER.trace(() -> String.format("Rejecting online reward-share that is not in MINTER Group, account %s", rewardShareData.getMinter()));
+            return false;
+        }
 
         Account mintingAccount = new Account(repository, rewardShareData.getMinter());
-        if (!mintingAccount.canMint()) {
+        if (!mintingAccount.canMint(true)) {  // group validation is a few lines above
             // Minting-account component of reward-share can no longer mint - disregard
             LOGGER.trace(() -> String.format("Rejecting online reward-share with non-minting account %s", mintingAccount.getAddress()));
             return false;
@@ -530,7 +555,7 @@ public class OnlineAccountsManager {
                     }
 
                     Account mintingAccount = new Account(repository, rewardShareData.getMinter());
-                    if (!mintingAccount.canMint()) {
+                    if (!mintingAccount.canMint(true)) {
                         // Minting-account component of reward-share can no longer mint - disregard
                         iterator.remove();
                         continue;
@@ -538,7 +563,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/TransactionImporter.java

@@ -2,6 +2,7 @@ package org.qortal.controller;
 
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
+import org.qortal.controller.arbitrary.PeerMessage;
 import org.qortal.data.block.BlockData;
 import org.qortal.data.transaction.TransactionData;
 import org.qortal.network.Network;
@@ -20,7 +21,11 @@ import org.qortal.utils.Base58;
 import org.qortal.utils.NTP;
 
 import java.util.*;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.locks.ReentrantLock;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 
 public class TransactionImporter extends Thread {
@@ -50,6 +55,10 @@ public class TransactionImporter extends Thread {
     /** Cached list of unconfirmed transactions, used when counting per creator. This is replaced regularly */
     public static List<TransactionData> unconfirmedTransactionsCache = null;
 
+    public TransactionImporter() {
+        signatureMessageScheduler.scheduleAtFixedRate(this::processNetworkTransactionSignaturesMessage, 60, 1, TimeUnit.SECONDS);
+        getTransactionMessageScheduler.scheduleAtFixedRate(this::processNetworkGetTransactionMessages, 60, 1, TimeUnit.SECONDS);
+    }
 
     public static synchronized TransactionImporter getInstance() {
         if (instance == null) {
@@ -371,36 +380,104 @@ public class TransactionImporter extends Thread {
         }
     }
 
+    // List to collect messages
+    private final List<PeerMessage> getTransactionMessageList = new ArrayList<>();
+    // Lock to synchronize access to the list
+    private final Object getTransactionMessageLock = new Object();
+
+    // Scheduled executor service to process messages every second
+    private final ScheduledExecutorService getTransactionMessageScheduler = Executors.newScheduledThreadPool(1);
+
     public void onNetworkGetTransactionMessage(Peer peer, Message message) {
-        GetTransactionMessage getTransactionMessage = (GetTransactionMessage) message;
-        byte[] signature = getTransactionMessage.getSignature();
 
-        try (final Repository repository = RepositoryManager.getRepository()) {
+        synchronized (getTransactionMessageLock) {
+            getTransactionMessageList.add(new PeerMessage(peer, message));
+        }
+    }
+
+    private void processNetworkGetTransactionMessages() {
+
+        try {
+            List<PeerMessage> messagesToProcess;
+            synchronized (getTransactionMessageLock) {
+                messagesToProcess = new ArrayList<>(getTransactionMessageList);
+                getTransactionMessageList.clear();
+            }
+
+            if( messagesToProcess.isEmpty() ) return;
+
+            Map<String, PeerMessage> peerMessageBySignature58 = new HashMap<>(messagesToProcess.size());
+
+            for( PeerMessage peerMessage : messagesToProcess ) {
+                GetTransactionMessage getTransactionMessage = (GetTransactionMessage) peerMessage.getMessage();
+                byte[] signature = getTransactionMessage.getSignature();
+
+                peerMessageBySignature58.put(Base58.encode(signature), peerMessage);
+            }
+
             // Firstly check the sig-valid transactions that are currently queued for import
-            TransactionData transactionData = this.getCachedSigValidTransactions().stream()
-                    .filter(t -> Arrays.equals(signature, t.getSignature()))
-                    .findFirst().orElse(null);
+            Map<String, TransactionData> transactionsCachedBySignature58
+                = this.getCachedSigValidTransactions().stream()
+                    .collect(Collectors.toMap(t -> Base58.encode(t.getSignature()), Function.identity()));
 
-            if (transactionData == null) {
+            Map<Boolean, List<Map.Entry<String, PeerMessage>>> transactionsCachedBySignature58Partition
+                = peerMessageBySignature58.entrySet().stream()
+                    .collect(Collectors.partitioningBy(entry -> transactionsCachedBySignature58.containsKey(entry.getKey())));
+
+            List<byte[]> signaturesNeeded
+                = transactionsCachedBySignature58Partition.get(false).stream()
+                    .map(Map.Entry::getValue)
+                    .map(PeerMessage::getMessage)
+                    .map(message -> (GetTransactionMessage) message)
+                    .map(GetTransactionMessage::getSignature)
+                    .collect(Collectors.toList());
+
+            // transaction found in the import queue
+            Map<String, TransactionData> transactionsToSendBySignature58 = new HashMap<>(messagesToProcess.size());
+            for( Map.Entry<String, PeerMessage> entry : transactionsCachedBySignature58Partition.get(true)) {
+                transactionsToSendBySignature58.put(entry.getKey(), transactionsCachedBySignature58.get(entry.getKey()));
+            }
+
+            if( !signaturesNeeded.isEmpty() ) {
                 // Not found in import queue, so try the database
-                transactionData = repository.getTransactionRepository().fromSignature(signature);
+                try (final Repository repository = RepositoryManager.getRepository()) {
+                    transactionsToSendBySignature58.putAll(
+                            repository.getTransactionRepository().fromSignatures(signaturesNeeded).stream()
+                                    .collect(Collectors.toMap(transactionData -> Base58.encode(transactionData.getSignature()), Function.identity()))
+                    );
+                } catch (DataException e) {
+                    LOGGER.error(e.getMessage(), e);
+                }
             }
 
-            if (transactionData == null) {
-                // Still not found - so we don't have this transaction
-                LOGGER.debug(() -> String.format("Ignoring GET_TRANSACTION request from peer %s for unknown transaction %s", peer, Base58.encode(signature)));
-                // Send no response at all???
-                return;
-            }
+            for( final Map.Entry<String, TransactionData> entry : transactionsToSendBySignature58.entrySet() ) {
 
-            Message transactionMessage = new TransactionMessage(transactionData);
+                PeerMessage peerMessage = peerMessageBySignature58.get(entry.getKey());
+                final Message message = peerMessage.getMessage();
+                final Peer peer = peerMessage.getPeer();
+
+                Runnable sendTransactionMessageRunner = () -> sendTransactionMessage(entry.getKey(), entry.getValue(), message, peer);
+                Thread sendTransactionMessageThread = new Thread(sendTransactionMessageRunner);
+                sendTransactionMessageThread.start();
+            }
+        } catch (Exception e) {
+            LOGGER.error(e.getMessage(),e);
+        }
+    }
+
+    private static void sendTransactionMessage(String signature58, TransactionData data, Message message, Peer peer) {
+        try {
+            Message transactionMessage = new TransactionMessage(data);
             transactionMessage.setId(message.getId());
+
             if (!peer.sendMessage(transactionMessage))
                 peer.disconnect("failed to send transaction");
-        } catch (DataException e) {
-            LOGGER.error(String.format("Repository issue while sending transaction %s to peer %s", Base58.encode(signature), peer), e);
-        } catch (TransformationException e) {
-            LOGGER.error(String.format("Serialization issue while sending transaction %s to peer %s", Base58.encode(signature), peer), e);
+        }
+        catch (TransformationException e) {
+            LOGGER.error(String.format("Serialization issue while sending transaction %s to peer %s", signature58, peer), e);
+        }
+        catch (Exception e) {
+            LOGGER.error(e.getMessage(), e);
         }
     }
 
@@ -421,44 +498,86 @@ public class TransactionImporter extends Thread {
         }
     }
 
+    // List to collect messages
+    private final List<PeerMessage> signatureMessageList = new ArrayList<>();
+    // Lock to synchronize access to the list
+    private final Object signatureMessageLock = new Object();
+
+    // Scheduled executor service to process messages every second
+    private final ScheduledExecutorService signatureMessageScheduler = Executors.newScheduledThreadPool(1);
+
     public void onNetworkTransactionSignaturesMessage(Peer peer, Message message) {
-        TransactionSignaturesMessage transactionSignaturesMessage = (TransactionSignaturesMessage) message;
-        List<byte[]> signatures = transactionSignaturesMessage.getSignatures();
+        synchronized (signatureMessageLock) {
+            signatureMessageList.add(new PeerMessage(peer, message));
+        }
+    }
 
-        try (final Repository repository = RepositoryManager.getRepository()) {
-            for (byte[] signature : signatures) {
-                String signature58 = Base58.encode(signature);
-                if (invalidUnconfirmedTransactions.containsKey(signature58)) {
-                    // Previously invalid transaction - don't keep requesting it
-                    // It will be periodically removed from invalidUnconfirmedTransactions to allow for rechecks
-                    continue;
-                }
+    public void processNetworkTransactionSignaturesMessage() {
 
-                // Ignore if this transaction is in the queue
-                if (incomingTransactionQueueContains(signature)) {
-                    LOGGER.trace(() -> String.format("Ignoring existing queued transaction %s from peer %s", Base58.encode(signature), peer));
-                    continue;
-                }
+        try {
+            List<PeerMessage> messagesToProcess;
+            synchronized (signatureMessageLock) {
+                messagesToProcess = new ArrayList<>(signatureMessageList);
+                signatureMessageList.clear();
+            }
 
-                // Do we have it already? (Before requesting transaction data itself)
-                if (repository.getTransactionRepository().exists(signature)) {
-                    LOGGER.trace(() -> String.format("Ignoring existing transaction %s from peer %s", Base58.encode(signature), peer));
-                    continue;
-                }
+            Map<String, byte[]> signatureBySignature58 = new HashMap<>(messagesToProcess.size() * 10);
+            Map<String, Peer> peerBySignature58 = new HashMap<>( messagesToProcess.size() * 10 );
 
-                // Check isInterrupted() here and exit fast
-                if (Thread.currentThread().isInterrupted())
-                    return;
+            for( PeerMessage peerMessage : messagesToProcess ) {
 
-                // Fetch actual transaction data from peer
-                Message getTransactionMessage = new GetTransactionMessage(signature);
-                if (!peer.sendMessage(getTransactionMessage)) {
-                    peer.disconnect("failed to request transaction");
-                    return;
+                TransactionSignaturesMessage transactionSignaturesMessage = (TransactionSignaturesMessage) peerMessage.getMessage();
+                List<byte[]> signatures = transactionSignaturesMessage.getSignatures();
+
+                for (byte[] signature : signatures) {
+                    String signature58 = Base58.encode(signature);
+                    if (invalidUnconfirmedTransactions.containsKey(signature58)) {
+                        // Previously invalid transaction - don't keep requesting it
+                        // It will be periodically removed from invalidUnconfirmedTransactions to allow for rechecks
+                        continue;
+                    }
+
+                    // Ignore if this transaction is in the queue
+                    if (incomingTransactionQueueContains(signature)) {
+                        LOGGER.trace(() -> String.format("Ignoring existing queued transaction %s from peer %s", Base58.encode(signature), peerMessage.getPeer()));
+                        continue;
+                    }
+
+                    signatureBySignature58.put(signature58, signature);
+                    peerBySignature58.put(signature58, peerMessage.getPeer());
                 }
             }
-        } catch (DataException e) {
-            LOGGER.error(String.format("Repository issue while processing unconfirmed transactions from peer %s", peer), e);
+
+            if( !signatureBySignature58.isEmpty() ) {
+                try (final Repository repository = RepositoryManager.getRepository()) {
+
+                    // remove signatures in db already
+                    repository.getTransactionRepository()
+                            .fromSignatures(new ArrayList<>(signatureBySignature58.values())).stream()
+                            .map(TransactionData::getSignature)
+                            .map(signature -> Base58.encode(signature))
+                            .forEach(signature58 -> signatureBySignature58.remove(signature58));
+                } catch (DataException e) {
+                    LOGGER.error(String.format("Repository issue while processing unconfirmed transactions from peer"), e);
+                }
+            }
+
+            // Check isInterrupted() here and exit fast
+            if (Thread.currentThread().isInterrupted())
+                return;
+
+            for (Map.Entry<String, byte[]> entry : signatureBySignature58.entrySet()) {
+
+                Peer peer = peerBySignature58.get(entry.getKey());
+
+                // Fetch actual transaction data from peer
+                Message getTransactionMessage = new GetTransactionMessage(entry.getValue());
+                if (peer != null && !peer.sendMessage(getTransactionMessage)) {
+                    peer.disconnect("failed to request transaction");
+                }
+            }
+        } catch (Exception e) {
+            LOGGER.error(e.getMessage(), e);
         }
     }
 

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

@@ -2,22 +2,30 @@ package org.qortal.controller.arbitrary;
 
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
-import org.qortal.api.resource.TransactionsResource;
 import org.qortal.controller.Controller;
 import org.qortal.data.arbitrary.ArbitraryResourceData;
 import org.qortal.data.transaction.ArbitraryTransactionData;
+import org.qortal.event.DataMonitorEvent;
+import org.qortal.event.EventBus;
 import org.qortal.gui.SplashFrame;
 import org.qortal.repository.DataException;
 import org.qortal.repository.Repository;
 import org.qortal.repository.RepositoryManager;
 import org.qortal.settings.Settings;
 import org.qortal.transaction.ArbitraryTransaction;
-import org.qortal.transaction.Transaction;
 import org.qortal.utils.Base58;
 
+import java.text.NumberFormat;
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.stream.Collectors;
 
 public class ArbitraryDataCacheManager extends Thread {
 
@@ -29,6 +37,11 @@ public class ArbitraryDataCacheManager extends Thread {
     /** Queue of arbitrary transactions that require cache updates */
     private final List<ArbitraryTransactionData> updateQueue = Collections.synchronizedList(new ArrayList<>());
 
+    private static final NumberFormat FORMATTER = NumberFormat.getNumberInstance();
+
+    static {
+        FORMATTER.setGroupingUsed(true);
+    }
 
     public static synchronized ArbitraryDataCacheManager getInstance() {
         if (instance == null) {
@@ -41,20 +54,26 @@ 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()) {
-                Thread.sleep(500L);
+                try {
+                    Thread.sleep(500L);
 
-                // Process queue
-                processResourceQueue();
+                    // Process queue
+                    processResourceQueue();
+                } catch (Exception e) {
+                    LOGGER.error(e.getMessage(), e);
+                    Thread.sleep(600_000L); // wait 10 minutes to continue
+                }
             }
-        } catch (InterruptedException e) {
-            // Fall through to exit thread
-        }
 
-        // Clear queue before terminating thread
-        processResourceQueue();
+            // Clear queue before terminating thread
+            processResourceQueue();
+        } catch (Exception e) {
+            LOGGER.error(e.getMessage(), e);
+        }
     }
 
     public void shutdown() {
@@ -84,14 +103,25 @@ public class ArbitraryDataCacheManager extends Thread {
                 // Update arbitrary resource caches
                 try {
                     ArbitraryTransaction arbitraryTransaction = new ArbitraryTransaction(repository, transactionData);
-                    arbitraryTransaction.updateArbitraryResourceCache(repository);
-                    arbitraryTransaction.updateArbitraryMetadataCache(repository);
+                    arbitraryTransaction.updateArbitraryResourceCacheIncludingMetadata(repository, new HashSet<>(0), new HashMap<>(0));
                     repository.saveChanges();
 
                     // Update status as separate commit, as this is more prone to failure
                     arbitraryTransaction.updateArbitraryResourceStatus(repository);
                     repository.saveChanges();
 
+                    EventBus.INSTANCE.notify(
+                        new DataMonitorEvent(
+                            System.currentTimeMillis(),
+                            transactionData.getIdentifier(),
+                            transactionData.getName(),
+                            transactionData.getService().name(),
+                            "updated resource cache and status, queue",
+                            transactionData.getTimestamp(),
+                            transactionData.getTimestamp()
+                        )
+                    );
+
                     LOGGER.debug(() -> String.format("Finished processing transaction %.8s in arbitrary resource queue...", Base58.encode(transactionData.getSignature())));
 
                 } catch (DataException e) {
@@ -102,6 +132,9 @@ public class ArbitraryDataCacheManager extends Thread {
         } catch (DataException e) {
             LOGGER.error("Repository issue while processing arbitrary resource cache updates", e);
         }
+        catch (Exception e) {
+            LOGGER.error(e.getMessage(), e);
+        }
     }
 
     public void addToUpdateQueue(ArbitraryTransactionData transactionData) {
@@ -147,34 +180,66 @@ public class ArbitraryDataCacheManager extends Thread {
             LOGGER.info("Building arbitrary resources cache...");
             SplashFrame.getInstance().updateStatus("Building QDN cache - please wait...");
 
-            final int batchSize = 100;
+            final int batchSize = Settings.getInstance().getBuildArbitraryResourcesBatchSize();
             int offset = 0;
 
+            List<ArbitraryTransactionData> allArbitraryTransactionsInDescendingOrder
+                    = repository.getArbitraryRepository().getLatestArbitraryTransactions();
+
+            LOGGER.info("arbitrary transactions: count = " + allArbitraryTransactionsInDescendingOrder.size());
+
+            List<ArbitraryResourceData> resources = repository.getArbitraryRepository().getArbitraryResources(null, null, true);
+
+            Map<ArbitraryTransactionDataHashWrapper, ArbitraryResourceData> resourceByWrapper = new HashMap<>(resources.size());
+            for( ArbitraryResourceData resource : resources ) {
+                resourceByWrapper.put(
+                    new ArbitraryTransactionDataHashWrapper(resource.service.value, resource.name, resource.identifier),
+                    resource
+                );
+            }
+
+            LOGGER.info("arbitrary resources: count = " + resourceByWrapper.size());
+
+            Set<ArbitraryTransactionDataHashWrapper> latestTransactionsWrapped = new HashSet<>(allArbitraryTransactionsInDescendingOrder.size());
+
             // Loop through all ARBITRARY transactions, and determine latest state
             while (!Controller.isStopping()) {
-                LOGGER.info("Fetching arbitrary transactions {} - {}", offset, offset+batchSize-1);
+                LOGGER.info(
+                    "Fetching arbitrary transactions {} - {} / {} Total",
+                    FORMATTER.format(offset),
+                    FORMATTER.format(offset+batchSize-1),
+                    FORMATTER.format(allArbitraryTransactionsInDescendingOrder.size())
+                );
 
-                List<byte[]> signatures = repository.getTransactionRepository().getSignaturesMatchingCriteria(null, null, null, List.of(Transaction.TransactionType.ARBITRARY), null, null, null, TransactionsResource.ConfirmationStatus.BOTH, batchSize, offset, false);
-                if (signatures.isEmpty()) {
+                List<ArbitraryTransactionData> transactionsToProcess
+                    = allArbitraryTransactionsInDescendingOrder.stream()
+                        .skip(offset)
+                        .limit(batchSize)
+                        .collect(Collectors.toList());
+
+                if (transactionsToProcess.isEmpty()) {
                     // Complete
                     break;
                 }
 
-                // Expand signatures to transactions
-                for (byte[] signature : signatures) {
-                    ArbitraryTransactionData transactionData = (ArbitraryTransactionData) repository
-                            .getTransactionRepository().fromSignature(signature);
+                try {
+                    for( ArbitraryTransactionData transactionData : transactionsToProcess) {
+                        if (transactionData.getService() == null) {
+                            // Unsupported service - ignore this resource
+                            continue;
+                        }
 
-                    if (transactionData.getService() == null) {
-                        // Unsupported service - ignore this resource
-                        continue;
+                        latestTransactionsWrapped.add(new ArbitraryTransactionDataHashWrapper(transactionData));
+
+                        // Update arbitrary resource caches
+                        ArbitraryTransaction arbitraryTransaction = new ArbitraryTransaction(repository, transactionData);
+                        arbitraryTransaction.updateArbitraryResourceCacheIncludingMetadata(repository, latestTransactionsWrapped, resourceByWrapper);
                     }
-
-                    // Update arbitrary resource caches
-                    ArbitraryTransaction arbitraryTransaction = new ArbitraryTransaction(repository, transactionData);
-                    arbitraryTransaction.updateArbitraryResourceCache(repository);
-                    arbitraryTransaction.updateArbitraryMetadataCache(repository);
                     repository.saveChanges();
+                } catch (DataException e) {
+                    repository.discardChanges();
+
+                    LOGGER.error(e.getMessage(), e);
                 }
                 offset += batchSize;
             }
@@ -192,6 +257,11 @@ public class ArbitraryDataCacheManager extends Thread {
             repository.discardChanges();
             throw new DataException("Build of arbitrary resources cache failed.");
         }
+        catch (Exception e) {
+            LOGGER.error(e.getMessage(), e);
+
+            return false;
+        }
     }
 
     private boolean refreshArbitraryStatuses(Repository repository) throws DataException {
@@ -199,27 +269,48 @@ public class ArbitraryDataCacheManager extends Thread {
             LOGGER.info("Refreshing arbitrary resource statuses for locally hosted transactions...");
             SplashFrame.getInstance().updateStatus("Refreshing statuses - please wait...");
 
-            final int batchSize = 100;
+            final int batchSize = Settings.getInstance().getBuildArbitraryResourcesBatchSize();
             int offset = 0;
 
+            List<ArbitraryTransactionData> allHostedTransactions
+                = ArbitraryDataStorageManager.getInstance()
+                    .listAllHostedTransactions(repository, null, null);
+
             // Loop through all ARBITRARY transactions, and determine latest state
             while (!Controller.isStopping()) {
-                LOGGER.info("Fetching hosted transactions {} - {}", offset, offset+batchSize-1);
+                LOGGER.info(
+                    "Fetching hosted transactions {} - {} / {} Total",
+                    FORMATTER.format(offset),
+                    FORMATTER.format(offset+batchSize-1),
+                    FORMATTER.format(allHostedTransactions.size())
+                );
+
+                List<ArbitraryTransactionData> hostedTransactions
+                    = allHostedTransactions.stream()
+                        .skip(offset)
+                        .limit(batchSize)
+                        .collect(Collectors.toList());
 
-                List<ArbitraryTransactionData> hostedTransactions = ArbitraryDataStorageManager.getInstance().listAllHostedTransactions(repository, batchSize, offset);
                 if (hostedTransactions.isEmpty()) {
                     // Complete
                     break;
                 }
 
-                // Loop through hosted transactions
-                for (ArbitraryTransactionData transactionData : hostedTransactions) {
+                try {
+                    // Loop through hosted transactions
+                    for (ArbitraryTransactionData transactionData : hostedTransactions) {
 
-                    // Determine status and update cache
-                    ArbitraryTransaction arbitraryTransaction = new ArbitraryTransaction(repository, transactionData);
-                    arbitraryTransaction.updateArbitraryResourceStatus(repository);
+                        // Determine status and update cache
+                        ArbitraryTransaction arbitraryTransaction = new ArbitraryTransaction(repository, transactionData);
+                        arbitraryTransaction.updateArbitraryResourceStatus(repository);
+                    }
                     repository.saveChanges();
+                } catch (DataException e) {
+                    repository.discardChanges();
+
+                    LOGGER.error(e.getMessage(), e);
                 }
+
                 offset += batchSize;
             }
 
@@ -233,6 +324,11 @@ public class ArbitraryDataCacheManager extends Thread {
             repository.discardChanges();
             throw new DataException("Refresh of arbitrary resource statuses failed.");
         }
+        catch (Exception e) {
+            LOGGER.error(e.getMessage(), e);
+
+            return false;
+        }
     }
 
 }

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

@@ -2,9 +2,10 @@ package org.qortal.controller.arbitrary;
 
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
-import org.qortal.api.resource.TransactionsResource.ConfirmationStatus;
 import org.qortal.data.transaction.ArbitraryTransactionData;
 import org.qortal.data.transaction.TransactionData;
+import org.qortal.event.DataMonitorEvent;
+import org.qortal.event.EventBus;
 import org.qortal.repository.DataException;
 import org.qortal.repository.Repository;
 import org.qortal.repository.RepositoryManager;
@@ -21,8 +22,12 @@ import java.nio.file.Paths;
 import java.security.SecureRandom;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Collectors;
 
 import static org.qortal.controller.arbitrary.ArbitraryDataStorageManager.DELETION_THRESHOLD;
 
@@ -71,11 +76,25 @@ 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;
 		int offset = 0;
 
+		List<ArbitraryTransactionData> allArbitraryTransactionsInDescendingOrder;
+
+		try (final Repository repository = RepositoryManager.getRepository()) {
+			allArbitraryTransactionsInDescendingOrder
+					= repository.getArbitraryRepository()
+					.getLatestArbitraryTransactions();
+		} catch( Exception e) {
+			LOGGER.error(e.getMessage(), e);
+			allArbitraryTransactionsInDescendingOrder = new ArrayList<>(0);
+		}
+
+		Set<ArbitraryTransactionData> processedTransactions = new HashSet<>();
+
 		try {
 			while (!isStopping) {
 				Thread.sleep(30000);
@@ -106,27 +125,31 @@ public class ArbitraryDataCleanupManager extends Thread {
 
 				// Any arbitrary transactions we want to fetch data for?
 				try (final Repository repository = RepositoryManager.getRepository()) {
-					List<byte[]> signatures = repository.getTransactionRepository().getSignaturesMatchingCriteria(null, null, null, ARBITRARY_TX_TYPE, null, null, null, ConfirmationStatus.BOTH, limit, offset, true);
-					// LOGGER.info("Found {} arbitrary transactions at offset: {}, limit: {}", signatures.size(), offset, limit);
+					List<ArbitraryTransactionData> transactions = allArbitraryTransactionsInDescendingOrder.stream().skip(offset).limit(limit).collect(Collectors.toList());
 					if (isStopping) {
 						return;
 					}
 
-					if (signatures == null || signatures.isEmpty()) {
+					if (transactions == null || transactions.isEmpty()) {
 						offset = 0;
-						continue;
+						allArbitraryTransactionsInDescendingOrder
+								= repository.getArbitraryRepository()
+								.getLatestArbitraryTransactions();
+						transactions = allArbitraryTransactionsInDescendingOrder.stream().limit(limit).collect(Collectors.toList());
+						processedTransactions.clear();
 					}
+
 					offset += limit;
 					now = NTP.getTime();
 
 					// Loop through the signatures in this batch
-					for (int i=0; i<signatures.size(); i++) {
+					for (int i=0; i<transactions.size(); i++) {
 						if (isStopping) {
 							return;
 						}
 
-						byte[] signature = signatures.get(i);
-						if (signature == null) {
+						ArbitraryTransactionData arbitraryTransactionData = transactions.get(i);
+						if (arbitraryTransactionData == null) {
 							continue;
 						}
 
@@ -135,9 +158,7 @@ public class ArbitraryDataCleanupManager extends Thread {
 							Thread.sleep(5000);
 						}
 
-						// Fetch the transaction data
-						ArbitraryTransactionData arbitraryTransactionData = ArbitraryTransactionUtils.fetchTransactionData(repository, signature);
-						if (arbitraryTransactionData == null || arbitraryTransactionData.getService() == null) {
+						if (arbitraryTransactionData.getService() == null) {
 							continue;
 						}
 
@@ -146,6 +167,8 @@ public class ArbitraryDataCleanupManager extends Thread {
 							continue;
 						}
 
+						boolean mostRecentTransaction = processedTransactions.add(arbitraryTransactionData);
+
 						// Check if we have the complete file
 						boolean completeFileExists = ArbitraryTransactionUtils.completeFileExists(arbitraryTransactionData);
 
@@ -166,20 +189,54 @@ public class ArbitraryDataCleanupManager extends Thread {
 							LOGGER.info("Deleting transaction {} because we can't host its data",
 									Base58.encode(arbitraryTransactionData.getSignature()));
 							ArbitraryTransactionUtils.deleteCompleteFileAndChunks(arbitraryTransactionData);
+
+							EventBus.INSTANCE.notify(
+								new DataMonitorEvent(
+									System.currentTimeMillis(),
+									arbitraryTransactionData.getIdentifier(),
+									arbitraryTransactionData.getName(),
+									arbitraryTransactionData.getService().name(),
+									"can't store data, deleting",
+									arbitraryTransactionData.getTimestamp(),
+									arbitraryTransactionData.getTimestamp()
+								)
+							);
 							continue;
 						}
 
 						// Check to see if we have had a more recent PUT
-						boolean hasMoreRecentPutTransaction = ArbitraryTransactionUtils.hasMoreRecentPutTransaction(repository, arbitraryTransactionData);
-						if (hasMoreRecentPutTransaction) {
+						if (!mostRecentTransaction) {
 							// There is a more recent PUT transaction than the one we are currently processing.
 							// When a PUT is issued, it replaces any layers that would have been there before.
 							// Therefore any data relating to this older transaction is no longer needed.
 							LOGGER.info(String.format("Newer PUT found for %s %s since transaction %s. " +
 											"Deleting all files associated with the earlier transaction.", arbitraryTransactionData.getService(),
-									arbitraryTransactionData.getName(), Base58.encode(signature)));
+									arbitraryTransactionData.getName(), Base58.encode(arbitraryTransactionData.getSignature())));
 
 							ArbitraryTransactionUtils.deleteCompleteFileAndChunks(arbitraryTransactionData);
+
+							Optional<ArbitraryTransactionData> moreRecentPutTransaction
+								= processedTransactions.stream()
+									.filter(data -> data.equals(arbitraryTransactionData))
+									.findAny();
+
+							if( moreRecentPutTransaction.isPresent() ) {
+								EventBus.INSTANCE.notify(
+									new DataMonitorEvent(
+										System.currentTimeMillis(),
+										arbitraryTransactionData.getIdentifier(),
+										arbitraryTransactionData.getName(),
+										arbitraryTransactionData.getService().name(),
+										"deleting data due to replacement",
+										arbitraryTransactionData.getTimestamp(),
+										moreRecentPutTransaction.get().getTimestamp()
+									)
+								);
+							}
+							else {
+								LOGGER.warn("Something went wrong with the most recent put transaction determination!");
+							}
+
 							continue;
 						}
 
@@ -198,7 +255,21 @@ public class ArbitraryDataCleanupManager extends Thread {
 							LOGGER.debug(String.format("Transaction %s has complete file and all chunks",
 									Base58.encode(arbitraryTransactionData.getSignature())));
 
-							ArbitraryTransactionUtils.deleteCompleteFile(arbitraryTransactionData, now, STALE_FILE_TIMEOUT);
+							boolean wasDeleted = ArbitraryTransactionUtils.deleteCompleteFile(arbitraryTransactionData, now, STALE_FILE_TIMEOUT);
+
+							if( wasDeleted ) {
+								EventBus.INSTANCE.notify(
+									new DataMonitorEvent(
+										System.currentTimeMillis(),
+										arbitraryTransactionData.getIdentifier(),
+										arbitraryTransactionData.getName(),
+										arbitraryTransactionData.getService().name(),
+										"deleting file, retaining chunks",
+										arbitraryTransactionData.getTimestamp(),
+										arbitraryTransactionData.getTimestamp()
+									)
+								);
+							}
 							continue;
 						}
 
@@ -208,8 +279,7 @@ public class ArbitraryDataCleanupManager extends Thread {
 									Base58.encode(arbitraryTransactionData.getSignature())));
 
 							ArbitraryTransactionUtils.convertFileToChunks(arbitraryTransactionData, now, STALE_FILE_TIMEOUT);
-							continue;
-						}
+                        }
 					}
 
 				} catch (DataException e) {
@@ -237,17 +307,6 @@ public class ArbitraryDataCleanupManager extends Thread {
 						this.storageLimitReached(repository);
 					}
 
-					// Delete random data associated with name if we're over our storage limit for this name
-					// Use the DELETION_THRESHOLD, for the same reasons as above
-					for (String followedName : ListUtils.followedNames()) {
-						if (isStopping) {
-							return;
-						}
-						if (!storageManager.isStorageSpaceAvailableForName(repository, followedName, DELETION_THRESHOLD)) {
-							this.storageLimitReachedForName(repository, followedName);
-						}
-					}
-
 				} catch (DataException e) {
 					LOGGER.error("Repository issue when cleaning up arbitrary transaction data", e);
 				}
@@ -284,8 +343,7 @@ public class ArbitraryDataCleanupManager extends Thread {
 				}
 
 			} catch (DataException e) {
-				continue;
-			}
+            }
 		}
 
 		return pathList;
@@ -327,25 +385,6 @@ public class ArbitraryDataCleanupManager extends Thread {
 		// FUTURE: consider reducing the expiry time of the reader cache
 	}
 
-	public void storageLimitReachedForName(Repository repository, String name) throws InterruptedException {
-		// We think that the storage limit has been reached for supplied name - but we should double check
-		if (ArbitraryDataStorageManager.getInstance().isStorageSpaceAvailableForName(repository, name, DELETION_THRESHOLD)) {
-			// We have space available for this name, so don't delete anything
-			return;
-		}
-
-		// Delete a batch of random chunks associated with this name
-		// This reduces the chance of too many nodes deleting the same chunk
-		// when they reach their storage limit
-		Path dataPath = Paths.get(Settings.getInstance().getDataPath());
-		for (int i=0; i<CHUNK_DELETION_BATCH_SIZE; i++) {
-			if (isStopping) {
-				return;
-			}
-			this.deleteRandomFile(repository, dataPath.toFile(), name);
-		}
-	}
-
 	/**
 	 * Iteratively walk through given directory and delete a single random file
 	 *
@@ -424,6 +463,7 @@ public class ArbitraryDataCleanupManager extends Thread {
 				}
 
 				LOGGER.info("Deleting random file {} because we have reached max storage capacity...", randomItem.toString());
+				fireRandomItemDeletionNotification(randomItem, repository, "Deleting random file, because we have reached max storage capacity");
 				boolean success = randomItem.delete();
 				if (success) {
 					try {
@@ -438,6 +478,35 @@ public class ArbitraryDataCleanupManager extends Thread {
 		return false;
 	}
 
+	private void fireRandomItemDeletionNotification(File randomItem, Repository repository, String reason) {
+		try {
+			Path parentFileNamePath = randomItem.toPath().toAbsolutePath().getParent().getFileName();
+			if (parentFileNamePath != null) {
+				String signature58 = parentFileNamePath.toString();
+				byte[] signature = Base58.decode(signature58);
+				TransactionData transactionData = repository.getTransactionRepository().fromSignature(signature);
+				if (transactionData != null && transactionData.getType() == Transaction.TransactionType.ARBITRARY) {
+					ArbitraryTransactionData arbitraryTransactionData = (ArbitraryTransactionData) transactionData;
+
+					EventBus.INSTANCE.notify(
+						new DataMonitorEvent(
+							System.currentTimeMillis(),
+							arbitraryTransactionData.getIdentifier(),
+							arbitraryTransactionData.getName(),
+							arbitraryTransactionData.getService().name(),
+							reason,
+							arbitraryTransactionData.getTimestamp(),
+							arbitraryTransactionData.getTimestamp()
+						)
+					);
+				}
+			}
+
+		} catch (Exception e) {
+			LOGGER.error(e.getMessage(), e);
+		}
+	}
+
 	private void cleanupTempDirectory(String folder, long now, long minAge) {
 		String baseDir = Settings.getInstance().getTempDataPath();
 		Path tempDir = Paths.get(baseDir, folder);

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

@@ -0,0 +1,21 @@
+package org.qortal.controller.arbitrary;
+
+public class ArbitraryDataExamination {
+
+    private boolean pass;
+
+    private String notes;
+
+    public ArbitraryDataExamination(boolean pass, String notes) {
+        this.pass = pass;
+        this.notes = notes;
+    }
+
+    public boolean isPass() {
+        return pass;
+    }
+
+    public String getNotes() {
+        return notes;
+    }
+}

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

@@ -25,6 +25,10 @@ import org.qortal.utils.NTP;
 import org.qortal.utils.Triple;
 
 import java.util.*;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
 
 import static org.qortal.controller.arbitrary.ArbitraryDataFileManager.MAX_FILE_HASH_RESPONSES;
 
@@ -73,6 +77,8 @@ public class ArbitraryDataFileListManager {
 
 
     private ArbitraryDataFileListManager() {
+        getArbitraryDataFileListMessageScheduler.scheduleAtFixedRate(this::processNetworkGetArbitraryDataFileListMessage, 60, 1, TimeUnit.SECONDS);
+        arbitraryDataFileListMessageScheduler.scheduleAtFixedRate(this::processNetworkArbitraryDataFileListMessage, 60, 1, TimeUnit.SECONDS);
     }
 
     public static ArbitraryDataFileListManager getInstance() {
@@ -118,8 +124,8 @@ public class ArbitraryDataFileListManager {
         if (timeSinceLastAttempt > 15 * 1000L) {
             // We haven't tried for at least 15 seconds
 
-            if (networkBroadcastCount < 3) {
-                // We've made less than 3 total attempts
+            if (networkBroadcastCount < 12) {
+                // We've made less than 12 total attempts
                 return true;
             }
         }
@@ -128,8 +134,8 @@ public class ArbitraryDataFileListManager {
         if (timeSinceLastAttempt > 60 * 1000L) {
             // We haven't tried for at least 1 minute
 
-            if (networkBroadcastCount < 8) {
-                // We've made less than 8 total attempts
+            if (networkBroadcastCount < 40) {
+                // We've made less than 40 total attempts
                 return true;
             }
         }
@@ -396,11 +402,11 @@ public class ArbitraryDataFileListManager {
         return true;
     }
 
-    public void deleteFileListRequestsForSignature(byte[] signature) {
-        String signature58 = Base58.encode(signature);
+    public void deleteFileListRequestsForSignature(String signature58) {
+
         for (Iterator<Map.Entry<Integer, Triple<String, Peer, Long>>> it = arbitraryDataFileListRequests.entrySet().iterator(); it.hasNext();) {
             Map.Entry<Integer, Triple<String, Peer, Long>> entry = it.next();
-            if (entry == null || entry.getKey() == null || entry.getValue() != null) {
+            if (entry == null || entry.getKey() == null || entry.getValue() == null) {
                 continue;
             }
             if (Objects.equals(entry.getValue().getA(), signature58)) {
@@ -413,70 +419,116 @@ public class ArbitraryDataFileListManager {
 
     // Network handlers
 
+    // List to collect messages
+    private final List<PeerMessage> arbitraryDataFileListMessageList = new ArrayList<>();
+    // Lock to synchronize access to the list
+    private final Object arbitraryDataFileListMessageLock = new Object();
+
+    // Scheduled executor service to process messages every second
+    private final ScheduledExecutorService arbitraryDataFileListMessageScheduler = Executors.newScheduledThreadPool(1);
+
     public void onNetworkArbitraryDataFileListMessage(Peer peer, Message message) {
         // Don't process if QDN is disabled
         if (!Settings.getInstance().isQdnEnabled()) {
             return;
         }
 
-        ArbitraryDataFileListMessage arbitraryDataFileListMessage = (ArbitraryDataFileListMessage) message;
-        LOGGER.debug("Received hash list from peer {} with {} hashes", peer, arbitraryDataFileListMessage.getHashes().size());
-
-        if (LOGGER.isDebugEnabled() && arbitraryDataFileListMessage.getRequestTime() != null) {
-            long totalRequestTime = NTP.getTime() - arbitraryDataFileListMessage.getRequestTime();
-            LOGGER.debug("totalRequestTime: {}, requestHops: {}, peerAddress: {}, isRelayPossible: {}",
-                    totalRequestTime, arbitraryDataFileListMessage.getRequestHops(),
-                    arbitraryDataFileListMessage.getPeerAddress(), arbitraryDataFileListMessage.isRelayPossible());
+        synchronized (arbitraryDataFileListMessageLock) {
+            arbitraryDataFileListMessageList.add(new PeerMessage(peer, message));
         }
+    }
 
-        // Do we have a pending request for this data?
-        Triple<String, Peer, Long> request = arbitraryDataFileListRequests.get(message.getId());
-        if (request == null || request.getA() == null) {
-            return;
-        }
-        boolean isRelayRequest = (request.getB() != null);
+    private void processNetworkArbitraryDataFileListMessage() {
 
-        // Does this message's signature match what we're expecting?
-        byte[] signature = arbitraryDataFileListMessage.getSignature();
-        String signature58 = Base58.encode(signature);
-        if (!request.getA().equals(signature58)) {
-            return;
-        }
+        try {
+            List<PeerMessage> messagesToProcess;
+            synchronized (arbitraryDataFileListMessageLock) {
+                messagesToProcess = new ArrayList<>(arbitraryDataFileListMessageList);
+                arbitraryDataFileListMessageList.clear();
+            }
 
-        List<byte[]> hashes = arbitraryDataFileListMessage.getHashes();
-        if (hashes == null || hashes.isEmpty()) {
-            return;
-        }
+            if (messagesToProcess.isEmpty()) return;
 
-        ArbitraryTransactionData arbitraryTransactionData = null;
+            Map<String, PeerMessage> peerMessageBySignature58 = new HashMap<>(messagesToProcess.size());
+            Map<String, byte[]> signatureBySignature58 = new HashMap<>(messagesToProcess.size());
+            Map<String, Boolean> isRelayRequestBySignature58 = new HashMap<>(messagesToProcess.size());
+            Map<String, List<byte[]>> hashesBySignature58 = new HashMap<>(messagesToProcess.size());
+            Map<String, Triple<String, Peer, Long>> requestBySignature58 = new HashMap<>(messagesToProcess.size());
 
-        // Check transaction exists and hashes are correct
-        try (final Repository repository = RepositoryManager.getRepository()) {
-            TransactionData transactionData = repository.getTransactionRepository().fromSignature(signature);
-            if (!(transactionData instanceof ArbitraryTransactionData))
+            for (PeerMessage peerMessage : messagesToProcess) {
+                Peer peer = peerMessage.getPeer();
+                Message message = peerMessage.getMessage();
+
+                ArbitraryDataFileListMessage arbitraryDataFileListMessage = (ArbitraryDataFileListMessage) message;
+                LOGGER.debug("Received hash list from peer {} with {} hashes", peer, arbitraryDataFileListMessage.getHashes().size());
+
+                if (LOGGER.isDebugEnabled() && arbitraryDataFileListMessage.getRequestTime() != null) {
+                    long totalRequestTime = NTP.getTime() - arbitraryDataFileListMessage.getRequestTime();
+                    LOGGER.debug("totalRequestTime: {}, requestHops: {}, peerAddress: {}, isRelayPossible: {}",
+                            totalRequestTime, arbitraryDataFileListMessage.getRequestHops(),
+                            arbitraryDataFileListMessage.getPeerAddress(), arbitraryDataFileListMessage.isRelayPossible());
+                }
+
+                // Do we have a pending request for this data?
+                Triple<String, Peer, Long> request = arbitraryDataFileListRequests.get(message.getId());
+                if (request == null || request.getA() == null) {
+                    continue;
+                }
+                boolean isRelayRequest = (request.getB() != null);
+
+                // Does this message's signature match what we're expecting?
+                byte[] signature = arbitraryDataFileListMessage.getSignature();
+                String signature58 = Base58.encode(signature);
+                if (!request.getA().equals(signature58)) {
+                    continue;
+                }
+
+                List<byte[]> hashes = arbitraryDataFileListMessage.getHashes();
+                if (hashes == null || hashes.isEmpty()) {
+                    continue;
+                }
+
+                peerMessageBySignature58.put(signature58, peerMessage);
+                signatureBySignature58.put(signature58, signature);
+                isRelayRequestBySignature58.put(signature58, isRelayRequest);
+                hashesBySignature58.put(signature58, hashes);
+                requestBySignature58.put(signature58, request);
+            }
+
+            if (signatureBySignature58.isEmpty()) return;
+
+            List<ArbitraryTransactionData> arbitraryTransactionDataList;
+
+            // Check transaction exists and hashes are correct
+            try (final Repository repository = RepositoryManager.getRepository()) {
+                arbitraryTransactionDataList
+                        = repository.getTransactionRepository()
+                        .fromSignatures(new ArrayList<>(signatureBySignature58.values())).stream()
+                        .filter(data -> data instanceof ArbitraryTransactionData)
+                        .map(data -> (ArbitraryTransactionData) data)
+                        .collect(Collectors.toList());
+            } catch (DataException e) {
+                LOGGER.error(String.format("Repository issue while finding arbitrary transaction data list"), e);
                 return;
+            }
 
-            arbitraryTransactionData = (ArbitraryTransactionData) transactionData;
+            for (ArbitraryTransactionData arbitraryTransactionData : arbitraryTransactionDataList) {
 
-//          // Load data file(s)
-//          ArbitraryDataFile arbitraryDataFile = ArbitraryDataFile.fromTransactionData(arbitraryTransactionData);
-//
-//			// Check all hashes exist
-//			for (byte[] hash : hashes) {
-//				//LOGGER.debug("Received hash {}", Base58.encode(hash));
-//				if (!arbitraryDataFile.containsChunk(hash)) {
-//					// Check the hash against the complete file
-//					if (!Arrays.equals(arbitraryDataFile.getHash(), hash)) {
-//						LOGGER.info("Received non-matching chunk hash {} for signature {}. This could happen if we haven't obtained the metadata file yet.", Base58.encode(hash), signature58);
-//						return;
-//					}
-//				}
-//			}
+                byte[] signature = arbitraryTransactionData.getSignature();
+                String signature58 = Base58.encode(signature);
 
-            if (!isRelayRequest || !Settings.getInstance().isRelayModeEnabled()) {
-                Long now = NTP.getTime();
+                List<byte[]> hashes = hashesBySignature58.get(signature58);
+
+                PeerMessage peerMessage = peerMessageBySignature58.get(signature58);
+                Peer peer = peerMessage.getPeer();
+                Message message = peerMessage.getMessage();
+
+                ArbitraryDataFileListMessage arbitraryDataFileListMessage = (ArbitraryDataFileListMessage) message;
+
+                Boolean isRelayRequest = isRelayRequestBySignature58.get(signature58);
+                if (!isRelayRequest || !Settings.getInstance().isRelayModeEnabled()) {
+                    Long now = NTP.getTime();
 
-                if (ArbitraryDataFileManager.getInstance().arbitraryDataFileHashResponses.size() < MAX_FILE_HASH_RESPONSES) {
                     // Keep track of the hashes this peer reports to have access to
                     for (byte[] hash : hashes) {
                         String hash58 = Base58.encode(hash);
@@ -487,233 +539,300 @@ public class ArbitraryDataFileListManager {
                         ArbitraryFileListResponseInfo responseInfo = new ArbitraryFileListResponseInfo(hash58, signature58,
                                 peer, now, arbitraryDataFileListMessage.getRequestTime(), requestHops);
 
-                        ArbitraryDataFileManager.getInstance().arbitraryDataFileHashResponses.add(responseInfo);
+                        ArbitraryDataFileManager.getInstance().addResponse(responseInfo);
+                    }
+
+                    // Keep track of the source peer, for direct connections
+                    if (arbitraryDataFileListMessage.getPeerAddress() != null) {
+                        ArbitraryDataFileManager.getInstance().addDirectConnectionInfoIfUnique(
+                                new ArbitraryDirectConnectionInfo(signature, arbitraryDataFileListMessage.getPeerAddress(), hashes, now));
                     }
                 }
 
-                // Keep track of the source peer, for direct connections
-                if (arbitraryDataFileListMessage.getPeerAddress() != null) {
-                    ArbitraryDataFileManager.getInstance().addDirectConnectionInfoIfUnique(
-                            new ArbitraryDirectConnectionInfo(signature, arbitraryDataFileListMessage.getPeerAddress(), hashes, now));
-                }
-            }
+                // Forwarding
+                if (isRelayRequest && Settings.getInstance().isRelayModeEnabled()) {
 
-        } catch (DataException e) {
-            LOGGER.error(String.format("Repository issue while finding arbitrary transaction data list for peer %s", peer), e);
-        }
+                    boolean isBlocked = (arbitraryTransactionData == null || ListUtils.isNameBlocked(arbitraryTransactionData.getName()));
+                    if (!isBlocked) {
+                        Triple<String, Peer, Long> request = requestBySignature58.get(signature58);
+                        Peer requestingPeer = request.getB();
+                        if (requestingPeer != null) {
+                            Long requestTime = arbitraryDataFileListMessage.getRequestTime();
+                            Integer requestHops = arbitraryDataFileListMessage.getRequestHops();
 
-        // Forwarding
-        if (isRelayRequest && Settings.getInstance().isRelayModeEnabled()) {
-            boolean isBlocked = (arbitraryTransactionData == null || ListUtils.isNameBlocked(arbitraryTransactionData.getName()));
-            if (!isBlocked) {
-                Peer requestingPeer = request.getB();
-                if (requestingPeer != null) {
-                    Long requestTime = arbitraryDataFileListMessage.getRequestTime();
-                    Integer requestHops = arbitraryDataFileListMessage.getRequestHops();
+                            // Add each hash to our local mapping so we know who to ask later
+                            Long now = NTP.getTime();
+                            for (byte[] hash : hashes) {
+                                String hash58 = Base58.encode(hash);
+                                ArbitraryRelayInfo relayInfo = new ArbitraryRelayInfo(hash58, signature58, peer, now, requestTime, requestHops);
+                                ArbitraryDataFileManager.getInstance().addToRelayMap(relayInfo);
+                            }
 
-                    // Add each hash to our local mapping so we know who to ask later
-                    Long now = NTP.getTime();
-                    for (byte[] hash : hashes) {
-                        String hash58 = Base58.encode(hash);
-                        ArbitraryRelayInfo relayInfo = new ArbitraryRelayInfo(hash58, signature58, peer, now, requestTime, requestHops);
-                        ArbitraryDataFileManager.getInstance().addToRelayMap(relayInfo);
-                    }
+                            // Bump requestHops if it exists
+                            if (requestHops != null) {
+                                requestHops++;
+                            }
 
-                    // Bump requestHops if it exists
-                    if (requestHops != null) {
-                        requestHops++;
-                    }
+                            ArbitraryDataFileListMessage forwardArbitraryDataFileListMessage;
 
-                    ArbitraryDataFileListMessage forwardArbitraryDataFileListMessage;
+                            // Remove optional parameters if the requesting peer doesn't support it yet
+                            // A message with less statistical data is better than no message at all
+                            if (!requestingPeer.isAtLeastVersion(MIN_PEER_VERSION_FOR_FILE_LIST_STATS)) {
+                                forwardArbitraryDataFileListMessage = new ArbitraryDataFileListMessage(signature, hashes);
+                            } else {
+                                forwardArbitraryDataFileListMessage = new ArbitraryDataFileListMessage(signature, hashes, requestTime, requestHops,
+                                        arbitraryDataFileListMessage.getPeerAddress(), arbitraryDataFileListMessage.isRelayPossible());
+                            }
+                            forwardArbitraryDataFileListMessage.setId(message.getId());
 
-                    // Remove optional parameters if the requesting peer doesn't support it yet
-                    // A message with less statistical data is better than no message at all
-                    if (!requestingPeer.isAtLeastVersion(MIN_PEER_VERSION_FOR_FILE_LIST_STATS)) {
-                        forwardArbitraryDataFileListMessage = new ArbitraryDataFileListMessage(signature, hashes);
-                    } else {
-                        forwardArbitraryDataFileListMessage = new ArbitraryDataFileListMessage(signature, hashes, requestTime, requestHops,
-                                arbitraryDataFileListMessage.getPeerAddress(), arbitraryDataFileListMessage.isRelayPossible());
-                    }
-                    forwardArbitraryDataFileListMessage.setId(message.getId());
-
-                    // Forward to requesting peer
-                    LOGGER.debug("Forwarding file list with {} hashes to requesting peer: {}", hashes.size(), requestingPeer);
-                    if (!requestingPeer.sendMessage(forwardArbitraryDataFileListMessage)) {
-                        requestingPeer.disconnect("failed to forward arbitrary data file list");
+                            // Forward to requesting peer
+                            LOGGER.debug("Forwarding file list with {} hashes to requesting peer: {}", hashes.size(), requestingPeer);
+                            requestingPeer.sendMessage(forwardArbitraryDataFileListMessage);
+                        }
                     }
                 }
             }
+        } catch (Exception e) {
+            LOGGER.error(e.getMessage(), e);
         }
     }
 
+    // List to collect messages
+    private final List<PeerMessage> getArbitraryDataFileListMessageList = new ArrayList<>();
+    // Lock to synchronize access to the list
+    private final Object getArbitraryDataFileListMessageLock = new Object();
+
+    // Scheduled executor service to process messages every second
+    private final ScheduledExecutorService getArbitraryDataFileListMessageScheduler = Executors.newScheduledThreadPool(1);
+
     public void onNetworkGetArbitraryDataFileListMessage(Peer peer, Message message) {
         // Don't respond if QDN is disabled
         if (!Settings.getInstance().isQdnEnabled()) {
             return;
         }
 
-        Controller.getInstance().stats.getArbitraryDataFileListMessageStats.requests.incrementAndGet();
-
-        GetArbitraryDataFileListMessage getArbitraryDataFileListMessage = (GetArbitraryDataFileListMessage) message;
-        byte[] signature = getArbitraryDataFileListMessage.getSignature();
-        String signature58 = Base58.encode(signature);
-        Long now = NTP.getTime();
-        Triple<String, Peer, Long> newEntry = new Triple<>(signature58, peer, now);
-
-        // If we've seen this request recently, then ignore
-        if (arbitraryDataFileListRequests.putIfAbsent(message.getId(), newEntry) != null) {
-            LOGGER.trace("Ignoring hash list request from peer {} for signature {}", peer, signature58);
-            return;
+        synchronized (getArbitraryDataFileListMessageLock) {
+            getArbitraryDataFileListMessageList.add(new PeerMessage(peer, message));
         }
+    }
 
-        List<byte[]> requestedHashes = getArbitraryDataFileListMessage.getHashes();
-        int hashCount = requestedHashes != null ? requestedHashes.size() : 0;
-        String requestingPeer = getArbitraryDataFileListMessage.getRequestingPeer();
+    private void processNetworkGetArbitraryDataFileListMessage() {
 
-        if (requestingPeer != null) {
-            LOGGER.debug("Received hash list request with {} hashes from peer {} (requesting peer {}) for signature {}", hashCount, peer, requestingPeer, signature58);
-        }
-        else {
-            LOGGER.debug("Received hash list request with {} hashes from peer {} for signature {}", hashCount, peer, signature58);
-        }
+        try {
+            List<PeerMessage> messagesToProcess;
+            synchronized (getArbitraryDataFileListMessageLock) {
+                messagesToProcess = new ArrayList<>(getArbitraryDataFileListMessageList);
+                getArbitraryDataFileListMessageList.clear();
+            }
 
-        List<byte[]> hashes = new ArrayList<>();
-        ArbitraryTransactionData transactionData = null;
-        boolean allChunksExist = false;
-        boolean hasMetadata = false;
+            if (messagesToProcess.isEmpty()) return;
 
-        try (final Repository repository = RepositoryManager.getRepository()) {
+            Map<String, byte[]> signatureBySignature58 = new HashMap<>(messagesToProcess.size());
+            Map<String, List<byte[]>> requestedHashesBySignature58 = new HashMap<>(messagesToProcess.size());
+            Map<String, String> requestingPeerBySignature58 = new HashMap<>(messagesToProcess.size());
+            Map<String, Long> nowBySignature58 = new HashMap<>((messagesToProcess.size()));
+            Map<String, PeerMessage> peerMessageBySignature58 = new HashMap<>(messagesToProcess.size());
 
-            // Firstly we need to lookup this file on chain to get a list of its hashes
-            transactionData = (ArbitraryTransactionData)repository.getTransactionRepository().fromSignature(signature);
-            if (transactionData instanceof ArbitraryTransactionData) {
+            for (PeerMessage messagePeer : messagesToProcess) {
+                Controller.getInstance().stats.getArbitraryDataFileListMessageStats.requests.incrementAndGet();
+
+                Message message = messagePeer.message;
+                Peer peer = messagePeer.peer;
+
+                GetArbitraryDataFileListMessage getArbitraryDataFileListMessage = (GetArbitraryDataFileListMessage) message;
+                byte[] signature = getArbitraryDataFileListMessage.getSignature();
+                String signature58 = Base58.encode(signature);
+                Long now = NTP.getTime();
+                Triple<String, Peer, Long> newEntry = new Triple<>(signature58, peer, now);
+
+                // If we've seen this request recently, then ignore
+                if (arbitraryDataFileListRequests.putIfAbsent(message.getId(), newEntry) != null) {
+                    LOGGER.trace("Ignoring hash list request from peer {} for signature {}", peer, signature58);
+                    continue;
+                }
+
+                List<byte[]> requestedHashes = getArbitraryDataFileListMessage.getHashes();
+                int hashCount = requestedHashes != null ? requestedHashes.size() : 0;
+                String requestingPeer = getArbitraryDataFileListMessage.getRequestingPeer();
+
+                if (requestingPeer != null) {
+                    LOGGER.debug("Received hash list request with {} hashes from peer {} (requesting peer {}) for signature {}", hashCount, peer, requestingPeer, signature58);
+                } else {
+                    LOGGER.debug("Received hash list request with {} hashes from peer {} for signature {}", hashCount, peer, signature58);
+                }
+
+                signatureBySignature58.put(signature58, signature);
+                requestedHashesBySignature58.put(signature58, requestedHashes);
+                requestingPeerBySignature58.put(signature58, requestingPeer);
+                nowBySignature58.put(signature58, now);
+                peerMessageBySignature58.put(signature58, messagePeer);
+            }
+
+            if (signatureBySignature58.isEmpty()) {
+                return;
+            }
+
+            List<byte[]> hashes = new ArrayList<>();
+            boolean allChunksExist = false;
+            boolean hasMetadata = false;
+
+            List<ArbitraryTransactionData> transactionDataList;
+            try (final Repository repository = RepositoryManager.getRepository()) {
+
+                // Firstly we need to lookup this file on chain to get a list of its hashes
+                transactionDataList
+                        = repository.getTransactionRepository()
+                        .fromSignatures(new ArrayList<>(signatureBySignature58.values())).stream()
+                        .filter(data -> data instanceof ArbitraryTransactionData)
+                        .map(data -> (ArbitraryTransactionData) data)
+                        .collect(Collectors.toList());
+
+            } catch (DataException e) {
+                LOGGER.error(String.format("Repository issue while fetching arbitrary file list for peer"), e);
+                return;
+            }
+
+            for (ArbitraryTransactionData transactionData : transactionDataList) {
+                byte[] signature = transactionData.getSignature();
+                String signature58 = Base58.encode(signature);
+                List<byte[]> requestedHashes = requestedHashesBySignature58.get(signature58);
 
                 // Check if we're even allowed to serve data for this transaction
                 if (ArbitraryDataStorageManager.getInstance().canStoreData(transactionData)) {
 
-                    // Load file(s) and add any that exist to the list of hashes
-                    ArbitraryDataFile arbitraryDataFile = ArbitraryDataFile.fromTransactionData(transactionData);
+                    try {
+                        // Load file(s) and add any that exist to the list of hashes
+                        ArbitraryDataFile arbitraryDataFile = ArbitraryDataFile.fromTransactionData(transactionData);
 
-                    // If the peer didn't supply a hash list, we need to return all hashes for this transaction
-                    if (requestedHashes == null || requestedHashes.isEmpty()) {
-                        requestedHashes = new ArrayList<>();
+                        // If the peer didn't supply a hash list, we need to return all hashes for this transaction
+                        if (requestedHashes == null || requestedHashes.isEmpty()) {
+                            requestedHashes = new ArrayList<>();
 
-                        // Add the metadata file
-                        if (arbitraryDataFile.getMetadataHash() != null) {
-                            requestedHashes.add(arbitraryDataFile.getMetadataHash());
-                            hasMetadata = true;
+                            // Add the metadata file
+                            if (arbitraryDataFile.getMetadataHash() != null) {
+                                requestedHashes.add(arbitraryDataFile.getMetadataHash());
+                                hasMetadata = true;
+                            }
+
+                            // Add the chunk hashes
+                            if (!arbitraryDataFile.getChunkHashes().isEmpty()) {
+                                requestedHashes.addAll(arbitraryDataFile.getChunkHashes());
+                            }
+                            // Add complete file if there are no hashes
+                            else {
+                                requestedHashes.add(arbitraryDataFile.getHash());
+                            }
                         }
 
-                        // Add the chunk hashes
-                        if (arbitraryDataFile.getChunkHashes().size() > 0) {
-                            requestedHashes.addAll(arbitraryDataFile.getChunkHashes());
-                        }
-                        // Add complete file if there are no hashes
-                        else {
-                            requestedHashes.add(arbitraryDataFile.getHash());
+
+                        // Assume all chunks exists, unless one can't be found below
+                        allChunksExist = true;
+
+                        for (byte[] requestedHash : requestedHashes) {
+                            ArbitraryDataFileChunk chunk = ArbitraryDataFileChunk.fromHash(requestedHash, signature);
+                            if (chunk.exists()) {
+                                hashes.add(chunk.getHash());
+                                //LOGGER.trace("Added hash {}", chunk.getHash58());
+                            } else {
+                                LOGGER.trace("Couldn't add hash {} because it doesn't exist", chunk.getHash58());
+                                allChunksExist = false;
+                            }
                         }
+                    } catch (DataException e) {
+                        LOGGER.error(e.getMessage(), e);
+                    }
+                }
+
+                // If the only file we have is the metadata then we shouldn't respond. Most nodes will already have that,
+                // or can use the separate metadata protocol to fetch it. This should greatly reduce network spam.
+                if (hasMetadata && hashes.size() == 1) {
+                    hashes.clear();
+                }
+
+                PeerMessage peerMessage = peerMessageBySignature58.get(signature58);
+                Peer peer = peerMessage.getPeer();
+                Message message = peerMessage.getMessage();
+
+                Long now = nowBySignature58.get(signature58);
+
+                // We should only respond if we have at least one hash
+                String requestingPeer = requestingPeerBySignature58.get(signature58);
+                if (!hashes.isEmpty()) {
+
+                    // Firstly we should keep track of the requesting peer, to allow for potential direct connections later
+                    ArbitraryDataFileManager.getInstance().addRecentDataRequest(requestingPeer);
+
+                    // We have all the chunks, so update requests map to reflect that we've sent it
+                    // There is no need to keep track of the request, as we can serve all the chunks
+                    if (allChunksExist) {
+                        Triple<String, Peer, Long> newEntry = new Triple<>(null, null, now);
+                        arbitraryDataFileListRequests.put(message.getId(), newEntry);
                     }
 
-                    // Assume all chunks exists, unless one can't be found below
-                    allChunksExist = true;
+                    String ourAddress = Network.getInstance().getOurExternalIpAddressAndPort();
+                    ArbitraryDataFileListMessage arbitraryDataFileListMessage;
+
+                    // Remove optional parameters if the requesting peer doesn't support it yet
+                    // A message with less statistical data is better than no message at all
+                    if (!peer.isAtLeastVersion(MIN_PEER_VERSION_FOR_FILE_LIST_STATS)) {
+                        arbitraryDataFileListMessage = new ArbitraryDataFileListMessage(signature, hashes);
+                    } else {
+                        arbitraryDataFileListMessage = new ArbitraryDataFileListMessage(signature,
+                                hashes, NTP.getTime(), 0, ourAddress, true);
+                    }
+
+                    arbitraryDataFileListMessage.setId(message.getId());
+
+                    if (!peer.sendMessage(arbitraryDataFileListMessage)) {
+                        LOGGER.debug("Couldn't send list of hashes");
+                        continue;
+                    }
+
+                    if (allChunksExist) {
+                        // Nothing left to do, so return to prevent any unnecessary forwarding from occurring
+                        LOGGER.debug("No need for any forwarding because file list request is fully served");
+                        continue;
+                    }
+
+                }
+
+                // We may need to forward this request on
+                boolean isBlocked = (transactionData == null || ListUtils.isNameBlocked(transactionData.getName()));
+                if (Settings.getInstance().isRelayModeEnabled() && !isBlocked) {
+                    // In relay mode - so ask our other peers if they have it
+
+
+                    GetArbitraryDataFileListMessage getArbitraryDataFileListMessage = (GetArbitraryDataFileListMessage) message;
+
+                    long requestTime = getArbitraryDataFileListMessage.getRequestTime();
+                    int requestHops = getArbitraryDataFileListMessage.getRequestHops() + 1;
+                    long totalRequestTime = now - requestTime;
+
+                    if (totalRequestTime < RELAY_REQUEST_MAX_DURATION) {
+                        // Relay request hasn't timed out yet, so can potentially be rebroadcast
+                        if (requestHops < RELAY_REQUEST_MAX_HOPS) {
+                            // Relay request hasn't reached the maximum number of hops yet, so can be rebroadcast
+
+                            Message relayGetArbitraryDataFileListMessage = new GetArbitraryDataFileListMessage(signature, hashes, requestTime, requestHops, requestingPeer);
+                            relayGetArbitraryDataFileListMessage.setId(message.getId());
+
+                            LOGGER.debug("Rebroadcasting hash list request from peer {} for signature {} to our other peers... totalRequestTime: {}, requestHops: {}", peer, Base58.encode(signature), totalRequestTime, requestHops);
+                            Network.getInstance().broadcast(
+                                    broadcastPeer ->
+                                            !broadcastPeer.isAtLeastVersion(RELAY_MIN_PEER_VERSION) ? null :
+                                                    broadcastPeer == peer || Objects.equals(broadcastPeer.getPeerData().getAddress().getHost(), peer.getPeerData().getAddress().getHost()) ? null : relayGetArbitraryDataFileListMessage
+                            );
 
-                    for (byte[] requestedHash : requestedHashes) {
-                        ArbitraryDataFileChunk chunk = ArbitraryDataFileChunk.fromHash(requestedHash, signature);
-                        if (chunk.exists()) {
-                            hashes.add(chunk.getHash());
-                            //LOGGER.trace("Added hash {}", chunk.getHash58());
                         } else {
-                            LOGGER.trace("Couldn't add hash {} because it doesn't exist", chunk.getHash58());
-                            allChunksExist = false;
+                            // This relay request has reached the maximum number of allowed hops
                         }
+                    } else {
+                        // This relay request has timed out
                     }
                 }
             }
-
-        } catch (DataException e) {
-            LOGGER.error(String.format("Repository issue while fetching arbitrary file list for peer %s", peer), e);
-        }
-
-        // If the only file we have is the metadata then we shouldn't respond. Most nodes will already have that,
-        // or can use the separate metadata protocol to fetch it. This should greatly reduce network spam.
-        if (hasMetadata && hashes.size() == 1) {
-            hashes.clear();
-        }
-
-        // We should only respond if we have at least one hash
-        if (hashes.size() > 0) {
-
-            // Firstly we should keep track of the requesting peer, to allow for potential direct connections later
-            ArbitraryDataFileManager.getInstance().addRecentDataRequest(requestingPeer);
-
-            // We have all the chunks, so update requests map to reflect that we've sent it
-            // There is no need to keep track of the request, as we can serve all the chunks
-            if (allChunksExist) {
-                newEntry = new Triple<>(null, null, now);
-                arbitraryDataFileListRequests.put(message.getId(), newEntry);
-            }
-
-            String ourAddress = Network.getInstance().getOurExternalIpAddressAndPort();
-            ArbitraryDataFileListMessage arbitraryDataFileListMessage;
-
-            // Remove optional parameters if the requesting peer doesn't support it yet
-            // A message with less statistical data is better than no message at all
-            if (!peer.isAtLeastVersion(MIN_PEER_VERSION_FOR_FILE_LIST_STATS)) {
-                arbitraryDataFileListMessage = new ArbitraryDataFileListMessage(signature, hashes);
-            } else {
-                arbitraryDataFileListMessage = new ArbitraryDataFileListMessage(signature,
-                        hashes, NTP.getTime(), 0, ourAddress, true);
-            }
-
-            arbitraryDataFileListMessage.setId(message.getId());
-
-            if (!peer.sendMessage(arbitraryDataFileListMessage)) {
-                LOGGER.debug("Couldn't send list of hashes");
-                peer.disconnect("failed to send list of hashes");
-                return;
-            }
-            LOGGER.debug("Sent list of hashes (count: {})", hashes.size());
-
-            if (allChunksExist) {
-                // Nothing left to do, so return to prevent any unnecessary forwarding from occurring
-                LOGGER.debug("No need for any forwarding because file list request is fully served");
-                return;
-            }
-
-        }
-
-        // We may need to forward this request on
-        boolean isBlocked = (transactionData == null || ListUtils.isNameBlocked(transactionData.getName()));
-        if (Settings.getInstance().isRelayModeEnabled() && !isBlocked) {
-            // In relay mode - so ask our other peers if they have it
-
-            long requestTime = getArbitraryDataFileListMessage.getRequestTime();
-            int requestHops = getArbitraryDataFileListMessage.getRequestHops() + 1;
-            long totalRequestTime = now - requestTime;
-
-            if (totalRequestTime < RELAY_REQUEST_MAX_DURATION) {
-                // Relay request hasn't timed out yet, so can potentially be rebroadcast
-                if (requestHops < RELAY_REQUEST_MAX_HOPS) {
-                    // Relay request hasn't reached the maximum number of hops yet, so can be rebroadcast
-
-                    Message relayGetArbitraryDataFileListMessage = new GetArbitraryDataFileListMessage(signature, hashes, requestTime, requestHops, requestingPeer);
-                    relayGetArbitraryDataFileListMessage.setId(message.getId());
-
-                    LOGGER.debug("Rebroadcasting hash list request from peer {} for signature {} to our other peers... totalRequestTime: {}, requestHops: {}", peer, Base58.encode(signature), totalRequestTime, requestHops);
-                    Network.getInstance().broadcast(
-                            broadcastPeer ->
-                                    !broadcastPeer.isAtLeastVersion(RELAY_MIN_PEER_VERSION) ? null :
-                                    broadcastPeer == peer || Objects.equals(broadcastPeer.getPeerData().getAddress().getHost(), peer.getPeerData().getAddress().getHost()) ? null : relayGetArbitraryDataFileListMessage
-                    );
-
-                }
-                else {
-                    // This relay request has reached the maximum number of allowed hops
-                }
-            }
-            else {
-                // This relay request has timed out
-            }
+        } catch (Exception e) {
+            LOGGER.error(e.getMessage(), e);
         }
     }
 

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

@@ -1,6 +1,7 @@
 package org.qortal.controller.arbitrary;
 
 import com.google.common.net.InetAddresses;
+
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.qortal.arbitrary.ArbitraryDataFile;
@@ -12,6 +13,7 @@ import org.qortal.data.network.PeerData;
 import org.qortal.data.transaction.ArbitraryTransactionData;
 import org.qortal.network.Network;
 import org.qortal.network.Peer;
+import org.qortal.network.PeerSendManagement;
 import org.qortal.network.message.*;
 import org.qortal.repository.DataException;
 import org.qortal.repository.Repository;
@@ -23,12 +25,16 @@ import org.qortal.utils.NTP;
 
 import java.security.SecureRandom;
 import java.util.*;
-import java.util.concurrent.ExecutorService;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
 import java.util.stream.Collectors;
 
 public class ArbitraryDataFileManager extends Thread {
 
+    public static final int SEND_TIMEOUT_MS = 500;
     private static final Logger LOGGER = LogManager.getLogger(ArbitraryDataFileManager.class);
 
     private static ArbitraryDataFileManager instance;
@@ -43,17 +49,17 @@ 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
      */
-    public final List<ArbitraryFileListResponseInfo> arbitraryDataFileHashResponses = Collections.synchronizedList(new ArrayList<>());
+    private final List<ArbitraryFileListResponseInfo> arbitraryDataFileHashResponses = Collections.synchronizedList(new ArrayList<>());
 
     /**
      * 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.
@@ -65,8 +71,9 @@ public class ArbitraryDataFileManager extends Thread {
 
     public static int MAX_FILE_HASH_RESPONSES = 1000;
 
-
     private ArbitraryDataFileManager() {
+        this.arbitraryDataFileHashResponseScheduler.scheduleAtFixedRate( this::processResponses, 60, 1, TimeUnit.SECONDS);
+        this.arbitraryDataFileHashResponseScheduler.scheduleAtFixedRate(this::handleFileListRequestProcess, 60, 1, TimeUnit.SECONDS);
     }
 
     public static ArbitraryDataFileManager getInstance() {
@@ -76,18 +83,13 @@ public class ArbitraryDataFileManager extends Thread {
         return instance;
     }
 
+
+
     @Override
     public void run() {
         Thread.currentThread().setName("Arbitrary Data File Manager");
 
         try {
-            // Use a fixed thread pool to execute the arbitrary data file requests
-            int threadCount = 5;
-            ExecutorService arbitraryDataFileRequestExecutor = Executors.newFixedThreadPool(threadCount);
-            for (int i = 0; i < threadCount; i++) {
-                arbitraryDataFileRequestExecutor.execute(new ArbitraryDataFileRequestThread());
-            }
-
             while (!isStopping) {
                 // Nothing to do yet
                 Thread.sleep(1000);
@@ -112,7 +114,6 @@ public class ArbitraryDataFileManager extends Thread {
 
         final long relayMinimumTimestamp = now - ArbitraryDataManager.getInstance().ARBITRARY_RELAY_TIMEOUT;
         arbitraryRelayMap.removeIf(entry -> entry == null || entry.getTimestamp() == null || entry.getTimestamp() < relayMinimumTimestamp);
-        arbitraryDataFileHashResponses.removeIf(entry -> entry.getTimestamp() < relayMinimumTimestamp);
 
         final long directConnectionInfoMinimumTimestamp = now - ArbitraryDataManager.getInstance().ARBITRARY_DIRECT_CONNECTION_INFO_TIMEOUT;
         directConnectionInfo.removeIf(entry -> entry.getTimestamp() < directConnectionInfoMinimumTimestamp);
@@ -125,8 +126,7 @@ public class ArbitraryDataFileManager extends Thread {
 
     // Fetch data files by hash
 
-    public boolean fetchArbitraryDataFiles(Repository repository,
-                                           Peer peer,
+    public boolean fetchArbitraryDataFiles(Peer peer,
                                            byte[] signature,
                                            ArbitraryTransactionData arbitraryTransactionData,
                                            List<byte[]> hashes) throws DataException {
@@ -146,21 +146,15 @@ public class ArbitraryDataFileManager extends Thread {
                 if (!arbitraryDataFileRequests.containsKey(Base58.encode(hash))) {
                     LOGGER.debug("Requesting data file {} from peer {}", hash58, peer);
                     Long startTime = NTP.getTime();
-                    ArbitraryDataFile receivedArbitraryDataFile = fetchArbitraryDataFile(peer, null, arbitraryTransactionData, signature, hash, null);
+                    ArbitraryDataFile receivedArbitraryDataFile = fetchArbitraryDataFile(peer, arbitraryTransactionData, signature, hash);
                     Long endTime = NTP.getTime();
                     if (receivedArbitraryDataFile != null) {
                         LOGGER.debug("Received data file {} from peer {}. Time taken: {} ms", receivedArbitraryDataFile.getHash58(), peer, (endTime-startTime));
                         receivedAtLeastOneFile = true;
-
-                        // Remove this hash from arbitraryDataFileHashResponses now that we have received it
-                        arbitraryDataFileHashResponses.remove(hash58);
                     }
                     else {
                         LOGGER.debug("Peer {} didn't respond with data file {} for signature {}. Time taken: {} ms", peer, Base58.encode(hash), Base58.encode(signature), (endTime-startTime));
 
-                        // Remove this hash from arbitraryDataFileHashResponses now that we have failed to receive it
-                        arbitraryDataFileHashResponses.remove(hash58);
-
                         // Stop asking for files from this peer
                         break;
                     }
@@ -169,10 +163,6 @@ public class ArbitraryDataFileManager extends Thread {
                     LOGGER.trace("Already requesting data file {} for signature {} from peer {}", arbitraryDataFile, Base58.encode(signature), peer);
                 }
             }
-            else {
-                // Remove this hash from arbitraryDataFileHashResponses because we have a local copy
-                arbitraryDataFileHashResponses.remove(hash58);
-            }
         }
 
         if (receivedAtLeastOneFile) {
@@ -191,14 +181,103 @@ public class ArbitraryDataFileManager extends Thread {
         return receivedAtLeastOneFile;
     }
 
-    private ArbitraryDataFile fetchArbitraryDataFile(Peer peer, Peer requestingPeer, ArbitraryTransactionData arbitraryTransactionData, byte[] signature, byte[] hash, Message originalMessage) throws DataException {
-        ArbitraryDataFile existingFile = ArbitraryDataFile.fromHash(hash, signature);
-        boolean fileAlreadyExists = existingFile.exists();
-        String hash58 = Base58.encode(hash);
+    // Lock to synchronize access to the list
+    private final Object arbitraryDataFileHashResponseLock = new Object();
+
+    // Scheduled executor service to process messages every second
+    private final ScheduledExecutorService arbitraryDataFileHashResponseScheduler = Executors.newScheduledThreadPool(1);
+
+
+    public void addResponse( ArbitraryFileListResponseInfo responseInfo ) {
+
+        synchronized (arbitraryDataFileHashResponseLock) {
+            this.arbitraryDataFileHashResponses.add(responseInfo);
+        }
+    }
+
+    private void processResponses() {
+        try {
+            List<ArbitraryFileListResponseInfo> responsesToProcess;
+            synchronized (arbitraryDataFileHashResponseLock) {
+                responsesToProcess = new ArrayList<>(arbitraryDataFileHashResponses);
+                arbitraryDataFileHashResponses.clear();
+            }
+
+            if (responsesToProcess.isEmpty()) return;
+
+            Long now = NTP.getTime();
+
+            ArbitraryDataFileRequestThread.getInstance().processFileHashes(now, responsesToProcess, this);
+        } catch (Exception e) {
+            LOGGER.error(e.getMessage(), e);
+        }
+    }
+
+    private ArbitraryDataFile fetchArbitraryDataFile(Peer peer, ArbitraryTransactionData arbitraryTransactionData, byte[] signature, byte[] hash) throws DataException {
         ArbitraryDataFile arbitraryDataFile;
 
-        // Fetch the file if it doesn't exist locally
-        if (!fileAlreadyExists) {
+        try {
+            ArbitraryDataFile existingFile = ArbitraryDataFile.fromHash(hash, signature);
+            boolean fileAlreadyExists = existingFile.exists();
+            String hash58 = Base58.encode(hash);
+
+            // Fetch the file if it doesn't exist locally
+            if (!fileAlreadyExists) {
+                LOGGER.debug(String.format("Fetching data file %.8s from peer %s", hash58, peer));
+                arbitraryDataFileRequests.put(hash58, NTP.getTime());
+                Message getArbitraryDataFileMessage = new GetArbitraryDataFileMessage(signature, hash);
+
+                Message response = null;
+                try {
+                    response = peer.getResponseWithTimeout(getArbitraryDataFileMessage, (int) ArbitraryDataManager.ARBITRARY_REQUEST_TIMEOUT);
+                } catch (InterruptedException e) {
+                    // Will return below due to null response
+                }
+                arbitraryDataFileRequests.remove(hash58);
+                LOGGER.trace(String.format("Removed hash %.8s from arbitraryDataFileRequests", hash58));
+
+                if (response == null) {
+                    LOGGER.debug("Received null response from peer {}", peer);
+                    return null;
+                }
+                if (response.getType() != MessageType.ARBITRARY_DATA_FILE) {
+                    LOGGER.debug("Received response with invalid type: {} from peer {}", response.getType(), peer);
+                    return null;
+                }
+
+                ArbitraryDataFileMessage peersArbitraryDataFileMessage = (ArbitraryDataFileMessage) response;
+                arbitraryDataFile = peersArbitraryDataFileMessage.getArbitraryDataFile();
+            } else {
+                LOGGER.debug(String.format("File hash %s already exists, so skipping the request", hash58));
+                arbitraryDataFile = existingFile;
+            }
+
+            if (arbitraryDataFile != null) {
+
+                arbitraryDataFile.save();
+
+                // If this is a metadata file then we need to update the cache
+                if (arbitraryTransactionData != null && arbitraryTransactionData.getMetadataHash() != null) {
+                    if (Arrays.equals(arbitraryTransactionData.getMetadataHash(), hash)) {
+                        ArbitraryDataCacheManager.getInstance().addToUpdateQueue(arbitraryTransactionData);
+                    }
+                }
+
+                // We may need to remove the file list request, if we have all the files for this transaction
+                this.handleFileListRequests(signature);
+            }
+        } catch (DataException e) {
+            LOGGER.error(e.getMessage(), e);
+            arbitraryDataFile = null;
+        }
+
+        return arbitraryDataFile;
+    }
+
+    private void fetchFileForRelay(Peer peer, Peer requestingPeer, byte[] signature, byte[] hash, Message originalMessage) throws DataException {
+        try {
+            String hash58 = Base58.encode(hash);
+
             LOGGER.debug(String.format("Fetching data file %.8s from peer %s", hash58, peer));
             arbitraryDataFileRequests.put(hash58, NTP.getTime());
             Message getArbitraryDataFileMessage = new GetArbitraryDataFileMessage(signature, hash);
@@ -212,72 +291,73 @@ public class ArbitraryDataFileManager extends Thread {
             arbitraryDataFileRequests.remove(hash58);
             LOGGER.trace(String.format("Removed hash %.8s from arbitraryDataFileRequests", hash58));
 
-            // We may need to remove the file list request, if we have all the files for this transaction
-            this.handleFileListRequests(signature);
-
             if (response == null) {
                 LOGGER.debug("Received null response from peer {}", peer);
-                return null;
+                return;
             }
             if (response.getType() != MessageType.ARBITRARY_DATA_FILE) {
                 LOGGER.debug("Received response with invalid type: {} from peer {}", response.getType(), peer);
-                return null;
-            }
-
-            ArbitraryDataFileMessage peersArbitraryDataFileMessage = (ArbitraryDataFileMessage) response;
-            arbitraryDataFile = peersArbitraryDataFileMessage.getArbitraryDataFile();
-        } else {
-            LOGGER.debug(String.format("File hash %s already exists, so skipping the request", hash58));
-            arbitraryDataFile = existingFile;
-        }
-
-        if (arbitraryDataFile == null) {
-            // We don't have a file, so give up here
-            return null;
-        }
-
-        // We might want to forward the request to the peer that originally requested it
-        this.handleArbitraryDataFileForwarding(requestingPeer, new ArbitraryDataFileMessage(signature, arbitraryDataFile), originalMessage);
-
-        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
-                arbitraryDataFile.delete(10);
-            }
-        }
-
-        // If this is a metadata file then we need to update the cache
-        if (arbitraryTransactionData != null && arbitraryTransactionData.getMetadataHash() != null) {
-            if (Arrays.equals(arbitraryTransactionData.getMetadataHash(), hash)) {
-                ArbitraryDataCacheManager.getInstance().addToUpdateQueue(arbitraryTransactionData);
-            }
-        }
-
-        return arbitraryDataFile;
-    }
-
-    private void handleFileListRequests(byte[] signature) {
-        try (final Repository repository = RepositoryManager.getRepository()) {
-
-            // Fetch the transaction data
-            ArbitraryTransactionData arbitraryTransactionData = ArbitraryTransactionUtils.fetchTransactionData(repository, signature);
-            if (arbitraryTransactionData == null) {
                 return;
             }
 
-            boolean allChunksExist = ArbitraryTransactionUtils.allChunksExist(arbitraryTransactionData);
+            ArbitraryDataFileMessage peersArbitraryDataFileMessage = (ArbitraryDataFileMessage) response;
+            ArbitraryDataFile arbitraryDataFile = peersArbitraryDataFileMessage.getArbitraryDataFile();
 
-            if (allChunksExist) {
-                // Update requests map to reflect that we've received all chunks
-                ArbitraryDataFileListManager.getInstance().deleteFileListRequestsForSignature(signature);
+            if (arbitraryDataFile != null) {
+
+                // We might want to forward the request to the peer that originally requested it
+                this.handleArbitraryDataFileForwarding(requestingPeer, new ArbitraryDataFileMessage(signature, arbitraryDataFile), originalMessage);
+            }
+        } catch (Exception e) {
+            LOGGER.error(e.getMessage(), e);
+        }
+    }
+
+    Map<String, byte[]> signatureBySignature58 = new HashMap<>();
+
+    // Lock to synchronize access to the list
+    private final Object handleFileListRequestsLock = new Object();
+
+    // Scheduled executor service to process messages every second
+    private final ScheduledExecutorService handleFileListRequestsScheduler = Executors.newScheduledThreadPool(1);
+
+    private void handleFileListRequests(byte[] signature) {
+
+        synchronized (handleFileListRequestsLock) {
+            signatureBySignature58.put(Base58.encode(signature), signature);
+        }
+    }
+
+    private void handleFileListRequestProcess() {
+
+        Map<String, byte[]> signaturesToProcess;
+
+        synchronized (handleFileListRequestsLock) {
+            signaturesToProcess = new HashMap<>(signatureBySignature58);
+            signatureBySignature58.clear();
+        }
+
+        if( signaturesToProcess.isEmpty() ) return;
+
+        try (final Repository repository = RepositoryManager.getRepository()) {
+
+            // Fetch the transaction data
+            List<ArbitraryTransactionData> arbitraryTransactionDataList
+                = ArbitraryTransactionUtils.fetchTransactionDataList(repository, new ArrayList<>(signaturesToProcess.values()));
+
+            for( ArbitraryTransactionData arbitraryTransactionData : arbitraryTransactionDataList ) {
+                boolean completeFileExists = ArbitraryTransactionUtils.completeFileExists(arbitraryTransactionData);
+
+                if (completeFileExists) {
+                    String signature58 = Base58.encode(arbitraryTransactionData.getSignature());
+                    LOGGER.debug("All chunks or complete file exist for transaction {}", signature58);
+
+                    ArbitraryDataFileListManager.getInstance().deleteFileListRequestsForSignature(signature58);
+                }
             }
 
-        } catch (DataException e) {
-            LOGGER.debug("Unable to handle file list requests: {}", e.getMessage());
+        } catch (Exception e) {
+            LOGGER.error(e.getMessage(), e);
         }
     }
 
@@ -294,15 +374,14 @@ public class ArbitraryDataFileManager extends Thread {
 
         LOGGER.debug("Received arbitrary data file - forwarding is needed");
 
-        // The ID needs to match that of the original request
-        message.setId(originalMessage.getId());
+        try {
+            // The ID needs to match that of the original request
+            message.setId(originalMessage.getId());
 
-        if (!requestingPeer.sendMessageWithTimeout(message, (int) ArbitraryDataManager.ARBITRARY_REQUEST_TIMEOUT)) {
-            LOGGER.debug("Failed to forward arbitrary data file to peer {}", requestingPeer);
-            requestingPeer.disconnect("failed to forward arbitrary data file");
-        }
-        else {
-            LOGGER.debug("Forwarded arbitrary data file to peer {}", requestingPeer);
+            PeerSendManagement.getInstance().getOrCreateSendManager(requestingPeer).queueMessage(message, SEND_TIMEOUT_MS);
+
+        } catch (Exception e) {
+            LOGGER.error(e.getMessage(), e);
         }
     }
 
@@ -576,13 +655,9 @@ public class ArbitraryDataFileManager extends Thread {
                 LOGGER.debug("Sending file {}...", arbitraryDataFile);
                 ArbitraryDataFileMessage arbitraryDataFileMessage = new ArbitraryDataFileMessage(signature, arbitraryDataFile);
                 arbitraryDataFileMessage.setId(message.getId());
-                if (!peer.sendMessageWithTimeout(arbitraryDataFileMessage, (int) ArbitraryDataManager.ARBITRARY_REQUEST_TIMEOUT)) {
-                    LOGGER.debug("Couldn't send file {}", arbitraryDataFile);
-                    peer.disconnect("failed to send file");
-                }
-                else {
-                    LOGGER.debug("Sent file {}", arbitraryDataFile);
-                }
+
+                PeerSendManagement.getInstance().getOrCreateSendManager(peer).queueMessage(arbitraryDataFileMessage, SEND_TIMEOUT_MS);
+
             }
             else if (relayInfo != null) {
                 LOGGER.debug("We have relay info for hash {}", Base58.encode(hash));
@@ -594,7 +669,7 @@ public class ArbitraryDataFileManager extends Thread {
                     LOGGER.debug("Asking peer {} for hash {}", peerToAsk, hash58);
                     // No need to pass arbitraryTransactionData below because this is only used for metadata caching,
                     // and metadata isn't retained when relaying.
-                    this.fetchArbitraryDataFile(peerToAsk, peer, null, signature, hash, message);
+                    this.fetchFileForRelay(peerToAsk, peer, signature, hash, message);
                 }
                 else {
                     LOGGER.debug("Peer {} not found in relay info", peer);
@@ -616,7 +691,6 @@ public class ArbitraryDataFileManager extends Thread {
                 fileUnknownMessage.setId(message.getId());
                 if (!peer.sendMessage(fileUnknownMessage)) {
                     LOGGER.debug("Couldn't sent file-unknown response");
-                    peer.disconnect("failed to send file-unknown response");
                 }
                 else {
                     LOGGER.debug("Sent file-unknown response for file {}", arbitraryDataFile);