Bump version to 4.3.1

Reward share limit activation timestamp set to 1698508800000 (Sat Oct 28 2023 16:00:00 UTC)
Merge pull request #134 from AlphaX-Projects/master
2025-07-31 06:01:22 +00:00 · 2023-10-19 13:51:53 -04:00 · 2023-10-19 13:48:33 -04:00 · 2023-10-19 12:57:44 -04:00 · 2023-10-18 17:29:10 +02:00 · 2023-10-18 13:49:53 +02:00
128 changed files with 4374 additions and 7820 deletions
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -0,0 +1,3 @@
+{
+    "java.compile.nullAnalysis.mode": "automatic"
+}
--- a/Q-Apps.md
+++ b/Q-Apps.md
@@ -576,14 +576,15 @@ let res = await qortalRequest({
 ```

 ### Send foreign coin to address
-_Requires user approval_
+_Requires user approval_<br />
+Note: default fees can be found [here](https://github.com/Qortal/qortal-ui/blob/master/plugins/plugins/core/qdn/browser/browser.src.js#L205-L209).
 ```
 let res = await qortalRequest({
    action: "SEND_COIN",
    coin: "LTC",
    destinationAddress: "LSdTvMHRm8sScqwCi6x9wzYQae8JeZhx6y",
    amount: 1.00000000, // 1 LTC
-    fee: 0.00000020 // fee per byte
+    fee: 0.00000020 // Optional fee per byte (default fee used if omitted, recommended) - not used for QORT or ARRR
 });
 ```

--- a/WindowsInstaller/Install
+++ b/WindowsInstaller/Install
@@ -1,7 +1,7 @@
 rootLogger.level = info
 # On Windows, uncomment next line to set dirname:
 # property.dirname = ${sys:user.home}\\AppData\\Local\\qortal\\
-property.filename = ${sys:log4j2.filenameTemplate:-log.txt}
+# property.filename = ${sys:log4j2.filenameTemplate:-log.txt}

 rootLogger.appenderRef.console.ref = stdout
 rootLogger.appenderRef.rolling.ref = FILE
@@ -59,11 +59,14 @@ appender.console.filter.threshold.level = error

 appender.rolling.type = RollingFile
 appender.rolling.name = FILE
+appender.rolling.fileName = qortal.log
+appender.rolling.filePattern = qortal.%d{dd-MMM}.log.gz
 appender.rolling.layout.type = PatternLayout
 appender.rolling.layout.pattern = %d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n
-appender.rolling.filePattern = ./${filename}.%i
 appender.rolling.policy.type = SizeBasedTriggeringPolicy
-appender.rolling.policy.size = 4MB
+appender.rolling.policy.size = 10MB
+appender.rolling.strategy.type = DefaultRolloverStrategy
+appender.rolling.strategy.max = 7
 # Set the immediate flush to true (default)
 # appender.rolling.immediateFlush = true
 # Set the append to true (default), should not overwrite
--- a/lib/org/ciyam/AT/1.4.1/AT-1.4.1.jar
+++ b/lib/org/ciyam/AT/1.4.1/AT-1.4.1.jar
--- a/lib/org/ciyam/AT/1.4.1/AT-1.4.1.pom
+++ b/lib/org/ciyam/AT/1.4.1/AT-1.4.1.pom
@@ -0,0 +1,124 @@
+<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>
+
+		<maven-compiler-plugin.version>3.8.1</maven-compiler-plugin.version>
+		<maven-source-plugin.version>3.2.0</maven-source-plugin.version>
+		<maven-javadoc-plugin.version>3.3.1</maven-javadoc-plugin.version>
+		<maven-surefire-plugin.version>3.0.0-M4</maven-surefire-plugin.version>
+		<maven-jar-plugin.version>3.2.0</maven-jar-plugin.version>
+
+		<bouncycastle.version>1.64</bouncycastle.version>
+	</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>4.13</version>
+			<scope>test</scope>
+		</dependency>
+	</dependencies>
+</project>
--- a/lib/org/ciyam/AT/maven-metadata-local.xml
+++ b/lib/org/ciyam/AT/maven-metadata-local.xml
@@ -3,7 +3,7 @@
  <groupId>org.ciyam</groupId>
  <artifactId>AT</artifactId>
  <versioning>
-    <release>1.4.0</release>
+    <release>1.4.1</release>
    <versions>
      <version>1.3.4</version>
      <version>1.3.5</version>
@@ -11,7 +11,8 @@
      <version>1.3.7</version>
      <version>1.3.8</version>
      <version>1.4.0</version>
+      <version>1.4.1</version>
    </versions>
-    <lastUpdated>20221105114346</lastUpdated>
+    <lastUpdated>20230821074325</lastUpdated>
  </versioning>
 </metadata>
--- a/log4j2.properties
+++ b/log4j2.properties
@@ -1,7 +1,7 @@
 rootLogger.level = info
 # On Windows, uncomment next line to set dirname:
 # property.dirname = ${sys:user.home}\\AppData\\Local\\qortal\\
-property.filename = ${sys:log4j2.filenameTemplate:-log.txt}
+# property.filename = ${sys:log4j2.filenameTemplate:-log.txt}

 rootLogger.appenderRef.console.ref = stdout
 rootLogger.appenderRef.rolling.ref = FILE
@@ -59,11 +59,14 @@ appender.console.filter.threshold.level = error

 appender.rolling.type = RollingFile
 appender.rolling.name = FILE
+appender.rolling.fileName = qortal.log
+appender.rolling.filePattern = qortal.%d{dd-MMM}.log.gz
 appender.rolling.layout.type = PatternLayout
 appender.rolling.layout.pattern = %d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n
-appender.rolling.filePattern = ./${filename}.%i
 appender.rolling.policy.type = SizeBasedTriggeringPolicy
-appender.rolling.policy.size = 4MB
+appender.rolling.policy.size = 10MB
+appender.rolling.strategy.type = DefaultRolloverStrategy
+appender.rolling.strategy.max = 7
 # Set the immediate flush to true (default)
 # appender.rolling.immediateFlush = true
 # Set the append to true (default), should not overwrite
--- a/pom.xml
+++ b/pom.xml
@@ -3,7 +3,7 @@
 	<modelVersion>4.0.0</modelVersion>
 	<groupId>org.qortal</groupId>
 	<artifactId>qortal</artifactId>
-	<version>4.1.0</version>
+	<version>4.3.1</version>
 	<packaging>jar</packaging>
 	<properties>
 		<skipTests>true</skipTests>
@@ -11,32 +11,52 @@
 		<bitcoinj.version>0.15.10</bitcoinj.version>
 		<bouncycastle.version>1.69</bouncycastle.version>
 		<build.timestamp>${maven.build.timestamp}</build.timestamp>
-		<ciyam-at.version>1.4.0</ciyam-at.version>
-		<commons-net.version>3.6</commons-net.version>
-		<commons-text.version>1.8</commons-text.version>
-		<commons-io.version>2.6</commons-io.version>
-		<commons-compress.version>1.21</commons-compress.version>
-		<commons-lang3.version>3.12.0</commons-lang3.version>
+		<ciyam-at.version>1.4.1</ciyam-at.version>
+		<commons-net.version>3.8.0</commons-net.version>
+		<commons-text.version>1.10.0</commons-text.version>
+		<commons-io.version>2.11.0</commons-io.version>
+		<commons-compress.version>1.24.0</commons-compress.version>
+		<commons-lang3.version>3.13.0</commons-lang3.version>
 		<xz.version>1.9</xz.version>
 		<dagger.version>1.2.2</dagger.version>
-		<guava.version>28.1-jre</guava.version>
+		<guava.version>32.1.3-jre</guava.version>
 		<hsqldb.version>2.5.1</hsqldb.version>
 		<homoglyph.version>1.2.1</homoglyph.version>
-		<icu4j.version>70.1</icu4j.version>
+		<icu4j.version>73.2</icu4j.version>
 		<upnp.version>1.1</upnp.version>
-		<jersey.version>2.29.1</jersey.version>
-		<jetty.version>9.4.29.v20200521</jetty.version>
-		<log4j.version>2.17.1</log4j.version>
+		<jaxb-runtime.version>2.3.3</jaxb-runtime.version>
+		<jersey.version>2.40</jersey.version>
+		<jetty.version>9.4.53.v20231009</jetty.version>
+		<log4j.version>2.20.0</log4j.version>
 		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-		<slf4j.version>1.7.12</slf4j.version>
-		<swagger-api.version>2.0.9</swagger-api.version>
-		<swagger-ui.version>3.23.8</swagger-ui.version>
+		<slf4j.version>1.7.36</slf4j.version>
+		<swagger-api.version>2.0.10</swagger-api.version>
+		<swagger-ui.version>3.52.5</swagger-ui.version>
 		<package-info-maven-plugin.version>1.1.0</package-info-maven-plugin.version>
-		<jsoup.version>1.13.1</jsoup.version>
-		<java-diff-utils.version>4.10</java-diff-utils.version>
-		<grpc.version>1.45.1</grpc.version>
-		<protobuf.version>3.19.4</protobuf.version>
+		<jsoup.version>1.16.1</jsoup.version>
+		<java-diff-utils.version>4.12</java-diff-utils.version>
+		<grpc.version>1.58.0</grpc.version>
+		<protobuf.version>3.24.4</protobuf.version>
 		<simplemagic.version>1.17</simplemagic.version>
+		<versions-maven-plugin.version>2.16.1</versions-maven-plugin.version>
+		<maven-compiler-plugin.version>3.11.0</maven-compiler-plugin.version>
+		<git-commit-id-plugin.version>4.9.10</git-commit-id-plugin.version>
+		<replacer.version>1.5.3</replacer.version>
+		<maven-resources-plugin.version>3.3.1</maven-resources-plugin.version>
+		<build-helper-maven-plugin.version>3.4.0</build-helper-maven-plugin.version>
+		<maven-jar-plugin.version>3.3.0</maven-jar-plugin.version>
+		<maven-shade-plugin.version>3.5.1</maven-shade-plugin.version>
+		<reproducible-build-maven-plugin.version>0.16</reproducible-build-maven-plugin.version>
+		<maven-surefire-plugin.version>3.1.2</maven-surefire-plugin.version>
+		<lifecycle-mapping.version>1.0.0</lifecycle-mapping.version>
+		<build-helper-maven-plugin.version>3.4.0</build-helper-maven-plugin.version>
+		<json-simple.version>1.1.1</json-simple.version>
+		<json.version>20231013</json.version>
+		<extendedset.version>0.12.3</extendedset.version>
+		<javax.servlet-api.version>4.0.1</javax.servlet-api.version>
+		<mail.version>1.5.0-b01</mail.version>
+		<junit-jupiter-engine.version>5.3.1</junit-jupiter-engine.version>
+		<hamcrest-library.version>1.3</hamcrest-library.version>
 	</properties>
 	<build>
 		<sourceDirectory>src/main/java</sourceDirectory>
@@ -51,14 +71,14 @@
 			<plugin>
 				<groupId>org.codehaus.mojo</groupId>
 				<artifactId>versions-maven-plugin</artifactId>
-				<version>2.5</version>
+				<version>${versions-maven-plugin.version}</version>
 				<configuration>
 					<generateBackupPoms>false</generateBackupPoms>
 				</configuration>
 			</plugin>
 			<plugin>
 				<artifactId>maven-compiler-plugin</artifactId>
-				<version>3.8.0</version>
+				<version>${maven-compiler-plugin.version}</version>
 				<configuration>
 					<release>11</release>
 				</configuration>
@@ -89,7 +109,7 @@
 			<plugin>
 				<groupId>pl.project13.maven</groupId>
 				<artifactId>git-commit-id-plugin</artifactId>
-				<version>4.0.0</version>
+				<version>${git-commit-id-plugin.version}</version>
 				<executions>
 					<execution>
 						<id>get-the-git-infos</id>
@@ -121,7 +141,7 @@
 			<plugin>
 				<groupId>com.google.code.maven-replacer-plugin</groupId>
 				<artifactId>replacer</artifactId>
-				<version>1.5.3</version>
+				<version>${replacer.version}</version>
 				<executions>
 					<execution>
 						<id>replace-swagger-ui</id>
@@ -164,11 +184,13 @@
 						<configuration>
 							<file>${project.build.outputDirectory}/git.properties</file>
 							<regex>true</regex>
-							<regexFlags><regexFlag>MULTILINE</regexFlag></regexFlags>
+							<regexFlags>
+								<regexFlag>MULTILINE</regexFlag>
+							</regexFlags>
 							<replacements>
 								<replacement>
 									<token>^(#.*$[\n\r]*)</token>
-									<value></value>
+									<value/>
 								</replacement>
 							</replacements>
 						</configuration>
@@ -178,7 +200,10 @@
 			<!-- add swagger-ui as resource to output package -->
 			<plugin>
 				<artifactId>maven-resources-plugin</artifactId>
-				<version>3.1.0</version>
+				<version>${maven-resources-plugin.version}</version>
+				<configuration>
+					<propertiesEncoding>ISO-8859-1</propertiesEncoding>
+				</configuration>
 				<executions>
 					<execution>
 						<id>copy-resources</id>
@@ -232,7 +257,7 @@
 			<plugin>
 				<groupId>org.codehaus.mojo</groupId>
 				<artifactId>build-helper-maven-plugin</artifactId>
-				<version>3.0.0</version>
+				<version>${build-helper-maven-plugin.version}</version>
 				<executions>
 					<execution>
 						<phase>generate-sources</phase>
@@ -250,7 +275,7 @@
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-jar-plugin</artifactId>
-				<version>3.2.0</version>
+				<version>${maven-jar-plugin.version}</version>
 				<configuration>
 					<archive>
 						<manifest>
@@ -268,13 +293,12 @@
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-shade-plugin</artifactId>
-				<version>2.4.3</version>
+				<version>${maven-shade-plugin.version}</version>
 				<configuration>
 					<createDependencyReducedPom>false</createDependencyReducedPom>
 					<artifactSet>
 						<excludes>
-							<!-- Don't include original swagger-UI as we're including our own 
-								modified version -->
+							<!-- Don't include original swagger-UI as we're including our own modified version -->
 							<exclude>org.webjars:swagger-ui</exclude>
 							<!-- Don't include JUnit as it's for testing only! -->
 							<exclude>junit:junit</exclude>
@@ -318,7 +342,7 @@
 			<plugin>
 				<groupId>io.github.zlika</groupId>
 				<artifactId>reproducible-build-maven-plugin</artifactId>
-				<version>0.11</version>
+				<version>${reproducible-build-maven-plugin.version}</version>
 				<executions>
 					<execution>
 						<phase>package</phase>
@@ -335,7 +359,7 @@
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-surefire-plugin</artifactId>
-				<version>2.22.2</version>
+				<version>${maven-surefire-plugin.version}</version>
 				<configuration>
 					<skipTests>${skipTests}</skipTests>
 				</configuration>
@@ -347,7 +371,7 @@
 				<plugin>
 					<groupId>org.eclipse.m2e</groupId>
 					<artifactId>lifecycle-mapping</artifactId>
-					<version>1.0.0</version>
+					<version>${lifecycle-mapping.version}</version>
 					<configuration>
 						<lifecycleMappingMetadata>
 							<pluginExecutions>
@@ -360,14 +384,14 @@
 											maven-dependency-plugin
 										</artifactId>
 										<versionRange>
-											[2.8,)
+											[3.6.0,)
 										</versionRange>
 										<goals>
 											<goal>unpack</goal>
 										</goals>
 									</pluginExecutionFilter>
 									<action>
-										<execute></execute>
+										<execute/>
 									</action>
 								</pluginExecution>
 								<pluginExecution>
@@ -386,7 +410,7 @@
 										</goals>
 									</pluginExecutionFilter>
 									<action>
-										<execute></execute>
+										<execute/>
 									</action>
 								</pluginExecution>
 							</pluginExecutions>
@@ -413,15 +437,17 @@
 		<dependency>
 			<groupId>org.codehaus.mojo</groupId>
 			<artifactId>build-helper-maven-plugin</artifactId>
-			<version>3.0.0</version>
-			<scope>provided</scope><!-- needed for build, not for runtime -->
+			<version>${build-helper-maven-plugin.version}</version>
+			<scope>provided</scope>
+			<!-- needed for build, not for runtime -->
 		</dependency>
 		<!-- https://mvnrepository.com/artifact/com.github.bohnman/package-info-maven-plugin -->
 		<dependency>
 			<groupId>com.github.bohnman</groupId>
 			<artifactId>package-info-maven-plugin</artifactId>
 			<version>${package-info-maven-plugin.version}</version>
-			<scope>provided</scope><!-- needed for build, not for runtime -->
+			<scope>provided</scope>
+			<!-- needed for build, not for runtime -->
 		</dependency>
 		<!-- HSQLDB for repository -->
 		<dependency>
@@ -457,12 +483,12 @@
 		<dependency>
 			<groupId>com.googlecode.json-simple</groupId>
 			<artifactId>json-simple</artifactId>
-			<version>1.1.1</version>
+			<version>${json-simple.version}</version>
 		</dependency>
 		<dependency>
 			<groupId>org.json</groupId>
 			<artifactId>json</artifactId>
-			<version>20210307</version>
+			<version>${json.version}</version>
 		</dependency>
 		<dependency>
 			<groupId>org.apache.commons</groupId>
@@ -493,7 +519,7 @@
 		<dependency>
 			<groupId>io.druid</groupId>
 			<artifactId>extendedset</artifactId>
-			<version>0.12.3</version>
+			<version>${extendedset.version}</version>
 			<exclusions>
 				<!-- exclude old versions of jackson-annotations / jackson-core -->
 				<exclusion>
@@ -564,12 +590,12 @@
 		<dependency>
 			<groupId>javax.servlet</groupId>
 			<artifactId>javax.servlet-api</artifactId>
-			<version>4.0.1</version>
+			<version>${javax.servlet-api.version}</version>
 		</dependency>
 		<dependency>
 			<groupId>javax.mail</groupId>
 			<artifactId>mail</artifactId>
-			<version>1.5.0-b01</version>
+			<version>${mail.version}</version>
 		</dependency>
 		<!-- Unicode homoglyph utilities -->
 		<dependency>
@@ -638,7 +664,8 @@
 			<artifactId>jersey-hk2</artifactId>
 			<version>${jersey.version}</version>
 			<exclusions>
-				<exclusion><!-- exclude javax.inject-1.jar because other jersey modules include javax.inject v2+ -->
+				<exclusion>
+					<!-- exclude javax.inject-1.jar because other jersey modules include javax.inject v2+ -->
 					<groupId>javax.inject</groupId>
 					<artifactId>javax.inject</artifactId>
 				</exclusion>
@@ -665,7 +692,8 @@
 			<artifactId>swagger-jaxrs2-servlet-initializer</artifactId>
 			<version>${swagger-api.version}</version>
 			<exclusions>
-				<exclusion><!-- excluded because included in swagger-jaxrs2-servlet-initializer -->
+				<exclusion>
+					<!-- excluded because included in swagger-jaxrs2-servlet-initializer -->
 					<groupId>io.swagger.core.v3</groupId>
 					<artifactId>swagger-integration</artifactId>
 				</exclusion>
@@ -681,12 +709,12 @@
 		<dependency>
 			<groupId>org.junit.jupiter</groupId>
 			<artifactId>junit-jupiter-engine</artifactId>
-			<version>5.3.1</version>
+			<version>${junit-jupiter-engine.version}</version>
 		</dependency>
 		<dependency>
 			<groupId>org.hamcrest</groupId>
 			<artifactId>hamcrest-library</artifactId>
-			<version>1.3</version>
+			<version>${hamcrest-library.version}</version>
 		</dependency>
 		-->
 		<!-- BouncyCastle for crypto, including TLS secure networking -->
@@ -735,5 +763,11 @@
 			<artifactId>simplemagic</artifactId>
 			<version>${simplemagic.version}</version>
 		</dependency>
+		<!-- JAXB runtime for WADL support -->
+		<dependency>
+			<groupId>org.glassfish.jaxb</groupId>
+			<artifactId>jaxb-runtime</artifactId>
+			<version>${jaxb-runtime.version}</version>
+		</dependency>
 	</dependencies>
 </project>
--- a/src/main/java/org/qortal/api/ApiService.java
+++ b/src/main/java/org/qortal/api/ApiService.java
@@ -96,7 +96,7 @@ public class ApiService {
 					throw new RuntimeException("Failed to start SSL API due to broken keystore");

 				// BouncyCastle-specific SSLContext build
-				SSLContext sslContext = SSLContext.getInstance("TLS", "BCJSSE");
+				SSLContext sslContext = SSLContext.getInstance("TLSv1.3", "BCJSSE");
 				KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance("PKIX", "BCJSSE");

 				KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType(), "BC");
--- a/src/main/java/org/qortal/api/DevProxyService.java
+++ b/src/main/java/org/qortal/api/DevProxyService.java
@@ -0,0 +1,173 @@
+package org.qortal.api;
+
+import io.swagger.v3.jaxrs2.integration.resources.OpenApiResource;
+import org.eclipse.jetty.http.HttpVersion;
+import org.eclipse.jetty.rewrite.handler.RewriteHandler;
+import org.eclipse.jetty.server.*;
+import org.eclipse.jetty.server.handler.ErrorHandler;
+import org.eclipse.jetty.server.handler.InetAccessHandler;
+import org.eclipse.jetty.servlet.FilterHolder;
+import org.eclipse.jetty.servlet.ServletContextHandler;
+import org.eclipse.jetty.servlet.ServletHolder;
+import org.eclipse.jetty.servlets.CrossOriginFilter;
+import org.eclipse.jetty.util.ssl.SslContextFactory;
+import org.glassfish.jersey.server.ResourceConfig;
+import org.glassfish.jersey.servlet.ServletContainer;
+import org.qortal.api.resource.AnnotationPostProcessor;
+import org.qortal.api.resource.ApiDefinition;
+import org.qortal.network.Network;
+import org.qortal.repository.DataException;
+import org.qortal.settings.Settings;
+
+import javax.net.ssl.KeyManagerFactory;
+import javax.net.ssl.SSLContext;
+import java.io.InputStream;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.security.KeyStore;
+import java.security.SecureRandom;
+
+public class DevProxyService {
+
+	private static DevProxyService instance;
+
+	private final ResourceConfig config;
+	private Server server;
+
+	private DevProxyService() {
+		this.config = new ResourceConfig();
+		this.config.packages("org.qortal.api.proxy.resource", "org.qortal.api.resource");
+		this.config.register(OpenApiResource.class);
+		this.config.register(ApiDefinition.class);
+		this.config.register(AnnotationPostProcessor.class);
+	}
+
+	public static DevProxyService getInstance() {
+		if (instance == null)
+			instance = new DevProxyService();
+
+		return instance;
+	}
+
+	public Iterable<Class<?>> getResources() {
+		return this.config.getClasses();
+	}
+
+	public void start() throws DataException {
+		try {
+			// Create API server
+
+			// SSL support if requested
+			String keystorePathname = Settings.getInstance().getSslKeystorePathname();
+			String keystorePassword = Settings.getInstance().getSslKeystorePassword();
+
+			if (keystorePathname != null && keystorePassword != null) {
+				// SSL version
+				if (!Files.isReadable(Path.of(keystorePathname)))
+					throw new RuntimeException("Failed to start SSL API due to broken keystore");
+
+				// BouncyCastle-specific SSLContext build
+				SSLContext sslContext = SSLContext.getInstance("TLS", "BCJSSE");
+				KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance("PKIX", "BCJSSE");
+
+				KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType(), "BC");
+
+				try (InputStream keystoreStream = Files.newInputStream(Paths.get(keystorePathname))) {
+					keyStore.load(keystoreStream, keystorePassword.toCharArray());
+				}
+
+				keyManagerFactory.init(keyStore, keystorePassword.toCharArray());
+				sslContext.init(keyManagerFactory.getKeyManagers(), null, new SecureRandom());
+
+				SslContextFactory.Server sslContextFactory = new SslContextFactory.Server();
+				sslContextFactory.setSslContext(sslContext);
+
+				this.server = new Server();
+
+				HttpConfiguration httpConfig = new HttpConfiguration();
+				httpConfig.setSecureScheme("https");
+				httpConfig.setSecurePort(Settings.getInstance().getDevProxyPort());
+
+				SecureRequestCustomizer src = new SecureRequestCustomizer();
+				httpConfig.addCustomizer(src);
+
+				HttpConnectionFactory httpConnectionFactory = new HttpConnectionFactory(httpConfig);
+				SslConnectionFactory sslConnectionFactory = new SslConnectionFactory(sslContextFactory, HttpVersion.HTTP_1_1.asString());
+
+				ServerConnector portUnifiedConnector = new ServerConnector(this.server,
+						new DetectorConnectionFactory(sslConnectionFactory),
+						httpConnectionFactory);
+				portUnifiedConnector.setHost(Network.getInstance().getBindAddress());
+				portUnifiedConnector.setPort(Settings.getInstance().getDevProxyPort());
+
+				this.server.addConnector(portUnifiedConnector);
+			} else {
+				// Non-SSL
+				InetAddress bindAddr = InetAddress.getByName(Network.getInstance().getBindAddress());
+				InetSocketAddress endpoint = new InetSocketAddress(bindAddr, Settings.getInstance().getDevProxyPort());
+				this.server = new Server(endpoint);
+			}
+
+			// Error handler
+			ErrorHandler errorHandler = new ApiErrorHandler();
+			this.server.setErrorHandler(errorHandler);
+
+			// Request logging
+			if (Settings.getInstance().isDevProxyLoggingEnabled()) {
+				RequestLogWriter logWriter = new RequestLogWriter("devproxy-requests.log");
+				logWriter.setAppend(true);
+				logWriter.setTimeZone("UTC");
+				RequestLog requestLog = new CustomRequestLog(logWriter, CustomRequestLog.EXTENDED_NCSA_FORMAT);
+				this.server.setRequestLog(requestLog);
+			}
+
+			// Access handler (currently no whitelist is used)
+			InetAccessHandler accessHandler = new InetAccessHandler();
+			this.server.setHandler(accessHandler);
+
+			// URL rewriting
+			RewriteHandler rewriteHandler = new RewriteHandler();
+			accessHandler.setHandler(rewriteHandler);
+
+			// Context
+			ServletContextHandler context = new ServletContextHandler(ServletContextHandler.NO_SESSIONS);
+			context.setContextPath("/");
+			rewriteHandler.setHandler(context);
+
+			// Cross-origin resource sharing
+			FilterHolder corsFilterHolder = new FilterHolder(CrossOriginFilter.class);
+			corsFilterHolder.setInitParameter(CrossOriginFilter.ALLOWED_ORIGINS_PARAM, "*");
+			corsFilterHolder.setInitParameter(CrossOriginFilter.ALLOWED_METHODS_PARAM, "GET, POST, DELETE");
+			corsFilterHolder.setInitParameter(CrossOriginFilter.CHAIN_PREFLIGHT_PARAM, "false");
+			context.addFilter(corsFilterHolder, "/*", null);
+
+			// API servlet
+			ServletContainer container = new ServletContainer(this.config);
+			ServletHolder apiServlet = new ServletHolder(container);
+			apiServlet.setInitOrder(1);
+			context.addServlet(apiServlet, "/*");
+
+			// Start server
+			this.server.start();
+		} catch (Exception e) {
+			// Failed to start
+			throw new DataException("Failed to start developer proxy", e);
+		}
+	}
+
+	public void stop() {
+		try {
+			// Stop server
+			this.server.stop();
+		} catch (Exception e) {
+			// Failed to stop
+		}
+
+		this.server = null;
+		instance = null;
+	}
+
+}
--- a/src/main/java/org/qortal/api/DomainMapService.java
+++ b/src/main/java/org/qortal/api/DomainMapService.java
@@ -69,7 +69,7 @@ public class DomainMapService {
 					throw new RuntimeException("Failed to start SSL API due to broken keystore");

 				// BouncyCastle-specific SSLContext build
-				SSLContext sslContext = SSLContext.getInstance("TLS", "BCJSSE");
+				SSLContext sslContext = SSLContext.getInstance("TLSv1.3", "BCJSSE");
 				KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance("PKIX", "BCJSSE");

 				KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType(), "BC");
--- a/src/main/java/org/qortal/api/GatewayService.java
+++ b/src/main/java/org/qortal/api/GatewayService.java
@@ -69,7 +69,7 @@ public class GatewayService {
 					throw new RuntimeException("Failed to start SSL API due to broken keystore");

 				// BouncyCastle-specific SSLContext build
-				SSLContext sslContext = SSLContext.getInstance("TLS", "BCJSSE");
+				SSLContext sslContext = SSLContext.getInstance("TLSv1.3", "BCJSSE");
 				KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance("PKIX", "BCJSSE");

 				KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType(), "BC");
--- a/src/main/java/org/qortal/api/HTMLParser.java
+++ b/src/main/java/org/qortal/api/HTMLParser.java
@@ -24,11 +24,11 @@ public class HTMLParser {
    private String theme;
    private boolean usingCustomRouting;

-    public HTMLParser(String resourceId, String inPath, String prefix, boolean usePrefix, byte[] data,
+    public HTMLParser(String resourceId, String inPath, String prefix, boolean includeResourceIdInPrefix, byte[] data,
                      String qdnContext, Service service, String identifier, String theme, boolean usingCustomRouting) {
-        String inPathWithoutFilename = inPath.contains("/") ? inPath.substring(0, inPath.lastIndexOf('/')) : "";
-        this.qdnBase = usePrefix ? String.format("%s/%s", prefix, resourceId) : "";
-        this.qdnBaseWithPath = usePrefix ? String.format("%s/%s%s", prefix, resourceId, inPathWithoutFilename) : "";
+        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);
        this.data = data;
        this.qdnContext = qdnContext;
        this.resourceId = resourceId;
@@ -82,7 +82,7 @@ public class HTMLParser {
    }

    public static boolean isHtmlFile(String path) {
-        if (path.endsWith(".html") || path.endsWith(".htm")) {
+        if (path.endsWith(".html") || path.endsWith(".htm") || path.equals("")) {
            return true;
        }
        return false;
--- a/src/main/java/org/qortal/api/domainmap/resource/DomainMapResource.java
+++ b/src/main/java/org/qortal/api/domainmap/resource/DomainMapResource.java
@@ -48,10 +48,10 @@ public class DomainMapResource {
    }

    private HttpServletResponse get(String resourceId, ResourceIdType resourceIdType, Service service, String identifier,
-                                    String inPath, String secret58, String prefix, boolean usePrefix, boolean async) {
+                                    String inPath, String secret58, String prefix, boolean includeResourceIdInPrefix, boolean async) {

        ArbitraryDataRenderer renderer = new ArbitraryDataRenderer(resourceId, resourceIdType, service, identifier, inPath,
-                secret58, prefix, usePrefix, async, "domainMap", request, response, context);
+                secret58, prefix, includeResourceIdInPrefix, async, "domainMap", request, response, context);
        return renderer.render();
    }

--- a/src/main/java/org/qortal/api/gateway/resource/GatewayResource.java
+++ b/src/main/java/org/qortal/api/gateway/resource/GatewayResource.java
@@ -90,7 +90,7 @@ public class GatewayResource {
    }

    
-    private HttpServletResponse parsePath(String inPath, String qdnContext, String secret58, boolean usePrefix, boolean async) {
+    private HttpServletResponse parsePath(String inPath, String qdnContext, String secret58, boolean includeResourceIdInPrefix, boolean async) {

        if (inPath == null || inPath.equals("")) {
            // Assume not a real file
@@ -157,7 +157,7 @@ public class GatewayResource {
        }

        ArbitraryDataRenderer renderer = new ArbitraryDataRenderer(name, ResourceIdType.NAME, service, identifier, outPath,
-                secret58, prefix, usePrefix, async, qdnContext, request, response, context);
+                secret58, prefix, includeResourceIdInPrefix, async, qdnContext, request, response, context);
        return renderer.render();
    }

--- a/src/main/java/org/qortal/api/model/AtCreationRequest.java
+++ b/src/main/java/org/qortal/api/model/AtCreationRequest.java
@@ -0,0 +1,102 @@
+package org.qortal.api.model;
+
+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.XmlTransient;
+
+import org.bouncycastle.util.encoders.Base64;
+import org.bouncycastle.util.encoders.DecoderException;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+public class AtCreationRequest {
+
+    @Schema(description = "CIYAM AT version", example = "2")
+    private short ciyamAtVersion;
+
+    @Schema(description = "base64-encoded code bytes", example = "")
+    private String codeBytesBase64;
+
+    @Schema(description = "base64-encoded data bytes", example = "")
+    private String dataBytesBase64;
+
+    private short numCallStackPages;
+    private short numUserStackPages;
+    private long minActivationAmount;
+
+    // Default constructor for JSON deserialization
+    public AtCreationRequest() {}
+
+    // Getters and setters
+    public short getCiyamAtVersion() {
+        return ciyamAtVersion;
+    }
+
+    public void setCiyamAtVersion(short ciyamAtVersion) {
+        this.ciyamAtVersion = ciyamAtVersion;
+    }
+
+
+    public String getCodeBytesBase64() {
+        return this.codeBytesBase64;
+    }
+
+    @XmlTransient
+    @Schema(hidden = true)
+    public byte[] getCodeBytes() {
+        if (this.codeBytesBase64 != null) {
+            try {
+                return Base64.decode(this.codeBytesBase64);
+            }
+            catch (DecoderException e) {
+                return null;
+            }
+        }
+        return null;
+    }
+
+
+    public String getDataBytesBase64() {
+        return this.dataBytesBase64;
+    }
+
+    @XmlTransient
+    @Schema(hidden = true)
+    public byte[] getDataBytes() {
+        if (this.dataBytesBase64 != null) {
+            try {
+                return Base64.decode(this.dataBytesBase64);
+            }
+            catch (DecoderException e) {
+                return null;
+            }
+        }
+        return null;
+    }
+
+
+    public short getNumCallStackPages() {
+        return numCallStackPages;
+    }
+
+    public void setNumCallStackPages(short numCallStackPages) {
+        this.numCallStackPages = numCallStackPages;
+    }
+
+    public short getNumUserStackPages() {
+        return numUserStackPages;
+    }
+
+    public void setNumUserStackPages(short numUserStackPages) {
+        this.numUserStackPages = numUserStackPages;
+    }
+
+    public long getMinActivationAmount() {
+        return minActivationAmount;
+    }
+
+    public void setMinActivationAmount(long minActivationAmount) {
+        this.minActivationAmount = minActivationAmount;
+    }
+}
--- a/src/main/java/org/qortal/api/proxy/resource/DevProxyServerResource.java
+++ b/src/main/java/org/qortal/api/proxy/resource/DevProxyServerResource.java
@@ -0,0 +1,164 @@
+package org.qortal.api.proxy.resource;
+
+import org.qortal.api.ApiError;
+import org.qortal.api.ApiExceptionFactory;
+import org.qortal.api.HTMLParser;
+import org.qortal.arbitrary.misc.Service;
+import org.qortal.controller.DevProxyManager;
+
+import javax.servlet.ServletContext;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.ws.rs.GET;
+import javax.ws.rs.Path;
+import javax.ws.rs.PathParam;
+import javax.ws.rs.core.Context;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.ConnectException;
+import java.net.HttpURLConnection;
+import java.net.ProtocolException;
+import java.net.URL;
+import java.util.Enumeration;
+
+
+@Path("/")
+public class DevProxyServerResource {
+
+    @Context HttpServletRequest request;
+    @Context HttpServletResponse response;
+    @Context ServletContext context;
+
+
+    @GET
+    public HttpServletResponse getProxyIndex() {
+        return this.proxy("/");
+    }
+
+    @GET
+    @Path("{path:.*}")
+    public HttpServletResponse getProxyPath(@PathParam("path") String inPath) {
+        return this.proxy(inPath);
+    }
+
+    private HttpServletResponse proxy(String inPath) {
+        try {
+            String source = DevProxyManager.getInstance().getSourceHostAndPort();
+
+            if (!inPath.startsWith("/")) {
+                inPath = "/" + inPath;
+            }
+
+            String queryString = request.getQueryString() != null ? "?" + request.getQueryString() : "";
+
+            // Open URL
+            URL url = new URL(String.format("http://%s%s%s", source, inPath, queryString));
+            HttpURLConnection con = (HttpURLConnection) url.openConnection();
+
+            // Proxy the request data
+            this.proxyRequestToConnection(request, con);
+
+            try {
+                // Make the request and proxy the response code
+                response.setStatus(con.getResponseCode());
+            }
+            catch (ConnectException e) {
+
+                // Tey converting localhost / 127.0.0.1 to IPv6 [::1]
+                if (source.startsWith("localhost") || source.startsWith("127.0.0.1")) {
+                    int port = 80;
+                    String[] parts = source.split(":");
+                    if (parts.length > 1) {
+                        port = Integer.parseInt(parts[1]);
+                    }
+                    source = String.format("[::1]:%d", port);
+                }
+
+                // Retry connection
+                url = new URL(String.format("http://%s%s%s", source, inPath, queryString));
+                con = (HttpURLConnection) url.openConnection();
+                this.proxyRequestToConnection(request, con);
+                response.setStatus(con.getResponseCode());
+            }
+
+            // Proxy the response data back to the caller
+            this.proxyConnectionToResponse(con, response, inPath);
+
+        } catch (IOException e) {
+            throw ApiExceptionFactory.INSTANCE.createCustomException(request, ApiError.INVALID_CRITERIA, e.getMessage());
+        }
+
+        return response;
+    }
+
+    private void proxyRequestToConnection(HttpServletRequest request, HttpURLConnection con) throws ProtocolException {
+        // Proxy the request method
+        con.setRequestMethod(request.getMethod());
+
+        // Proxy the request headers
+        Enumeration<String> headerNames = request.getHeaderNames();
+        while (headerNames.hasMoreElements()) {
+            String headerName = headerNames.nextElement();
+            String headerValue = request.getHeader(headerName);
+            con.setRequestProperty(headerName, headerValue);
+        }
+
+        // TODO: proxy any POST parameters from "request" to "con"
+    }
+
+    private void proxyConnectionToResponse(HttpURLConnection con, HttpServletResponse response, String inPath) throws IOException {
+        // Proxy the response headers
+        for (int i = 0; ; i++) {
+            String headerKey = con.getHeaderFieldKey(i);
+            String headerValue = con.getHeaderField(i);
+            if (headerKey != null && headerValue != null) {
+                response.addHeader(headerKey, headerValue);
+                continue;
+            }
+            break;
+        }
+
+        // Read the response body
+        InputStream inputStream = con.getInputStream();
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        byte[] buffer = new byte[4096];
+        int bytesRead;
+        while ((bytesRead = inputStream.read(buffer)) != -1) {
+            outputStream.write(buffer, 0, bytesRead);
+        }
+        byte[] data = outputStream.toByteArray(); // TODO: limit file size that can be read into memory
+
+        // Close the streams
+        outputStream.close();
+        inputStream.close();
+
+        // Extract filename
+        String filename = "";
+        if (inPath.contains("/")) {
+            String[] parts = inPath.split("/");
+            if (parts.length > 0) {
+                filename = parts[parts.length - 1];
+            }
+        }
+
+        // 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.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());
+            response.setContentLength(htmlParser.getData().length);
+            response.getOutputStream().write(htmlParser.getData());
+        }
+        else {
+            // Regular file - can be streamed directly
+            response.addHeader("Content-Security-Policy", "default-src 'self'");
+            response.setContentType(con.getContentType());
+            response.setContentLength(data.length);
+            response.getOutputStream().write(data);
+        }
+    }
+
+}
--- a/src/main/java/org/qortal/api/resource/ArbitraryResource.java
+++ b/src/main/java/org/qortal/api/resource/ArbitraryResource.java
@@ -724,7 +724,7 @@ public class ArbitraryResource {
 		ArbitraryDataResource resource = new ArbitraryDataResource(name, ResourceIdType.NAME, service, identifier);

 		try {
-			ArbitraryDataTransactionMetadata transactionMetadata = ArbitraryMetadataManager.getInstance().fetchMetadata(resource, false);
+			ArbitraryDataTransactionMetadata transactionMetadata = ArbitraryMetadataManager.getInstance().fetchMetadata(resource, true);
 			if (transactionMetadata != null) {
 				ArbitraryResourceMetadata resourceMetadata = ArbitraryResourceMetadata.fromTransactionMetadata(transactionMetadata, true);
 				if (resourceMetadata != null) {
--- a/src/main/java/org/qortal/api/resource/AtResource.java
+++ b/src/main/java/org/qortal/api/resource/AtResource.java
@@ -27,6 +27,7 @@ import org.qortal.api.ApiException;
 import org.qortal.api.ApiExceptionFactory;
 import org.qortal.data.at.ATData;
 import org.qortal.data.at.ATStateData;
+import org.qortal.api.model.AtCreationRequest;
 import org.qortal.data.transaction.DeployAtTransactionData;
 import org.qortal.repository.DataException;
 import org.qortal.repository.Repository;
@@ -38,9 +39,14 @@ import org.qortal.transform.TransformationException;
 import org.qortal.transform.transaction.DeployAtTransactionTransformer;
 import org.qortal.utils.Base58;

+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+
@Path("/at")
@Tag(name = "Automated Transactions")
 public class AtResource {
+	private static final Logger logger = LoggerFactory.getLogger(AtResource.class);

 	@Context
 	HttpServletRequest request;
@@ -156,6 +162,52 @@ public class AtResource {
 		}
 	}

+	@POST
+	@Path("/create")
+	@Operation(
+			summary = "Create base58-encoded AT creation bytes from the provided parameters",
+			requestBody = @RequestBody(
+					required = true,
+					content = @Content(
+							mediaType = MediaType.APPLICATION_JSON,
+							schema = @Schema(
+									implementation = AtCreationRequest.class
+							)
+					)
+			),
+			responses = {
+					@ApiResponse(
+							description = "AT creation bytes suitable for use in a DEPLOY_AT transaction",
+							content = @Content(
+									mediaType = MediaType.TEXT_PLAIN,
+									schema = @Schema(
+											type = "string"
+									)
+							)
+					)
+			}
+	)
+	public String create(AtCreationRequest atCreationRequest) {
+		if (atCreationRequest.getCiyamAtVersion() < 2) {
+			throw ApiExceptionFactory.INSTANCE.createCustomException(request, ApiError.INVALID_CRITERIA, "ciyamAtVersion must be at least 2");
+		}
+		if (atCreationRequest.getCodeBytes() == null) {
+			throw ApiExceptionFactory.INSTANCE.createCustomException(request, ApiError.INVALID_CRITERIA, "Valid codeBytesBase64 must be supplied");
+		}
+		if (atCreationRequest.getDataBytes() == null) {
+			throw ApiExceptionFactory.INSTANCE.createCustomException(request, ApiError.INVALID_CRITERIA, "Valid dataBytesBase64 must be supplied");
+		}
+
+		byte[] creationBytes = MachineState.toCreationBytes(
+				atCreationRequest.getCiyamAtVersion(),
+				atCreationRequest.getCodeBytes(),
+				atCreationRequest.getDataBytes(),
+				atCreationRequest.getNumCallStackPages(),
+				atCreationRequest.getNumUserStackPages(),
+				atCreationRequest.getMinActivationAmount()
+		);
+		return Base58.encode(creationBytes);
+	}
 	@POST
 	@Operation(
 		summary = "Build raw, unsigned, DEPLOY_AT transaction",
--- a/src/main/java/org/qortal/api/resource/DeveloperResource.java
+++ b/src/main/java/org/qortal/api/resource/DeveloperResource.java
@@ -0,0 +1,96 @@
+package org.qortal.api.resource;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.media.Content;
+import io.swagger.v3.oas.annotations.media.Schema;
+import io.swagger.v3.oas.annotations.parameters.RequestBody;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import org.qortal.api.ApiError;
+import org.qortal.api.ApiErrors;
+import org.qortal.api.ApiExceptionFactory;
+import org.qortal.controller.DevProxyManager;
+import org.qortal.repository.DataException;
+
+import javax.servlet.ServletContext;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.ws.rs.POST;
+import javax.ws.rs.Path;
+import javax.ws.rs.core.Context;
+import javax.ws.rs.core.MediaType;
+
+
+@Path("/developer")
+@Tag(name = "Developer Tools")
+public class DeveloperResource {
+
+	@Context HttpServletRequest request;
+	@Context HttpServletResponse response;
+	@Context ServletContext context;
+
+
+	@POST
+	@Path("/proxy/start")
+	@Operation(
+			summary = "Start proxy server, for real time QDN app/website development",
+			requestBody = @RequestBody(
+					description = "Host and port of source webserver to be proxied",
+					required = true,
+					content = @Content(
+							mediaType = MediaType.TEXT_PLAIN,
+							schema = @Schema(
+									type = "string",
+									example = "127.0.0.1:5173"
+							)
+					)
+			),
+			responses = {
+					@ApiResponse(
+							description = "Port number of running server",
+							content = @Content(
+									mediaType = MediaType.TEXT_PLAIN,
+									schema = @Schema(
+											type = "number"
+									)
+							)
+					)
+			}
+	)
+	@ApiErrors({ApiError.INVALID_CRITERIA})
+	public Integer startProxy(String sourceHostAndPort) {
+		// TODO: API key
+		DevProxyManager devProxyManager = DevProxyManager.getInstance();
+		try {
+			devProxyManager.setSourceHostAndPort(sourceHostAndPort);
+			devProxyManager.start();
+			return devProxyManager.getPort();
+
+		} catch (DataException e) {
+			throw ApiExceptionFactory.INSTANCE.createCustomException(request, ApiError.INVALID_CRITERIA, e.getMessage());
+		}
+	}
+
+	@POST
+	@Path("/proxy/stop")
+	@Operation(
+			summary = "Stop proxy server",
+			responses = {
+					@ApiResponse(
+							description = "true if stopped",
+							content = @Content(
+									mediaType = MediaType.TEXT_PLAIN,
+									schema = @Schema(
+											type = "boolean"
+									)
+							)
+					)
+			}
+	)
+	public boolean stopProxy() {
+		DevProxyManager devProxyManager = DevProxyManager.getInstance();
+		devProxyManager.stop();
+		return !devProxyManager.isRunning();
+	}
+
+}
--- a/src/main/java/org/qortal/api/restricted/resource/AdminResource.java
+++ b/src/main/java/org/qortal/api/restricted/resource/AdminResource.java
@@ -16,11 +16,6 @@ import java.net.InetSocketAddress;
 import java.net.UnknownHostException;
 import java.nio.file.Files;
 import java.nio.file.Paths;
-import java.time.LocalDate;
-import java.time.LocalTime;
-import java.time.OffsetDateTime;
-import java.time.ZoneOffset;
-import java.util.Arrays;
 import java.util.List;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
@@ -38,7 +33,6 @@ import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.core.LoggerContext;
 import org.apache.logging.log4j.core.appender.RollingFileAppender;
 import org.json.JSONArray;
-import org.json.JSONObject;
 import org.qortal.account.Account;
 import org.qortal.account.PrivateKeyAccount;
 import org.qortal.api.*;
@@ -269,7 +263,7 @@ public class AdminResource {
 	@GET
 	@Path("/summary")
 	@Operation(
-		summary = "Summary of activity since midnight, UTC",
+		summary = "Summary of activity past 24 hours",
 		responses = {
 			@ApiResponse(
 				content = @Content(schema = @Schema(implementation = ActivitySummary.class))
@@ -282,23 +276,21 @@ public class AdminResource {
 		Security.checkApiCallAllowed(request);

 		ActivitySummary summary = new ActivitySummary();
-
-		LocalDate date = LocalDate.now();
-		LocalTime time = LocalTime.of(0, 0);
-		ZoneOffset offset = ZoneOffset.UTC;
-		long start = OffsetDateTime.of(date, time, offset).toInstant().toEpochMilli();
+		
+		long now = NTP.getTime();
+		long oneday = now - 24 * 60 * 60 * 1000L;

 		try (final Repository repository = RepositoryManager.getRepository()) {
-			int startHeight = repository.getBlockRepository().getHeightFromTimestamp(start);
+			int startHeight = repository.getBlockRepository().getHeightFromTimestamp(oneday);
 			int endHeight = repository.getBlockRepository().getBlockchainHeight();

 			summary.setBlockCount(endHeight - startHeight);

 			summary.setTransactionCountByType(repository.getTransactionRepository().getTransactionSummary(startHeight + 1, endHeight));

-			summary.setAssetsIssued(repository.getAssetRepository().getRecentAssetIds(start).size());
+			summary.setAssetsIssued(repository.getAssetRepository().getRecentAssetIds(oneday).size());

-			summary.setNamesRegistered (repository.getNameRepository().getRecentNames(start).size());
+			summary.setNamesRegistered (repository.getNameRepository().getRecentNames(oneday).size());

 			return summary;
 		} catch (DataException e) {
--- a/src/main/java/org/qortal/api/restricted/resource/RenderResource.java
+++ b/src/main/java/org/qortal/api/restricted/resource/RenderResource.java
@@ -157,10 +157,10 @@ public class RenderResource {


    private HttpServletResponse get(String resourceId, ResourceIdType resourceIdType, Service service, String identifier,
-                                    String inPath, String secret58, String prefix, boolean usePrefix, boolean async, String theme) {
+                                    String inPath, String secret58, String prefix, boolean includeResourceIdInPrefix, boolean async, String theme) {

        ArbitraryDataRenderer renderer = new ArbitraryDataRenderer(resourceId, resourceIdType, service, identifier, inPath,
-                secret58, prefix, usePrefix, async, "render", request, response, context);
+                secret58, prefix, includeResourceIdInPrefix, async, "render", request, response, context);

        if (theme != null) {
            renderer.setTheme(theme);
--- a/src/main/java/org/qortal/arbitrary/ArbitraryDataRenderer.java
+++ b/src/main/java/org/qortal/arbitrary/ArbitraryDataRenderer.java
@@ -40,7 +40,7 @@ public class ArbitraryDataRenderer {
    private String inPath;
    private final String secret58;
    private final String prefix;
-    private final boolean usePrefix;
+    private final boolean includeResourceIdInPrefix;
    private final boolean async;
    private final String qdnContext;
    private final HttpServletRequest request;
@@ -48,7 +48,7 @@ public class ArbitraryDataRenderer {
    private final ServletContext context;

    public ArbitraryDataRenderer(String resourceId, ResourceIdType resourceIdType, Service service, String identifier,
-                                 String inPath, String secret58, String prefix, boolean usePrefix, boolean async, String qdnContext,
+                                 String inPath, String secret58, String prefix, boolean includeResourceIdInPrefix, boolean async, String qdnContext,
                                 HttpServletRequest request, HttpServletResponse response, ServletContext context) {

        this.resourceId = resourceId;
@@ -58,7 +58,7 @@ public class ArbitraryDataRenderer {
        this.inPath = inPath;
        this.secret58 = secret58;
        this.prefix = prefix;
-        this.usePrefix = usePrefix;
+        this.includeResourceIdInPrefix = includeResourceIdInPrefix;
        this.async = async;
        this.qdnContext = qdnContext;
        this.request = request;
@@ -127,6 +127,11 @@ public class ArbitraryDataRenderer {
            String filename = this.getFilename(unzippedPath, inPath);
            Path filePath = Paths.get(unzippedPath, filename);
            boolean usingCustomRouting = false;
+            if (Files.isDirectory(filePath) && (!inPath.endsWith("/"))) {
+                inPath = inPath + "/";
+                filename = this.getFilename(unzippedPath, inPath);
+                filePath = Paths.get(unzippedPath, filename);
+            }
            
            // If the file doesn't exist, we may need to route the request elsewhere, or cleanup
            if (!Files.exists(filePath)) {
@@ -159,7 +164,7 @@ 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, usePrefix, data, qdnContext, service, identifier, theme, usingCustomRouting);
+                HTMLParser htmlParser = new HTMLParser(resourceId, inPath, prefix, includeResourceIdInPrefix, data, qdnContext, service, identifier, theme, usingCustomRouting);
                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.setContentType(context.getMimeType(filename));
--- a/src/main/java/org/qortal/arbitrary/misc/Service.java
+++ b/src/main/java/org/qortal/arbitrary/misc/Service.java
@@ -186,6 +186,7 @@ public enum Service {
    private static final ObjectMapper objectMapper = new ObjectMapper();

    private static final String encryptedDataPrefix = "qortalEncryptedData";
+    private static final String encryptedGroupDataPrefix = "qortalGroupEncryptedData";

    Service(int value, boolean requiresValidation, Long maxSize, boolean single, boolean isPrivate, List<String> requiredKeys) {
        this.value = value;
@@ -221,10 +222,10 @@ public enum Service {
        // Validate private data for single file resources
        if (this.single) {
            String dataString = new String(data, StandardCharsets.UTF_8);
-            if (this.isPrivate && !dataString.startsWith(encryptedDataPrefix)) {
+            if (this.isPrivate && !dataString.startsWith(encryptedDataPrefix) && !dataString.startsWith(encryptedGroupDataPrefix)) {
                return ValidationResult.DATA_NOT_ENCRYPTED;
            }
-            if (!this.isPrivate && dataString.startsWith(encryptedDataPrefix)) {
+            if (!this.isPrivate && (dataString.startsWith(encryptedDataPrefix) || dataString.startsWith(encryptedGroupDataPrefix))) {
                return ValidationResult.DATA_ENCRYPTED;
            }
        }
--- a/src/main/java/org/qortal/block/Block.java
+++ b/src/main/java/org/qortal/block/Block.java
@@ -84,6 +84,7 @@ public class Block {
 		TRANSACTION_PROCESSING_FAILED(53),
 		TRANSACTION_ALREADY_PROCESSED(54),
 		TRANSACTION_NEEDS_APPROVAL(55),
+		TRANSACTION_NOT_CONFIRMABLE(56),
 		AT_STATES_MISMATCH(61),
 		ONLINE_ACCOUNTS_INVALID(70),
 		ONLINE_ACCOUNT_UNKNOWN(71),
@@ -130,6 +131,9 @@ public class Block {
 	/** Locally-generated AT fees */
 	protected long ourAtFees; // Generated locally

+	/** Cached online accounts validation decision, to avoid revalidating when true */
+	private boolean onlineAccountsAlreadyValid = false;
+
 	@FunctionalInterface
 	private interface BlockRewardDistributor {
 		long distribute(long amount, Map<String, Long> balanceChanges) throws DataException;
@@ -563,6 +567,13 @@ public class Block {
 	}


+	/**
+	 * Force online accounts to be revalidated, e.g. at final stage of block minting.
+	 */
+	public void clearOnlineAccountsValidationCache() {
+		this.onlineAccountsAlreadyValid = false;
+	}
+
 	// More information

 	/**
@@ -1043,6 +1054,10 @@ public class Block {
 		if (this.blockData.getHeight() != null && this.blockData.getHeight() == 1)
 			return ValidationResult.OK;

+		// Don't bother revalidating if accounts have already been validated in this block
+		if (this.onlineAccountsAlreadyValid)
+			return ValidationResult.OK;
+
 		// Expand block's online accounts indexes into actual accounts
 		ConciseSet accountIndexes = BlockTransformer.decodeOnlineAccounts(this.blockData.getEncodedOnlineAccounts());
 		// We use count of online accounts to validate decoded account indexes
@@ -1130,6 +1145,9 @@ public class Block {
 		// All online accounts valid, so save our list of online accounts for potential later use
 		this.cachedOnlineRewardShares = onlineRewardShares;

+		// Remember that the accounts are valid, to speed up subsequent checks
+		this.onlineAccountsAlreadyValid = true;
+
 		return ValidationResult.OK;
 	}

@@ -1234,6 +1252,13 @@ public class Block {
 						|| transaction.getDeadline() <= this.blockData.getTimestamp())
 					return ValidationResult.TRANSACTION_TIMESTAMP_INVALID;

+				// After feature trigger, check that this transaction is confirmable
+				if (transactionData.getTimestamp() >= BlockChain.getInstance().getMemPoWTransactionUpdatesTimestamp()) {
+					if (!transaction.isConfirmable()) {
+						return ValidationResult.TRANSACTION_NOT_CONFIRMABLE;
+					}
+				}
+
 				// Check transaction isn't already included in a block
 				if (this.repository.getTransactionRepository().isConfirmed(transactionData.getSignature()))
 					return ValidationResult.TRANSACTION_ALREADY_PROCESSED;
--- a/src/main/java/org/qortal/block/BlockChain.java
+++ b/src/main/java/org/qortal/block/BlockChain.java
@@ -48,9 +48,6 @@ public class BlockChain {
 	/** Transaction expiry period, starting from transaction's timestamp, in milliseconds. */
 	private long transactionExpiryPeriod;

-	@XmlJavaTypeAdapter(value = org.qortal.api.AmountTypeAdapter.class)
-	private long unitFee;
-
 	private int maxBytesPerUnitFee;

 	/** Maximum acceptable timestamp disagreement offset in milliseconds. */
@@ -89,6 +86,7 @@ public class BlockChain {
 		@XmlJavaTypeAdapter(value = org.qortal.api.AmountTypeAdapter.class)
 		public long fee;
 	}
+	private List<UnitFeesByTimestamp> unitFees;
 	private List<UnitFeesByTimestamp> nameRegistrationUnitFees;

 	/** Map of which blockchain features are enabled when (height/timestamp) */
@@ -211,6 +209,9 @@ public class BlockChain {
 	/** Snapshot timestamp for self sponsorship algo V1 */
 	private long selfSponsorshipAlgoV1SnapshotTimestamp;

+	/** Feature-trigger timestamp to modify behaviour of various transactions that support mempow */
+	private long mempowTransactionUpdatesTimestamp;
+
 	/** Max reward shares by block height */
 	public static class MaxRewardSharesByTimestamp {
 		public long timestamp;
@@ -346,10 +347,6 @@ public class BlockChain {
 		return this.isTestChain;
 	}

-	public long getUnitFee() {
-		return this.unitFee;
-	}
-
 	public int getMaxBytesPerUnitFee() {
 		return this.maxBytesPerUnitFee;
 	}
@@ -376,6 +373,11 @@ public class BlockChain {
 		return this.selfSponsorshipAlgoV1SnapshotTimestamp;
 	}

+	// Feature-trigger timestamp to modify behaviour of various transactions that support mempow
+	public long getMemPoWTransactionUpdatesTimestamp() {
+		return this.mempowTransactionUpdatesTimestamp;
+	}
+
 	/** Returns true if approval-needing transaction types require a txGroupId other than NO_GROUP. */
 	public boolean getRequireGroupForApproval() {
 		return this.requireGroupForApproval;
@@ -547,13 +549,22 @@ public class BlockChain {
 		throw new IllegalStateException(String.format("No block timing info available for height %d", ourHeight));
 	}

+	public long getUnitFeeAtTimestamp(long ourTimestamp) {
+		for (int i = unitFees.size() - 1; i >= 0; --i)
+			if (unitFees.get(i).timestamp <= ourTimestamp)
+				return unitFees.get(i).fee;
+
+		// Shouldn't happen, but set a sensible default just in case
+		return 100000;
+	}
+
 	public long getNameRegistrationUnitFeeAtTimestamp(long ourTimestamp) {
 		for (int i = nameRegistrationUnitFees.size() - 1; i >= 0; --i)
 			if (nameRegistrationUnitFees.get(i).timestamp <= ourTimestamp)
 				return nameRegistrationUnitFees.get(i).fee;

-		// Default to system-wide unit fee
-		return this.getUnitFee();
+		// Shouldn't happen, but set a sensible default just in case
+		return 100000;
 	}

 	public int getMaxRewardSharesAtTimestamp(long ourTimestamp) {
--- a/src/main/java/org/qortal/controller/BlockMinter.java
+++ b/src/main/java/org/qortal/controller/BlockMinter.java
@@ -380,9 +380,13 @@ public class BlockMinter extends Thread {
 						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();

@@ -484,6 +488,9 @@ public class BlockMinter extends Thread {
 		// Sign to create block's signature, needed by Block.isValid()
 		newBlock.sign();

+		// User-defined limit per block
+		int limit = Settings.getInstance().getMaxTransactionsPerBlock();
+
 		// Attempt to add transactions until block is full, or we run out
 		// If a transaction makes the block invalid then skip it and it'll either expire or be in next block.
 		for (TransactionData transactionData : unconfirmedTransactions) {
@@ -496,6 +503,12 @@ public class BlockMinter extends Thread {
 				LOGGER.debug(() -> String.format("Skipping invalid transaction %s during block minting", Base58.encode(transactionData.getSignature())));
 				newBlock.deleteTransaction(transactionData);
 			}
+
+			// User-defined limit per block
+			List<Transaction> transactions = newBlock.getTransactions();
+			if (transactions != null && transactions.size() >= limit) {
+				break;
+			}
 		}
 	}

@@ -549,6 +562,9 @@ public class BlockMinter extends Thread {
 			// Sign to create block's signature
 			newBlock.sign();

+			// Ensure online accounts are fully re-validated in this final check
+			newBlock.clearOnlineAccountsValidationCache();
+
 			// Is newBlock still valid?
 			ValidationResult validationResult = newBlock.isValid();
 			if (validationResult != ValidationResult.OK)
--- a/src/main/java/org/qortal/controller/Controller.java
+++ b/src/main/java/org/qortal/controller/Controller.java
@@ -444,6 +444,7 @@ public class Controller extends Thread {
 			if (RepositoryManager.needsTransactionSequenceRebuild(repository)) {
 				// Don't allow the node to start if transaction sequences haven't been built yet
 				// This is needed to handle a case when bootstrapping
+				LOGGER.error("Database upgrade needed. Please restart the core to complete the upgrade process.");
 				Gui.getInstance().fatalError("Database upgrade needed", "Please restart the core to complete the upgrade process.");
 				return;
 			}
@@ -1277,13 +1278,6 @@ public class Controller extends Thread {
 				TransactionImporter.getInstance().onNetworkTransactionSignaturesMessage(peer, message);
 				break;

-			case GET_ONLINE_ACCOUNTS:
-			case ONLINE_ACCOUNTS:
-			case GET_ONLINE_ACCOUNTS_V2:
-			case ONLINE_ACCOUNTS_V2:
-				// No longer supported - to be eventually removed
-				break;
-
 			case GET_ONLINE_ACCOUNTS_V3:
 				OnlineAccountsManager.getInstance().onNetworkGetOnlineAccountsV3Message(peer, message);
 				break;
--- a/src/main/java/org/qortal/controller/DevProxyManager.java
+++ b/src/main/java/org/qortal/controller/DevProxyManager.java
@@ -0,0 +1,74 @@
+package org.qortal.controller;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.qortal.api.DevProxyService;
+import org.qortal.repository.DataException;
+import org.qortal.settings.Settings;
+
+public class DevProxyManager {
+
+    protected static final Logger LOGGER = LogManager.getLogger(DevProxyManager.class);
+
+    private static DevProxyManager instance;
+
+    private boolean running = false;
+
+    private String sourceHostAndPort = "127.0.0.1:5173"; // Default for React/Vite
+
+    private DevProxyManager() {
+
+    }
+
+    public static DevProxyManager getInstance() {
+        if (instance == null)
+            instance = new DevProxyManager();
+
+        return instance;
+    }
+
+    public void start() throws DataException {
+        synchronized(this) {
+            if (this.running) {
+                // Already running
+                return;
+            }
+
+            LOGGER.info(String.format("Starting developer proxy service on port %d", Settings.getInstance().getDevProxyPort()));
+            DevProxyService devProxyService = DevProxyService.getInstance();
+            devProxyService.start();
+            this.running = true;
+        }
+    }
+
+    public void stop() {
+        synchronized(this) {
+            if (!this.running) {
+                // Not running
+                return;
+            }
+
+            LOGGER.info(String.format("Shutting down developer proxy service"));
+            DevProxyService devProxyService = DevProxyService.getInstance();
+            devProxyService.stop();
+            this.running = false;
+        }
+    }
+
+    public void setSourceHostAndPort(String sourceHostAndPort) {
+        this.sourceHostAndPort = sourceHostAndPort;
+    }
+
+    public String getSourceHostAndPort() {
+        return this.sourceHostAndPort;
+    }
+
+    public Integer getPort() {
+        return Settings.getInstance().getDevProxyPort();
+    }
+
+    public boolean isRunning() {
+        return this.running;
+    }
+
+}
--- a/src/main/java/org/qortal/controller/OnlineAccountsManager.java
+++ b/src/main/java/org/qortal/controller/OnlineAccountsManager.java
@@ -414,7 +414,7 @@ public class OnlineAccountsManager {
        boolean isSuperiorEntry = isOnlineAccountsDataSuperior(onlineAccountData);
        if (isSuperiorEntry)
            // Remove existing inferior entry so it can be re-added below (it's likely the existing copy is missing a nonce value)
-            onlineAccounts.remove(onlineAccountData);
+            onlineAccounts.removeIf(a -> Objects.equals(a.getPublicKey(), onlineAccountData.getPublicKey()));

        boolean isNewEntry = onlineAccounts.add(onlineAccountData);

--- a/src/main/java/org/qortal/controller/Synchronizer.java
+++ b/src/main/java/org/qortal/controller/Synchronizer.java
@@ -229,13 +229,6 @@ public class Synchronizer extends Thread {
 		peers.removeIf(Controller.hasOldVersion);

 		checkRecoveryModeForPeers(peers);
-		if (recoveryMode) {
-			// Needs a mutable copy of the unmodifiableList
-			peers = new ArrayList<>(Network.getInstance().getImmutableHandshakedPeers());
-			peers.removeIf(Controller.hasOnlyGenesisBlock);
-			peers.removeIf(Controller.hasMisbehaved);
-			peers.removeIf(Controller.hasOldVersion);
-		}

 		// Check we have enough peers to potentially synchronize
 		if (peers.size() < Settings.getInstance().getMinBlockchainPeers())
@@ -262,10 +255,7 @@ public class Synchronizer extends Thread {
 		peers.removeIf(Controller.hasInferiorChainTip);

 		// Remove any peers that are no longer on a recent block since the last check
-		// Except for times when we're in recovery mode, in which case we need to keep them
-		if (!recoveryMode) {
-			peers.removeIf(Controller.hasNoRecentBlock);
-		}
+		peers.removeIf(Controller.hasNoRecentBlock);

 		final int peersRemoved = peersBeforeComparison - peers.size();
 		if (peersRemoved > 0 && peers.size() > 0)
@@ -1340,8 +1330,8 @@ public class Synchronizer extends Thread {
 				return SynchronizationResult.INVALID_DATA;
 			}

-			// Final check to make sure the peer isn't out of date (except for when we're in recovery mode)
-			if (!recoveryMode && peer.getChainTipData() != null) {
+			// Final check to make sure the peer isn't out of date
+			if (peer.getChainTipData() != null) {
 				final Long minLatestBlockTimestamp = Controller.getMinimumLatestBlockTimestamp();
 				final Long peerLastBlockTimestamp = peer.getChainTipData().getTimestamp();
 				if (peerLastBlockTimestamp == null || peerLastBlockTimestamp < minLatestBlockTimestamp) {
--- a/src/main/java/org/qortal/controller/TransactionImporter.java
+++ b/src/main/java/org/qortal/controller/TransactionImporter.java
@@ -47,6 +47,9 @@ public class TransactionImporter extends Thread {
    /** Map of recent invalid unconfirmed transactions. Key is base58 transaction signature, value is do-not-request expiry timestamp. */
    private final Map<String, Long> invalidUnconfirmedTransactions = Collections.synchronizedMap(new HashMap<>());

+    /** Cached list of unconfirmed transactions, used when counting per creator. This is replaced regularly */
+    public static List<TransactionData> unconfirmedTransactionsCache = null;
+

    public static synchronized TransactionImporter getInstance() {
        if (instance == null) {
@@ -215,12 +218,6 @@ public class TransactionImporter extends Thread {
                LOGGER.debug("Finished validating signatures in incoming transactions queue (valid this round: {}, total pending import: {})...", validatedCount, sigValidTransactions.size());
            }

-            if (!newlyValidSignatures.isEmpty()) {
-                LOGGER.debug("Broadcasting {} newly valid signatures ahead of import", newlyValidSignatures.size());
-                Message newTransactionSignatureMessage = new TransactionSignaturesMessage(newlyValidSignatures);
-                Network.getInstance().broadcast(broadcastPeer -> newTransactionSignatureMessage);
-            }
-
        } catch (DataException e) {
            LOGGER.error("Repository issue while processing incoming transactions", e);
        }
@@ -254,6 +251,15 @@ public class TransactionImporter extends Thread {
        int processedCount = 0;
        try (final Repository repository = RepositoryManager.getRepository()) {

+            // Use a single copy of the unconfirmed transactions list for each cycle, to speed up constant lookups
+            // when counting unconfirmed transactions by creator.
+            List<TransactionData> unconfirmedTransactions = repository.getTransactionRepository().getUnconfirmedTransactions();
+            unconfirmedTransactions.removeIf(t -> t.getType() == Transaction.TransactionType.CHAT);
+            unconfirmedTransactionsCache = unconfirmedTransactions;
+
+            // A list of signatures were imported in this round
+            List<byte[]> newlyImportedSignatures = new ArrayList<>();
+
            // Import transactions with valid signatures
            try {
                for (int i = 0; i < sigValidTransactions.size(); ++i) {
@@ -286,6 +292,15 @@ public class TransactionImporter extends Thread {

                        case OK: {
                            LOGGER.debug(() -> String.format("Imported %s transaction %s", transactionData.getType().name(), Base58.encode(transactionData.getSignature())));
+
+                            // Add to the unconfirmed transactions cache
+                            if (transactionData.getType() != Transaction.TransactionType.CHAT && unconfirmedTransactionsCache != null) {
+                                unconfirmedTransactionsCache.add(transactionData);
+                            }
+
+                            // Signature imported in this round
+                            newlyImportedSignatures.add(transactionData.getSignature());
+
                            break;
                        }

@@ -314,9 +329,18 @@ public class TransactionImporter extends Thread {
                    // Transaction has been processed, even if only to reject it
                    removeIncomingTransaction(transactionData.getSignature());
                }
+
+                if (!newlyImportedSignatures.isEmpty()) {
+                    LOGGER.debug("Broadcasting {} newly imported signatures", newlyImportedSignatures.size());
+                    Message newTransactionSignatureMessage = new TransactionSignaturesMessage(newlyImportedSignatures);
+                    Network.getInstance().broadcast(broadcastPeer -> newTransactionSignatureMessage);
+                }
            } finally {
                LOGGER.debug("Finished importing {} incoming transaction{}", processedCount, (processedCount == 1 ? "" : "s"));
                blockchainLock.unlock();
+
+                // Clear the unconfirmed transaction cache so new data can be populated in the next cycle
+                unconfirmedTransactionsCache = null;
            }
        } catch (DataException e) {
            LOGGER.error("Repository issue while importing incoming transactions", e);
--- a/src/main/java/org/qortal/controller/arbitrary/ArbitraryDataManager.java
+++ b/src/main/java/org/qortal/controller/arbitrary/ArbitraryDataManager.java
@@ -275,7 +275,10 @@ public class ArbitraryDataManager extends Thread {
 		int offset = 0;

 		while (!isStopping) {
-			Thread.sleep(1000L);
+			final int minSeconds = 3;
+			final int maxSeconds = 10;
+			final int randomSleepTime = new Random().nextInt((maxSeconds - minSeconds + 1)) + minSeconds;
+			Thread.sleep(randomSleepTime * 1000L);

 			// Any arbitrary transactions we want to fetch data for?
 			try (final Repository repository = RepositoryManager.getRepository()) {
--- a/src/main/java/org/qortal/controller/repository/NamesDatabaseIntegrityCheck.java
+++ b/src/main/java/org/qortal/controller/repository/NamesDatabaseIntegrityCheck.java
@@ -25,7 +25,8 @@ public class NamesDatabaseIntegrityCheck {
            TransactionType.REGISTER_NAME,
            TransactionType.UPDATE_NAME,
            TransactionType.BUY_NAME,
-            TransactionType.SELL_NAME
+            TransactionType.SELL_NAME,
+            TransactionType.CANCEL_SELL_NAME
    );

    private List<TransactionData> nameTransactions = new ArrayList<>();
--- a/src/main/java/org/qortal/controller/tradebot/BitcoinACCTv3TradeBot.java
+++ b/src/main/java/org/qortal/controller/tradebot/BitcoinACCTv3TradeBot.java
@@ -19,6 +19,7 @@ import org.qortal.data.transaction.MessageTransactionData;
 import org.qortal.group.Group;
 import org.qortal.repository.DataException;
 import org.qortal.repository.Repository;
+import org.qortal.repository.RepositoryManager;
 import org.qortal.transaction.DeployAtTransaction;
 import org.qortal.transaction.MessageTransaction;
 import org.qortal.transaction.Transaction.ValidationResult;
@@ -317,20 +318,36 @@ public class BitcoinACCTv3TradeBot implements AcctTradeBot {

 		boolean isMessageAlreadySent = repository.getMessageRepository().exists(tradeBotData.getTradeNativePublicKey(), messageRecipient, messageData);
 		if (!isMessageAlreadySent) {
-			PrivateKeyAccount sender = new PrivateKeyAccount(repository, tradeBotData.getTradePrivateKey());
-			MessageTransaction messageTransaction = MessageTransaction.build(repository, sender, Group.NO_GROUP, messageRecipient, messageData, false, false);
+			// Do this in a new thread so caller doesn't have to wait for computeNonce()
+			// In the unlikely event that the transaction doesn't validate then the buy won't happen and eventually Alice's AT will be refunded
+			new Thread(() -> {
+				try (final Repository threadsRepository = RepositoryManager.getRepository()) {
+					PrivateKeyAccount sender = new PrivateKeyAccount(threadsRepository, tradeBotData.getTradePrivateKey());
+					MessageTransaction messageTransaction = MessageTransaction.build(threadsRepository, sender, Group.NO_GROUP, messageRecipient, messageData, false, false);

-			messageTransaction.computeNonce();
-			messageTransaction.sign(sender);
+					LOGGER.info("Computing nonce at difficulty {} for AT {} and recipient {}", messageTransaction.getPoWDifficulty(), tradeBotData.getAtAddress(), messageRecipient);
+					messageTransaction.computeNonce();
+					MessageTransactionData newMessageTransactionData = (MessageTransactionData) messageTransaction.getTransactionData();
+					LOGGER.info("Computed nonce {} at difficulty {}", newMessageTransactionData.getNonce(), messageTransaction.getPoWDifficulty());
+					messageTransaction.sign(sender);

-			// reset repository state to prevent deadlock
-			repository.discardChanges();
-			ValidationResult result = messageTransaction.importAsUnconfirmed();
+					// reset repository state to prevent deadlock
+					threadsRepository.discardChanges();

-			if (result != ValidationResult.OK) {
-				LOGGER.warn(() -> String.format("Unable to send MESSAGE to Bob's trade-bot %s: %s", messageRecipient, result.name()));
-				return ResponseResult.NETWORK_ISSUE;
-			}
+					if (messageTransaction.isSignatureValid()) {
+						ValidationResult result = messageTransaction.importAsUnconfirmed();
+
+						if (result != ValidationResult.OK) {
+							LOGGER.warn(() -> String.format("Unable to send MESSAGE to Bob's trade-bot %s: %s", messageRecipient, result.name()));
+						}
+					}
+					else {
+						LOGGER.warn(() -> String.format("Unable to send MESSAGE to Bob's trade-bot %s: signature invalid", messageRecipient));
+					}
+				} catch (DataException e) {
+					LOGGER.warn(() -> String.format("Unable to send MESSAGE to Bob's trade-bot %s: %s", messageRecipient, e.getMessage()));
+				}
+			}, "TradeBot response").start();
 		}

 		TradeBot.updateTradeBotState(repository, tradeBotData, () -> String.format("Funding P2SH-A %s. Messaged Bob. Waiting for AT-lock", p2shAddress));
@@ -548,15 +565,25 @@ public class BitcoinACCTv3TradeBot implements AcctTradeBot {
 				PrivateKeyAccount sender = new PrivateKeyAccount(repository, tradeBotData.getTradePrivateKey());
 				MessageTransaction outgoingMessageTransaction = MessageTransaction.build(repository, sender, Group.NO_GROUP, messageRecipient, outgoingMessageData, false, false);

+				LOGGER.info("Computing nonce at difficulty {} for AT {} and recipient {}", outgoingMessageTransaction.getPoWDifficulty(), tradeBotData.getAtAddress(), messageRecipient);
 				outgoingMessageTransaction.computeNonce();
+				MessageTransactionData newMessageTransactionData = (MessageTransactionData) outgoingMessageTransaction.getTransactionData();
+				LOGGER.info("Computed nonce {} at difficulty {}", newMessageTransactionData.getNonce(), outgoingMessageTransaction.getPoWDifficulty());
 				outgoingMessageTransaction.sign(sender);

 				// reset repository state to prevent deadlock
 				repository.discardChanges();
-				ValidationResult result = outgoingMessageTransaction.importAsUnconfirmed();

-				if (result != ValidationResult.OK) {
-					LOGGER.warn(() -> String.format("Unable to send MESSAGE to AT %s: %s", messageRecipient, result.name()));
+				if (outgoingMessageTransaction.isSignatureValid()) {
+					ValidationResult result = outgoingMessageTransaction.importAsUnconfirmed();
+
+					if (result != ValidationResult.OK) {
+						LOGGER.warn(() -> String.format("Unable to send MESSAGE to AT %s: %s", messageRecipient, result.name()));
+						return;
+					}
+				}
+				else {
+					LOGGER.warn(() -> String.format("Unable to send MESSAGE to AT %s: signature invalid", messageRecipient));
 					return;
 				}
 			}
@@ -668,15 +695,25 @@ public class BitcoinACCTv3TradeBot implements AcctTradeBot {
 			PrivateKeyAccount sender = new PrivateKeyAccount(repository, tradeBotData.getTradePrivateKey());
 			MessageTransaction messageTransaction = MessageTransaction.build(repository, sender, Group.NO_GROUP, messageRecipient, messageData, false, false);

+			LOGGER.info("Computing nonce at difficulty {} for AT {} and recipient {}", messageTransaction.getPoWDifficulty(), tradeBotData.getAtAddress(), messageRecipient);
 			messageTransaction.computeNonce();
+			MessageTransactionData newMessageTransactionData = (MessageTransactionData) messageTransaction.getTransactionData();
+			LOGGER.info("Computed nonce {} at difficulty {}", newMessageTransactionData.getNonce(), messageTransaction.getPoWDifficulty());
 			messageTransaction.sign(sender);

 			// Reset repository state to prevent deadlock
 			repository.discardChanges();
-			ValidationResult result = messageTransaction.importAsUnconfirmed();

-			if (result != ValidationResult.OK) {
-				LOGGER.warn(() -> String.format("Unable to send MESSAGE to AT %s: %s", messageRecipient, result.name()));
+			if (messageTransaction.isSignatureValid()) {
+				ValidationResult result = messageTransaction.importAsUnconfirmed();
+
+				if (result != ValidationResult.OK) {
+					LOGGER.warn(() -> String.format("Unable to send MESSAGE to AT %s: %s", messageRecipient, result.name()));
+					return;
+				}
+			}
+			else {
+				LOGGER.warn(() -> String.format("Unable to send MESSAGE to AT %s: signature invalid", messageRecipient));
 				return;
 			}
 		}
--- a/src/main/java/org/qortal/controller/tradebot/DigibyteACCTv3TradeBot.java
+++ b/src/main/java/org/qortal/controller/tradebot/DigibyteACCTv3TradeBot.java
@@ -19,6 +19,7 @@ import org.qortal.data.transaction.MessageTransactionData;
 import org.qortal.group.Group;
 import org.qortal.repository.DataException;
 import org.qortal.repository.Repository;
+import org.qortal.repository.RepositoryManager;
 import org.qortal.transaction.DeployAtTransaction;
 import org.qortal.transaction.MessageTransaction;
 import org.qortal.transaction.Transaction.ValidationResult;
@@ -317,20 +318,36 @@ public class DigibyteACCTv3TradeBot implements AcctTradeBot {

 		boolean isMessageAlreadySent = repository.getMessageRepository().exists(tradeBotData.getTradeNativePublicKey(), messageRecipient, messageData);
 		if (!isMessageAlreadySent) {
-			PrivateKeyAccount sender = new PrivateKeyAccount(repository, tradeBotData.getTradePrivateKey());
-			MessageTransaction messageTransaction = MessageTransaction.build(repository, sender, Group.NO_GROUP, messageRecipient, messageData, false, false);
+			// Do this in a new thread so caller doesn't have to wait for computeNonce()
+			// In the unlikely event that the transaction doesn't validate then the buy won't happen and eventually Alice's AT will be refunded
+			new Thread(() -> {
+				try (final Repository threadsRepository = RepositoryManager.getRepository()) {
+					PrivateKeyAccount sender = new PrivateKeyAccount(threadsRepository, tradeBotData.getTradePrivateKey());
+					MessageTransaction messageTransaction = MessageTransaction.build(threadsRepository, sender, Group.NO_GROUP, messageRecipient, messageData, false, false);

-			messageTransaction.computeNonce();
-			messageTransaction.sign(sender);
+					LOGGER.info("Computing nonce at difficulty {} for AT {} and recipient {}", messageTransaction.getPoWDifficulty(), tradeBotData.getAtAddress(), messageRecipient);
+					messageTransaction.computeNonce();
+					MessageTransactionData newMessageTransactionData = (MessageTransactionData) messageTransaction.getTransactionData();
+					LOGGER.info("Computed nonce {} at difficulty {}", newMessageTransactionData.getNonce(), messageTransaction.getPoWDifficulty());
+					messageTransaction.sign(sender);

-			// reset repository state to prevent deadlock
-			repository.discardChanges();
-			ValidationResult result = messageTransaction.importAsUnconfirmed();
+					// reset repository state to prevent deadlock
+					threadsRepository.discardChanges();

-			if (result != ValidationResult.OK) {
-				LOGGER.warn(() -> String.format("Unable to send MESSAGE to Bob's trade-bot %s: %s", messageRecipient, result.name()));
-				return ResponseResult.NETWORK_ISSUE;
-			}
+					if (messageTransaction.isSignatureValid()) {
+						ValidationResult result = messageTransaction.importAsUnconfirmed();
+
+						if (result != ValidationResult.OK) {
+							LOGGER.warn(() -> String.format("Unable to send MESSAGE to Bob's trade-bot %s: %s", messageRecipient, result.name()));
+						}
+					}
+					else {
+						LOGGER.warn(() -> String.format("Unable to send MESSAGE to Bob's trade-bot %s: signature invalid", messageRecipient));
+					}
+				} catch (DataException e) {
+					LOGGER.warn(() -> String.format("Unable to send MESSAGE to Bob's trade-bot %s: %s", messageRecipient, e.getMessage()));
+				}
+			}, "TradeBot response").start();
 		}

 		TradeBot.updateTradeBotState(repository, tradeBotData, () -> String.format("Funding P2SH-A %s. Messaged Bob. Waiting for AT-lock", p2shAddress));
@@ -548,15 +565,25 @@ public class DigibyteACCTv3TradeBot implements AcctTradeBot {
 				PrivateKeyAccount sender = new PrivateKeyAccount(repository, tradeBotData.getTradePrivateKey());
 				MessageTransaction outgoingMessageTransaction = MessageTransaction.build(repository, sender, Group.NO_GROUP, messageRecipient, outgoingMessageData, false, false);

+				LOGGER.info("Computing nonce at difficulty {} for AT {} and recipient {}", outgoingMessageTransaction.getPoWDifficulty(), tradeBotData.getAtAddress(), messageRecipient);
 				outgoingMessageTransaction.computeNonce();
+				MessageTransactionData newMessageTransactionData = (MessageTransactionData) outgoingMessageTransaction.getTransactionData();
+				LOGGER.info("Computed nonce {} at difficulty {}", newMessageTransactionData.getNonce(), outgoingMessageTransaction.getPoWDifficulty());
 				outgoingMessageTransaction.sign(sender);

 				// reset repository state to prevent deadlock
 				repository.discardChanges();
-				ValidationResult result = outgoingMessageTransaction.importAsUnconfirmed();

-				if (result != ValidationResult.OK) {
-					LOGGER.warn(() -> String.format("Unable to send MESSAGE to AT %s: %s", messageRecipient, result.name()));
+				if (outgoingMessageTransaction.isSignatureValid()) {
+					ValidationResult result = outgoingMessageTransaction.importAsUnconfirmed();
+
+					if (result != ValidationResult.OK) {
+						LOGGER.warn(() -> String.format("Unable to send MESSAGE to AT %s: %s", messageRecipient, result.name()));
+						return;
+					}
+				}
+				else {
+					LOGGER.warn(() -> String.format("Unable to send MESSAGE to AT %s: signature invalid", messageRecipient));
 					return;
 				}
 			}
@@ -668,15 +695,25 @@ public class DigibyteACCTv3TradeBot implements AcctTradeBot {
 			PrivateKeyAccount sender = new PrivateKeyAccount(repository, tradeBotData.getTradePrivateKey());
 			MessageTransaction messageTransaction = MessageTransaction.build(repository, sender, Group.NO_GROUP, messageRecipient, messageData, false, false);

+			LOGGER.info("Computing nonce at difficulty {} for AT {} and recipient {}", messageTransaction.getPoWDifficulty(), tradeBotData.getAtAddress(), messageRecipient);
 			messageTransaction.computeNonce();
+			MessageTransactionData newMessageTransactionData = (MessageTransactionData) messageTransaction.getTransactionData();
+			LOGGER.info("Computed nonce {} at difficulty {}", newMessageTransactionData.getNonce(), messageTransaction.getPoWDifficulty());
 			messageTransaction.sign(sender);

 			// Reset repository state to prevent deadlock
 			repository.discardChanges();
-			ValidationResult result = messageTransaction.importAsUnconfirmed();

-			if (result != ValidationResult.OK) {
-				LOGGER.warn(() -> String.format("Unable to send MESSAGE to AT %s: %s", messageRecipient, result.name()));
+			if (messageTransaction.isSignatureValid()) {
+				ValidationResult result = messageTransaction.importAsUnconfirmed();
+
+				if (result != ValidationResult.OK) {
+					LOGGER.warn(() -> String.format("Unable to send MESSAGE to AT %s: %s", messageRecipient, result.name()));
+					return;
+				}
+			}
+			else {
+				LOGGER.warn(() -> String.format("Unable to send MESSAGE to AT %s: signature invalid", messageRecipient));
 				return;
 			}
 		}
--- a/src/main/java/org/qortal/controller/tradebot/DogecoinACCTv1TradeBot.java
+++ b/src/main/java/org/qortal/controller/tradebot/DogecoinACCTv1TradeBot.java
@@ -19,6 +19,7 @@ import org.qortal.data.transaction.MessageTransactionData;
 import org.qortal.group.Group;
 import org.qortal.repository.DataException;
 import org.qortal.repository.Repository;
+import org.qortal.repository.RepositoryManager;
 import org.qortal.transaction.DeployAtTransaction;
 import org.qortal.transaction.MessageTransaction;
 import org.qortal.transaction.Transaction.ValidationResult;
@@ -317,20 +318,36 @@ public class DogecoinACCTv1TradeBot implements AcctTradeBot {

 		boolean isMessageAlreadySent = repository.getMessageRepository().exists(tradeBotData.getTradeNativePublicKey(), messageRecipient, messageData);
 		if (!isMessageAlreadySent) {
-			PrivateKeyAccount sender = new PrivateKeyAccount(repository, tradeBotData.getTradePrivateKey());
-			MessageTransaction messageTransaction = MessageTransaction.build(repository, sender, Group.NO_GROUP, messageRecipient, messageData, false, false);
+			// Do this in a new thread so caller doesn't have to wait for computeNonce()
+			// In the unlikely event that the transaction doesn't validate then the buy won't happen and eventually Alice's AT will be refunded
+			new Thread(() -> {
+				try (final Repository threadsRepository = RepositoryManager.getRepository()) {
+					PrivateKeyAccount sender = new PrivateKeyAccount(threadsRepository, tradeBotData.getTradePrivateKey());
+					MessageTransaction messageTransaction = MessageTransaction.build(threadsRepository, sender, Group.NO_GROUP, messageRecipient, messageData, false, false);

-			messageTransaction.computeNonce();
-			messageTransaction.sign(sender);
+					LOGGER.info("Computing nonce at difficulty {} for AT {} and recipient {}", messageTransaction.getPoWDifficulty(), tradeBotData.getAtAddress(), messageRecipient);
+					messageTransaction.computeNonce();
+					MessageTransactionData newMessageTransactionData = (MessageTransactionData) messageTransaction.getTransactionData();
+					LOGGER.info("Computed nonce {} at difficulty {}", newMessageTransactionData.getNonce(), messageTransaction.getPoWDifficulty());
+					messageTransaction.sign(sender);

-			// reset repository state to prevent deadlock
-			repository.discardChanges();
-			ValidationResult result = messageTransaction.importAsUnconfirmed();
+					// reset repository state to prevent deadlock
+					threadsRepository.discardChanges();

-			if (result != ValidationResult.OK) {
-				LOGGER.warn(() -> String.format("Unable to send MESSAGE to Bob's trade-bot %s: %s", messageRecipient, result.name()));
-				return ResponseResult.NETWORK_ISSUE;
-			}
+					if (messageTransaction.isSignatureValid()) {
+						ValidationResult result = messageTransaction.importAsUnconfirmed();
+
+						if (result != ValidationResult.OK) {
+							LOGGER.warn(() -> String.format("Unable to send MESSAGE to Bob's trade-bot %s: %s", messageRecipient, result.name()));
+						}
+					}
+					else {
+						LOGGER.warn(() -> String.format("Unable to send MESSAGE to Bob's trade-bot %s: signature invalid", messageRecipient));
+					}
+				} catch (DataException e) {
+					LOGGER.warn(() -> String.format("Unable to send MESSAGE to Bob's trade-bot %s: %s", messageRecipient, e.getMessage()));
+				}
+			}, "TradeBot response").start();
 		}

 		TradeBot.updateTradeBotState(repository, tradeBotData, () -> String.format("Funding P2SH-A %s. Messaged Bob. Waiting for AT-lock", p2shAddress));
@@ -548,15 +565,25 @@ public class DogecoinACCTv1TradeBot implements AcctTradeBot {
 				PrivateKeyAccount sender = new PrivateKeyAccount(repository, tradeBotData.getTradePrivateKey());
 				MessageTransaction outgoingMessageTransaction = MessageTransaction.build(repository, sender, Group.NO_GROUP, messageRecipient, outgoingMessageData, false, false);

+				LOGGER.info("Computing nonce at difficulty {} for AT {} and recipient {}", outgoingMessageTransaction.getPoWDifficulty(), tradeBotData.getAtAddress(), messageRecipient);
 				outgoingMessageTransaction.computeNonce();
+				MessageTransactionData newMessageTransactionData = (MessageTransactionData) outgoingMessageTransaction.getTransactionData();
+				LOGGER.info("Computed nonce {} at difficulty {}", newMessageTransactionData.getNonce(), outgoingMessageTransaction.getPoWDifficulty());
 				outgoingMessageTransaction.sign(sender);

 				// reset repository state to prevent deadlock
 				repository.discardChanges();
-				ValidationResult result = outgoingMessageTransaction.importAsUnconfirmed();

-				if (result != ValidationResult.OK) {
-					LOGGER.warn(() -> String.format("Unable to send MESSAGE to AT %s: %s", messageRecipient, result.name()));
+				if (outgoingMessageTransaction.isSignatureValid()) {
+					ValidationResult result = outgoingMessageTransaction.importAsUnconfirmed();
+
+					if (result != ValidationResult.OK) {
+						LOGGER.warn(() -> String.format("Unable to send MESSAGE to AT %s: %s", messageRecipient, result.name()));
+						return;
+					}
+				}
+				else {
+					LOGGER.warn(() -> String.format("Unable to send MESSAGE to AT %s: signature invalid", messageRecipient));
 					return;
 				}
 			}
@@ -668,15 +695,25 @@ public class DogecoinACCTv1TradeBot implements AcctTradeBot {
 			PrivateKeyAccount sender = new PrivateKeyAccount(repository, tradeBotData.getTradePrivateKey());
 			MessageTransaction messageTransaction = MessageTransaction.build(repository, sender, Group.NO_GROUP, messageRecipient, messageData, false, false);

+			LOGGER.info("Computing nonce at difficulty {} for AT {} and recipient {}", messageTransaction.getPoWDifficulty(), tradeBotData.getAtAddress(), messageRecipient);
 			messageTransaction.computeNonce();
+			MessageTransactionData newMessageTransactionData = (MessageTransactionData) messageTransaction.getTransactionData();
+			LOGGER.info("Computed nonce {} at difficulty {}", newMessageTransactionData.getNonce(), messageTransaction.getPoWDifficulty());
 			messageTransaction.sign(sender);

 			// Reset repository state to prevent deadlock
 			repository.discardChanges();
-			ValidationResult result = messageTransaction.importAsUnconfirmed();

-			if (result != ValidationResult.OK) {
-				LOGGER.warn(() -> String.format("Unable to send MESSAGE to AT %s: %s", messageRecipient, result.name()));
+			if (messageTransaction.isSignatureValid()) {
+				ValidationResult result = messageTransaction.importAsUnconfirmed();
+
+				if (result != ValidationResult.OK) {
+					LOGGER.warn(() -> String.format("Unable to send MESSAGE to AT %s: %s", messageRecipient, result.name()));
+					return;
+				}
+			}
+			else {
+				LOGGER.warn(() -> String.format("Unable to send MESSAGE to AT %s: signature invalid", messageRecipient));
 				return;
 			}
 		}
--- a/src/main/java/org/qortal/controller/tradebot/DogecoinACCTv3TradeBot.java
+++ b/src/main/java/org/qortal/controller/tradebot/DogecoinACCTv3TradeBot.java
@@ -19,6 +19,7 @@ import org.qortal.data.transaction.MessageTransactionData;
 import org.qortal.group.Group;
 import org.qortal.repository.DataException;
 import org.qortal.repository.Repository;
+import org.qortal.repository.RepositoryManager;
 import org.qortal.transaction.DeployAtTransaction;
 import org.qortal.transaction.MessageTransaction;
 import org.qortal.transaction.Transaction.ValidationResult;
@@ -317,20 +318,36 @@ public class DogecoinACCTv3TradeBot implements AcctTradeBot {

 		boolean isMessageAlreadySent = repository.getMessageRepository().exists(tradeBotData.getTradeNativePublicKey(), messageRecipient, messageData);
 		if (!isMessageAlreadySent) {
-			PrivateKeyAccount sender = new PrivateKeyAccount(repository, tradeBotData.getTradePrivateKey());
-			MessageTransaction messageTransaction = MessageTransaction.build(repository, sender, Group.NO_GROUP, messageRecipient, messageData, false, false);
+			// Do this in a new thread so caller doesn't have to wait for computeNonce()
+			// In the unlikely event that the transaction doesn't validate then the buy won't happen and eventually Alice's AT will be refunded
+			new Thread(() -> {
+				try (final Repository threadsRepository = RepositoryManager.getRepository()) {
+					PrivateKeyAccount sender = new PrivateKeyAccount(threadsRepository, tradeBotData.getTradePrivateKey());
+					MessageTransaction messageTransaction = MessageTransaction.build(threadsRepository, sender, Group.NO_GROUP, messageRecipient, messageData, false, false);

-			messageTransaction.computeNonce();
-			messageTransaction.sign(sender);
+					LOGGER.info("Computing nonce at difficulty {} for AT {} and recipient {}", messageTransaction.getPoWDifficulty(), tradeBotData.getAtAddress(), messageRecipient);
+					messageTransaction.computeNonce();
+					MessageTransactionData newMessageTransactionData = (MessageTransactionData) messageTransaction.getTransactionData();
+					LOGGER.info("Computed nonce {} at difficulty {}", newMessageTransactionData.getNonce(), messageTransaction.getPoWDifficulty());
+					messageTransaction.sign(sender);

-			// reset repository state to prevent deadlock
-			repository.discardChanges();
-			ValidationResult result = messageTransaction.importAsUnconfirmed();
+					// reset repository state to prevent deadlock
+					threadsRepository.discardChanges();

-			if (result != ValidationResult.OK) {
-				LOGGER.warn(() -> String.format("Unable to send MESSAGE to Bob's trade-bot %s: %s", messageRecipient, result.name()));
-				return ResponseResult.NETWORK_ISSUE;
-			}
+					if (messageTransaction.isSignatureValid()) {
+						ValidationResult result = messageTransaction.importAsUnconfirmed();
+
+						if (result != ValidationResult.OK) {
+							LOGGER.warn(() -> String.format("Unable to send MESSAGE to Bob's trade-bot %s: %s", messageRecipient, result.name()));
+						}
+					}
+					else {
+						LOGGER.warn(() -> String.format("Unable to send MESSAGE to Bob's trade-bot %s: signature invalid", messageRecipient));
+					}
+				} catch (DataException e) {
+					LOGGER.warn(() -> String.format("Unable to send MESSAGE to Bob's trade-bot %s: %s", messageRecipient, e.getMessage()));
+				}
+			}, "TradeBot response").start();
 		}

 		TradeBot.updateTradeBotState(repository, tradeBotData, () -> String.format("Funding P2SH-A %s. Messaged Bob. Waiting for AT-lock", p2shAddress));
@@ -548,15 +565,25 @@ public class DogecoinACCTv3TradeBot implements AcctTradeBot {
 				PrivateKeyAccount sender = new PrivateKeyAccount(repository, tradeBotData.getTradePrivateKey());
 				MessageTransaction outgoingMessageTransaction = MessageTransaction.build(repository, sender, Group.NO_GROUP, messageRecipient, outgoingMessageData, false, false);

+				LOGGER.info("Computing nonce at difficulty {} for AT {} and recipient {}", outgoingMessageTransaction.getPoWDifficulty(), tradeBotData.getAtAddress(), messageRecipient);
 				outgoingMessageTransaction.computeNonce();
+				MessageTransactionData newMessageTransactionData = (MessageTransactionData) outgoingMessageTransaction.getTransactionData();
+				LOGGER.info("Computed nonce {} at difficulty {}", newMessageTransactionData.getNonce(), outgoingMessageTransaction.getPoWDifficulty());
 				outgoingMessageTransaction.sign(sender);

 				// reset repository state to prevent deadlock
 				repository.discardChanges();
-				ValidationResult result = outgoingMessageTransaction.importAsUnconfirmed();

-				if (result != ValidationResult.OK) {
-					LOGGER.warn(() -> String.format("Unable to send MESSAGE to AT %s: %s", messageRecipient, result.name()));
+				if (outgoingMessageTransaction.isSignatureValid()) {
+					ValidationResult result = outgoingMessageTransaction.importAsUnconfirmed();
+
+					if (result != ValidationResult.OK) {
+						LOGGER.warn(() -> String.format("Unable to send MESSAGE to AT %s: %s", messageRecipient, result.name()));
+						return;
+					}
+				}
+				else {
+					LOGGER.warn(() -> String.format("Unable to send MESSAGE to AT %s: signature invalid", messageRecipient));
 					return;
 				}
 			}
@@ -668,15 +695,25 @@ public class DogecoinACCTv3TradeBot implements AcctTradeBot {
 			PrivateKeyAccount sender = new PrivateKeyAccount(repository, tradeBotData.getTradePrivateKey());
 			MessageTransaction messageTransaction = MessageTransaction.build(repository, sender, Group.NO_GROUP, messageRecipient, messageData, false, false);

+			LOGGER.info("Computing nonce at difficulty {} for AT {} and recipient {}", messageTransaction.getPoWDifficulty(), tradeBotData.getAtAddress(), messageRecipient);
 			messageTransaction.computeNonce();
+			MessageTransactionData newMessageTransactionData = (MessageTransactionData) messageTransaction.getTransactionData();
+			LOGGER.info("Computed nonce {} at difficulty {}", newMessageTransactionData.getNonce(), messageTransaction.getPoWDifficulty());
 			messageTransaction.sign(sender);

 			// Reset repository state to prevent deadlock
 			repository.discardChanges();
-			ValidationResult result = messageTransaction.importAsUnconfirmed();

-			if (result != ValidationResult.OK) {
-				LOGGER.warn(() -> String.format("Unable to send MESSAGE to AT %s: %s", messageRecipient, result.name()));
+			if (messageTransaction.isSignatureValid()) {
+				ValidationResult result = messageTransaction.importAsUnconfirmed();
+
+				if (result != ValidationResult.OK) {
+					LOGGER.warn(() -> String.format("Unable to send MESSAGE to AT %s: %s", messageRecipient, result.name()));
+					return;
+				}
+			}
+			else {
+				LOGGER.warn(() -> String.format("Unable to send MESSAGE to AT %s: signature invalid", messageRecipient));
 				return;
 			}
 		}
--- a/src/main/java/org/qortal/controller/tradebot/LitecoinACCTv3TradeBot.java
+++ b/src/main/java/org/qortal/controller/tradebot/LitecoinACCTv3TradeBot.java
@@ -325,15 +325,24 @@ public class LitecoinACCTv3TradeBot implements AcctTradeBot {
 					PrivateKeyAccount sender = new PrivateKeyAccount(threadsRepository, tradeBotData.getTradePrivateKey());
 					MessageTransaction messageTransaction = MessageTransaction.build(threadsRepository, sender, Group.NO_GROUP, messageRecipient, messageData, false, false);

+					LOGGER.info("Computing nonce at difficulty {} for AT {} and recipient {}", messageTransaction.getPoWDifficulty(), tradeBotData.getAtAddress(), messageRecipient);
 					messageTransaction.computeNonce();
+					MessageTransactionData newMessageTransactionData = (MessageTransactionData) messageTransaction.getTransactionData();
+					LOGGER.info("Computed nonce {} at difficulty {}", newMessageTransactionData.getNonce(), messageTransaction.getPoWDifficulty());
 					messageTransaction.sign(sender);

 					// reset repository state to prevent deadlock
 					threadsRepository.discardChanges();
-					ValidationResult result = messageTransaction.importAsUnconfirmed();

-					if (result != ValidationResult.OK) {
-						LOGGER.warn(() -> String.format("Unable to send MESSAGE to Bob's trade-bot %s: %s", messageRecipient, result.name()));
+					if (messageTransaction.isSignatureValid()) {
+						ValidationResult result = messageTransaction.importAsUnconfirmed();
+
+						if (result != ValidationResult.OK) {
+							LOGGER.warn(() -> String.format("Unable to send MESSAGE to Bob's trade-bot %s: %s", messageRecipient, result.name()));
+						}
+					}
+					else {
+						LOGGER.warn(() -> String.format("Unable to send MESSAGE to Bob's trade-bot %s: signature invalid", messageRecipient));
 					}
 				} catch (DataException e) {
 					LOGGER.warn(() -> String.format("Unable to send MESSAGE to Bob's trade-bot %s: %s", messageRecipient, e.getMessage()));
@@ -556,15 +565,25 @@ public class LitecoinACCTv3TradeBot implements AcctTradeBot {
 				PrivateKeyAccount sender = new PrivateKeyAccount(repository, tradeBotData.getTradePrivateKey());
 				MessageTransaction outgoingMessageTransaction = MessageTransaction.build(repository, sender, Group.NO_GROUP, messageRecipient, outgoingMessageData, false, false);

+				LOGGER.info("Computing nonce at difficulty {} for AT {} and recipient {}", outgoingMessageTransaction.getPoWDifficulty(), tradeBotData.getAtAddress(), messageRecipient);
 				outgoingMessageTransaction.computeNonce();
+				MessageTransactionData newMessageTransactionData = (MessageTransactionData) outgoingMessageTransaction.getTransactionData();
+				LOGGER.info("Computed nonce {} at difficulty {}", newMessageTransactionData.getNonce(), outgoingMessageTransaction.getPoWDifficulty());
 				outgoingMessageTransaction.sign(sender);

 				// reset repository state to prevent deadlock
 				repository.discardChanges();
-				ValidationResult result = outgoingMessageTransaction.importAsUnconfirmed();

-				if (result != ValidationResult.OK) {
-					LOGGER.warn(() -> String.format("Unable to send MESSAGE to AT %s: %s", messageRecipient, result.name()));
+				if (outgoingMessageTransaction.isSignatureValid()) {
+					ValidationResult result = outgoingMessageTransaction.importAsUnconfirmed();
+
+					if (result != ValidationResult.OK) {
+						LOGGER.warn(() -> String.format("Unable to send MESSAGE to AT %s: %s", messageRecipient, result.name()));
+						return;
+					}
+				}
+				else {
+					LOGGER.warn(() -> String.format("Unable to send MESSAGE to AT %s: signature invalid", messageRecipient));
 					return;
 				}
 			}
@@ -676,15 +695,25 @@ public class LitecoinACCTv3TradeBot implements AcctTradeBot {
 			PrivateKeyAccount sender = new PrivateKeyAccount(repository, tradeBotData.getTradePrivateKey());
 			MessageTransaction messageTransaction = MessageTransaction.build(repository, sender, Group.NO_GROUP, messageRecipient, messageData, false, false);

+			LOGGER.info("Computing nonce at difficulty {} for AT {} and recipient {}", messageTransaction.getPoWDifficulty(), tradeBotData.getAtAddress(), messageRecipient);
 			messageTransaction.computeNonce();
+			MessageTransactionData newMessageTransactionData = (MessageTransactionData) messageTransaction.getTransactionData();
+			LOGGER.info("Computed nonce {} at difficulty {}", newMessageTransactionData.getNonce(), messageTransaction.getPoWDifficulty());
 			messageTransaction.sign(sender);

 			// Reset repository state to prevent deadlock
 			repository.discardChanges();
-			ValidationResult result = messageTransaction.importAsUnconfirmed();

-			if (result != ValidationResult.OK) {
-				LOGGER.warn(() -> String.format("Unable to send MESSAGE to AT %s: %s", messageRecipient, result.name()));
+			if (messageTransaction.isSignatureValid()) {
+				ValidationResult result = messageTransaction.importAsUnconfirmed();
+
+				if (result != ValidationResult.OK) {
+					LOGGER.warn(() -> String.format("Unable to send MESSAGE to AT %s: %s", messageRecipient, result.name()));
+					return;
+				}
+			}
+			else {
+				LOGGER.warn(() -> String.format("Unable to send MESSAGE to AT %s: signature invalid", messageRecipient));
 				return;
 			}
 		}
--- a/src/main/java/org/qortal/controller/tradebot/PirateChainACCTv3TradeBot.java
+++ b/src/main/java/org/qortal/controller/tradebot/PirateChainACCTv3TradeBot.java
@@ -20,6 +20,7 @@ import org.qortal.data.transaction.MessageTransactionData;
 import org.qortal.group.Group;
 import org.qortal.repository.DataException;
 import org.qortal.repository.Repository;
+import org.qortal.repository.RepositoryManager;
 import org.qortal.transaction.DeployAtTransaction;
 import org.qortal.transaction.MessageTransaction;
 import org.qortal.transaction.Transaction.ValidationResult;
@@ -320,20 +321,36 @@ public class PirateChainACCTv3TradeBot implements AcctTradeBot {

 		boolean isMessageAlreadySent = repository.getMessageRepository().exists(tradeBotData.getTradeNativePublicKey(), messageRecipient, messageData);
 		if (!isMessageAlreadySent) {
-			PrivateKeyAccount sender = new PrivateKeyAccount(repository, tradeBotData.getTradePrivateKey());
-			MessageTransaction messageTransaction = MessageTransaction.build(repository, sender, Group.NO_GROUP, messageRecipient, messageData, false, false);
+			// Do this in a new thread so caller doesn't have to wait for computeNonce()
+			// In the unlikely event that the transaction doesn't validate then the buy won't happen and eventually Alice's AT will be refunded
+			new Thread(() -> {
+				try (final Repository threadsRepository = RepositoryManager.getRepository()) {
+					PrivateKeyAccount sender = new PrivateKeyAccount(threadsRepository, tradeBotData.getTradePrivateKey());
+					MessageTransaction messageTransaction = MessageTransaction.build(threadsRepository, sender, Group.NO_GROUP, messageRecipient, messageData, false, false);

-			messageTransaction.computeNonce();
-			messageTransaction.sign(sender);
+					LOGGER.info("Computing nonce at difficulty {} for AT {} and recipient {}", messageTransaction.getPoWDifficulty(), tradeBotData.getAtAddress(), messageRecipient);
+					messageTransaction.computeNonce();
+					MessageTransactionData newMessageTransactionData = (MessageTransactionData) messageTransaction.getTransactionData();
+					LOGGER.info("Computed nonce {} at difficulty {}", newMessageTransactionData.getNonce(), messageTransaction.getPoWDifficulty());
+					messageTransaction.sign(sender);

-			// reset repository state to prevent deadlock
-			repository.discardChanges();
-			ValidationResult result = messageTransaction.importAsUnconfirmed();
+					// reset repository state to prevent deadlock
+					threadsRepository.discardChanges();

-			if (result != ValidationResult.OK) {
-				LOGGER.warn(() -> String.format("Unable to send MESSAGE to Bob's trade-bot %s: %s", messageRecipient, result.name()));
-				return ResponseResult.NETWORK_ISSUE;
-			}
+					if (messageTransaction.isSignatureValid()) {
+						ValidationResult result = messageTransaction.importAsUnconfirmed();
+
+						if (result != ValidationResult.OK) {
+							LOGGER.warn(() -> String.format("Unable to send MESSAGE to Bob's trade-bot %s: %s", messageRecipient, result.name()));
+						}
+					}
+					else {
+						LOGGER.warn(() -> String.format("Unable to send MESSAGE to Bob's trade-bot %s: signature invalid", messageRecipient));
+					}
+				} catch (DataException e) {
+					LOGGER.warn(() -> String.format("Unable to send MESSAGE to Bob's trade-bot %s: %s", messageRecipient, e.getMessage()));
+				}
+			}, "TradeBot response").start();
 		}

 		TradeBot.updateTradeBotState(repository, tradeBotData, () -> String.format("Funding P2SH-A %s. Messaged Bob. Waiting for AT-lock", p2shAddressT3));
@@ -561,15 +578,25 @@ public class PirateChainACCTv3TradeBot implements AcctTradeBot {
 				PrivateKeyAccount sender = new PrivateKeyAccount(repository, tradeBotData.getTradePrivateKey());
 				MessageTransaction outgoingMessageTransaction = MessageTransaction.build(repository, sender, Group.NO_GROUP, messageRecipient, outgoingMessageData, false, false);

+				LOGGER.info("Computing nonce at difficulty {} for AT {} and recipient {}", outgoingMessageTransaction.getPoWDifficulty(), tradeBotData.getAtAddress(), messageRecipient);
 				outgoingMessageTransaction.computeNonce();
+				MessageTransactionData newMessageTransactionData = (MessageTransactionData) outgoingMessageTransaction.getTransactionData();
+				LOGGER.info("Computed nonce {} at difficulty {}", newMessageTransactionData.getNonce(), outgoingMessageTransaction.getPoWDifficulty());
 				outgoingMessageTransaction.sign(sender);

 				// reset repository state to prevent deadlock
 				repository.discardChanges();
-				ValidationResult result = outgoingMessageTransaction.importAsUnconfirmed();

-				if (result != ValidationResult.OK) {
-					LOGGER.warn(() -> String.format("Unable to send MESSAGE to AT %s: %s", messageRecipient, result.name()));
+				if (outgoingMessageTransaction.isSignatureValid()) {
+					ValidationResult result = outgoingMessageTransaction.importAsUnconfirmed();
+
+					if (result != ValidationResult.OK) {
+						LOGGER.warn(() -> String.format("Unable to send MESSAGE to AT %s: %s", messageRecipient, result.name()));
+						return;
+					}
+				}
+				else {
+					LOGGER.warn(() -> String.format("Unable to send MESSAGE to AT %s: signature invalid", messageRecipient));
 					return;
 				}
 			}
@@ -681,15 +708,25 @@ public class PirateChainACCTv3TradeBot implements AcctTradeBot {
 			PrivateKeyAccount sender = new PrivateKeyAccount(repository, tradeBotData.getTradePrivateKey());
 			MessageTransaction messageTransaction = MessageTransaction.build(repository, sender, Group.NO_GROUP, messageRecipient, messageData, false, false);

+			LOGGER.info("Computing nonce at difficulty {} for AT {} and recipient {}", messageTransaction.getPoWDifficulty(), tradeBotData.getAtAddress(), messageRecipient);
 			messageTransaction.computeNonce();
+			MessageTransactionData newMessageTransactionData = (MessageTransactionData) messageTransaction.getTransactionData();
+			LOGGER.info("Computed nonce {} at difficulty {}", newMessageTransactionData.getNonce(), messageTransaction.getPoWDifficulty());
 			messageTransaction.sign(sender);

 			// Reset repository state to prevent deadlock
 			repository.discardChanges();
-			ValidationResult result = messageTransaction.importAsUnconfirmed();

-			if (result != ValidationResult.OK) {
-				LOGGER.warn(() -> String.format("Unable to send MESSAGE to AT %s: %s", messageRecipient, result.name()));
+			if (messageTransaction.isSignatureValid()) {
+				ValidationResult result = messageTransaction.importAsUnconfirmed();
+
+				if (result != ValidationResult.OK) {
+					LOGGER.warn(() -> String.format("Unable to send MESSAGE to AT %s: %s", messageRecipient, result.name()));
+					return;
+				}
+			}
+			else {
+				LOGGER.warn(() -> String.format("Unable to send MESSAGE to AT %s: signature invalid", messageRecipient));
 				return;
 			}
 		}
--- a/src/main/java/org/qortal/controller/tradebot/RavencoinACCTv3TradeBot.java
+++ b/src/main/java/org/qortal/controller/tradebot/RavencoinACCTv3TradeBot.java
@@ -19,6 +19,7 @@ import org.qortal.data.transaction.MessageTransactionData;
 import org.qortal.group.Group;
 import org.qortal.repository.DataException;
 import org.qortal.repository.Repository;
+import org.qortal.repository.RepositoryManager;
 import org.qortal.transaction.DeployAtTransaction;
 import org.qortal.transaction.MessageTransaction;
 import org.qortal.transaction.Transaction.ValidationResult;
@@ -317,20 +318,36 @@ public class RavencoinACCTv3TradeBot implements AcctTradeBot {

 		boolean isMessageAlreadySent = repository.getMessageRepository().exists(tradeBotData.getTradeNativePublicKey(), messageRecipient, messageData);
 		if (!isMessageAlreadySent) {
-			PrivateKeyAccount sender = new PrivateKeyAccount(repository, tradeBotData.getTradePrivateKey());
-			MessageTransaction messageTransaction = MessageTransaction.build(repository, sender, Group.NO_GROUP, messageRecipient, messageData, false, false);
+			// Do this in a new thread so caller doesn't have to wait for computeNonce()
+			// In the unlikely event that the transaction doesn't validate then the buy won't happen and eventually Alice's AT will be refunded
+			new Thread(() -> {
+				try (final Repository threadsRepository = RepositoryManager.getRepository()) {
+					PrivateKeyAccount sender = new PrivateKeyAccount(threadsRepository, tradeBotData.getTradePrivateKey());
+					MessageTransaction messageTransaction = MessageTransaction.build(threadsRepository, sender, Group.NO_GROUP, messageRecipient, messageData, false, false);

-			messageTransaction.computeNonce();
-			messageTransaction.sign(sender);
+					LOGGER.info("Computing nonce at difficulty {} for AT {} and recipient {}", messageTransaction.getPoWDifficulty(), tradeBotData.getAtAddress(), messageRecipient);
+					messageTransaction.computeNonce();
+					MessageTransactionData newMessageTransactionData = (MessageTransactionData) messageTransaction.getTransactionData();
+					LOGGER.info("Computed nonce {} at difficulty {}", newMessageTransactionData.getNonce(), messageTransaction.getPoWDifficulty());
+					messageTransaction.sign(sender);

-			// reset repository state to prevent deadlock
-			repository.discardChanges();
-			ValidationResult result = messageTransaction.importAsUnconfirmed();
+					// reset repository state to prevent deadlock
+					threadsRepository.discardChanges();

-			if (result != ValidationResult.OK) {
-				LOGGER.warn(() -> String.format("Unable to send MESSAGE to Bob's trade-bot %s: %s", messageRecipient, result.name()));
-				return ResponseResult.NETWORK_ISSUE;
-			}
+					if (messageTransaction.isSignatureValid()) {
+						ValidationResult result = messageTransaction.importAsUnconfirmed();
+
+						if (result != ValidationResult.OK) {
+							LOGGER.warn(() -> String.format("Unable to send MESSAGE to Bob's trade-bot %s: %s", messageRecipient, result.name()));
+						}
+					}
+					else {
+						LOGGER.warn(() -> String.format("Unable to send MESSAGE to Bob's trade-bot %s: signature invalid", messageRecipient));
+					}
+				} catch (DataException e) {
+					LOGGER.warn(() -> String.format("Unable to send MESSAGE to Bob's trade-bot %s: %s", messageRecipient, e.getMessage()));
+				}
+			}, "TradeBot response").start();
 		}

 		TradeBot.updateTradeBotState(repository, tradeBotData, () -> String.format("Funding P2SH-A %s. Messaged Bob. Waiting for AT-lock", p2shAddress));
@@ -548,15 +565,25 @@ public class RavencoinACCTv3TradeBot implements AcctTradeBot {
 				PrivateKeyAccount sender = new PrivateKeyAccount(repository, tradeBotData.getTradePrivateKey());
 				MessageTransaction outgoingMessageTransaction = MessageTransaction.build(repository, sender, Group.NO_GROUP, messageRecipient, outgoingMessageData, false, false);

+				LOGGER.info("Computing nonce at difficulty {} for AT {} and recipient {}", outgoingMessageTransaction.getPoWDifficulty(), tradeBotData.getAtAddress(), messageRecipient);
 				outgoingMessageTransaction.computeNonce();
+				MessageTransactionData newMessageTransactionData = (MessageTransactionData) outgoingMessageTransaction.getTransactionData();
+				LOGGER.info("Computed nonce {} at difficulty {}", newMessageTransactionData.getNonce(), outgoingMessageTransaction.getPoWDifficulty());
 				outgoingMessageTransaction.sign(sender);

 				// reset repository state to prevent deadlock
 				repository.discardChanges();
-				ValidationResult result = outgoingMessageTransaction.importAsUnconfirmed();

-				if (result != ValidationResult.OK) {
-					LOGGER.warn(() -> String.format("Unable to send MESSAGE to AT %s: %s", messageRecipient, result.name()));
+				if (outgoingMessageTransaction.isSignatureValid()) {
+					ValidationResult result = outgoingMessageTransaction.importAsUnconfirmed();
+
+					if (result != ValidationResult.OK) {
+						LOGGER.warn(() -> String.format("Unable to send MESSAGE to AT %s: %s", messageRecipient, result.name()));
+						return;
+					}
+				}
+				else {
+					LOGGER.warn(() -> String.format("Unable to send MESSAGE to AT %s: signature invalid", messageRecipient));
 					return;
 				}
 			}
@@ -668,15 +695,25 @@ public class RavencoinACCTv3TradeBot implements AcctTradeBot {
 			PrivateKeyAccount sender = new PrivateKeyAccount(repository, tradeBotData.getTradePrivateKey());
 			MessageTransaction messageTransaction = MessageTransaction.build(repository, sender, Group.NO_GROUP, messageRecipient, messageData, false, false);

+			LOGGER.info("Computing nonce at difficulty {} for AT {} and recipient {}", messageTransaction.getPoWDifficulty(), tradeBotData.getAtAddress(), messageRecipient);
 			messageTransaction.computeNonce();
+			MessageTransactionData newMessageTransactionData = (MessageTransactionData) messageTransaction.getTransactionData();
+			LOGGER.info("Computed nonce {} at difficulty {}", newMessageTransactionData.getNonce(), messageTransaction.getPoWDifficulty());
 			messageTransaction.sign(sender);

 			// Reset repository state to prevent deadlock
 			repository.discardChanges();
-			ValidationResult result = messageTransaction.importAsUnconfirmed();

-			if (result != ValidationResult.OK) {
-				LOGGER.warn(() -> String.format("Unable to send MESSAGE to AT %s: %s", messageRecipient, result.name()));
+			if (messageTransaction.isSignatureValid()) {
+				ValidationResult result = messageTransaction.importAsUnconfirmed();
+
+				if (result != ValidationResult.OK) {
+					LOGGER.warn(() -> String.format("Unable to send MESSAGE to AT %s: %s", messageRecipient, result.name()));
+					return;
+				}
+			}
+			else {
+				LOGGER.warn(() -> String.format("Unable to send MESSAGE to AT %s: signature invalid", messageRecipient));
 				return;
 			}
 		}
--- a/src/main/java/org/qortal/controller/tradebot/TradeBot.java
+++ b/src/main/java/org/qortal/controller/tradebot/TradeBot.java
@@ -333,7 +333,7 @@ public class TradeBot implements Listener {
 			SysTray.getInstance().showMessage("Trade-Bot", String.format("%s: %s", tradeBotData.getAtAddress(), newState), MessageType.INFO);

 		if (logMessageSupplier != null)
-			LOGGER.info(logMessageSupplier);
+			LOGGER.info(logMessageSupplier.get());

 		LOGGER.debug(() -> String.format("new state for trade-bot entry based on AT %s: %s", tradeBotData.getAtAddress(), newState));

@@ -712,30 +712,16 @@ public class TradeBot implements Listener {
 			}

 			try {
-				List<byte[]> signatures = repository.getTransactionRepository().getSignaturesMatchingCriteria(null, null, null, Arrays.asList(Transaction.TransactionType.MESSAGE), null, null, crossChainTradeData.qortalCreatorTradeAddress, TransactionsResource.ConfirmationStatus.CONFIRMED, null, null, null);
-				if (signatures.size() < getMaxTradeOfferAttempts) {
-					// Less than 3 (or user-specified number of) MESSAGE transactions relate to this trade, so assume it is ok
-					validTrades.put(crossChainTradeData.qortalAtAddress, now);
-					continue;
-				}
+				List<TransactionData> transactions = repository.getTransactionRepository().getUnconfirmedTransactions(Arrays.asList(Transaction.TransactionType.MESSAGE), null, null, null, null);

-				List<TransactionData> transactions = new ArrayList<>(signatures.size());
-				for (byte[] signature : signatures) {
-					transactions.add(repository.getTransactionRepository().fromSignature(signature));
-				}
-				transactions.sort(Transaction.getDataComparator());
-
-				// Get timestamp of the first MESSAGE transaction
-				long firstMessageTimestamp = transactions.get(0).getTimestamp();
-
-				// Treat as failed if first buy attempt was more than 60 mins ago (as it's still in the OFFERING state)
-				boolean isFailed = (now - firstMessageTimestamp > 60*60*1000L);
-				if (isFailed) {
-					failedTrades.put(crossChainTradeData.qortalAtAddress, now);
-					updatedCrossChainTrades.remove(crossChainTradeData);
-				}
-				else {
-					validTrades.put(crossChainTradeData.qortalAtAddress, now);
+				for (TransactionData transactionData : transactions) {
+					// Treat as failed if buy attempt was more than 60 mins ago (as it's still in the OFFERING state)
+					if (transactionData.getRecipient().equals(crossChainTradeData.qortalCreatorTradeAddress) && now - transactionData.getTimestamp() > 60*60*1000L) {
+						failedTrades.put(crossChainTradeData.qortalAtAddress, now);
+						updatedCrossChainTrades.remove(crossChainTradeData);
+					} else {
+						validTrades.put(crossChainTradeData.qortalAtAddress, now);
+					}
 				}

 			} catch (DataException e) {
--- a/src/main/java/org/qortal/crosschain/Bitcoin.java
+++ b/src/main/java/org/qortal/crosschain/Bitcoin.java
@@ -44,89 +44,78 @@ public class Bitcoin extends Bitcoiny {
 			@Override
 			public Collection<ElectrumX.Server> getServers() {
 				return Arrays.asList(
-						// Servers chosen on NO BASIS WHATSOEVER from various sources!
-						// Status verified at https://1209k.com/bitcoin-eye/ele.php?chain=btc
-						//CLOSED new Server("bitcoin.grey.pw", Server.ConnectionType.SSL, 50002),
-						//CLOSED new Server("btc.litepay.ch", Server.ConnectionType.SSL, 50002),
-						//CLOSED new Server("electrum.pabu.io", Server.ConnectionType.SSL, 50002),
-						//CLOSED new Server("electrumx.dev", Server.ConnectionType.SSL, 50002),
-						//CLOSED new Server("electrumx.hodlwallet.com", Server.ConnectionType.SSL, 50002),
-						//CLOSED new Server("gd42.org", Server.ConnectionType.SSL, 50002),
-						//CLOSED new Server("korea.electrum-server.com", Server.ConnectionType.SSL, 50002),
-						//CLOSED new Server("prospero.bitsrc.net", Server.ConnectionType.SSL, 50002),
-						//1.15.0 new Server("alviss.coinjoined.com", Server.ConnectionType.SSL, 50002),
-						//1.15.0 new Server("electrum.acinq.co", Server.ConnectionType.SSL, 50002),
-						//1.14.0 new Server("electrum.coinext.com.br", Server.ConnectionType.SSL, 50002),
-						//F1.7.0 new Server("btc.lastingcoin.net", Server.ConnectionType.SSL, 50002),
-						new Server("104.248.139.211", Server.ConnectionType.SSL, 50002),
-						new Server("128.0.190.26", Server.ConnectionType.SSL, 50002),
-						new Server("142.93.6.38", Server.ConnectionType.SSL, 50002),
-						new Server("157.245.172.236", Server.ConnectionType.SSL, 50002),
-						new Server("167.172.226.175", Server.ConnectionType.SSL, 50002),
-						new Server("167.172.42.31", Server.ConnectionType.SSL, 50002),
-						new Server("178.62.80.20", Server.ConnectionType.SSL, 50002),
-						new Server("185.64.116.15", Server.ConnectionType.SSL, 50002),
-						new Server("188.165.206.215", Server.ConnectionType.SSL, 50002),
-						new Server("188.165.211.112", Server.ConnectionType.SSL, 50002),
-						new Server("2azzarita.hopto.org", Server.ConnectionType.SSL, 50002),
-						new Server("2electrumx.hopto.me", Server.ConnectionType.SSL, 56022),
-						new Server("2ex.digitaleveryware.com", Server.ConnectionType.SSL, 50002),
-						new Server("65.39.140.37", Server.ConnectionType.SSL, 50002),
-						new Server("68.183.188.105", Server.ConnectionType.SSL, 50002),
-						new Server("71.73.14.254", Server.ConnectionType.SSL, 50002),
-						new Server("94.23.247.135", Server.ConnectionType.SSL, 50002),
-						new Server("assuredly.not.fyi", Server.ConnectionType.SSL, 50002),
-						new Server("ax101.blockeng.ch", Server.ConnectionType.SSL, 50002),
-						new Server("ax102.blockeng.ch", Server.ConnectionType.SSL, 50002),
-						new Server("b.1209k.com", Server.ConnectionType.SSL, 50002),
-						new Server("b6.1209k.com", Server.ConnectionType.SSL, 50002),
-						new Server("bitcoin.dermichi.com", Server.ConnectionType.SSL, 50002),
-						new Server("bitcoin.lu.ke", Server.ConnectionType.SSL, 50002),
-						new Server("bitcoin.lukechilds.co", Server.ConnectionType.SSL, 50002),
-						new Server("blkhub.net", Server.ConnectionType.SSL, 50002),
-						new Server("btc.electroncash.dk", Server.ConnectionType.SSL, 60002),
-						new Server("btc.ocf.sh", Server.ConnectionType.SSL, 50002),
-						new Server("btce.iiiiiii.biz", Server.ConnectionType.SSL, 50002),
-						new Server("caleb.vegas", Server.ConnectionType.SSL, 50002),
-						new Server("eai.coincited.net", Server.ConnectionType.SSL, 50002),
-						new Server("electrum.bhoovd.com", Server.ConnectionType.SSL, 50002),
-						new Server("electrum.bitaroo.net", Server.ConnectionType.SSL, 50002),
-						new Server("electrum.bitcoinlizard.net", Server.ConnectionType.SSL, 50002),
-						new Server("electrum.blockstream.info", Server.ConnectionType.SSL, 50002),
-						new Server("electrum.emzy.de", Server.ConnectionType.SSL, 50002),
-						new Server("electrum.exan.tech", Server.ConnectionType.SSL, 50002),
-						new Server("electrum.kendigisland.xyz", Server.ConnectionType.SSL, 50002),
-						new Server("electrum.mmitech.info", Server.ConnectionType.SSL, 50002),
-						new Server("electrum.petrkr.net", Server.ConnectionType.SSL, 50002),
-						new Server("electrum.stippy.com", Server.ConnectionType.SSL, 50002),
-						new Server("electrum.thomasfischbach.de", Server.ConnectionType.SSL, 50002),
-						new Server("electrum0.snel.it", Server.ConnectionType.SSL, 50002),
-						new Server("electrum1.cipig.net", Server.ConnectionType.SSL, 50002),
-						new Server("electrum2.cipig.net", Server.ConnectionType.SSL, 50002),
-						new Server("electrum3.cipig.net", Server.ConnectionType.SSL, 50002),
-						new Server("electrumx.alexridevski.net", Server.ConnectionType.SSL, 50002),
-						new Server("electrumx-core.1209k.com", Server.ConnectionType.SSL, 50002),
-						new Server("elx.bitske.com", Server.ConnectionType.SSL, 50002),
-						new Server("ex03.axalgo.com", Server.ConnectionType.SSL, 50002),
-						new Server("ex05.axalgo.com", Server.ConnectionType.SSL, 50002),
-						new Server("ex07.axalgo.com", Server.ConnectionType.SSL, 50002),
-						new Server("fortress.qtornado.com", Server.ConnectionType.SSL, 50002),
-						new Server("fulcrum.grey.pw", Server.ConnectionType.SSL, 50002),
-						new Server("fulcrum.sethforprivacy.com", Server.ConnectionType.SSL, 51002),
-						new Server("guichet.centure.cc", Server.ConnectionType.SSL, 50002),
-						new Server("hodlers.beer", Server.ConnectionType.SSL, 50002),
-						new Server("kareoke.qoppa.org", Server.ConnectionType.SSL, 50002),
-						new Server("kirsche.emzy.de", Server.ConnectionType.SSL, 50002),
-						new Server("node1.btccuracao.com", Server.ConnectionType.SSL, 50002),
-						new Server("osr1ex1.compumundohipermegared.one", Server.ConnectionType.SSL, 50002),
-						new Server("smmalis37.ddns.net", Server.ConnectionType.SSL, 50002),
-						new Server("ulrichard.ch", Server.ConnectionType.SSL, 50002),
-						new Server("vmd104012.contaboserver.net", Server.ConnectionType.SSL, 50002),
-						new Server("vmd104014.contaboserver.net", Server.ConnectionType.SSL, 50002),
-						new Server("vmd63185.contaboserver.net", Server.ConnectionType.SSL, 50002),
-						new Server("vmd71287.contaboserver.net", Server.ConnectionType.SSL, 50002),
-						new Server("vmd84592.contaboserver.net", Server.ConnectionType.SSL, 50002),
-						new Server("xtrum.com", Server.ConnectionType.SSL, 50002));
+					// Servers chosen on NO BASIS WHATSOEVER from various sources!
+					// Status verified at https://1209k.com/bitcoin-eye/ele.php?chain=btc
+					new Server("104.248.139.211", Server.ConnectionType.SSL, 50002),
+					new Server("128.0.190.26", Server.ConnectionType.SSL, 50002),
+					new Server("142.93.6.38", Server.ConnectionType.SSL, 50002),
+					new Server("157.245.172.236", Server.ConnectionType.SSL, 50002),
+					new Server("167.172.226.175", Server.ConnectionType.SSL, 50002),
+					new Server("167.172.42.31", Server.ConnectionType.SSL, 50002),
+					new Server("178.62.80.20", Server.ConnectionType.SSL, 50002),
+					new Server("185.64.116.15", Server.ConnectionType.SSL, 50002),
+					new Server("188.165.206.215", Server.ConnectionType.SSL, 50002),
+					new Server("188.165.211.112", Server.ConnectionType.SSL, 50002),
+					new Server("2azzarita.hopto.org", Server.ConnectionType.SSL, 50002),
+					new Server("2electrumx.hopto.me", Server.ConnectionType.SSL, 56022),
+					new Server("2ex.digitaleveryware.com", Server.ConnectionType.SSL, 50002),
+					new Server("65.39.140.37", Server.ConnectionType.SSL, 50002),
+					new Server("68.183.188.105", Server.ConnectionType.SSL, 50002),
+					new Server("71.73.14.254", Server.ConnectionType.SSL, 50002),
+					new Server("94.23.247.135", Server.ConnectionType.SSL, 50002),
+					new Server("assuredly.not.fyi", Server.ConnectionType.SSL, 50002),
+					new Server("ax101.blockeng.ch", Server.ConnectionType.SSL, 50002),
+					new Server("ax102.blockeng.ch", Server.ConnectionType.SSL, 50002),
+					new Server("b.1209k.com", Server.ConnectionType.SSL, 50002),
+					new Server("b6.1209k.com", Server.ConnectionType.SSL, 50002),
+					new Server("bitcoin.dermichi.com", Server.ConnectionType.SSL, 50002),
+					new Server("bitcoin.lu.ke", Server.ConnectionType.SSL, 50002),
+					new Server("bitcoin.lukechilds.co", Server.ConnectionType.SSL, 50002),
+					new Server("blkhub.net", Server.ConnectionType.SSL, 50002),
+					new Server("btc.electroncash.dk", Server.ConnectionType.SSL, 60002),
+					new Server("btc.ocf.sh", Server.ConnectionType.SSL, 50002),
+					new Server("btce.iiiiiii.biz", Server.ConnectionType.SSL, 50002),
+					new Server("caleb.vegas", Server.ConnectionType.SSL, 50002),
+					new Server("eai.coincited.net", Server.ConnectionType.SSL, 50002),
+					new Server("electrum.bhoovd.com", Server.ConnectionType.SSL, 50002),
+					new Server("electrum.bitaroo.net", Server.ConnectionType.SSL, 50002),
+					new Server("electrum.bitcoinlizard.net", Server.ConnectionType.SSL, 50002),
+					new Server("electrum.blockstream.info", Server.ConnectionType.SSL, 50002),
+					new Server("electrum.emzy.de", Server.ConnectionType.SSL, 50002),
+					new Server("electrum.exan.tech", Server.ConnectionType.SSL, 50002),
+					new Server("electrum.kendigisland.xyz", Server.ConnectionType.SSL, 50002),
+					new Server("electrum.mmitech.info", Server.ConnectionType.SSL, 50002),
+					new Server("electrum.petrkr.net", Server.ConnectionType.SSL, 50002),
+					new Server("electrum.stippy.com", Server.ConnectionType.SSL, 50002),
+					new Server("electrum.thomasfischbach.de", Server.ConnectionType.SSL, 50002),
+					new Server("electrum0.snel.it", Server.ConnectionType.SSL, 50002),
+					new Server("electrum1.cipig.net", Server.ConnectionType.SSL, 50002),
+					new Server("electrum2.cipig.net", Server.ConnectionType.SSL, 50002),
+					new Server("electrum3.cipig.net", Server.ConnectionType.SSL, 50002),
+					new Server("electrumx.alexridevski.net", Server.ConnectionType.SSL, 50002),
+					new Server("electrumx-core.1209k.com", Server.ConnectionType.SSL, 50002),
+					new Server("elx.bitske.com", Server.ConnectionType.SSL, 50002),
+					new Server("ex03.axalgo.com", Server.ConnectionType.SSL, 50002),
+					new Server("ex05.axalgo.com", Server.ConnectionType.SSL, 50002),
+					new Server("ex07.axalgo.com", Server.ConnectionType.SSL, 50002),
+					new Server("fortress.qtornado.com", Server.ConnectionType.SSL, 50002),
+					new Server("fulcrum.grey.pw", Server.ConnectionType.SSL, 50002),
+					new Server("fulcrum.sethforprivacy.com", Server.ConnectionType.SSL, 51002),
+					new Server("guichet.centure.cc", Server.ConnectionType.SSL, 50002),
+					new Server("hodlers.beer", Server.ConnectionType.SSL, 50002),
+					new Server("kareoke.qoppa.org", Server.ConnectionType.SSL, 50002),
+					new Server("kirsche.emzy.de", Server.ConnectionType.SSL, 50002),
+					new Server("node1.btccuracao.com", Server.ConnectionType.SSL, 50002),
+					new Server("osr1ex1.compumundohipermegared.one", Server.ConnectionType.SSL, 50002),
+					new Server("smmalis37.ddns.net", Server.ConnectionType.SSL, 50002),
+					new Server("ulrichard.ch", Server.ConnectionType.SSL, 50002),
+					new Server("vmd104012.contaboserver.net", Server.ConnectionType.SSL, 50002),
+					new Server("vmd104014.contaboserver.net", Server.ConnectionType.SSL, 50002),
+					new Server("vmd63185.contaboserver.net", Server.ConnectionType.SSL, 50002),
+					new Server("vmd71287.contaboserver.net", Server.ConnectionType.SSL, 50002),
+					new Server("vmd84592.contaboserver.net", Server.ConnectionType.SSL, 50002),
+					new Server("xtrum.com", Server.ConnectionType.SSL, 50002)
+				);
 			}

 			@Override
@@ -152,12 +141,13 @@ public class Bitcoin extends Bitcoiny {
 			@Override
 			public Collection<ElectrumX.Server> getServers() {
 				return Arrays.asList(
-						new Server("tn.not.fyi", Server.ConnectionType.SSL, 55002),
-						new Server("electrumx-test.1209k.com", Server.ConnectionType.SSL, 50002),
-						new Server("testnet.qtornado.com", Server.ConnectionType.SSL, 51002),
-						new Server("testnet.aranguren.org", Server.ConnectionType.TCP, 51001),
-						new Server("testnet.aranguren.org", Server.ConnectionType.SSL, 51002),
-						new Server("testnet.hsmiths.com", Server.ConnectionType.SSL, 53012));
+					new Server("tn.not.fyi", Server.ConnectionType.SSL, 55002),
+					new Server("electrumx-test.1209k.com", Server.ConnectionType.SSL, 50002),
+					new Server("testnet.qtornado.com", Server.ConnectionType.SSL, 51002),
+					new Server("testnet.aranguren.org", Server.ConnectionType.TCP, 51001),
+					new Server("testnet.aranguren.org", Server.ConnectionType.SSL, 51002),
+					new Server("testnet.hsmiths.com", Server.ConnectionType.SSL, 53012)
+				);
 			}

 			@Override
@@ -179,8 +169,9 @@ public class Bitcoin extends Bitcoiny {
 			@Override
 			public Collection<ElectrumX.Server> getServers() {
 				return Arrays.asList(
-						new Server("localhost", Server.ConnectionType.TCP, 50001),
-						new Server("localhost", Server.ConnectionType.SSL, 50002));
+					new Server("localhost", Server.ConnectionType.TCP, 50001),
+					new Server("localhost", Server.ConnectionType.SSL, 50002)
+				);
 			}

 			@Override
--- a/src/main/java/org/qortal/crosschain/Digibyte.java
+++ b/src/main/java/org/qortal/crosschain/Digibyte.java
@@ -43,14 +43,17 @@ public class Digibyte extends Bitcoiny {
 			@Override
 			public Collection<Server> getServers() {
 				return Arrays.asList(
-						// Servers chosen on NO BASIS WHATSOEVER from various sources!
-						// Status verified at https://1209k.com/bitcoin-eye/ele.php?chain=dgb
-						new Server("electrum.qortal.link", Server.ConnectionType.SSL, 55002),
-						new Server("electrum-dgb.qortal.online", ConnectionType.SSL, 50002),
-						new Server("electrum1-dgb.qortal.online", ConnectionType.SSL, 50002),
-						new Server("electrum1.cipig.net", ConnectionType.SSL, 20059),
-						new Server("electrum2.cipig.net", ConnectionType.SSL, 20059),
-						new Server("electrum3.cipig.net", ConnectionType.SSL, 20059));
+					// Servers chosen on NO BASIS WHATSOEVER from various sources!
+					// Status verified at https://1209k.com/bitcoin-eye/ele.php?chain=dgb
+					new Server("electrum.qortal.link", Server.ConnectionType.SSL, 55002),
+					new Server("electrum1-dgb.qortal.online", Server.ConnectionType.SSL, 50002),
+					new Server("electrum2-dgb.qortal.online", Server.ConnectionType.SSL, 50002),
+					new Server("electrum3-dgb.qortal.online", Server.ConnectionType.SSL, 40002),
+					new Server("electrum4-dgb.qortal.online", Server.ConnectionType.SSL, 40002),
+					new Server("electrum1.cipig.net", Server.ConnectionType.SSL, 20059),
+					new Server("electrum2.cipig.net", Server.ConnectionType.SSL, 20059),
+					new Server("electrum3.cipig.net", Server.ConnectionType.SSL, 20059)
+				);
 			}

 			@Override
@@ -94,8 +97,9 @@ public class Digibyte extends Bitcoiny {
 			@Override
 			public Collection<Server> getServers() {
 				return Arrays.asList(
-						new Server("localhost", ConnectionType.TCP, 50001),
-						new Server("localhost", ConnectionType.SSL, 50002));
+					new Server("localhost", Server.ConnectionType.TCP, 50001),
+					new Server("localhost", Server.ConnectionType.SSL, 50002)
+				);
 			}

 			@Override
--- a/src/main/java/org/qortal/crosschain/Dogecoin.java
+++ b/src/main/java/org/qortal/crosschain/Dogecoin.java
@@ -4,7 +4,6 @@ import org.bitcoinj.core.Coin;
 import org.bitcoinj.core.Context;
 import org.bitcoinj.core.NetworkParameters;
 import org.libdohj.params.DogecoinMainNetParams;
-//import org.libdohj.params.DogecoinRegTestParams;
 import org.libdohj.params.DogecoinTestNet3Params;
 import org.qortal.crosschain.ElectrumX.Server;
 import org.qortal.crosschain.ElectrumX.Server.ConnectionType;
@@ -44,14 +43,17 @@ public class Dogecoin extends Bitcoiny {
 			@Override
 			public Collection<Server> getServers() {
 				return Arrays.asList(
-						// Servers chosen on NO BASIS WHATSOEVER from various sources!
-						// Status verified at https://1209k.com/bitcoin-eye/ele.php?chain=doge
-						new Server("electrum.qortal.link", Server.ConnectionType.SSL, 54002),
-						new Server("electrum-doge.qortal.online", ConnectionType.SSL, 50002),
-						new Server("electrum1-doge.qortal.online", ConnectionType.SSL, 50002),
-						new Server("electrum1.cipig.net", ConnectionType.SSL, 20060),
-						new Server("electrum2.cipig.net", ConnectionType.SSL, 20060),
-						new Server("electrum3.cipig.net", ConnectionType.SSL, 20060));
+					// Servers chosen on NO BASIS WHATSOEVER from various sources!
+					// Status verified at https://1209k.com/bitcoin-eye/ele.php?chain=doge
+					new Server("electrum.qortal.link", Server.ConnectionType.SSL, 54002),
+					new Server("electrum1-doge.qortal.online", Server.ConnectionType.SSL, 50002),
+					new Server("electrum2-doge.qortal.online", Server.ConnectionType.SSL, 50002),
+					new Server("electrum3-doge.qortal.online", Server.ConnectionType.SSL, 30002),
+					new Server("electrum4-doge.qortal.online", Server.ConnectionType.SSL, 30002),
+					new Server("electrum1.cipig.net", Server.ConnectionType.SSL, 20060),
+					new Server("electrum2.cipig.net", Server.ConnectionType.SSL, 20060),
+					new Server("electrum3.cipig.net", Server.ConnectionType.SSL, 20060)
+				);
 			}

 			@Override
@@ -95,8 +97,9 @@ public class Dogecoin extends Bitcoiny {
 			@Override
 			public Collection<Server> getServers() {
 				return Arrays.asList(
-						new Server("localhost", ConnectionType.TCP, 50001),
-						new Server("localhost", ConnectionType.SSL, 50002));
+					new Server("localhost", Server.ConnectionType.TCP, 50001),
+					new Server("localhost", Server.ConnectionType.SSL, 50002)
+				);
 			}

 			@Override
--- a/src/main/java/org/qortal/crosschain/Litecoin.java
+++ b/src/main/java/org/qortal/crosschain/Litecoin.java
@@ -43,22 +43,21 @@ public class Litecoin extends Bitcoiny {
 			@Override
 			public Collection<ElectrumX.Server> getServers() {
 				return Arrays.asList(
-						// Servers chosen on NO BASIS WHATSOEVER from various sources!
-						// Status verified at https://1209k.com/bitcoin-eye/ele.php?chain=ltc
-						//CLOSED new Server("electrum-ltc.someguy123.net", Server.ConnectionType.SSL, 50002),
-						//CLOSED new Server("ltc.litepay.ch", Server.ConnectionType.SSL, 50022),
-						//BEHIND new Server("62.171.169.176", Server.ConnectionType.SSL, 50002),
-						//PHISHY new Server("electrum-ltc.bysh.me", Server.ConnectionType.SSL, 50002),
-						new Server("backup.electrum-ltc.org", Server.ConnectionType.SSL, 443),
-						new Server("electrum.qortal.link", Server.ConnectionType.SSL, 50002),
-						new Server("electrum.ltc.xurious.com", Server.ConnectionType.SSL, 50002),
-						new Server("electrum-ltc.petrkr.net", Server.ConnectionType.SSL, 60002),
-						new Server("electrum-ltc.qortal.online", Server.ConnectionType.SSL, 50002),
-						new Server("electrum1-ltc.qortal.online", Server.ConnectionType.SSL, 50002),
-						new Server("electrum1.cipig.net", Server.ConnectionType.SSL, 20063),
-						new Server("electrum2.cipig.net", Server.ConnectionType.SSL, 20063),
-						new Server("electrum3.cipig.net", Server.ConnectionType.SSL, 20063),
-						new Server("ltc.rentonrisk.com", Server.ConnectionType.SSL, 50002));
+					// Servers chosen on NO BASIS WHATSOEVER from various sources!
+					// Status verified at https://1209k.com/bitcoin-eye/ele.php?chain=ltc
+					new Server("electrum.qortal.link", Server.ConnectionType.SSL, 50002),
+					new Server("electrum1-ltc.qortal.online", Server.ConnectionType.SSL, 50002),
+					new Server("electrum2-ltc.qortal.online", Server.ConnectionType.SSL, 50002),
+					new Server("electrum3-ltc.qortal.online", Server.ConnectionType.SSL, 20002),
+					new Server("electrum4-ltc.qortal.online", Server.ConnectionType.SSL, 20002),
+					new Server("backup.electrum-ltc.org", Server.ConnectionType.SSL, 443),
+					new Server("electrum.ltc.xurious.com", Server.ConnectionType.SSL, 50002),
+					new Server("electrum-ltc.petrkr.net", Server.ConnectionType.SSL, 60002),
+					new Server("electrum1.cipig.net", Server.ConnectionType.SSL, 20063),
+					new Server("electrum2.cipig.net", Server.ConnectionType.SSL, 20063),
+					new Server("electrum3.cipig.net", Server.ConnectionType.SSL, 20063),
+					new Server("ltc.rentonrisk.com", Server.ConnectionType.SSL, 50002)
+				);
 			}

 			@Override
@@ -81,10 +80,11 @@ public class Litecoin extends Bitcoiny {
 			@Override
 			public Collection<ElectrumX.Server> getServers() {
 				return Arrays.asList(
-						new Server("electrum-ltc.bysh.me", Server.ConnectionType.TCP, 51001),
-						new Server("electrum-ltc.bysh.me", Server.ConnectionType.SSL, 51002),
-						new Server("electrum.ltc.xurious.com", Server.ConnectionType.TCP, 51001),
-						new Server("electrum.ltc.xurious.com", Server.ConnectionType.SSL, 51002));
+					new Server("electrum-ltc.bysh.me", Server.ConnectionType.TCP, 51001),
+					new Server("electrum-ltc.bysh.me", Server.ConnectionType.SSL, 51002),
+					new Server("electrum.ltc.xurious.com", Server.ConnectionType.TCP, 51001),
+					new Server("electrum.ltc.xurious.com", Server.ConnectionType.SSL, 51002)
+				);
 			}

 			@Override
@@ -106,8 +106,9 @@ public class Litecoin extends Bitcoiny {
 			@Override
 			public Collection<ElectrumX.Server> getServers() {
 				return Arrays.asList(
-						new Server("localhost", Server.ConnectionType.TCP, 50001),
-						new Server("localhost", Server.ConnectionType.SSL, 50002));
+					new Server("localhost", Server.ConnectionType.TCP, 50001),
+					new Server("localhost", Server.ConnectionType.SSL, 50002)
+				);
 			}

 			@Override
--- a/src/main/java/org/qortal/crosschain/PirateChain.java
+++ b/src/main/java/org/qortal/crosschain/PirateChain.java
@@ -56,11 +56,14 @@ public class PirateChain extends Bitcoiny {
 			@Override
 			public Collection<Server> getServers() {
 				return Arrays.asList(
-						// Servers chosen on NO BASIS WHATSOEVER from various sources!
-						new Server("wallet-arrr1.qortal.online", ConnectionType.SSL, 443),
-						new Server("wallet-arrr2.qortal.online", ConnectionType.SSL, 443),
-						new Server("wallet-arrr3.qortal.online", ConnectionType.SSL, 443),
-						new Server("lightd.pirate.black", ConnectionType.SSL, 443));
+					// Servers chosen on NO BASIS WHATSOEVER from various sources!
+					new Server("wallet-arrr1.qortal.online", Server.ConnectionType.SSL, 443),
+					new Server("wallet-arrr2.qortal.online", Server.ConnectionType.SSL, 443),
+					new Server("wallet-arrr3.qortal.online", Server.ConnectionType.SSL, 443),
+					new Server("wallet-arrr4.qortal.online", Server.ConnectionType.SSL, 443),
+					new Server("wallet-arrr5.qortal.online", Server.ConnectionType.SSL, 443),
+					new Server("lightd.pirate.black", Server.ConnectionType.SSL, 443)
+				);
 			}

 			@Override
@@ -104,8 +107,9 @@ public class PirateChain extends Bitcoiny {
 			@Override
 			public Collection<Server> getServers() {
 				return Arrays.asList(
-						new Server("localhost", ConnectionType.TCP, 9067),
-						new Server("localhost", ConnectionType.SSL, 443));
+					new Server("localhost", Server.ConnectionType.TCP, 9067),
+					new Server("localhost", Server.ConnectionType.SSL, 443)
+				);
 			}

 			@Override
--- a/src/main/java/org/qortal/crosschain/Ravencoin.java
+++ b/src/main/java/org/qortal/crosschain/Ravencoin.java
@@ -43,19 +43,19 @@ public class Ravencoin extends Bitcoiny {
 			@Override
 			public Collection<Server> getServers() {
 				return Arrays.asList(
-						// Servers chosen on NO BASIS WHATSOEVER from various sources!
-						// Status verified at https://1209k.com/bitcoin-eye/ele.php?chain=rvn
-						//CLOSED new Server("aethyn.com", ConnectionType.SSL, 50002),
-						//CLOSED new Server("electrum2.rvn.rocks", ConnectionType.SSL, 50002),
-						//BEHIND new Server("electrum3.rvn.rocks", ConnectionType.SSL, 50002),
-						new Server("electrum.qortal.link", Server.ConnectionType.SSL, 56002),
-						new Server("electrum-rvn.qortal.online", ConnectionType.SSL, 50002),
-						new Server("electrum1-rvn.qortal.online", ConnectionType.SSL, 50002),
-						new Server("electrum1.cipig.net", ConnectionType.SSL, 20051),
-						new Server("electrum2.cipig.net", ConnectionType.SSL, 20051),
-						new Server("electrum3.cipig.net", ConnectionType.SSL, 20051),
-						new Server("rvn-dashboard.com", ConnectionType.SSL, 50002),
-						new Server("rvn4lyfe.com", ConnectionType.SSL, 50002));
+					// Servers chosen on NO BASIS WHATSOEVER from various sources!
+					// Status verified at https://1209k.com/bitcoin-eye/ele.php?chain=rvn
+					new Server("electrum.qortal.link", Server.ConnectionType.SSL, 56002),
+					new Server("electrum1-rvn.qortal.online", Server.ConnectionType.SSL, 50002),
+					new Server("electrum2-rvn.qortal.online", Server.ConnectionType.SSL, 50002),
+					new Server("electrum3-rvn.qortal.online", Server.ConnectionType.SSL, 50002),
+					new Server("electrum4-rvn.qortal.online", Server.ConnectionType.SSL, 50002),
+					new Server("electrum1.cipig.net", Server.ConnectionType.SSL, 20051),
+					new Server("electrum2.cipig.net", Server.ConnectionType.SSL, 20051),
+					new Server("electrum3.cipig.net", Server.ConnectionType.SSL, 20051),
+					new Server("rvn-dashboard.com", Server.ConnectionType.SSL, 50002),
+					new Server("rvn4lyfe.com", Server.ConnectionType.SSL, 50002)
+				);
 			}

 			@Override
@@ -99,8 +99,9 @@ public class Ravencoin extends Bitcoiny {
 			@Override
 			public Collection<Server> getServers() {
 				return Arrays.asList(
-						new Server("localhost", ConnectionType.TCP, 50001),
-						new Server("localhost", ConnectionType.SSL, 50002));
+					new Server("localhost", Server.ConnectionType.TCP, 50001),
+					new Server("localhost", Server.ConnectionType.SSL, 50002)
+				);
 			}

 			@Override
--- a/src/main/java/org/qortal/crypto/TrustlessSSLSocketFactory.java
+++ b/src/main/java/org/qortal/crypto/TrustlessSSLSocketFactory.java
@@ -28,7 +28,7 @@ public abstract class TrustlessSSLSocketFactory {
 	private static final SSLContext sc;
 	static {
 		try {
-			sc = SSLContext.getInstance("SSL");
+			sc = SSLContext.getInstance("TLSv1.3");
 			sc.init(null, TRUSTLESS_MANAGER, new java.security.SecureRandom());
 		} catch (Exception e) {
 			throw new RuntimeException(e);
--- a/src/main/java/org/qortal/data/network/OnlineAccountData.java
+++ b/src/main/java/org/qortal/data/network/OnlineAccountData.java
@@ -1,6 +1,7 @@
 package org.qortal.data.network;

 import java.util.Arrays;
+import java.util.Objects;

 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
@@ -34,10 +35,6 @@ public class OnlineAccountData {
 		this.nonce = nonce;
 	}

-	public OnlineAccountData(long timestamp, byte[] signature, byte[] publicKey) {
-		this(timestamp, signature, publicKey, null);
-	}
-
 	public long getTimestamp() {
 		return this.timestamp;
 	}
@@ -76,6 +73,10 @@ public class OnlineAccountData {
 		if (otherOnlineAccountData.timestamp != this.timestamp)
 			return false;

+		// Almost as quick
+		if (!Objects.equals(otherOnlineAccountData.nonce, this.nonce))
+			return false;
+
 		if (!Arrays.equals(otherOnlineAccountData.publicKey, this.publicKey))
 			return false;

@@ -88,9 +89,10 @@ public class OnlineAccountData {
 	public int hashCode() {
 		int h = this.hash;
 		if (h == 0) {
-			this.hash = h = Long.hashCode(this.timestamp)
-					^ Arrays.hashCode(this.publicKey);
+			h = Objects.hash(timestamp, nonce);
+			h = 31 * h + Arrays.hashCode(publicKey);
 			// We don't use signature because newer aggregate signatures use random nonces
+			this.hash = h;
 		}
 		return h;
 	}
--- a/src/main/java/org/qortal/data/transaction/TransactionData.java
+++ b/src/main/java/org/qortal/data/transaction/TransactionData.java
@@ -75,6 +75,9 @@ public abstract class TransactionData {
 	@Schema(description = "groupID for this transaction")
 	protected int txGroupId;

+	@Schema(description = "recipient for this transaction")
+	protected String recipient;
+
 	// Not always present
 	@Schema(accessMode = AccessMode.READ_ONLY, hidden = true, description = "height of block containing transaction")
 	protected Integer blockHeight;
@@ -105,7 +108,7 @@ public abstract class TransactionData {
 	/** Constructor for use by transaction subclasses. */
 	protected TransactionData(TransactionType type, BaseTransactionData baseTransactionData) {
 		this.type = type;
-
+		this.recipient = baseTransactionData.recipient;
 		this.timestamp = baseTransactionData.timestamp;
 		this.txGroupId = baseTransactionData.txGroupId;
 		this.reference = baseTransactionData.reference;
@@ -136,6 +139,10 @@ public abstract class TransactionData {
 		return this.txGroupId;
 	}

+	public String getRecipient() {
+		return this.recipient;
+	}
+
 	public void setTxGroupId(int txGroupId) {
 		this.txGroupId = txGroupId;
 	}
@@ -250,5 +257,4 @@ public abstract class TransactionData {

 		return Arrays.equals(this.signature, otherTransactionData.signature);
 	}
-
-}
+}
--- a/src/main/java/org/qortal/network/Handshake.java
+++ b/src/main/java/org/qortal/network/Handshake.java
@@ -265,7 +265,7 @@ public enum Handshake {
 	private static final long PEER_VERSION_131 = 0x0100030001L;

 	/** Minimum peer version that we are allowed to communicate with */
-	private static final String MIN_PEER_VERSION = "4.0.0";
+	private static final String MIN_PEER_VERSION = "4.1.1";

 	private static final int POW_BUFFER_SIZE_PRE_131 = 8 * 1024 * 1024; // bytes
 	private static final int POW_DIFFICULTY_PRE_131 = 8; // leading zero bits
--- a/src/main/java/org/qortal/network/Network.java
+++ b/src/main/java/org/qortal/network/Network.java
@@ -8,7 +8,6 @@ import org.bouncycastle.crypto.params.Ed25519PublicKeyParameters;
 import org.qortal.block.BlockChain;
 import org.qortal.controller.Controller;
 import org.qortal.controller.arbitrary.ArbitraryDataFileListManager;
-import org.qortal.controller.arbitrary.ArbitraryDataManager;
 import org.qortal.crypto.Crypto;
 import org.qortal.data.block.BlockData;
 import org.qortal.data.block.BlockSummaryData;
@@ -122,6 +121,22 @@ public class Network {
    private List<Peer> immutableOutboundHandshakedPeers = Collections.emptyList(); // always rebuilt from mutable, synced list above


+    /**
+     * Count threads per message type in order to enforce limits
+     */
+    private final Map<MessageType, Integer> threadsPerMessageType = Collections.synchronizedMap(new HashMap<>());
+
+    /**
+     * Keep track of total thread count, to warn when the thread pool is getting low
+     */
+    private int totalThreadCount = 0;
+
+    /**
+     * Thresholds at which to warn about the number of active threads
+     */
+    private final int threadCountWarningThreshold = (int) (Settings.getInstance().getMaxNetworkThreadPoolSize() * 0.9f);
+    private final Integer threadCountPerMessageTypeWarningThreshold = Settings.getInstance().getThreadCountPerMessageTypeWarningThreshold();
+
    private final List<PeerAddress> selfPeers = new ArrayList<>();

    private String bindAddress = null;
@@ -187,7 +202,7 @@ public class Network {

                this.bindAddress = bindAddress; // Store the selected address, so that it can be used by other parts of the app
                break; // We don't want to bind to more than one address
-            } catch (UnknownHostException e) {
+            } catch (UnknownHostException | UnsupportedAddressTypeException e) {
                LOGGER.error("Can't bind listen socket to address {}", Settings.getInstance().getBindAddress());
                if (i == bindAddresses.size()-1) { // Only throw an exception if all addresses have been tried
                    throw new IOException("Can't bind listen socket to address", e);
@@ -240,6 +255,16 @@ public class Network {
        private static final Network INSTANCE = new Network();
    }

+    public Map<MessageType, Integer> getThreadsPerMessageType() {
+        return this.threadsPerMessageType;
+    }
+
+    public int getTotalThreadCount() {
+        synchronized (this) {
+            return this.totalThreadCount;
+        }
+    }
+
    public static Network getInstance() {
        return SingletonContainer.INSTANCE;
    }
@@ -952,6 +977,37 @@ public class Network {

        // Should be non-handshaking messages from now on

+        // Limit threads per message type and discard if there are already too many
+        Integer maxThreadsForMessageType = Settings.getInstance().getMaxThreadsForMessageType(message.getType());
+        if (maxThreadsForMessageType != null) {
+            Integer threadCount = threadsPerMessageType.get(message.getType());
+            if (threadCount != null && threadCount >= maxThreadsForMessageType) {
+                LOGGER.trace("Discarding {} message as there are already {} active threads", message.getType().name(), threadCount);
+                return;
+            }
+        }
+
+        // Warn if necessary
+        if (threadCountPerMessageTypeWarningThreshold != null) {
+            Integer threadCount = threadsPerMessageType.get(message.getType());
+            if (threadCount != null && threadCount > threadCountPerMessageTypeWarningThreshold) {
+                LOGGER.info("Warning: high thread count for {} message type: {}", message.getType().name(), threadCount);
+            }
+        }
+
+        // Add to per-message thread count (first initializing to 0 if not already present)
+        threadsPerMessageType.computeIfAbsent(message.getType(), key -> 0);
+        threadsPerMessageType.computeIfPresent(message.getType(), (key, value) -> value + 1);
+        
+        // Add to total thread count
+        synchronized (this) {
+            totalThreadCount++;
+
+            if (totalThreadCount >= threadCountWarningThreshold) {
+                LOGGER.info("Warning: high total thread count: {} / {}", totalThreadCount, Settings.getInstance().getMaxNetworkThreadPoolSize());
+            }
+        }
+
        // Ordered by message type value
        switch (message.getType()) {
            case GET_PEERS:
@@ -979,6 +1035,15 @@ public class Network {
                Controller.getInstance().onNetworkMessage(peer, message);
                break;
        }
+
+        // Remove from per-message thread count (first initializing to 0 if not already present)
+        threadsPerMessageType.computeIfAbsent(message.getType(), key -> 0);
+        threadsPerMessageType.computeIfPresent(message.getType(), (key, value) -> value - 1);
+
+        // Remove from total thread count
+        synchronized (this) {
+            totalThreadCount--;
+        }
    }

    private void onHandshakingMessage(Peer peer, Message message, Handshake handshakeStatus) {
--- a/src/main/java/org/qortal/network/message/GetOnlineAccountsMessage.java
+++ b/src/main/java/org/qortal/network/message/GetOnlineAccountsMessage.java
@@ -1,69 +0,0 @@
-package org.qortal.network.message;
-
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.nio.ByteBuffer;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.stream.Collectors;
-
-import org.qortal.data.network.OnlineAccountData;
-import org.qortal.transform.Transformer;
-
-import com.google.common.primitives.Ints;
-import com.google.common.primitives.Longs;
-
-public class GetOnlineAccountsMessage extends Message {
-	private static final int MAX_ACCOUNT_COUNT = 5000;
-
-	private List<OnlineAccountData> onlineAccounts;
-
-	public GetOnlineAccountsMessage(List<OnlineAccountData> onlineAccounts) {
-		super(MessageType.GET_ONLINE_ACCOUNTS);
-
-		ByteArrayOutputStream bytes = new ByteArrayOutputStream();
-
-		try {
-			bytes.write(Ints.toByteArray(onlineAccounts.size()));
-
-			for (OnlineAccountData onlineAccountData : onlineAccounts) {
-				bytes.write(Longs.toByteArray(onlineAccountData.getTimestamp()));
-
-				bytes.write(onlineAccountData.getPublicKey());
-			}
-		} catch (IOException e) {
-			throw new AssertionError("IOException shouldn't occur with ByteArrayOutputStream");
-		}
-
-		this.dataBytes = bytes.toByteArray();
-		this.checksumBytes = Message.generateChecksum(this.dataBytes);
-	}
-
-	private GetOnlineAccountsMessage(int id, List<OnlineAccountData> onlineAccounts) {
-		super(id, MessageType.GET_ONLINE_ACCOUNTS);
-
-		this.onlineAccounts = onlineAccounts.stream().limit(MAX_ACCOUNT_COUNT).collect(Collectors.toList());
-	}
-
-	public List<OnlineAccountData> getOnlineAccounts() {
-		return this.onlineAccounts;
-	}
-
-	public static Message fromByteBuffer(int id, ByteBuffer bytes) {
-		final int accountCount = bytes.getInt();
-
-		List<OnlineAccountData> onlineAccounts = new ArrayList<>(accountCount);
-
-		for (int i = 0; i < Math.min(MAX_ACCOUNT_COUNT, accountCount); ++i) {
-			long timestamp = bytes.getLong();
-
-			byte[] publicKey = new byte[Transformer.PUBLIC_KEY_LENGTH];
-			bytes.get(publicKey);
-
-			onlineAccounts.add(new OnlineAccountData(timestamp, null, publicKey));
-		}
-
-		return new GetOnlineAccountsMessage(id, onlineAccounts);
-	}
-
-}
--- a/src/main/java/org/qortal/network/message/GetOnlineAccountsV2Message.java
+++ b/src/main/java/org/qortal/network/message/GetOnlineAccountsV2Message.java
@@ -1,109 +0,0 @@
-package org.qortal.network.message;
-
-import com.google.common.primitives.Ints;
-import com.google.common.primitives.Longs;
-import org.qortal.data.network.OnlineAccountData;
-import org.qortal.transform.Transformer;
-
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.nio.ByteBuffer;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-/**
- * For requesting online accounts info from remote peer, given our list of online accounts.
- *
- * Different format to V1:
- * V1 is: number of entries, then timestamp + pubkey for each entry
- * V2 is: groups of: number of entries, timestamp, then pubkey for each entry
- *
- * Also V2 only builds online accounts message once!
- */
-public class GetOnlineAccountsV2Message extends Message {
-
-	private List<OnlineAccountData> onlineAccounts;
-
-	public GetOnlineAccountsV2Message(List<OnlineAccountData> onlineAccounts) {
-		super(MessageType.GET_ONLINE_ACCOUNTS_V2);
-
-		// If we don't have ANY online accounts then it's an easier construction...
-		if (onlineAccounts.isEmpty()) {
-			// Always supply a number of accounts
-			this.dataBytes = Ints.toByteArray(0);
-			this.checksumBytes = Message.generateChecksum(this.dataBytes);
-			return;
-		}
-
-		// How many of each timestamp
-		Map<Long, Integer> countByTimestamp = new HashMap<>();
-
-		for (OnlineAccountData onlineAccountData : onlineAccounts) {
-			Long timestamp = onlineAccountData.getTimestamp();
-			countByTimestamp.compute(timestamp, (k, v) -> v == null ? 1 : ++v);
-		}
-
-		// We should know exactly how many bytes to allocate now
-		int byteSize = countByTimestamp.size() * (Transformer.INT_LENGTH + Transformer.TIMESTAMP_LENGTH)
-				+ onlineAccounts.size() * Transformer.PUBLIC_KEY_LENGTH;
-
-		ByteArrayOutputStream bytes = new ByteArrayOutputStream(byteSize);
-
-		try {
-			for (long timestamp : countByTimestamp.keySet()) {
-				bytes.write(Ints.toByteArray(countByTimestamp.get(timestamp)));
-
-				bytes.write(Longs.toByteArray(timestamp));
-
-				for (OnlineAccountData onlineAccountData : onlineAccounts) {
-					if (onlineAccountData.getTimestamp() == timestamp)
-						bytes.write(onlineAccountData.getPublicKey());
-				}
-			}
-		} catch (IOException e) {
-			throw new AssertionError("IOException shouldn't occur with ByteArrayOutputStream");
-		}
-
-		this.dataBytes = bytes.toByteArray();
-		this.checksumBytes = Message.generateChecksum(this.dataBytes);
-	}
-
-	private GetOnlineAccountsV2Message(int id, List<OnlineAccountData> onlineAccounts) {
-		super(id, MessageType.GET_ONLINE_ACCOUNTS_V2);
-
-		this.onlineAccounts = onlineAccounts;
-	}
-
-	public List<OnlineAccountData> getOnlineAccounts() {
-		return this.onlineAccounts;
-	}
-
-	public static Message fromByteBuffer(int id, ByteBuffer bytes) {
-		int accountCount = bytes.getInt();
-
-		List<OnlineAccountData> onlineAccounts = new ArrayList<>(accountCount);
-
-		while (accountCount > 0) {
-			long timestamp = bytes.getLong();
-
-			for (int i = 0; i < accountCount; ++i) {
-				byte[] publicKey = new byte[Transformer.PUBLIC_KEY_LENGTH];
-				bytes.get(publicKey);
-
-				onlineAccounts.add(new OnlineAccountData(timestamp, null, publicKey));
-			}
-
-			if (bytes.hasRemaining()) {
-				accountCount = bytes.getInt();
-			} else {
-				// we've finished
-				accountCount = 0;
-			}
-		}
-
-		return new GetOnlineAccountsV2Message(id, onlineAccounts);
-	}
-
-}
--- a/src/main/java/org/qortal/network/message/MessageType.java
+++ b/src/main/java/org/qortal/network/message/MessageType.java
@@ -43,11 +43,7 @@ public enum MessageType {
    BLOCK_SUMMARIES(70, BlockSummariesMessage::fromByteBuffer),
    GET_BLOCK_SUMMARIES(71, GetBlockSummariesMessage::fromByteBuffer),
    BLOCK_SUMMARIES_V2(72, BlockSummariesV2Message::fromByteBuffer),
-
-    ONLINE_ACCOUNTS(80, OnlineAccountsMessage::fromByteBuffer),
-    GET_ONLINE_ACCOUNTS(81, GetOnlineAccountsMessage::fromByteBuffer),
-    ONLINE_ACCOUNTS_V2(82, OnlineAccountsV2Message::fromByteBuffer),
-    GET_ONLINE_ACCOUNTS_V2(83, GetOnlineAccountsV2Message::fromByteBuffer),
+    
    ONLINE_ACCOUNTS_V3(84, OnlineAccountsV3Message::fromByteBuffer),
    GET_ONLINE_ACCOUNTS_V3(85, GetOnlineAccountsV3Message::fromByteBuffer),

--- a/src/main/java/org/qortal/network/message/OnlineAccountsMessage.java
+++ b/src/main/java/org/qortal/network/message/OnlineAccountsMessage.java
@@ -1,75 +0,0 @@
-package org.qortal.network.message;
-
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.nio.ByteBuffer;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.stream.Collectors;
-
-import org.qortal.data.network.OnlineAccountData;
-import org.qortal.transform.Transformer;
-
-import com.google.common.primitives.Ints;
-import com.google.common.primitives.Longs;
-
-public class OnlineAccountsMessage extends Message {
-	private static final int MAX_ACCOUNT_COUNT = 5000;
-
-	private List<OnlineAccountData> onlineAccounts;
-
-	public OnlineAccountsMessage(List<OnlineAccountData> onlineAccounts) {
-		super(MessageType.ONLINE_ACCOUNTS);
-
-		ByteArrayOutputStream bytes = new ByteArrayOutputStream();
-
-		try {
-			bytes.write(Ints.toByteArray(onlineAccounts.size()));
-
-			for (OnlineAccountData onlineAccountData : onlineAccounts) {
-				bytes.write(Longs.toByteArray(onlineAccountData.getTimestamp()));
-
-				bytes.write(onlineAccountData.getSignature());
-
-				bytes.write(onlineAccountData.getPublicKey());
-			}
-		} catch (IOException e) {
-			throw new AssertionError("IOException shouldn't occur with ByteArrayOutputStream");
-		}
-
-		this.dataBytes = bytes.toByteArray();
-		this.checksumBytes = Message.generateChecksum(this.dataBytes);
-	}
-
-	private OnlineAccountsMessage(int id, List<OnlineAccountData> onlineAccounts) {
-		super(id, MessageType.ONLINE_ACCOUNTS);
-
-		this.onlineAccounts = onlineAccounts.stream().limit(MAX_ACCOUNT_COUNT).collect(Collectors.toList());
-	}
-
-	public List<OnlineAccountData> getOnlineAccounts() {
-		return this.onlineAccounts;
-	}
-
-	public static Message fromByteBuffer(int id, ByteBuffer bytes) {
-		final int accountCount = bytes.getInt();
-
-		List<OnlineAccountData> onlineAccounts = new ArrayList<>(accountCount);
-
-		for (int i = 0; i < Math.min(MAX_ACCOUNT_COUNT, accountCount); ++i) {
-			long timestamp = bytes.getLong();
-
-			byte[] signature = new byte[Transformer.SIGNATURE_LENGTH];
-			bytes.get(signature);
-
-			byte[] publicKey = new byte[Transformer.PUBLIC_KEY_LENGTH];
-			bytes.get(publicKey);
-
-			OnlineAccountData onlineAccountData = new OnlineAccountData(timestamp, signature, publicKey);
-			onlineAccounts.add(onlineAccountData);
-		}
-
-		return new OnlineAccountsMessage(id, onlineAccounts);
-	}
-
-}
--- a/src/main/java/org/qortal/network/message/OnlineAccountsV2Message.java
+++ b/src/main/java/org/qortal/network/message/OnlineAccountsV2Message.java
@@ -1,113 +0,0 @@
-package org.qortal.network.message;
-
-import com.google.common.primitives.Ints;
-import com.google.common.primitives.Longs;
-import org.qortal.data.network.OnlineAccountData;
-import org.qortal.transform.Transformer;
-
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.nio.ByteBuffer;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-/**
- * For sending online accounts info to remote peer.
- *
- * Different format to V1:
- * V1 is: number of entries, then timestamp + sig + pubkey for each entry
- * V2 is: groups of: number of entries, timestamp, then sig + pubkey for each entry
- *
- * Also V2 only builds online accounts message once!
- */
-public class OnlineAccountsV2Message extends Message {
-
-	private List<OnlineAccountData> onlineAccounts;
-
-	public OnlineAccountsV2Message(List<OnlineAccountData> onlineAccounts) {
-		super(MessageType.ONLINE_ACCOUNTS_V2);
-
-		// Shortcut in case we have no online accounts
-		if (onlineAccounts.isEmpty()) {
-			this.dataBytes = Ints.toByteArray(0);
-			this.checksumBytes = Message.generateChecksum(this.dataBytes);
-			return;
-		}
-
-		// How many of each timestamp
-		Map<Long, Integer> countByTimestamp = new HashMap<>();
-
-		for (OnlineAccountData onlineAccountData : onlineAccounts) {
-			Long timestamp = onlineAccountData.getTimestamp();
-			countByTimestamp.compute(timestamp, (k, v) -> v == null ? 1 : ++v);
-		}
-
-		// We should know exactly how many bytes to allocate now
-		int byteSize = countByTimestamp.size() * (Transformer.INT_LENGTH + Transformer.TIMESTAMP_LENGTH)
-				+ onlineAccounts.size() * (Transformer.SIGNATURE_LENGTH + Transformer.PUBLIC_KEY_LENGTH);
-
-		ByteArrayOutputStream bytes = new ByteArrayOutputStream(byteSize);
-
-		try {
-			for (long timestamp : countByTimestamp.keySet()) {
-				bytes.write(Ints.toByteArray(countByTimestamp.get(timestamp)));
-
-				bytes.write(Longs.toByteArray(timestamp));
-
-				for (OnlineAccountData onlineAccountData : onlineAccounts) {
-					if (onlineAccountData.getTimestamp() == timestamp) {
-						bytes.write(onlineAccountData.getSignature());
-						bytes.write(onlineAccountData.getPublicKey());
-					}
-				}
-			}
-		} catch (IOException e) {
-			throw new AssertionError("IOException shouldn't occur with ByteArrayOutputStream");
-		}
-
-		this.dataBytes = bytes.toByteArray();
-		this.checksumBytes = Message.generateChecksum(this.dataBytes);
-	}
-
-	private OnlineAccountsV2Message(int id, List<OnlineAccountData> onlineAccounts) {
-		super(id, MessageType.ONLINE_ACCOUNTS_V2);
-
-		this.onlineAccounts = onlineAccounts;
-	}
-
-	public List<OnlineAccountData> getOnlineAccounts() {
-		return this.onlineAccounts;
-	}
-
-	public static Message fromByteBuffer(int id, ByteBuffer bytes) throws MessageException {
-		int accountCount = bytes.getInt();
-
-		List<OnlineAccountData> onlineAccounts = new ArrayList<>(accountCount);
-
-		while (accountCount > 0) {
-			long timestamp = bytes.getLong();
-
-			for (int i = 0; i < accountCount; ++i) {
-				byte[] signature = new byte[Transformer.SIGNATURE_LENGTH];
-				bytes.get(signature);
-
-				byte[] publicKey = new byte[Transformer.PUBLIC_KEY_LENGTH];
-				bytes.get(publicKey);
-
-				onlineAccounts.add(new OnlineAccountData(timestamp, signature, publicKey));
-			}
-
-			if (bytes.hasRemaining()) {
-				accountCount = bytes.getInt();
-			} else {
-				// we've finished
-				accountCount = 0;
-			}
-		}
-
-		return new OnlineAccountsV2Message(id, onlineAccounts);
-	}
-
-}
--- a/src/main/java/org/qortal/network/message/OnlineAccountsV3Message.java
+++ b/src/main/java/org/qortal/network/message/OnlineAccountsV3Message.java
@@ -99,9 +99,10 @@ public class OnlineAccountsV3Message extends Message {
 				bytes.get(publicKey);

 				// Nonce is optional - will be -1 if missing
+				// ... but we should skip/ignore an online account if it has no nonce
 				Integer nonce = bytes.getInt();
 				if (nonce < 0) {
-					nonce = null;
+					continue;
 				}

 				onlineAccounts.add(new OnlineAccountData(timestamp, signature, publicKey, nonce));
--- a/src/main/java/org/qortal/repository/RepositoryManager.java
+++ b/src/main/java/org/qortal/repository/RepositoryManager.java
@@ -71,11 +71,11 @@ public abstract class RepositoryManager {
 	}

 	public static boolean needsTransactionSequenceRebuild(Repository repository) throws DataException {
-		// Check if we have any unpopulated block_sequence values for the first 1000 blocks
+		// Check if we have any transactions without a block_sequence
 		List<byte[]> testSignatures = repository.getTransactionRepository().getSignaturesMatchingCustomCriteria(
-				null, Arrays.asList("block_height < 1000 AND block_sequence IS NULL"), new ArrayList<>());
+				null, Arrays.asList("block_height IS NOT NULL AND block_sequence IS NULL"), new ArrayList<>(), 100);
 		if (testSignatures.isEmpty()) {
-			// block_sequence already populated for the first 1000 blocks, so assume complete.
+			// block_sequence intact, so assume complete
 			return false;
 		}

@@ -108,7 +108,7 @@ public abstract class RepositoryManager {
 			int blockchainHeight = repository.getBlockRepository().getBlockchainHeight();
 			int totalTransactionCount = 0;

-			for (int height = 1; height < blockchainHeight; ++height) {
+			for (int height = 1; height <= blockchainHeight; ++height) {
 				List<TransactionData> inputTransactions = new ArrayList<>();

 				// Fetch block and transactions
--- a/src/main/java/org/qortal/repository/TransactionRepository.java
+++ b/src/main/java/org/qortal/repository/TransactionRepository.java
@@ -125,6 +125,23 @@ public interface TransactionRepository {
 	public List<byte[]> getSignaturesMatchingCustomCriteria(TransactionType txType, List<String> whereClauses,
 															List<Object> bindParams) throws DataException;

+	/**
+	 * Returns signatures for transactions that match search criteria, with optional limit.
+	 * <p>
+	 * Alternate version that allows for custom where clauses and bind params.
+	 * Only use for very specific use cases, such as the names integrity check.
+	 * Not advised to be used otherwise, given that it could be possible for
+	 * unsanitized inputs to be passed in if not careful.
+	 *
+	 * @param txType
+	 * @param whereClauses
+	 * @param bindParams
+	 * @return
+	 * @throws DataException
+	 */
+	public List<byte[]> getSignaturesMatchingCustomCriteria(TransactionType txType, List<String> whereClauses,
+															List<Object> bindParams, Integer limit) throws DataException;
+
 	/**
 	 * Returns signature for latest auto-update transaction.
 	 * <p>
@@ -297,7 +314,7 @@ public interface TransactionRepository {
 	 * @return list of transactions, or empty if none.
 	 * @throws DataException
 	 */
-	public List<TransactionData> getUnconfirmedTransactions(EnumSet<TransactionType> excludedTxTypes) throws DataException;
+	public List<TransactionData> getUnconfirmedTransactions(EnumSet<TransactionType> excludedTxTypes, Integer limit) throws DataException;

 	/**
 	 * Remove transaction from unconfirmed transactions pile.
--- a/src/main/java/org/qortal/repository/hsqldb/HSQLDBDatabaseUpdates.java
+++ b/src/main/java/org/qortal/repository/hsqldb/HSQLDBDatabaseUpdates.java
@@ -1014,5 +1014,4 @@ public class HSQLDBDatabaseUpdates {
 		LOGGER.info(() -> String.format("HSQLDB repository updated to version %d", databaseVersion + 1));
 		return true;
 	}
-
-}
+}
--- a/src/main/java/org/qortal/repository/hsqldb/transaction/HSQLDBTransactionRepository.java
+++ b/src/main/java/org/qortal/repository/hsqldb/transaction/HSQLDBTransactionRepository.java
@@ -694,6 +694,53 @@ public class HSQLDBTransactionRepository implements TransactionRepository {
 		}
 	}

+	public List<byte[]> getSignaturesMatchingCustomCriteria(TransactionType txType, List<String> whereClauses,
+															List<Object> bindParams, Integer limit) throws DataException {
+		List<byte[]> signatures = new ArrayList<>();
+
+		String txTypeClassName = "";
+		if (txType != null) {
+			txTypeClassName = txType.className;
+		}
+
+		StringBuilder sql = new StringBuilder(1024);
+		sql.append(String.format("SELECT signature FROM %sTransactions", txTypeClassName));
+
+		if (!whereClauses.isEmpty()) {
+			sql.append(" WHERE ");
+
+			final int whereClausesSize = whereClauses.size();
+			for (int wci = 0; wci < whereClausesSize; ++wci) {
+				if (wci != 0)
+					sql.append(" AND ");
+
+				sql.append(whereClauses.get(wci));
+			}
+		}
+
+		if (limit != null) {
+			sql.append(" LIMIT ?");
+			bindParams.add(limit);
+		}
+
+		LOGGER.trace(() -> String.format("Transaction search SQL: %s", sql));
+
+		try (ResultSet resultSet = this.repository.checkedExecute(sql.toString(), bindParams.toArray())) {
+			if (resultSet == null)
+				return signatures;
+
+			do {
+				byte[] signature = resultSet.getBytes(1);
+
+				signatures.add(signature);
+			} while (resultSet.next());
+
+			return signatures;
+		} catch (SQLException e) {
+			throw new DataException("Unable to fetch matching transaction signatures from repository", e);
+		}
+	}
+
 	@Override
 	public byte[] getLatestAutoUpdateTransaction(TransactionType txType, int txGroupId, Integer service) throws DataException {
 		StringBuilder sql = new StringBuilder(1024);
@@ -1382,8 +1429,10 @@ public class HSQLDBTransactionRepository implements TransactionRepository {
 	}

 	@Override
-	public List<TransactionData> getUnconfirmedTransactions(EnumSet<TransactionType> excludedTxTypes) throws DataException {
+	public List<TransactionData> getUnconfirmedTransactions(EnumSet<TransactionType> excludedTxTypes, Integer limit) throws DataException {
 		StringBuilder sql = new StringBuilder(1024);
+		List<Object> bindParams = new ArrayList<>();
+
 		sql.append("SELECT signature FROM UnconfirmedTransactions ");
 		sql.append("JOIN Transactions USING (signature) ");
 		sql.append("WHERE type NOT IN (");
@@ -1399,12 +1448,17 @@ public class HSQLDBTransactionRepository implements TransactionRepository {
 		}

 		sql.append(")");
-		sql.append("ORDER BY created_when, signature");
+		sql.append("ORDER BY created_when, signature ");
+
+		if (limit != null) {
+			sql.append("LIMIT ?");
+			bindParams.add(limit);
+		}

 		List<TransactionData> transactions = new ArrayList<>();

 		// Find transactions with no corresponding row in BlockTransactions
-		try (ResultSet resultSet = this.repository.checkedExecute(sql.toString())) {
+		try (ResultSet resultSet = this.repository.checkedExecute(sql.toString(), bindParams.toArray())) {
 			if (resultSet == null)
 				return transactions;

--- a/src/main/java/org/qortal/settings/Settings.java
+++ b/src/main/java/org/qortal/settings/Settings.java
@@ -29,6 +29,7 @@ import org.qortal.crosschain.Dogecoin.DogecoinNet;
 import org.qortal.crosschain.Digibyte.DigibyteNet;
 import org.qortal.crosschain.Ravencoin.RavencoinNet;
 import org.qortal.crosschain.PirateChain.PirateChainNet;
+import org.qortal.network.message.MessageType;
 import org.qortal.utils.EnumUtils;

 // All properties to be converted to JSON via JAXB
@@ -47,6 +48,9 @@ public class Settings {
 	private static final int MAINNET_GATEWAY_PORT = 80;
 	private static final int TESTNET_GATEWAY_PORT = 8080;

+	private static final int MAINNET_DEV_PROXY_PORT = 12393;
+	private static final int TESTNET_DEV_PROXY_PORT = 62393;
+
 	private static final Logger LOGGER = LogManager.getLogger(Settings.class);
 	private static final String SETTINGS_FILENAME = "settings.json";

@@ -107,6 +111,10 @@ public class Settings {
 	private boolean gatewayLoggingEnabled = false;
 	private boolean gatewayLoopbackEnabled = false;

+	// Developer Proxy
+	private Integer devProxyPort;
+	private boolean devProxyLoggingEnabled = false;
+
 	// Specific to this node
 	private boolean wipeUnconfirmedOnStart = false;
 	/** Maximum number of unconfirmed transactions allowed per account */
@@ -138,6 +146,9 @@ public class Settings {
 	/* How many blocks to cache locally. Defaulted to 10, which covers a typical Synchronizer request + a few spare */
 	private int blockCacheSize = 10;

+	/** Maximum number of transactions for the block minter to include in a block */
+	private int maxTransactionsPerBlock = 50;
+
 	/** How long to keep old, full, AT state data (ms). */
 	private long atStatesMaxLifetime = 5 * 24 * 60 * 60 * 1000L; // milliseconds
 	/** How often to attempt AT state trimming (ms). */
@@ -175,23 +186,19 @@ public class Settings {
 	 * This has a significant effect on execution time. */
 	private int blockPruneBatchSize = 10000; // blocks

-
 	/** Whether we should archive old data to reduce the database size */
 	private boolean archiveEnabled = true;
 	/** How often to attempt archiving (ms). */
 	private long archiveInterval = 7171L; // milliseconds
 	/** Serialization version to use when building an archive */
-	private int defaultArchiveVersion = 1;
-
+	private int defaultArchiveVersion = 2;

 	/** Whether to automatically bootstrap instead of syncing from genesis */
 	private boolean bootstrap = true;

-
 	/** Registered names integrity check */
 	private boolean namesIntegrityCheckEnabled = false;

-
 	// Peer-to-peer related
 	private boolean isTestNet = false;
 	/** Single node testnet mode */
@@ -209,17 +216,17 @@ public class Settings {
 	/** Number of slots to reserve for short-lived QDN data transfers */
 	private int maxDataPeers = 4;
 	/** Maximum number of threads for network engine. */
-	private int maxNetworkThreadPoolSize = 32;
+	private int maxNetworkThreadPoolSize = 120;
 	/** Maximum number of threads for network proof-of-work compute, used during handshaking. */
 	private int networkPoWComputePoolSize = 2;
 	/** Maximum number of retry attempts if a peer fails to respond with the requested data */
 	private int maxRetries = 2;

 	/** The number of seconds of no activity before recovery mode begins */
-	public long recoveryModeTimeout = 24 * 60 * 60 * 1000L;
+	public long recoveryModeTimeout = 9999999999999L;

 	/** Minimum peer version number required in order to sync with them */
-	private String minPeerVersion = "4.0.0";
+	private String minPeerVersion = "4.3.0";
 	/** Whether to allow connections with peers below minPeerVersion
 	 * If true, we won't sync with them but they can still sync with us, and will show in the peers list
 	 * If false, sync will be blocked both ways, and they will not appear in the peers list */
@@ -267,7 +274,7 @@ public class Settings {
 	/** Repository storage path. */
 	private String repositoryPath = "db";
 	/** Repository connection pool size. Needs to be a bit bigger than maxNetworkThreadPoolSize */
-	private int repositoryConnectionPoolSize = 100;
+	private int repositoryConnectionPoolSize = 240;
 	private List<String> fixedNetwork;

 	// Export/import
@@ -278,10 +285,10 @@ public class Settings {

 	// Bootstrap sources
 	private String[] bootstrapHosts = new String[] {
-			"http://bootstrap.qortal.org",
-			"http://bootstrap2.qortal.org",
-			"http://bootstrap3.qortal.org",
-			"http://bootstrap.qortal.online"
+		"http://bootstrap.qortal.org",
+		"http://bootstrap2.qortal.org",
+		"http://bootstrap3.qortal.org",
+		"http://bootstrap.qortal.online"
 	};

 	// Auto-update sources
@@ -300,17 +307,35 @@ public class Settings {
 		"1.pool.ntp.org",
 		"2.pool.ntp.org",
 		"3.pool.ntp.org",
-		"cn.pool.ntp.org",
-		"0.cn.pool.ntp.org",
-		"1.cn.pool.ntp.org",
-		"2.cn.pool.ntp.org",
-		"3.cn.pool.ntp.org"
+		"asia.pool.ntp.org",
+		"0.asia.pool.ntp.org",
+		"1.asia.pool.ntp.org",
+		"2.asia.pool.ntp.org",
+		"3.asia.pool.ntp.org",
+		"europe.pool.ntp.org",
+		"0.europe.pool.ntp.org",
+		"1.europe.pool.ntp.org",
+		"2.europe.pool.ntp.org",
+		"3.europe.pool.ntp.org",
+		"north-america.pool.ntp.org",
+		"0.north-america.pool.ntp.org",
+		"1.north-america.pool.ntp.org",
+		"2.north-america.pool.ntp.org",
+		"3.north-america.pool.ntp.org",
+		"oceania.pool.ntp.org",
+		"0.oceania.pool.ntp.org",
+		"1.oceania.pool.ntp.org",
+		"2.oceania.pool.ntp.org",
+		"3.oceania.pool.ntp.org",
+		"south-america.pool.ntp.org",
+		"0.south-america.pool.ntp.org",
+		"1.south-america.pool.ntp.org",
+		"2.south-america.pool.ntp.org",
+		"3.south-america.pool.ntp.org"
 	};
 	/** Additional offset added to values returned by NTP.getTime() */
 	private Long testNtpOffset = null;

-
-
 	/* Foreign chains */

 	/** The number of consecutive empty addresses required before treating a wallet's transaction set as complete */
@@ -319,8 +344,6 @@ public class Settings {
 	/** How many wallet keys to generate when using bitcoinj as the blockchain interface (e.g. when sending coins) */
 	private int bitcoinjLookaheadSize = 50;

-
-
 	// Data storage (QDN)

 	/** Data storage enabled/disabled*/
@@ -360,6 +383,58 @@ public class Settings {
 	/** Whether to serve QDN data without authentication */
 	private boolean qdnAuthBypassEnabled = true;

+	/** Limit threads per message type */
+	private Set<ThreadLimit> maxThreadsPerMessageType = new HashSet<>();
+
+	/** The number of threads per message type at which a warning should be logged.
+	 * Exclude from settings.json to disable this warning. */
+	private Integer threadCountPerMessageTypeWarningThreshold = null;
+
+
+	// Domain mapping
+	public static class ThreadLimit {
+		private String messageType;
+		private Integer limit;
+
+		private ThreadLimit() { // makes JAXB happy; will never be invoked
+		}
+
+		private ThreadLimit(String messageType, Integer limit) {
+			this.messageType = messageType;
+			this.limit = limit;
+		}
+
+		public String getMessageType() {
+			return messageType;
+		}
+
+		public void setMessageType(String messageType) {
+			this.messageType = messageType;
+		}
+
+		public Integer getLimit() {
+			return limit;
+		}
+
+		public void setLimit(Integer limit) {
+			this.limit = limit;
+		}
+
+		@Override
+		public boolean equals(Object other) {
+			if (!(other instanceof ThreadLimit))
+				return false;
+
+			return this.messageType.equals(((ThreadLimit) other).getMessageType());
+		}
+
+		@Override
+		public int hashCode() {
+			return Objects.hash(messageType);
+		}
+	}
+
+
 	// Domain mapping
 	public static class DomainMap {
 		private String domain;
@@ -385,7 +460,6 @@ public class Settings {
 		}
 	}

-
 	// Constructors

 	private Settings() {
@@ -486,6 +560,9 @@ public class Settings {
 			}
 		} while (settings.userPath != null);

+		// Set some additional defaults if needed
+		settings.setAdditionalDefaults();
+
 		// Validate settings
 		settings.validate();

@@ -522,6 +599,22 @@ public class Settings {
 		}
 	}

+	private void setAdditionalDefaults() {
+		// Populate defaults for maxThreadsPerMessageType. If any are specified in settings.json, they will take priority.
+		maxThreadsPerMessageType.add(new ThreadLimit("ARBITRARY_DATA_FILE", 5));
+		maxThreadsPerMessageType.add(new ThreadLimit("GET_ARBITRARY_DATA_FILE", 5));
+		maxThreadsPerMessageType.add(new ThreadLimit("ARBITRARY_DATA", 5));
+		maxThreadsPerMessageType.add(new ThreadLimit("GET_ARBITRARY_DATA", 5));
+		maxThreadsPerMessageType.add(new ThreadLimit("ARBITRARY_DATA_FILE_LIST", 5));
+		maxThreadsPerMessageType.add(new ThreadLimit("GET_ARBITRARY_DATA_FILE_LIST", 5));
+		maxThreadsPerMessageType.add(new ThreadLimit("ARBITRARY_SIGNATURES", 5));
+		maxThreadsPerMessageType.add(new ThreadLimit("ARBITRARY_METADATA", 5));
+		maxThreadsPerMessageType.add(new ThreadLimit("GET_ARBITRARY_METADATA", 5));
+		maxThreadsPerMessageType.add(new ThreadLimit("GET_TRANSACTION", 10));
+		maxThreadsPerMessageType.add(new ThreadLimit("TRANSACTION_SIGNATURES", 5));
+		maxThreadsPerMessageType.add(new ThreadLimit("TRADE_PRESENCES", 5));
+	}
+
 	// Getters / setters

 	public String getUserPath() {
@@ -649,6 +742,17 @@ public class Settings {
 	}


+	public int getDevProxyPort() {
+		if (this.devProxyPort != null)
+			return this.devProxyPort;
+
+		return this.isTestNet ? TESTNET_DEV_PROXY_PORT : MAINNET_DEV_PROXY_PORT;
+	}
+
+	public boolean isDevProxyLoggingEnabled() {
+		return this.devProxyLoggingEnabled;
+	}
+
 	public boolean getWipeUnconfirmedOnStart() {
 		return this.wipeUnconfirmedOnStart;
 	}
@@ -673,6 +777,10 @@ public class Settings {
 		return this.blockCacheSize;
 	}

+	public int getMaxTransactionsPerBlock() {
+		return this.maxTransactionsPerBlock;
+	}
+
 	public boolean isTestNet() {
 		return this.isTestNet;
 	}
@@ -1027,4 +1135,20 @@ public class Settings {
 		}
 		return this.qdnAuthBypassEnabled;
 	}
+
+	public Integer getMaxThreadsForMessageType(MessageType messageType) {
+		if (maxThreadsPerMessageType != null) {
+			for (ThreadLimit threadLimit : maxThreadsPerMessageType) {
+				if (threadLimit.getMessageType().equals(messageType.name())) {
+					return threadLimit.getLimit();
+				}
+			}
+		}
+		// No entry, so assume unlimited
+		return null;
+	}
+
+	public Integer getThreadCountPerMessageTypeWarningThreshold() {
+		return this.threadCountPerMessageTypeWarningThreshold;
+	}
 }
--- a/src/main/java/org/qortal/transaction/ArbitraryTransaction.java
+++ b/src/main/java/org/qortal/transaction/ArbitraryTransaction.java
@@ -1,6 +1,5 @@
 package org.qortal.transaction;

-import java.util.Arrays;
 import java.util.List;
 import java.util.Objects;
 import java.util.stream.Collectors;
@@ -8,7 +7,6 @@ import java.util.stream.Collectors;
 import org.qortal.account.Account;
 import org.qortal.block.BlockChain;
 import org.qortal.controller.arbitrary.ArbitraryDataManager;
-import org.qortal.controller.arbitrary.ArbitraryDataStorageManager;
 import org.qortal.controller.repository.NamesDatabaseIntegrityCheck;
 import org.qortal.crypto.Crypto;
 import org.qortal.crypto.MemoryPoW;
@@ -88,8 +86,14 @@ public class ArbitraryTransaction extends Transaction {
 		if (this.transactionData.getFee() < 0)
 			return ValidationResult.NEGATIVE_FEE;

-		// After the feature trigger, we require the fee to be sufficient if it's not 0.
-		// If the fee is zero, then the nonce is validated in isSignatureValid() as an alternative to a fee
+		// As of the mempow transaction updates timestamp, a nonce is no longer supported, so a valid fee must be included
+		if (this.transactionData.getTimestamp() >= BlockChain.getInstance().getMemPoWTransactionUpdatesTimestamp()) {
+			// Validate the fee
+			return super.isFeeValid();
+		}
+
+		// After the earlier "optional fee" feature trigger, we required the fee to be sufficient if it wasn't 0.
+		// If the fee was zero, then the nonce was validated in isSignatureValid() as an alternative to a fee
 		if (this.arbitraryTransactionData.getTimestamp() >= BlockChain.getInstance().getArbitraryOptionalFeeTimestamp() && this.arbitraryTransactionData.getFee() != 0L) {
 			return super.isFeeValid();
 		}
@@ -214,7 +218,13 @@ public class ArbitraryTransaction extends Transaction {
 			// Clear nonce from transactionBytes
 			ArbitraryTransactionTransformer.clearNonce(transactionBytes);

-			// As of feature-trigger timestamp, we only require a nonce when the fee is zero
+			// As of the mempow transaction updates timestamp, a nonce is no longer supported, so a fee must be included
+			if (this.transactionData.getTimestamp() >= BlockChain.getInstance().getMemPoWTransactionUpdatesTimestamp()) {
+				// Require that the fee is a positive number. Fee checking itself is performed in isFeeValid()
+				return (this.arbitraryTransactionData.getFee() > 0L);
+			}
+
+			// As of the earlier "optional fee" feature-trigger timestamp, we only required a nonce when the fee was zero
 			boolean beforeFeatureTrigger = this.arbitraryTransactionData.getTimestamp() < BlockChain.getInstance().getArbitraryOptionalFeeTimestamp();
 			if (beforeFeatureTrigger || this.arbitraryTransactionData.getFee() == 0L) {
 				// We only need to check nonce for recent transactions due to PoW verification overhead
--- a/src/main/java/org/qortal/transaction/ChatTransaction.java
+++ b/src/main/java/org/qortal/transaction/ChatTransaction.java
@@ -148,6 +148,12 @@ public class ChatTransaction extends Transaction {
 		// Nothing to do
 	}

+	@Override
+	public boolean isConfirmable() {
+		// CHAT transactions can't go into blocks
+		return false;
+	}
+
 	@Override
 	public ValidationResult isValid() throws DataException {
 		// Nonce checking is done via isSignatureValid() as that method is only called once per import
--- a/src/main/java/org/qortal/transaction/MessageTransaction.java
+++ b/src/main/java/org/qortal/transaction/MessageTransaction.java
@@ -33,7 +33,9 @@ public class MessageTransaction extends Transaction {

 	public static final int MAX_DATA_SIZE = 4000;
 	public static final int POW_BUFFER_SIZE = 8 * 1024 * 1024; // bytes
-	public static final int POW_DIFFICULTY = 14; // leading zero bits
+	public static final int POW_DIFFICULTY_V1 = 14; // leading zero bits
+	public static final int POW_DIFFICULTY_V2_CONFIRMABLE = 16; // leading zero bits
+	public static final int POW_DIFFICULTY_V2_UNCONFIRMABLE = 12; // leading zero bits

 	// Properties

@@ -109,7 +111,17 @@ public class MessageTransaction extends Transaction {
 		MessageTransactionTransformer.clearNonce(transactionBytes);

 		// Calculate nonce
-		this.messageTransactionData.setNonce(MemoryPoW.compute2(transactionBytes, POW_BUFFER_SIZE, POW_DIFFICULTY));
+		this.messageTransactionData.setNonce(MemoryPoW.compute2(transactionBytes, POW_BUFFER_SIZE, getPoWDifficulty()));
+	}
+
+	public int getPoWDifficulty() {
+		// The difficulty changes at the "mempow transactions updates" timestamp
+		if (this.transactionData.getTimestamp() >= BlockChain.getInstance().getMemPoWTransactionUpdatesTimestamp()) {
+			// If this message is confirmable then require a higher difficulty
+			return this.isConfirmable() ? POW_DIFFICULTY_V2_CONFIRMABLE : POW_DIFFICULTY_V2_UNCONFIRMABLE;
+		}
+		// Before feature trigger timestamp, so use existing difficulty value
+		return POW_DIFFICULTY_V1;
 	}

 	/**
@@ -183,6 +195,18 @@ public class MessageTransaction extends Transaction {
 		return super.hasValidReference();
 	}

+	@Override
+	public boolean isConfirmable() {
+		// After feature trigger timestamp, only messages to an AT address can confirm
+		if (this.transactionData.getTimestamp() >= BlockChain.getInstance().getMemPoWTransactionUpdatesTimestamp()) {
+			if (this.messageTransactionData.getRecipient() == null || !this.messageTransactionData.getRecipient().toUpperCase().startsWith("A")) {
+				// Message isn't to an AT address, so this transaction is unconfirmable
+				return false;
+			}
+		}
+		return true;
+	}
+
 	@Override
 	public ValidationResult isValid() throws DataException {
 		// Nonce checking is done via isSignatureValid() as that method is only called once per import
@@ -235,7 +259,7 @@ public class MessageTransaction extends Transaction {
 		MessageTransactionTransformer.clearNonce(transactionBytes);

 		// Check nonce
-		return MemoryPoW.verify2(transactionBytes, POW_BUFFER_SIZE, POW_DIFFICULTY, nonce);
+		return MemoryPoW.verify2(transactionBytes, POW_BUFFER_SIZE, getPoWDifficulty(), nonce);
 	}

 	@Override
@@ -256,6 +280,11 @@ public class MessageTransaction extends Transaction {

 	@Override
 	public void process() throws DataException {
+		// Only certain MESSAGE transactions are able to confirm
+		if (!this.isConfirmable()) {
+			throw new DataException("Unconfirmable MESSAGE transactions should never be processed");
+		}
+
 		// If we have no amount then there's nothing to do
 		if (this.messageTransactionData.getAmount() == 0L)
 			return;
@@ -280,6 +309,11 @@ public class MessageTransaction extends Transaction {

 	@Override
 	public void orphan() throws DataException {
+		// Only certain MESSAGE transactions are able to confirm
+		if (!this.isConfirmable()) {
+			throw new DataException("Unconfirmable MESSAGE transactions should never be orphaned");
+		}
+
 		// If we have no amount then there's nothing to do
 		if (this.messageTransactionData.getAmount() == 0L)
 			return;
--- a/src/main/java/org/qortal/transaction/PresenceTransaction.java
+++ b/src/main/java/org/qortal/transaction/PresenceTransaction.java
@@ -155,6 +155,12 @@ public class PresenceTransaction extends Transaction {
 		// Nothing to do
 	}

+	@Override
+	public boolean isConfirmable() {
+		// PRESENCE transactions can't go into blocks
+		return false;
+	}
+
 	@Override
 	public ValidationResult isValid() throws DataException {
 		// Nonce checking is done via isSignatureValid() as that method is only called once per import
--- a/src/main/java/org/qortal/transaction/PublicizeTransaction.java
+++ b/src/main/java/org/qortal/transaction/PublicizeTransaction.java
@@ -7,6 +7,7 @@ import org.qortal.account.Account;
 import org.qortal.account.PublicKeyAccount;
 import org.qortal.api.resource.TransactionsResource.ConfirmationStatus;
 import org.qortal.asset.Asset;
+import org.qortal.block.BlockChain;
 import org.qortal.crypto.MemoryPoW;
 import org.qortal.data.transaction.PublicizeTransactionData;
 import org.qortal.data.transaction.TransactionData;
@@ -89,6 +90,12 @@ public class PublicizeTransaction extends Transaction {

 	@Override
 	public ValidationResult isValid() throws DataException {
+		// Disable completely after feature-trigger timestamp, at the same time that mempow difficulties are being increased.
+		// It could be enabled again in the future, but preferably with an enforced minimum fee instead of allowing a mempow nonce.
+		if (this.transactionData.getTimestamp() >= BlockChain.getInstance().getMemPoWTransactionUpdatesTimestamp()) {
+			return ValidationResult.NOT_SUPPORTED;
+		}
+
 		// There can be only one
 		List<byte[]> signatures = this.repository.getTransactionRepository().getSignaturesMatchingCriteria(
 				TransactionType.PUBLICIZE,
--- a/src/main/java/org/qortal/transaction/Transaction.java
+++ b/src/main/java/org/qortal/transaction/Transaction.java
@@ -13,6 +13,7 @@ import org.qortal.account.PublicKeyAccount;
 import org.qortal.asset.Asset;
 import org.qortal.block.BlockChain;
 import org.qortal.controller.Controller;
+import org.qortal.controller.TransactionImporter;
 import org.qortal.crypto.Crypto;
 import org.qortal.data.block.BlockData;
 import org.qortal.data.group.GroupApprovalData;
@@ -247,7 +248,8 @@ public abstract class Transaction {
 		GROUP_APPROVAL_REQUIRED(98),
 		ACCOUNT_NOT_TRANSFERABLE(99),
 		INVALID_BUT_OK(999),
-		NOT_YET_RELEASED(1000);
+		NOT_YET_RELEASED(1000),
+		NOT_SUPPORTED(1001);

 		public final int value;

@@ -377,7 +379,7 @@ public abstract class Transaction {
 	 * @return
 	 */
 	public long getUnitFee(Long timestamp) {
-		return BlockChain.getInstance().getUnitFee();
+		return BlockChain.getInstance().getUnitFeeAtTimestamp(timestamp);
 	}

 	/**
@@ -617,7 +619,10 @@ public abstract class Transaction {
 	}

 	private int countUnconfirmedByCreator(PublicKeyAccount creator) throws DataException {
-		List<TransactionData> unconfirmedTransactions = repository.getTransactionRepository().getUnconfirmedTransactions();
+		List<TransactionData> unconfirmedTransactions = TransactionImporter.getInstance().unconfirmedTransactionsCache;
+		if (unconfirmedTransactions == null) {
+			unconfirmedTransactions = repository.getTransactionRepository().getUnconfirmedTransactions();
+		}

 		// We exclude CHAT transactions as they never get included into blocks and
 		// have spam/DoS prevention by requiring proof of work
@@ -632,7 +637,7 @@ public abstract class Transaction {
 	}

 	/**
-	 * Returns sorted, unconfirmed transactions, excluding invalid.
+	 * Returns sorted, unconfirmed transactions, excluding invalid and unconfirmable.
 	 * 
 	 * @return sorted, unconfirmed transactions
 	 * @throws DataException
@@ -641,7 +646,7 @@ public abstract class Transaction {
 		BlockData latestBlockData = repository.getBlockRepository().getLastBlock();

 		EnumSet<TransactionType> excludedTxTypes = EnumSet.of(TransactionType.CHAT, TransactionType.PRESENCE);
-		List<TransactionData> unconfirmedTransactions = repository.getTransactionRepository().getUnconfirmedTransactions(excludedTxTypes);
+		List<TransactionData> unconfirmedTransactions = repository.getTransactionRepository().getUnconfirmedTransactions(excludedTxTypes, null);

 		unconfirmedTransactions.sort(getDataComparator());

@@ -650,7 +655,8 @@ public abstract class Transaction {
 			TransactionData transactionData = unconfirmedTransactionsIterator.next();
 			Transaction transaction = Transaction.fromData(repository, transactionData);

-			if (transaction.isStillValidUnconfirmed(latestBlockData.getTimestamp()) != ValidationResult.OK)
+			// Must be confirmable and valid
+			if (!transaction.isConfirmable() || transaction.isStillValidUnconfirmed(latestBlockData.getTimestamp()) != ValidationResult.OK)
 				unconfirmedTransactionsIterator.remove();
 		}

@@ -888,6 +894,17 @@ public abstract class Transaction {
 		/* To be optionally overridden */
 	}

+	/**
+	 * Returns whether transaction is 'confirmable' - i.e. is of a type that
+	 * can be included in a block. Some transactions are 'unconfirmable'
+	 * and therefore must remain in the mempool until they expire.
+	 * @return
+	 */
+	public boolean isConfirmable() {
+		/* To be optionally overridden */
+		return true;
+	}
+
 	/**
 	 * Returns whether transaction can be added to the blockchain.
 	 * <p>
--- a/src/main/resources/blockchain.json
+++ b/src/main/resources/blockchain.json
@@ -3,8 +3,12 @@
 	"transactionExpiryPeriod": 86400000,
 	"maxBlockSize": 2097152,
 	"maxBytesPerUnitFee": 1024,
-	"unitFee": "0.001",
+	"unitFees": [
+		{ "timestamp": 0, "fee": "0.001" },
+		{ "timestamp": 1692118800000, "fee": "0.01" }
+	],
 	"nameRegistrationUnitFees": [
+		{ "timestamp": 0, "fee": "0.001" },
 		{ "timestamp": 1645372800000, "fee": "5" },
 		{ "timestamp": 1651420800000, "fee": "1.25" }
 	],
@@ -18,13 +22,15 @@
 	"maxRewardSharesPerFounderMintingAccount": 6,
 	"maxRewardSharesByTimestamp": [
 		{ "timestamp": 0, "maxShares": 6 },
-		{ "timestamp": 1657382400000, "maxShares": 3 }
+		{ "timestamp": 1657382400000, "maxShares": 3 },
+		{ "timestamp": 1698508800000, "maxShares": 2 }
 	],
 	"founderEffectiveMintingLevel": 10,
 	"onlineAccountSignaturesMinLifetime": 43200000,
 	"onlineAccountSignaturesMaxLifetime": 86400000,
 	"onlineAccountsModulusV2Timestamp": 1659801600000,
 	"selfSponsorshipAlgoV1SnapshotTimestamp": 1670230000000,
+	"mempowTransactionUpdatesTimestamp": 1693558800000,
 	"rewardsByHeight": [
 		{ "height": 1, "reward": 5.00 },
 		{ "height": 259201, "reward": 4.75 },
--- a/src/main/resources/i18n/ApiError_de.properties
+++ b/src/main/resources/i18n/ApiError_de.properties
@@ -4,52 +4,52 @@
 # "localeLang": "de",

 ### Common ###
-JSON = JSON Nachricht konnte nicht geparst werden
+JSON = JSON-Nachricht konnte nicht geparst werden

-INSUFFICIENT_BALANCE = Kein Ausgleich
+INSUFFICIENT_BALANCE = Guthaben reicht nicht aus

 UNAUTHORIZED = API-Aufruf nicht autorisiert

 REPOSITORY_ISSUE = Repository-Fehler

-NON_PRODUCTION = Dieser APi-Aufruf ist nicht gestattet für Produtkion
+NON_PRODUCTION = dieser API-Aufruf ist für Produktionssysteme nicht gestattet

-BLOCKCHAIN_NEEDS_SYNC = Blockchain muss sich erst verbinden
+BLOCKCHAIN_NEEDS_SYNC = Blockchain muss sich erst synchronisieren

-NO_TIME_SYNC = noch keine Uhrensynchronisation
+NO_TIME_SYNC = Uhrzeit noch nicht synchronisiert

 ### Validation ###
-INVALID_SIGNATURE = ungültige Signatur
+INVALID_SIGNATURE = Signatur ungültig

-INVALID_ADDRESS = ungültige Adresse
+INVALID_ADDRESS = Adresse ungültig

-INVALID_PUBLIC_KEY = ungültiger public key
+INVALID_PUBLIC_KEY = öffentlicher Schlüssel ungültig

-INVALID_DATA = ungültige Daten
+INVALID_DATA = Daten ungültig

-INVALID_NETWORK_ADDRESS = ungültige Netzwerk Adresse
+INVALID_NETWORK_ADDRESS = Netzwerk Adresse ungültig

-ADDRESS_UNKNOWN = Account Adresse unbekannt
+ADDRESS_UNKNOWN = Kontoadresse unbekannt

-INVALID_CRITERIA = ungültige Suchkriterien
+INVALID_CRITERIA = Suchkriterien ungültig

-INVALID_REFERENCE = ungültige Referenz
+INVALID_REFERENCE = Referenz ungültig

 TRANSFORMATION_ERROR = konnte JSON nicht in eine Transaktion umwandeln

-INVALID_PRIVATE_KEY = ungültiger private key
+INVALID_PRIVATE_KEY = öffentlicher Schlüssel ungültig

-INVALID_HEIGHT = ungültige block height
+INVALID_HEIGHT = Blockhöhe ungültig

-CANNOT_MINT = Account kann nicht minten
+CANNOT_MINT = Konto kann nicht prägen

 ### Blocks ###
-BLOCK_UNKNOWN = block unbekannt
+BLOCK_UNKNOWN = Block unbekannt

 ### Transactions ###
 TRANSACTION_UNKNOWN = Transaktion unbekannt

-PUBLIC_KEY_NOT_FOUND = public key wurde nicht gefunden
+PUBLIC_KEY_NOT_FOUND = öffentlicher Schlüssel wurde nicht gefunden

 # this one is special in that caller expected to pass two additional strings, hence the two %s
 TRANSACTION_INVALID = Transaktion ungültig: %s (%s)
@@ -58,19 +58,19 @@ TRANSACTION_INVALID = Transaktion ungültig: %s (%s)
 NAME_UNKNOWN = Name unbekannt

 ### Asset ###
-INVALID_ASSET_ID = ungültige asset ID
+INVALID_ASSET_ID = Vermögenswert-Kennung ungültig

-INVALID_ORDER_ID = ungültige asset order ID
+INVALID_ORDER_ID = Vermögenswert-Auftragssnummer ungültig

-ORDER_UNKNOWN = unbekannte asset order ID
+ORDER_UNKNOWN = Vermögenswert-Auftragssnummer unbekannt

 ### Groups ###
 GROUP_UNKNOWN = Gruppe unbekannt

 ### Foreign Blockchain ###
-FOREIGN_BLOCKCHAIN_NETWORK_ISSUE = fremde Blockchain oder ElectrumX Netzwerk Problem
+FOREIGN_BLOCKCHAIN_NETWORK_ISSUE = fremde Blockchain oder ElectrumX Netzwerkproblem

-FOREIGN_BLOCKCHAIN_BALANCE_ISSUE = unzureichend Bilanz auf fremde blockchain
+FOREIGN_BLOCKCHAIN_BALANCE_ISSUE = unzureichendes Guthaben auf fremder blockchain

 FOREIGN_BLOCKCHAIN_TOO_SOON = zu früh um fremde Blockchain-Transaktionen zu übertragen (Sperrzeit/mittlere Blockzeit)

@@ -80,4 +80,4 @@ ORDER_SIZE_TOO_SMALL = Bestellmenge zu niedrig
 ### Data ###
 FILE_NOT_FOUND = Datei nicht gefunden

-NO_REPLY = Peer hat nicht mit Daten verbinden
+NO_REPLY = Peer hat nicht in vorgegebener Zeit geantwortet
--- a/src/main/resources/i18n/ApiError_jp.properties
+++ b/src/main/resources/i18n/ApiError_jp.properties
@@ -0,0 +1,83 @@
+#Generated by ResourceBundle Editor (http://essiembre.github.io/eclipse-rbe/)
+# Keys are from api.ApiError enum
+
+# "localeLang": "jp",
+
+### Common ###
+JSON = JSON メッセージの解析に失敗しました
+
+INSUFFICIENT_BALANCE = 残高不足
+
+UNAUTHORIZED = APIコール未承認
+
+REPOSITORY_ISSUE = リポジトリエラー
+
+NON_PRODUCTION = この APIコールはプロダクションシステムでは許可されていません
+
+BLOCKCHAIN_NEEDS_SYNC = ブロックチェーンをまず同期する必要があります
+
+NO_TIME_SYNC = 時刻が未同期
+
+### Validation ###
+INVALID_SIGNATURE = 無効な署名
+
+INVALID_ADDRESS = 無効なアドレス
+
+INVALID_PUBLIC_KEY = 無効な公開鍵
+
+INVALID_DATA = 無効なデータ
+
+INVALID_NETWORK_ADDRESS = 無効なネットワーク アドレス
+
+ADDRESS_UNKNOWN = 不明なアカウントアドレス
+
+INVALID_CRITERIA = 無効な検索条件
+
+INVALID_REFERENCE = 無効な参照
+
+TRANSFORMATION_ERROR = JSONをトランザクションに変換出来ませんでした
+
+INVALID_PRIVATE_KEY = 無効な秘密鍵
+
+INVALID_HEIGHT = 無効なブロック高
+
+CANNOT_MINT = アカウントはミント出来ません
+
+### Blocks ###
+BLOCK_UNKNOWN = 不明なブロック
+
+### Transactions ###
+TRANSACTION_UNKNOWN = 不明なトランザクション
+
+PUBLIC_KEY_NOT_FOUND = 公開鍵が見つかりません
+
+# this one is special in that caller expected to pass two additional strings, hence the two %s
+TRANSACTION_INVALID = 無効なトランザクション: %s (%s)
+
+### Naming ###
+NAME_UNKNOWN = 不明な名前
+
+### Asset ###
+INVALID_ASSET_ID = 無効なアセット ID
+
+INVALID_ORDER_ID = 無効なアセット注文 ID
+
+ORDER_UNKNOWN = 不明なアセット注文 ID
+
+### Groups ###
+GROUP_UNKNOWN = 不明なグループ
+
+### Foreign Blockchain ###
+FOREIGN_BLOCKCHAIN_NETWORK_ISSUE = 外部ブロックチェーンまたはElectrumXネットワークの問題
+
+FOREIGN_BLOCKCHAIN_BALANCE_ISSUE = 外部ブロックチェーンの残高が不足しています
+
+FOREIGN_BLOCKCHAIN_TOO_SOON = 外部ブロックチェーン トランザクションのブロードキャストが時期尚早 (ロックタイム/ブロック時間の中央値)
+
+### Trade Portal ###
+ORDER_SIZE_TOO_SMALL = 注文金額が低すぎます
+
+### Data ###
+FILE_NOT_FOUND = ファイルが見つかりません
+
+NO_REPLY = ピアが制限時間内に応答しませんでした
--- a/src/main/resources/i18n/SysTray_de.properties
+++ b/src/main/resources/i18n/SysTray_de.properties
@@ -1,7 +1,7 @@
 #Generated by ResourceBundle Editor (http://essiembre.github.io/eclipse-rbe/)
 # SysTray pop-up menu

-APPLYING_UPDATE_AND_RESTARTING = Automatisches Update anwenden und neu starten …
+APPLYING_UPDATE_AND_RESTARTING = Automatisches Update anwenden und neu starten...

 AUTO_UPDATE = Automatisches Update

@@ -19,7 +19,7 @@ CONNECTION = Verbindung

 CONNECTIONS = Verbindungen

-CREATING_BACKUP_OF_DB_FILES = Erstellen Backup von Datenbank Dateien …
+CREATING_BACKUP_OF_DB_FILES = Erstelle Backup von Datenbank Dateien...

 DB_BACKUP = Datenbank Backup

@@ -31,18 +31,18 @@ EXIT = Verlassen

 LITE_NODE = Lite node

-MINTING_DISABLED = Kein minting
+MINTING_DISABLED = Münzprägung inaktiv

-MINTING_ENABLED = \u2714 Minting aktiviert 
+MINTING_ENABLED = \u2714 Münzprägung aktiv

-OPEN_UI = Öffne UI
+OPEN_UI = Öffne Benutzeroberfläche

-PERFORMING_DB_CHECKPOINT = Speichern von unbestätigten Datenbankänderungen...
+PERFORMING_DB_CHECKPOINT = Speichere unerfasste Datenbankänderungen...

-PERFORMING_DB_MAINTENANCE = Planmäßige Wartung durchführen...
+PERFORMING_DB_MAINTENANCE = Planmäßige Wartung wird durchgeführt...

-SYNCHRONIZE_CLOCK = Synchronisiere Uhr
+SYNCHRONIZE_CLOCK = Synchronisiere Uhrzeit

-SYNCHRONIZING_BLOCKCHAIN = Synchronisierung der Blockchain
+SYNCHRONIZING_BLOCKCHAIN = Synchronisiere

-SYNCHRONIZING_CLOCK = Synchronisierung der Uhr
+SYNCHRONIZING_CLOCK = Uhrzeit wird synchronisiert
--- a/src/main/resources/i18n/SysTray_jp.properties
+++ b/src/main/resources/i18n/SysTray_jp.properties
@@ -0,0 +1,48 @@
+#Generated by ResourceBundle Editor (http://essiembre.github.io/eclipse-rbe/)
+# SysTray pop-up menu # Japanese translation by R M 2023
+
+APPLYING_UPDATE_AND_RESTARTING = 自動更新を適用して再起動しています...
+
+AUTO_UPDATE = 自動更新
+
+BLOCK_HEIGHT = ブロック高
+
+BLOCKS_REMAINING = 残りのブロック
+
+BUILD_VERSION = ビルドバージョン
+
+CHECK_TIME_ACCURACY = 時刻の精度を確認
+
+CONNECTING = 接続中
+
+CONNECTION = 接続
+
+CONNECTIONS = 接続
+
+CREATING_BACKUP_OF_DB_FILES = データベース ファイルのバックアップを作成中...
+
+DB_BACKUP = データベースのバックアップ
+
+DB_CHECKPOINT = データベースのチェックポイント
+
+DB_MAINTENANCE = データベースのメンテナンス
+
+EXIT = 終了
+
+LITE_NODE = ライトノード
+
+MINTING_DISABLED = ミント一時中止中
+
+MINTING_ENABLED = \u2714 ミント
+
+OPEN_UI = UIを開く
+
+PERFORMING_DB_CHECKPOINT = コミットされていないデータベースの変更を保存中...
+
+PERFORMING_DB_MAINTENANCE = 定期メンテナンスを実行中...
+
+SYNCHRONIZE_CLOCK = 時刻を同期
+
+SYNCHRONIZING_BLOCKCHAIN = ブロックチェーンを同期中
+
+SYNCHRONIZING_CLOCK = 時刻を同期中
--- a/src/main/resources/i18n/TransactionValidity_de.properties
+++ b/src/main/resources/i18n/TransactionValidity_de.properties
@@ -1,60 +1,60 @@
 #

-ACCOUNT_ALREADY_EXISTS = Account existiert bereits
+ACCOUNT_ALREADY_EXISTS = Konto existiert bereits

-ACCOUNT_CANNOT_REWARD_SHARE = Account kann keine Belohnung teilen
+ACCOUNT_CANNOT_REWARD_SHARE = Konto kann nicht an Belohnungsbeteiligung teilnehmen

-ADDRESS_ABOVE_RATE_LIMIT = address hat das angegebene Geschwindigkeitlimit erreicht 
+ADDRESS_ABOVE_RATE_LIMIT = Adresse hat festgelegtes Tarif-Limit erreicht

-ADDRESS_BLOCKED =  Addresse ist geblockt
+ADDRESS_BLOCKED = diese Adresse ist gesperrt

-ALREADY_GROUP_ADMIN = bereits Gruppen Admin
+ALREADY_GROUP_ADMIN = bereits Gruppenadmin

-ALREADY_GROUP_MEMBER = bereits Gruppen Mitglied
+ALREADY_GROUP_MEMBER = bereits Gruppenmitglied

 ALREADY_VOTED_FOR_THAT_OPTION = bereits für diese Option gestimmt

-ASSET_ALREADY_EXISTS = asset existiert bereits
+ASSET_ALREADY_EXISTS = Vermögenswert existiert bereits

-ASSET_DOES_NOT_EXIST = asset nicht gefunden 
+ASSET_DOES_NOT_EXIST = Vermögenswert existiert nicht

-ASSET_DOES_NOT_MATCH_AT = asset passt nicht mit AT's asset
+ASSET_DOES_NOT_MATCH_AT = Vermögenswert stimmt nicht mit dem Vermögenswert von AT überein

-ASSET_NOT_SPENDABLE = asset ist nicht ausgabefähig
+ASSET_NOT_SPENDABLE = Vermögenswert ist nicht auszahlbar

 AT_ALREADY_EXISTS = AT existiert bereits

-AT_IS_FINISHED = AT ist fertig 
+AT_IS_FINISHED = AT ist beendet

-AT_UNKNOWN = AT unbekannt 
+AT_UNKNOWN = AT unbekannt

-BAN_EXISTS = ban besteht bereits
+BAN_EXISTS = Bann ist bereits vorhanden

-BAN_UNKNOWN = ban unbekannt
+BAN_UNKNOWN = Bann unbekannt

-BANNED_FROM_GROUP = von der gruppe gebannt
+BANNED_FROM_GROUP = aus der Gruppe verbannt

-BUYER_ALREADY_OWNER = Käufer ist bereits Besitzer 
+BUYER_ALREADY_OWNER = Käufer ist bereits Eigentümer

-CLOCK_NOT_SYNCED = Uhr nicht synchronisiert
+CLOCK_NOT_SYNCED = Uhrzeit ist nicht synchronisiert

-DUPLICATE_MESSAGE = Adresse sendete doppelte Nachricht
+DUPLICATE_MESSAGE = Adresse hat doppelte Nachricht gesendet

-DUPLICATE_OPTION = Duplizierungsmöglichkeit
+DUPLICATE_OPTION = doppelte Option

-GROUP_ALREADY_EXISTS = Gruppe besteht bereits
+GROUP_ALREADY_EXISTS = Gruppe existiert bereits

-GROUP_APPROVAL_DECIDED = Gruppenfreigabe bereits beschlossen
+GROUP_APPROVAL_DECIDED = Gruppenzulassung bereits beschlossen

-GROUP_APPROVAL_NOT_REQUIRED = Gruppenfreigabe nicht erforderlich
+GROUP_APPROVAL_NOT_REQUIRED = Gruppenzustimmung nicht erforderlich

-GROUP_DOES_NOT_EXIST = Gruppe nicht vorhanden
+GROUP_DOES_NOT_EXIST = Gruppe existiert nicht

 GROUP_ID_MISMATCH = Gruppen-ID stimmt nicht überein

-GROUP_OWNER_CANNOT_LEAVE = Gruppenbesitzer kann Gruppe nicht verlassen
+GROUP_OWNER_CANNOT_LEAVE = Gruppeneigentümer kann Gruppe nicht verlassen

-HAVE_EQUALS_WANT = das bessesene-asset ist das selbe wie das gesuchte-asset
+HAVE_EQUALS_WANT = Haben-Vermögenswert ist derselbe wie Wollen-Vermögenswert

 INCORRECT_NONCE = falsche PoW-Nonce

@@ -64,81 +64,81 @@ INVALID_ADDRESS = ungültige Adresse

 INVALID_AMOUNT = ungültiger Betrag

-INVALID_ASSET_OWNER = Ungültiger Eigentümer
+INVALID_ASSET_OWNER = ungültiger Vermögenswert-Eigentümer

 INVALID_AT_TRANSACTION = ungültige AT-Transaktion

-INVALID_AT_TYPE_LENGTH = ungültige AT 'Typ' Länge
+INVALID_AT_TYPE_LENGTH = ungültige AT-Typ-Länge

-INVALID_BUT_OK = ungültig aber OK
+INVALID_BUT_OK = ungültig, aber OK

-INVALID_CREATION_BYTES = ungültige Erstellungs der bytes
+INVALID_CREATION_BYTES = ungültige Erstellungsbytes

-INVALID_DATA_LENGTH = ungültige Datenlänge
+INVALID_DATA_LENGTH = unzulässige Datenlänge

-INVALID_DESCRIPTION_LENGTH = ungültige Länge der Beschreibung
+INVALID_DESCRIPTION_LENGTH = unzulässige Länge der Beschreibung

 INVALID_GROUP_APPROVAL_THRESHOLD = ungültiger Schwellenwert für die Gruppenzulassung

-INVALID_GROUP_BLOCK_DELAY = Ungültige Blockverzögerung der Gruppenfreigabe
+INVALID_GROUP_BLOCK_DELAY = ungültige Blockverzögerung bei der Gruppenfreigabe

 INVALID_GROUP_ID = ungültige Gruppen-ID

-INVALID_GROUP_OWNER = ungültiger Gruppenbesitzer
+INVALID_GROUP_OWNER = ungültiger Gruppeneigentümer

-INVALID_LIFETIME = unzulässige Lebensdauer
+INVALID_LIFETIME = unzulässige Gültigkeitsdauer

 INVALID_NAME_LENGTH = ungültige Namenslänge

-INVALID_NAME_OWNER = ungültiger Besitzername 
+INVALID_NAME_OWNER = ungültiger Eigentümer des Namens

 INVALID_OPTION_LENGTH = ungültige Länge der Optionen

-INVALID_OPTIONS_COUNT = Anzahl ungültiger Optionen
+INVALID_OPTIONS_COUNT = ungültige Anzahl von Optionen

 INVALID_ORDER_CREATOR = ungültiger Auftragsersteller

-INVALID_PAYMENTS_COUNT = Anzahl ungültiger Zahlungen
+INVALID_PAYMENTS_COUNT = ungültige Anzahl der Zahlungen

 INVALID_PUBLIC_KEY = ungültiger öffentlicher Schlüssel

-INVALID_QUANTITY = unzulässige Menge
+INVALID_QUANTITY = ungültige Menge

 INVALID_REFERENCE = ungültige Referenz

 INVALID_RETURN = ungültige Rückgabe

-INVALID_REWARD_SHARE_PERCENT = ungültig Prozent der Belohnunganteile 
+INVALID_REWARD_SHARE_PERCENT = ungültiger Belohnungsbeteiligungs-Anteil

-INVALID_SELLER = unzulässiger Verkäufer
+INVALID_SELLER = ungültiger Verkäufer

 INVALID_TAGS_LENGTH = ungültige 'tags'-Länge

-INVALID_TIMESTAMP_SIGNATURE = Ungültige Zeitstempel-Signatur
+INVALID_TIMESTAMP_SIGNATURE = ungültige Zeitstempel-Signatur

-INVALID_TX_GROUP_ID = Ungültige Transaktionsgruppen-ID
+INVALID_TX_GROUP_ID = ungültige Transaktionsgruppen-ID

-INVALID_VALUE_LENGTH = ungültige 'Wert'-Länge
+INVALID_VALUE_LENGTH = ungültige 'value'-Länge

 INVITE_UNKNOWN = Gruppeneinladung unbekannt

-JOIN_REQUEST_EXISTS = Gruppeneinladung existiert bereits
+JOIN_REQUEST_EXISTS = Gruppenverbindungsanfrage existiert bereits

-MAXIMUM_REWARD_SHARES = die maximale Anzahl von Reward-Shares für dieses Konto erreicht
+MAXIMUM_REWARD_SHARES = maximale Anzahl von Belohnungsbeteiligungen für dieses Konto bereits erreicht

 MISSING_CREATOR = fehlender Ersteller

-MULTIPLE_NAMES_FORBIDDEN = mehrere registrierte Namen pro Konto sind untersagt
+MULTIPLE_NAMES_FORBIDDEN = mehrere registrierte Namen pro Konto sind verboten

-NAME_ALREADY_FOR_SALE = Name bereits zum Verkauf
+NAME_ALREADY_FOR_SALE = Name steht bereits zum Verkauf

 NAME_ALREADY_REGISTERED = Name bereits registriert

-NAME_BLOCKED = Name geblockt
+NAME_BLOCKED = dieser Name ist gesperrt

-NAME_DOES_NOT_EXIST = Name nicht vorhanden
+NAME_DOES_NOT_EXIST = Name existiert nicht

-NAME_NOT_FOR_SALE = Name ist unverkäuflich
+NAME_NOT_FOR_SALE = Name steht nicht zum Verkauf

 NAME_NOT_NORMALIZED = Name nicht in Unicode-'normalisierter' Form

@@ -150,46 +150,46 @@ NEGATIVE_PRICE = ungültiger/negativer Preis

 NO_BALANCE = unzureichendes Guthaben

-NO_BLOCKCHAIN_LOCK = die Blockchain des Knotens ist beschäftigt
+NO_BLOCKCHAIN_LOCK = die Blockchain des Knotens ist derzeit beschäftigt

 NO_FLAG_PERMISSION = Konto hat diese Berechtigung nicht

-NOT_GROUP_ADMIN = Account ist kein Gruppenadmin
+NOT_GROUP_ADMIN = Konto ist kein Gruppenadmin

-NOT_GROUP_MEMBER = Account kein Gruppenmitglied 
+NOT_GROUP_MEMBER = Konto ist kein Gruppenmitglied

-NOT_MINTING_ACCOUNT = Account kann nicht minten
+NOT_MINTING_ACCOUNT = Konto kann nicht prägen

 NOT_YET_RELEASED = Funktion noch nicht freigegeben

 OK = OK

-ORDER_ALREADY_CLOSED = Asset Trade Order ist bereits geschlossen
+ORDER_ALREADY_CLOSED = Vermögenswert-Handelsauftrag ist bereits geschlossen

-ORDER_DOES_NOT_EXIST = asset trade order existiert nicht
+ORDER_DOES_NOT_EXIST = Vermögenswert-Handelsauftrag existiert nicht

-POLL_ALREADY_EXISTS = Umfrage bereits vorhanden
+POLL_ALREADY_EXISTS = Umfrage existiert bereits

-POLL_DOES_NOT_EXIST = Umfrage nicht vorhanden
+POLL_DOES_NOT_EXIST = Umfrage existiert nicht

-POLL_OPTION_DOES_NOT_EXIST = Umfrageoption existiert nicht
+POLL_OPTION_DOES_NOT_EXIST = Umfrageoption nicht vorhanden

 PUBLIC_KEY_UNKNOWN = öffentlicher Schlüssel unbekannt

-REWARD_SHARE_UNKNOWN = Geteilte Belohnungen unbekant
+REWARD_SHARE_UNKNOWN = Belohnungsbeteiligung unbekannt

-SELF_SHARE_EXISTS = Selbstbeteiligung (Geteilte Belohnungen) sind breits vorhanden
+SELF_SHARE_EXISTS = Selbst-Beteiligung (Belohnungsbeteiligung) existiert bereits

 TIMESTAMP_TOO_NEW = Zeitstempel zu neu

 TIMESTAMP_TOO_OLD = Zeitstempel zu alt

-TOO_MANY_UNCONFIRMED = Account hat zu viele unbestätigte Transaktionen am laufen
+TOO_MANY_UNCONFIRMED = Konto hat zu viele ausstehende unbestätigte Transaktionen

-TRANSACTION_ALREADY_CONFIRMED = Transaktionen sind bereits bestätigt
+TRANSACTION_ALREADY_CONFIRMED = Transaktion wurde bereits bestätigt

-TRANSACTION_ALREADY_EXISTS = Transaktionen existiert bereits
+TRANSACTION_ALREADY_EXISTS = Transaktion existiert bereits

-TRANSACTION_UNKNOWN = Unbekante Transaktion
+TRANSACTION_UNKNOWN = Transaktion unbekannt

-TX_GROUP_ID_MISMATCH = Transaktion Gruppen ID stimmt nicht überein
+TX_GROUP_ID_MISMATCH = die Gruppen-ID der Transaktion stimmt nicht überein
--- a/src/main/resources/i18n/TransactionValidity_jp.properties
+++ b/src/main/resources/i18n/TransactionValidity_jp.properties
@@ -0,0 +1,195 @@
+#
+
+ACCOUNT_ALREADY_EXISTS = 既にアカウントは存在します
+
+ACCOUNT_CANNOT_REWARD_SHARE = アカウントは報酬シェアが出来ません
+
+ADDRESS_ABOVE_RATE_LIMIT = アドレスが指定されたレート制限に達しました
+
+ADDRESS_BLOCKED = このアドレスはブロックされています
+
+ALREADY_GROUP_ADMIN = 既ににグループ管理者です
+
+ALREADY_GROUP_MEMBER = 既にグループメンバーです
+
+ALREADY_VOTED_FOR_THAT_OPTION = 既にそのオプションに投票しています
+
+ASSET_ALREADY_EXISTS = 既にアセットは存在します
+
+ASSET_DOES_NOT_EXIST = アセットが存在しません
+
+ASSET_DOES_NOT_MATCH_AT = アセットがATのアセットと一致しません
+
+ASSET_NOT_SPENDABLE = 資産が使用不可です
+
+AT_ALREADY_EXISTS = 既にATが存在します
+
+AT_IS_FINISHED = ATが終了しました
+
+AT_UNKNOWN = 不明なAT
+
+BAN_EXISTS = 既にバンされてます
+
+BAN_UNKNOWN = 不明なバン
+
+BANNED_FROM_GROUP = グループからのバンされています
+
+BUYER_ALREADY_OWNER = 既に購入者が所有者です
+
+CLOCK_NOT_SYNCED = 時刻が未同期
+
+DUPLICATE_MESSAGE = このアドレスは重複メッセージを送信しました
+
+DUPLICATE_OPTION = 重複したオプション
+
+GROUP_ALREADY_EXISTS = 既にグループは存在します
+
+GROUP_APPROVAL_DECIDED = 既にグループの承認は決定されています
+
+GROUP_APPROVAL_NOT_REQUIRED = グループ承認が不必要
+
+GROUP_DOES_NOT_EXIST = グループが存在しません
+
+GROUP_ID_MISMATCH = グループ ID が不一致
+
+GROUP_OWNER_CANNOT_LEAVE = グループ所有者はグループを退会出来ません
+
+HAVE_EQUALS_WANT = 持っている資産は欲しい資産と同じです
+
+INCORRECT_NONCE = 不正な PoW ナンス
+
+INSUFFICIENT_FEE = 手数料が不十分です
+
+INVALID_ADDRESS = 無効なアドレス
+
+INVALID_AMOUNT = 無効な金額
+
+INVALID_ASSET_OWNER = 無効なアセット所有者
+
+INVALID_AT_TRANSACTION = 無効なATトランザクション
+
+INVALID_AT_TYPE_LENGTH = 無効なATの「タイプ」の長さです
+
+INVALID_BUT_OK = 無効だがOK
+
+INVALID_CREATION_BYTES = 無効な作成バイト数
+
+INVALID_DATA_LENGTH = 無効なデータ長
+
+INVALID_DESCRIPTION_LENGTH = 無効な概要の長さ
+
+INVALID_GROUP_APPROVAL_THRESHOLD = 無効なグループ承認のしきい値
+
+INVALID_GROUP_BLOCK_DELAY = 無効なグループ承認のブロック遅延
+
+INVALID_GROUP_ID = 無効なグループ ID
+
+INVALID_GROUP_OWNER = 無効なグループ所有者
+
+INVALID_LIFETIME = 無効な有効期間
+
+INVALID_NAME_LENGTH = 無効な名前の長さです
+
+INVALID_NAME_OWNER = 無効な名前の所有者
+
+INVALID_OPTION_LENGTH = 無効なオプションの長さ
+
+INVALID_OPTIONS_COUNT = 無効なオプションの数
+
+INVALID_ORDER_CREATOR = 無効な注文作成者
+
+INVALID_PAYMENTS_COUNT = 無効な入出金数
+
+INVALID_PUBLIC_KEY = 無効な公開鍵
+
+INVALID_QUANTITY = 無効な数量
+
+INVALID_REFERENCE = 無効な参照
+
+INVALID_RETURN = 無効な返品
+
+INVALID_REWARD_SHARE_PERCENT = 無効な報酬シェア率
+
+INVALID_SELLER = 無効な販売者
+
+INVALID_TAGS_LENGTH = 無効な「タグ」の長さ
+
+INVALID_TIMESTAMP_SIGNATURE = 無効なタイムスタンプ署名
+
+INVALID_TX_GROUP_ID = 無効なトランザクション グループ ID
+
+INVALID_VALUE_LENGTH = 無効な「値」の長さ
+
+INVITE_UNKNOWN = 不明なグループ招待
+
+JOIN_REQUEST_EXISTS = 既にグループ参加リクエストが存在します
+
+MAXIMUM_REWARD_SHARES = 既にこのアカウントの報酬シェアは最大です
+
+MISSING_CREATOR = 作成者が見つかりません
+
+MULTIPLE_NAMES_FORBIDDEN = アカウントごとに複数の登録名は禁止されています
+
+NAME_ALREADY_FOR_SALE = 既に名前は販売中です
+
+NAME_ALREADY_REGISTERED = 既に名前は登録されています
+
+NAME_BLOCKED = この名前はブロックされています
+
+NAME_DOES_NOT_EXIST = 名前は存在しません
+
+NAME_NOT_FOR_SALE = 名前は非売品です
+
+NAME_NOT_NORMALIZED = 名前は Unicode の「正規化」形式ではありません
+
+NEGATIVE_AMOUNT = 無効な/負の金額
+
+NEGATIVE_FEE = 無効な/負の料金
+
+NEGATIVE_PRICE = 無効な/負の価格
+
+NO_BALANCE = 残高が不足しています
+
+NO_BLOCKCHAIN_LOCK = ノードのブロックチェーンは現在ビジーです
+
+NO_FLAG_PERMISSION = アカウントにはその権限がありません
+
+NOT_GROUP_ADMIN = アカウントはグループ管理者ではありません
+
+NOT_GROUP_MEMBER = アカウントはグループメンバーではありません
+
+NOT_MINTING_ACCOUNT = アカウントはミント出来ません
+
+NOT_YET_RELEASED = 機能はまだリリースされていません
+
+OK = OK
+
+ORDER_ALREADY_CLOSED = 既に資産取引注文は終了しています
+
+ORDER_DOES_NOT_EXIST = 資産取引注文が存在しません
+
+POLL_ALREADY_EXISTS = 既に投票は存在します
+
+POLL_DOES_NOT_EXIST = 投票は存在しません
+
+POLL_OPTION_DOES_NOT_EXIST = 投票オプションが存在しません
+
+PUBLIC_KEY_UNKNOWN = 不明な公開鍵
+
+REWARD_SHARE_UNKNOWN = 不明な報酬シェア
+
+SELF_SHARE_EXISTS = 既に自己シェア(報酬シェア)が存在します
+
+TIMESTAMP_TOO_NEW = タイムスタンプが新しすぎます
+
+TIMESTAMP_TOO_OLD = タイムスタンプが古すぎます
+
+TOO_MANY_UNCONFIRMED = アカウントに保留中の未承認トランザクションが多すぎます
+
+TRANSACTION_ALREADY_CONFIRMED = 既にトランザクションは承認されています
+
+TRANSACTION_ALREADY_EXISTS = 既にトランザクションは存在します
+
+TRANSACTION_UNKNOWN = 不明なトランザクション
+
+TX_GROUP_ID_MISMATCH = トランザクションのグループIDが一致しません
--- a/src/main/resources/q-apps/q-apps.js
+++ b/src/main/resources/q-apps/q-apps.js
@@ -448,6 +448,10 @@ function getDefaultTimeout(action) {
                // User may take a long time to accept/deny the popup
                return 60 * 60 * 1000;

+            case "SEARCH_QDN_RESOURCES":
+                // Searching for data can be slow, especially when metadata and statuses are also being included
+                return 30 * 1000;
+
            case "FETCH_QDN_RESOURCE":
                // Fetching data can take a while, especially if the status hasn't been checked first
                return 60 * 1000;
@@ -467,6 +471,10 @@ function getDefaultTimeout(action) {
                // Allow extra time for other actions that create transactions, even if there is no PoW
                return 5 * 60 * 1000;

+            case "GET_WALLET_BALANCE":
+                // Getting a wallet balance can take a while, if there are many transactions
+                return 2 * 60 * 1000;
+
            default:
                break;
        }
--- a/src/test/java/org/qortal/test/BootstrapTests.java
+++ b/src/test/java/org/qortal/test/BootstrapTests.java
@@ -212,7 +212,7 @@ public class BootstrapTests extends Common {
    @Test
    public void testBootstrapHosts() throws IOException {
        String[] bootstrapHosts = Settings.getInstance().getBootstrapHosts();
-        String[] bootstrapTypes = { "archive", "toponly" };
+        String[] bootstrapTypes = { "archive" }; // , "toponly"

        for (String host : bootstrapHosts) {
            for (String type : bootstrapTypes) {
--- a/src/test/java/org/qortal/test/MemoryPoWTests.java
+++ b/src/test/java/org/qortal/test/MemoryPoWTests.java
@@ -3,6 +3,8 @@ package org.qortal.test;
 import org.junit.Ignore;
 import org.junit.Test;
 import org.qortal.crypto.MemoryPoW;
+import org.qortal.repository.DataException;
+import org.qortal.test.common.Common;

 import static org.junit.Assert.*;

@@ -39,13 +41,14 @@ public class MemoryPoWTests {
 	}

 	@Test
-	public void testMultipleComputes() {
+	public void testMultipleComputes() throws DataException {
+		Common.useDefaultSettings();
 		Random random = new Random();

-		final int sampleSize = 20;
+		final int sampleSize = 10;
 		final long stddevDivisor = sampleSize * (sampleSize - 1);

-		for (int difficulty = 8; difficulty < 16; difficulty += 2) {
+		for (int difficulty = 8; difficulty <= 16; difficulty++) {
 			byte[] data = new byte[256];
 			long[] times = new long[sampleSize];

--- a/src/test/java/org/qortal/test/MessageTests.java
+++ b/src/test/java/org/qortal/test/MessageTests.java
@@ -1,5 +1,6 @@
 package org.qortal.test;

+import org.apache.commons.lang3.reflect.FieldUtils;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
@@ -14,12 +15,9 @@ import org.qortal.group.Group.ApprovalThreshold;
 import org.qortal.repository.DataException;
 import org.qortal.repository.Repository;
 import org.qortal.repository.RepositoryManager;
-import org.qortal.test.common.BlockUtils;
-import org.qortal.test.common.Common;
-import org.qortal.test.common.GroupUtils;
-import org.qortal.test.common.TestAccount;
-import org.qortal.test.common.TransactionUtils;
+import org.qortal.test.common.*;
 import org.qortal.test.common.transaction.TestTransaction;
+import org.qortal.transaction.DeployAtTransaction;
 import org.qortal.transaction.MessageTransaction;
 import org.qortal.transaction.Transaction;
 import org.qortal.transaction.Transaction.TransactionType;
@@ -31,6 +29,7 @@ import org.qortal.utils.NTP;

 import static org.junit.Assert.*;

+import java.util.List;
 import java.util.Random;

 public class MessageTests extends Common {
@@ -85,7 +84,7 @@ public class MessageTests extends Common {
 		byte[] randomReference = new byte[64];
 		random.nextBytes(randomReference);

-		long minimumFee = BlockChain.getInstance().getUnitFee();
+		long minimumFee = BlockChain.getInstance().getUnitFeeAtTimestamp(System.currentTimeMillis());

 		try (final Repository repository = RepositoryManager.getRepository()) {
 			PrivateKeyAccount alice = Common.getTestAccount(repository, "alice");
@@ -139,7 +138,7 @@ public class MessageTests extends Common {
 	}

 	@Test
-	public void withRecipentWithAmount() throws DataException {
+	public void withRecipientWithAmount() throws DataException {
 		testMessage(Group.NO_GROUP, recipient, 123L, Asset.QORT);
 	}

@@ -153,6 +152,140 @@ public class MessageTests extends Common {
 		testMessage(1, null, 0L, null);
 	}

+	@Test
+	public void atRecipientNoFeeWithNonce() throws DataException {
+		try (final Repository repository = RepositoryManager.getRepository()) {
+			PrivateKeyAccount alice = Common.getTestAccount(repository, "alice");
+			String atRecipient = deployAt();
+			MessageTransaction transaction = testFeeNonce(repository, false, true, atRecipient, true);
+
+			// Transaction should be confirmable because it's to an AT, and therefore should be present in a block
+			assertTrue(transaction.isConfirmable());
+			TransactionUtils.signAndMint(repository, transaction.getTransactionData(), alice);
+			assertTrue(isTransactionConfirmed(repository, transaction));
+			assertEquals(16, transaction.getPoWDifficulty());
+
+			BlockUtils.orphanLastBlock(repository);
+		}
+	}
+
+	@Test
+	public void regularRecipientNoFeeWithNonce() throws DataException {
+		try (final Repository repository = RepositoryManager.getRepository()) {
+			PrivateKeyAccount alice = Common.getTestAccount(repository, "alice");
+
+			// Transaction should not be present in db yet
+			List<MessageTransactionData> messageTransactionsData = repository.getMessageRepository().getMessagesByParticipants(null, recipient, null, null, null);
+			assertTrue(messageTransactionsData.isEmpty());
+
+			MessageTransaction transaction = testFeeNonce(repository, false, true, recipient, true);
+
+			// Transaction shouldn't be confirmable because it's not to an AT, and therefore shouldn't be present in a block
+			assertFalse(transaction.isConfirmable());
+			TransactionUtils.signAndMint(repository, transaction.getTransactionData(), alice);
+			assertFalse(isTransactionConfirmed(repository, transaction));
+			assertEquals(12, transaction.getPoWDifficulty());
+
+			// Transaction should be found when trade bot searches for it
+			messageTransactionsData = repository.getMessageRepository().getMessagesByParticipants(null, recipient, null, null, null);
+			assertEquals(1, messageTransactionsData.size());
+
+			BlockUtils.orphanLastBlock(repository);
+		}
+	}
+
+	@Test
+	public void noRecipientNoFeeWithNonce() throws DataException {
+		try (final Repository repository = RepositoryManager.getRepository()) {
+			PrivateKeyAccount alice = Common.getTestAccount(repository, "alice");
+
+			MessageTransaction transaction = testFeeNonce(repository, false, true, null, true);
+
+			// Transaction shouldn't be confirmable because it's not to an AT, and therefore shouldn't be present in a block
+			assertFalse(transaction.isConfirmable());
+			TransactionUtils.signAndMint(repository, transaction.getTransactionData(), alice);
+			assertFalse(isTransactionConfirmed(repository, transaction));
+			assertEquals(12, transaction.getPoWDifficulty());
+
+			BlockUtils.orphanLastBlock(repository);
+		}
+	}
+
+	@Test
+	public void atRecipientWithFeeNoNonce() throws DataException {
+		try (final Repository repository = RepositoryManager.getRepository()) {
+			PrivateKeyAccount alice = Common.getTestAccount(repository, "alice");
+			String atRecipient = deployAt();
+			MessageTransaction transaction = testFeeNonce(repository, true, false, atRecipient, true);
+
+			// Transaction should be confirmable because it's to an AT, and therefore should be present in a block
+			assertTrue(transaction.isConfirmable());
+			TransactionUtils.signAndMint(repository, transaction.getTransactionData(), alice);
+			assertTrue(isTransactionConfirmed(repository, transaction));
+			assertEquals(16, transaction.getPoWDifficulty());
+
+			BlockUtils.orphanLastBlock(repository);
+		}
+	}
+
+	@Test
+	public void regularRecipientWithFeeNoNonce() throws DataException {
+		try (final Repository repository = RepositoryManager.getRepository()) {
+			PrivateKeyAccount alice = Common.getTestAccount(repository, "alice");
+
+			MessageTransaction transaction = testFeeNonce(repository, true, false, recipient, true);
+
+			// Transaction shouldn't be confirmable because it's not to an AT, and therefore shouldn't be present in a block
+			assertFalse(transaction.isConfirmable());
+			TransactionUtils.signAndMint(repository, transaction.getTransactionData(), alice);
+			assertFalse(isTransactionConfirmed(repository, transaction));
+			assertEquals(12, transaction.getPoWDifficulty());
+
+			BlockUtils.orphanLastBlock(repository);
+		}
+	}
+
+	@Test
+	public void atRecipientNoFeeWithNonceLegacyDifficulty() throws DataException, IllegalAccessException {
+		try (final Repository repository = RepositoryManager.getRepository()) {
+
+			// Set mempowTransactionUpdatesTimestamp to a high value, so that it hasn't activated key
+			FieldUtils.writeField(BlockChain.getInstance(), "mempowTransactionUpdatesTimestamp", Long.MAX_VALUE, true);
+
+			PrivateKeyAccount alice = Common.getTestAccount(repository, "alice");
+			String atRecipient = deployAt();
+			MessageTransaction transaction = testFeeNonce(repository, false, true, atRecipient, true);
+
+			// Transaction should be confirmable because all MESSAGE transactions confirmed prior to the feature trigger
+			assertTrue(transaction.isConfirmable());
+			TransactionUtils.signAndMint(repository, transaction.getTransactionData(), alice);
+			assertTrue(isTransactionConfirmed(repository, transaction));
+			assertEquals(14, transaction.getPoWDifficulty()); // Legacy difficulty was 14 in all cases
+
+			BlockUtils.orphanLastBlock(repository);
+		}
+	}
+
+	@Test
+	public void regularRecipientNoFeeWithNonceLegacyDifficulty() throws DataException, IllegalAccessException {
+		try (final Repository repository = RepositoryManager.getRepository()) {
+
+			// Set mempowTransactionUpdatesTimestamp to a high value, so that it hasn't activated key
+			FieldUtils.writeField(BlockChain.getInstance(), "mempowTransactionUpdatesTimestamp", Long.MAX_VALUE, true);
+
+			PrivateKeyAccount alice = Common.getTestAccount(repository, "alice");
+			MessageTransaction transaction = testFeeNonce(repository, false, true, recipient, true);
+
+			// Transaction should be confirmable because all MESSAGE transactions confirmed prior to the feature trigger
+			assertTrue(transaction.isConfirmable());
+			TransactionUtils.signAndMint(repository, transaction.getTransactionData(), alice);
+			assertTrue(isTransactionConfirmed(repository, transaction)); // All MESSAGE transactions would confirm before feature trigger
+			assertEquals(14, transaction.getPoWDifficulty()); // Legacy difficulty was 14 in all cases
+
+			BlockUtils.orphanLastBlock(repository);
+		}
+	}
+
 	@Test
 	public void serializationTests() throws DataException, TransformationException {
 		// with recipient, with amount
@@ -165,6 +298,24 @@ public class MessageTests extends Common {
 		testSerialization(null, 0L, null);
 	}

+	private String deployAt() throws DataException {
+		try (final Repository repository = RepositoryManager.getRepository()) {
+			PrivateKeyAccount deployer = Common.getTestAccount(repository, "alice");
+			byte[] creationBytes = AtUtils.buildSimpleAT();
+			long fundingAmount = 1_00000000L;
+			DeployAtTransaction deployAtTransaction = AtUtils.doDeployAT(repository, deployer, creationBytes, fundingAmount);
+
+			String address = deployAtTransaction.getATAccount().getAddress();
+			assertNotNull(address);
+			return address;
+		}
+	}
+
+	private boolean isTransactionConfirmed(Repository repository, MessageTransaction transaction) throws DataException {
+		TransactionData queriedTransactionData = repository.getTransactionRepository().fromSignature(transaction.getTransactionData().getSignature());
+		return queriedTransactionData.getBlockHeight() != null && queriedTransactionData.getBlockHeight() > 0;
+	}
+
 	private boolean isValid(int txGroupId, String recipient, long amount, Long assetId) throws DataException {
 		try (final Repository repository = RepositoryManager.getRepository()) {
 			TestAccount alice = Common.getTestAccount(repository, "alice");
@@ -195,41 +346,48 @@ public class MessageTests extends Common {
 		return messageTransaction.hasValidReference();
 	}

-	private void testFeeNonce(boolean withFee, boolean withNonce, boolean isValid) throws DataException {
+
+	private MessageTransaction testFeeNonce(boolean withFee, boolean withNonce, boolean isValid) throws DataException {
 		try (final Repository repository = RepositoryManager.getRepository()) {
-			TestAccount alice = Common.getTestAccount(repository, "alice");
-
-			int txGroupId = 0;
-			int nonce = 0;
-			long amount = 0;
-			long assetId = Asset.QORT;
-			byte[] data = new byte[1];
-			boolean isText = false;
-			boolean isEncrypted = false;
-
-			MessageTransactionData transactionData = new MessageTransactionData(TestTransaction.generateBase(alice, txGroupId),
-					version, nonce, recipient, amount, assetId, data, isText, isEncrypted);
-
-			MessageTransaction transaction = new MessageTransaction(repository, transactionData);
-
-			if (withFee)
-				transactionData.setFee(transaction.calcRecommendedFee());
-			else
-				transactionData.setFee(0L);
-
-			if (withNonce) {
-				transaction.computeNonce();
-			} else {
-				transactionData.setNonce(-1);
-			}
-
-			transaction.sign(alice);
-
-			assertEquals(isValid, transaction.isSignatureValid());
+			return testFeeNonce(repository, withFee, withNonce, recipient, isValid);
 		}
 	}

-	private void testMessage(int txGroupId, String recipient, long amount, Long assetId) throws DataException {
+	private MessageTransaction testFeeNonce(Repository repository, boolean withFee, boolean withNonce, String recipient, boolean isValid) throws DataException {
+		TestAccount alice = Common.getTestAccount(repository, "alice");
+
+		int txGroupId = 0;
+		int nonce = 0;
+		long amount = 0;
+		long assetId = Asset.QORT;
+		byte[] data = new byte[1];
+		boolean isText = false;
+		boolean isEncrypted = false;
+
+		MessageTransactionData transactionData = new MessageTransactionData(TestTransaction.generateBase(alice, txGroupId),
+				version, nonce, recipient, amount, assetId, data, isText, isEncrypted);
+
+		MessageTransaction transaction = new MessageTransaction(repository, transactionData);
+
+		if (withFee)
+			transactionData.setFee(transaction.calcRecommendedFee());
+		else
+			transactionData.setFee(0L);
+
+		if (withNonce) {
+			transaction.computeNonce();
+		} else {
+			transactionData.setNonce(-1);
+		}
+
+		transaction.sign(alice);
+
+		assertEquals(isValid, transaction.isSignatureValid());
+
+		return transaction;
+	}
+
+	private MessageTransaction testMessage(int txGroupId, String recipient, long amount, Long assetId) throws DataException {
 		try (final Repository repository = RepositoryManager.getRepository()) {
 			TestAccount alice = Common.getTestAccount(repository, "alice");

@@ -244,6 +402,8 @@ public class MessageTests extends Common {
 			TransactionUtils.signAndMint(repository, transactionData, alice);

 			BlockUtils.orphanLastBlock(repository);
+
+			return new MessageTransaction(repository, transactionData);
 		}
 	}

--- a/src/test/java/org/qortal/test/arbitrary/ArbitraryServiceTests.java
+++ b/src/test/java/org/qortal/test/arbitrary/ArbitraryServiceTests.java
@@ -456,6 +456,25 @@ public class ArbitraryServiceTests extends Common {
        assertEquals(ValidationResult.OK, service.validate(filePath));
    }

+    @Test
+    public void testValidPrivateGroupData() throws IOException {
+        String dataString = "qortalGroupEncryptedDatabMx4fELNTV+ifJxmv4+GcuOIJOTo+3qAvbWKNY2L1rfla5UBoEcoxbtjgZ9G7FLPb8V/Qfr0bfKWfvMmN06U/pgUdLuv2mGL2V0D3qYd1011MUzGdNG1qERjaCDz8GAi63+KnHHjfMtPgYt6bcqjs4CNV+ZZ4dIt3xxHYyVEBNc=";
+
+        // Write the data a single file in a temp path
+        Path path = Files.createTempDirectory("testValidPrivateData");
+        Path filePath = Paths.get(path.toString(), "test");
+        filePath.toFile().deleteOnExit();
+
+        BufferedWriter writer = new BufferedWriter(new FileWriter(filePath.toFile()));
+        writer.write(dataString);
+        writer.close();
+
+        Service service = Service.FILE_PRIVATE;
+        assertTrue(service.isValidationRequired());
+
+        assertEquals(ValidationResult.OK, service.validate(filePath));
+    }
+
    @Test
    public void testEncryptedData() throws IOException {
        String dataString = "qortalEncryptedDatabMx4fELNTV+ifJxmv4+GcuOIJOTo+3qAvbWKNY2L1rfla5UBoEcoxbtjgZ9G7FLPb8V/Qfr0bfKWfvMmN06U/pgUdLuv2mGL2V0D3qYd1011MUzGdNG1qERjaCDz8GAi63+KnHHjfMtPgYt6bcqjs4CNV+ZZ4dIt3xxHYyVEBNc=";
--- a/src/test/java/org/qortal/test/arbitrary/ArbitraryTransactionMetadataTests.java
+++ b/src/test/java/org/qortal/test/arbitrary/ArbitraryTransactionMetadataTests.java
@@ -11,6 +11,7 @@ import org.qortal.arbitrary.ArbitraryDataReader;
 import org.qortal.arbitrary.exception.MissingDataException;
 import org.qortal.arbitrary.misc.Category;
 import org.qortal.arbitrary.misc.Service;
+import org.qortal.block.BlockChain;
 import org.qortal.controller.arbitrary.ArbitraryDataManager;
 import org.qortal.data.arbitrary.ArbitraryResourceMetadata;
 import org.qortal.data.transaction.ArbitraryTransactionData;
@@ -24,6 +25,7 @@ import org.qortal.test.common.TransactionUtils;
 import org.qortal.test.common.transaction.TestTransaction;
 import org.qortal.transaction.RegisterNameTransaction;
 import org.qortal.utils.Base58;
+import org.qortal.utils.NTP;

 import java.io.IOException;
 import java.nio.file.Files;
@@ -106,8 +108,9 @@ public class ArbitraryTransactionMetadataTests extends Common {

            // Create PUT transaction
            Path path1 = ArbitraryUtils.generateRandomDataPath(dataLength);
+            long fee = BlockChain.getInstance().getUnitFeeAtTimestamp(NTP.getTime());
            ArbitraryDataFile arbitraryDataFile = ArbitraryUtils.createAndMintTxn(repository, publicKey58, path1, name,
-                    identifier, ArbitraryTransactionData.Method.PUT, service, alice, chunkSize, 0L, true,
+                    identifier, ArbitraryTransactionData.Method.PUT, service, alice, chunkSize, fee, false,
                    title, description, tags, category);

            // Check the chunk count is correct
@@ -157,8 +160,9 @@ public class ArbitraryTransactionMetadataTests extends Common {

            // Create PUT transaction
            Path path1 = ArbitraryUtils.generateRandomDataPath(dataLength);
+            long fee = BlockChain.getInstance().getUnitFeeAtTimestamp(NTP.getTime());
            ArbitraryDataFile arbitraryDataFile = ArbitraryUtils.createAndMintTxn(repository, publicKey58, path1, name,
-                    identifier, ArbitraryTransactionData.Method.PUT, service, alice, chunkSize, 0L, true,
+                    identifier, ArbitraryTransactionData.Method.PUT, service, alice, chunkSize, fee, false,
                    title, description, tags, category);

            // Check the chunk count is correct
@@ -220,8 +224,9 @@ public class ArbitraryTransactionMetadataTests extends Common {

            // Create PUT transaction
            Path path1 = ArbitraryUtils.generateRandomDataPath(dataLength);
+            long fee = BlockChain.getInstance().getUnitFeeAtTimestamp(NTP.getTime());
            ArbitraryDataFile arbitraryDataFile = ArbitraryUtils.createAndMintTxn(repository, publicKey58, path1, name,
-                    identifier, ArbitraryTransactionData.Method.PUT, service, alice, chunkSize, 0L, true,
+                    identifier, ArbitraryTransactionData.Method.PUT, service, alice, chunkSize, fee, false,
                    title, description, tags, category);

            // Check the chunk count is correct
@@ -272,8 +277,9 @@ public class ArbitraryTransactionMetadataTests extends Common {

            // Create PUT transaction
            Path path1 = ArbitraryUtils.generateRandomDataPath(dataLength);
+            long fee = BlockChain.getInstance().getUnitFeeAtTimestamp(NTP.getTime());
            ArbitraryDataFile arbitraryDataFile = ArbitraryUtils.createAndMintTxn(repository, publicKey58, path1, name,
-                    identifier, ArbitraryTransactionData.Method.PUT, service, alice, chunkSize, 0L, true,
+                    identifier, ArbitraryTransactionData.Method.PUT, service, alice, chunkSize, fee, false,
                    title, description, tags, category);

            // Check the chunk count is correct
@@ -316,8 +322,9 @@ public class ArbitraryTransactionMetadataTests extends Common {

            // Create PUT transaction
            Path path1 = ArbitraryUtils.generateRandomDataPath(dataLength);
+            long fee = BlockChain.getInstance().getUnitFeeAtTimestamp(NTP.getTime());
            ArbitraryDataFile arbitraryDataFile = ArbitraryUtils.createAndMintTxn(repository, publicKey58, path1, name,
-                    identifier, ArbitraryTransactionData.Method.PUT, service, alice, chunkSize, 0L, true,
+                    identifier, ArbitraryTransactionData.Method.PUT, service, alice, chunkSize, fee, false,
                    title, description, tags, category);

            // Check the metadata is correct
--- a/src/test/java/org/qortal/test/arbitrary/ArbitraryTransactionTests.java
+++ b/src/test/java/org/qortal/test/arbitrary/ArbitraryTransactionTests.java
@@ -10,6 +10,7 @@ import org.qortal.arbitrary.ArbitraryDataTransactionBuilder;
 import org.qortal.arbitrary.exception.MissingDataException;
 import org.qortal.arbitrary.misc.Category;
 import org.qortal.arbitrary.misc.Service;
+import org.qortal.block.BlockChain;
 import org.qortal.controller.arbitrary.ArbitraryDataManager;
 import org.qortal.crypto.Crypto;
 import org.qortal.data.PaymentData;
@@ -50,51 +51,6 @@ public class ArbitraryTransactionTests extends Common {
        Common.useDefaultSettings();
    }

-    @Test
-    public void testDifficultyTooLow() throws IllegalAccessException, DataException, IOException {
-        try (final Repository repository = RepositoryManager.getRepository()) {
-            PrivateKeyAccount alice = Common.getTestAccount(repository, "alice");
-            String publicKey58 = Base58.encode(alice.getPublicKey());
-            String name = "TEST"; // Can be anything for this test
-            String identifier = null; // Not used for this test
-            Service service = Service.ARBITRARY_DATA;
-            int chunkSize = 100;
-            int dataLength = 900; // Actual data length will be longer due to encryption
-
-            // Register the name to Alice
-            RegisterNameTransactionData registerNameTransactionData = new RegisterNameTransactionData(TestTransaction.generateBase(alice), name, "");
-            registerNameTransactionData.setFee(new RegisterNameTransaction(null, null).getUnitFee(registerNameTransactionData.getTimestamp()));
-            TransactionUtils.signAndMint(repository, registerNameTransactionData, alice);
-
-            // Set difficulty to 1
-            FieldUtils.writeField(ArbitraryDataManager.getInstance(), "powDifficulty", 1, true);
-
-            // Create PUT transaction
-            Path path1 = ArbitraryUtils.generateRandomDataPath(dataLength);
-            ArbitraryDataFile arbitraryDataFile = ArbitraryUtils.createAndMintTxn(repository, publicKey58, path1, name, identifier, ArbitraryTransactionData.Method.PUT, service, alice, chunkSize);
-
-            // Check that nonce validation succeeds
-            byte[] signature = arbitraryDataFile.getSignature();
-            TransactionData transactionData = repository.getTransactionRepository().fromSignature(signature);
-            ArbitraryTransaction transaction = new ArbitraryTransaction(repository, transactionData);
-            assertTrue(transaction.isSignatureValid());
-
-            // Increase difficulty to 15
-            FieldUtils.writeField(ArbitraryDataManager.getInstance(), "powDifficulty", 15, true);
-
-            // Make sure the nonce validation fails
-            // Note: there is a very tiny chance this could succeed due to being extremely lucky
-            // and finding a high difficulty nonce in the first couple of cycles. It will be rare
-            // enough that we shouldn't need to account for it.
-            assertFalse(transaction.isSignatureValid());
-
-            // Reduce difficulty back to 1, to double check
-            FieldUtils.writeField(ArbitraryDataManager.getInstance(), "powDifficulty", 1, true);
-            assertTrue(transaction.isSignatureValid());
-
-        }
-    }
-
    @Test
    public void testNonceAndFee() throws IllegalAccessException, DataException, IOException {
        try (final Repository repository = RepositoryManager.getRepository()) {
@@ -497,8 +453,9 @@ public class ArbitraryTransactionTests extends Common {

            // Create PUT transaction
            Path path1 = ArbitraryUtils.generateRandomDataPath(dataLength, true);
+            long fee = BlockChain.getInstance().getUnitFeeAtTimestamp(NTP.getTime());
            ArbitraryDataFile arbitraryDataFile = ArbitraryUtils.createAndMintTxn(repository, publicKey58, path1, name,
-                    identifier, ArbitraryTransactionData.Method.PUT, service, alice, chunkSize, 0L, true,
+                    identifier, ArbitraryTransactionData.Method.PUT, service, alice, chunkSize, fee, false,
                    null, null, null, null);

            byte[] signature = arbitraryDataFile.getSignature();
@@ -556,8 +513,9 @@ public class ArbitraryTransactionTests extends Common {

            // Create PUT transaction
            Path path1 = ArbitraryUtils.generateRandomDataPath(dataLength, true);
+            long fee = BlockChain.getInstance().getUnitFeeAtTimestamp(NTP.getTime());
            ArbitraryDataFile arbitraryDataFile = ArbitraryUtils.createAndMintTxn(repository, publicKey58, path1, name,
-                    identifier, ArbitraryTransactionData.Method.PUT, service, alice, chunkSize, 0L, true,
+                    identifier, ArbitraryTransactionData.Method.PUT, service, alice, chunkSize, fee, false,
                    title, description, tags, category);

            byte[] signature = arbitraryDataFile.getSignature();
@@ -614,8 +572,9 @@ public class ArbitraryTransactionTests extends Common {

            // Create PUT transaction
            Path path1 = ArbitraryUtils.generateRandomDataPath(dataLength, true);
+            long fee = BlockChain.getInstance().getUnitFeeAtTimestamp(NTP.getTime());
            ArbitraryDataFile arbitraryDataFile = ArbitraryUtils.createAndMintTxn(repository, publicKey58, path1, name,
-                    identifier, ArbitraryTransactionData.Method.PUT, service, alice, chunkSize, 0L, true,
+                    identifier, ArbitraryTransactionData.Method.PUT, service, alice, chunkSize, fee, false,
                    null, null, null, null);

            byte[] signature = arbitraryDataFile.getSignature();
--- a/src/test/java/org/qortal/test/common/ArbitraryUtils.java
+++ b/src/test/java/org/qortal/test/common/ArbitraryUtils.java
@@ -5,10 +5,12 @@ import org.qortal.arbitrary.ArbitraryDataFile;
 import org.qortal.arbitrary.ArbitraryDataTransactionBuilder;
 import org.qortal.arbitrary.misc.Category;
 import org.qortal.arbitrary.misc.Service;
+import org.qortal.block.BlockChain;
 import org.qortal.data.transaction.ArbitraryTransactionData;
 import org.qortal.repository.DataException;
 import org.qortal.repository.Repository;
 import org.qortal.transaction.Transaction;
+import org.qortal.utils.NTP;

 import java.io.BufferedWriter;
 import java.io.File;
@@ -20,16 +22,15 @@ import java.nio.file.Paths;
 import java.util.List;
 import java.util.Random;

-import static org.junit.Assert.assertEquals;
-
 public class ArbitraryUtils {

    public static ArbitraryDataFile createAndMintTxn(Repository repository, String publicKey58, Path path, String name, String identifier,
                                                     ArbitraryTransactionData.Method method, Service service, PrivateKeyAccount account,
                                                     int chunkSize) throws DataException {

+        long fee = BlockChain.getInstance().getUnitFeeAtTimestamp(NTP.getTime());
        return ArbitraryUtils.createAndMintTxn(repository, publicKey58, path, name, identifier, method, service,
-                account, chunkSize, 0L, true, null, null, null, null);
+                account, chunkSize, fee, false, null, null, null, null);
    }

    public static ArbitraryDataFile createAndMintTxn(Repository repository, String publicKey58, Path path, String name, String identifier,
@@ -47,7 +48,9 @@ public class ArbitraryUtils {
        }
        ArbitraryTransactionData transactionData = txnBuilder.getArbitraryTransactionData();
        Transaction.ValidationResult result = TransactionUtils.signAndImport(repository, transactionData, account);
-        assertEquals(Transaction.ValidationResult.OK, result);
+        if (result != Transaction.ValidationResult.OK) {
+            throw new DataException(String.format("Arbitrary transaction invalid: %s", result.toString()));
+        }
        BlockUtils.mintBlock(repository);

        // We need a new ArbitraryDataFile instance because the files will have been moved to the signature's folder
--- a/src/test/java/org/qortal/test/common/transaction/TestTransaction.java
+++ b/src/test/java/org/qortal/test/common/transaction/TestTransaction.java
@@ -7,13 +7,15 @@ import org.qortal.block.BlockChain;
 import org.qortal.data.transaction.BaseTransactionData;
 import org.qortal.group.Group;
 import org.qortal.repository.DataException;
+import org.qortal.utils.NTP;

 public abstract class TestTransaction {

 	protected static final Random random = new Random();

 	public static BaseTransactionData generateBase(PrivateKeyAccount account, int txGroupId) throws DataException {
-		return new BaseTransactionData(System.currentTimeMillis(), txGroupId, account.getLastReference(), account.getPublicKey(), BlockChain.getInstance().getUnitFee(), null);
+		long timestamp = System.currentTimeMillis();
+		return new BaseTransactionData(timestamp, txGroupId, account.getLastReference(), account.getPublicKey(), BlockChain.getInstance().getUnitFeeAtTimestamp(timestamp), null);
 	}

 	public static BaseTransactionData generateBase(PrivateKeyAccount account) throws DataException {
--- a/src/test/java/org/qortal/test/crosschain/ACCTTests.java
+++ b/src/test/java/org/qortal/test/crosschain/ACCTTests.java
@@ -0,0 +1,790 @@
+package org.qortal.test.crosschain;
+
+import com.google.common.hash.HashCode;
+import com.google.common.primitives.Bytes;
+import org.junit.Before;
+import org.junit.Test;
+import org.qortal.account.Account;
+import org.qortal.account.PrivateKeyAccount;
+import org.qortal.asset.Asset;
+import org.qortal.block.Block;
+import org.qortal.crosschain.ACCT;
+import org.qortal.crosschain.AcctMode;
+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.transaction.BaseTransactionData;
+import org.qortal.data.transaction.DeployAtTransactionData;
+import org.qortal.data.transaction.MessageTransactionData;
+import org.qortal.data.transaction.TransactionData;
+import org.qortal.group.Group;
+import org.qortal.repository.DataException;
+import org.qortal.repository.Repository;
+import org.qortal.repository.RepositoryManager;
+import org.qortal.test.common.BlockUtils;
+import org.qortal.test.common.Common;
+import org.qortal.test.common.TransactionUtils;
+import org.qortal.transaction.DeployAtTransaction;
+import org.qortal.transaction.MessageTransaction;
+import org.qortal.utils.Amounts;
+
+import java.time.Instant;
+import java.time.LocalDateTime;
+import java.time.ZoneOffset;
+import java.time.format.DateTimeFormatter;
+import java.time.format.FormatStyle;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Random;
+import java.util.function.Function;
+
+import static org.junit.Assert.*;
+
+public abstract class ACCTTests extends Common {
+
+	public static final byte[] secretA = "This string is exactly 32 bytes!".getBytes();
+	public static final byte[] hashOfSecretA = Crypto.hash160(secretA); // daf59884b4d1aec8c1b17102530909ee43c0151a
+	public static final int tradeTimeout = 20; // blocks
+	public static final long redeemAmount = 80_40200000L;
+	public static final long fundingAmount = 123_45600000L;
+	public static final long foreignAmount = 864200L; // 0.00864200 foreign units
+
+	protected static final Random RANDOM = new Random();
+
+	protected abstract byte[] getPublicKey();
+
+	protected abstract byte[] buildQortalAT(String address, byte[] publicKey, long redeemAmount, long foreignAmount, int tradeTimeout);
+
+	protected abstract ACCT getInstance();
+
+	protected abstract int calcRefundTimeout(long partnersOfferMessageTransactionTimestamp, int lockTimeA);
+
+	protected abstract byte[] buildTradeMessage(String address, byte[] publicKey, byte[] hashOfSecretA, int lockTimeA, int refundTimeout);
+
+	protected abstract byte[] buildRedeemMessage(byte[] secretA, String address);
+
+	protected abstract byte[] getCodeBytesHash();
+
+	protected abstract String getSymbol();
+
+	protected abstract String getName();
+
+	@Before
+	public void beforeTest() throws DataException {
+		Common.useDefaultSettings();
+	}
+
+	@Test
+	public void testCompile() {
+		PrivateKeyAccount tradeAccount = createTradeAccount(null);
+
+		byte[] creationBytes = buildQortalAT(tradeAccount.getAddress(), getPublicKey(), redeemAmount, foreignAmount, tradeTimeout);
+		assertNotNull(creationBytes);
+
+		System.out.println("AT creation bytes: " + HashCode.fromBytes(creationBytes).toString());
+	}
+
+
+	@Test
+	public void testDeploy() throws DataException {
+		try (final Repository repository = RepositoryManager.getRepository()) {
+			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
+			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
+
+			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
+
+			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
+			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
+
+			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
+
+			long expectedBalance = deployersInitialBalance - fundingAmount - deployAtTransaction.getTransactionData().getFee();
+			long actualBalance = deployer.getConfirmedBalance(Asset.QORT);
+
+			assertEquals("Deployer's post-deployment balance incorrect", expectedBalance, actualBalance);
+
+			expectedBalance = fundingAmount;
+			actualBalance = deployAtTransaction.getATAccount().getConfirmedBalance(Asset.QORT);
+
+			assertEquals("AT's post-deployment balance incorrect", expectedBalance, actualBalance);
+
+			expectedBalance = partnersInitialBalance;
+			actualBalance = partner.getConfirmedBalance(Asset.QORT);
+
+			assertEquals("Partner's post-deployment balance incorrect", expectedBalance, actualBalance);
+
+			// Test orphaning
+			BlockUtils.orphanLastBlock(repository);
+
+			expectedBalance = deployersInitialBalance;
+			actualBalance = deployer.getConfirmedBalance(Asset.QORT);
+
+			assertEquals("Deployer's post-orphan/pre-deployment balance incorrect", expectedBalance, actualBalance);
+
+			expectedBalance = 0;
+			actualBalance = deployAtTransaction.getATAccount().getConfirmedBalance(Asset.QORT);
+
+			assertEquals("AT's post-orphan/pre-deployment balance incorrect", expectedBalance, actualBalance);
+
+			expectedBalance = partnersInitialBalance;
+			actualBalance = partner.getConfirmedBalance(Asset.QORT);
+
+			assertEquals("Partner's post-orphan/pre-deployment balance incorrect", expectedBalance, actualBalance);
+		}
+	}
+
+	@SuppressWarnings("unused")
+	@Test
+	public void testOfferCancel() throws DataException {
+		try (final Repository repository = RepositoryManager.getRepository()) {
+			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
+			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
+
+			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
+
+			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
+			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
+
+			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
+			Account at = deployAtTransaction.getATAccount();
+			String atAddress = at.getAddress();
+
+			long deployAtFee = deployAtTransaction.getTransactionData().getFee();
+			long deployersPostDeploymentBalance = deployersInitialBalance - fundingAmount - deployAtFee;
+
+			// Send creator's address to AT, instead of typical partner's address
+			byte[] messageData = getInstance().buildCancelMessage(deployer.getAddress());
+			MessageTransaction messageTransaction = sendMessage(repository, deployer, messageData, atAddress);
+			long messageFee = messageTransaction.getTransactionData().getFee();
+
+			// AT should process 'cancel' message in next block
+			BlockUtils.mintBlock(repository);
+
+			describeAt(repository, atAddress);
+
+			// Check AT is finished
+			ATData atData = repository.getATRepository().fromATAddress(atAddress);
+			assertTrue(atData.getIsFinished());
+
+			// AT should be in CANCELLED mode
+			CrossChainTradeData tradeData = getInstance().populateTradeData(repository, atData);
+			assertEquals(AcctMode.CANCELLED, tradeData.mode);
+
+			// Check balances
+			long expectedMinimumBalance = deployersPostDeploymentBalance;
+			long expectedMaximumBalance = deployersInitialBalance - deployAtFee - messageFee;
+
+			long actualBalance = deployer.getConfirmedBalance(Asset.QORT);
+
+			assertTrue(String.format("Deployer's balance %s should be above minimum %s", actualBalance, expectedMinimumBalance), actualBalance > expectedMinimumBalance);
+			assertTrue(String.format("Deployer's balance %s should be below maximum %s", actualBalance, expectedMaximumBalance), actualBalance < expectedMaximumBalance);
+
+			// Test orphaning
+			BlockUtils.orphanLastBlock(repository);
+
+			// Check balances
+			long expectedBalance = deployersPostDeploymentBalance - messageFee;
+			actualBalance = deployer.getConfirmedBalance(Asset.QORT);
+
+			assertEquals("Deployer's post-orphan/pre-refund balance incorrect", expectedBalance, actualBalance);
+		}
+	}
+
+	@SuppressWarnings("unused")
+	@Test
+	public void testOfferCancelInvalidLength() throws DataException {
+		try (final Repository repository = RepositoryManager.getRepository()) {
+			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
+			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
+
+			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
+
+			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
+			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
+
+			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
+			Account at = deployAtTransaction.getATAccount();
+			String atAddress = at.getAddress();
+
+			long deployAtFee = deployAtTransaction.getTransactionData().getFee();
+			long deployersPostDeploymentBalance = deployersInitialBalance - fundingAmount - deployAtFee;
+
+			// Instead of sending creator's address to AT, send too-short/invalid message
+			byte[] messageData = new byte[7];
+			RANDOM.nextBytes(messageData);
+			MessageTransaction messageTransaction = sendMessage(repository, deployer, messageData, atAddress);
+			long messageFee = messageTransaction.getTransactionData().getFee();
+
+			// AT should process 'cancel' message in next block
+			// As message is too short, it will be padded to 32bytes but cancel code doesn't care about message content, so should be ok
+			BlockUtils.mintBlock(repository);
+
+			describeAt(repository, atAddress);
+
+			// Check AT is finished
+			ATData atData = repository.getATRepository().fromATAddress(atAddress);
+			assertTrue(atData.getIsFinished());
+
+			// AT should be in CANCELLED mode
+			CrossChainTradeData tradeData = getInstance().populateTradeData(repository, atData);
+			assertEquals(AcctMode.CANCELLED, tradeData.mode);
+		}
+	}
+
+	@SuppressWarnings("unused")
+	@Test
+	public void testTradingInfoProcessing() throws DataException {
+		try (final Repository repository = RepositoryManager.getRepository()) {
+			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
+			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
+
+			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
+
+			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
+			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
+
+			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
+			Account at = deployAtTransaction.getATAccount();
+			String atAddress = at.getAddress();
+
+			long partnersOfferMessageTransactionTimestamp = System.currentTimeMillis();
+			int lockTimeA = calcTestLockTimeA(partnersOfferMessageTransactionTimestamp);
+			int refundTimeout = calcRefundTimeout(partnersOfferMessageTransactionTimestamp, lockTimeA);
+
+			// Send trade info to AT
+			byte[] messageData = buildTradeMessage(partner.getAddress(), getPublicKey(), hashOfSecretA, lockTimeA, refundTimeout);
+			MessageTransaction messageTransaction = sendMessage(repository, tradeAccount, messageData, atAddress);
+
+			Block postDeploymentBlock = BlockUtils.mintBlock(repository);
+			int postDeploymentBlockHeight = postDeploymentBlock.getBlockData().getHeight();
+
+			long deployAtFee = deployAtTransaction.getTransactionData().getFee();
+			long deployersPostDeploymentBalance = deployersInitialBalance - fundingAmount - deployAtFee;
+
+			describeAt(repository, atAddress);
+
+			ATData atData = repository.getATRepository().fromATAddress(atAddress);
+			CrossChainTradeData tradeData = getInstance().populateTradeData(repository, atData);
+
+			// AT should be in TRADE mode
+			assertEquals(AcctMode.TRADING, tradeData.mode);
+
+			// Check hashOfSecretA was extracted correctly
+			assertTrue(Arrays.equals(hashOfSecretA, tradeData.hashOfSecretA));
+
+			// Check trade partner Qortal address was extracted correctly
+			assertEquals(partner.getAddress(), tradeData.qortalPartnerAddress);
+
+			// Check trade partner's Foreign Coin PKH was extracted correctly
+			assertTrue(Arrays.equals(getPublicKey(), tradeData.partnerForeignPKH));
+
+			// Test orphaning
+			BlockUtils.orphanToBlock(repository, postDeploymentBlockHeight);
+
+			// Check balances
+			long expectedBalance = deployersPostDeploymentBalance;
+			long actualBalance = deployer.getConfirmedBalance(Asset.QORT);
+
+			assertEquals("Deployer's post-orphan/pre-refund balance incorrect", expectedBalance, actualBalance);
+		}
+	}
+
+	// TEST SENDING TRADING INFO BUT NOT FROM AT CREATOR (SHOULD BE IGNORED)
+	@SuppressWarnings("unused")
+	@Test
+	public void testIncorrectTradeSender() throws DataException {
+		try (final Repository repository = RepositoryManager.getRepository()) {
+			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
+			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
+
+			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
+
+			PrivateKeyAccount bystander = Common.getTestAccount(repository, "bob");
+
+			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
+			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
+
+			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
+			Account at = deployAtTransaction.getATAccount();
+			String atAddress = at.getAddress();
+
+			long partnersOfferMessageTransactionTimestamp = System.currentTimeMillis();
+			int lockTimeA = calcTestLockTimeA(partnersOfferMessageTransactionTimestamp);
+			int refundTimeout = calcRefundTimeout(partnersOfferMessageTransactionTimestamp, lockTimeA);
+
+			// Send trade info to AT BUT NOT FROM AT CREATOR
+			byte[] messageData = buildTradeMessage(partner.getAddress(), getPublicKey(), hashOfSecretA, lockTimeA, refundTimeout);
+			MessageTransaction messageTransaction = sendMessage(repository, bystander, messageData, atAddress);
+
+			BlockUtils.mintBlock(repository);
+
+			long expectedBalance = partnersInitialBalance;
+			long actualBalance = partner.getConfirmedBalance(Asset.QORT);
+
+			assertEquals("Partner's post-initial-payout balance incorrect", expectedBalance, actualBalance);
+
+			describeAt(repository, atAddress);
+
+			ATData atData = repository.getATRepository().fromATAddress(atAddress);
+			CrossChainTradeData tradeData = getInstance().populateTradeData(repository, atData);
+
+			// AT should still be in OFFER mode
+			assertEquals(AcctMode.OFFERING, tradeData.mode);
+		}
+	}
+
+	@SuppressWarnings("unused")
+	@Test
+	public void testAutomaticTradeRefund() throws DataException {
+		try (final Repository repository = RepositoryManager.getRepository()) {
+			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
+			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
+
+			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
+
+			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
+			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
+
+			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
+			Account at = deployAtTransaction.getATAccount();
+			String atAddress = at.getAddress();
+
+			long partnersOfferMessageTransactionTimestamp = System.currentTimeMillis();
+			int lockTimeA = calcTestLockTimeA(partnersOfferMessageTransactionTimestamp);
+			int refundTimeout = calcRefundTimeout(partnersOfferMessageTransactionTimestamp, lockTimeA);
+
+			// Send trade info to AT
+			byte[] messageData = buildTradeMessage(partner.getAddress(), getPublicKey(), hashOfSecretA, lockTimeA, refundTimeout);
+			MessageTransaction messageTransaction = sendMessage(repository, tradeAccount, messageData, atAddress);
+
+			Block postDeploymentBlock = BlockUtils.mintBlock(repository);
+			int postDeploymentBlockHeight = postDeploymentBlock.getBlockData().getHeight();
+
+			// Check refund
+			long deployAtFee = deployAtTransaction.getTransactionData().getFee();
+			long deployersPostDeploymentBalance = deployersInitialBalance - fundingAmount - deployAtFee;
+
+			checkTradeRefund(repository, deployer, deployersInitialBalance, deployAtFee);
+
+			describeAt(repository, atAddress);
+
+			// Check AT is finished
+			ATData atData = repository.getATRepository().fromATAddress(atAddress);
+			assertTrue(atData.getIsFinished());
+
+			// AT should be in REFUNDED mode
+			CrossChainTradeData tradeData = getInstance().populateTradeData(repository, atData);
+			assertEquals(AcctMode.REFUNDED, tradeData.mode);
+
+			// Test orphaning
+			BlockUtils.orphanToBlock(repository, postDeploymentBlockHeight);
+
+			// Check balances
+			long expectedBalance = deployersPostDeploymentBalance;
+			long actualBalance = deployer.getConfirmedBalance(Asset.QORT);
+
+			assertEquals("Deployer's post-orphan/pre-refund balance incorrect", expectedBalance, actualBalance);
+		}
+	}
+
+	@SuppressWarnings("unused")
+	@Test
+	public void testCorrectSecretCorrectSender() throws DataException {
+		try (final Repository repository = RepositoryManager.getRepository()) {
+			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
+			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
+
+			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
+
+			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
+			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
+
+			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
+			Account at = deployAtTransaction.getATAccount();
+			String atAddress = at.getAddress();
+
+			long partnersOfferMessageTransactionTimestamp = System.currentTimeMillis();
+			int lockTimeA = calcTestLockTimeA(partnersOfferMessageTransactionTimestamp);
+			int refundTimeout = calcRefundTimeout(partnersOfferMessageTransactionTimestamp, lockTimeA);
+
+			// Send trade info to AT
+			byte[] messageData = buildTradeMessage(partner.getAddress(), getPublicKey(), hashOfSecretA, lockTimeA, refundTimeout);
+			MessageTransaction messageTransaction = sendMessage(repository, tradeAccount, messageData, atAddress);
+
+			// Give AT time to process message
+			BlockUtils.mintBlock(repository);
+
+			// Send correct secret to AT, from correct account
+			messageData = buildRedeemMessage(secretA,  partner.getAddress());
+			messageTransaction = sendMessage(repository, partner, messageData, atAddress);
+
+			// AT should send funds in the next block
+			ATStateData preRedeemAtStateData = repository.getATRepository().getLatestATState(atAddress);
+			BlockUtils.mintBlock(repository);
+
+			describeAt(repository, atAddress);
+
+			// Check AT is finished
+			ATData atData = repository.getATRepository().fromATAddress(atAddress);
+			assertTrue(atData.getIsFinished());
+
+			// AT should be in REDEEMED mode
+			CrossChainTradeData tradeData = getInstance().populateTradeData(repository, atData);
+			assertEquals(AcctMode.REDEEMED, tradeData.mode);
+
+			// Check balances
+			long expectedBalance = partnersInitialBalance - messageTransaction.getTransactionData().getFee() + redeemAmount;
+			long actualBalance = partner.getConfirmedBalance(Asset.QORT);
+
+			assertEquals("Partner's post-redeem balance incorrect", expectedBalance, actualBalance);
+
+			// Orphan redeem
+			BlockUtils.orphanLastBlock(repository);
+
+			// Check balances
+			expectedBalance = partnersInitialBalance - messageTransaction.getTransactionData().getFee();
+			actualBalance = partner.getConfirmedBalance(Asset.QORT);
+
+			assertEquals("Partner's post-orphan/pre-redeem balance incorrect", expectedBalance, actualBalance);
+
+			// Check AT state
+			ATStateData postOrphanAtStateData = repository.getATRepository().getLatestATState(atAddress);
+
+			assertTrue("AT states mismatch", Arrays.equals(preRedeemAtStateData.getStateData(), postOrphanAtStateData.getStateData()));
+		}
+	}
+
+	@SuppressWarnings("unused")
+	@Test
+	public void testCorrectSecretIncorrectSender() throws DataException {
+		try (final Repository repository = RepositoryManager.getRepository()) {
+			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
+			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
+
+			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
+
+			PrivateKeyAccount bystander = Common.getTestAccount(repository, "bob");
+
+			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
+			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
+
+			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
+			long deployAtFee = deployAtTransaction.getTransactionData().getFee();
+
+			Account at = deployAtTransaction.getATAccount();
+			String atAddress = at.getAddress();
+
+			long partnersOfferMessageTransactionTimestamp = System.currentTimeMillis();
+			int lockTimeA = calcTestLockTimeA(partnersOfferMessageTransactionTimestamp);
+			int refundTimeout = calcRefundTimeout(partnersOfferMessageTransactionTimestamp, lockTimeA);
+
+			// Send trade info to AT
+			byte[] messageData = buildTradeMessage(partner.getAddress(), getPublicKey(), hashOfSecretA, lockTimeA, refundTimeout);
+			MessageTransaction messageTransaction = sendMessage(repository, tradeAccount, messageData, atAddress);
+
+			// Give AT time to process message
+			BlockUtils.mintBlock(repository);
+
+			// Send correct secret to AT, but from wrong account
+			messageData = buildRedeemMessage(secretA, partner.getAddress());
+			messageTransaction = sendMessage(repository, bystander, messageData, atAddress);
+
+			// AT should NOT send funds in the next block
+			ATStateData preRedeemAtStateData = repository.getATRepository().getLatestATState(atAddress);
+			BlockUtils.mintBlock(repository);
+
+			describeAt(repository, atAddress);
+
+			// Check AT is NOT finished
+			ATData atData = repository.getATRepository().fromATAddress(atAddress);
+			assertFalse(atData.getIsFinished());
+
+			// AT should still be in TRADE mode
+			CrossChainTradeData tradeData = getInstance().populateTradeData(repository, atData);
+			assertEquals(AcctMode.TRADING, tradeData.mode);
+
+			// Check balances
+			long expectedBalance = partnersInitialBalance;
+			long actualBalance = partner.getConfirmedBalance(Asset.QORT);
+
+			assertEquals("Partner's balance incorrect", expectedBalance, actualBalance);
+
+			// Check eventual refund
+			checkTradeRefund(repository, deployer, deployersInitialBalance, deployAtFee);
+		}
+	}
+
+	@SuppressWarnings("unused")
+	@Test
+	public void testIncorrectSecretCorrectSender() throws DataException {
+		try (final Repository repository = RepositoryManager.getRepository()) {
+			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
+			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
+
+			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
+
+			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
+			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
+
+			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
+			long deployAtFee = deployAtTransaction.getTransactionData().getFee();
+
+			Account at = deployAtTransaction.getATAccount();
+			String atAddress = at.getAddress();
+
+			long partnersOfferMessageTransactionTimestamp = System.currentTimeMillis();
+			int lockTimeA = calcTestLockTimeA(partnersOfferMessageTransactionTimestamp);
+			int refundTimeout = calcRefundTimeout(partnersOfferMessageTransactionTimestamp, lockTimeA);
+
+			// Send trade info to AT
+			byte[] messageData = buildTradeMessage(partner.getAddress(), getPublicKey(), hashOfSecretA, lockTimeA, refundTimeout);
+			MessageTransaction messageTransaction = sendMessage(repository, tradeAccount, messageData, atAddress);
+
+			// Give AT time to process message
+			BlockUtils.mintBlock(repository);
+
+			// Send incorrect secret to AT, from correct account
+			byte[] wrongSecret = new byte[32];
+			RANDOM.nextBytes(wrongSecret);
+			messageData = buildRedeemMessage(wrongSecret, partner.getAddress());
+			messageTransaction = sendMessage(repository, partner, messageData, atAddress);
+
+			// AT should NOT send funds in the next block
+			ATStateData preRedeemAtStateData = repository.getATRepository().getLatestATState(atAddress);
+			BlockUtils.mintBlock(repository);
+
+			describeAt(repository, atAddress);
+
+			// Check AT is NOT finished
+			ATData atData = repository.getATRepository().fromATAddress(atAddress);
+			assertFalse(atData.getIsFinished());
+
+			// AT should still be in TRADE mode
+			CrossChainTradeData tradeData = getInstance().populateTradeData(repository, atData);
+			assertEquals(AcctMode.TRADING, tradeData.mode);
+
+			long expectedBalance = partnersInitialBalance - messageTransaction.getTransactionData().getFee();
+			long actualBalance = partner.getConfirmedBalance(Asset.QORT);
+
+			assertEquals("Partner's balance incorrect", expectedBalance, actualBalance);
+
+			// Check eventual refund
+			checkTradeRefund(repository, deployer, deployersInitialBalance, deployAtFee);
+		}
+	}
+
+	@SuppressWarnings("unused")
+	@Test
+	public void testCorrectSecretCorrectSenderInvalidMessageLength() throws DataException {
+		try (final Repository repository = RepositoryManager.getRepository()) {
+			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
+			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
+
+			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
+
+			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
+			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
+
+			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
+			Account at = deployAtTransaction.getATAccount();
+			String atAddress = at.getAddress();
+
+			long partnersOfferMessageTransactionTimestamp = System.currentTimeMillis();
+			int lockTimeA = calcTestLockTimeA(partnersOfferMessageTransactionTimestamp);
+			int refundTimeout = calcRefundTimeout(partnersOfferMessageTransactionTimestamp, lockTimeA);
+
+			// Send trade info to AT
+			byte[] messageData = buildTradeMessage(partner.getAddress(), getPublicKey(), hashOfSecretA, lockTimeA, refundTimeout);
+			MessageTransaction messageTransaction = sendMessage(repository, tradeAccount, messageData, atAddress);
+
+			// Give AT time to process message
+			BlockUtils.mintBlock(repository);
+
+			// Send correct secret to AT, from correct account, but missing receive address, hence incorrect length
+			messageData = Bytes.concat(secretA);
+			messageTransaction = sendMessage(repository, partner, messageData, atAddress);
+
+			// AT should NOT send funds in the next block
+			ATStateData preRedeemAtStateData = repository.getATRepository().getLatestATState(atAddress);
+			BlockUtils.mintBlock(repository);
+
+			describeAt(repository, atAddress);
+
+			// Check AT is NOT finished
+			ATData atData = repository.getATRepository().fromATAddress(atAddress);
+			assertFalse(atData.getIsFinished());
+
+			// AT should be in TRADING mode
+			CrossChainTradeData tradeData = getInstance().populateTradeData(repository, atData);
+			assertEquals(AcctMode.TRADING, tradeData.mode);
+		}
+	}
+
+	@SuppressWarnings("unused")
+	@Test
+	public void testDescribeDeployed() throws DataException {
+		try (final Repository repository = RepositoryManager.getRepository()) {
+			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
+			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
+
+			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
+
+			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
+			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
+
+			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
+
+			List<ATData> executableAts = repository.getATRepository().getAllExecutableATs();
+
+			for (ATData atData : executableAts) {
+				String atAddress = atData.getATAddress();
+				byte[] codeBytes = atData.getCodeBytes();
+				byte[] codeHash = Crypto.digest(codeBytes);
+
+				System.out.println(String.format("%s: code length: %d byte%s, code hash: %s",
+						atAddress,
+						codeBytes.length,
+						(codeBytes.length != 1 ? "s": ""),
+						HashCode.fromBytes(codeHash)));
+
+				// Not one of ours?
+				if (!Arrays.equals(codeHash, getCodeBytesHash()))
+					continue;
+
+				describeAt(repository, atAddress);
+			}
+		}
+	}
+
+	protected int calcTestLockTimeA(long messageTimestamp) {
+		return (int) (messageTimestamp / 1000L + tradeTimeout * 60);
+	}
+
+	protected DeployAtTransaction doDeploy(Repository repository, PrivateKeyAccount deployer, String tradeAddress) throws DataException {
+		byte[] creationBytes = buildQortalAT(tradeAddress, getPublicKey(), redeemAmount, foreignAmount, tradeTimeout);
+
+		long txTimestamp = System.currentTimeMillis();
+		byte[] lastReference = deployer.getLastReference();
+
+		if (lastReference == null) {
+			System.err.println(String.format("Qortal account %s has no last reference", deployer.getAddress()));
+			System.exit(2);
+		}
+
+		Long fee = null;
+		String name = "QORT-" + getSymbol() + " cross-chain trade";
+		String description = String.format("Qortal-" + getName() + " cross-chain trade");
+		String atType = "ACCT";
+		String tags = "QORT-" + getSymbol() + " ACCT";
+
+		BaseTransactionData baseTransactionData = new BaseTransactionData(txTimestamp, Group.NO_GROUP, lastReference, deployer.getPublicKey(), fee, null);
+		TransactionData deployAtTransactionData = new DeployAtTransactionData(baseTransactionData, name, description, atType, tags, creationBytes, fundingAmount, Asset.QORT);
+
+		DeployAtTransaction deployAtTransaction = new DeployAtTransaction(repository, deployAtTransactionData);
+
+		fee = deployAtTransaction.calcRecommendedFee();
+		deployAtTransactionData.setFee(fee);
+
+		TransactionUtils.signAndMint(repository, deployAtTransactionData, deployer);
+
+		return deployAtTransaction;
+	}
+
+	protected MessageTransaction sendMessage(Repository repository, PrivateKeyAccount sender, byte[] data, String recipient) throws DataException {
+		long txTimestamp = System.currentTimeMillis();
+		byte[] lastReference = sender.getLastReference();
+
+		if (lastReference == null) {
+			System.err.println(String.format("Qortal account %s has no last reference", sender.getAddress()));
+			System.exit(2);
+		}
+
+		Long fee = null;
+		int version = 4;
+		int nonce = 0;
+		long amount = 0;
+		Long assetId = null; // because amount is zero
+
+		BaseTransactionData baseTransactionData = new BaseTransactionData(txTimestamp, Group.NO_GROUP, lastReference, sender.getPublicKey(), fee, null);
+		TransactionData messageTransactionData = new MessageTransactionData(baseTransactionData, version, nonce, recipient, amount, assetId, data, false, false);
+
+		MessageTransaction messageTransaction = new MessageTransaction(repository, messageTransactionData);
+
+		fee = messageTransaction.calcRecommendedFee();
+		messageTransactionData.setFee(fee);
+
+		TransactionUtils.signAndMint(repository, messageTransactionData, sender);
+
+		return messageTransaction;
+	}
+
+	protected void checkTradeRefund(Repository repository, Account deployer, long deployersInitialBalance, long deployAtFee) throws DataException {
+		long deployersPostDeploymentBalance = deployersInitialBalance - fundingAmount - deployAtFee;
+		int refundTimeout = tradeTimeout / 2 + 1; // close enough
+
+		// AT should automatically refund deployer after 'refundTimeout' blocks
+		for (int blockCount = 0; blockCount <= refundTimeout; ++blockCount)
+			BlockUtils.mintBlock(repository);
+
+		// We don't bother to exactly calculate QORT spent running AT for several blocks, but we do know the expected range
+		long expectedMinimumBalance = deployersPostDeploymentBalance;
+		long expectedMaximumBalance = deployersInitialBalance - deployAtFee;
+
+		long actualBalance = deployer.getConfirmedBalance(Asset.QORT);
+
+		assertTrue(String.format("Deployer's balance %s should be above minimum %s", actualBalance, expectedMinimumBalance), actualBalance > expectedMinimumBalance);
+		assertTrue(String.format("Deployer's balance %s should be below maximum %s", actualBalance, expectedMaximumBalance), actualBalance < expectedMaximumBalance);
+	}
+
+	protected void describeAt(Repository repository, String atAddress) throws DataException {
+		ATData atData = repository.getATRepository().fromATAddress(atAddress);
+		CrossChainTradeData tradeData = getInstance().populateTradeData(repository, atData);
+
+		Function<Long, String> epochMilliFormatter = (timestamp) -> LocalDateTime.ofInstant(Instant.ofEpochMilli(timestamp), ZoneOffset.UTC).format(DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM));
+		int currentBlockHeight = repository.getBlockRepository().getBlockchainHeight();
+
+		System.out.print(String.format("%s:\n"
+				+ "\tmode: %s\n"
+				+ "\tcreator: %s,\n"
+				+ "\tcreation timestamp: %s,\n"
+				+ "\tcurrent balance: %s QORT,\n"
+				+ "\tis finished: %b,\n"
+				+ "\tredeem payout: %s QORT,\n"
+				+ "\texpected " + getName() + ": %s " + getSymbol() + ",\n"
+				+ "\tcurrent block height: %d,\n",
+				tradeData.qortalAtAddress,
+				tradeData.mode,
+				tradeData.qortalCreator,
+				epochMilliFormatter.apply(tradeData.creationTimestamp),
+				Amounts.prettyAmount(tradeData.qortBalance),
+				atData.getIsFinished(),
+				Amounts.prettyAmount(tradeData.qortAmount),
+				Amounts.prettyAmount(tradeData.expectedForeignAmount),
+				currentBlockHeight));
+
+		describeRefundAt(tradeData, epochMilliFormatter);
+	}
+
+	protected void describeRefundAt(CrossChainTradeData tradeData, Function<Long, String> epochMilliFormatter) {
+		if (tradeData.mode != AcctMode.OFFERING && tradeData.mode != AcctMode.CANCELLED) {
+			System.out.println(String.format("\trefund timeout: %d minutes,\n"
+					+ "\trefund height: block %d,\n"
+					+ "\tHASH160 of secret-A: %s,\n"
+					+ "\t" + getName() + " P2SH-A nLockTime: %d (%s),\n"
+					+ "\ttrade partner: %s\n"
+					+ "\tpartner's receiving address: %s",
+					tradeData.refundTimeout,
+					tradeData.tradeRefundHeight,
+					HashCode.fromBytes(tradeData.hashOfSecretA).toString().substring(0, 40),
+					tradeData.lockTimeA, epochMilliFormatter.apply(tradeData.lockTimeA * 1000L),
+					tradeData.qortalPartnerAddress,
+					tradeData.qortalPartnerReceivingAddress));
+		}
+	}
+
+	protected PrivateKeyAccount createTradeAccount(Repository repository) {
+		// We actually use a known test account with funds to avoid PoW compute
+		return Common.getTestAccount(repository, "alice");
+	}
+}
--- a/src/test/java/org/qortal/test/crosschain/BitcoinTests.java
+++ b/src/test/java/org/qortal/test/crosschain/BitcoinTests.java
@@ -1,115 +1,59 @@
 package org.qortal.test.crosschain;

-import static org.junit.Assert.*;
-
-import java.util.Arrays;
-
-import org.bitcoinj.core.Transaction;
-import org.bitcoinj.store.BlockStoreException;
-import org.junit.After;
-import org.junit.Before;
+import org.junit.Ignore;
 import org.junit.Test;
 import org.qortal.crosschain.Bitcoin;
-import org.qortal.crosschain.ForeignBlockchainException;
-import org.qortal.crosschain.BitcoinyHTLC;
-import org.qortal.repository.DataException;
-import org.qortal.test.common.Common;
+import org.qortal.crosschain.Bitcoiny;

-public class BitcoinTests extends Common {
+public class BitcoinTests extends BitcoinyTests {

-	private Bitcoin bitcoin;
-
-	@Before
-	public void beforeTest() throws DataException {
-		Common.useDefaultSettings(); // TestNet3
-		bitcoin = Bitcoin.getInstance();
+	@Override
+	protected String getCoinName() {
+		return "Bitcoin";
 	}

-	@After
-	public void afterTest() {
+	@Override
+	protected String getCoinSymbol() {
+		return "BTC";
+	}
+
+	@Override
+	protected Bitcoiny getCoin() {
+		return Bitcoin.getInstance();
+	}
+
+	@Override
+	protected void resetCoinForTesting() {
 		Bitcoin.resetForTesting();
-		bitcoin = null;
+	}
+
+	@Override
+	protected String getDeterministicKey58() {
+		return "tprv8ZgxMBicQKsPdahhFSrCdvC1bsWyzHHZfTneTVqUXN6s1wEtZLwAkZXzFP6TYLg2aQMecZLXLre5bTVGajEB55L1HYJcawpdFG66STVAWPJ";
+	}
+
+	@Override
+	protected String getRecipient() {
+		return "2N8WCg52ULCtDSMjkgVTm5mtPdCsUptkHWE";
 	}

 	@Test
-	public void testGetMedianBlockTime() throws BlockStoreException, ForeignBlockchainException {
-		System.out.println(String.format("Starting BTC instance..."));
-		System.out.println(String.format("BTC instance started"));
-
-		long before = System.currentTimeMillis();
-		System.out.println(String.format("Bitcoin median blocktime: %d", bitcoin.getMedianBlockTime()));
-		long afterFirst = System.currentTimeMillis();
-
-		System.out.println(String.format("Bitcoin median blocktime: %d", bitcoin.getMedianBlockTime()));
-		long afterSecond = System.currentTimeMillis();
-
-		long firstPeriod = afterFirst - before;
-		long secondPeriod = afterSecond - afterFirst;
-
-		System.out.println(String.format("1st call: %d ms, 2nd call: %d ms", firstPeriod, secondPeriod));
-
-		assertTrue("2nd call should be quicker than 1st", secondPeriod < firstPeriod);
-		assertTrue("2nd call should take less than 5 seconds", secondPeriod < 5000L);
-	}
+	@Ignore("Often fails due to unreliable BTC testnet ElectrumX servers")
+	public void testGetMedianBlockTime() {}

 	@Test
-	public void testFindHtlcSecret() throws ForeignBlockchainException {
-		// This actually exists on TEST3 but can take a while to fetch
-		String p2shAddress = "2N8WCg52ULCtDSMjkgVTm5mtPdCsUptkHWE";
-
-		byte[] expectedSecret = "This string is exactly 32 bytes!".getBytes();
-		byte[] secret = BitcoinyHTLC.findHtlcSecret(bitcoin, p2shAddress);
-
-		assertNotNull(secret);
-		assertTrue("secret incorrect", Arrays.equals(expectedSecret, secret));
-	}
+	@Ignore("Often fails due to unreliable BTC testnet ElectrumX servers")
+	public void testFindHtlcSecret() {}

 	@Test
-	public void testBuildSpend() {
-		String xprv58 = "tprv8ZgxMBicQKsPdahhFSrCdvC1bsWyzHHZfTneTVqUXN6s1wEtZLwAkZXzFP6TYLg2aQMecZLXLre5bTVGajEB55L1HYJcawpdFG66STVAWPJ";
-
-		String recipient = "2N8WCg52ULCtDSMjkgVTm5mtPdCsUptkHWE";
-		long amount = 1000L;
-
-		Transaction transaction = bitcoin.buildSpend(xprv58, recipient, amount);
-		assertNotNull(transaction);
-
-		// Check spent key caching doesn't affect outcome
-
-		transaction = bitcoin.buildSpend(xprv58, recipient, amount);
-		assertNotNull(transaction);
-	}
+	@Ignore("Often fails due to unreliable BTC testnet ElectrumX servers")
+	public void testBuildSpend() {}

 	@Test
-	public void testGetWalletBalance() throws ForeignBlockchainException {
-		String xprv58 = "tprv8ZgxMBicQKsPdahhFSrCdvC1bsWyzHHZfTneTVqUXN6s1wEtZLwAkZXzFP6TYLg2aQMecZLXLre5bTVGajEB55L1HYJcawpdFG66STVAWPJ";
-
-		Long balance = bitcoin.getWalletBalance(xprv58);
-
-		assertNotNull(balance);
-
-		System.out.println(bitcoin.format(balance));
-
-		// Check spent key caching doesn't affect outcome
-
-		Long repeatBalance = bitcoin.getWalletBalance(xprv58);
-
-		assertNotNull(repeatBalance);
-
-		System.out.println(bitcoin.format(repeatBalance));
-
-		assertEquals(balance, repeatBalance);
-	}
+	@Ignore("Often fails due to unreliable BTC testnet ElectrumX servers")
+	public void testGetWalletBalance() {}

 	@Test
-	public void testGetUnusedReceiveAddress() throws ForeignBlockchainException {
-		String xprv58 = "tprv8ZgxMBicQKsPdahhFSrCdvC1bsWyzHHZfTneTVqUXN6s1wEtZLwAkZXzFP6TYLg2aQMecZLXLre5bTVGajEB55L1HYJcawpdFG66STVAWPJ";
-
-		String address = bitcoin.getUnusedReceiveAddress(xprv58);
-
-		assertNotNull(address);
-
-		System.out.println(address);
-	}
-
+	@Ignore("Often fails due to unreliable BTC testnet ElectrumX servers")
+	public void testGetUnusedReceiveAddress() {}
 }
--- a/src/test/java/org/qortal/test/crosschain/BitcoinyTests.java
+++ b/src/test/java/org/qortal/test/crosschain/BitcoinyTests.java
@@ -0,0 +1,130 @@
+package org.qortal.test.crosschain;
+
+import org.bitcoinj.core.Transaction;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.qortal.crosschain.Bitcoiny;
+import org.qortal.crosschain.BitcoinyHTLC;
+import org.qortal.crosschain.ForeignBlockchainException;
+import org.qortal.repository.DataException;
+import org.qortal.test.common.Common;
+
+import java.util.Arrays;
+
+import static org.junit.Assert.*;
+
+public abstract class BitcoinyTests extends Common {
+
+	protected Bitcoiny bitcoiny;
+
+	protected abstract String getCoinName();
+
+	protected abstract String getCoinSymbol();
+
+	protected abstract Bitcoiny getCoin();
+
+	protected abstract void resetCoinForTesting();
+
+	protected abstract String getDeterministicKey58();
+
+	protected abstract String getRecipient();
+
+	@Before
+	public void beforeTest() throws DataException {
+		Common.useDefaultSettings(); // TestNet3
+		bitcoiny = getCoin();
+	}
+
+	@After
+	public void afterTest() {
+		resetCoinForTesting();
+		bitcoiny = null;
+	}
+
+	@Test
+	public void testGetMedianBlockTime() throws ForeignBlockchainException {
+		System.out.println(String.format("Starting " + getCoinSymbol() + " instance..."));
+		System.out.println(String.format(getCoinSymbol() + " instance started"));
+
+		long before = System.currentTimeMillis();
+		System.out.println(String.format(getCoinName() + " median blocktime: %d", bitcoiny.getMedianBlockTime()));
+		long afterFirst = System.currentTimeMillis();
+
+		System.out.println(String.format(getCoinName() + " median blocktime: %d", bitcoiny.getMedianBlockTime()));
+		long afterSecond = System.currentTimeMillis();
+
+		long firstPeriod = afterFirst - before;
+		long secondPeriod = afterSecond - afterFirst;
+
+		System.out.println(String.format("1st call: %d ms, 2nd call: %d ms", firstPeriod, secondPeriod));
+
+		makeGetMedianBlockTimeAssertions(firstPeriod, secondPeriod);
+	}
+
+	public void makeGetMedianBlockTimeAssertions(long firstPeriod, long secondPeriod) {
+		assertTrue("2nd call should be quicker than 1st", secondPeriod < firstPeriod);
+		assertTrue("2nd call should take less than 5 seconds", secondPeriod < 5000L);
+	}
+
+	@Test
+	public void testFindHtlcSecret() throws ForeignBlockchainException {
+		// This actually exists on TEST3 but can take a while to fetch
+		String p2shAddress = "2N8WCg52ULCtDSMjkgVTm5mtPdCsUptkHWE";
+
+		byte[] expectedSecret = "This string is exactly 32 bytes!".getBytes();
+		byte[] secret = BitcoinyHTLC.findHtlcSecret(bitcoiny, p2shAddress);
+
+		assertNotNull(secret);
+		assertTrue("secret incorrect", Arrays.equals(expectedSecret, secret));
+	}
+
+	@Test
+	public void testBuildSpend() {
+		String xprv58 = getDeterministicKey58();
+
+		String recipient = getRecipient();
+		long amount = 1000L;
+
+		Transaction transaction = bitcoiny.buildSpend(xprv58, recipient, amount);
+		assertNotNull(transaction);
+
+		// Check spent key caching doesn't affect outcome
+
+		transaction = bitcoiny.buildSpend(xprv58, recipient, amount);
+		assertNotNull(transaction);
+	}
+
+	@Test
+	public void testGetWalletBalance() throws ForeignBlockchainException {
+		String xprv58 = getDeterministicKey58();
+
+		Long balance = bitcoiny.getWalletBalance(xprv58);
+
+		assertNotNull(balance);
+
+		System.out.println(bitcoiny.format(balance));
+
+		// Check spent key caching doesn't affect outcome
+
+		Long repeatBalance = bitcoiny.getWalletBalance(xprv58);
+
+		assertNotNull(repeatBalance);
+
+		System.out.println(bitcoiny.format(repeatBalance));
+
+		assertEquals(balance, repeatBalance);
+	}
+
+	@Test
+	public void testGetUnusedReceiveAddress() throws ForeignBlockchainException {
+		String xprv58 = getDeterministicKey58();
+
+		String address = bitcoiny.getUnusedReceiveAddress(xprv58);
+
+		assertNotNull(address);
+
+		System.out.println(address);
+	}
+
+}
--- a/src/test/java/org/qortal/test/crosschain/DigibyteTests.java
+++ b/src/test/java/org/qortal/test/crosschain/DigibyteTests.java
@@ -1,115 +1,48 @@
 package org.qortal.test.crosschain;

-import static org.junit.Assert.*;
-
-import java.util.Arrays;
-
-import org.bitcoinj.core.Transaction;
-import org.bitcoinj.store.BlockStoreException;
-import org.junit.After;
-import org.junit.Before;
 import org.junit.Ignore;
 import org.junit.Test;
-import org.qortal.crosschain.ForeignBlockchainException;
+import org.qortal.crosschain.Bitcoiny;
 import org.qortal.crosschain.Digibyte;
-import org.qortal.crosschain.BitcoinyHTLC;
-import org.qortal.repository.DataException;
-import org.qortal.test.common.Common;

-public class DigibyteTests extends Common {
+public class DigibyteTests extends BitcoinyTests {

-	private Digibyte digibyte;
-
-	@Before
-	public void beforeTest() throws DataException {
-		Common.useDefaultSettings(); // TestNet3
-		digibyte = Digibyte.getInstance();
+	@Override
+	protected String getCoinName() {
+		return "Digibyte";
 	}

-	@After
-	public void afterTest() {
+	@Override
+	protected String getCoinSymbol() {
+		return "DGB";
+	}
+
+	@Override
+	protected Bitcoiny getCoin() {
+		return Digibyte.getInstance();
+	}
+
+	@Override
+	protected void resetCoinForTesting() {
 		Digibyte.resetForTesting();
-		digibyte = null;
 	}

-	@Test
-	public void testGetMedianBlockTime() throws BlockStoreException, ForeignBlockchainException {
-		long before = System.currentTimeMillis();
-		System.out.println(String.format("Digibyte median blocktime: %d", digibyte.getMedianBlockTime()));
-		long afterFirst = System.currentTimeMillis();
+	@Override
+	protected String getDeterministicKey58() {
+		return "xpub661MyMwAqRbcEnabTLX5uebYcsE3uG5y7ve9jn1VK8iY1MaU3YLoLJEe8sTu2YVav5Zka5qf2dmMssfxmXJTqZnazZL2kL7M2tNKwEoC34R";
+	}

-		System.out.println(String.format("Digibyte median blocktime: %d", digibyte.getMedianBlockTime()));
-		long afterSecond = System.currentTimeMillis();
-
-		long firstPeriod = afterFirst - before;
-		long secondPeriod = afterSecond - afterFirst;
-
-		System.out.println(String.format("1st call: %d ms, 2nd call: %d ms", firstPeriod, secondPeriod));
-
-		assertTrue("2nd call should be quicker than 1st", secondPeriod < firstPeriod);
-		assertTrue("2nd call should take less than 5 seconds", secondPeriod < 5000L);
+	@Override
+	protected String getRecipient() {
+		return "2N8WCg52ULCtDSMjkgVTm5mtPdCsUptkHWE";
 	}

 	@Test
 	@Ignore(value = "Doesn't work, to be fixed later")
-	public void testFindHtlcSecret() throws ForeignBlockchainException {
-		// This actually exists on TEST3 but can take a while to fetch
-		String p2shAddress = "2N8WCg52ULCtDSMjkgVTm5mtPdCsUptkHWE";
-
-		byte[] expectedSecret = "This string is exactly 32 bytes!".getBytes();
-		byte[] secret = BitcoinyHTLC.findHtlcSecret(digibyte, p2shAddress);
-
-		assertNotNull("secret not found", secret);
-		assertTrue("secret incorrect", Arrays.equals(expectedSecret, secret));
-	}
+	public void testFindHtlcSecret() {}

 	@Test
 	@Ignore(value = "No testnet nodes available, so we can't regularly test buildSpend yet")
-	public void testBuildSpend() {
-		String xprv58 = "tprv8ZgxMBicQKsPdahhFSrCdvC1bsWyzHHZfTneTVqUXN6s1wEtZLwAkZXzFP6TYLg2aQMecZLXLre5bTVGajEB55L1HYJcawpdFG66STVAWPJ";
+	public void testBuildSpend() {}

-		String recipient = "2N8WCg52ULCtDSMjkgVTm5mtPdCsUptkHWE";
-		long amount = 1000L;
-
-		Transaction transaction = digibyte.buildSpend(xprv58, recipient, amount);
-		assertNotNull("insufficient funds", transaction);
-
-		// Check spent key caching doesn't affect outcome
-
-		transaction = digibyte.buildSpend(xprv58, recipient, amount);
-		assertNotNull("insufficient funds", transaction);
 	}
-
-	@Test
-	public void testGetWalletBalance() throws ForeignBlockchainException {
-		String xprv58 = "xpub661MyMwAqRbcEnabTLX5uebYcsE3uG5y7ve9jn1VK8iY1MaU3YLoLJEe8sTu2YVav5Zka5qf2dmMssfxmXJTqZnazZL2kL7M2tNKwEoC34R";
-
-		Long balance = digibyte.getWalletBalance(xprv58);
-
-		assertNotNull(balance);
-
-		System.out.println(digibyte.format(balance));
-
-		// Check spent key caching doesn't affect outcome
-
-		Long repeatBalance = digibyte.getWalletBalance(xprv58);
-
-		assertNotNull(repeatBalance);
-
-		System.out.println(digibyte.format(repeatBalance));
-
-		assertEquals(balance, repeatBalance);
-	}
-
-	@Test
-	public void testGetUnusedReceiveAddress() throws ForeignBlockchainException {
-		String xprv58 = "xpub661MyMwAqRbcEnabTLX5uebYcsE3uG5y7ve9jn1VK8iY1MaU3YLoLJEe8sTu2YVav5Zka5qf2dmMssfxmXJTqZnazZL2kL7M2tNKwEoC34R";
-
-		String address = digibyte.getUnusedReceiveAddress(xprv58);
-
-		assertNotNull(address);
-
-		System.out.println(address);
-	}
-
-}
--- a/src/test/java/org/qortal/test/crosschain/DogecoinTests.java
+++ b/src/test/java/org/qortal/test/crosschain/DogecoinTests.java
@@ -1,115 +1,47 @@
 package org.qortal.test.crosschain;

-import org.bitcoinj.core.Transaction;
-import org.bitcoinj.store.BlockStoreException;
-import org.junit.After;
-import org.junit.Before;
 import org.junit.Ignore;
 import org.junit.Test;
-import org.qortal.crosschain.BitcoinyHTLC;
-import org.qortal.crosschain.ForeignBlockchainException;
+import org.qortal.crosschain.Bitcoiny;
 import org.qortal.crosschain.Dogecoin;
-import org.qortal.repository.DataException;
-import org.qortal.test.common.Common;

-import java.util.Arrays;
+public class DogecoinTests extends BitcoinyTests {

-import static org.junit.Assert.*;
-
-public class DogecoinTests extends Common {
-
-	private Dogecoin dogecoin;
-
-	@Before
-	public void beforeTest() throws DataException {
-		Common.useDefaultSettings(); // TestNet3
-		dogecoin = Dogecoin.getInstance();
+	@Override
+	protected String getCoinName() {
+		return "Dogecoin";
 	}

-	@After
-	public void afterTest() {
+	@Override
+	protected String getCoinSymbol() {
+		return "DOGE";
+	}
+
+	@Override
+	protected Bitcoiny getCoin() {
+		return Dogecoin.getInstance();
+	}
+
+	@Override
+	protected void resetCoinForTesting() {
 		Dogecoin.resetForTesting();
-		dogecoin = null;
 	}

-	@Test
-	public void testGetMedianBlockTime() throws BlockStoreException, ForeignBlockchainException {
-		long before = System.currentTimeMillis();
-		System.out.println(String.format("Dogecoin median blocktime: %d", dogecoin.getMedianBlockTime()));
-		long afterFirst = System.currentTimeMillis();
+	@Override
+	protected String getDeterministicKey58() {
+		return "dgpv51eADS3spNJh9drNeW1Tc1P9z2LyaQRXPBortsq6yice1k47C2u2Prvgxycr2ihNBWzKZ2LthcBBGiYkWZ69KUTVkcLVbnjq7pD8mnApEru";
+	}

-		System.out.println(String.format("Dogecoin median blocktime: %d", dogecoin.getMedianBlockTime()));
-		long afterSecond = System.currentTimeMillis();
-
-		long firstPeriod = afterFirst - before;
-		long secondPeriod = afterSecond - afterFirst;
-
-		System.out.println(String.format("1st call: %d ms, 2nd call: %d ms", firstPeriod, secondPeriod));
-
-		assertTrue("2nd call should be quicker than 1st", secondPeriod < firstPeriod);
-		assertTrue("2nd call should take less than 5 seconds", secondPeriod < 5000L);
+	@Override
+	protected String getRecipient() {
+		return null;
 	}

 	@Test
 	@Ignore(value = "Doesn't work, to be fixed later")
-	public void testFindHtlcSecret() throws ForeignBlockchainException {
-		// This actually exists on TEST3 but can take a while to fetch
-		String p2shAddress = "2N8WCg52ULCtDSMjkgVTm5mtPdCsUptkHWE";
-
-		byte[] expectedSecret = "This string is exactly 32 bytes!".getBytes();
-		byte[] secret = BitcoinyHTLC.findHtlcSecret(dogecoin, p2shAddress);
-
-		assertNotNull("secret not found", secret);
-		assertTrue("secret incorrect", Arrays.equals(expectedSecret, secret));
-	}
+	public void testFindHtlcSecret() {}

 	@Test
 	@Ignore(value = "No testnet nodes available, so we can't regularly test buildSpend yet")
-	public void testBuildSpend() {
-		String xprv58 = "dgpv51eADS3spNJh9drNeW1Tc1P9z2LyaQRXPBortsq6yice1k47C2u2Prvgxycr2ihNBWzKZ2LthcBBGiYkWZ69KUTVkcLVbnjq7pD8mnApEru";
-
-		String recipient = "DP1iFao33xdEPa5vaArpj7sykfzKNeiJeX";
-		long amount = 1000L;
-
-		Transaction transaction = dogecoin.buildSpend(xprv58, recipient, amount);
-		assertNotNull("insufficient funds", transaction);
-
-		// Check spent key caching doesn't affect outcome
-
-		transaction = dogecoin.buildSpend(xprv58, recipient, amount);
-		assertNotNull("insufficient funds", transaction);
-	}
-
-	@Test
-	public void testGetWalletBalance() throws ForeignBlockchainException {
-		String xprv58 = "dgpv51eADS3spNJh9drNeW1Tc1P9z2LyaQRXPBortsq6yice1k47C2u2Prvgxycr2ihNBWzKZ2LthcBBGiYkWZ69KUTVkcLVbnjq7pD8mnApEru";
-
-		Long balance = dogecoin.getWalletBalance(xprv58);
-
-		assertNotNull(balance);
-
-		System.out.println(dogecoin.format(balance));
-
-		// Check spent key caching doesn't affect outcome
-
-		Long repeatBalance = dogecoin.getWalletBalance(xprv58);
-
-		assertNotNull(repeatBalance);
-
-		System.out.println(dogecoin.format(repeatBalance));
-
-		assertEquals(balance, repeatBalance);
-	}
-
-	@Test
-	public void testGetUnusedReceiveAddress() throws ForeignBlockchainException {
-		String xprv58 = "dgpv51eADS3spNJh9drNeW1Tc1P9z2LyaQRXPBortsq6yice1k47C2u2Prvgxycr2ihNBWzKZ2LthcBBGiYkWZ69KUTVkcLVbnjq7pD8mnApEru";
-
-		String address = dogecoin.getUnusedReceiveAddress(xprv58);
-
-		assertNotNull(address);
-
-		System.out.println(address);
-	}
-
+	public void testBuildSpend() {}
 }
--- a/src/test/java/org/qortal/test/crosschain/HtlcTests.java
+++ b/src/test/java/org/qortal/test/crosschain/HtlcTests.java
@@ -8,6 +8,7 @@ import org.junit.Ignore;
 import org.junit.Test;
 import org.qortal.crosschain.Bitcoin;
 import org.qortal.crosschain.ForeignBlockchainException;
+import org.qortal.crosschain.Litecoin;
 import org.qortal.crypto.Crypto;
 import org.qortal.crosschain.BitcoinyHTLC;
 import org.qortal.repository.DataException;
@@ -18,17 +19,19 @@ import com.google.common.primitives.Longs;
 public class HtlcTests extends Common {

 	private Bitcoin bitcoin;
+	private Litecoin litecoin;

 	@Before
 	public void beforeTest() throws DataException {
 		Common.useDefaultSettings(); // TestNet3
 		bitcoin = Bitcoin.getInstance();
+		litecoin = Litecoin.getInstance();
 	}

 	@After
 	public void afterTest() {
 		Bitcoin.resetForTesting();
-		bitcoin = null;
+		litecoin = null;
 	}

 	@Test
@@ -52,12 +55,12 @@ public class HtlcTests extends Common {
 		do {
 			// We need to perform fresh setup for 1st test
 			Bitcoin.resetForTesting();
-			bitcoin = Bitcoin.getInstance();
+			litecoin = Litecoin.getInstance();

 			long now = System.currentTimeMillis();
 			long timestampBoundary = now / 30_000L;

-			byte[] secret1 = BitcoinyHTLC.findHtlcSecret(bitcoin, p2shAddress);
+			byte[] secret1 = BitcoinyHTLC.findHtlcSecret(litecoin, p2shAddress);
 			long executionPeriod1 = System.currentTimeMillis() - now;

 			assertNotNull(secret1);
@@ -65,7 +68,7 @@ public class HtlcTests extends Common {

 			assertTrue("1st execution period should not be instant!", executionPeriod1 > 10);

-			byte[] secret2 = BitcoinyHTLC.findHtlcSecret(bitcoin, p2shAddress);
+			byte[] secret2 = BitcoinyHTLC.findHtlcSecret(litecoin, p2shAddress);
 			long executionPeriod2 = System.currentTimeMillis() - now - executionPeriod1;

 			assertNotNull(secret2);
@@ -86,7 +89,7 @@ public class HtlcTests extends Common {
 		// This actually exists on TEST3 but can take a while to fetch
 		String p2shAddress = "2N8WCg52ULCtDSMjkgVTm5mtPdCsUptkHWE";

-		BitcoinyHTLC.Status htlcStatus = BitcoinyHTLC.determineHtlcStatus(bitcoin.getBlockchainProvider(), p2shAddress, 1L);
+		BitcoinyHTLC.Status htlcStatus = BitcoinyHTLC.determineHtlcStatus(litecoin.getBlockchainProvider(), p2shAddress, 1L);
 		assertNotNull(htlcStatus);

 		System.out.println(String.format("HTLC %s status: %s", p2shAddress, htlcStatus.name()));
@@ -97,21 +100,21 @@ public class HtlcTests extends Common {
 		do {
 			// We need to perform fresh setup for 1st test
 			Bitcoin.resetForTesting();
-			bitcoin = Bitcoin.getInstance();
+			litecoin = Litecoin.getInstance();

 			long now = System.currentTimeMillis();
 			long timestampBoundary = now / 30_000L;

 			// Won't ever exist
-			String p2shAddress = bitcoin.deriveP2shAddress(Crypto.hash160(Longs.toByteArray(now)));
+			String p2shAddress = litecoin.deriveP2shAddress(Crypto.hash160(Longs.toByteArray(now)));

-			BitcoinyHTLC.Status htlcStatus1 = BitcoinyHTLC.determineHtlcStatus(bitcoin.getBlockchainProvider(), p2shAddress, 1L);
+			BitcoinyHTLC.Status htlcStatus1 = BitcoinyHTLC.determineHtlcStatus(litecoin.getBlockchainProvider(), p2shAddress, 1L);
 			long executionPeriod1 = System.currentTimeMillis() - now;

 			assertNotNull(htlcStatus1);
 			assertTrue("1st execution period should not be instant!", executionPeriod1 > 10);

-			BitcoinyHTLC.Status htlcStatus2 = BitcoinyHTLC.determineHtlcStatus(bitcoin.getBlockchainProvider(), p2shAddress, 1L);
+			BitcoinyHTLC.Status htlcStatus2 = BitcoinyHTLC.determineHtlcStatus(litecoin.getBlockchainProvider(), p2shAddress, 1L);
 			long executionPeriod2 = System.currentTimeMillis() - now - executionPeriod1;

 			assertNotNull(htlcStatus2);
--- a/src/test/java/org/qortal/test/crosschain/LitecoinTests.java
+++ b/src/test/java/org/qortal/test/crosschain/LitecoinTests.java
@@ -1,114 +1,43 @@
 package org.qortal.test.crosschain;

-import static org.junit.Assert.*;
-
-import java.util.Arrays;
-
-import org.bitcoinj.core.Transaction;
-import org.bitcoinj.store.BlockStoreException;
-import org.junit.After;
-import org.junit.Before;
 import org.junit.Ignore;
 import org.junit.Test;
-import org.qortal.crosschain.ForeignBlockchainException;
+import org.qortal.crosschain.Bitcoiny;
 import org.qortal.crosschain.Litecoin;
-import org.qortal.crosschain.BitcoinyHTLC;
-import org.qortal.repository.DataException;
-import org.qortal.test.common.Common;

-public class LitecoinTests extends Common {
+public class LitecoinTests extends BitcoinyTests {

-	private Litecoin litecoin;
-
-	@Before
-	public void beforeTest() throws DataException {
-		Common.useDefaultSettings(); // TestNet3
-		litecoin = Litecoin.getInstance();
+	@Override
+	protected String getCoinName() {
+		return "Litecoin";
 	}

-	@After
-	public void afterTest() {
+	@Override
+	protected String getCoinSymbol() {
+		return "LTC";
+	}
+
+	@Override
+	protected Bitcoiny getCoin() {
+		return Litecoin.getInstance();
+	}
+
+	@Override
+	protected void resetCoinForTesting() {
 		Litecoin.resetForTesting();
-		litecoin = null;
 	}

-	@Test
-	public void testGetMedianBlockTime() throws BlockStoreException, ForeignBlockchainException {
-		long before = System.currentTimeMillis();
-		System.out.println(String.format("Bitcoin median blocktime: %d", litecoin.getMedianBlockTime()));
-		long afterFirst = System.currentTimeMillis();
+	@Override
+	protected String getDeterministicKey58() {
+		return "tprv8ZgxMBicQKsPdahhFSrCdvC1bsWyzHHZfTneTVqUXN6s1wEtZLwAkZXzFP6TYLg2aQMecZLXLre5bTVGajEB55L1HYJcawpdFG66STVAWPJ";
+	}

-		System.out.println(String.format("Bitcoin median blocktime: %d", litecoin.getMedianBlockTime()));
-		long afterSecond = System.currentTimeMillis();
-
-		long firstPeriod = afterFirst - before;
-		long secondPeriod = afterSecond - afterFirst;
-
-		System.out.println(String.format("1st call: %d ms, 2nd call: %d ms", firstPeriod, secondPeriod));
-
-		assertTrue("2nd call should be quicker than 1st", secondPeriod < firstPeriod);
-		assertTrue("2nd call should take less than 5 seconds", secondPeriod < 5000L);
+	@Override
+	protected String getRecipient() {
+		return "2N8WCg52ULCtDSMjkgVTm5mtPdCsUptkHWE";
 	}

 	@Test
 	@Ignore(value = "Doesn't work, to be fixed later")
-	public void testFindHtlcSecret() throws ForeignBlockchainException {
-		// This actually exists on TEST3 but can take a while to fetch
-		String p2shAddress = "2N8WCg52ULCtDSMjkgVTm5mtPdCsUptkHWE";
-
-		byte[] expectedSecret = "This string is exactly 32 bytes!".getBytes();
-		byte[] secret = BitcoinyHTLC.findHtlcSecret(litecoin, p2shAddress);
-
-		assertNotNull("secret not found", secret);
-		assertTrue("secret incorrect", Arrays.equals(expectedSecret, secret));
-	}
-
-	@Test
-	public void testBuildSpend() {
-		String xprv58 = "tprv8ZgxMBicQKsPdahhFSrCdvC1bsWyzHHZfTneTVqUXN6s1wEtZLwAkZXzFP6TYLg2aQMecZLXLre5bTVGajEB55L1HYJcawpdFG66STVAWPJ";
-
-		String recipient = "2N8WCg52ULCtDSMjkgVTm5mtPdCsUptkHWE";
-		long amount = 1000L;
-
-		Transaction transaction = litecoin.buildSpend(xprv58, recipient, amount);
-		assertNotNull("insufficient funds", transaction);
-
-		// Check spent key caching doesn't affect outcome
-
-		transaction = litecoin.buildSpend(xprv58, recipient, amount);
-		assertNotNull("insufficient funds", transaction);
-	}
-
-	@Test
-	public void testGetWalletBalance() throws ForeignBlockchainException {
-		String xprv58 = "tprv8ZgxMBicQKsPdahhFSrCdvC1bsWyzHHZfTneTVqUXN6s1wEtZLwAkZXzFP6TYLg2aQMecZLXLre5bTVGajEB55L1HYJcawpdFG66STVAWPJ";
-
-		Long balance = litecoin.getWalletBalance(xprv58);
-
-		assertNotNull(balance);
-
-		System.out.println(litecoin.format(balance));
-
-		// Check spent key caching doesn't affect outcome
-
-		Long repeatBalance = litecoin.getWalletBalance(xprv58);
-
-		assertNotNull(repeatBalance);
-
-		System.out.println(litecoin.format(repeatBalance));
-
-		assertEquals(balance, repeatBalance);
-	}
-
-	@Test
-	public void testGetUnusedReceiveAddress() throws ForeignBlockchainException {
-		String xprv58 = "tprv8ZgxMBicQKsPdahhFSrCdvC1bsWyzHHZfTneTVqUXN6s1wEtZLwAkZXzFP6TYLg2aQMecZLXLre5bTVGajEB55L1HYJcawpdFG66STVAWPJ";
-
-		String address = litecoin.getUnusedReceiveAddress(xprv58);
-
-		assertNotNull(address);
-
-		System.out.println(address);
-	}
-
+	public void testFindHtlcSecret() {}
 }
--- a/src/test/java/org/qortal/test/crosschain/PirateChainTests.java
+++ b/src/test/java/org/qortal/test/crosschain/PirateChainTests.java
@@ -3,57 +3,53 @@ package org.qortal.test.crosschain;
 import cash.z.wallet.sdk.rpc.CompactFormats.*;
 import com.google.common.hash.HashCode;
 import com.google.common.primitives.Bytes;
-import org.bitcoinj.core.Transaction;
-import org.bitcoinj.store.BlockStoreException;
-import org.junit.After;
-import org.junit.Before;
 import org.junit.Ignore;
 import org.junit.Test;
 import org.qortal.controller.tradebot.TradeBot;
 import org.qortal.crosschain.*;
 import org.qortal.crypto.Crypto;
-import org.qortal.repository.DataException;
-import org.qortal.test.common.Common;
 import org.qortal.transform.TransformationException;

-import java.util.Arrays;
 import java.util.List;

 import static org.junit.Assert.*;
 import static org.qortal.crosschain.BitcoinyHTLC.Status.*;

-public class PirateChainTests extends Common {
+public class PirateChainTests extends BitcoinyTests {

-	private PirateChain pirateChain;
-
-	@Before
-	public void beforeTest() throws DataException {
-		Common.useDefaultSettings();
-		pirateChain = PirateChain.getInstance();
+	@Override
+	protected String getCoinName() {
+		return "PirateChain";
 	}

-	@After
-	public void afterTest() {
+	@Override
+	protected String getCoinSymbol() {
+		return "ARRR";
+	}
+
+	@Override
+	protected Bitcoiny getCoin() {
+		return PirateChain.getInstance();
+	}
+
+	@Override
+	protected void resetCoinForTesting() {
 		Litecoin.resetForTesting();
-		pirateChain = null;
 	}

-	@Test
-	public void testGetMedianBlockTime() throws BlockStoreException, ForeignBlockchainException {
-		long before = System.currentTimeMillis();
-		System.out.println(String.format("Pirate Chain median blocktime: %d", pirateChain.getMedianBlockTime()));
-		long afterFirst = System.currentTimeMillis();
+	@Override
+	protected String getDeterministicKey58() {
+		return null;
+	}

-		System.out.println(String.format("Pirate Chain median blocktime: %d", pirateChain.getMedianBlockTime()));
-		long afterSecond = System.currentTimeMillis();
+	@Override
+	protected String getRecipient() {
+		return null;
+	}

-		long firstPeriod = afterFirst - before;
-		long secondPeriod = afterSecond - afterFirst;
-
-		System.out.println(String.format("1st call: %d ms, 2nd call: %d ms", firstPeriod, secondPeriod));
-
-		assertTrue("1st call should take less than 5 seconds", firstPeriod < 5000L);
-		assertTrue("2nd call should take less than 5 seconds", secondPeriod < 5000L);
+	public void makeGetMedianBlockTimeAssertions(long firstPeriod, long secondPeriod) {
+			assertTrue("1st call should take less than 5 seconds", firstPeriod < 5000L);
+			assertTrue("2nd call should take less than 5 seconds", secondPeriod < 5000L);
 	}

 	@Test
@@ -62,7 +58,7 @@ public class PirateChainTests extends Common {
 		int count = 20;

 		long before = System.currentTimeMillis();
-		List<CompactBlock> compactBlocks = pirateChain.getCompactBlocks(startHeight, count);
+		List<CompactBlock> compactBlocks = ((PirateChain) bitcoiny).getCompactBlocks(startHeight, count);
 		long after = System.currentTimeMillis();

 		System.out.println(String.format("Retrieval took: %d ms", after-before));
@@ -82,7 +78,7 @@ public class PirateChainTests extends Common {
 		Bytes.reverse(txBytes);
 		String txHashBE = HashCode.fromBytes(txBytes).toString();

-		byte[] rawTransaction = pirateChain.getBlockchainProvider().getRawTransaction(txHashBE);
+		byte[] rawTransaction = bitcoiny.getBlockchainProvider().getRawTransaction(txHashBE);
 		assertNotNull(rawTransaction);
 	}

@@ -121,7 +117,7 @@ public class PirateChainTests extends Common {
 		String p2shAddress = "ba6Q5HWrWtmfU2WZqQbrFdRYsafA45cUAt";
 		long p2shFee = 10000;
 		final long minimumAmount = 10000 + p2shFee;
-		BitcoinyHTLC.Status htlcStatus = PirateChainHTLC.determineHtlcStatus(pirateChain.getBlockchainProvider(), p2shAddress, minimumAmount);
+		BitcoinyHTLC.Status htlcStatus = PirateChainHTLC.determineHtlcStatus(bitcoiny.getBlockchainProvider(), p2shAddress, minimumAmount);
 		assertEquals(FUNDED, htlcStatus);
 	}

@@ -130,7 +126,7 @@ public class PirateChainTests extends Common {
 		String p2shAddress = "bYZrzSSgGp8aEGvihukoMGU8sXYrx19Wka";
 		long p2shFee = 10000;
 		final long minimumAmount = 10000 + p2shFee;
-		BitcoinyHTLC.Status htlcStatus = PirateChainHTLC.determineHtlcStatus(pirateChain.getBlockchainProvider(), p2shAddress, minimumAmount);
+		BitcoinyHTLC.Status htlcStatus = PirateChainHTLC.determineHtlcStatus(bitcoiny.getBlockchainProvider(), p2shAddress, minimumAmount);
 		assertEquals(REDEEMED, htlcStatus);
 	}

@@ -139,14 +135,14 @@ public class PirateChainTests extends Common {
 		String p2shAddress = "bE49izfVxz8odhu8c2BcUaVFUnt7NLFRgv";
 		long p2shFee = 10000;
 		final long minimumAmount = 10000 + p2shFee;
-		BitcoinyHTLC.Status htlcStatus = PirateChainHTLC.determineHtlcStatus(pirateChain.getBlockchainProvider(), p2shAddress, minimumAmount);
+		BitcoinyHTLC.Status htlcStatus = PirateChainHTLC.determineHtlcStatus(bitcoiny.getBlockchainProvider(), p2shAddress, minimumAmount);
 		assertEquals(REFUNDED, htlcStatus);
 	}

 	@Test
 	public void testGetTxidForUnspentAddress() throws ForeignBlockchainException {
 		String p2shAddress = "ba6Q5HWrWtmfU2WZqQbrFdRYsafA45cUAt";
-		String txid = PirateChainHTLC.getFundingTxid(pirateChain.getBlockchainProvider(), p2shAddress);
+		String txid = PirateChainHTLC.getFundingTxid(bitcoiny.getBlockchainProvider(), p2shAddress);

 		// Reverse the byte order of the txid used by block explorers, to get to big-endian form
 		byte[] expectedTxidLE = HashCode.fromString("fea4b0c1abcf8f0f3ddc2fa2f9438501ee102aad62a9ff18a5ce7d08774755c0").asBytes();
@@ -161,7 +157,7 @@ public class PirateChainTests extends Common {
 		String p2shAddress = "ba6Q5HWrWtmfU2WZqQbrFdRYsafA45cUAt";
 		long p2shFee = 10000;
 		final long minimumAmount = 10000 + p2shFee;
-		String txid = PirateChainHTLC.getUnspentFundingTxid(pirateChain.getBlockchainProvider(), p2shAddress, minimumAmount);
+		String txid = PirateChainHTLC.getUnspentFundingTxid(bitcoiny.getBlockchainProvider(), p2shAddress, minimumAmount);

 		// Reverse the byte order of the txid used by block explorers, to get to big-endian form
 		byte[] expectedTxidLE = HashCode.fromString("fea4b0c1abcf8f0f3ddc2fa2f9438501ee102aad62a9ff18a5ce7d08774755c0").asBytes();
@@ -174,7 +170,7 @@ public class PirateChainTests extends Common {
 	@Test
 	public void testGetTxidForSpentAddress() throws ForeignBlockchainException {
 		String p2shAddress = "bE49izfVxz8odhu8c2BcUaVFUnt7NLFRgv"; //"t3KtVxeEb8srJofo6atMEpMpEP6TjEi8VqA";
-		String txid = PirateChainHTLC.getFundingTxid(pirateChain.getBlockchainProvider(), p2shAddress);
+		String txid = PirateChainHTLC.getFundingTxid(bitcoiny.getBlockchainProvider(), p2shAddress);

 		// Reverse the byte order of the txid used by block explorers, to get to big-endian form
 		byte[] expectedTxidLE = HashCode.fromString("fb386fc8eea0fbf3ea37047726b92c39441652b32d8d62a274331687f7a1eca8").asBytes();
@@ -187,7 +183,7 @@ public class PirateChainTests extends Common {
 	@Test
 	public void testGetTransactionsForAddress() throws ForeignBlockchainException {
 		String p2shAddress = "bE49izfVxz8odhu8c2BcUaVFUnt7NLFRgv"; //"t3KtVxeEb8srJofo6atMEpMpEP6TjEi8VqA";
-		List<BitcoinyTransaction> transactions = pirateChain.getBlockchainProvider()
+		List<BitcoinyTransaction> transactions = bitcoiny.getBlockchainProvider()
 				.getAddressBitcoinyTransactions(p2shAddress, false);

 		assertEquals(2, transactions.size());
@@ -232,66 +228,17 @@ public class PirateChainTests extends Common {

 	@Test
 	@Ignore(value = "Doesn't work, to be fixed later")
-	public void testFindHtlcSecret() throws ForeignBlockchainException {
-		// This actually exists on TEST3 but can take a while to fetch
-		String p2shAddress = "2N8WCg52ULCtDSMjkgVTm5mtPdCsUptkHWE";
-
-		byte[] expectedSecret = "This string is exactly 32 bytes!".getBytes();
-		byte[] secret = BitcoinyHTLC.findHtlcSecret(pirateChain, p2shAddress);
-
-		assertNotNull("secret not found", secret);
-		assertTrue("secret incorrect", Arrays.equals(expectedSecret, secret));
-	}
+	public void testFindHtlcSecret() {}

 	@Test
 	@Ignore(value = "Needs adapting for Pirate Chain")
-	public void testBuildSpend() {
-		String xprv58 = "tprv8ZgxMBicQKsPdahhFSrCdvC1bsWyzHHZfTneTVqUXN6s1wEtZLwAkZXzFP6TYLg2aQMecZLXLre5bTVGajEB55L1HYJcawpdFG66STVAWPJ";
-
-		String recipient = "2N8WCg52ULCtDSMjkgVTm5mtPdCsUptkHWE";
-		long amount = 1000L;
-
-		Transaction transaction = pirateChain.buildSpend(xprv58, recipient, amount);
-		assertNotNull("insufficient funds", transaction);
-
-		// Check spent key caching doesn't affect outcome
-
-		transaction = pirateChain.buildSpend(xprv58, recipient, amount);
-		assertNotNull("insufficient funds", transaction);
-	}
+	public void testBuildSpend() {}

 	@Test
 	@Ignore(value = "Needs adapting for Pirate Chain")
-	public void testGetWalletBalance() throws ForeignBlockchainException {
-		String xprv58 = "tprv8ZgxMBicQKsPdahhFSrCdvC1bsWyzHHZfTneTVqUXN6s1wEtZLwAkZXzFP6TYLg2aQMecZLXLre5bTVGajEB55L1HYJcawpdFG66STVAWPJ";
-
-		Long balance = pirateChain.getWalletBalance(xprv58);
-
-		assertNotNull(balance);
-
-		System.out.println(pirateChain.format(balance));
-
-		// Check spent key caching doesn't affect outcome
-
-		Long repeatBalance = pirateChain.getWalletBalance(xprv58);
-
-		assertNotNull(repeatBalance);
-
-		System.out.println(pirateChain.format(repeatBalance));
-
-		assertEquals(balance, repeatBalance);
-	}
+	public void testGetWalletBalance() {}

 	@Test
 	@Ignore(value = "Needs adapting for Pirate Chain")
-	public void testGetUnusedReceiveAddress() throws ForeignBlockchainException {
-		String xprv58 = "tprv8ZgxMBicQKsPdahhFSrCdvC1bsWyzHHZfTneTVqUXN6s1wEtZLwAkZXzFP6TYLg2aQMecZLXLre5bTVGajEB55L1HYJcawpdFG66STVAWPJ";
-
-		String address = pirateChain.getUnusedReceiveAddress(xprv58);
-
-		assertNotNull(address);
-
-		System.out.println(address);
-	}
-
-}
+	public void testGetUnusedReceiveAddress() {}
+}
--- a/src/test/java/org/qortal/test/crosschain/RavencoinTests.java
+++ b/src/test/java/org/qortal/test/crosschain/RavencoinTests.java
@@ -1,115 +1,47 @@
 package org.qortal.test.crosschain;

-import static org.junit.Assert.*;
-
-import java.util.Arrays;
-
-import org.bitcoinj.core.Transaction;
-import org.bitcoinj.store.BlockStoreException;
-import org.junit.After;
-import org.junit.Before;
 import org.junit.Ignore;
 import org.junit.Test;
-import org.qortal.crosschain.ForeignBlockchainException;
+import org.qortal.crosschain.Bitcoiny;
 import org.qortal.crosschain.Ravencoin;
-import org.qortal.crosschain.BitcoinyHTLC;
-import org.qortal.repository.DataException;
-import org.qortal.test.common.Common;

-public class RavencoinTests extends Common {
+public class RavencoinTests extends BitcoinyTests {

-	private Ravencoin ravencoin;
-
-	@Before
-	public void beforeTest() throws DataException {
-		Common.useDefaultSettings(); // TestNet3
-		ravencoin = Ravencoin.getInstance();
+	@Override
+	protected String getCoinName() {
+		return "Ravencoin";
 	}

-	@After
-	public void afterTest() {
+	@Override
+	protected String getCoinSymbol() {
+		return "RVN";
+	}
+
+	@Override
+	protected Bitcoiny getCoin() {
+		return Ravencoin.getInstance();
+	}
+
+	@Override
+	protected void resetCoinForTesting() {
 		Ravencoin.resetForTesting();
-		ravencoin = null;
 	}

-	@Test
-	public void testGetMedianBlockTime() throws BlockStoreException, ForeignBlockchainException {
-		long before = System.currentTimeMillis();
-		System.out.println(String.format("Ravencoin median blocktime: %d", ravencoin.getMedianBlockTime()));
-		long afterFirst = System.currentTimeMillis();
+	@Override
+	protected String getDeterministicKey58() {
+		return "xpub661MyMwAqRbcEt3Ge1wNmkagyb1J7yTQu4Kquvy77Ycg2iPoh7Urg8s9Jdwp7YmrqGkDKJpUVjsZXSSsQgmAVUC17ZVQQeoWMzm7vDTt1y7";
+	}

-		System.out.println(String.format("Ravencoin median blocktime: %d", ravencoin.getMedianBlockTime()));
-		long afterSecond = System.currentTimeMillis();
-
-		long firstPeriod = afterFirst - before;
-		long secondPeriod = afterSecond - afterFirst;
-
-		System.out.println(String.format("1st call: %d ms, 2nd call: %d ms", firstPeriod, secondPeriod));
-
-		assertTrue("2nd call should be quicker than 1st", secondPeriod < firstPeriod);
-		assertTrue("2nd call should take less than 5 seconds", secondPeriod < 5000L);
+	@Override
+	protected String getRecipient() {
+		return null;
 	}

 	@Test
 	@Ignore(value = "Doesn't work, to be fixed later")
-	public void testFindHtlcSecret() throws ForeignBlockchainException {
-		// This actually exists on TEST3 but can take a while to fetch
-		String p2shAddress = "2N8WCg52ULCtDSMjkgVTm5mtPdCsUptkHWE";
-
-		byte[] expectedSecret = "This string is exactly 32 bytes!".getBytes();
-		byte[] secret = BitcoinyHTLC.findHtlcSecret(ravencoin, p2shAddress);
-
-		assertNotNull("secret not found", secret);
-		assertTrue("secret incorrect", Arrays.equals(expectedSecret, secret));
-	}
+	public void testFindHtlcSecret() {}

 	@Test
 	@Ignore(value = "No testnet nodes available, so we can't regularly test buildSpend yet")
-	public void testBuildSpend() {
-		String xprv58 = "tprv8ZgxMBicQKsPdahhFSrCdvC1bsWyzHHZfTneTVqUXN6s1wEtZLwAkZXzFP6TYLg2aQMecZLXLre5bTVGajEB55L1HYJcawpdFG66STVAWPJ";
-
-		String recipient = "2N8WCg52ULCtDSMjkgVTm5mtPdCsUptkHWE";
-		long amount = 1000L;
-
-		Transaction transaction = ravencoin.buildSpend(xprv58, recipient, amount);
-		assertNotNull("insufficient funds", transaction);
-
-		// Check spent key caching doesn't affect outcome
-
-		transaction = ravencoin.buildSpend(xprv58, recipient, amount);
-		assertNotNull("insufficient funds", transaction);
-	}
-
-	@Test
-	public void testGetWalletBalance() throws ForeignBlockchainException {
-		String xprv58 = "xpub661MyMwAqRbcEt3Ge1wNmkagyb1J7yTQu4Kquvy77Ycg2iPoh7Urg8s9Jdwp7YmrqGkDKJpUVjsZXSSsQgmAVUC17ZVQQeoWMzm7vDTt1y7";
-
-		Long balance = ravencoin.getWalletBalance(xprv58);
-
-		assertNotNull(balance);
-
-		System.out.println(ravencoin.format(balance));
-
-		// Check spent key caching doesn't affect outcome
-
-		Long repeatBalance = ravencoin.getWalletBalance(xprv58);
-
-		assertNotNull(repeatBalance);
-
-		System.out.println(ravencoin.format(repeatBalance));
-
-		assertEquals(balance, repeatBalance);
-	}
-
-	@Test
-	public void testGetUnusedReceiveAddress() throws ForeignBlockchainException {
-		String xprv58 = "xpub661MyMwAqRbcEt3Ge1wNmkagyb1J7yTQu4Kquvy77Ycg2iPoh7Urg8s9Jdwp7YmrqGkDKJpUVjsZXSSsQgmAVUC17ZVQQeoWMzm7vDTt1y7";
-
-		String address = ravencoin.getUnusedReceiveAddress(xprv58);
-
-		assertNotNull(address);
-
-		System.out.println(address);
-	}
-
+	public void testBuildSpend() {}
 }
--- a/src/test/java/org/qortal/test/crosschain/bitcoinv1/BitcoinACCTv1Tests.java
+++ b/src/test/java/org/qortal/test/crosschain/bitcoinv1/BitcoinACCTv1Tests.java
@@ -2,507 +2,89 @@ package org.qortal.test.crosschain.bitcoinv1;

 import static org.junit.Assert.*;

-import java.time.Instant;
-import java.time.LocalDateTime;
-import java.time.ZoneOffset;
-import java.time.format.DateTimeFormatter;
-import java.time.format.FormatStyle;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Random;
 import java.util.function.Function;

-import org.junit.Before;
 import org.junit.Test;
 import org.qortal.account.Account;
 import org.qortal.account.PrivateKeyAccount;
 import org.qortal.asset.Asset;
-import org.qortal.block.Block;
+import org.qortal.crosschain.ACCT;
 import org.qortal.crosschain.BitcoinACCTv1;
 import org.qortal.crosschain.AcctMode;
 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.transaction.BaseTransactionData;
-import org.qortal.data.transaction.DeployAtTransactionData;
-import org.qortal.data.transaction.MessageTransactionData;
-import org.qortal.data.transaction.TransactionData;
-import org.qortal.group.Group;
 import org.qortal.repository.DataException;
 import org.qortal.repository.Repository;
 import org.qortal.repository.RepositoryManager;
 import org.qortal.test.common.BlockUtils;
 import org.qortal.test.common.Common;
-import org.qortal.test.common.TransactionUtils;
+import org.qortal.test.crosschain.ACCTTests;
 import org.qortal.transaction.DeployAtTransaction;
 import org.qortal.transaction.MessageTransaction;
-import org.qortal.utils.Amounts;

 import com.google.common.hash.HashCode;
-import com.google.common.primitives.Bytes;

-public class BitcoinACCTv1Tests extends Common {
+public class BitcoinACCTv1Tests extends ACCTTests {

-	public static final byte[] secretA = "This string is exactly 32 bytes!".getBytes();
-	public static final byte[] hashOfSecretA = Crypto.hash160(secretA); // daf59884b4d1aec8c1b17102530909ee43c0151a
 	public static final byte[] secretB = "This string is roughly 32 bytes?".getBytes();
 	public static final byte[] hashOfSecretB = Crypto.hash160(secretB); // 31f0dd71decf59bbc8ef0661f4030479255cfa58
 	public static final byte[] bitcoinPublicKeyHash = HashCode.fromString("bb00bb11bb22bb33bb44bb55bb66bb77bb88bb99").asBytes();
-	public static final int tradeTimeout = 20; // blocks
-	public static final long redeemAmount = 80_40200000L;
-	public static final long fundingAmount = 123_45600000L;
-	public static final long bitcoinAmount = 864200L; // 0.00864200 BTC

-	private static final Random RANDOM = new Random();
+	private static final String SYMBOL = "BTC";

-	@Before
-	public void beforeTest() throws DataException {
-		Common.useDefaultSettings();
+	private static final String NAME = "Bitcoin";
+
+	@Override
+	protected byte[] getPublicKey() {
+		return bitcoinPublicKeyHash;
 	}

-	@Test
-	public void testCompile() {
-		PrivateKeyAccount tradeAccount = createTradeAccount(null);
-
-		byte[] creationBytes = BitcoinACCTv1.buildQortalAT(tradeAccount.getAddress(), bitcoinPublicKeyHash, hashOfSecretB, redeemAmount, bitcoinAmount, tradeTimeout);
-		assertNotNull(creationBytes);
-
-		System.out.println("AT creation bytes: " + HashCode.fromBytes(creationBytes).toString());
+	@Override
+	protected byte[] buildQortalAT(String address, byte[] publicKey, long redeemAmount, long foreignAmount, int tradeTimeout) {
+		return BitcoinACCTv1.buildQortalAT(address,publicKey, hashOfSecretB, redeemAmount, foreignAmount,tradeTimeout);
 	}

-	@Test
-	public void testDeploy() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
+	@Override
+	protected ACCT getInstance() {
+		return BitcoinACCTv1.getInstance();
+	}

-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
+	@Override
+	protected int calcRefundTimeout(long partnersOfferMessageTransactionTimestamp, int lockTimeA) {
+		return BitcoinACCTv1.calcLockTimeB(partnersOfferMessageTransactionTimestamp, lockTimeA);
+	}

-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
+	@Override
+	protected byte[] buildTradeMessage(String address, byte[] publicKey, byte[] hashOfSecretA, int lockTimeA, int refundTimeout) {
+		return BitcoinACCTv1.buildTradeMessage(address, publicKey, hashOfSecretA, lockTimeA, refundTimeout);
+	}

-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
+	@Override
+	protected byte[] buildRedeemMessage(byte[] secretA, String address) {
+		return BitcoinACCTv1.buildRedeemMessage(secretA,secretB,address);
+	}

-			long expectedBalance = deployersInitialBalance - fundingAmount - deployAtTransaction.getTransactionData().getFee();
-			long actualBalance = deployer.getConfirmedBalance(Asset.QORT);
+	@Override
+	protected byte[] getCodeBytesHash() {
+		return BitcoinACCTv1.CODE_BYTES_HASH;
+	}

-			assertEquals("Deployer's post-deployment balance incorrect", expectedBalance, actualBalance);
+	@Override
+	protected String getSymbol() {
+		return SYMBOL;
+	}

-			expectedBalance = fundingAmount;
-			actualBalance = deployAtTransaction.getATAccount().getConfirmedBalance(Asset.QORT);
-
-			assertEquals("AT's post-deployment balance incorrect", expectedBalance, actualBalance);
-
-			expectedBalance = partnersInitialBalance;
-			actualBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Partner's post-deployment balance incorrect", expectedBalance, actualBalance);
-
-			// Test orphaning
-			BlockUtils.orphanLastBlock(repository);
-
-			expectedBalance = deployersInitialBalance;
-			actualBalance = deployer.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Deployer's post-orphan/pre-deployment balance incorrect", expectedBalance, actualBalance);
-
-			expectedBalance = 0;
-			actualBalance = deployAtTransaction.getATAccount().getConfirmedBalance(Asset.QORT);
-
-			assertEquals("AT's post-orphan/pre-deployment balance incorrect", expectedBalance, actualBalance);
-
-			expectedBalance = partnersInitialBalance;
-			actualBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Partner's post-orphan/pre-deployment balance incorrect", expectedBalance, actualBalance);
-		}
+	@Override
+	protected String getName() {
+		return NAME;
 	}

 	@SuppressWarnings("unused")
+	@Override
 	@Test
-	public void testOfferCancel() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long deployAtFee = deployAtTransaction.getTransactionData().getFee();
-			long deployersPostDeploymentBalance = deployersInitialBalance - fundingAmount - deployAtFee;
-
-			// Send creator's address to AT, instead of typical partner's address
-			byte[] messageData = BitcoinACCTv1.getInstance().buildCancelMessage(deployer.getAddress());
-			MessageTransaction messageTransaction = sendMessage(repository, deployer, messageData, atAddress);
-			long messageFee = messageTransaction.getTransactionData().getFee();
-
-			// AT should process 'cancel' message in next block
-			BlockUtils.mintBlock(repository);
-
-			describeAt(repository, atAddress);
-
-			// Check AT is finished
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			assertTrue(atData.getIsFinished());
-
-			// AT should be in CANCELLED mode
-			CrossChainTradeData tradeData = BitcoinACCTv1.getInstance().populateTradeData(repository, atData);
-			assertEquals(AcctMode.CANCELLED, tradeData.mode);
-
-			// Check balances
-			long expectedMinimumBalance = deployersPostDeploymentBalance;
-			long expectedMaximumBalance = deployersInitialBalance - deployAtFee - messageFee;
-
-			long actualBalance = deployer.getConfirmedBalance(Asset.QORT);
-
-			assertTrue(String.format("Deployer's balance %s should be above minimum %s", actualBalance, expectedMinimumBalance), actualBalance > expectedMinimumBalance);
-			assertTrue(String.format("Deployer's balance %s should be below maximum %s", actualBalance, expectedMaximumBalance), actualBalance < expectedMaximumBalance);
-
-			// Test orphaning
-			BlockUtils.orphanLastBlock(repository);
-
-			// Check balances
-			long expectedBalance = deployersPostDeploymentBalance - messageFee;
-			actualBalance = deployer.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Deployer's post-orphan/pre-refund balance incorrect", expectedBalance, actualBalance);
-		}
-	}
-
-	@SuppressWarnings("unused")
-	@Test
-	public void testOfferCancelInvalidLength() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long deployAtFee = deployAtTransaction.getTransactionData().getFee();
-			long deployersPostDeploymentBalance = deployersInitialBalance - fundingAmount - deployAtFee;
-
-			// Instead of sending creator's address to AT, send too-short/invalid message
-			byte[] messageData = new byte[7];
-			RANDOM.nextBytes(messageData);
-			MessageTransaction messageTransaction = sendMessage(repository, deployer, messageData, atAddress);
-			long messageFee = messageTransaction.getTransactionData().getFee();
-
-			// AT should process 'cancel' message in next block
-			// As message is too short, it will be padded to 32bytes but cancel code doesn't care about message content, so should be ok
-			BlockUtils.mintBlock(repository);
-
-			describeAt(repository, atAddress);
-
-			// Check AT is finished
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			assertTrue(atData.getIsFinished());
-
-			// AT should be in CANCELLED mode
-			CrossChainTradeData tradeData = BitcoinACCTv1.getInstance().populateTradeData(repository, atData);
-			assertEquals(AcctMode.CANCELLED, tradeData.mode);
-		}
-	}
-
-	@SuppressWarnings("unused")
-	@Test
-	public void testTradingInfoProcessing() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long partnersOfferMessageTransactionTimestamp = System.currentTimeMillis();
-			int lockTimeA = calcTestLockTimeA(partnersOfferMessageTransactionTimestamp);
-			int lockTimeB = BitcoinACCTv1.calcLockTimeB(partnersOfferMessageTransactionTimestamp, lockTimeA);
-
-			// Send trade info to AT
-			byte[] messageData = BitcoinACCTv1.buildTradeMessage(partner.getAddress(), bitcoinPublicKeyHash, hashOfSecretA, lockTimeA, lockTimeB);
-			MessageTransaction messageTransaction = sendMessage(repository, tradeAccount, messageData, atAddress);
-
-			Block postDeploymentBlock = BlockUtils.mintBlock(repository);
-			int postDeploymentBlockHeight = postDeploymentBlock.getBlockData().getHeight();
-
-			long deployAtFee = deployAtTransaction.getTransactionData().getFee();
-			long deployersPostDeploymentBalance = deployersInitialBalance - fundingAmount - deployAtFee;
-
-			describeAt(repository, atAddress);
-
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			CrossChainTradeData tradeData = BitcoinACCTv1.getInstance().populateTradeData(repository, atData);
-
-			// AT should be in TRADE mode
-			assertEquals(AcctMode.TRADING, tradeData.mode);
-
-			// Check hashOfSecretA was extracted correctly
-			assertTrue(Arrays.equals(hashOfSecretA, tradeData.hashOfSecretA));
-
-			// Check trade partner Qortal address was extracted correctly
-			assertEquals(partner.getAddress(), tradeData.qortalPartnerAddress);
-
-			// Check trade partner's Bitcoin PKH was extracted correctly
-			assertTrue(Arrays.equals(bitcoinPublicKeyHash, tradeData.partnerForeignPKH));
-
-			// Test orphaning
-			BlockUtils.orphanToBlock(repository, postDeploymentBlockHeight);
-
-			// Check balances
-			long expectedBalance = deployersPostDeploymentBalance;
-			long actualBalance = deployer.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Deployer's post-orphan/pre-refund balance incorrect", expectedBalance, actualBalance);
-		}
-	}
-
-	// TEST SENDING TRADING INFO BUT NOT FROM AT CREATOR (SHOULD BE IGNORED)
-	@SuppressWarnings("unused")
-	@Test
-	public void testIncorrectTradeSender() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			PrivateKeyAccount bystander = Common.getTestAccount(repository, "bob");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long partnersOfferMessageTransactionTimestamp = System.currentTimeMillis();
-			int lockTimeA = calcTestLockTimeA(partnersOfferMessageTransactionTimestamp);
-			int lockTimeB = BitcoinACCTv1.calcLockTimeB(partnersOfferMessageTransactionTimestamp, lockTimeA);
-
-			// Send trade info to AT BUT NOT FROM AT CREATOR
-			byte[] messageData = BitcoinACCTv1.buildTradeMessage(partner.getAddress(), bitcoinPublicKeyHash, hashOfSecretA, lockTimeA, lockTimeB);
-			MessageTransaction messageTransaction = sendMessage(repository, bystander, messageData, atAddress);
-
-			BlockUtils.mintBlock(repository);
-
-			long expectedBalance = partnersInitialBalance;
-			long actualBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Partner's post-initial-payout balance incorrect", expectedBalance, actualBalance);
-
-			describeAt(repository, atAddress);
-
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			CrossChainTradeData tradeData = BitcoinACCTv1.getInstance().populateTradeData(repository, atData);
-
-			// AT should still be in OFFER mode
-			assertEquals(AcctMode.OFFERING, tradeData.mode);
-		}
-	}
-
-	@SuppressWarnings("unused")
-	@Test
-	public void testAutomaticTradeRefund() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long partnersOfferMessageTransactionTimestamp = System.currentTimeMillis();
-			int lockTimeA = calcTestLockTimeA(partnersOfferMessageTransactionTimestamp);
-			int lockTimeB = BitcoinACCTv1.calcLockTimeB(partnersOfferMessageTransactionTimestamp, lockTimeA);
-
-			// Send trade info to AT
-			byte[] messageData = BitcoinACCTv1.buildTradeMessage(partner.getAddress(), bitcoinPublicKeyHash, hashOfSecretA, lockTimeA, lockTimeB);
-			MessageTransaction messageTransaction = sendMessage(repository, tradeAccount, messageData, atAddress);
-
-			Block postDeploymentBlock = BlockUtils.mintBlock(repository);
-			int postDeploymentBlockHeight = postDeploymentBlock.getBlockData().getHeight();
-
-			// Check refund
-			long deployAtFee = deployAtTransaction.getTransactionData().getFee();
-			long deployersPostDeploymentBalance = deployersInitialBalance - fundingAmount - deployAtFee;
-
-			checkTradeRefund(repository, deployer, deployersInitialBalance, deployAtFee);
-
-			describeAt(repository, atAddress);
-
-			// Check AT is finished
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			assertTrue(atData.getIsFinished());
-
-			// AT should be in REFUNDED mode
-			CrossChainTradeData tradeData = BitcoinACCTv1.getInstance().populateTradeData(repository, atData);
-			assertEquals(AcctMode.REFUNDED, tradeData.mode);
-
-			// Test orphaning
-			BlockUtils.orphanToBlock(repository, postDeploymentBlockHeight);
-
-			// Check balances
-			long expectedBalance = deployersPostDeploymentBalance;
-			long actualBalance = deployer.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Deployer's post-orphan/pre-refund balance incorrect", expectedBalance, actualBalance);
-		}
-	}
-
-	@SuppressWarnings("unused")
-	@Test
-	public void testCorrectSecretsCorrectSender() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long partnersOfferMessageTransactionTimestamp = System.currentTimeMillis();
-			int lockTimeA = calcTestLockTimeA(partnersOfferMessageTransactionTimestamp);
-			int lockTimeB = BitcoinACCTv1.calcLockTimeB(partnersOfferMessageTransactionTimestamp, lockTimeA);
-
-			// Send trade info to AT
-			byte[] messageData = BitcoinACCTv1.buildTradeMessage(partner.getAddress(), bitcoinPublicKeyHash, hashOfSecretA, lockTimeA, lockTimeB);
-			MessageTransaction messageTransaction = sendMessage(repository, tradeAccount, messageData, atAddress);
-
-			// Give AT time to process message
-			BlockUtils.mintBlock(repository);
-
-			// Send correct secrets to AT, from correct account
-			messageData = BitcoinACCTv1.buildRedeemMessage(secretA, secretB, partner.getAddress());
-			messageTransaction = sendMessage(repository, partner, messageData, atAddress);
-
-			// AT should send funds in the next block
-			ATStateData preRedeemAtStateData = repository.getATRepository().getLatestATState(atAddress);
-			BlockUtils.mintBlock(repository);
-
-			describeAt(repository, atAddress);
-
-			// Check AT is finished
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			assertTrue(atData.getIsFinished());
-
-			// AT should be in REDEEMED mode
-			CrossChainTradeData tradeData = BitcoinACCTv1.getInstance().populateTradeData(repository, atData);
-			assertEquals(AcctMode.REDEEMED, tradeData.mode);
-
-			// Check balances
-			long expectedBalance = partnersInitialBalance - messageTransaction.getTransactionData().getFee() + redeemAmount;
-			long actualBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Partner's post-redeem balance incorrect", expectedBalance, actualBalance);
-
-			// Orphan redeem
-			BlockUtils.orphanLastBlock(repository);
-
-			// Check balances
-			expectedBalance = partnersInitialBalance - messageTransaction.getTransactionData().getFee();
-			actualBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Partner's post-orphan/pre-redeem balance incorrect", expectedBalance, actualBalance);
-
-			// Check AT state
-			ATStateData postOrphanAtStateData = repository.getATRepository().getLatestATState(atAddress);
-
-			assertTrue("AT states mismatch", Arrays.equals(preRedeemAtStateData.getStateData(), postOrphanAtStateData.getStateData()));
-		}
-	}
-
-	@SuppressWarnings("unused")
-	@Test
-	public void testCorrectSecretsIncorrectSender() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			PrivateKeyAccount bystander = Common.getTestAccount(repository, "bob");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			long deployAtFee = deployAtTransaction.getTransactionData().getFee();
-
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long partnersOfferMessageTransactionTimestamp = System.currentTimeMillis();
-			int lockTimeA = calcTestLockTimeA(partnersOfferMessageTransactionTimestamp);
-			int lockTimeB = BitcoinACCTv1.calcLockTimeB(partnersOfferMessageTransactionTimestamp, lockTimeA);
-
-			// Send trade info to AT
-			byte[] messageData = BitcoinACCTv1.buildTradeMessage(partner.getAddress(), bitcoinPublicKeyHash, hashOfSecretA, lockTimeA, lockTimeB);
-			MessageTransaction messageTransaction = sendMessage(repository, tradeAccount, messageData, atAddress);
-
-			// Give AT time to process message
-			BlockUtils.mintBlock(repository);
-
-			// Send correct secrets to AT, but from wrong account
-			messageData = BitcoinACCTv1.buildRedeemMessage(secretA, secretB, partner.getAddress());
-			messageTransaction = sendMessage(repository, bystander, messageData, atAddress);
-
-			// AT should NOT send funds in the next block
-			ATStateData preRedeemAtStateData = repository.getATRepository().getLatestATState(atAddress);
-			BlockUtils.mintBlock(repository);
-
-			describeAt(repository, atAddress);
-
-			// Check AT is NOT finished
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			assertFalse(atData.getIsFinished());
-
-			// AT should still be in TRADE mode
-			CrossChainTradeData tradeData = BitcoinACCTv1.getInstance().populateTradeData(repository, atData);
-			assertEquals(AcctMode.TRADING, tradeData.mode);
-
-			// Check balances
-			long expectedBalance = partnersInitialBalance;
-			long actualBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Partner's balance incorrect", expectedBalance, actualBalance);
-
-			// Check eventual refund
-			checkTradeRefund(repository, deployer, deployersInitialBalance, deployAtFee);
-		}
-	}
-
-	@SuppressWarnings("unused")
-	@Test
-	public void testIncorrectSecretsCorrectSender() throws DataException {
+	public void testIncorrectSecretCorrectSender() throws DataException {
 		try (final Repository repository = RepositoryManager.getRepository()) {
 			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
 			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
@@ -582,197 +164,8 @@ public class BitcoinACCTv1Tests extends Common {
 		}
 	}

-	@SuppressWarnings("unused")
-	@Test
-	public void testCorrectSecretsCorrectSenderInvalidMessageLength() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long partnersOfferMessageTransactionTimestamp = System.currentTimeMillis();
-			int lockTimeA = calcTestLockTimeA(partnersOfferMessageTransactionTimestamp);
-			int lockTimeB = BitcoinACCTv1.calcLockTimeB(partnersOfferMessageTransactionTimestamp, lockTimeA);
-
-			// Send trade info to AT
-			byte[] messageData = BitcoinACCTv1.buildTradeMessage(partner.getAddress(), bitcoinPublicKeyHash, hashOfSecretA, lockTimeA, lockTimeB);
-			MessageTransaction messageTransaction = sendMessage(repository, tradeAccount, messageData, atAddress);
-
-			// Give AT time to process message
-			BlockUtils.mintBlock(repository);
-
-			// Send correct secrets to AT, from correct account, but missing receive address, hence incorrect length
-			messageData = Bytes.concat(secretA, secretB);
-			messageTransaction = sendMessage(repository, partner, messageData, atAddress);
-
-			// AT should NOT send funds in the next block
-			ATStateData preRedeemAtStateData = repository.getATRepository().getLatestATState(atAddress);
-			BlockUtils.mintBlock(repository);
-
-			describeAt(repository, atAddress);
-
-			// Check AT is NOT finished
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			assertFalse(atData.getIsFinished());
-
-			// AT should be in TRADING mode
-			CrossChainTradeData tradeData = BitcoinACCTv1.getInstance().populateTradeData(repository, atData);
-			assertEquals(AcctMode.TRADING, tradeData.mode);
-		}
-	}
-
-	@SuppressWarnings("unused")
-	@Test
-	public void testDescribeDeployed() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-
-			List<ATData> executableAts = repository.getATRepository().getAllExecutableATs();
-
-			for (ATData atData : executableAts) {
-				String atAddress = atData.getATAddress();
-				byte[] codeBytes = atData.getCodeBytes();
-				byte[] codeHash = Crypto.digest(codeBytes);
-
-				System.out.println(String.format("%s: code length: %d byte%s, code hash: %s",
-						atAddress,
-						codeBytes.length,
-						(codeBytes.length != 1 ? "s": ""),
-						HashCode.fromBytes(codeHash)));
-
-				// Not one of ours?
-				if (!Arrays.equals(codeHash, BitcoinACCTv1.CODE_BYTES_HASH))
-					continue;
-
-				describeAt(repository, atAddress);
-			}
-		}
-	}
-
-	private int calcTestLockTimeA(long messageTimestamp) {
-		return (int) (messageTimestamp / 1000L + tradeTimeout * 60);
-	}
-
-	private DeployAtTransaction doDeploy(Repository repository, PrivateKeyAccount deployer, String tradeAddress) throws DataException {
-		byte[] creationBytes = BitcoinACCTv1.buildQortalAT(tradeAddress, bitcoinPublicKeyHash, hashOfSecretB, redeemAmount, bitcoinAmount, tradeTimeout);
-
-		long txTimestamp = System.currentTimeMillis();
-		byte[] lastReference = deployer.getLastReference();
-
-		if (lastReference == null) {
-			System.err.println(String.format("Qortal account %s has no last reference", deployer.getAddress()));
-			System.exit(2);
-		}
-
-		Long fee = null;
-		String name = "QORT-BTC cross-chain trade";
-		String description = String.format("Qortal-Bitcoin cross-chain trade");
-		String atType = "ACCT";
-		String tags = "QORT-BTC ACCT";
-
-		BaseTransactionData baseTransactionData = new BaseTransactionData(txTimestamp, Group.NO_GROUP, lastReference, deployer.getPublicKey(), fee, null);
-		TransactionData deployAtTransactionData = new DeployAtTransactionData(baseTransactionData, name, description, atType, tags, creationBytes, fundingAmount, Asset.QORT);
-
-		DeployAtTransaction deployAtTransaction = new DeployAtTransaction(repository, deployAtTransactionData);
-
-		fee = deployAtTransaction.calcRecommendedFee();
-		deployAtTransactionData.setFee(fee);
-
-		TransactionUtils.signAndMint(repository, deployAtTransactionData, deployer);
-
-		return deployAtTransaction;
-	}
-
-	private MessageTransaction sendMessage(Repository repository, PrivateKeyAccount sender, byte[] data, String recipient) throws DataException {
-		long txTimestamp = System.currentTimeMillis();
-		byte[] lastReference = sender.getLastReference();
-
-		if (lastReference == null) {
-			System.err.println(String.format("Qortal account %s has no last reference", sender.getAddress()));
-			System.exit(2);
-		}
-
-		Long fee = null;
-		int version = 4;
-		int nonce = 0;
-		long amount = 0;
-		Long assetId = null; // because amount is zero
-
-		BaseTransactionData baseTransactionData = new BaseTransactionData(txTimestamp, Group.NO_GROUP, lastReference, sender.getPublicKey(), fee, null);
-		TransactionData messageTransactionData = new MessageTransactionData(baseTransactionData, version, nonce, recipient, amount, assetId, data, false, false);
-
-		MessageTransaction messageTransaction = new MessageTransaction(repository, messageTransactionData);
-
-		fee = messageTransaction.calcRecommendedFee();
-		messageTransactionData.setFee(fee);
-
-		TransactionUtils.signAndMint(repository, messageTransactionData, sender);
-
-		return messageTransaction;
-	}
-
-	private void checkTradeRefund(Repository repository, Account deployer, long deployersInitialBalance, long deployAtFee) throws DataException {
-		long deployersPostDeploymentBalance = deployersInitialBalance - fundingAmount - deployAtFee;
-		int refundTimeout = tradeTimeout * 3 / 4 + 1; // close enough
-
-		// AT should automatically refund deployer after 'refundTimeout' blocks
-		for (int blockCount = 0; blockCount <= refundTimeout; ++blockCount)
-			BlockUtils.mintBlock(repository);
-
-		// We don't bother to exactly calculate QORT spent running AT for several blocks, but we do know the expected range
-		long expectedMinimumBalance = deployersPostDeploymentBalance;
-		long expectedMaximumBalance = deployersInitialBalance - deployAtFee;
-
-		long actualBalance = deployer.getConfirmedBalance(Asset.QORT);
-
-		assertTrue(String.format("Deployer's balance %s should be above minimum %s", actualBalance, expectedMinimumBalance), actualBalance > expectedMinimumBalance);
-		assertTrue(String.format("Deployer's balance %s should be below maximum %s", actualBalance, expectedMaximumBalance), actualBalance < expectedMaximumBalance);
-	}
-
-	private void describeAt(Repository repository, String atAddress) throws DataException {
-		ATData atData = repository.getATRepository().fromATAddress(atAddress);
-		CrossChainTradeData tradeData = BitcoinACCTv1.getInstance().populateTradeData(repository, atData);
-
-		Function<Long, String> epochMilliFormatter = (timestamp) -> LocalDateTime.ofInstant(Instant.ofEpochMilli(timestamp), ZoneOffset.UTC).format(DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM));
-		int currentBlockHeight = repository.getBlockRepository().getBlockchainHeight();
-
-		System.out.print(String.format("%s:\n"
-				+ "\tmode: %s\n"
-				+ "\tcreator: %s,\n"
-				+ "\tcreation timestamp: %s,\n"
-				+ "\tcurrent balance: %s QORT,\n"
-				+ "\tis finished: %b,\n"
-				+ "\tHASH160 of secret-B: %s,\n"
-				+ "\tredeem payout: %s QORT,\n"
-				+ "\texpected bitcoin: %s BTC,\n"
-				+ "\tcurrent block height: %d,\n",
-				tradeData.qortalAtAddress,
-				tradeData.mode,
-				tradeData.qortalCreator,
-				epochMilliFormatter.apply(tradeData.creationTimestamp),
-				Amounts.prettyAmount(tradeData.qortBalance),
-				atData.getIsFinished(),
-				HashCode.fromBytes(tradeData.hashOfSecretB).toString().substring(0, 40),
-				Amounts.prettyAmount(tradeData.qortAmount),
-				Amounts.prettyAmount(tradeData.expectedForeignAmount),
-				currentBlockHeight));
-
+	@Override
+	protected void describeRefundAt(CrossChainTradeData tradeData, Function<Long, String> epochMilliFormatter) {
 		if (tradeData.mode != AcctMode.OFFERING && tradeData.mode != AcctMode.CANCELLED) {
 			System.out.println(String.format("\trefund height: block %d,\n"
 					+ "\tHASH160 of secret-A: %s,\n"
@@ -786,10 +179,4 @@ public class BitcoinACCTv1Tests extends Common {
 					tradeData.qortalPartnerAddress));
 		}
 	}
-
-	private PrivateKeyAccount createTradeAccount(Repository repository) {
-		// We actually use a known test account with funds to avoid PoW compute
-		return Common.getTestAccount(repository, "alice");
-	}
-
 }
--- a/src/test/java/org/qortal/test/crosschain/bitcoinv3/BitcoinACCTv3Tests.java
+++ b/src/test/java/org/qortal/test/crosschain/bitcoinv3/BitcoinACCTv3Tests.java
@@ -1,769 +1,58 @@
 package org.qortal.test.crosschain.bitcoinv3;

 import com.google.common.hash.HashCode;
-import com.google.common.primitives.Bytes;
-import org.junit.Before;
-import org.junit.Test;
-import org.qortal.account.Account;
-import org.qortal.account.PrivateKeyAccount;
-import org.qortal.asset.Asset;
-import org.qortal.block.Block;
-import org.qortal.crosschain.AcctMode;
+import org.qortal.crosschain.ACCT;
 import org.qortal.crosschain.BitcoinACCTv3;
-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.transaction.BaseTransactionData;
-import org.qortal.data.transaction.DeployAtTransactionData;
-import org.qortal.data.transaction.MessageTransactionData;
-import org.qortal.data.transaction.TransactionData;
-import org.qortal.group.Group;
-import org.qortal.repository.DataException;
-import org.qortal.repository.Repository;
-import org.qortal.repository.RepositoryManager;
-import org.qortal.test.common.BlockUtils;
-import org.qortal.test.common.Common;
-import org.qortal.test.common.TransactionUtils;
-import org.qortal.transaction.DeployAtTransaction;
-import org.qortal.transaction.MessageTransaction;
-import org.qortal.utils.Amounts;
+import org.qortal.test.crosschain.ACCTTests;

-import java.time.Instant;
-import java.time.LocalDateTime;
-import java.time.ZoneOffset;
-import java.time.format.DateTimeFormatter;
-import java.time.format.FormatStyle;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Random;
-import java.util.function.Function;
+public class BitcoinACCTv3Tests extends ACCTTests {

-import static org.junit.Assert.*;
-
-public class BitcoinACCTv3Tests extends Common {
-
-	public static final byte[] secretA = "This string is exactly 32 bytes!".getBytes();
-	public static final byte[] hashOfSecretA = Crypto.hash160(secretA); // daf59884b4d1aec8c1b17102530909ee43c0151a
 	public static final byte[] bitcoinPublicKeyHash = HashCode.fromString("bb00bb11bb22bb33bb44bb55bb66bb77bb88bb99").asBytes();
-	public static final int tradeTimeout = 20; // blocks
-	public static final long redeemAmount = 80_40200000L;
-	public static final long fundingAmount = 123_45600000L;
-	public static final long bitcoinAmount = 864200L; // 0.00864200 BTC
+	private static final String SYMBOL = "BTC";
+	private static final String NAME = "Bitcoin";

-	private static final Random RANDOM = new Random();
-
-	@Before
-	public void beforeTest() throws DataException {
-		Common.useDefaultSettings();
+	@Override
+	protected byte[] getPublicKey() {
+		return bitcoinPublicKeyHash;
 	}

-	@Test
-	public void testCompile() {
-		PrivateKeyAccount tradeAccount = createTradeAccount(null);
-
-		byte[] creationBytes = BitcoinACCTv3.buildQortalAT(tradeAccount.getAddress(), bitcoinPublicKeyHash, redeemAmount, bitcoinAmount, tradeTimeout);
-		assertNotNull(creationBytes);
-
-		System.out.println("AT creation bytes: " + HashCode.fromBytes(creationBytes).toString());
+	@Override
+	protected byte[] buildQortalAT(String address, byte[] publicKey, long redeemAmount, long foreignAmount, int tradeTimeout) {
+		return BitcoinACCTv3.buildQortalAT(address, publicKey, redeemAmount, foreignAmount, tradeTimeout);
 	}

-	@Test
-	public void testDeploy() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-
-			long expectedBalance = deployersInitialBalance - fundingAmount - deployAtTransaction.getTransactionData().getFee();
-			long actualBalance = deployer.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Deployer's post-deployment balance incorrect", expectedBalance, actualBalance);
-
-			expectedBalance = fundingAmount;
-			actualBalance = deployAtTransaction.getATAccount().getConfirmedBalance(Asset.QORT);
-
-			assertEquals("AT's post-deployment balance incorrect", expectedBalance, actualBalance);
-
-			expectedBalance = partnersInitialBalance;
-			actualBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Partner's post-deployment balance incorrect", expectedBalance, actualBalance);
-
-			// Test orphaning
-			BlockUtils.orphanLastBlock(repository);
-
-			expectedBalance = deployersInitialBalance;
-			actualBalance = deployer.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Deployer's post-orphan/pre-deployment balance incorrect", expectedBalance, actualBalance);
-
-			expectedBalance = 0;
-			actualBalance = deployAtTransaction.getATAccount().getConfirmedBalance(Asset.QORT);
-
-			assertEquals("AT's post-orphan/pre-deployment balance incorrect", expectedBalance, actualBalance);
-
-			expectedBalance = partnersInitialBalance;
-			actualBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Partner's post-orphan/pre-deployment balance incorrect", expectedBalance, actualBalance);
-		}
+	@Override
+	protected ACCT getInstance() {
+		return BitcoinACCTv3.getInstance();
 	}

-	@SuppressWarnings("unused")
-	@Test
-	public void testOfferCancel() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long deployAtFee = deployAtTransaction.getTransactionData().getFee();
-			long deployersPostDeploymentBalance = deployersInitialBalance - fundingAmount - deployAtFee;
-
-			// Send creator's address to AT, instead of typical partner's address
-			byte[] messageData = BitcoinACCTv3.getInstance().buildCancelMessage(deployer.getAddress());
-			MessageTransaction messageTransaction = sendMessage(repository, deployer, messageData, atAddress);
-			long messageFee = messageTransaction.getTransactionData().getFee();
-
-			// AT should process 'cancel' message in next block
-			BlockUtils.mintBlock(repository);
-
-			describeAt(repository, atAddress);
-
-			// Check AT is finished
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			assertTrue(atData.getIsFinished());
-
-			// AT should be in CANCELLED mode
-			CrossChainTradeData tradeData = BitcoinACCTv3.getInstance().populateTradeData(repository, atData);
-			assertEquals(AcctMode.CANCELLED, tradeData.mode);
-
-			// Check balances
-			long expectedMinimumBalance = deployersPostDeploymentBalance;
-			long expectedMaximumBalance = deployersInitialBalance - deployAtFee - messageFee;
-
-			long actualBalance = deployer.getConfirmedBalance(Asset.QORT);
-
-			assertTrue(String.format("Deployer's balance %s should be above minimum %s", actualBalance, expectedMinimumBalance), actualBalance > expectedMinimumBalance);
-			assertTrue(String.format("Deployer's balance %s should be below maximum %s", actualBalance, expectedMaximumBalance), actualBalance < expectedMaximumBalance);
-
-			// Test orphaning
-			BlockUtils.orphanLastBlock(repository);
-
-			// Check balances
-			long expectedBalance = deployersPostDeploymentBalance - messageFee;
-			actualBalance = deployer.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Deployer's post-orphan/pre-refund balance incorrect", expectedBalance, actualBalance);
-		}
+	@Override
+	protected int calcRefundTimeout(long partnersOfferMessageTransactionTimestamp, int lockTimeA) {
+		return BitcoinACCTv3.calcRefundTimeout(partnersOfferMessageTransactionTimestamp, lockTimeA);
 	}

-	@SuppressWarnings("unused")
-	@Test
-	public void testOfferCancelInvalidLength() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long deployAtFee = deployAtTransaction.getTransactionData().getFee();
-			long deployersPostDeploymentBalance = deployersInitialBalance - fundingAmount - deployAtFee;
-
-			// Instead of sending creator's address to AT, send too-short/invalid message
-			byte[] messageData = new byte[7];
-			RANDOM.nextBytes(messageData);
-			MessageTransaction messageTransaction = sendMessage(repository, deployer, messageData, atAddress);
-			long messageFee = messageTransaction.getTransactionData().getFee();
-
-			// AT should process 'cancel' message in next block
-			// As message is too short, it will be padded to 32bytes but cancel code doesn't care about message content, so should be ok
-			BlockUtils.mintBlock(repository);
-
-			describeAt(repository, atAddress);
-
-			// Check AT is finished
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			assertTrue(atData.getIsFinished());
-
-			// AT should be in CANCELLED mode
-			CrossChainTradeData tradeData = BitcoinACCTv3.getInstance().populateTradeData(repository, atData);
-			assertEquals(AcctMode.CANCELLED, tradeData.mode);
-		}
+	@Override
+	protected byte[] buildTradeMessage(String address, byte[] publicKey, byte[] hashOfSecretA, int lockTimeA, int refundTimeout) {
+		return BitcoinACCTv3.buildTradeMessage(address, publicKey, hashOfSecretA, lockTimeA, refundTimeout);
 	}

-	@SuppressWarnings("unused")
-	@Test
-	public void testTradingInfoProcessing() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long partnersOfferMessageTransactionTimestamp = System.currentTimeMillis();
-			int lockTimeA = calcTestLockTimeA(partnersOfferMessageTransactionTimestamp);
-			int refundTimeout = BitcoinACCTv3.calcRefundTimeout(partnersOfferMessageTransactionTimestamp, lockTimeA);
-
-			// Send trade info to AT
-			byte[] messageData = BitcoinACCTv3.buildTradeMessage(partner.getAddress(), bitcoinPublicKeyHash, hashOfSecretA, lockTimeA, refundTimeout);
-			MessageTransaction messageTransaction = sendMessage(repository, tradeAccount, messageData, atAddress);
-
-			Block postDeploymentBlock = BlockUtils.mintBlock(repository);
-			int postDeploymentBlockHeight = postDeploymentBlock.getBlockData().getHeight();
-
-			long deployAtFee = deployAtTransaction.getTransactionData().getFee();
-			long deployersPostDeploymentBalance = deployersInitialBalance - fundingAmount - deployAtFee;
-
-			describeAt(repository, atAddress);
-
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			CrossChainTradeData tradeData = BitcoinACCTv3.getInstance().populateTradeData(repository, atData);
-
-			// AT should be in TRADE mode
-			assertEquals(AcctMode.TRADING, tradeData.mode);
-
-			// Check hashOfSecretA was extracted correctly
-			assertTrue(Arrays.equals(hashOfSecretA, tradeData.hashOfSecretA));
-
-			// Check trade partner Qortal address was extracted correctly
-			assertEquals(partner.getAddress(), tradeData.qortalPartnerAddress);
-
-			// Check trade partner's Bitcoin PKH was extracted correctly
-			assertTrue(Arrays.equals(bitcoinPublicKeyHash, tradeData.partnerForeignPKH));
-
-			// Test orphaning
-			BlockUtils.orphanToBlock(repository, postDeploymentBlockHeight);
-
-			// Check balances
-			long expectedBalance = deployersPostDeploymentBalance;
-			long actualBalance = deployer.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Deployer's post-orphan/pre-refund balance incorrect", expectedBalance, actualBalance);
-		}
+	@Override
+	protected byte[] buildRedeemMessage(byte[] secretA, String address) {
+		return BitcoinACCTv3.buildRedeemMessage(secretA, address);
 	}

-	// TEST SENDING TRADING INFO BUT NOT FROM AT CREATOR (SHOULD BE IGNORED)
-	@SuppressWarnings("unused")
-	@Test
-	public void testIncorrectTradeSender() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			PrivateKeyAccount bystander = Common.getTestAccount(repository, "bob");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long partnersOfferMessageTransactionTimestamp = System.currentTimeMillis();
-			int lockTimeA = calcTestLockTimeA(partnersOfferMessageTransactionTimestamp);
-			int refundTimeout = BitcoinACCTv3.calcRefundTimeout(partnersOfferMessageTransactionTimestamp, lockTimeA);
-
-			// Send trade info to AT BUT NOT FROM AT CREATOR
-			byte[] messageData = BitcoinACCTv3.buildTradeMessage(partner.getAddress(), bitcoinPublicKeyHash, hashOfSecretA, lockTimeA, refundTimeout);
-			MessageTransaction messageTransaction = sendMessage(repository, bystander, messageData, atAddress);
-
-			BlockUtils.mintBlock(repository);
-
-			long expectedBalance = partnersInitialBalance;
-			long actualBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Partner's post-initial-payout balance incorrect", expectedBalance, actualBalance);
-
-			describeAt(repository, atAddress);
-
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			CrossChainTradeData tradeData = BitcoinACCTv3.getInstance().populateTradeData(repository, atData);
-
-			// AT should still be in OFFER mode
-			assertEquals(AcctMode.OFFERING, tradeData.mode);
-		}
+	@Override
+	protected byte[] getCodeBytesHash() {
+		return BitcoinACCTv3.CODE_BYTES_HASH;
 	}

-	@SuppressWarnings("unused")
-	@Test
-	public void testAutomaticTradeRefund() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long partnersOfferMessageTransactionTimestamp = System.currentTimeMillis();
-			int lockTimeA = calcTestLockTimeA(partnersOfferMessageTransactionTimestamp);
-			int refundTimeout = BitcoinACCTv3.calcRefundTimeout(partnersOfferMessageTransactionTimestamp, lockTimeA);
-
-			// Send trade info to AT
-			byte[] messageData = BitcoinACCTv3.buildTradeMessage(partner.getAddress(), bitcoinPublicKeyHash, hashOfSecretA, lockTimeA, refundTimeout);
-			MessageTransaction messageTransaction = sendMessage(repository, tradeAccount, messageData, atAddress);
-
-			Block postDeploymentBlock = BlockUtils.mintBlock(repository);
-			int postDeploymentBlockHeight = postDeploymentBlock.getBlockData().getHeight();
-
-			// Check refund
-			long deployAtFee = deployAtTransaction.getTransactionData().getFee();
-			long deployersPostDeploymentBalance = deployersInitialBalance - fundingAmount - deployAtFee;
-
-			checkTradeRefund(repository, deployer, deployersInitialBalance, deployAtFee);
-
-			describeAt(repository, atAddress);
-
-			// Check AT is finished
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			assertTrue(atData.getIsFinished());
-
-			// AT should be in REFUNDED mode
-			CrossChainTradeData tradeData = BitcoinACCTv3.getInstance().populateTradeData(repository, atData);
-			assertEquals(AcctMode.REFUNDED, tradeData.mode);
-
-			// Test orphaning
-			BlockUtils.orphanToBlock(repository, postDeploymentBlockHeight);
-
-			// Check balances
-			long expectedBalance = deployersPostDeploymentBalance;
-			long actualBalance = deployer.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Deployer's post-orphan/pre-refund balance incorrect", expectedBalance, actualBalance);
-		}
+	@Override
+	protected String getSymbol() {
+		return SYMBOL;
 	}

-	@SuppressWarnings("unused")
-	@Test
-	public void testCorrectSecretCorrectSender() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long partnersOfferMessageTransactionTimestamp = System.currentTimeMillis();
-			int lockTimeA = calcTestLockTimeA(partnersOfferMessageTransactionTimestamp);
-			int refundTimeout = BitcoinACCTv3.calcRefundTimeout(partnersOfferMessageTransactionTimestamp, lockTimeA);
-
-			// Send trade info to AT
-			byte[] messageData = BitcoinACCTv3.buildTradeMessage(partner.getAddress(), bitcoinPublicKeyHash, hashOfSecretA, lockTimeA, refundTimeout);
-			MessageTransaction messageTransaction = sendMessage(repository, tradeAccount, messageData, atAddress);
-
-			// Give AT time to process message
-			BlockUtils.mintBlock(repository);
-
-			// Send correct secret to AT, from correct account
-			messageData = BitcoinACCTv3.buildRedeemMessage(secretA,  partner.getAddress());
-			messageTransaction = sendMessage(repository, partner, messageData, atAddress);
-
-			// AT should send funds in the next block
-			ATStateData preRedeemAtStateData = repository.getATRepository().getLatestATState(atAddress);
-			BlockUtils.mintBlock(repository);
-
-			describeAt(repository, atAddress);
-
-			// Check AT is finished
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			assertTrue(atData.getIsFinished());
-
-			// AT should be in REDEEMED mode
-			CrossChainTradeData tradeData = BitcoinACCTv3.getInstance().populateTradeData(repository, atData);
-			assertEquals(AcctMode.REDEEMED, tradeData.mode);
-
-			// Check balances
-			long expectedBalance = partnersInitialBalance - messageTransaction.getTransactionData().getFee() + redeemAmount;
-			long actualBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Partner's post-redeem balance incorrect", expectedBalance, actualBalance);
-
-			// Orphan redeem
-			BlockUtils.orphanLastBlock(repository);
-
-			// Check balances
-			expectedBalance = partnersInitialBalance - messageTransaction.getTransactionData().getFee();
-			actualBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Partner's post-orphan/pre-redeem balance incorrect", expectedBalance, actualBalance);
-
-			// Check AT state
-			ATStateData postOrphanAtStateData = repository.getATRepository().getLatestATState(atAddress);
-
-			assertTrue("AT states mismatch", Arrays.equals(preRedeemAtStateData.getStateData(), postOrphanAtStateData.getStateData()));
-		}
+	@Override
+	protected String getName() {
+		return NAME;
 	}
-
-	@SuppressWarnings("unused")
-	@Test
-	public void testCorrectSecretIncorrectSender() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			PrivateKeyAccount bystander = Common.getTestAccount(repository, "bob");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			long deployAtFee = deployAtTransaction.getTransactionData().getFee();
-
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long partnersOfferMessageTransactionTimestamp = System.currentTimeMillis();
-			int lockTimeA = calcTestLockTimeA(partnersOfferMessageTransactionTimestamp);
-			int refundTimeout = BitcoinACCTv3.calcRefundTimeout(partnersOfferMessageTransactionTimestamp, lockTimeA);
-
-			// Send trade info to AT
-			byte[] messageData = BitcoinACCTv3.buildTradeMessage(partner.getAddress(), bitcoinPublicKeyHash, hashOfSecretA, lockTimeA, refundTimeout);
-			MessageTransaction messageTransaction = sendMessage(repository, tradeAccount, messageData, atAddress);
-
-			// Give AT time to process message
-			BlockUtils.mintBlock(repository);
-
-			// Send correct secret to AT, but from wrong account
-			messageData = BitcoinACCTv3.buildRedeemMessage(secretA, partner.getAddress());
-			messageTransaction = sendMessage(repository, bystander, messageData, atAddress);
-
-			// AT should NOT send funds in the next block
-			ATStateData preRedeemAtStateData = repository.getATRepository().getLatestATState(atAddress);
-			BlockUtils.mintBlock(repository);
-
-			describeAt(repository, atAddress);
-
-			// Check AT is NOT finished
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			assertFalse(atData.getIsFinished());
-
-			// AT should still be in TRADE mode
-			CrossChainTradeData tradeData = BitcoinACCTv3.getInstance().populateTradeData(repository, atData);
-			assertEquals(AcctMode.TRADING, tradeData.mode);
-
-			// Check balances
-			long expectedBalance = partnersInitialBalance;
-			long actualBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Partner's balance incorrect", expectedBalance, actualBalance);
-
-			// Check eventual refund
-			checkTradeRefund(repository, deployer, deployersInitialBalance, deployAtFee);
-		}
-	}
-
-	@SuppressWarnings("unused")
-	@Test
-	public void testIncorrectSecretCorrectSender() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			long deployAtFee = deployAtTransaction.getTransactionData().getFee();
-
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long partnersOfferMessageTransactionTimestamp = System.currentTimeMillis();
-			int lockTimeA = calcTestLockTimeA(partnersOfferMessageTransactionTimestamp);
-			int refundTimeout = BitcoinACCTv3.calcRefundTimeout(partnersOfferMessageTransactionTimestamp, lockTimeA);
-
-			// Send trade info to AT
-			byte[] messageData = BitcoinACCTv3.buildTradeMessage(partner.getAddress(), bitcoinPublicKeyHash, hashOfSecretA, lockTimeA, refundTimeout);
-			MessageTransaction messageTransaction = sendMessage(repository, tradeAccount, messageData, atAddress);
-
-			// Give AT time to process message
-			BlockUtils.mintBlock(repository);
-
-			// Send incorrect secret to AT, from correct account
-			byte[] wrongSecret = new byte[32];
-			RANDOM.nextBytes(wrongSecret);
-			messageData = BitcoinACCTv3.buildRedeemMessage(wrongSecret, partner.getAddress());
-			messageTransaction = sendMessage(repository, partner, messageData, atAddress);
-
-			// AT should NOT send funds in the next block
-			ATStateData preRedeemAtStateData = repository.getATRepository().getLatestATState(atAddress);
-			BlockUtils.mintBlock(repository);
-
-			describeAt(repository, atAddress);
-
-			// Check AT is NOT finished
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			assertFalse(atData.getIsFinished());
-
-			// AT should still be in TRADE mode
-			CrossChainTradeData tradeData = BitcoinACCTv3.getInstance().populateTradeData(repository, atData);
-			assertEquals(AcctMode.TRADING, tradeData.mode);
-
-			long expectedBalance = partnersInitialBalance - messageTransaction.getTransactionData().getFee();
-			long actualBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Partner's balance incorrect", expectedBalance, actualBalance);
-
-			// Check eventual refund
-			checkTradeRefund(repository, deployer, deployersInitialBalance, deployAtFee);
-		}
-	}
-
-	@SuppressWarnings("unused")
-	@Test
-	public void testCorrectSecretCorrectSenderInvalidMessageLength() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long partnersOfferMessageTransactionTimestamp = System.currentTimeMillis();
-			int lockTimeA = calcTestLockTimeA(partnersOfferMessageTransactionTimestamp);
-			int refundTimeout = BitcoinACCTv3.calcRefundTimeout(partnersOfferMessageTransactionTimestamp, lockTimeA);
-
-			// Send trade info to AT
-			byte[] messageData = BitcoinACCTv3.buildTradeMessage(partner.getAddress(), bitcoinPublicKeyHash, hashOfSecretA, lockTimeA, refundTimeout);
-			MessageTransaction messageTransaction = sendMessage(repository, tradeAccount, messageData, atAddress);
-
-			// Give AT time to process message
-			BlockUtils.mintBlock(repository);
-
-			// Send correct secret to AT, from correct account, but missing receive address, hence incorrect length
-			messageData = Bytes.concat(secretA);
-			messageTransaction = sendMessage(repository, partner, messageData, atAddress);
-
-			// AT should NOT send funds in the next block
-			ATStateData preRedeemAtStateData = repository.getATRepository().getLatestATState(atAddress);
-			BlockUtils.mintBlock(repository);
-
-			describeAt(repository, atAddress);
-
-			// Check AT is NOT finished
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			assertFalse(atData.getIsFinished());
-
-			// AT should be in TRADING mode
-			CrossChainTradeData tradeData = BitcoinACCTv3.getInstance().populateTradeData(repository, atData);
-			assertEquals(AcctMode.TRADING, tradeData.mode);
-		}
-	}
-
-	@SuppressWarnings("unused")
-	@Test
-	public void testDescribeDeployed() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-
-			List<ATData> executableAts = repository.getATRepository().getAllExecutableATs();
-
-			for (ATData atData : executableAts) {
-				String atAddress = atData.getATAddress();
-				byte[] codeBytes = atData.getCodeBytes();
-				byte[] codeHash = Crypto.digest(codeBytes);
-
-				System.out.println(String.format("%s: code length: %d byte%s, code hash: %s",
-						atAddress,
-						codeBytes.length,
-						(codeBytes.length != 1 ? "s": ""),
-						HashCode.fromBytes(codeHash)));
-
-				// Not one of ours?
-				if (!Arrays.equals(codeHash, BitcoinACCTv3.CODE_BYTES_HASH))
-					continue;
-
-				describeAt(repository, atAddress);
-			}
-		}
-	}
-
-	private int calcTestLockTimeA(long messageTimestamp) {
-		return (int) (messageTimestamp / 1000L + tradeTimeout * 60);
-	}
-
-	private DeployAtTransaction doDeploy(Repository repository, PrivateKeyAccount deployer, String tradeAddress) throws DataException {
-		byte[] creationBytes = BitcoinACCTv3.buildQortalAT(tradeAddress, bitcoinPublicKeyHash, redeemAmount, bitcoinAmount, tradeTimeout);
-
-		long txTimestamp = System.currentTimeMillis();
-		byte[] lastReference = deployer.getLastReference();
-
-		if (lastReference == null) {
-			System.err.println(String.format("Qortal account %s has no last reference", deployer.getAddress()));
-			System.exit(2);
-		}
-
-		Long fee = null;
-		String name = "QORT-BTC cross-chain trade";
-		String description = String.format("Qortal-Bitcoin cross-chain trade");
-		String atType = "ACCT";
-		String tags = "QORT-BTC ACCT";
-
-		BaseTransactionData baseTransactionData = new BaseTransactionData(txTimestamp, Group.NO_GROUP, lastReference, deployer.getPublicKey(), fee, null);
-		TransactionData deployAtTransactionData = new DeployAtTransactionData(baseTransactionData, name, description, atType, tags, creationBytes, fundingAmount, Asset.QORT);
-
-		DeployAtTransaction deployAtTransaction = new DeployAtTransaction(repository, deployAtTransactionData);
-
-		fee = deployAtTransaction.calcRecommendedFee();
-		deployAtTransactionData.setFee(fee);
-
-		TransactionUtils.signAndMint(repository, deployAtTransactionData, deployer);
-
-		return deployAtTransaction;
-	}
-
-	private MessageTransaction sendMessage(Repository repository, PrivateKeyAccount sender, byte[] data, String recipient) throws DataException {
-		long txTimestamp = System.currentTimeMillis();
-		byte[] lastReference = sender.getLastReference();
-
-		if (lastReference == null) {
-			System.err.println(String.format("Qortal account %s has no last reference", sender.getAddress()));
-			System.exit(2);
-		}
-
-		Long fee = null;
-		int version = 4;
-		int nonce = 0;
-		long amount = 0;
-		Long assetId = null; // because amount is zero
-
-		BaseTransactionData baseTransactionData = new BaseTransactionData(txTimestamp, Group.NO_GROUP, lastReference, sender.getPublicKey(), fee, null);
-		TransactionData messageTransactionData = new MessageTransactionData(baseTransactionData, version, nonce, recipient, amount, assetId, data, false, false);
-
-		MessageTransaction messageTransaction = new MessageTransaction(repository, messageTransactionData);
-
-		fee = messageTransaction.calcRecommendedFee();
-		messageTransactionData.setFee(fee);
-
-		TransactionUtils.signAndMint(repository, messageTransactionData, sender);
-
-		return messageTransaction;
-	}
-
-	private void checkTradeRefund(Repository repository, Account deployer, long deployersInitialBalance, long deployAtFee) throws DataException {
-		long deployersPostDeploymentBalance = deployersInitialBalance - fundingAmount - deployAtFee;
-		int refundTimeout = tradeTimeout / 2 + 1; // close enough
-
-		// AT should automatically refund deployer after 'refundTimeout' blocks
-		for (int blockCount = 0; blockCount <= refundTimeout; ++blockCount)
-			BlockUtils.mintBlock(repository);
-
-		// We don't bother to exactly calculate QORT spent running AT for several blocks, but we do know the expected range
-		long expectedMinimumBalance = deployersPostDeploymentBalance;
-		long expectedMaximumBalance = deployersInitialBalance - deployAtFee;
-
-		long actualBalance = deployer.getConfirmedBalance(Asset.QORT);
-
-		assertTrue(String.format("Deployer's balance %s should be above minimum %s", actualBalance, expectedMinimumBalance), actualBalance > expectedMinimumBalance);
-		assertTrue(String.format("Deployer's balance %s should be below maximum %s", actualBalance, expectedMaximumBalance), actualBalance < expectedMaximumBalance);
-	}
-
-	private void describeAt(Repository repository, String atAddress) throws DataException {
-		ATData atData = repository.getATRepository().fromATAddress(atAddress);
-		CrossChainTradeData tradeData = BitcoinACCTv3.getInstance().populateTradeData(repository, atData);
-
-		Function<Long, String> epochMilliFormatter = (timestamp) -> LocalDateTime.ofInstant(Instant.ofEpochMilli(timestamp), ZoneOffset.UTC).format(DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM));
-		int currentBlockHeight = repository.getBlockRepository().getBlockchainHeight();
-
-		System.out.print(String.format("%s:\n"
-				+ "\tmode: %s\n"
-				+ "\tcreator: %s,\n"
-				+ "\tcreation timestamp: %s,\n"
-				+ "\tcurrent balance: %s QORT,\n"
-				+ "\tis finished: %b,\n"
-				+ "\tredeem payout: %s QORT,\n"
-				+ "\texpected Bitcoin: %s BTC,\n"
-				+ "\tcurrent block height: %d,\n",
-				tradeData.qortalAtAddress,
-				tradeData.mode,
-				tradeData.qortalCreator,
-				epochMilliFormatter.apply(tradeData.creationTimestamp),
-				Amounts.prettyAmount(tradeData.qortBalance),
-				atData.getIsFinished(),
-				Amounts.prettyAmount(tradeData.qortAmount),
-				Amounts.prettyAmount(tradeData.expectedForeignAmount),
-				currentBlockHeight));
-
-		if (tradeData.mode != AcctMode.OFFERING && tradeData.mode != AcctMode.CANCELLED) {
-			System.out.println(String.format("\trefund timeout: %d minutes,\n"
-					+ "\trefund height: block %d,\n"
-					+ "\tHASH160 of secret-A: %s,\n"
-					+ "\tBitcoin P2SH-A nLockTime: %d (%s),\n"
-					+ "\ttrade partner: %s\n"
-					+ "\tpartner's receiving address: %s",
-					tradeData.refundTimeout,
-					tradeData.tradeRefundHeight,
-					HashCode.fromBytes(tradeData.hashOfSecretA).toString().substring(0, 40),
-					tradeData.lockTimeA, epochMilliFormatter.apply(tradeData.lockTimeA * 1000L),
-					tradeData.qortalPartnerAddress,
-					tradeData.qortalPartnerReceivingAddress));
-		}
-	}
-
-	private PrivateKeyAccount createTradeAccount(Repository repository) {
-		// We actually use a known test account with funds to avoid PoW compute
-		return Common.getTestAccount(repository, "alice");
-	}
-
 }
--- a/src/test/java/org/qortal/test/crosschain/digibytev3/DigibyteACCTv3Tests.java
+++ b/src/test/java/org/qortal/test/crosschain/digibytev3/DigibyteACCTv3Tests.java
@@ -1,769 +1,58 @@
 package org.qortal.test.crosschain.digibytev3;

 import com.google.common.hash.HashCode;
-import com.google.common.primitives.Bytes;
-import org.junit.Before;
-import org.junit.Test;
-import org.qortal.account.Account;
-import org.qortal.account.PrivateKeyAccount;
-import org.qortal.asset.Asset;
-import org.qortal.block.Block;
-import org.qortal.crosschain.AcctMode;
+import org.qortal.crosschain.ACCT;
 import org.qortal.crosschain.DigibyteACCTv3;
-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.transaction.BaseTransactionData;
-import org.qortal.data.transaction.DeployAtTransactionData;
-import org.qortal.data.transaction.MessageTransactionData;
-import org.qortal.data.transaction.TransactionData;
-import org.qortal.group.Group;
-import org.qortal.repository.DataException;
-import org.qortal.repository.Repository;
-import org.qortal.repository.RepositoryManager;
-import org.qortal.test.common.BlockUtils;
-import org.qortal.test.common.Common;
-import org.qortal.test.common.TransactionUtils;
-import org.qortal.transaction.DeployAtTransaction;
-import org.qortal.transaction.MessageTransaction;
-import org.qortal.utils.Amounts;
+import org.qortal.test.crosschain.ACCTTests;

-import java.time.Instant;
-import java.time.LocalDateTime;
-import java.time.ZoneOffset;
-import java.time.format.DateTimeFormatter;
-import java.time.format.FormatStyle;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Random;
-import java.util.function.Function;
+public class DigibyteACCTv3Tests extends ACCTTests {

-import static org.junit.Assert.*;
-
-public class DigibyteACCTv3Tests extends Common {
-
-	public static final byte[] secretA = "This string is exactly 32 bytes!".getBytes();
-	public static final byte[] hashOfSecretA = Crypto.hash160(secretA); // daf59884b4d1aec8c1b17102530909ee43c0151a
 	public static final byte[] digibytePublicKeyHash = HashCode.fromString("bb00bb11bb22bb33bb44bb55bb66bb77bb88bb99").asBytes();
-	public static final int tradeTimeout = 20; // blocks
-	public static final long redeemAmount = 80_40200000L;
-	public static final long fundingAmount = 123_45600000L;
-	public static final long digibyteAmount = 864200L; // 0.00864200 DGB
+	private static final String SYMBOL = "DGB";
+	private static final String NAME = "DigiByte";

-	private static final Random RANDOM = new Random();
-
-	@Before
-	public void beforeTest() throws DataException {
-		Common.useDefaultSettings();
+	@Override
+	protected byte[] getPublicKey() {
+		return digibytePublicKeyHash;
 	}

-	@Test
-	public void testCompile() {
-		PrivateKeyAccount tradeAccount = createTradeAccount(null);
-
-		byte[] creationBytes = DigibyteACCTv3.buildQortalAT(tradeAccount.getAddress(), digibytePublicKeyHash, redeemAmount, digibyteAmount, tradeTimeout);
-		assertNotNull(creationBytes);
-
-		System.out.println("AT creation bytes: " + HashCode.fromBytes(creationBytes).toString());
+	@Override
+	protected byte[] buildQortalAT(String address, byte[] publicKey, long redeemAmount, long foreignAmount, int tradeTimeout) {
+		return DigibyteACCTv3.buildQortalAT(address, publicKey, redeemAmount, foreignAmount, tradeTimeout);
 	}

-	@Test
-	public void testDeploy() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-
-			long expectedBalance = deployersInitialBalance - fundingAmount - deployAtTransaction.getTransactionData().getFee();
-			long actualBalance = deployer.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Deployer's post-deployment balance incorrect", expectedBalance, actualBalance);
-
-			expectedBalance = fundingAmount;
-			actualBalance = deployAtTransaction.getATAccount().getConfirmedBalance(Asset.QORT);
-
-			assertEquals("AT's post-deployment balance incorrect", expectedBalance, actualBalance);
-
-			expectedBalance = partnersInitialBalance;
-			actualBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Partner's post-deployment balance incorrect", expectedBalance, actualBalance);
-
-			// Test orphaning
-			BlockUtils.orphanLastBlock(repository);
-
-			expectedBalance = deployersInitialBalance;
-			actualBalance = deployer.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Deployer's post-orphan/pre-deployment balance incorrect", expectedBalance, actualBalance);
-
-			expectedBalance = 0;
-			actualBalance = deployAtTransaction.getATAccount().getConfirmedBalance(Asset.QORT);
-
-			assertEquals("AT's post-orphan/pre-deployment balance incorrect", expectedBalance, actualBalance);
-
-			expectedBalance = partnersInitialBalance;
-			actualBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Partner's post-orphan/pre-deployment balance incorrect", expectedBalance, actualBalance);
-		}
+	@Override
+	protected ACCT getInstance() {
+		return DigibyteACCTv3.getInstance();
 	}

-	@SuppressWarnings("unused")
-	@Test
-	public void testOfferCancel() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long deployAtFee = deployAtTransaction.getTransactionData().getFee();
-			long deployersPostDeploymentBalance = deployersInitialBalance - fundingAmount - deployAtFee;
-
-			// Send creator's address to AT, instead of typical partner's address
-			byte[] messageData = DigibyteACCTv3.getInstance().buildCancelMessage(deployer.getAddress());
-			MessageTransaction messageTransaction = sendMessage(repository, deployer, messageData, atAddress);
-			long messageFee = messageTransaction.getTransactionData().getFee();
-
-			// AT should process 'cancel' message in next block
-			BlockUtils.mintBlock(repository);
-
-			describeAt(repository, atAddress);
-
-			// Check AT is finished
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			assertTrue(atData.getIsFinished());
-
-			// AT should be in CANCELLED mode
-			CrossChainTradeData tradeData = DigibyteACCTv3.getInstance().populateTradeData(repository, atData);
-			assertEquals(AcctMode.CANCELLED, tradeData.mode);
-
-			// Check balances
-			long expectedMinimumBalance = deployersPostDeploymentBalance;
-			long expectedMaximumBalance = deployersInitialBalance - deployAtFee - messageFee;
-
-			long actualBalance = deployer.getConfirmedBalance(Asset.QORT);
-
-			assertTrue(String.format("Deployer's balance %s should be above minimum %s", actualBalance, expectedMinimumBalance), actualBalance > expectedMinimumBalance);
-			assertTrue(String.format("Deployer's balance %s should be below maximum %s", actualBalance, expectedMaximumBalance), actualBalance < expectedMaximumBalance);
-
-			// Test orphaning
-			BlockUtils.orphanLastBlock(repository);
-
-			// Check balances
-			long expectedBalance = deployersPostDeploymentBalance - messageFee;
-			actualBalance = deployer.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Deployer's post-orphan/pre-refund balance incorrect", expectedBalance, actualBalance);
-		}
+	@Override
+	protected int calcRefundTimeout(long partnersOfferMessageTransactionTimestamp, int lockTimeA) {
+		return DigibyteACCTv3.calcRefundTimeout(partnersOfferMessageTransactionTimestamp, lockTimeA);
 	}

-	@SuppressWarnings("unused")
-	@Test
-	public void testOfferCancelInvalidLength() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long deployAtFee = deployAtTransaction.getTransactionData().getFee();
-			long deployersPostDeploymentBalance = deployersInitialBalance - fundingAmount - deployAtFee;
-
-			// Instead of sending creator's address to AT, send too-short/invalid message
-			byte[] messageData = new byte[7];
-			RANDOM.nextBytes(messageData);
-			MessageTransaction messageTransaction = sendMessage(repository, deployer, messageData, atAddress);
-			long messageFee = messageTransaction.getTransactionData().getFee();
-
-			// AT should process 'cancel' message in next block
-			// As message is too short, it will be padded to 32bytes but cancel code doesn't care about message content, so should be ok
-			BlockUtils.mintBlock(repository);
-
-			describeAt(repository, atAddress);
-
-			// Check AT is finished
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			assertTrue(atData.getIsFinished());
-
-			// AT should be in CANCELLED mode
-			CrossChainTradeData tradeData = DigibyteACCTv3.getInstance().populateTradeData(repository, atData);
-			assertEquals(AcctMode.CANCELLED, tradeData.mode);
-		}
+	@Override
+	protected byte[] buildTradeMessage(String address, byte[] publicKey, byte[] hashOfSecretA, int lockTimeA, int refundTimeout) {
+		return DigibyteACCTv3.buildTradeMessage(address, publicKey, hashOfSecretA, lockTimeA, refundTimeout);
 	}

-	@SuppressWarnings("unused")
-	@Test
-	public void testTradingInfoProcessing() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long partnersOfferMessageTransactionTimestamp = System.currentTimeMillis();
-			int lockTimeA = calcTestLockTimeA(partnersOfferMessageTransactionTimestamp);
-			int refundTimeout = DigibyteACCTv3.calcRefundTimeout(partnersOfferMessageTransactionTimestamp, lockTimeA);
-
-			// Send trade info to AT
-			byte[] messageData = DigibyteACCTv3.buildTradeMessage(partner.getAddress(), digibytePublicKeyHash, hashOfSecretA, lockTimeA, refundTimeout);
-			MessageTransaction messageTransaction = sendMessage(repository, tradeAccount, messageData, atAddress);
-
-			Block postDeploymentBlock = BlockUtils.mintBlock(repository);
-			int postDeploymentBlockHeight = postDeploymentBlock.getBlockData().getHeight();
-
-			long deployAtFee = deployAtTransaction.getTransactionData().getFee();
-			long deployersPostDeploymentBalance = deployersInitialBalance - fundingAmount - deployAtFee;
-
-			describeAt(repository, atAddress);
-
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			CrossChainTradeData tradeData = DigibyteACCTv3.getInstance().populateTradeData(repository, atData);
-
-			// AT should be in TRADE mode
-			assertEquals(AcctMode.TRADING, tradeData.mode);
-
-			// Check hashOfSecretA was extracted correctly
-			assertTrue(Arrays.equals(hashOfSecretA, tradeData.hashOfSecretA));
-
-			// Check trade partner Qortal address was extracted correctly
-			assertEquals(partner.getAddress(), tradeData.qortalPartnerAddress);
-
-			// Check trade partner's digibyte PKH was extracted correctly
-			assertTrue(Arrays.equals(digibytePublicKeyHash, tradeData.partnerForeignPKH));
-
-			// Test orphaning
-			BlockUtils.orphanToBlock(repository, postDeploymentBlockHeight);
-
-			// Check balances
-			long expectedBalance = deployersPostDeploymentBalance;
-			long actualBalance = deployer.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Deployer's post-orphan/pre-refund balance incorrect", expectedBalance, actualBalance);
-		}
+	@Override
+	protected byte[] buildRedeemMessage(byte[] secretA, String address) {
+		return DigibyteACCTv3.buildRedeemMessage(secretA, address);
 	}

-	// TEST SENDING TRADING INFO BUT NOT FROM AT CREATOR (SHOULD BE IGNORED)
-	@SuppressWarnings("unused")
-	@Test
-	public void testIncorrectTradeSender() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			PrivateKeyAccount bystander = Common.getTestAccount(repository, "bob");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long partnersOfferMessageTransactionTimestamp = System.currentTimeMillis();
-			int lockTimeA = calcTestLockTimeA(partnersOfferMessageTransactionTimestamp);
-			int refundTimeout = DigibyteACCTv3.calcRefundTimeout(partnersOfferMessageTransactionTimestamp, lockTimeA);
-
-			// Send trade info to AT BUT NOT FROM AT CREATOR
-			byte[] messageData = DigibyteACCTv3.buildTradeMessage(partner.getAddress(), digibytePublicKeyHash, hashOfSecretA, lockTimeA, refundTimeout);
-			MessageTransaction messageTransaction = sendMessage(repository, bystander, messageData, atAddress);
-
-			BlockUtils.mintBlock(repository);
-
-			long expectedBalance = partnersInitialBalance;
-			long actualBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Partner's post-initial-payout balance incorrect", expectedBalance, actualBalance);
-
-			describeAt(repository, atAddress);
-
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			CrossChainTradeData tradeData = DigibyteACCTv3.getInstance().populateTradeData(repository, atData);
-
-			// AT should still be in OFFER mode
-			assertEquals(AcctMode.OFFERING, tradeData.mode);
-		}
+	@Override
+	protected byte[] getCodeBytesHash() {
+		return DigibyteACCTv3.CODE_BYTES_HASH;
 	}

-	@SuppressWarnings("unused")
-	@Test
-	public void testAutomaticTradeRefund() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long partnersOfferMessageTransactionTimestamp = System.currentTimeMillis();
-			int lockTimeA = calcTestLockTimeA(partnersOfferMessageTransactionTimestamp);
-			int refundTimeout = DigibyteACCTv3.calcRefundTimeout(partnersOfferMessageTransactionTimestamp, lockTimeA);
-
-			// Send trade info to AT
-			byte[] messageData = DigibyteACCTv3.buildTradeMessage(partner.getAddress(), digibytePublicKeyHash, hashOfSecretA, lockTimeA, refundTimeout);
-			MessageTransaction messageTransaction = sendMessage(repository, tradeAccount, messageData, atAddress);
-
-			Block postDeploymentBlock = BlockUtils.mintBlock(repository);
-			int postDeploymentBlockHeight = postDeploymentBlock.getBlockData().getHeight();
-
-			// Check refund
-			long deployAtFee = deployAtTransaction.getTransactionData().getFee();
-			long deployersPostDeploymentBalance = deployersInitialBalance - fundingAmount - deployAtFee;
-
-			checkTradeRefund(repository, deployer, deployersInitialBalance, deployAtFee);
-
-			describeAt(repository, atAddress);
-
-			// Check AT is finished
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			assertTrue(atData.getIsFinished());
-
-			// AT should be in REFUNDED mode
-			CrossChainTradeData tradeData = DigibyteACCTv3.getInstance().populateTradeData(repository, atData);
-			assertEquals(AcctMode.REFUNDED, tradeData.mode);
-
-			// Test orphaning
-			BlockUtils.orphanToBlock(repository, postDeploymentBlockHeight);
-
-			// Check balances
-			long expectedBalance = deployersPostDeploymentBalance;
-			long actualBalance = deployer.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Deployer's post-orphan/pre-refund balance incorrect", expectedBalance, actualBalance);
-		}
+	@Override
+	protected String getSymbol() {
+		return SYMBOL;
 	}

-	@SuppressWarnings("unused")
-	@Test
-	public void testCorrectSecretCorrectSender() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long partnersOfferMessageTransactionTimestamp = System.currentTimeMillis();
-			int lockTimeA = calcTestLockTimeA(partnersOfferMessageTransactionTimestamp);
-			int refundTimeout = DigibyteACCTv3.calcRefundTimeout(partnersOfferMessageTransactionTimestamp, lockTimeA);
-
-			// Send trade info to AT
-			byte[] messageData = DigibyteACCTv3.buildTradeMessage(partner.getAddress(), digibytePublicKeyHash, hashOfSecretA, lockTimeA, refundTimeout);
-			MessageTransaction messageTransaction = sendMessage(repository, tradeAccount, messageData, atAddress);
-
-			// Give AT time to process message
-			BlockUtils.mintBlock(repository);
-
-			// Send correct secret to AT, from correct account
-			messageData = DigibyteACCTv3.buildRedeemMessage(secretA,  partner.getAddress());
-			messageTransaction = sendMessage(repository, partner, messageData, atAddress);
-
-			// AT should send funds in the next block
-			ATStateData preRedeemAtStateData = repository.getATRepository().getLatestATState(atAddress);
-			BlockUtils.mintBlock(repository);
-
-			describeAt(repository, atAddress);
-
-			// Check AT is finished
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			assertTrue(atData.getIsFinished());
-
-			// AT should be in REDEEMED mode
-			CrossChainTradeData tradeData = DigibyteACCTv3.getInstance().populateTradeData(repository, atData);
-			assertEquals(AcctMode.REDEEMED, tradeData.mode);
-
-			// Check balances
-			long expectedBalance = partnersInitialBalance - messageTransaction.getTransactionData().getFee() + redeemAmount;
-			long actualBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Partner's post-redeem balance incorrect", expectedBalance, actualBalance);
-
-			// Orphan redeem
-			BlockUtils.orphanLastBlock(repository);
-
-			// Check balances
-			expectedBalance = partnersInitialBalance - messageTransaction.getTransactionData().getFee();
-			actualBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Partner's post-orphan/pre-redeem balance incorrect", expectedBalance, actualBalance);
-
-			// Check AT state
-			ATStateData postOrphanAtStateData = repository.getATRepository().getLatestATState(atAddress);
-
-			assertTrue("AT states mismatch", Arrays.equals(preRedeemAtStateData.getStateData(), postOrphanAtStateData.getStateData()));
-		}
+	@Override
+	protected String getName() {
+		return NAME;
 	}
-
-	@SuppressWarnings("unused")
-	@Test
-	public void testCorrectSecretIncorrectSender() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			PrivateKeyAccount bystander = Common.getTestAccount(repository, "bob");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			long deployAtFee = deployAtTransaction.getTransactionData().getFee();
-
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long partnersOfferMessageTransactionTimestamp = System.currentTimeMillis();
-			int lockTimeA = calcTestLockTimeA(partnersOfferMessageTransactionTimestamp);
-			int refundTimeout = DigibyteACCTv3.calcRefundTimeout(partnersOfferMessageTransactionTimestamp, lockTimeA);
-
-			// Send trade info to AT
-			byte[] messageData = DigibyteACCTv3.buildTradeMessage(partner.getAddress(), digibytePublicKeyHash, hashOfSecretA, lockTimeA, refundTimeout);
-			MessageTransaction messageTransaction = sendMessage(repository, tradeAccount, messageData, atAddress);
-
-			// Give AT time to process message
-			BlockUtils.mintBlock(repository);
-
-			// Send correct secret to AT, but from wrong account
-			messageData = DigibyteACCTv3.buildRedeemMessage(secretA, partner.getAddress());
-			messageTransaction = sendMessage(repository, bystander, messageData, atAddress);
-
-			// AT should NOT send funds in the next block
-			ATStateData preRedeemAtStateData = repository.getATRepository().getLatestATState(atAddress);
-			BlockUtils.mintBlock(repository);
-
-			describeAt(repository, atAddress);
-
-			// Check AT is NOT finished
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			assertFalse(atData.getIsFinished());
-
-			// AT should still be in TRADE mode
-			CrossChainTradeData tradeData = DigibyteACCTv3.getInstance().populateTradeData(repository, atData);
-			assertEquals(AcctMode.TRADING, tradeData.mode);
-
-			// Check balances
-			long expectedBalance = partnersInitialBalance;
-			long actualBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Partner's balance incorrect", expectedBalance, actualBalance);
-
-			// Check eventual refund
-			checkTradeRefund(repository, deployer, deployersInitialBalance, deployAtFee);
-		}
-	}
-
-	@SuppressWarnings("unused")
-	@Test
-	public void testIncorrectSecretCorrectSender() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			long deployAtFee = deployAtTransaction.getTransactionData().getFee();
-
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long partnersOfferMessageTransactionTimestamp = System.currentTimeMillis();
-			int lockTimeA = calcTestLockTimeA(partnersOfferMessageTransactionTimestamp);
-			int refundTimeout = DigibyteACCTv3.calcRefundTimeout(partnersOfferMessageTransactionTimestamp, lockTimeA);
-
-			// Send trade info to AT
-			byte[] messageData = DigibyteACCTv3.buildTradeMessage(partner.getAddress(), digibytePublicKeyHash, hashOfSecretA, lockTimeA, refundTimeout);
-			MessageTransaction messageTransaction = sendMessage(repository, tradeAccount, messageData, atAddress);
-
-			// Give AT time to process message
-			BlockUtils.mintBlock(repository);
-
-			// Send incorrect secret to AT, from correct account
-			byte[] wrongSecret = new byte[32];
-			RANDOM.nextBytes(wrongSecret);
-			messageData = DigibyteACCTv3.buildRedeemMessage(wrongSecret, partner.getAddress());
-			messageTransaction = sendMessage(repository, partner, messageData, atAddress);
-
-			// AT should NOT send funds in the next block
-			ATStateData preRedeemAtStateData = repository.getATRepository().getLatestATState(atAddress);
-			BlockUtils.mintBlock(repository);
-
-			describeAt(repository, atAddress);
-
-			// Check AT is NOT finished
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			assertFalse(atData.getIsFinished());
-
-			// AT should still be in TRADE mode
-			CrossChainTradeData tradeData = DigibyteACCTv3.getInstance().populateTradeData(repository, atData);
-			assertEquals(AcctMode.TRADING, tradeData.mode);
-
-			long expectedBalance = partnersInitialBalance - messageTransaction.getTransactionData().getFee();
-			long actualBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Partner's balance incorrect", expectedBalance, actualBalance);
-
-			// Check eventual refund
-			checkTradeRefund(repository, deployer, deployersInitialBalance, deployAtFee);
-		}
-	}
-
-	@SuppressWarnings("unused")
-	@Test
-	public void testCorrectSecretCorrectSenderInvalidMessageLength() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long partnersOfferMessageTransactionTimestamp = System.currentTimeMillis();
-			int lockTimeA = calcTestLockTimeA(partnersOfferMessageTransactionTimestamp);
-			int refundTimeout = DigibyteACCTv3.calcRefundTimeout(partnersOfferMessageTransactionTimestamp, lockTimeA);
-
-			// Send trade info to AT
-			byte[] messageData = DigibyteACCTv3.buildTradeMessage(partner.getAddress(), digibytePublicKeyHash, hashOfSecretA, lockTimeA, refundTimeout);
-			MessageTransaction messageTransaction = sendMessage(repository, tradeAccount, messageData, atAddress);
-
-			// Give AT time to process message
-			BlockUtils.mintBlock(repository);
-
-			// Send correct secret to AT, from correct account, but missing receive address, hence incorrect length
-			messageData = Bytes.concat(secretA);
-			messageTransaction = sendMessage(repository, partner, messageData, atAddress);
-
-			// AT should NOT send funds in the next block
-			ATStateData preRedeemAtStateData = repository.getATRepository().getLatestATState(atAddress);
-			BlockUtils.mintBlock(repository);
-
-			describeAt(repository, atAddress);
-
-			// Check AT is NOT finished
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			assertFalse(atData.getIsFinished());
-
-			// AT should be in TRADING mode
-			CrossChainTradeData tradeData = DigibyteACCTv3.getInstance().populateTradeData(repository, atData);
-			assertEquals(AcctMode.TRADING, tradeData.mode);
-		}
-	}
-
-	@SuppressWarnings("unused")
-	@Test
-	public void testDescribeDeployed() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-
-			List<ATData> executableAts = repository.getATRepository().getAllExecutableATs();
-
-			for (ATData atData : executableAts) {
-				String atAddress = atData.getATAddress();
-				byte[] codeBytes = atData.getCodeBytes();
-				byte[] codeHash = Crypto.digest(codeBytes);
-
-				System.out.println(String.format("%s: code length: %d byte%s, code hash: %s",
-						atAddress,
-						codeBytes.length,
-						(codeBytes.length != 1 ? "s": ""),
-						HashCode.fromBytes(codeHash)));
-
-				// Not one of ours?
-				if (!Arrays.equals(codeHash, DigibyteACCTv3.CODE_BYTES_HASH))
-					continue;
-
-				describeAt(repository, atAddress);
-			}
-		}
-	}
-
-	private int calcTestLockTimeA(long messageTimestamp) {
-		return (int) (messageTimestamp / 1000L + tradeTimeout * 60);
-	}
-
-	private DeployAtTransaction doDeploy(Repository repository, PrivateKeyAccount deployer, String tradeAddress) throws DataException {
-		byte[] creationBytes = DigibyteACCTv3.buildQortalAT(tradeAddress, digibytePublicKeyHash, redeemAmount, digibyteAmount, tradeTimeout);
-
-		long txTimestamp = System.currentTimeMillis();
-		byte[] lastReference = deployer.getLastReference();
-
-		if (lastReference == null) {
-			System.err.println(String.format("Qortal account %s has no last reference", deployer.getAddress()));
-			System.exit(2);
-		}
-
-		Long fee = null;
-		String name = "QORT-DGB cross-chain trade";
-		String description = String.format("Qortal-Digibyte cross-chain trade");
-		String atType = "ACCT";
-		String tags = "QORT-DGB ACCT";
-
-		BaseTransactionData baseTransactionData = new BaseTransactionData(txTimestamp, Group.NO_GROUP, lastReference, deployer.getPublicKey(), fee, null);
-		TransactionData deployAtTransactionData = new DeployAtTransactionData(baseTransactionData, name, description, atType, tags, creationBytes, fundingAmount, Asset.QORT);
-
-		DeployAtTransaction deployAtTransaction = new DeployAtTransaction(repository, deployAtTransactionData);
-
-		fee = deployAtTransaction.calcRecommendedFee();
-		deployAtTransactionData.setFee(fee);
-
-		TransactionUtils.signAndMint(repository, deployAtTransactionData, deployer);
-
-		return deployAtTransaction;
-	}
-
-	private MessageTransaction sendMessage(Repository repository, PrivateKeyAccount sender, byte[] data, String recipient) throws DataException {
-		long txTimestamp = System.currentTimeMillis();
-		byte[] lastReference = sender.getLastReference();
-
-		if (lastReference == null) {
-			System.err.println(String.format("Qortal account %s has no last reference", sender.getAddress()));
-			System.exit(2);
-		}
-
-		Long fee = null;
-		int version = 4;
-		int nonce = 0;
-		long amount = 0;
-		Long assetId = null; // because amount is zero
-
-		BaseTransactionData baseTransactionData = new BaseTransactionData(txTimestamp, Group.NO_GROUP, lastReference, sender.getPublicKey(), fee, null);
-		TransactionData messageTransactionData = new MessageTransactionData(baseTransactionData, version, nonce, recipient, amount, assetId, data, false, false);
-
-		MessageTransaction messageTransaction = new MessageTransaction(repository, messageTransactionData);
-
-		fee = messageTransaction.calcRecommendedFee();
-		messageTransactionData.setFee(fee);
-
-		TransactionUtils.signAndMint(repository, messageTransactionData, sender);
-
-		return messageTransaction;
-	}
-
-	private void checkTradeRefund(Repository repository, Account deployer, long deployersInitialBalance, long deployAtFee) throws DataException {
-		long deployersPostDeploymentBalance = deployersInitialBalance - fundingAmount - deployAtFee;
-		int refundTimeout = tradeTimeout / 2 + 1; // close enough
-
-		// AT should automatically refund deployer after 'refundTimeout' blocks
-		for (int blockCount = 0; blockCount <= refundTimeout; ++blockCount)
-			BlockUtils.mintBlock(repository);
-
-		// We don't bother to exactly calculate QORT spent running AT for several blocks, but we do know the expected range
-		long expectedMinimumBalance = deployersPostDeploymentBalance;
-		long expectedMaximumBalance = deployersInitialBalance - deployAtFee;
-
-		long actualBalance = deployer.getConfirmedBalance(Asset.QORT);
-
-		assertTrue(String.format("Deployer's balance %s should be above minimum %s", actualBalance, expectedMinimumBalance), actualBalance > expectedMinimumBalance);
-		assertTrue(String.format("Deployer's balance %s should be below maximum %s", actualBalance, expectedMaximumBalance), actualBalance < expectedMaximumBalance);
-	}
-
-	private void describeAt(Repository repository, String atAddress) throws DataException {
-		ATData atData = repository.getATRepository().fromATAddress(atAddress);
-		CrossChainTradeData tradeData = DigibyteACCTv3.getInstance().populateTradeData(repository, atData);
-
-		Function<Long, String> epochMilliFormatter = (timestamp) -> LocalDateTime.ofInstant(Instant.ofEpochMilli(timestamp), ZoneOffset.UTC).format(DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM));
-		int currentBlockHeight = repository.getBlockRepository().getBlockchainHeight();
-
-		System.out.print(String.format("%s:\n"
-				+ "\tmode: %s\n"
-				+ "\tcreator: %s,\n"
-				+ "\tcreation timestamp: %s,\n"
-				+ "\tcurrent balance: %s QORT,\n"
-				+ "\tis finished: %b,\n"
-				+ "\tredeem payout: %s QORT,\n"
-				+ "\texpected digibyte: %s DGB,\n"
-				+ "\tcurrent block height: %d,\n",
-				tradeData.qortalAtAddress,
-				tradeData.mode,
-				tradeData.qortalCreator,
-				epochMilliFormatter.apply(tradeData.creationTimestamp),
-				Amounts.prettyAmount(tradeData.qortBalance),
-				atData.getIsFinished(),
-				Amounts.prettyAmount(tradeData.qortAmount),
-				Amounts.prettyAmount(tradeData.expectedForeignAmount),
-				currentBlockHeight));
-
-		if (tradeData.mode != AcctMode.OFFERING && tradeData.mode != AcctMode.CANCELLED) {
-			System.out.println(String.format("\trefund timeout: %d minutes,\n"
-					+ "\trefund height: block %d,\n"
-					+ "\tHASH160 of secret-A: %s,\n"
-					+ "\tDigibyte P2SH-A nLockTime: %d (%s),\n"
-					+ "\ttrade partner: %s\n"
-					+ "\tpartner's receiving address: %s",
-					tradeData.refundTimeout,
-					tradeData.tradeRefundHeight,
-					HashCode.fromBytes(tradeData.hashOfSecretA).toString().substring(0, 40),
-					tradeData.lockTimeA, epochMilliFormatter.apply(tradeData.lockTimeA * 1000L),
-					tradeData.qortalPartnerAddress,
-					tradeData.qortalPartnerReceivingAddress));
-		}
-	}
-
-	private PrivateKeyAccount createTradeAccount(Repository repository) {
-		// We actually use a known test account with funds to avoid PoW compute
-		return Common.getTestAccount(repository, "alice");
-	}
-
 }
--- a/src/test/java/org/qortal/test/crosschain/dogecoinv3/DogecoinACCTv3Tests.java
+++ b/src/test/java/org/qortal/test/crosschain/dogecoinv3/DogecoinACCTv3Tests.java
@@ -1,769 +1,58 @@
 package org.qortal.test.crosschain.dogecoinv3;

 import com.google.common.hash.HashCode;
-import com.google.common.primitives.Bytes;
-import org.junit.Before;
-import org.junit.Test;
-import org.qortal.account.Account;
-import org.qortal.account.PrivateKeyAccount;
-import org.qortal.asset.Asset;
-import org.qortal.block.Block;
-import org.qortal.crosschain.AcctMode;
+import org.qortal.crosschain.ACCT;
 import org.qortal.crosschain.DogecoinACCTv3;
-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.transaction.BaseTransactionData;
-import org.qortal.data.transaction.DeployAtTransactionData;
-import org.qortal.data.transaction.MessageTransactionData;
-import org.qortal.data.transaction.TransactionData;
-import org.qortal.group.Group;
-import org.qortal.repository.DataException;
-import org.qortal.repository.Repository;
-import org.qortal.repository.RepositoryManager;
-import org.qortal.test.common.BlockUtils;
-import org.qortal.test.common.Common;
-import org.qortal.test.common.TransactionUtils;
-import org.qortal.transaction.DeployAtTransaction;
-import org.qortal.transaction.MessageTransaction;
-import org.qortal.utils.Amounts;
+import org.qortal.test.crosschain.ACCTTests;

-import java.time.Instant;
-import java.time.LocalDateTime;
-import java.time.ZoneOffset;
-import java.time.format.DateTimeFormatter;
-import java.time.format.FormatStyle;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Random;
-import java.util.function.Function;
+public class DogecoinACCTv3Tests extends ACCTTests {

-import static org.junit.Assert.*;
-
-public class DogecoinACCTv3Tests extends Common {
-
-	public static final byte[] secretA = "This string is exactly 32 bytes!".getBytes();
-	public static final byte[] hashOfSecretA = Crypto.hash160(secretA); // daf59884b4d1aec8c1b17102530909ee43c0151a
 	public static final byte[] dogecoinPublicKeyHash = HashCode.fromString("bb00bb11bb22bb33bb44bb55bb66bb77bb88bb99").asBytes();
-	public static final int tradeTimeout = 20; // blocks
-	public static final long redeemAmount = 80_40200000L;
-	public static final long fundingAmount = 123_45600000L;
-	public static final long dogecoinAmount = 864200L; // 0.00864200 DOGE
+	private static final String SYMBOL = "DOGE";
+	private static final String NAME = "Dogecoin";

-	private static final Random RANDOM = new Random();
-
-	@Before
-	public void beforeTest() throws DataException {
-		Common.useDefaultSettings();
+	@Override
+	protected byte[] getPublicKey() {
+		return dogecoinPublicKeyHash;
 	}

-	@Test
-	public void testCompile() {
-		PrivateKeyAccount tradeAccount = createTradeAccount(null);
-
-		byte[] creationBytes = DogecoinACCTv3.buildQortalAT(tradeAccount.getAddress(), dogecoinPublicKeyHash, redeemAmount, dogecoinAmount, tradeTimeout);
-		assertNotNull(creationBytes);
-
-		System.out.println("AT creation bytes: " + HashCode.fromBytes(creationBytes).toString());
+	@Override
+	protected byte[] buildQortalAT(String address, byte[] publicKey, long redeemAmount, long foreignAmount, int tradeTimeout) {
+		return DogecoinACCTv3.buildQortalAT(address, publicKey, redeemAmount, foreignAmount, tradeTimeout);
 	}

-	@Test
-	public void testDeploy() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-
-			long expectedBalance = deployersInitialBalance - fundingAmount - deployAtTransaction.getTransactionData().getFee();
-			long actualBalance = deployer.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Deployer's post-deployment balance incorrect", expectedBalance, actualBalance);
-
-			expectedBalance = fundingAmount;
-			actualBalance = deployAtTransaction.getATAccount().getConfirmedBalance(Asset.QORT);
-
-			assertEquals("AT's post-deployment balance incorrect", expectedBalance, actualBalance);
-
-			expectedBalance = partnersInitialBalance;
-			actualBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Partner's post-deployment balance incorrect", expectedBalance, actualBalance);
-
-			// Test orphaning
-			BlockUtils.orphanLastBlock(repository);
-
-			expectedBalance = deployersInitialBalance;
-			actualBalance = deployer.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Deployer's post-orphan/pre-deployment balance incorrect", expectedBalance, actualBalance);
-
-			expectedBalance = 0;
-			actualBalance = deployAtTransaction.getATAccount().getConfirmedBalance(Asset.QORT);
-
-			assertEquals("AT's post-orphan/pre-deployment balance incorrect", expectedBalance, actualBalance);
-
-			expectedBalance = partnersInitialBalance;
-			actualBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Partner's post-orphan/pre-deployment balance incorrect", expectedBalance, actualBalance);
-		}
+	@Override
+	protected ACCT getInstance() {
+		return DogecoinACCTv3.getInstance();
 	}

-	@SuppressWarnings("unused")
-	@Test
-	public void testOfferCancel() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long deployAtFee = deployAtTransaction.getTransactionData().getFee();
-			long deployersPostDeploymentBalance = deployersInitialBalance - fundingAmount - deployAtFee;
-
-			// Send creator's address to AT, instead of typical partner's address
-			byte[] messageData = DogecoinACCTv3.getInstance().buildCancelMessage(deployer.getAddress());
-			MessageTransaction messageTransaction = sendMessage(repository, deployer, messageData, atAddress);
-			long messageFee = messageTransaction.getTransactionData().getFee();
-
-			// AT should process 'cancel' message in next block
-			BlockUtils.mintBlock(repository);
-
-			describeAt(repository, atAddress);
-
-			// Check AT is finished
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			assertTrue(atData.getIsFinished());
-
-			// AT should be in CANCELLED mode
-			CrossChainTradeData tradeData = DogecoinACCTv3.getInstance().populateTradeData(repository, atData);
-			assertEquals(AcctMode.CANCELLED, tradeData.mode);
-
-			// Check balances
-			long expectedMinimumBalance = deployersPostDeploymentBalance;
-			long expectedMaximumBalance = deployersInitialBalance - deployAtFee - messageFee;
-
-			long actualBalance = deployer.getConfirmedBalance(Asset.QORT);
-
-			assertTrue(String.format("Deployer's balance %s should be above minimum %s", actualBalance, expectedMinimumBalance), actualBalance > expectedMinimumBalance);
-			assertTrue(String.format("Deployer's balance %s should be below maximum %s", actualBalance, expectedMaximumBalance), actualBalance < expectedMaximumBalance);
-
-			// Test orphaning
-			BlockUtils.orphanLastBlock(repository);
-
-			// Check balances
-			long expectedBalance = deployersPostDeploymentBalance - messageFee;
-			actualBalance = deployer.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Deployer's post-orphan/pre-refund balance incorrect", expectedBalance, actualBalance);
-		}
+	@Override
+	protected int calcRefundTimeout(long partnersOfferMessageTransactionTimestamp, int lockTimeA) {
+		return DogecoinACCTv3.calcRefundTimeout(partnersOfferMessageTransactionTimestamp, lockTimeA);
 	}

-	@SuppressWarnings("unused")
-	@Test
-	public void testOfferCancelInvalidLength() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long deployAtFee = deployAtTransaction.getTransactionData().getFee();
-			long deployersPostDeploymentBalance = deployersInitialBalance - fundingAmount - deployAtFee;
-
-			// Instead of sending creator's address to AT, send too-short/invalid message
-			byte[] messageData = new byte[7];
-			RANDOM.nextBytes(messageData);
-			MessageTransaction messageTransaction = sendMessage(repository, deployer, messageData, atAddress);
-			long messageFee = messageTransaction.getTransactionData().getFee();
-
-			// AT should process 'cancel' message in next block
-			// As message is too short, it will be padded to 32bytes but cancel code doesn't care about message content, so should be ok
-			BlockUtils.mintBlock(repository);
-
-			describeAt(repository, atAddress);
-
-			// Check AT is finished
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			assertTrue(atData.getIsFinished());
-
-			// AT should be in CANCELLED mode
-			CrossChainTradeData tradeData = DogecoinACCTv3.getInstance().populateTradeData(repository, atData);
-			assertEquals(AcctMode.CANCELLED, tradeData.mode);
-		}
+	@Override
+	protected byte[] buildTradeMessage(String address, byte[] publicKey, byte[] hashOfSecretA, int lockTimeA, int refundTimeout) {
+		return DogecoinACCTv3.buildTradeMessage(address, publicKey, hashOfSecretA, lockTimeA, refundTimeout);
 	}

-	@SuppressWarnings("unused")
-	@Test
-	public void testTradingInfoProcessing() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long partnersOfferMessageTransactionTimestamp = System.currentTimeMillis();
-			int lockTimeA = calcTestLockTimeA(partnersOfferMessageTransactionTimestamp);
-			int refundTimeout = DogecoinACCTv3.calcRefundTimeout(partnersOfferMessageTransactionTimestamp, lockTimeA);
-
-			// Send trade info to AT
-			byte[] messageData = DogecoinACCTv3.buildTradeMessage(partner.getAddress(), dogecoinPublicKeyHash, hashOfSecretA, lockTimeA, refundTimeout);
-			MessageTransaction messageTransaction = sendMessage(repository, tradeAccount, messageData, atAddress);
-
-			Block postDeploymentBlock = BlockUtils.mintBlock(repository);
-			int postDeploymentBlockHeight = postDeploymentBlock.getBlockData().getHeight();
-
-			long deployAtFee = deployAtTransaction.getTransactionData().getFee();
-			long deployersPostDeploymentBalance = deployersInitialBalance - fundingAmount - deployAtFee;
-
-			describeAt(repository, atAddress);
-
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			CrossChainTradeData tradeData = DogecoinACCTv3.getInstance().populateTradeData(repository, atData);
-
-			// AT should be in TRADE mode
-			assertEquals(AcctMode.TRADING, tradeData.mode);
-
-			// Check hashOfSecretA was extracted correctly
-			assertTrue(Arrays.equals(hashOfSecretA, tradeData.hashOfSecretA));
-
-			// Check trade partner Qortal address was extracted correctly
-			assertEquals(partner.getAddress(), tradeData.qortalPartnerAddress);
-
-			// Check trade partner's dogecoin PKH was extracted correctly
-			assertTrue(Arrays.equals(dogecoinPublicKeyHash, tradeData.partnerForeignPKH));
-
-			// Test orphaning
-			BlockUtils.orphanToBlock(repository, postDeploymentBlockHeight);
-
-			// Check balances
-			long expectedBalance = deployersPostDeploymentBalance;
-			long actualBalance = deployer.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Deployer's post-orphan/pre-refund balance incorrect", expectedBalance, actualBalance);
-		}
+	@Override
+	protected byte[] buildRedeemMessage(byte[] secretA, String address) {
+		return DogecoinACCTv3.buildRedeemMessage(secretA, address);
 	}

-	// TEST SENDING TRADING INFO BUT NOT FROM AT CREATOR (SHOULD BE IGNORED)
-	@SuppressWarnings("unused")
-	@Test
-	public void testIncorrectTradeSender() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			PrivateKeyAccount bystander = Common.getTestAccount(repository, "bob");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long partnersOfferMessageTransactionTimestamp = System.currentTimeMillis();
-			int lockTimeA = calcTestLockTimeA(partnersOfferMessageTransactionTimestamp);
-			int refundTimeout = DogecoinACCTv3.calcRefundTimeout(partnersOfferMessageTransactionTimestamp, lockTimeA);
-
-			// Send trade info to AT BUT NOT FROM AT CREATOR
-			byte[] messageData = DogecoinACCTv3.buildTradeMessage(partner.getAddress(), dogecoinPublicKeyHash, hashOfSecretA, lockTimeA, refundTimeout);
-			MessageTransaction messageTransaction = sendMessage(repository, bystander, messageData, atAddress);
-
-			BlockUtils.mintBlock(repository);
-
-			long expectedBalance = partnersInitialBalance;
-			long actualBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Partner's post-initial-payout balance incorrect", expectedBalance, actualBalance);
-
-			describeAt(repository, atAddress);
-
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			CrossChainTradeData tradeData = DogecoinACCTv3.getInstance().populateTradeData(repository, atData);
-
-			// AT should still be in OFFER mode
-			assertEquals(AcctMode.OFFERING, tradeData.mode);
-		}
+	@Override
+	protected byte[] getCodeBytesHash() {
+		return DogecoinACCTv3.CODE_BYTES_HASH;
 	}

-	@SuppressWarnings("unused")
-	@Test
-	public void testAutomaticTradeRefund() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long partnersOfferMessageTransactionTimestamp = System.currentTimeMillis();
-			int lockTimeA = calcTestLockTimeA(partnersOfferMessageTransactionTimestamp);
-			int refundTimeout = DogecoinACCTv3.calcRefundTimeout(partnersOfferMessageTransactionTimestamp, lockTimeA);
-
-			// Send trade info to AT
-			byte[] messageData = DogecoinACCTv3.buildTradeMessage(partner.getAddress(), dogecoinPublicKeyHash, hashOfSecretA, lockTimeA, refundTimeout);
-			MessageTransaction messageTransaction = sendMessage(repository, tradeAccount, messageData, atAddress);
-
-			Block postDeploymentBlock = BlockUtils.mintBlock(repository);
-			int postDeploymentBlockHeight = postDeploymentBlock.getBlockData().getHeight();
-
-			// Check refund
-			long deployAtFee = deployAtTransaction.getTransactionData().getFee();
-			long deployersPostDeploymentBalance = deployersInitialBalance - fundingAmount - deployAtFee;
-
-			checkTradeRefund(repository, deployer, deployersInitialBalance, deployAtFee);
-
-			describeAt(repository, atAddress);
-
-			// Check AT is finished
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			assertTrue(atData.getIsFinished());
-
-			// AT should be in REFUNDED mode
-			CrossChainTradeData tradeData = DogecoinACCTv3.getInstance().populateTradeData(repository, atData);
-			assertEquals(AcctMode.REFUNDED, tradeData.mode);
-
-			// Test orphaning
-			BlockUtils.orphanToBlock(repository, postDeploymentBlockHeight);
-
-			// Check balances
-			long expectedBalance = deployersPostDeploymentBalance;
-			long actualBalance = deployer.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Deployer's post-orphan/pre-refund balance incorrect", expectedBalance, actualBalance);
-		}
+	@Override
+	protected String getSymbol() {
+		return SYMBOL;
 	}

-	@SuppressWarnings("unused")
-	@Test
-	public void testCorrectSecretCorrectSender() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long partnersOfferMessageTransactionTimestamp = System.currentTimeMillis();
-			int lockTimeA = calcTestLockTimeA(partnersOfferMessageTransactionTimestamp);
-			int refundTimeout = DogecoinACCTv3.calcRefundTimeout(partnersOfferMessageTransactionTimestamp, lockTimeA);
-
-			// Send trade info to AT
-			byte[] messageData = DogecoinACCTv3.buildTradeMessage(partner.getAddress(), dogecoinPublicKeyHash, hashOfSecretA, lockTimeA, refundTimeout);
-			MessageTransaction messageTransaction = sendMessage(repository, tradeAccount, messageData, atAddress);
-
-			// Give AT time to process message
-			BlockUtils.mintBlock(repository);
-
-			// Send correct secret to AT, from correct account
-			messageData = DogecoinACCTv3.buildRedeemMessage(secretA,  partner.getAddress());
-			messageTransaction = sendMessage(repository, partner, messageData, atAddress);
-
-			// AT should send funds in the next block
-			ATStateData preRedeemAtStateData = repository.getATRepository().getLatestATState(atAddress);
-			BlockUtils.mintBlock(repository);
-
-			describeAt(repository, atAddress);
-
-			// Check AT is finished
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			assertTrue(atData.getIsFinished());
-
-			// AT should be in REDEEMED mode
-			CrossChainTradeData tradeData = DogecoinACCTv3.getInstance().populateTradeData(repository, atData);
-			assertEquals(AcctMode.REDEEMED, tradeData.mode);
-
-			// Check balances
-			long expectedBalance = partnersInitialBalance - messageTransaction.getTransactionData().getFee() + redeemAmount;
-			long actualBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Partner's post-redeem balance incorrect", expectedBalance, actualBalance);
-
-			// Orphan redeem
-			BlockUtils.orphanLastBlock(repository);
-
-			// Check balances
-			expectedBalance = partnersInitialBalance - messageTransaction.getTransactionData().getFee();
-			actualBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Partner's post-orphan/pre-redeem balance incorrect", expectedBalance, actualBalance);
-
-			// Check AT state
-			ATStateData postOrphanAtStateData = repository.getATRepository().getLatestATState(atAddress);
-
-			assertTrue("AT states mismatch", Arrays.equals(preRedeemAtStateData.getStateData(), postOrphanAtStateData.getStateData()));
-		}
+	@Override
+	protected String getName() {
+		return NAME;
 	}
-
-	@SuppressWarnings("unused")
-	@Test
-	public void testCorrectSecretIncorrectSender() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			PrivateKeyAccount bystander = Common.getTestAccount(repository, "bob");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			long deployAtFee = deployAtTransaction.getTransactionData().getFee();
-
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long partnersOfferMessageTransactionTimestamp = System.currentTimeMillis();
-			int lockTimeA = calcTestLockTimeA(partnersOfferMessageTransactionTimestamp);
-			int refundTimeout = DogecoinACCTv3.calcRefundTimeout(partnersOfferMessageTransactionTimestamp, lockTimeA);
-
-			// Send trade info to AT
-			byte[] messageData = DogecoinACCTv3.buildTradeMessage(partner.getAddress(), dogecoinPublicKeyHash, hashOfSecretA, lockTimeA, refundTimeout);
-			MessageTransaction messageTransaction = sendMessage(repository, tradeAccount, messageData, atAddress);
-
-			// Give AT time to process message
-			BlockUtils.mintBlock(repository);
-
-			// Send correct secret to AT, but from wrong account
-			messageData = DogecoinACCTv3.buildRedeemMessage(secretA, partner.getAddress());
-			messageTransaction = sendMessage(repository, bystander, messageData, atAddress);
-
-			// AT should NOT send funds in the next block
-			ATStateData preRedeemAtStateData = repository.getATRepository().getLatestATState(atAddress);
-			BlockUtils.mintBlock(repository);
-
-			describeAt(repository, atAddress);
-
-			// Check AT is NOT finished
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			assertFalse(atData.getIsFinished());
-
-			// AT should still be in TRADE mode
-			CrossChainTradeData tradeData = DogecoinACCTv3.getInstance().populateTradeData(repository, atData);
-			assertEquals(AcctMode.TRADING, tradeData.mode);
-
-			// Check balances
-			long expectedBalance = partnersInitialBalance;
-			long actualBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Partner's balance incorrect", expectedBalance, actualBalance);
-
-			// Check eventual refund
-			checkTradeRefund(repository, deployer, deployersInitialBalance, deployAtFee);
-		}
-	}
-
-	@SuppressWarnings("unused")
-	@Test
-	public void testIncorrectSecretCorrectSender() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			long deployAtFee = deployAtTransaction.getTransactionData().getFee();
-
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long partnersOfferMessageTransactionTimestamp = System.currentTimeMillis();
-			int lockTimeA = calcTestLockTimeA(partnersOfferMessageTransactionTimestamp);
-			int refundTimeout = DogecoinACCTv3.calcRefundTimeout(partnersOfferMessageTransactionTimestamp, lockTimeA);
-
-			// Send trade info to AT
-			byte[] messageData = DogecoinACCTv3.buildTradeMessage(partner.getAddress(), dogecoinPublicKeyHash, hashOfSecretA, lockTimeA, refundTimeout);
-			MessageTransaction messageTransaction = sendMessage(repository, tradeAccount, messageData, atAddress);
-
-			// Give AT time to process message
-			BlockUtils.mintBlock(repository);
-
-			// Send incorrect secret to AT, from correct account
-			byte[] wrongSecret = new byte[32];
-			RANDOM.nextBytes(wrongSecret);
-			messageData = DogecoinACCTv3.buildRedeemMessage(wrongSecret, partner.getAddress());
-			messageTransaction = sendMessage(repository, partner, messageData, atAddress);
-
-			// AT should NOT send funds in the next block
-			ATStateData preRedeemAtStateData = repository.getATRepository().getLatestATState(atAddress);
-			BlockUtils.mintBlock(repository);
-
-			describeAt(repository, atAddress);
-
-			// Check AT is NOT finished
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			assertFalse(atData.getIsFinished());
-
-			// AT should still be in TRADE mode
-			CrossChainTradeData tradeData = DogecoinACCTv3.getInstance().populateTradeData(repository, atData);
-			assertEquals(AcctMode.TRADING, tradeData.mode);
-
-			long expectedBalance = partnersInitialBalance - messageTransaction.getTransactionData().getFee();
-			long actualBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Partner's balance incorrect", expectedBalance, actualBalance);
-
-			// Check eventual refund
-			checkTradeRefund(repository, deployer, deployersInitialBalance, deployAtFee);
-		}
-	}
-
-	@SuppressWarnings("unused")
-	@Test
-	public void testCorrectSecretCorrectSenderInvalidMessageLength() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long partnersOfferMessageTransactionTimestamp = System.currentTimeMillis();
-			int lockTimeA = calcTestLockTimeA(partnersOfferMessageTransactionTimestamp);
-			int refundTimeout = DogecoinACCTv3.calcRefundTimeout(partnersOfferMessageTransactionTimestamp, lockTimeA);
-
-			// Send trade info to AT
-			byte[] messageData = DogecoinACCTv3.buildTradeMessage(partner.getAddress(), dogecoinPublicKeyHash, hashOfSecretA, lockTimeA, refundTimeout);
-			MessageTransaction messageTransaction = sendMessage(repository, tradeAccount, messageData, atAddress);
-
-			// Give AT time to process message
-			BlockUtils.mintBlock(repository);
-
-			// Send correct secret to AT, from correct account, but missing receive address, hence incorrect length
-			messageData = Bytes.concat(secretA);
-			messageTransaction = sendMessage(repository, partner, messageData, atAddress);
-
-			// AT should NOT send funds in the next block
-			ATStateData preRedeemAtStateData = repository.getATRepository().getLatestATState(atAddress);
-			BlockUtils.mintBlock(repository);
-
-			describeAt(repository, atAddress);
-
-			// Check AT is NOT finished
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			assertFalse(atData.getIsFinished());
-
-			// AT should be in TRADING mode
-			CrossChainTradeData tradeData = DogecoinACCTv3.getInstance().populateTradeData(repository, atData);
-			assertEquals(AcctMode.TRADING, tradeData.mode);
-		}
-	}
-
-	@SuppressWarnings("unused")
-	@Test
-	public void testDescribeDeployed() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-
-			List<ATData> executableAts = repository.getATRepository().getAllExecutableATs();
-
-			for (ATData atData : executableAts) {
-				String atAddress = atData.getATAddress();
-				byte[] codeBytes = atData.getCodeBytes();
-				byte[] codeHash = Crypto.digest(codeBytes);
-
-				System.out.println(String.format("%s: code length: %d byte%s, code hash: %s",
-						atAddress,
-						codeBytes.length,
-						(codeBytes.length != 1 ? "s": ""),
-						HashCode.fromBytes(codeHash)));
-
-				// Not one of ours?
-				if (!Arrays.equals(codeHash, DogecoinACCTv3.CODE_BYTES_HASH))
-					continue;
-
-				describeAt(repository, atAddress);
-			}
-		}
-	}
-
-	private int calcTestLockTimeA(long messageTimestamp) {
-		return (int) (messageTimestamp / 1000L + tradeTimeout * 60);
-	}
-
-	private DeployAtTransaction doDeploy(Repository repository, PrivateKeyAccount deployer, String tradeAddress) throws DataException {
-		byte[] creationBytes = DogecoinACCTv3.buildQortalAT(tradeAddress, dogecoinPublicKeyHash, redeemAmount, dogecoinAmount, tradeTimeout);
-
-		long txTimestamp = System.currentTimeMillis();
-		byte[] lastReference = deployer.getLastReference();
-
-		if (lastReference == null) {
-			System.err.println(String.format("Qortal account %s has no last reference", deployer.getAddress()));
-			System.exit(2);
-		}
-
-		Long fee = null;
-		String name = "QORT-DOGE cross-chain trade";
-		String description = String.format("Qortal-Dogecoin cross-chain trade");
-		String atType = "ACCT";
-		String tags = "QORT-DOGE ACCT";
-
-		BaseTransactionData baseTransactionData = new BaseTransactionData(txTimestamp, Group.NO_GROUP, lastReference, deployer.getPublicKey(), fee, null);
-		TransactionData deployAtTransactionData = new DeployAtTransactionData(baseTransactionData, name, description, atType, tags, creationBytes, fundingAmount, Asset.QORT);
-
-		DeployAtTransaction deployAtTransaction = new DeployAtTransaction(repository, deployAtTransactionData);
-
-		fee = deployAtTransaction.calcRecommendedFee();
-		deployAtTransactionData.setFee(fee);
-
-		TransactionUtils.signAndMint(repository, deployAtTransactionData, deployer);
-
-		return deployAtTransaction;
-	}
-
-	private MessageTransaction sendMessage(Repository repository, PrivateKeyAccount sender, byte[] data, String recipient) throws DataException {
-		long txTimestamp = System.currentTimeMillis();
-		byte[] lastReference = sender.getLastReference();
-
-		if (lastReference == null) {
-			System.err.println(String.format("Qortal account %s has no last reference", sender.getAddress()));
-			System.exit(2);
-		}
-
-		Long fee = null;
-		int version = 4;
-		int nonce = 0;
-		long amount = 0;
-		Long assetId = null; // because amount is zero
-
-		BaseTransactionData baseTransactionData = new BaseTransactionData(txTimestamp, Group.NO_GROUP, lastReference, sender.getPublicKey(), fee, null);
-		TransactionData messageTransactionData = new MessageTransactionData(baseTransactionData, version, nonce, recipient, amount, assetId, data, false, false);
-
-		MessageTransaction messageTransaction = new MessageTransaction(repository, messageTransactionData);
-
-		fee = messageTransaction.calcRecommendedFee();
-		messageTransactionData.setFee(fee);
-
-		TransactionUtils.signAndMint(repository, messageTransactionData, sender);
-
-		return messageTransaction;
-	}
-
-	private void checkTradeRefund(Repository repository, Account deployer, long deployersInitialBalance, long deployAtFee) throws DataException {
-		long deployersPostDeploymentBalance = deployersInitialBalance - fundingAmount - deployAtFee;
-		int refundTimeout = tradeTimeout / 2 + 1; // close enough
-
-		// AT should automatically refund deployer after 'refundTimeout' blocks
-		for (int blockCount = 0; blockCount <= refundTimeout; ++blockCount)
-			BlockUtils.mintBlock(repository);
-
-		// We don't bother to exactly calculate QORT spent running AT for several blocks, but we do know the expected range
-		long expectedMinimumBalance = deployersPostDeploymentBalance;
-		long expectedMaximumBalance = deployersInitialBalance - deployAtFee;
-
-		long actualBalance = deployer.getConfirmedBalance(Asset.QORT);
-
-		assertTrue(String.format("Deployer's balance %s should be above minimum %s", actualBalance, expectedMinimumBalance), actualBalance > expectedMinimumBalance);
-		assertTrue(String.format("Deployer's balance %s should be below maximum %s", actualBalance, expectedMaximumBalance), actualBalance < expectedMaximumBalance);
-	}
-
-	private void describeAt(Repository repository, String atAddress) throws DataException {
-		ATData atData = repository.getATRepository().fromATAddress(atAddress);
-		CrossChainTradeData tradeData = DogecoinACCTv3.getInstance().populateTradeData(repository, atData);
-
-		Function<Long, String> epochMilliFormatter = (timestamp) -> LocalDateTime.ofInstant(Instant.ofEpochMilli(timestamp), ZoneOffset.UTC).format(DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM));
-		int currentBlockHeight = repository.getBlockRepository().getBlockchainHeight();
-
-		System.out.print(String.format("%s:\n"
-				+ "\tmode: %s\n"
-				+ "\tcreator: %s,\n"
-				+ "\tcreation timestamp: %s,\n"
-				+ "\tcurrent balance: %s QORT,\n"
-				+ "\tis finished: %b,\n"
-				+ "\tredeem payout: %s QORT,\n"
-				+ "\texpected dogecoin: %s DOGE,\n"
-				+ "\tcurrent block height: %d,\n",
-				tradeData.qortalAtAddress,
-				tradeData.mode,
-				tradeData.qortalCreator,
-				epochMilliFormatter.apply(tradeData.creationTimestamp),
-				Amounts.prettyAmount(tradeData.qortBalance),
-				atData.getIsFinished(),
-				Amounts.prettyAmount(tradeData.qortAmount),
-				Amounts.prettyAmount(tradeData.expectedForeignAmount),
-				currentBlockHeight));
-
-		if (tradeData.mode != AcctMode.OFFERING && tradeData.mode != AcctMode.CANCELLED) {
-			System.out.println(String.format("\trefund timeout: %d minutes,\n"
-					+ "\trefund height: block %d,\n"
-					+ "\tHASH160 of secret-A: %s,\n"
-					+ "\tDogecoin P2SH-A nLockTime: %d (%s),\n"
-					+ "\ttrade partner: %s\n"
-					+ "\tpartner's receiving address: %s",
-					tradeData.refundTimeout,
-					tradeData.tradeRefundHeight,
-					HashCode.fromBytes(tradeData.hashOfSecretA).toString().substring(0, 40),
-					tradeData.lockTimeA, epochMilliFormatter.apply(tradeData.lockTimeA * 1000L),
-					tradeData.qortalPartnerAddress,
-					tradeData.qortalPartnerReceivingAddress));
-		}
-	}
-
-	private PrivateKeyAccount createTradeAccount(Repository repository) {
-		// We actually use a known test account with funds to avoid PoW compute
-		return Common.getTestAccount(repository, "alice");
-	}
-
 }
--- a/src/test/java/org/qortal/test/crosschain/litecoinv1/LitecoinACCTv1Tests.java
+++ b/src/test/java/org/qortal/test/crosschain/litecoinv1/LitecoinACCTv1Tests.java
@@ -1,770 +1,60 @@
 package org.qortal.test.crosschain.litecoinv1;

-import static org.junit.Assert.*;
-
-import java.time.Instant;
-import java.time.LocalDateTime;
-import java.time.ZoneOffset;
-import java.time.format.DateTimeFormatter;
-import java.time.format.FormatStyle;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Random;
-import java.util.function.Function;
-
-import org.junit.Before;
-import org.junit.Test;
-import org.qortal.account.Account;
-import org.qortal.account.PrivateKeyAccount;
-import org.qortal.asset.Asset;
-import org.qortal.block.Block;
+import org.qortal.crosschain.ACCT;
 import org.qortal.crosschain.LitecoinACCTv1;
-import org.qortal.crosschain.AcctMode;
-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.transaction.BaseTransactionData;
-import org.qortal.data.transaction.DeployAtTransactionData;
-import org.qortal.data.transaction.MessageTransactionData;
-import org.qortal.data.transaction.TransactionData;
-import org.qortal.group.Group;
-import org.qortal.repository.DataException;
-import org.qortal.repository.Repository;
-import org.qortal.repository.RepositoryManager;
-import org.qortal.test.common.BlockUtils;
-import org.qortal.test.common.Common;
-import org.qortal.test.common.TransactionUtils;
-import org.qortal.transaction.DeployAtTransaction;
-import org.qortal.transaction.MessageTransaction;
-import org.qortal.utils.Amounts;
+import org.qortal.test.crosschain.ACCTTests;

 import com.google.common.hash.HashCode;
-import com.google.common.primitives.Bytes;

-public class LitecoinACCTv1Tests extends Common {
+public class LitecoinACCTv1Tests extends ACCTTests {

-	public static final byte[] secretA = "This string is exactly 32 bytes!".getBytes();
-	public static final byte[] hashOfSecretA = Crypto.hash160(secretA); // daf59884b4d1aec8c1b17102530909ee43c0151a
 	public static final byte[] litecoinPublicKeyHash = HashCode.fromString("bb00bb11bb22bb33bb44bb55bb66bb77bb88bb99").asBytes();
-	public static final int tradeTimeout = 20; // blocks
-	public static final long redeemAmount = 80_40200000L;
-	public static final long fundingAmount = 123_45600000L;
-	public static final long litecoinAmount = 864200L; // 0.00864200 LTC
+	private static final String SYMBOL = "LTC";

-	private static final Random RANDOM = new Random();
+	private static final String NAME = "Litecoin";

-	@Before
-	public void beforeTest() throws DataException {
-		Common.useDefaultSettings();
+	@Override
+	protected byte[] getPublicKey() {
+		return litecoinPublicKeyHash;
 	}

-	@Test
-	public void testCompile() {
-		PrivateKeyAccount tradeAccount = createTradeAccount(null);
-
-		byte[] creationBytes = LitecoinACCTv1.buildQortalAT(tradeAccount.getAddress(), litecoinPublicKeyHash, redeemAmount, litecoinAmount, tradeTimeout);
-		assertNotNull(creationBytes);
-
-		System.out.println("AT creation bytes: " + HashCode.fromBytes(creationBytes).toString());
+	@Override
+	protected byte[] buildQortalAT(String address, byte[] publicKey, long redeemAmount, long foreignAmount, int tradeTimeout) {
+		return LitecoinACCTv1.buildQortalAT(address, publicKey, redeemAmount, foreignAmount, tradeTimeout);
 	}

-	@Test
-	public void testDeploy() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-
-			long expectedBalance = deployersInitialBalance - fundingAmount - deployAtTransaction.getTransactionData().getFee();
-			long actualBalance = deployer.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Deployer's post-deployment balance incorrect", expectedBalance, actualBalance);
-
-			expectedBalance = fundingAmount;
-			actualBalance = deployAtTransaction.getATAccount().getConfirmedBalance(Asset.QORT);
-
-			assertEquals("AT's post-deployment balance incorrect", expectedBalance, actualBalance);
-
-			expectedBalance = partnersInitialBalance;
-			actualBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Partner's post-deployment balance incorrect", expectedBalance, actualBalance);
-
-			// Test orphaning
-			BlockUtils.orphanLastBlock(repository);
-
-			expectedBalance = deployersInitialBalance;
-			actualBalance = deployer.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Deployer's post-orphan/pre-deployment balance incorrect", expectedBalance, actualBalance);
-
-			expectedBalance = 0;
-			actualBalance = deployAtTransaction.getATAccount().getConfirmedBalance(Asset.QORT);
-
-			assertEquals("AT's post-orphan/pre-deployment balance incorrect", expectedBalance, actualBalance);
-
-			expectedBalance = partnersInitialBalance;
-			actualBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Partner's post-orphan/pre-deployment balance incorrect", expectedBalance, actualBalance);
-		}
+	@Override
+	protected ACCT getInstance() {
+		return LitecoinACCTv1.getInstance();
 	}

-	@SuppressWarnings("unused")
-	@Test
-	public void testOfferCancel() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long deployAtFee = deployAtTransaction.getTransactionData().getFee();
-			long deployersPostDeploymentBalance = deployersInitialBalance - fundingAmount - deployAtFee;
-
-			// Send creator's address to AT, instead of typical partner's address
-			byte[] messageData = LitecoinACCTv1.getInstance().buildCancelMessage(deployer.getAddress());
-			MessageTransaction messageTransaction = sendMessage(repository, deployer, messageData, atAddress);
-			long messageFee = messageTransaction.getTransactionData().getFee();
-
-			// AT should process 'cancel' message in next block
-			BlockUtils.mintBlock(repository);
-
-			describeAt(repository, atAddress);
-
-			// Check AT is finished
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			assertTrue(atData.getIsFinished());
-
-			// AT should be in CANCELLED mode
-			CrossChainTradeData tradeData = LitecoinACCTv1.getInstance().populateTradeData(repository, atData);
-			assertEquals(AcctMode.CANCELLED, tradeData.mode);
-
-			// Check balances
-			long expectedMinimumBalance = deployersPostDeploymentBalance;
-			long expectedMaximumBalance = deployersInitialBalance - deployAtFee - messageFee;
-
-			long actualBalance = deployer.getConfirmedBalance(Asset.QORT);
-
-			assertTrue(String.format("Deployer's balance %s should be above minimum %s", actualBalance, expectedMinimumBalance), actualBalance > expectedMinimumBalance);
-			assertTrue(String.format("Deployer's balance %s should be below maximum %s", actualBalance, expectedMaximumBalance), actualBalance < expectedMaximumBalance);
-
-			// Test orphaning
-			BlockUtils.orphanLastBlock(repository);
-
-			// Check balances
-			long expectedBalance = deployersPostDeploymentBalance - messageFee;
-			actualBalance = deployer.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Deployer's post-orphan/pre-refund balance incorrect", expectedBalance, actualBalance);
-		}
+	@Override
+	protected int calcRefundTimeout(long partnersOfferMessageTransactionTimestamp, int lockTimeA) {
+		return LitecoinACCTv1.calcRefundTimeout(partnersOfferMessageTransactionTimestamp, lockTimeA);
 	}

-	@SuppressWarnings("unused")
-	@Test
-	public void testOfferCancelInvalidLength() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long deployAtFee = deployAtTransaction.getTransactionData().getFee();
-			long deployersPostDeploymentBalance = deployersInitialBalance - fundingAmount - deployAtFee;
-
-			// Instead of sending creator's address to AT, send too-short/invalid message
-			byte[] messageData = new byte[7];
-			RANDOM.nextBytes(messageData);
-			MessageTransaction messageTransaction = sendMessage(repository, deployer, messageData, atAddress);
-			long messageFee = messageTransaction.getTransactionData().getFee();
-
-			// AT should process 'cancel' message in next block
-			// As message is too short, it will be padded to 32bytes but cancel code doesn't care about message content, so should be ok
-			BlockUtils.mintBlock(repository);
-
-			describeAt(repository, atAddress);
-
-			// Check AT is finished
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			assertTrue(atData.getIsFinished());
-
-			// AT should be in CANCELLED mode
-			CrossChainTradeData tradeData = LitecoinACCTv1.getInstance().populateTradeData(repository, atData);
-			assertEquals(AcctMode.CANCELLED, tradeData.mode);
-		}
+	@Override
+	protected byte[] buildTradeMessage(String address, byte[] publicKey, byte[] hashOfSecretA, int lockTimeA, int refundTimeout) {
+		return LitecoinACCTv1.buildTradeMessage(address, publicKey, hashOfSecretA, lockTimeA, refundTimeout);
 	}

-	@SuppressWarnings("unused")
-	@Test
-	public void testTradingInfoProcessing() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long partnersOfferMessageTransactionTimestamp = System.currentTimeMillis();
-			int lockTimeA = calcTestLockTimeA(partnersOfferMessageTransactionTimestamp);
-			int refundTimeout = LitecoinACCTv1.calcRefundTimeout(partnersOfferMessageTransactionTimestamp, lockTimeA);
-
-			// Send trade info to AT
-			byte[] messageData = LitecoinACCTv1.buildTradeMessage(partner.getAddress(), litecoinPublicKeyHash, hashOfSecretA, lockTimeA, refundTimeout);
-			MessageTransaction messageTransaction = sendMessage(repository, tradeAccount, messageData, atAddress);
-
-			Block postDeploymentBlock = BlockUtils.mintBlock(repository);
-			int postDeploymentBlockHeight = postDeploymentBlock.getBlockData().getHeight();
-
-			long deployAtFee = deployAtTransaction.getTransactionData().getFee();
-			long deployersPostDeploymentBalance = deployersInitialBalance - fundingAmount - deployAtFee;
-
-			describeAt(repository, atAddress);
-
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			CrossChainTradeData tradeData = LitecoinACCTv1.getInstance().populateTradeData(repository, atData);
-
-			// AT should be in TRADE mode
-			assertEquals(AcctMode.TRADING, tradeData.mode);
-
-			// Check hashOfSecretA was extracted correctly
-			assertTrue(Arrays.equals(hashOfSecretA, tradeData.hashOfSecretA));
-
-			// Check trade partner Qortal address was extracted correctly
-			assertEquals(partner.getAddress(), tradeData.qortalPartnerAddress);
-
-			// Check trade partner's Litecoin PKH was extracted correctly
-			assertTrue(Arrays.equals(litecoinPublicKeyHash, tradeData.partnerForeignPKH));
-
-			// Test orphaning
-			BlockUtils.orphanToBlock(repository, postDeploymentBlockHeight);
-
-			// Check balances
-			long expectedBalance = deployersPostDeploymentBalance;
-			long actualBalance = deployer.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Deployer's post-orphan/pre-refund balance incorrect", expectedBalance, actualBalance);
-		}
+	@Override
+	protected byte[] buildRedeemMessage(byte[] secretA, String address) {
+		return LitecoinACCTv1.buildRedeemMessage(secretA, address);
 	}

-	// TEST SENDING TRADING INFO BUT NOT FROM AT CREATOR (SHOULD BE IGNORED)
-	@SuppressWarnings("unused")
-	@Test
-	public void testIncorrectTradeSender() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			PrivateKeyAccount bystander = Common.getTestAccount(repository, "bob");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long partnersOfferMessageTransactionTimestamp = System.currentTimeMillis();
-			int lockTimeA = calcTestLockTimeA(partnersOfferMessageTransactionTimestamp);
-			int refundTimeout = LitecoinACCTv1.calcRefundTimeout(partnersOfferMessageTransactionTimestamp, lockTimeA);
-
-			// Send trade info to AT BUT NOT FROM AT CREATOR
-			byte[] messageData = LitecoinACCTv1.buildTradeMessage(partner.getAddress(), litecoinPublicKeyHash, hashOfSecretA, lockTimeA, refundTimeout);
-			MessageTransaction messageTransaction = sendMessage(repository, bystander, messageData, atAddress);
-
-			BlockUtils.mintBlock(repository);
-
-			long expectedBalance = partnersInitialBalance;
-			long actualBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Partner's post-initial-payout balance incorrect", expectedBalance, actualBalance);
-
-			describeAt(repository, atAddress);
-
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			CrossChainTradeData tradeData = LitecoinACCTv1.getInstance().populateTradeData(repository, atData);
-
-			// AT should still be in OFFER mode
-			assertEquals(AcctMode.OFFERING, tradeData.mode);
-		}
+	@Override
+	protected byte[] getCodeBytesHash() {
+		return LitecoinACCTv1.CODE_BYTES_HASH;
 	}

-	@SuppressWarnings("unused")
-	@Test
-	public void testAutomaticTradeRefund() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long partnersOfferMessageTransactionTimestamp = System.currentTimeMillis();
-			int lockTimeA = calcTestLockTimeA(partnersOfferMessageTransactionTimestamp);
-			int refundTimeout = LitecoinACCTv1.calcRefundTimeout(partnersOfferMessageTransactionTimestamp, lockTimeA);
-
-			// Send trade info to AT
-			byte[] messageData = LitecoinACCTv1.buildTradeMessage(partner.getAddress(), litecoinPublicKeyHash, hashOfSecretA, lockTimeA, refundTimeout);
-			MessageTransaction messageTransaction = sendMessage(repository, tradeAccount, messageData, atAddress);
-
-			Block postDeploymentBlock = BlockUtils.mintBlock(repository);
-			int postDeploymentBlockHeight = postDeploymentBlock.getBlockData().getHeight();
-
-			// Check refund
-			long deployAtFee = deployAtTransaction.getTransactionData().getFee();
-			long deployersPostDeploymentBalance = deployersInitialBalance - fundingAmount - deployAtFee;
-
-			checkTradeRefund(repository, deployer, deployersInitialBalance, deployAtFee);
-
-			describeAt(repository, atAddress);
-
-			// Check AT is finished
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			assertTrue(atData.getIsFinished());
-
-			// AT should be in REFUNDED mode
-			CrossChainTradeData tradeData = LitecoinACCTv1.getInstance().populateTradeData(repository, atData);
-			assertEquals(AcctMode.REFUNDED, tradeData.mode);
-
-			// Test orphaning
-			BlockUtils.orphanToBlock(repository, postDeploymentBlockHeight);
-
-			// Check balances
-			long expectedBalance = deployersPostDeploymentBalance;
-			long actualBalance = deployer.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Deployer's post-orphan/pre-refund balance incorrect", expectedBalance, actualBalance);
-		}
+	@Override
+	protected String getSymbol() {
+		return SYMBOL;
 	}

-	@SuppressWarnings("unused")
-	@Test
-	public void testCorrectSecretCorrectSender() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long partnersOfferMessageTransactionTimestamp = System.currentTimeMillis();
-			int lockTimeA = calcTestLockTimeA(partnersOfferMessageTransactionTimestamp);
-			int refundTimeout = LitecoinACCTv1.calcRefundTimeout(partnersOfferMessageTransactionTimestamp, lockTimeA);
-
-			// Send trade info to AT
-			byte[] messageData = LitecoinACCTv1.buildTradeMessage(partner.getAddress(), litecoinPublicKeyHash, hashOfSecretA, lockTimeA, refundTimeout);
-			MessageTransaction messageTransaction = sendMessage(repository, tradeAccount, messageData, atAddress);
-
-			// Give AT time to process message
-			BlockUtils.mintBlock(repository);
-
-			// Send correct secret to AT, from correct account
-			messageData = LitecoinACCTv1.buildRedeemMessage(secretA,  partner.getAddress());
-			messageTransaction = sendMessage(repository, partner, messageData, atAddress);
-
-			// AT should send funds in the next block
-			ATStateData preRedeemAtStateData = repository.getATRepository().getLatestATState(atAddress);
-			BlockUtils.mintBlock(repository);
-
-			describeAt(repository, atAddress);
-
-			// Check AT is finished
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			assertTrue(atData.getIsFinished());
-
-			// AT should be in REDEEMED mode
-			CrossChainTradeData tradeData = LitecoinACCTv1.getInstance().populateTradeData(repository, atData);
-			assertEquals(AcctMode.REDEEMED, tradeData.mode);
-
-			// Check balances
-			long expectedBalance = partnersInitialBalance - messageTransaction.getTransactionData().getFee() + redeemAmount;
-			long actualBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Partner's post-redeem balance incorrect", expectedBalance, actualBalance);
-
-			// Orphan redeem
-			BlockUtils.orphanLastBlock(repository);
-
-			// Check balances
-			expectedBalance = partnersInitialBalance - messageTransaction.getTransactionData().getFee();
-			actualBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Partner's post-orphan/pre-redeem balance incorrect", expectedBalance, actualBalance);
-
-			// Check AT state
-			ATStateData postOrphanAtStateData = repository.getATRepository().getLatestATState(atAddress);
-
-			assertTrue("AT states mismatch", Arrays.equals(preRedeemAtStateData.getStateData(), postOrphanAtStateData.getStateData()));
-		}
+	@Override
+	protected String getName() {
+		return NAME;
 	}
-
-	@SuppressWarnings("unused")
-	@Test
-	public void testCorrectSecretIncorrectSender() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			PrivateKeyAccount bystander = Common.getTestAccount(repository, "bob");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			long deployAtFee = deployAtTransaction.getTransactionData().getFee();
-
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long partnersOfferMessageTransactionTimestamp = System.currentTimeMillis();
-			int lockTimeA = calcTestLockTimeA(partnersOfferMessageTransactionTimestamp);
-			int refundTimeout = LitecoinACCTv1.calcRefundTimeout(partnersOfferMessageTransactionTimestamp, lockTimeA);
-
-			// Send trade info to AT
-			byte[] messageData = LitecoinACCTv1.buildTradeMessage(partner.getAddress(), litecoinPublicKeyHash, hashOfSecretA, lockTimeA, refundTimeout);
-			MessageTransaction messageTransaction = sendMessage(repository, tradeAccount, messageData, atAddress);
-
-			// Give AT time to process message
-			BlockUtils.mintBlock(repository);
-
-			// Send correct secret to AT, but from wrong account
-			messageData = LitecoinACCTv1.buildRedeemMessage(secretA, partner.getAddress());
-			messageTransaction = sendMessage(repository, bystander, messageData, atAddress);
-
-			// AT should NOT send funds in the next block
-			ATStateData preRedeemAtStateData = repository.getATRepository().getLatestATState(atAddress);
-			BlockUtils.mintBlock(repository);
-
-			describeAt(repository, atAddress);
-
-			// Check AT is NOT finished
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			assertFalse(atData.getIsFinished());
-
-			// AT should still be in TRADE mode
-			CrossChainTradeData tradeData = LitecoinACCTv1.getInstance().populateTradeData(repository, atData);
-			assertEquals(AcctMode.TRADING, tradeData.mode);
-
-			// Check balances
-			long expectedBalance = partnersInitialBalance;
-			long actualBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Partner's balance incorrect", expectedBalance, actualBalance);
-
-			// Check eventual refund
-			checkTradeRefund(repository, deployer, deployersInitialBalance, deployAtFee);
-		}
-	}
-
-	@SuppressWarnings("unused")
-	@Test
-	public void testIncorrectSecretCorrectSender() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			long deployAtFee = deployAtTransaction.getTransactionData().getFee();
-
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long partnersOfferMessageTransactionTimestamp = System.currentTimeMillis();
-			int lockTimeA = calcTestLockTimeA(partnersOfferMessageTransactionTimestamp);
-			int refundTimeout = LitecoinACCTv1.calcRefundTimeout(partnersOfferMessageTransactionTimestamp, lockTimeA);
-
-			// Send trade info to AT
-			byte[] messageData = LitecoinACCTv1.buildTradeMessage(partner.getAddress(), litecoinPublicKeyHash, hashOfSecretA, lockTimeA, refundTimeout);
-			MessageTransaction messageTransaction = sendMessage(repository, tradeAccount, messageData, atAddress);
-
-			// Give AT time to process message
-			BlockUtils.mintBlock(repository);
-
-			// Send incorrect secret to AT, from correct account
-			byte[] wrongSecret = new byte[32];
-			RANDOM.nextBytes(wrongSecret);
-			messageData = LitecoinACCTv1.buildRedeemMessage(wrongSecret, partner.getAddress());
-			messageTransaction = sendMessage(repository, partner, messageData, atAddress);
-
-			// AT should NOT send funds in the next block
-			ATStateData preRedeemAtStateData = repository.getATRepository().getLatestATState(atAddress);
-			BlockUtils.mintBlock(repository);
-
-			describeAt(repository, atAddress);
-
-			// Check AT is NOT finished
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			assertFalse(atData.getIsFinished());
-
-			// AT should still be in TRADE mode
-			CrossChainTradeData tradeData = LitecoinACCTv1.getInstance().populateTradeData(repository, atData);
-			assertEquals(AcctMode.TRADING, tradeData.mode);
-
-			long expectedBalance = partnersInitialBalance - messageTransaction.getTransactionData().getFee();
-			long actualBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			assertEquals("Partner's balance incorrect", expectedBalance, actualBalance);
-
-			// Check eventual refund
-			checkTradeRefund(repository, deployer, deployersInitialBalance, deployAtFee);
-		}
-	}
-
-	@SuppressWarnings("unused")
-	@Test
-	public void testCorrectSecretCorrectSenderInvalidMessageLength() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-			Account at = deployAtTransaction.getATAccount();
-			String atAddress = at.getAddress();
-
-			long partnersOfferMessageTransactionTimestamp = System.currentTimeMillis();
-			int lockTimeA = calcTestLockTimeA(partnersOfferMessageTransactionTimestamp);
-			int refundTimeout = LitecoinACCTv1.calcRefundTimeout(partnersOfferMessageTransactionTimestamp, lockTimeA);
-
-			// Send trade info to AT
-			byte[] messageData = LitecoinACCTv1.buildTradeMessage(partner.getAddress(), litecoinPublicKeyHash, hashOfSecretA, lockTimeA, refundTimeout);
-			MessageTransaction messageTransaction = sendMessage(repository, tradeAccount, messageData, atAddress);
-
-			// Give AT time to process message
-			BlockUtils.mintBlock(repository);
-
-			// Send correct secret to AT, from correct account, but missing receive address, hence incorrect length
-			messageData = Bytes.concat(secretA);
-			messageTransaction = sendMessage(repository, partner, messageData, atAddress);
-
-			// AT should NOT send funds in the next block
-			ATStateData preRedeemAtStateData = repository.getATRepository().getLatestATState(atAddress);
-			BlockUtils.mintBlock(repository);
-
-			describeAt(repository, atAddress);
-
-			// Check AT is NOT finished
-			ATData atData = repository.getATRepository().fromATAddress(atAddress);
-			assertFalse(atData.getIsFinished());
-
-			// AT should be in TRADING mode
-			CrossChainTradeData tradeData = LitecoinACCTv1.getInstance().populateTradeData(repository, atData);
-			assertEquals(AcctMode.TRADING, tradeData.mode);
-		}
-	}
-
-	@SuppressWarnings("unused")
-	@Test
-	public void testDescribeDeployed() throws DataException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
-			PrivateKeyAccount tradeAccount = createTradeAccount(repository);
-
-			PrivateKeyAccount partner = Common.getTestAccount(repository, "dilbert");
-
-			long deployersInitialBalance = deployer.getConfirmedBalance(Asset.QORT);
-			long partnersInitialBalance = partner.getConfirmedBalance(Asset.QORT);
-
-			DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
-
-			List<ATData> executableAts = repository.getATRepository().getAllExecutableATs();
-
-			for (ATData atData : executableAts) {
-				String atAddress = atData.getATAddress();
-				byte[] codeBytes = atData.getCodeBytes();
-				byte[] codeHash = Crypto.digest(codeBytes);
-
-				System.out.println(String.format("%s: code length: %d byte%s, code hash: %s",
-						atAddress,
-						codeBytes.length,
-						(codeBytes.length != 1 ? "s": ""),
-						HashCode.fromBytes(codeHash)));
-
-				// Not one of ours?
-				if (!Arrays.equals(codeHash, LitecoinACCTv1.CODE_BYTES_HASH))
-					continue;
-
-				describeAt(repository, atAddress);
-			}
-		}
-	}
-
-	private int calcTestLockTimeA(long messageTimestamp) {
-		return (int) (messageTimestamp / 1000L + tradeTimeout * 60);
-	}
-
-	private DeployAtTransaction doDeploy(Repository repository, PrivateKeyAccount deployer, String tradeAddress) throws DataException {
-		byte[] creationBytes = LitecoinACCTv1.buildQortalAT(tradeAddress, litecoinPublicKeyHash, redeemAmount, litecoinAmount, tradeTimeout);
-
-		long txTimestamp = System.currentTimeMillis();
-		byte[] lastReference = deployer.getLastReference();
-
-		if (lastReference == null) {
-			System.err.println(String.format("Qortal account %s has no last reference", deployer.getAddress()));
-			System.exit(2);
-		}
-
-		Long fee = null;
-		String name = "QORT-LTC cross-chain trade";
-		String description = String.format("Qortal-Litecoin cross-chain trade");
-		String atType = "ACCT";
-		String tags = "QORT-LTC ACCT";
-
-		BaseTransactionData baseTransactionData = new BaseTransactionData(txTimestamp, Group.NO_GROUP, lastReference, deployer.getPublicKey(), fee, null);
-		TransactionData deployAtTransactionData = new DeployAtTransactionData(baseTransactionData, name, description, atType, tags, creationBytes, fundingAmount, Asset.QORT);
-
-		DeployAtTransaction deployAtTransaction = new DeployAtTransaction(repository, deployAtTransactionData);
-
-		fee = deployAtTransaction.calcRecommendedFee();
-		deployAtTransactionData.setFee(fee);
-
-		TransactionUtils.signAndMint(repository, deployAtTransactionData, deployer);
-
-		return deployAtTransaction;
-	}
-
-	private MessageTransaction sendMessage(Repository repository, PrivateKeyAccount sender, byte[] data, String recipient) throws DataException {
-		long txTimestamp = System.currentTimeMillis();
-		byte[] lastReference = sender.getLastReference();
-
-		if (lastReference == null) {
-			System.err.println(String.format("Qortal account %s has no last reference", sender.getAddress()));
-			System.exit(2);
-		}
-
-		Long fee = null;
-		int version = 4;
-		int nonce = 0;
-		long amount = 0;
-		Long assetId = null; // because amount is zero
-
-		BaseTransactionData baseTransactionData = new BaseTransactionData(txTimestamp, Group.NO_GROUP, lastReference, sender.getPublicKey(), fee, null);
-		TransactionData messageTransactionData = new MessageTransactionData(baseTransactionData, version, nonce, recipient, amount, assetId, data, false, false);
-
-		MessageTransaction messageTransaction = new MessageTransaction(repository, messageTransactionData);
-
-		fee = messageTransaction.calcRecommendedFee();
-		messageTransactionData.setFee(fee);
-
-		TransactionUtils.signAndMint(repository, messageTransactionData, sender);
-
-		return messageTransaction;
-	}
-
-	private void checkTradeRefund(Repository repository, Account deployer, long deployersInitialBalance, long deployAtFee) throws DataException {
-		long deployersPostDeploymentBalance = deployersInitialBalance - fundingAmount - deployAtFee;
-		int refundTimeout = tradeTimeout / 2 + 1; // close enough
-
-		// AT should automatically refund deployer after 'refundTimeout' blocks
-		for (int blockCount = 0; blockCount <= refundTimeout; ++blockCount)
-			BlockUtils.mintBlock(repository);
-
-		// We don't bother to exactly calculate QORT spent running AT for several blocks, but we do know the expected range
-		long expectedMinimumBalance = deployersPostDeploymentBalance;
-		long expectedMaximumBalance = deployersInitialBalance - deployAtFee;
-
-		long actualBalance = deployer.getConfirmedBalance(Asset.QORT);
-
-		assertTrue(String.format("Deployer's balance %s should be above minimum %s", actualBalance, expectedMinimumBalance), actualBalance > expectedMinimumBalance);
-		assertTrue(String.format("Deployer's balance %s should be below maximum %s", actualBalance, expectedMaximumBalance), actualBalance < expectedMaximumBalance);
-	}
-
-	private void describeAt(Repository repository, String atAddress) throws DataException {
-		ATData atData = repository.getATRepository().fromATAddress(atAddress);
-		CrossChainTradeData tradeData = LitecoinACCTv1.getInstance().populateTradeData(repository, atData);
-
-		Function<Long, String> epochMilliFormatter = (timestamp) -> LocalDateTime.ofInstant(Instant.ofEpochMilli(timestamp), ZoneOffset.UTC).format(DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM));
-		int currentBlockHeight = repository.getBlockRepository().getBlockchainHeight();
-
-		System.out.print(String.format("%s:\n"
-				+ "\tmode: %s\n"
-				+ "\tcreator: %s,\n"
-				+ "\tcreation timestamp: %s,\n"
-				+ "\tcurrent balance: %s QORT,\n"
-				+ "\tis finished: %b,\n"
-				+ "\tredeem payout: %s QORT,\n"
-				+ "\texpected Litecoin: %s LTC,\n"
-				+ "\tcurrent block height: %d,\n",
-				tradeData.qortalAtAddress,
-				tradeData.mode,
-				tradeData.qortalCreator,
-				epochMilliFormatter.apply(tradeData.creationTimestamp),
-				Amounts.prettyAmount(tradeData.qortBalance),
-				atData.getIsFinished(),
-				Amounts.prettyAmount(tradeData.qortAmount),
-				Amounts.prettyAmount(tradeData.expectedForeignAmount),
-				currentBlockHeight));
-
-		if (tradeData.mode != AcctMode.OFFERING && tradeData.mode != AcctMode.CANCELLED) {
-			System.out.println(String.format("\trefund timeout: %d minutes,\n"
-					+ "\trefund height: block %d,\n"
-					+ "\tHASH160 of secret-A: %s,\n"
-					+ "\tLitecoin P2SH-A nLockTime: %d (%s),\n"
-					+ "\ttrade partner: %s\n"
-					+ "\tpartner's receiving address: %s",
-					tradeData.refundTimeout,
-					tradeData.tradeRefundHeight,
-					HashCode.fromBytes(tradeData.hashOfSecretA).toString().substring(0, 40),
-					tradeData.lockTimeA, epochMilliFormatter.apply(tradeData.lockTimeA * 1000L),
-					tradeData.qortalPartnerAddress,
-					tradeData.qortalPartnerReceivingAddress));
-		}
-	}
-
-	private PrivateKeyAccount createTradeAccount(Repository repository) {
-		// We actually use a known test account with funds to avoid PoW compute
-		return Common.getTestAccount(repository, "alice");
-	}
-
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
QuickMythril	033b6adb72	Bump version to 4.3.1	2023-10-19 13:51:53 -04:00
QuickMythril	53c3f7899a	Reward share limit activation timestamp set to 1698508800000 (Sat Oct 28 2023 16:00:00 UTC)	2023-10-19 13:48:33 -04:00
QuickMythril	f7f2d70b77	Merge pull request #134 from AlphaX-Projects/master Final dependencies updates and fixes	2023-10-19 12:57:44 -04:00
AlphaX-Projects	5cbd4490cc	Back to Bouncycastle 1.69	2023-10-18 17:29:10 +02:00
AlphaX-Projects	7103f41e36	Reorg pom update dependencies	2023-10-18 13:49:53 +02:00
AlphaX-Projects	2d599ec3c5	Summary of activity past 24 hours	2023-10-17 18:39:17 +02:00
AlphaX-Projects	e40d884c81	Merge pull request #10 from Qortal/master Merge thread limit	2023-10-17 18:23:59 +02:00
QuickMythril	7cbeb00c1a	Merge pull request #132 from Qortal/thread-limits Added support for thread limits.	2023-10-17 12:10:35 -04:00
AlphaX-Projects	2af8199d9c	Update dependencies	2023-10-16 17:27:14 +02:00
AlphaX-Projects	404c5d0300	Filter failed trade after 1 attempt	2023-10-15 17:12:02 +02:00
AlphaX-Projects	db7b17e52e	Revert HSQLDB update	2023-10-13 15:57:43 +02:00
AlphaX-Projects	6d202b2b48	Create settings.json	2023-10-12 11:23:36 +02:00
AlphaX-Projects	499e2ac3f4	hide-failed-trade	2023-10-10 23:24:57 +02:00
AlphaX-Projects	bf270a63ff	Update bouncycastle	2023-09-24 15:19:07 +02:00
CalDescent	9454031b48	Added support for thread limits. Default thread limits per message type can be specified in Settings.setAdditionalDefaults(), e.g maxThreadsPerMessageType.add(new ThreadLimit("GET_ARBITRARY_DATA_FILE", 5)); These can also be overridden on a per-node basis in settings.json, e.g "maxThreadsPerMessageType": [ { "messageType": "GET_ARBITRARY_DATA_FILE", "limit": 3 }, { "messageType": "GET_ARBITRARY_DATA_FILE_LIST", "limit": 3 } ] settings.json values take priority, but any message types that aren't specified in settings.json will still be included from the Settings.java defaults. This allows single message types to be overridden in settings.json without removing the limits for all of the other message types. Any messages that arrive are discarded if the node is already at the thread limit for that message type. Warnings are now shown in the logs if the total number of active threads reaches 90% of the allocated thread pool size. Additionally, it can warn per message type by specifying a per-message-type warning threshold in settings.json, e.g "threadCountPerMessageTypeWarningThreshold": 20 The above setting would warn in the logs if a single message type was consuming more than 20 threads at once, therefore making it a candidate to be limited in maxThreadsPerMessageType. Initial values of maxThreadsPerMessageType are guesses and may need modifying based on real world results. Limiting threads may impact functionality, so this should be carefully tested. Also be aware that the thread tracking may reduce network performance slightly, so be sure to test thoroughly on slower hardware.	2023-09-22 13:06:03 +01:00
AlphaX-Projects	cae3fdcb06	Update ElectrumX Servers	2023-09-22 11:12:50 +02:00
AlphaX-Projects	1fbb1659a3	Update dependencies	2023-09-13 10:43:05 +02:00
AlphaX-Projects	9959985a13	Update grpc	2023-09-09 10:56:17 +02:00
AlphaX-Projects	15c073edfe	Merge branch 'Qortal:master' into master	2023-09-08 15:20:44 +02:00
QuickMythril	d453e80c6b	Update fee in qdn script	2023-09-08 03:30:06 -04:00
QuickMythril	4fb799ba38	Merge pull request #125 from crowetic/master ADD: (Tools) New features for qdn script	2023-09-08 03:26:34 -04:00
QuickMythril	29e56158ae	Merge pull request #98 from Nuc1eoN/german-translation ADD: (Language) German updates	2023-09-08 02:37:45 -04:00
QuickMythril	f74c9672f6	Merge branch 'test-german' into german-translation	2023-09-08 02:29:07 -04:00
AlphaX-Projects	a7ca306d1b	Update json dependency	2023-09-07 16:54:09 +02:00
AlphaX-Projects	1a9087984a	Swagger updates	2023-09-06 17:22:13 +02:00
AlphaX-Projects	94e9f86245	Version 3.8.0 get faster the NTP offset	2023-09-06 09:11:41 +02:00
AlphaX-Projects	bd05578035	Reverse need latest 1.7.x	2023-09-05 18:31:32 +02:00
AlphaX-Projects	c0ed4022a5	Update log4j2.properties	2023-09-05 15:27:33 +02:00
AlphaX-Projects	12dbff79c9	Update logging properties	2023-09-05 15:20:21 +02:00
AlphaX-Projects	6be3897fdb	Update logging	2023-09-05 15:06:46 +02:00
AlphaX-Projects	43921e6ab8	Update jetty server	2023-09-05 13:44:54 +02:00
AlphaX-Projects	b92c7cc866	Update dependencies and ntp servers	2023-09-05 11:35:53 +02:00
AlphaX-Projects	053d56d01d	Update hsqldb to 2.7.2 , ciyam at to 1.4.1	2023-09-05 09:40:01 +02:00
CalDescent	eb6a834fd9	Default minPeerVersion set to 4.3.0	2023-09-01 10:47:45 +01:00
CalDescent	a08f10ece3	Bump version to 4.3.0	2023-08-25 16:13:23 +01:00
CalDescent	ad51073f25	mempowTransactionUpdatesTimestamp set to Fri Sep 01 2023 09:00:00 UTC	2023-08-25 16:11:43 +01:00
CalDescent	5983e6ccc9	Merge branch 'add-create-bytes-endpoint'	2023-08-25 16:05:35 +01:00
CalDescent	760788e82b	Updated tools.	2023-08-25 12:12:32 +01:00
CalDescent	d39131ffa9	Merge pull request #128 from kennycud/master consolidated shared functionality into ACCTTests.java	2023-08-25 11:17:52 +01:00
CalDescent	3fbcc50503	Fixed deserialization issues with CreationRequest, added validation, and made small code tweaks for consistency with other endpoints.	2023-08-25 11:01:48 +01:00
kennycud	26ac7e5be5	consolidated shared functionality into ACCTTests.java	2023-08-24 15:47:45 -07:00
Phillip Lang Martinez	b051f9be89	fix strings in request	2023-08-23 14:41:50 -05:00
Phillip Lang Martinez	24ff3ab581	base64 to byte array	2023-08-22 22:46:58 -05:00
Phillip Lang Martinez	34382b6e69	add endpoint	2023-08-22 19:58:24 -05:00
CalDescent	086a9afa0e	Testnet mempowTransactionUpdatesTimestamp set to 1692554400000	2023-08-20 16:52:49 +01:00
CalDescent	9428f9688f	Merge pull request #126 from jschulthess/master Fix website sub-folder rendering 404	2023-08-20 14:22:58 +01:00
CalDescent	9f4a0b7957	Merge pull request #127 from kennycud/master consolidated shared functionality into BitcoinyTests.java	2023-08-20 14:22:18 +01:00
CalDescent	3c8574a466	Trade bot improvements - Add async responder thread from @catbref which was previously only in place for LTC - Log when computing mempow nonces - Skip transaction import if signature is invalid - Added checks to a message test to mimic trade bot transaction lookups	2023-08-20 12:42:49 +01:00
Jürg Schulthess	c428d7ce2e	Merge branch 'Qortal:master' into master	2023-08-20 09:21:48 +02:00
CalDescent	4feb8f46c8	Updated testchain.json to use new unitFees structure.	2023-08-19 20:42:15 +01:00
CalDescent	1f7a60dfd8	Fixed long term issue preventing trade bot statuses from being logged correctly.	2023-08-19 20:27:05 +01:00
CalDescent	379b850bbd	Increase default maxTransactionsPerBlock to 50 now that the process is faster. Can be increased much further in the future.	2023-08-19 14:12:12 +01:00
CalDescent	7bb61ec564	Update various transaction types at a future unknown timestamp. - PUBLICIZE transactions are no longer possible. - ARBITRARY transactions are now only possible using a fee. - MESSAGE transactions only confirm when they are being sent to an AT. Messages to regular addresses (or no recipient) will expire after 24 hours. - Difficulty for confirmed MESSAGE transactions increases from 14 to 16. - Difficulty for unconfirmed MESSAGE transactions decreases from 14 to 12.	2023-08-19 13:57:26 +01:00
CalDescent	b0224651c2	Always use rate limiter for metadata requests, and sleep for a random amount of time between fetching metadata items.	2023-08-18 20:32:44 +01:00
CalDescent	6bf2b99913	Wait until unconfirmed transactions are considered to be valid before broadcasting them.	2023-08-18 15:37:24 +01:00
Jürg Schulthess	fd9d0c4e51	Merge branch 'Qortal:master' into master	2023-08-13 19:17:11 +02:00
kennycud	c2756a5872	Merge branch 'Qortal:master' into master	2023-08-13 05:32:47 -07:00
CalDescent	ecfb9a7d6d	Bump version to 4.2.4	2023-08-12 19:34:59 +01:00
CalDescent	dd9d3fdb22	Add to the unconfirmed transactions cache when importing a transaction.	2023-08-12 19:27:19 +01:00
CalDescent	eea2884112	Bump version to 4.2.3	2023-08-12 18:59:00 +01:00
CalDescent	640a472876	Unit fee increase set to 1692118800000	2023-08-12 18:55:27 +01:00
CalDescent	e244a5f882	Removed legacy code that is no longer needed.	2023-08-12 16:09:41 +01:00
CalDescent	278dca75e8	Increase minimum fee at a future undecided timestamp.	2023-08-12 15:18:29 +01:00
CalDescent	897c44ffe8	Optimized transaction importing by using a temporary cache of unconfirmed transactions.	2023-08-12 11:14:21 +01:00
CalDescent	d9147b3af3	Cache the online accounts validation result, to speed up block minting.	2023-08-12 10:24:55 +01:00
kennycud	fe840bbf02	consolidated shared functionality into BitcoinyTests.java	2023-08-08 12:17:29 -07:00
Jürg Schulthess	e7901a391f	Merge branch 'Qortal:master' into master	2023-08-03 21:32:06 +02:00
CalDescent	9574100a08	Bump version to 4.2.2	2023-08-02 21:36:57 +01:00
CalDescent	528583fe38	Added logging relating to unconfirmed transactions.	2023-08-02 21:32:57 +01:00
CalDescent	33cfd02c49	Fixed issues in commit `f5c8dfe`	2023-08-02 21:13:33 +01:00
Jürg Schulthess	18e880158f	Merge branch 'Qortal:master' into master	2023-08-01 11:09:06 +02:00
CalDescent	94d3664cb0	Bump version to 4.2.1	2023-07-31 19:30:45 +01:00
CalDescent	f5c8dfe766	Added maxTransactionsPerBlock setting (default 25) to reduce minting load on slower machines. This is a short term limit, is well above current usage levels, and can be increased substantially in future once the block minter code has been improved.	2023-07-31 19:25:26 +01:00
Jürg Schulthess	a3526d84bc	Merge branch 'Qortal:master' into master	2023-07-30 13:39:44 +02:00
CalDescent	f7e1f2fca8	Increased timeout for SEARCH_QDN_RESOURCES from 10 to 30 seconds.	2023-07-28 21:47:29 +01:00
CalDescent	811b647c88	Catch UnsupportedAddressTypeException and fall back to IPv4 binding.	2023-07-28 18:58:47 +01:00
CalDescent	3215bb638d	More online accounts improvements	2023-07-22 10:44:41 +01:00
CalDescent	8ae7a1d65b	Removed (Get)OnlineAccountsV1 and V2, as these are no longer used.	2023-07-21 14:28:47 +01:00
CalDescent	29dcd53002	Revert "Improved filtering of online accounts data." This reverts commit `c14fca5660`.	2023-07-16 20:04:45 +01:00
CalDescent	62908f867a	Bump version to 4.2.0	2023-07-16 19:09:08 +01:00
Jürg Schulthess	ff7a87ab18	Merge branch 'Qortal:master' into master	2023-07-10 20:53:24 +02:00
CalDescent	5f86ecafd9	Refactored developer proxy, and modified IPv6 fallback so that it only occurs on a connection failure.	2023-07-09 12:35:46 +01:00
CalDescent	fe999a11f4	Include CANCEL_SELL_NAME transactions when performing a complete rebuild of names.	2023-07-08 11:06:33 +01:00
CalDescent	c14fca5660	Improved filtering of online accounts data.	2023-07-08 11:05:14 +01:00
Jürg Schulthess	cc8cdcd93a	Fix website sub-folder rendering 404	2023-07-03 09:52:07 +02:00
crowetic	ac433b1527	Add files via upload	2023-06-27 13:29:10 -07:00
CalDescent	fd8d720946	Added support for group encryption in service validation.	2023-06-23 13:32:23 +01:00
CalDescent	d628b3ab2a	Renamed the "usePrefix" parameter to "includeResourceIdInPrefix", and slightly modified its functionality.	2023-06-17 13:04:46 +01:00
CalDescent	5928b54a33	Added developer QDN proxy. This allows Q-Apps and websites to be developed and tested in real time, by proxying an existing webserver such as localhost:5173 from React/Vite. The proxy adds all QDN functionality to the existing server in real time. Needs UI integration before all features can be used.	2023-06-17 13:03:29 +01:00
QuickMythril	91dfc5efd0	Merge pull request #119 from QuickMythril/upgrade-tls Upgraded to TLSv1.3	2023-06-14 10:25:25 -04:00
QuickMythril	1343a88ee3	Merge pull request #124 from QuickMythril/translate-jp Added Japanese translations (Credit: R M)	2023-06-02 08:01:04 -04:00
QuickMythril	7f7b02f003	Updated Japanese translations (Credit: R M)	2023-06-02 06:17:48 -04:00
QuickMythril	5650923805	Merge pull request #123 from QuickMythril/2023-05-25 Added some fee info & Q-App support for foreign coins	2023-05-31 09:14:46 -04:00
CalDescent	5fb2640a3a	Bump version to 4.1.3	2023-05-30 18:05:05 +01:00
CalDescent	66c91fd365	MIN_PEER_VERSION for handshake set to 4.1.1	2023-05-30 17:42:31 +01:00
CalDescent	bfc03db6a9	Default minPeerVersion set to 4.1.2	2023-05-30 17:41:39 +01:00
QuickMythril	a4bb445f3e	Added Japanese translations for review	2023-05-29 04:23:22 -04:00
QuickMythril	27afcf12bf	Prepared files for Japanese translations	2023-05-29 04:07:52 -04:00
CalDescent	eda6ab5701	Fixed some failing unit tests, and ignored some failing BTC ones that have been superseded by LTC.	2023-05-26 18:01:09 +02:00
QuickMythril	13da0e8a7a	Adjusted fee info to long format	2023-05-25 17:26:29 -04:00
QuickMythril	d260c0a9a9	Updated info on foreign coin fees	2023-05-25 16:35:08 -04:00
QuickMythril	655073c524	Added 2m timeout for GET_WALLET_BALANCE action	2023-05-25 04:41:03 -04:00
crowetic	c8f3b6918f	Update start.sh Added better defaults for JVM_MEMORY_ARGS and description as to how and when to uncomment the line.	2023-05-24 16:20:05 -07:00
CalDescent	1565a461ac	Bump version to 4.1.2	2023-05-24 20:01:18 +01:00
CalDescent	1f30bef4f8	defaultArchiveVersion set to 2	2023-05-24 19:54:36 +01:00
CalDescent	6f0479c4fc	Default minPeerVersion set to 4.1.1	2023-05-24 19:47:37 +01:00
CalDescent	b967800a3e	Default repositoryConnectionPoolSize set to 240	2023-05-24 19:47:25 +01:00
CalDescent	0b50f965cc	Default maxNetworkThreadPoolSize set to 120	2023-05-24 19:47:10 +01:00
CalDescent	90f7cee058	Bump version to 4.1.1	2023-05-21 20:34:04 +01:00
CalDescent	947b523e61	Limit query to 100 so that it doesn't return endless amounts of transaction signatures. Using a separate database method for now to reduce risk of interfering with other parts of the code which use it. It can be combined later when there is more testing time.	2023-05-21 20:33:33 +01:00
CalDescent	95d72866e9	Use a better method to detect if a transactions table in need of a rebuild. Should handle cases where a previous rebuild didn't fully complete, or missed a block.	2023-05-21 20:06:09 +01:00
CalDescent	aea1cc62c8	Fixed off-by-one bug (correctly this time)	2023-05-21 20:02:58 +01:00
CalDescent	c763445e6e	Log to console if an extra core restart is needed to complete the update process (this needed ins some cases after bootstrapping).	2023-05-21 19:51:22 +01:00
QuickMythril	1e10bcf3b0	Merge branch 'Qortal:master' into upgrade-tls	2023-05-09 15:38:20 -04:00
QuickMythril	8f847d3689	Upgraded to TLSv1.3	2023-04-21 19:30:29 -04:00
Nuc1eoN	0693e26cda	Update/add German translation	2022-10-09 15:34:20 +02:00