Bump version to 3.5.0

This rewrite may have been causing problems with connections in the network, due to peers being forgotten too easily. Reverting for now to see if it solves the problem.

This reverts commit d81071f254.

# Conflicts:
#	src/main/java/org/qortal/network/Network.java

.gitignore

@@ -28,6 +28,7 @@
 /WindowsInstaller/Install Files/qortal.jar
 /*.7z
 /tmp
+/wallets
 /data*
 /src/test/resources/arbitrary/*/.qortal/cache
 apikey.txt

WindowsInstaller/Qortal.aip

@@ -17,10 +17,10 @@
     <ROW Property="Manufacturer" Value="Qortal"/>
     <ROW Property="MsiLogging" MultiBuildValue="DefaultBuild:vp"/>
     <ROW Property="NTP_GOOD" Value="false"/>
-    <ROW Property="ProductCode" Value="1033:{5FC8DCC3-BF9C-4D72-8C6D-940340ACD1B8} 1049:{1DEF14AB-2397-4517-B3C8-13221B921753} 2052:{B9E3C1DF-C92D-440A-9A21-869582F8585F} 2057:{91D69E7B-CA7D-4449-8E8A-F22DCEA546FC} " Type="16"/>
+    <ROW Property="ProductCode" Value="1033:{E5597539-098E-4BA6-99DF-4D22018BC0D3} 1049:{2B5E55A2-142A-4BED-B3B9-5657162282B7} 2052:{6F19171F-4743-4127-B191-AAFA3FA885D2} 2057:{A1B3108D-EC5D-47A1-AEE4-DBD956E682FB} " Type="16"/>
     <ROW Property="ProductLanguage" Value="2057"/>
     <ROW Property="ProductName" Value="Qortal"/>
-    <ROW Property="ProductVersion" Value="3.1.1" Type="32"/>
+    <ROW Property="ProductVersion" Value="3.4.3" Type="32"/>
     <ROW Property="RECONFIG_NTP" Value="true"/>
     <ROW Property="REMOVE_BLOCKCHAIN" Value="YES" Type="4"/>
     <ROW Property="REPAIR_BLOCKCHAIN" Value="YES" Type="4"/>
@@ -212,7 +212,7 @@
     <ROW Component="ADDITIONAL_LICENSE_INFO_71" ComponentId="{12A3ADBE-BB7A-496C-8869-410681E6232F}" Directory_="jdk.zipfs_Dir" Attributes="0" KeyPath="ADDITIONAL_LICENSE_INFO_71" Type="0"/>
     <ROW Component="ADDITIONAL_LICENSE_INFO_8" ComponentId="{D53AD95E-CF96-4999-80FC-5812277A7456}" Directory_="java.naming_Dir" Attributes="0" KeyPath="ADDITIONAL_LICENSE_INFO_8" Type="0"/>
     <ROW Component="ADDITIONAL_LICENSE_INFO_9" ComponentId="{6B7EA9B0-5D17-47A8-B78C-FACE86D15E01}" Directory_="java.net.http_Dir" Attributes="0" KeyPath="ADDITIONAL_LICENSE_INFO_9" Type="0"/>
-    <ROW Component="AI_CustomARPName" ComponentId="{42F5EC19-E46F-4299-B9F7-6E1112F6E4FB}" Directory_="APPDIR" Attributes="260" KeyPath="DisplayName" Options="1"/>
+    <ROW Component="AI_CustomARPName" ComponentId="{F17029E8-CCC4-456D-B4AC-1854C81C46B6}" Directory_="APPDIR" Attributes="260" KeyPath="DisplayName" Options="1"/>
     <ROW Component="AI_ExePath" ComponentId="{3644948D-AE0B-41BB-9FAF-A79E70490A08}" Directory_="APPDIR" Attributes="260" KeyPath="AI_ExePath"/>
     <ROW Component="APPDIR" ComponentId="{680DFDDE-3FB4-47A5-8FF5-934F576C6F91}" Directory_="APPDIR" Attributes="0"/>
     <ROW Component="AccessBridgeCallbacks.h" ComponentId="{288055D1-1062-47A3-AA44-5601B4E38AED}" Directory_="bridge_Dir" Attributes="0" KeyPath="AccessBridgeCallbacks.h" Type="0"/>

pom.xml

@@ -3,13 +3,13 @@
 	<modelVersion>4.0.0</modelVersion>
 	<groupId>org.qortal</groupId>
 	<artifactId>qortal</artifactId>
-	<version>3.2.0</version>
+	<version>3.5.0</version>
 	<packaging>jar</packaging>
 	<properties>
 		<skipTests>true</skipTests>
-		<altcoinj.version>bf9fb80</altcoinj.version>
+		<altcoinj.version>7dc8c6f</altcoinj.version>
 		<bitcoinj.version>0.15.10</bitcoinj.version>
-		<bouncycastle.version>1.64</bouncycastle.version>
+		<bouncycastle.version>1.69</bouncycastle.version>
 		<build.timestamp>${maven.build.timestamp}</build.timestamp>
 		<ciyam-at.version>1.3.8</ciyam-at.version>
 		<commons-net.version>3.6</commons-net.version>
@@ -21,6 +21,8 @@
 		<dagger.version>1.2.2</dagger.version>
 		<guava.version>28.1-jre</guava.version>
 		<hsqldb.version>2.5.1</hsqldb.version>
+		<homoglyph.version>1.2.1</homoglyph.version>
+		<icu4j.version>70.1</icu4j.version>
 		<upnp.version>1.1</upnp.version>
 		<jersey.version>2.29.1</jersey.version>
 		<jetty.version>9.4.29.v20200521</jetty.version>
@@ -32,6 +34,8 @@
 		<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>
 	</properties>
 	<build>
 		<sourceDirectory>src/main/java</sourceDirectory>
@@ -442,7 +446,7 @@
 		</dependency>
 		<!-- For Litecoin, etc. support, requires bitcoinj -->
 		<dependency>
-			<groupId>com.github.jjos2372</groupId>
+			<groupId>com.github.qortal</groupId>
 			<artifactId>altcoinj</artifactId>
 			<version>${altcoinj.version}</version>
 		</dependency>
@@ -568,7 +572,18 @@
 		<dependency>
 			<groupId>net.codebox</groupId>
 			<artifactId>homoglyph</artifactId>
-			<version>1.2.0</version>
+			<version>${homoglyph.version}</version>
+		</dependency>
+		<!-- Unicode support -->
+		<dependency>
+			<groupId>com.ibm.icu</groupId>
+			<artifactId>icu4j</artifactId>
+			<version>${icu4j.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>com.ibm.icu</groupId>
+			<artifactId>icu4j-charset</artifactId>
+			<version>${icu4j.version}</version>
 		</dependency>
 		<!-- Jetty -->
 		<dependency>
@@ -692,5 +707,25 @@
 			<artifactId>java-diff-utils</artifactId>
 			<version>${java-diff-utils.version}</version>
 		</dependency>
+		<dependency>
+			<groupId>io.grpc</groupId>
+			<artifactId>grpc-netty</artifactId>
+			<version>${grpc.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>io.grpc</groupId>
+			<artifactId>grpc-protobuf</artifactId>
+			<version>${grpc.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>io.grpc</groupId>
+			<artifactId>grpc-stub</artifactId>
+			<version>${grpc.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>com.google.protobuf</groupId>
+			<artifactId>protobuf-java</artifactId>
+			<version>${protobuf.version}</version>
+		</dependency>
 	</dependencies>
 </project>

src/main/java/com/rust/litewalletjni/LiteWalletJni.java

@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) 2009 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * LiteWalletJni code based on https://github.com/PirateNetwork/cordova-plugin-litewallet
+ *
+ * MIT License
+ *
+ * Copyright (c) 2020 Zero Currency Coin
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.rust.litewalletjni;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.qortal.controller.PirateChainWalletController;
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+public class LiteWalletJni {
+
+    protected static final Logger LOGGER = LogManager.getLogger(LiteWalletJni.class);
+
+    public static native String initlogging();
+    public static native String initnew(final String serveruri, final String params, final String saplingOutputb64, final String saplingSpendb64);
+    public static native String initfromseed(final String serveruri, final String params, final String seed, final String birthday, final String saplingOutputb64, final String saplingSpendb64);
+    public static native String initfromb64(final String serveruri, final String params, final String datab64, final String saplingOutputb64, final String saplingSpendb64);
+    public static native String save();
+
+    public static native String execute(final String cmd, final String args);
+    public static native String getseedphrase();
+    public static native String getseedphrasefromentropyb64(final String entropy64);
+    public static native String checkseedphrase(final String input);
+
+
+    private static boolean loaded = false;
+
+    public static void loadLibrary() {
+        if (loaded) {
+            return;
+        }
+        String osName = System.getProperty("os.name");
+        String osArchitecture = System.getProperty("os.arch");
+
+        LOGGER.info("OS Name: {}", osName);
+        LOGGER.info("OS Architecture: {}", osArchitecture);
+
+        try {
+            String libFileName = PirateChainWalletController.getRustLibFilename();
+            if (libFileName == null) {
+                LOGGER.info("Library not found for OS: {}, arch: {}", osName, osArchitecture);
+                return;
+            }
+
+            Path libPath = Paths.get(PirateChainWalletController.getRustLibOuterDirectory().toString(), libFileName);
+            System.load(libPath.toAbsolutePath().toString());
+            loaded = true;
+        }
+        catch (UnsatisfiedLinkError e) {
+            LOGGER.info("Unable to load library");
+        }
+    }
+
+    public static boolean isLoaded() {
+        return loaded;
+    }
+
+}

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

@@ -8,6 +8,7 @@ import java.nio.file.Paths;
 import java.nio.file.StandardCopyOption;
 import java.security.Security;
 import java.util.*;
+import java.util.stream.Collectors;
 
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
@@ -18,6 +19,8 @@ import org.qortal.api.ApiRequest;
 import org.qortal.controller.AutoUpdate;
 import org.qortal.settings.Settings;
 
+import static org.qortal.controller.AutoUpdate.AGENTLIB_JVM_HOLDER_ARG;
+
 public class ApplyUpdate {
 
 	static {
@@ -37,7 +40,7 @@ public class ApplyUpdate {
 	private static final String JAVA_TOOL_OPTIONS_NAME = "JAVA_TOOL_OPTIONS";
 	private static final String JAVA_TOOL_OPTIONS_VALUE = "-XX:MaxRAMFraction=4";
 
-	private static final long CHECK_INTERVAL = 10 * 1000L; // ms
+	private static final long CHECK_INTERVAL = 30 * 1000L; // ms
 	private static final int MAX_ATTEMPTS = 12;
 
 	public static void main(String[] args) {
@@ -197,6 +200,11 @@ public class ApplyUpdate {
 			// JVM arguments
 			javaCmd.addAll(ManagementFactory.getRuntimeMXBean().getInputArguments());
 
+			// Reapply any retained, but disabled, -agentlib JVM arg
+			javaCmd = javaCmd.stream()
+					.map(arg -> arg.replace(AGENTLIB_JVM_HOLDER_ARG, "-agentlib"))
+					.collect(Collectors.toList());
+
 			// Call mainClass in JAR
 			javaCmd.addAll(Arrays.asList("-jar", JAR_FILENAME));
 
@@ -205,7 +213,7 @@ public class ApplyUpdate {
 		}
 
 		try {
-			LOGGER.info(() -> String.format("Restarting node with: %s", String.join(" ", javaCmd)));
+			LOGGER.info(String.format("Restarting node with: %s", String.join(" ", javaCmd)));
 
 			ProcessBuilder processBuilder = new ProcessBuilder(javaCmd);
 
@@ -214,8 +222,15 @@ public class ApplyUpdate {
 				processBuilder.environment().put(JAVA_TOOL_OPTIONS_NAME, JAVA_TOOL_OPTIONS_VALUE);
 			}
 
-			processBuilder.start();
-		} catch (IOException e) {
+			// New process will inherit our stdout and stderr
+			processBuilder.redirectOutput(ProcessBuilder.Redirect.INHERIT);
+			processBuilder.redirectError(ProcessBuilder.Redirect.INHERIT);
+
+			Process process = processBuilder.start();
+
+			// Nothing to pipe to new process, so close output stream (process's stdin)
+			process.getOutputStream().close();
+		} catch (Exception e) {
 			LOGGER.error(String.format("Failed to restart node (BAD): %s", e.getMessage()));
 		}
 	}

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

@@ -8,11 +8,13 @@ import javax.xml.bind.annotation.XmlAccessorType;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.qortal.block.BlockChain;
+import org.qortal.controller.LiteNode;
 import org.qortal.data.account.AccountBalanceData;
 import org.qortal.data.account.AccountData;
 import org.qortal.data.account.RewardShareData;
 import org.qortal.repository.DataException;
 import org.qortal.repository.Repository;
+import org.qortal.settings.Settings;
 import org.qortal.utils.Base58;
 
 @XmlAccessorType(XmlAccessType.NONE) // Stops JAX-RS errors when unmarshalling blockchain config
@@ -59,7 +61,17 @@ public class Account {
 	// Balance manipulations - assetId is 0 for QORT
 
 	public long getConfirmedBalance(long assetId) throws DataException {
-		AccountBalanceData accountBalanceData = this.repository.getAccountRepository().getBalance(this.address, assetId);
+		AccountBalanceData accountBalanceData;
+
+		if (Settings.getInstance().isLite()) {
+			// Lite nodes request data from peers instead of the local db
+			accountBalanceData = LiteNode.getInstance().fetchAccountBalance(this.address, assetId);
+		}
+		else {
+			// All other node types fetch from the local db
+			accountBalanceData = this.repository.getAccountRepository().getBalance(this.address, assetId);
+		}
+
 		if (accountBalanceData == null)
 			return 0;
 
@@ -205,6 +217,12 @@ public class Account {
 		return false;
 	}
 
+	/** Returns account's blockMinted (0+) or null if account not found in repository. */
+	public Integer getBlocksMinted() throws DataException {
+		return this.repository.getAccountRepository().getMintedBlockCount(this.address);
+	}
+
+
 	/** Returns whether account can build reward-shares.
 	 * <p>
 	 * To be able to create reward-shares, the account needs to pass at least one of these tests:<br>

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

@@ -11,15 +11,15 @@ public class PrivateKeyAccount extends PublicKeyAccount {
 	private final Ed25519PrivateKeyParameters edPrivateKeyParams;
 
 	/**
-	 * Create PrivateKeyAccount using byte[32] seed.
+	 * Create PrivateKeyAccount using byte[32] private key.
 	 * 
-	 * @param seed
+	 * @param privateKey
 	 *            byte[32] used to create private/public key pair
 	 * @throws IllegalArgumentException
-	 *             if passed invalid seed
+	 *             if passed invalid privateKey
 	 */
-	public PrivateKeyAccount(Repository repository, byte[] seed) {
-		this(repository, new Ed25519PrivateKeyParameters(seed, 0));
+	public PrivateKeyAccount(Repository repository, byte[] privateKey) {
+		this(repository, new Ed25519PrivateKeyParameters(privateKey, 0));
 	}
 
 	private PrivateKeyAccount(Repository repository, Ed25519PrivateKeyParameters edPrivateKeyParams) {
@@ -37,10 +37,6 @@ public class PrivateKeyAccount extends PublicKeyAccount {
 		return this.privateKey;
 	}
 
-	public static byte[] toPublicKey(byte[] seed) {
-		return new Ed25519PrivateKeyParameters(seed, 0).generatePublicKey().getEncoded();
-	}
-
 	public byte[] sign(byte[] message) {
 		return Crypto.sign(this.edPrivateKeyParams, message);
 	}

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

@@ -12,6 +12,7 @@ public class NodeInfo {
 	public long buildTimestamp;
 	public String nodeId;
 	public boolean isTestNet;
+	public String type;
 
 	public NodeInfo() {
 	}

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

@@ -4,6 +4,7 @@ import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
 
 import org.qortal.controller.Controller;
+import org.qortal.controller.OnlineAccountsManager;
 import org.qortal.controller.Synchronizer;
 import org.qortal.network.Network;
 
@@ -21,12 +22,12 @@ public class NodeStatus {
 	public final int height;
 
 	public NodeStatus() {
-		this.isMintingPossible = Controller.getInstance().isMintingPossible();
+		this.isMintingPossible = OnlineAccountsManager.getInstance().hasActiveOnlineAccountSignatures();
 
 		this.syncPercent = Synchronizer.getInstance().getSyncPercent();
-		this.isSynchronizing = this.syncPercent != null;
+		this.isSynchronizing = Synchronizer.getInstance().isSynchronizing();
 
-		this.numberOfConnections = Network.getInstance().getHandshakedPeers().size();
+		this.numberOfConnections = Network.getInstance().getImmutableHandshakedPeers().size();
 
 		this.height = Controller.getInstance().getChainHeight();
 	}

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

@@ -0,0 +1,29 @@
+package org.qortal.api.model.crosschain;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+public class DigibyteSendRequest {
+
+	@Schema(description = "Digibyte BIP32 extended private key", example = "tprv___________________________________________________________________________________________________________")
+	public String xprv58;
+
+	@Schema(description = "Recipient's Digibyte address ('legacy' P2PKH only)", example = "1DigByteEaterAddressDontSendf59kuE")
+	public String receivingAddress;
+
+	@Schema(description = "Amount of DGB to send", type = "number")
+	@XmlJavaTypeAdapter(value = org.qortal.api.AmountTypeAdapter.class)
+	public long digibyteAmount;
+
+	@Schema(description = "Transaction fee per byte (optional). Default is 0.00000100 DGB (100 sats) per byte", example = "0.00000100", type = "number")
+	@XmlJavaTypeAdapter(value = org.qortal.api.AmountTypeAdapter.class)
+	public Long feePerByte;
+
+	public DigibyteSendRequest() {
+	}
+
+}

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

@@ -0,0 +1,32 @@
+package org.qortal.api.model.crosschain;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+public class PirateChainSendRequest {
+
+	@Schema(description = "32 bytes of entropy, Base58 encoded", example = "5oSXF53qENtdUyKhqSxYzP57m6RhVFP9BJKRr9E5kRGV")
+	public String entropy58;
+
+	@Schema(description = "Recipient's Pirate Chain address", example = "zc...")
+	public String receivingAddress;
+
+	@Schema(description = "Amount of ARRR to send", type = "number")
+	@XmlJavaTypeAdapter(value = org.qortal.api.AmountTypeAdapter.class)
+	public long arrrAmount;
+
+	@Schema(description = "Transaction fee per byte (optional). Default is 0.00000100 ARRR (100 sats) per byte", example = "0.00000100", type = "number")
+	@XmlJavaTypeAdapter(value = org.qortal.api.AmountTypeAdapter.class)
+	public Long feePerByte;
+
+	@Schema(description = "Optional memo to include information for the recipient", example = "zc...")
+	public String memo;
+
+	public PirateChainSendRequest() {
+	}
+
+}

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

@@ -0,0 +1,29 @@
+package org.qortal.api.model.crosschain;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+public class RavencoinSendRequest {
+
+	@Schema(description = "Ravencoin BIP32 extended private key", example = "tprv___________________________________________________________________________________________________________")
+	public String xprv58;
+
+	@Schema(description = "Recipient's Ravencoin address ('legacy' P2PKH only)", example = "1RvnCoinEaterAddressDontSendf59kuE")
+	public String receivingAddress;
+
+	@Schema(description = "Amount of RVN to send", type = "number")
+	@XmlJavaTypeAdapter(value = org.qortal.api.AmountTypeAdapter.class)
+	public long ravencoinAmount;
+
+	@Schema(description = "Transaction fee per byte (optional). Default is 0.00000100 RVN (100 sats) per byte", example = "0.00000100", type = "number")
+	@XmlJavaTypeAdapter(value = org.qortal.api.AmountTypeAdapter.class)
+	public Long feePerByte;
+
+	public RavencoinSendRequest() {
+	}
+
+}

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

@@ -30,7 +30,8 @@ import org.qortal.api.Security;
 import org.qortal.api.model.ApiOnlineAccount;
 import org.qortal.api.model.RewardShareKeyRequest;
 import org.qortal.asset.Asset;
-import org.qortal.controller.Controller;
+import org.qortal.controller.LiteNode;
+import org.qortal.controller.OnlineAccountsManager;
 import org.qortal.crypto.Crypto;
 import org.qortal.data.account.AccountData;
 import org.qortal.data.account.RewardShareData;
@@ -109,18 +110,26 @@ public class AddressesResource {
 		if (!Crypto.isValidAddress(address))
 			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_ADDRESS);
 
-		byte[] lastReference = null;
+		AccountData accountData;
 
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			AccountData accountData = repository.getAccountRepository().getAccount(address);
-			// Not found?
-			if (accountData == null)
-				throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.ADDRESS_UNKNOWN);
-
-			lastReference = accountData.getReference();
-		} catch (DataException e) {
-			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.REPOSITORY_ISSUE, e);
+		if (Settings.getInstance().isLite()) {
+			// Lite nodes request data from peers instead of the local db
+			accountData = LiteNode.getInstance().fetchAccountData(address);
 		}
+		else {
+			// All other node types request data from local db
+			try (final Repository repository = RepositoryManager.getRepository()) {
+				accountData = repository.getAccountRepository().getAccount(address);
+			} catch (DataException e) {
+				throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.REPOSITORY_ISSUE, e);
+			}
+		}
+
+		// Not found?
+		if (accountData == null)
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.ADDRESS_UNKNOWN);
+
+		byte[] lastReference = accountData.getReference();
 
 		if (lastReference == null || lastReference.length == 0)
 			return "false";
@@ -156,7 +165,7 @@ public class AddressesResource {
 	)
 	@ApiErrors({ApiError.PUBLIC_KEY_NOT_FOUND, ApiError.REPOSITORY_ISSUE})
 	public List<ApiOnlineAccount> getOnlineAccounts() {
-		List<OnlineAccountData> onlineAccounts = Controller.getInstance().getOnlineAccounts();
+		List<OnlineAccountData> onlineAccounts = OnlineAccountsManager.getInstance().getOnlineAccounts();
 
 		// Map OnlineAccountData entries to OnlineAccount via reward-share data
 		try (final Repository repository = RepositoryManager.getRepository()) {
@@ -191,7 +200,7 @@ public class AddressesResource {
 	)
 	@ApiErrors({ApiError.PUBLIC_KEY_NOT_FOUND, ApiError.REPOSITORY_ISSUE})
 	public List<OnlineAccountLevel> getOnlineAccountsByLevel() {
-		List<OnlineAccountData> onlineAccounts = Controller.getInstance().getOnlineAccounts();
+		List<OnlineAccountData> onlineAccounts = OnlineAccountsManager.getInstance().getOnlineAccounts();
 
 		try (final Repository repository = RepositoryManager.getRepository()) {
 			List<OnlineAccountLevel> onlineAccountLevels = new ArrayList<>();

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

@@ -35,7 +35,6 @@ import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.core.LoggerContext;
 import org.apache.logging.log4j.core.appender.RollingFileAppender;
-import org.checkerframework.checker.units.qual.A;
 import org.qortal.account.Account;
 import org.qortal.account.PrivateKeyAccount;
 import org.qortal.api.*;
@@ -120,10 +119,23 @@ public class AdminResource {
 		nodeInfo.buildTimestamp = Controller.getInstance().getBuildTimestamp();
 		nodeInfo.nodeId = Network.getInstance().getOurNodeId();
 		nodeInfo.isTestNet = Settings.getInstance().isTestNet();
+		nodeInfo.type = getNodeType();
 
 		return nodeInfo;
 	}
 
+	private String getNodeType() {
+		if (Settings.getInstance().isLite()) {
+			return "lite";
+		}
+		else if (Settings.getInstance().isTopOnly()) {
+			return "topOnly";
+		}
+		else {
+			return "full";
+		}
+	}
+
 	@GET
 	@Path("/status")
 	@Operation(
@@ -382,6 +394,10 @@ public class AdminResource {
 			) @QueryParam("limit") Integer limit, @Parameter(
 				ref = "offset"
 			) @QueryParam("offset") Integer offset, @Parameter(
+				name = "tail",
+				description = "Fetch most recent log lines",
+				schema = @Schema(type = "boolean")
+			) @QueryParam("tail") Boolean tail, @Parameter(
 				ref = "reverse"
 			) @QueryParam("reverse") Boolean reverse) {
 		LoggerContext loggerContext = (LoggerContext) LogManager.getContext();
@@ -397,6 +413,13 @@ public class AdminResource {
 			if (reverse != null && reverse)
 				logLines = Lists.reverse(logLines);
 
+			// Tail mode - return the last X lines (where X = limit)
+			if (tail != null && tail) {
+				if (limit != null && limit > 0) {
+					offset = logLines.size() - limit;
+				}
+			}
+
 			// offset out of bounds?
 			if (offset != null && (offset < 0 || offset >= logLines.size()))
 				return "";
@@ -417,7 +440,7 @@ public class AdminResource {
 
 			limit = Math.min(limit, logLines.size());
 
-			logLines.subList(limit - 1, logLines.size()).clear();
+			logLines.subList(limit, logLines.size()).clear();
 
 			return String.join("\n", logLines);
 		} catch (IOException e) {
@@ -514,7 +537,7 @@ public class AdminResource {
 			PeerAddress peerAddress = PeerAddress.fromString(targetPeerAddress);
 			InetSocketAddress resolvedAddress = peerAddress.toSocketAddress();
 
-			List<Peer> peers = Network.getInstance().getHandshakedPeers();
+			List<Peer> peers = Network.getInstance().getImmutableHandshakedPeers();
 			Peer targetPeer = peers.stream().filter(peer -> peer.getResolvedAddress().equals(resolvedAddress)).findFirst().orElse(null);
 
 			if (targetPeer == null)
@@ -589,10 +612,6 @@ public class AdminResource {
 	public String importRepository(@HeaderParam(Security.API_KEY_HEADER) String apiKey, String filename) {
 		Security.checkApiCallAllowed(request);
 
-		// Hard-coded because it's too dangerous to allow user-supplied filenames in weaker security contexts
-		if (Settings.getInstance().getApiKey() == null)
-			filename = "qortal-backup/TradeBotStates.json";
-
 		try (final Repository repository = RepositoryManager.getRepository()) {
 			ReentrantLock blockchainLock = Controller.getInstance().getBlockchainLock();
 

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

@@ -12,7 +12,6 @@ import io.swagger.v3.oas.annotations.security.SecurityRequirement;
 import io.swagger.v3.oas.annotations.tags.Tag;
 
 import java.io.*;
-import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.nio.file.Paths;
 import java.util.ArrayList;
@@ -56,7 +55,9 @@ import org.qortal.transaction.Transaction.ValidationResult;
 import org.qortal.transform.TransformationException;
 import org.qortal.transform.transaction.ArbitraryTransactionTransformer;
 import org.qortal.transform.transaction.TransactionTransformer;
+import org.qortal.utils.ArbitraryTransactionUtils;
 import org.qortal.utils.Base58;
+import org.qortal.utils.NTP;
 import org.qortal.utils.ZipUtils;
 
 @Path("/arbitrary")
@@ -253,7 +254,7 @@ public class ArbitraryResource {
 															@QueryParam("build") Boolean build) {
 
 		Security.requirePriorAuthorizationOrApiKey(request, name, service, null);
-		return this.getStatus(service, name, null, build);
+		return ArbitraryTransactionUtils.getStatus(service, name, null, build);
 	}
 
 	@GET
@@ -275,7 +276,7 @@ public class ArbitraryResource {
 													 @QueryParam("build") Boolean build) {
 
 		Security.requirePriorAuthorizationOrApiKey(request, name, service, identifier);
-		return this.getStatus(service, name, identifier, build);
+		return ArbitraryTransactionUtils.getStatus(service, name, identifier, build);
 	}
 
 
@@ -1099,7 +1100,8 @@ public class ArbitraryResource {
 				throw ApiExceptionFactory.INSTANCE.createCustomException(request, ApiError.INVALID_CRITERIA, error);
 			}
 
-			if (!Controller.getInstance().isUpToDate()) {
+			final Long minLatestBlockTimestamp = NTP.getTime() - (60 * 60 * 1000L);
+			if (!Controller.getInstance().isUpToDate(minLatestBlockTimestamp)) {
 				throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.BLOCKCHAIN_NEEDS_SYNC);
 			}
 
@@ -1245,35 +1247,23 @@ public class ArbitraryResource {
 	}
 
 
-	private ArbitraryResourceStatus getStatus(Service service, String name, String identifier, Boolean build) {
-
-		// If "build=true" has been specified in the query string, build the resource before returning its status
-		if (build != null && build == true) {
-			ArbitraryDataReader reader = new ArbitraryDataReader(name, ArbitraryDataFile.ResourceIdType.NAME, service, null);
-			try {
-				if (!reader.isBuilding()) {
-					reader.loadSynchronously(false);
-				}
-			} catch (Exception e) {
-				// No need to handle exception, as it will be reflected in the status
-			}
-		}
-
-		ArbitraryDataResource resource = new ArbitraryDataResource(name, ResourceIdType.NAME, service, identifier);
-		return resource.getStatus(false);
-	}
-
 	private List<ArbitraryResourceInfo> addStatusToResources(List<ArbitraryResourceInfo> resources) {
 		// Determine and add the status of each resource
 		List<ArbitraryResourceInfo> updatedResources = new ArrayList<>();
 		for (ArbitraryResourceInfo resourceInfo : resources) {
-			ArbitraryDataResource resource = new ArbitraryDataResource(resourceInfo.name, ResourceIdType.NAME,
-					resourceInfo.service, resourceInfo.identifier);
-			ArbitraryResourceStatus status = resource.getStatus(true);
-			if (status != null) {
-				resourceInfo.status = status;
+			try {
+				ArbitraryDataResource resource = new ArbitraryDataResource(resourceInfo.name, ResourceIdType.NAME,
+						resourceInfo.service, resourceInfo.identifier);
+				ArbitraryResourceStatus status = resource.getStatus(true);
+				if (status != null) {
+					resourceInfo.status = status;
+				}
+				updatedResources.add(resourceInfo);
+
+			} catch (Exception e) {
+				// Catch and log all exceptions, since some systems are experiencing 500 errors when including statuses
+				LOGGER.info("Caught exception when adding status to resource %s: %s", resourceInfo, e.toString());
 			}
-			updatedResources.add(resourceInfo);
 		}
 		return updatedResources;
 	}

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

@@ -114,7 +114,7 @@ public class BlocksResource {
 	@Path("/signature/{signature}/data")
 	@Operation(
 			summary = "Fetch serialized, base58 encoded block data using base58 signature",
-			description = "Returns serialized data for the block that matches the given signature",
+			description = "Returns serialized data for the block that matches the given signature, and an optional block serialization version",
 			responses = {
 					@ApiResponse(
 							description = "the block data",
@@ -125,7 +125,7 @@ public class BlocksResource {
 	@ApiErrors({
 			ApiError.INVALID_SIGNATURE, ApiError.BLOCK_UNKNOWN, ApiError.INVALID_DATA, ApiError.REPOSITORY_ISSUE
 	})
-	public String getSerializedBlockData(@PathParam("signature") String signature58) {
+	public String getSerializedBlockData(@PathParam("signature") String signature58, @QueryParam("version") Integer version) {
 		// Decode signature
 		byte[] signature;
 		try {
@@ -136,20 +136,41 @@ public class BlocksResource {
 
 		try (final Repository repository = RepositoryManager.getRepository()) {
 
+			// Default to version 1
+			if (version == null) {
+				version = 1;
+			}
+
             // Check the database first
 			BlockData blockData = repository.getBlockRepository().fromSignature(signature);
 			if (blockData != null) {
                 Block block = new Block(repository, blockData);
                 ByteArrayOutputStream bytes = new ByteArrayOutputStream();
                 bytes.write(Ints.toByteArray(block.getBlockData().getHeight()));
-                bytes.write(BlockTransformer.toBytes(block));
+
+				switch (version) {
+					case 1:
+						bytes.write(BlockTransformer.toBytes(block));
+						break;
+
+					case 2:
+						bytes.write(BlockTransformer.toBytesV2(block));
+						break;
+
+					default:
+						throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_CRITERIA);
+				}
+
                 return Base58.encode(bytes.toByteArray());
             }
 
             // Not found, so try the block archive
             byte[] bytes = BlockArchiveReader.getInstance().fetchSerializedBlockBytesForSignature(signature, false, repository);
             if (bytes != null) {
-                return Base58.encode(bytes);
+				if (version != 1) {
+					throw ApiExceptionFactory.INSTANCE.createCustomException(request, ApiError.INVALID_CRITERIA, "Archived blocks require version 1");
+				}
+				return Base58.encode(bytes);
             }
 
             throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.BLOCK_UNKNOWN);

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

@@ -0,0 +1,177 @@
+package org.qortal.api.resource;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.media.ArraySchema;
+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.security.SecurityRequirement;
+import io.swagger.v3.oas.annotations.tags.Tag;
+
+import java.util.List;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.ws.rs.HeaderParam;
+import javax.ws.rs.POST;
+import javax.ws.rs.Path;
+import javax.ws.rs.core.Context;
+import javax.ws.rs.core.MediaType;
+
+import org.bitcoinj.core.Transaction;
+import org.qortal.api.ApiError;
+import org.qortal.api.ApiErrors;
+import org.qortal.api.ApiExceptionFactory;
+import org.qortal.api.Security;
+import org.qortal.api.model.crosschain.DigibyteSendRequest;
+import org.qortal.crosschain.Digibyte;
+import org.qortal.crosschain.ForeignBlockchainException;
+import org.qortal.crosschain.SimpleTransaction;
+
+@Path("/crosschain/dgb")
+@Tag(name = "Cross-Chain (Digibyte)")
+public class CrossChainDigibyteResource {
+
+	@Context
+	HttpServletRequest request;
+
+	@POST
+	@Path("/walletbalance")
+	@Operation(
+		summary = "Returns DGB balance for hierarchical, deterministic BIP32 wallet",
+		description = "Supply BIP32 'm' private/public key in base58, starting with 'xprv'/'xpub' for mainnet, 'tprv'/'tpub' for testnet",
+		requestBody = @RequestBody(
+			required = true,
+			content = @Content(
+				mediaType = MediaType.TEXT_PLAIN,
+				schema = @Schema(
+					type = "string",
+					description = "BIP32 'm' private/public key in base58",
+					example = "tpubD6NzVbkrYhZ4XTPc4btCZ6SMgn8CxmWkj6VBVZ1tfcJfMq4UwAjZbG8U74gGSypL9XBYk2R2BLbDBe8pcEyBKM1edsGQEPKXNbEskZozeZc"
+				)
+			)
+		),
+		responses = {
+			@ApiResponse(
+				content = @Content(mediaType = MediaType.TEXT_PLAIN, schema = @Schema(type = "string", description = "balance (satoshis)"))
+			)
+		}
+	)
+	@ApiErrors({ApiError.INVALID_PRIVATE_KEY, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE})
+	@SecurityRequirement(name = "apiKey")
+	public String getDigibyteWalletBalance(@HeaderParam(Security.API_KEY_HEADER) String apiKey, String key58) {
+		Security.checkApiCallAllowed(request);
+
+		Digibyte digibyte = Digibyte.getInstance();
+
+		if (!digibyte.isValidDeterministicKey(key58))
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_PRIVATE_KEY);
+
+		try {
+			Long balance = digibyte.getWalletBalanceFromTransactions(key58);
+			if (balance == null)
+				throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE);
+
+			return balance.toString();
+
+		} catch (ForeignBlockchainException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE);
+		}
+	}
+
+	@POST
+	@Path("/wallettransactions")
+	@Operation(
+		summary = "Returns transactions for hierarchical, deterministic BIP32 wallet",
+		description = "Supply BIP32 'm' private/public key in base58, starting with 'xprv'/'xpub' for mainnet, 'tprv'/'tpub' for testnet",
+		requestBody = @RequestBody(
+			required = true,
+			content = @Content(
+				mediaType = MediaType.TEXT_PLAIN,
+				schema = @Schema(
+					type = "string",
+					description = "BIP32 'm' private/public key in base58",
+					example = "tpubD6NzVbkrYhZ4XTPc4btCZ6SMgn8CxmWkj6VBVZ1tfcJfMq4UwAjZbG8U74gGSypL9XBYk2R2BLbDBe8pcEyBKM1edsGQEPKXNbEskZozeZc"
+				)
+			)
+		),
+		responses = {
+			@ApiResponse(
+				content = @Content(array = @ArraySchema( schema = @Schema( implementation = SimpleTransaction.class ) ) )
+			)
+		}
+	)
+	@ApiErrors({ApiError.INVALID_PRIVATE_KEY, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE})
+	@SecurityRequirement(name = "apiKey")
+	public List<SimpleTransaction> getDigibyteWalletTransactions(@HeaderParam(Security.API_KEY_HEADER) String apiKey, String key58) {
+		Security.checkApiCallAllowed(request);
+
+		Digibyte digibyte = Digibyte.getInstance();
+
+		if (!digibyte.isValidDeterministicKey(key58))
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_PRIVATE_KEY);
+
+		try {
+			return digibyte.getWalletTransactions(key58);
+		} catch (ForeignBlockchainException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE);
+		}
+	}
+
+	@POST
+	@Path("/send")
+	@Operation(
+		summary = "Sends DGB from hierarchical, deterministic BIP32 wallet to specific address",
+		description = "Currently supports 'legacy' P2PKH Digibyte addresses and Native SegWit (P2WPKH) addresses. Supply BIP32 'm' private key in base58, starting with 'xprv' for mainnet, 'tprv' for testnet",
+		requestBody = @RequestBody(
+			required = true,
+			content = @Content(
+				mediaType = MediaType.APPLICATION_JSON,
+				schema = @Schema(
+					implementation = DigibyteSendRequest.class
+				)
+			)
+		),
+		responses = {
+			@ApiResponse(
+				content = @Content(mediaType = MediaType.TEXT_PLAIN, schema = @Schema(type = "string", description = "transaction hash"))
+			)
+		}
+	)
+	@ApiErrors({ApiError.INVALID_PRIVATE_KEY, ApiError.INVALID_CRITERIA, ApiError.INVALID_ADDRESS, ApiError.FOREIGN_BLOCKCHAIN_BALANCE_ISSUE, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE})
+	@SecurityRequirement(name = "apiKey")
+	public String sendBitcoin(@HeaderParam(Security.API_KEY_HEADER) String apiKey, DigibyteSendRequest digibyteSendRequest) {
+		Security.checkApiCallAllowed(request);
+
+		if (digibyteSendRequest.digibyteAmount <= 0)
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_CRITERIA);
+
+		if (digibyteSendRequest.feePerByte != null && digibyteSendRequest.feePerByte <= 0)
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_CRITERIA);
+
+		Digibyte digibyte = Digibyte.getInstance();
+
+		if (!digibyte.isValidAddress(digibyteSendRequest.receivingAddress))
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_ADDRESS);
+
+		if (!digibyte.isValidDeterministicKey(digibyteSendRequest.xprv58))
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_PRIVATE_KEY);
+
+		Transaction spendTransaction = digibyte.buildSpend(digibyteSendRequest.xprv58,
+				digibyteSendRequest.receivingAddress,
+				digibyteSendRequest.digibyteAmount,
+				digibyteSendRequest.feePerByte);
+
+		if (spendTransaction == null)
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_BALANCE_ISSUE);
+
+		try {
+			digibyte.broadcastTransaction(spendTransaction);
+		} catch (ForeignBlockchainException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE);
+		}
+
+		return spendTransaction.getTxId().toString();
+	}
+
+}

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

@@ -0,0 +1,229 @@
+package org.qortal.api.resource;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.media.ArraySchema;
+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.security.SecurityRequirement;
+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.api.Security;
+import org.qortal.api.model.crosschain.PirateChainSendRequest;
+import org.qortal.crosschain.ForeignBlockchainException;
+import org.qortal.crosschain.PirateChain;
+import org.qortal.crosschain.SimpleTransaction;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.ws.rs.HeaderParam;
+import javax.ws.rs.POST;
+import javax.ws.rs.Path;
+import javax.ws.rs.core.Context;
+import javax.ws.rs.core.MediaType;
+import java.util.List;
+
+@Path("/crosschain/arrr")
+@Tag(name = "Cross-Chain (Pirate Chain)")
+public class CrossChainPirateChainResource {
+
+	@Context
+	HttpServletRequest request;
+
+	@POST
+	@Path("/walletbalance")
+	@Operation(
+		summary = "Returns ARRR balance",
+		description = "Supply 32 bytes of entropy, Base58 encoded",
+		requestBody = @RequestBody(
+			required = true,
+			content = @Content(
+				mediaType = MediaType.TEXT_PLAIN,
+				schema = @Schema(
+						type = "string",
+						description = "32 bytes of entropy, Base58 encoded",
+						example = "5oSXF53qENtdUyKhqSxYzP57m6RhVFP9BJKRr9E5kRGV"
+				)
+			)
+		),
+		responses = {
+			@ApiResponse(
+				content = @Content(mediaType = MediaType.TEXT_PLAIN, schema = @Schema(type = "string", description = "balance (satoshis)"))
+			)
+		}
+	)
+	@ApiErrors({ApiError.INVALID_PRIVATE_KEY, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE})
+	@SecurityRequirement(name = "apiKey")
+	public String getPirateChainWalletBalance(@HeaderParam(Security.API_KEY_HEADER) String apiKey, String entropy58) {
+		Security.checkApiCallAllowed(request);
+
+		PirateChain pirateChain = PirateChain.getInstance();
+
+		try {
+			Long balance = pirateChain.getWalletBalance(entropy58);
+			if (balance == null)
+				throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE);
+
+			return balance.toString();
+
+		} catch (ForeignBlockchainException e) {
+			throw ApiExceptionFactory.INSTANCE.createCustomException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE, e.getMessage());
+		}
+	}
+
+	@POST
+	@Path("/wallettransactions")
+	@Operation(
+		summary = "Returns transactions",
+		description = "Supply 32 bytes of entropy, Base58 encoded",
+		requestBody = @RequestBody(
+			required = true,
+			content = @Content(
+				mediaType = MediaType.TEXT_PLAIN,
+				schema = @Schema(
+						type = "string",
+						description = "32 bytes of entropy, Base58 encoded",
+						example = "5oSXF53qENtdUyKhqSxYzP57m6RhVFP9BJKRr9E5kRGV"
+				)
+			)
+		),
+		responses = {
+			@ApiResponse(
+				content = @Content(array = @ArraySchema( schema = @Schema( implementation = SimpleTransaction.class ) ) )
+			)
+		}
+	)
+	@ApiErrors({ApiError.INVALID_PRIVATE_KEY, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE})
+	@SecurityRequirement(name = "apiKey")
+	public List<SimpleTransaction> getPirateChainWalletTransactions(@HeaderParam(Security.API_KEY_HEADER) String apiKey, String entropy58) {
+		Security.checkApiCallAllowed(request);
+
+		PirateChain pirateChain = PirateChain.getInstance();
+
+		try {
+			return pirateChain.getWalletTransactions(entropy58);
+		} catch (ForeignBlockchainException e) {
+			throw ApiExceptionFactory.INSTANCE.createCustomException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE, e.getMessage());
+		}
+	}
+
+	@POST
+	@Path("/send")
+	@Operation(
+		summary = "Sends ARRR from wallet",
+		description = "Currently supports 'legacy' P2PKH PirateChain addresses and Native SegWit (P2WPKH) addresses. Supply BIP32 'm' private key in base58, starting with 'xprv' for mainnet, 'tprv' for testnet",
+		requestBody = @RequestBody(
+			required = true,
+			content = @Content(
+				mediaType = MediaType.TEXT_PLAIN,
+				schema = @Schema(
+						type = "string",
+						description = "32 bytes of entropy, Base58 encoded",
+						example = "5oSXF53qENtdUyKhqSxYzP57m6RhVFP9BJKRr9E5kRGV"
+				)
+			)
+		),
+		responses = {
+			@ApiResponse(
+				content = @Content(mediaType = MediaType.TEXT_PLAIN, schema = @Schema(type = "string", description = "transaction hash"))
+			)
+		}
+	)
+	@ApiErrors({ApiError.INVALID_PRIVATE_KEY, ApiError.INVALID_CRITERIA, ApiError.INVALID_ADDRESS, ApiError.FOREIGN_BLOCKCHAIN_BALANCE_ISSUE, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE})
+	@SecurityRequirement(name = "apiKey")
+	public String sendBitcoin(@HeaderParam(Security.API_KEY_HEADER) String apiKey, PirateChainSendRequest pirateChainSendRequest) {
+		Security.checkApiCallAllowed(request);
+
+		if (pirateChainSendRequest.arrrAmount <= 0)
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_CRITERIA);
+
+		if (pirateChainSendRequest.feePerByte != null && pirateChainSendRequest.feePerByte <= 0)
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_CRITERIA);
+
+		PirateChain pirateChain = PirateChain.getInstance();
+
+		try {
+			return pirateChain.sendCoins(pirateChainSendRequest);
+
+		} catch (ForeignBlockchainException e) {
+			// TODO
+			throw ApiExceptionFactory.INSTANCE.createCustomException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE, e.getMessage());
+		}
+	}
+
+
+	@POST
+	@Path("/walletaddress")
+	@Operation(
+			summary = "Returns main wallet address",
+			description = "Supply 32 bytes of entropy, Base58 encoded",
+			requestBody = @RequestBody(
+					required = true,
+					content = @Content(
+							mediaType = MediaType.TEXT_PLAIN,
+							schema = @Schema(
+									type = "string",
+									description = "32 bytes of entropy, Base58 encoded",
+									example = "5oSXF53qENtdUyKhqSxYzP57m6RhVFP9BJKRr9E5kRGV"
+							)
+					)
+			),
+			responses = {
+					@ApiResponse(
+							content = @Content(array = @ArraySchema( schema = @Schema( implementation = SimpleTransaction.class ) ) )
+					)
+			}
+	)
+	@ApiErrors({ApiError.INVALID_PRIVATE_KEY, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE})
+	@SecurityRequirement(name = "apiKey")
+	public String getPirateChainWalletAddress(@HeaderParam(Security.API_KEY_HEADER) String apiKey, String entropy58) {
+		Security.checkApiCallAllowed(request);
+
+		PirateChain pirateChain = PirateChain.getInstance();
+
+		try {
+			return pirateChain.getWalletAddress(entropy58);
+		} catch (ForeignBlockchainException e) {
+			throw ApiExceptionFactory.INSTANCE.createCustomException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE, e.getMessage());
+		}
+	}
+
+
+	@POST
+	@Path("/syncstatus")
+	@Operation(
+			summary = "Returns synchronization status",
+			description = "Supply 32 bytes of entropy, Base58 encoded",
+			requestBody = @RequestBody(
+					required = true,
+					content = @Content(
+							mediaType = MediaType.TEXT_PLAIN,
+							schema = @Schema(
+									type = "string",
+									description = "32 bytes of entropy, Base58 encoded",
+									example = "5oSXF53qENtdUyKhqSxYzP57m6RhVFP9BJKRr9E5kRGV"
+							)
+					)
+			),
+			responses = {
+					@ApiResponse(
+							content = @Content(array = @ArraySchema( schema = @Schema( implementation = SimpleTransaction.class ) ) )
+					)
+			}
+	)
+	@ApiErrors({ApiError.INVALID_PRIVATE_KEY, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE})
+	@SecurityRequirement(name = "apiKey")
+	public String getPirateChainSyncStatus(@HeaderParam(Security.API_KEY_HEADER) String apiKey, String entropy58) {
+		Security.checkApiCallAllowed(request);
+
+		PirateChain pirateChain = PirateChain.getInstance();
+
+		try {
+			return pirateChain.getSyncStatus(entropy58);
+		} catch (ForeignBlockchainException e) {
+			throw ApiExceptionFactory.INSTANCE.createCustomException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE, e.getMessage());
+		}
+	}
+}

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

@@ -0,0 +1,177 @@
+package org.qortal.api.resource;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.media.ArraySchema;
+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.security.SecurityRequirement;
+import io.swagger.v3.oas.annotations.tags.Tag;
+
+import java.util.List;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.ws.rs.HeaderParam;
+import javax.ws.rs.POST;
+import javax.ws.rs.Path;
+import javax.ws.rs.core.Context;
+import javax.ws.rs.core.MediaType;
+
+import org.bitcoinj.core.Transaction;
+import org.qortal.api.ApiError;
+import org.qortal.api.ApiErrors;
+import org.qortal.api.ApiExceptionFactory;
+import org.qortal.api.Security;
+import org.qortal.api.model.crosschain.RavencoinSendRequest;
+import org.qortal.crosschain.Ravencoin;
+import org.qortal.crosschain.ForeignBlockchainException;
+import org.qortal.crosschain.SimpleTransaction;
+
+@Path("/crosschain/rvn")
+@Tag(name = "Cross-Chain (Ravencoin)")
+public class CrossChainRavencoinResource {
+
+	@Context
+	HttpServletRequest request;
+
+	@POST
+	@Path("/walletbalance")
+	@Operation(
+		summary = "Returns RVN balance for hierarchical, deterministic BIP32 wallet",
+		description = "Supply BIP32 'm' private/public key in base58, starting with 'xprv'/'xpub' for mainnet, 'tprv'/'tpub' for testnet",
+		requestBody = @RequestBody(
+			required = true,
+			content = @Content(
+				mediaType = MediaType.TEXT_PLAIN,
+				schema = @Schema(
+					type = "string",
+					description = "BIP32 'm' private/public key in base58",
+					example = "tpubD6NzVbkrYhZ4XTPc4btCZ6SMgn8CxmWkj6VBVZ1tfcJfMq4UwAjZbG8U74gGSypL9XBYk2R2BLbDBe8pcEyBKM1edsGQEPKXNbEskZozeZc"
+				)
+			)
+		),
+		responses = {
+			@ApiResponse(
+				content = @Content(mediaType = MediaType.TEXT_PLAIN, schema = @Schema(type = "string", description = "balance (satoshis)"))
+			)
+		}
+	)
+	@ApiErrors({ApiError.INVALID_PRIVATE_KEY, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE})
+	@SecurityRequirement(name = "apiKey")
+	public String getRavencoinWalletBalance(@HeaderParam(Security.API_KEY_HEADER) String apiKey, String key58) {
+		Security.checkApiCallAllowed(request);
+
+		Ravencoin ravencoin = Ravencoin.getInstance();
+
+		if (!ravencoin.isValidDeterministicKey(key58))
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_PRIVATE_KEY);
+
+		try {
+			Long balance = ravencoin.getWalletBalanceFromTransactions(key58);
+			if (balance == null)
+				throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE);
+
+			return balance.toString();
+
+		} catch (ForeignBlockchainException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE);
+		}
+	}
+
+	@POST
+	@Path("/wallettransactions")
+	@Operation(
+		summary = "Returns transactions for hierarchical, deterministic BIP32 wallet",
+		description = "Supply BIP32 'm' private/public key in base58, starting with 'xprv'/'xpub' for mainnet, 'tprv'/'tpub' for testnet",
+		requestBody = @RequestBody(
+			required = true,
+			content = @Content(
+				mediaType = MediaType.TEXT_PLAIN,
+				schema = @Schema(
+					type = "string",
+					description = "BIP32 'm' private/public key in base58",
+					example = "tpubD6NzVbkrYhZ4XTPc4btCZ6SMgn8CxmWkj6VBVZ1tfcJfMq4UwAjZbG8U74gGSypL9XBYk2R2BLbDBe8pcEyBKM1edsGQEPKXNbEskZozeZc"
+				)
+			)
+		),
+		responses = {
+			@ApiResponse(
+				content = @Content(array = @ArraySchema( schema = @Schema( implementation = SimpleTransaction.class ) ) )
+			)
+		}
+	)
+	@ApiErrors({ApiError.INVALID_PRIVATE_KEY, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE})
+	@SecurityRequirement(name = "apiKey")
+	public List<SimpleTransaction> getRavencoinWalletTransactions(@HeaderParam(Security.API_KEY_HEADER) String apiKey, String key58) {
+		Security.checkApiCallAllowed(request);
+
+		Ravencoin ravencoin = Ravencoin.getInstance();
+
+		if (!ravencoin.isValidDeterministicKey(key58))
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_PRIVATE_KEY);
+
+		try {
+			return ravencoin.getWalletTransactions(key58);
+		} catch (ForeignBlockchainException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE);
+		}
+	}
+
+	@POST
+	@Path("/send")
+	@Operation(
+		summary = "Sends RVN from hierarchical, deterministic BIP32 wallet to specific address",
+		description = "Currently only supports 'legacy' P2PKH Ravencoin addresses. Supply BIP32 'm' private key in base58, starting with 'xprv' for mainnet, 'tprv' for testnet",
+		requestBody = @RequestBody(
+			required = true,
+			content = @Content(
+				mediaType = MediaType.APPLICATION_JSON,
+				schema = @Schema(
+					implementation = RavencoinSendRequest.class
+				)
+			)
+		),
+		responses = {
+			@ApiResponse(
+				content = @Content(mediaType = MediaType.TEXT_PLAIN, schema = @Schema(type = "string", description = "transaction hash"))
+			)
+		}
+	)
+	@ApiErrors({ApiError.INVALID_PRIVATE_KEY, ApiError.INVALID_CRITERIA, ApiError.INVALID_ADDRESS, ApiError.FOREIGN_BLOCKCHAIN_BALANCE_ISSUE, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE})
+	@SecurityRequirement(name = "apiKey")
+	public String sendBitcoin(@HeaderParam(Security.API_KEY_HEADER) String apiKey, RavencoinSendRequest ravencoinSendRequest) {
+		Security.checkApiCallAllowed(request);
+
+		if (ravencoinSendRequest.ravencoinAmount <= 0)
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_CRITERIA);
+
+		if (ravencoinSendRequest.feePerByte != null && ravencoinSendRequest.feePerByte <= 0)
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_CRITERIA);
+
+		Ravencoin ravencoin = Ravencoin.getInstance();
+
+		if (!ravencoin.isValidAddress(ravencoinSendRequest.receivingAddress))
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_ADDRESS);
+
+		if (!ravencoin.isValidDeterministicKey(ravencoinSendRequest.xprv58))
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_PRIVATE_KEY);
+
+		Transaction spendTransaction = ravencoin.buildSpend(ravencoinSendRequest.xprv58,
+				ravencoinSendRequest.receivingAddress,
+				ravencoinSendRequest.ravencoinAmount,
+				ravencoinSendRequest.feePerByte);
+
+		if (spendTransaction == null)
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_BALANCE_ISSUE);
+
+		try {
+			ravencoin.broadcastTransaction(spendTransaction);
+		} catch (ForeignBlockchainException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE);
+		}
+
+		return spendTransaction.getTxId().toString();
+	}
+
+}

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

@@ -42,6 +42,7 @@ import org.qortal.repository.DataException;
 import org.qortal.repository.Repository;
 import org.qortal.repository.RepositoryManager;
 import org.qortal.utils.Base58;
+import org.qortal.utils.NTP;
 
 @Path("/crosschain/tradebot")
 @Tag(name = "Cross-Chain (Trade-Bot)")
@@ -137,7 +138,8 @@ public class CrossChainTradeBotResource {
 		if (tradeBotCreateRequest.qortAmount <= 0 || tradeBotCreateRequest.fundingQortAmount <= 0)
 			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.ORDER_SIZE_TOO_SMALL);
 
-		if (!Controller.getInstance().isUpToDate())
+		final Long minLatestBlockTimestamp = NTP.getTime() - (60 * 60 * 1000L);
+		if (!Controller.getInstance().isUpToDate(minLatestBlockTimestamp))
 			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.BLOCKCHAIN_NEEDS_SYNC);
 
 		try (final Repository repository = RepositoryManager.getRepository()) {
@@ -153,7 +155,7 @@ public class CrossChainTradeBotResource {
 
 			return Base58.encode(unsignedBytes);
 		} catch (DataException e) {
-			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.REPOSITORY_ISSUE, e);
+			throw ApiExceptionFactory.INSTANCE.createCustomException(request, ApiError.REPOSITORY_ISSUE, e.getMessage());
 		}
 	}
 
@@ -198,7 +200,8 @@ public class CrossChainTradeBotResource {
 		if (tradeBotRespondRequest.receivingAddress == null || !Crypto.isValidAddress(tradeBotRespondRequest.receivingAddress))
 			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_ADDRESS);
 
-		if (!Controller.getInstance().isUpToDate())
+		final Long minLatestBlockTimestamp = NTP.getTime() - (60 * 60 * 1000L);
+		if (!Controller.getInstance().isUpToDate(minLatestBlockTimestamp))
 			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.BLOCKCHAIN_NEEDS_SYNC);
 
 		// Extract data from cross-chain trading AT
@@ -237,7 +240,7 @@ public class CrossChainTradeBotResource {
 					return "false";
 			}
 		} catch (DataException e) {
-			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.REPOSITORY_ISSUE, e);
+			throw ApiExceptionFactory.INSTANCE.createCustomException(request, ApiError.REPOSITORY_ISSUE, e.getMessage());
 		}
 	}
 

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

@@ -98,7 +98,15 @@ public class GroupsResource {
 		ref = "reverse"
 	) @QueryParam("reverse") Boolean reverse) {
 		try (final Repository repository = RepositoryManager.getRepository()) {
-			return repository.getGroupRepository().getAllGroups(limit, offset, reverse);
+			List<GroupData> allGroupData = repository.getGroupRepository().getAllGroups(limit, offset, reverse);
+			allGroupData.forEach(groupData -> {
+				try {
+					groupData.memberCount = repository.getGroupRepository().countGroupMembers(groupData.getGroupId());
+				} catch (DataException e) {
+					// Exclude memberCount for this group
+				}
+			});
+			return allGroupData;
 		} catch (DataException e) {
 			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.REPOSITORY_ISSUE, e);
 		}
@@ -150,7 +158,15 @@ public class GroupsResource {
 			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_ADDRESS);
 
 		try (final Repository repository = RepositoryManager.getRepository()) {
-			return repository.getGroupRepository().getGroupsWithMember(member);
+			List<GroupData> allGroupData = repository.getGroupRepository().getGroupsWithMember(member);
+			allGroupData.forEach(groupData -> {
+				try {
+					groupData.memberCount = repository.getGroupRepository().countGroupMembers(groupData.getGroupId());
+				} catch (DataException e) {
+					// Exclude memberCount for this group
+				}
+			});
+			return allGroupData;
 		} catch (DataException e) {
 			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.REPOSITORY_ISSUE, e);
 		}
@@ -177,6 +193,7 @@ public class GroupsResource {
 			if (groupData == null)
 				throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.GROUP_UNKNOWN);
 
+			groupData.memberCount = repository.getGroupRepository().countGroupMembers(groupId);
 			return groupData;
 		} catch (DataException e) {
 			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.REPOSITORY_ISSUE, e);
@@ -922,4 +939,4 @@ public class GroupsResource {
 		}
 	}
 
-}
+}

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

@@ -26,6 +26,7 @@ import org.qortal.api.ApiErrors;
 import org.qortal.api.ApiException;
 import org.qortal.api.ApiExceptionFactory;
 import org.qortal.api.model.NameSummary;
+import org.qortal.controller.LiteNode;
 import org.qortal.crypto.Crypto;
 import org.qortal.data.naming.NameData;
 import org.qortal.data.transaction.BuyNameTransactionData;
@@ -101,7 +102,14 @@ public class NamesResource {
 			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_ADDRESS);
 
 		try (final Repository repository = RepositoryManager.getRepository()) {
-			List<NameData> names = repository.getNameRepository().getNamesByOwner(address, limit, offset, reverse);
+			List<NameData> names;
+
+			if (Settings.getInstance().isLite()) {
+				names = LiteNode.getInstance().fetchAccountNames(address);
+			}
+			else {
+				names = repository.getNameRepository().getNamesByOwner(address, limit, offset, reverse);
+			}
 
 			return names.stream().map(NameSummary::new).collect(Collectors.toList());
 		} catch (DataException e) {
@@ -126,10 +134,18 @@ public class NamesResource {
 	@ApiErrors({ApiError.NAME_UNKNOWN, ApiError.REPOSITORY_ISSUE})
 	public NameData getName(@PathParam("name") String name) {
 		try (final Repository repository = RepositoryManager.getRepository()) {
-			NameData nameData = repository.getNameRepository().fromName(name);
+			NameData nameData;
 
-			if (nameData == null)
+			if (Settings.getInstance().isLite()) {
+				nameData = LiteNode.getInstance().fetchNameData(name);
+			}
+			else {
+				nameData = repository.getNameRepository().fromName(name);
+			}
+
+			if (nameData == null) {
 				throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.NAME_UNKNOWN);
+			}
 
 			return nameData;
 		} catch (ApiException e) {

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

@@ -20,6 +20,11 @@ import javax.ws.rs.*;
 import javax.ws.rs.core.Context;
 import javax.ws.rs.core.MediaType;
 
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.core.config.Configuration;
+import org.apache.logging.log4j.core.config.LoggerConfig;
+import org.apache.logging.log4j.core.LoggerContext;
 import org.qortal.api.*;
 import org.qortal.api.model.ConnectedPeer;
 import org.qortal.api.model.PeersSummary;
@@ -61,7 +66,7 @@ public class PeersResource {
 		}
 	)
 	public List<ConnectedPeer> getPeers() {
-		return Network.getInstance().getConnectedPeers().stream().map(ConnectedPeer::new).collect(Collectors.toList());
+		return Network.getInstance().getImmutableConnectedPeers().stream().map(ConnectedPeer::new).collect(Collectors.toList());
 	}
 
 	@GET
@@ -127,9 +132,29 @@ public class PeersResource {
 		}
 	)
 	@SecurityRequirement(name = "apiKey")
-	public ExecuteProduceConsume.StatsSnapshot getEngineStats(@HeaderParam(Security.API_KEY_HEADER) String apiKey) {
+	public ExecuteProduceConsume.StatsSnapshot getEngineStats(@HeaderParam(Security.API_KEY_HEADER) String apiKey, @QueryParam("newLoggingLevel") Level newLoggingLevel) {
 		Security.checkApiCallAllowed(request);
 
+		if (newLoggingLevel != null) {
+			final LoggerContext ctx = (LoggerContext) LogManager.getContext(false);
+			final Configuration config = ctx.getConfiguration();
+
+			String epcClassName = "org.qortal.network.Network.NetworkProcessor";
+			LoggerConfig loggerConfig = config.getLoggerConfig(epcClassName);
+			LoggerConfig specificConfig = loggerConfig;
+
+			// We need a specific configuration for this logger,
+			// otherwise we would change the level of all other loggers
+			// having the original configuration as parent as well
+			if (!loggerConfig.getName().equals(epcClassName)) {
+				specificConfig = new LoggerConfig(epcClassName, newLoggingLevel, true);
+				specificConfig.setParent(loggerConfig);
+				config.addLogger(epcClassName, specificConfig);
+			}
+			specificConfig.setLevel(newLoggingLevel);
+			ctx.updateLoggers();
+		}
+
 		return Network.getInstance().getStatsSnapshot();
 	}
 
@@ -304,7 +329,7 @@ public class PeersResource {
 			PeerAddress peerAddress = PeerAddress.fromString(targetPeerAddress);
 			InetSocketAddress resolvedAddress = peerAddress.toSocketAddress();
 
-			List<Peer> peers = Network.getInstance().getHandshakedPeers();
+			List<Peer> peers = Network.getInstance().getImmutableHandshakedPeers();
 			Peer targetPeer = peers.stream().filter(peer -> peer.getResolvedAddress().equals(resolvedAddress)).findFirst().orElse(null);
 
 			if (targetPeer == null)
@@ -352,7 +377,7 @@ public class PeersResource {
 	public PeersSummary peersSummary() {
 		PeersSummary peersSummary = new PeersSummary();
 
-		List<Peer> connectedPeers = Network.getInstance().getConnectedPeers().stream().collect(Collectors.toList());
+		List<Peer> connectedPeers = Network.getInstance().getImmutableConnectedPeers().stream().collect(Collectors.toList());
 		for (Peer peer : connectedPeers) {
 			if (!peer.isOutbound()) {
 				peersSummary.inboundConnections++;

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

@@ -138,34 +138,38 @@ public class RenderResource {
     @GET
     @Path("/signature/{signature}")
     @SecurityRequirement(name = "apiKey")
-    public HttpServletResponse getIndexBySignature(@PathParam("signature") String signature) {
+    public HttpServletResponse getIndexBySignature(@PathParam("signature") String signature,
+                                                   @QueryParam("theme") String theme) {
         Security.requirePriorAuthorization(request, signature, Service.WEBSITE, null);
-        return this.get(signature, ResourceIdType.SIGNATURE, null, "/", null, "/render/signature", true, true);
+        return this.get(signature, ResourceIdType.SIGNATURE, null, "/", null, "/render/signature", true, true, theme);
     }
 
     @GET
     @Path("/signature/{signature}/{path:.*}")
     @SecurityRequirement(name = "apiKey")
-    public HttpServletResponse getPathBySignature(@PathParam("signature") String signature, @PathParam("path") String inPath) {
+    public HttpServletResponse getPathBySignature(@PathParam("signature") String signature, @PathParam("path") String inPath,
+                                                  @QueryParam("theme") String theme) {
         Security.requirePriorAuthorization(request, signature, Service.WEBSITE, null);
-        return this.get(signature, ResourceIdType.SIGNATURE, null, inPath,null, "/render/signature", true, true);
+        return this.get(signature, ResourceIdType.SIGNATURE, null, inPath,null, "/render/signature", true, true, theme);
     }
 
     @GET
     @Path("/hash/{hash}")
     @SecurityRequirement(name = "apiKey")
-    public HttpServletResponse getIndexByHash(@PathParam("hash") String hash58, @QueryParam("secret") String secret58) {
+    public HttpServletResponse getIndexByHash(@PathParam("hash") String hash58, @QueryParam("secret") String secret58,
+                                              @QueryParam("theme") String theme) {
         Security.requirePriorAuthorization(request, hash58, Service.WEBSITE, null);
-        return this.get(hash58, ResourceIdType.FILE_HASH, Service.WEBSITE, "/", secret58, "/render/hash", true, false);
+        return this.get(hash58, ResourceIdType.FILE_HASH, Service.WEBSITE, "/", secret58, "/render/hash", true, false, theme);
     }
 
     @GET
     @Path("/hash/{hash}/{path:.*}")
     @SecurityRequirement(name = "apiKey")
     public HttpServletResponse getPathByHash(@PathParam("hash") String hash58, @PathParam("path") String inPath,
-                                             @QueryParam("secret") String secret58) {
+                                             @QueryParam("secret") String secret58,
+                                             @QueryParam("theme") String theme) {
         Security.requirePriorAuthorization(request, hash58, Service.WEBSITE, null);
-        return this.get(hash58, ResourceIdType.FILE_HASH, Service.WEBSITE, inPath, secret58, "/render/hash", true, false);
+        return this.get(hash58, ResourceIdType.FILE_HASH, Service.WEBSITE, inPath, secret58, "/render/hash", true, false, theme);
     }
 
     @GET
@@ -173,29 +177,35 @@ public class RenderResource {
     @SecurityRequirement(name = "apiKey")
     public HttpServletResponse getPathByName(@PathParam("service") Service service,
                                              @PathParam("name") String name,
-                                             @PathParam("path") String inPath) {
+                                             @PathParam("path") String inPath,
+                                             @QueryParam("theme") String theme) {
         Security.requirePriorAuthorization(request, name, service, null);
         String prefix = String.format("/render/%s", service);
-        return this.get(name, ResourceIdType.NAME, service, inPath, null, prefix, true, true);
+        return this.get(name, ResourceIdType.NAME, service, inPath, null, prefix, true, true, theme);
     }
 
     @GET
     @Path("{service}/{name}")
     @SecurityRequirement(name = "apiKey")
     public HttpServletResponse getIndexByName(@PathParam("service") Service service,
-                                              @PathParam("name") String name) {
+                                              @PathParam("name") String name,
+                                              @QueryParam("theme") String theme) {
         Security.requirePriorAuthorization(request, name, service, null);
         String prefix = String.format("/render/%s", service);
-        return this.get(name, ResourceIdType.NAME, service, "/", null, prefix, true, true);
+        return this.get(name, ResourceIdType.NAME, service, "/", null, prefix, true, true, theme);
     }
 
 
 
     private HttpServletResponse get(String resourceId, ResourceIdType resourceIdType, Service service, String inPath,
-                                    String secret58, String prefix, boolean usePrefix, boolean async) {
+                                    String secret58, String prefix, boolean usePrefix, boolean async, String theme) {
 
         ArbitraryDataRenderer renderer = new ArbitraryDataRenderer(resourceId, resourceIdType, service, inPath,
                 secret58, prefix, usePrefix, async, request, response, context);
+
+        if (theme != null) {
+            renderer.setTheme(theme);
+        }
         return renderer.render();
     }
 

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

@@ -12,6 +12,7 @@ import io.swagger.v3.oas.annotations.tags.Tag;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
 import java.util.ArrayList;
+import java.util.Comparator;
 import java.util.List;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.locks.ReentrantLock;
@@ -32,6 +33,8 @@ import org.qortal.api.ApiException;
 import org.qortal.api.ApiExceptionFactory;
 import org.qortal.api.model.SimpleTransactionSignRequest;
 import org.qortal.controller.Controller;
+import org.qortal.controller.LiteNode;
+import org.qortal.crypto.Crypto;
 import org.qortal.data.transaction.TransactionData;
 import org.qortal.globalization.Translator;
 import org.qortal.repository.DataException;
@@ -250,14 +253,29 @@ public class TransactionsResource {
 		ApiError.REPOSITORY_ISSUE
 	})
 	public List<TransactionData> getUnconfirmedTransactions(@Parameter(
+			description = "A list of transaction types"
+	) @QueryParam("txType") List<TransactionType> txTypes, @Parameter(
+			description = "Transaction creator's base58 encoded public key"
+	) @QueryParam("creator") String creatorPublicKey58, @Parameter(
 		ref = "limit"
 	) @QueryParam("limit") Integer limit, @Parameter(
 		ref = "offset"
 	) @QueryParam("offset") Integer offset, @Parameter(
 		ref = "reverse"
 	) @QueryParam("reverse") Boolean reverse) {
+
+		// Decode public key if supplied
+		byte[] creatorPublicKey = null;
+		if (creatorPublicKey58 != null) {
+			try {
+				creatorPublicKey = Base58.decode(creatorPublicKey58);
+			} catch (NumberFormatException e) {
+				throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_PUBLIC_KEY, e);
+			}
+		}
+
 		try (final Repository repository = RepositoryManager.getRepository()) {
-			return repository.getTransactionRepository().getUnconfirmedTransactions(limit, offset, reverse);
+			return repository.getTransactionRepository().getUnconfirmedTransactions(txTypes, creatorPublicKey, limit, offset, reverse);
 		} catch (ApiException e) {
 			throw e;
 		} catch (DataException e) {
@@ -366,6 +384,73 @@ public class TransactionsResource {
 		}
 	}
 
+	@GET
+	@Path("/address/{address}")
+	@Operation(
+			summary = "Returns transactions for given address",
+			responses = {
+					@ApiResponse(
+							description = "transactions",
+							content = @Content(
+									array = @ArraySchema(
+											schema = @Schema(
+													implementation = TransactionData.class
+											)
+									)
+							)
+					)
+			}
+	)
+	@ApiErrors({ApiError.INVALID_ADDRESS,  ApiError.REPOSITORY_ISSUE})
+	public List<TransactionData> getAddressTransactions(@PathParam("address") String address,
+												 		@Parameter(ref = "limit") @QueryParam("limit") Integer limit,
+												 		@Parameter(ref = "offset") @QueryParam("offset") Integer offset,
+														@Parameter(ref = "reverse") @QueryParam("reverse") Boolean reverse) {
+		if (!Crypto.isValidAddress(address)) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_ADDRESS);
+		}
+
+		if (limit == null) {
+			limit = 0;
+		}
+		if (offset == null) {
+			offset = 0;
+		}
+
+		List<TransactionData> transactions;
+
+		if (Settings.getInstance().isLite()) {
+			// Fetch from network
+			transactions = LiteNode.getInstance().fetchAccountTransactions(address, limit, offset);
+
+			// Sort the data, since we can't guarantee the order that a peer sent it in
+			if (reverse) {
+				transactions.sort(Comparator.comparingLong(TransactionData::getTimestamp).reversed());
+			} else {
+				transactions.sort(Comparator.comparingLong(TransactionData::getTimestamp));
+			}
+		}
+		else {
+			// Fetch from local db
+			try (final Repository repository = RepositoryManager.getRepository()) {
+				List<byte[]> signatures = repository.getTransactionRepository().getSignaturesMatchingCriteria(null, null, null,
+						null, null, null, address, TransactionsResource.ConfirmationStatus.CONFIRMED, limit, offset, reverse);
+
+				// Expand signatures to transactions
+				transactions = new ArrayList<>(signatures.size());
+				for (byte[] signature : signatures) {
+					transactions.add(repository.getTransactionRepository().fromSignature(signature));
+				}
+			} catch (ApiException e) {
+				throw e;
+			} catch (DataException e) {
+				throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.REPOSITORY_ISSUE, e);
+			}
+		}
+
+		return transactions;
+	}
+
 	@GET
 	@Path("/unitfee")
 	@Operation(
@@ -638,9 +723,9 @@ public class TransactionsResource {
 		ApiError.BLOCKCHAIN_NEEDS_SYNC, ApiError.INVALID_SIGNATURE, ApiError.INVALID_DATA, ApiError.TRANSFORMATION_ERROR, ApiError.REPOSITORY_ISSUE
 	})
 	public String processTransaction(String rawBytes58) {
-		// Only allow a transaction to be processed if our latest block is less than 30 minutes old
+		// Only allow a transaction to be processed if our latest block is less than 60 minutes old
 		// If older than this, we should first wait until the blockchain is synced
-		final Long minLatestBlockTimestamp = NTP.getTime() - (30 * 60 * 1000L);
+		final Long minLatestBlockTimestamp = NTP.getTime() - (60 * 60 * 1000L);
 		if (!Controller.getInstance().isUpToDate(minLatestBlockTimestamp))
 			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.BLOCKCHAIN_NEEDS_SYNC);
 
@@ -663,7 +748,7 @@ public class TransactionsResource {
 				throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_SIGNATURE);
 
 			ReentrantLock blockchainLock = Controller.getInstance().getBlockchainLock();
-			if (!blockchainLock.tryLock(30, TimeUnit.SECONDS))
+			if (!blockchainLock.tryLock(60, TimeUnit.SECONDS))
 				throw createTransactionInvalidException(request, ValidationResult.NO_BLOCKCHAIN_LOCK);
 
 			try {

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

@@ -53,7 +53,8 @@ public class ArbitraryDataFile {
     private static final Logger LOGGER = LogManager.getLogger(ArbitraryDataFile.class);
 
     public static final long MAX_FILE_SIZE = 500 * 1024 * 1024; // 500MiB
-    public static final int CHUNK_SIZE = 1 * 1024 * 1024; // 1MiB
+    protected static final int MAX_CHUNK_SIZE = 1 * 1024 * 1024; // 1MiB
+    public static final int CHUNK_SIZE = 512 * 1024; // 0.5MiB
     public static int SHORT_DIGEST_LENGTH = 8;
 
     protected Path filePath;
@@ -72,7 +73,6 @@ public class ArbitraryDataFile {
     }
 
     public ArbitraryDataFile(String hash58, byte[] signature) throws DataException {
-        this.createDataDirectory();
         this.filePath = ArbitraryDataFile.getOutputFilePath(hash58, signature, false);
         this.chunks = new ArrayList<>();
         this.hash58 = hash58;
@@ -94,14 +94,9 @@ public class ArbitraryDataFile {
         try (FileOutputStream outputStream = new FileOutputStream(outputFile)) {
             outputStream.write(fileContent);
             this.filePath = outputFilePath;
-            // Verify hash
-            if (!this.hash58.equals(this.digest58())) {
-                LOGGER.error("Hash {} does not match file digest {}", this.hash58, this.digest58());
-                this.delete();
-                throw new DataException("Data file digest validation failed");
-            }
         } catch (IOException e) {
-            throw new DataException("Unable to write data to file");
+            this.delete();
+            throw new DataException(String.format("Unable to write data with hash %s: %s", this.hash58, e.getMessage()));
         }
     }
 
@@ -110,6 +105,9 @@ public class ArbitraryDataFile {
     }
 
     public static ArbitraryDataFile fromHash(byte[] hash, byte[] signature) throws DataException {
+        if (hash == null) {
+            return null;
+        }
         return ArbitraryDataFile.fromHash58(Base58.encode(hash), signature);
     }
 
@@ -146,19 +144,6 @@ public class ArbitraryDataFile {
         return ArbitraryDataFile.fromPath(Paths.get(file.getPath()), signature);
     }
 
-    private boolean createDataDirectory() {
-        // Create the data directory if it doesn't exist
-        String dataPath = Settings.getInstance().getDataPath();
-        Path dataDirectory = Paths.get(dataPath);
-        try {
-            Files.createDirectories(dataDirectory);
-        } catch (IOException e) {
-            LOGGER.error("Unable to create data directory");
-            return false;
-        }
-        return true;
-    }
-
     private Path copyToDataDirectory(Path sourcePath, byte[] signature) throws DataException {
         if (this.hash58 == null || this.filePath == null) {
             return null;
@@ -488,6 +473,14 @@ public class ArbitraryDataFile {
 
             // Read the metadata
             List<byte[]> chunks = metadata.getChunks();
+
+            // If the chunks array is empty, then this resource has no chunks,
+            // so we must return false to avoid confusing the caller.
+            if (chunks.isEmpty()) {
+                return false;
+            }
+
+            // Otherwise, we need to check each chunk individually
             for (byte[] chunkHash : chunks) {
                 ArbitraryDataFileChunk chunk = ArbitraryDataFileChunk.fromHash(chunkHash, this.signature);
                 if (!chunk.exists()) {

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

@@ -40,8 +40,8 @@ public class ArbitraryDataFileChunk extends ArbitraryDataFile {
         try {
             // Validate the file size (chunks have stricter limits)
             long fileSize = Files.size(this.filePath);
-            if (fileSize > CHUNK_SIZE) {
-                LOGGER.error(String.format("DataFileChunk is too large: %d bytes (max chunk size: %d bytes)", fileSize, CHUNK_SIZE));
+            if (fileSize > MAX_CHUNK_SIZE) {
+                LOGGER.error(String.format("DataFileChunk is too large: %d bytes (max chunk size: %d bytes)", fileSize, MAX_CHUNK_SIZE));
                 return ValidationResult.FILE_TOO_LARGE;
             }
 

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

@@ -170,6 +170,7 @@ public class ArbitraryDataReader {
             this.validate();
 
         } catch (DataException e) {
+            LOGGER.info("DataException when trying to load QDN resource", e);
             this.deleteWorkingDirectory();
             throw new DataException(e.getMessage());
 
@@ -208,8 +209,13 @@ public class ArbitraryDataReader {
      * serve a cached version of the resource for subsequent requests.
      * @throws IOException
      */
-    private void deleteWorkingDirectory() throws IOException {
-        FilesystemUtils.safeDeleteDirectory(this.workingPath, true);
+    private void deleteWorkingDirectory() {
+        try {
+            FilesystemUtils.safeDeleteDirectory(this.workingPath, true);
+        } catch (IOException e) {
+            // Ignore failures as this isn't an essential step
+            LOGGER.info("Unable to delete working path {}: {}", this.workingPath, e.getMessage());
+        }
     }
 
     private void createUncompressedDirectory() throws DataException {
@@ -408,6 +414,7 @@ public class ArbitraryDataReader {
             this.decryptUsingAlgo("AES/CBC/PKCS5Padding");
 
         } catch (DataException e) {
+            LOGGER.info("Unable to decrypt using specific parameters: {}", e.getMessage());
             // Something went wrong, so fall back to default AES params (necessary for legacy resource support)
             this.decryptUsingAlgo("AES");
 
@@ -420,8 +427,9 @@ public class ArbitraryDataReader {
         byte[] secret = this.secret58 != null ? Base58.decode(this.secret58) : null;
         if (secret != null && secret.length == Transformer.AES256_LENGTH) {
             try {
+                LOGGER.info("Decrypting using algorithm {}...", algorithm);
                 Path unencryptedPath = Paths.get(this.workingPath.toString(), "zipped.zip");
-                SecretKey aesKey = new SecretKeySpec(secret, 0, secret.length, algorithm);
+                SecretKey aesKey = new SecretKeySpec(secret, 0, secret.length, "AES");
                 AES.decryptFile(algorithm, aesKey, this.filePath.toString(), unencryptedPath.toString());
 
                 // Replace filePath pointer with the encrypted file path
@@ -430,7 +438,8 @@ public class ArbitraryDataReader {
 
             } catch (NoSuchAlgorithmException | InvalidAlgorithmParameterException | NoSuchPaddingException
                     | BadPaddingException | IllegalBlockSizeException | IOException | InvalidKeyException e) {
-                throw new DataException(String.format("Unable to decrypt file at path %s: %s", this.filePath, e.getMessage()));
+                LOGGER.info(String.format("Exception when decrypting using algorithm %s", algorithm), e);
+                throw new DataException(String.format("Unable to decrypt file at path %s using algorithm %s: %s", this.filePath, algorithm, e.getMessage()));
             }
         } else {
             // Assume it is unencrypted. This will be the case when we have built a custom path by combining
@@ -477,7 +486,12 @@ public class ArbitraryDataReader {
         // Delete original compressed file
         if (FilesystemUtils.pathInsideDataOrTempPath(this.filePath)) {
             if (Files.exists(this.filePath)) {
-                Files.delete(this.filePath);
+                try {
+                    Files.delete(this.filePath);
+                } catch (IOException e) {
+                    // Ignore failures as this isn't an essential step
+                    LOGGER.info("Unable to delete file at path {}", this.filePath);
+                }
             }
         }
 

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

@@ -34,6 +34,7 @@ public class ArbitraryDataRenderer {
     private final String resourceId;
     private final ResourceIdType resourceIdType;
     private final Service service;
+    private String theme = "light";
     private String inPath;
     private final String secret58;
     private final String prefix;
@@ -77,7 +78,7 @@ public class ArbitraryDataRenderer {
                 // If async is requested, show a loading screen whilst build is in progress
                 if (async) {
                     arbitraryDataReader.loadAsynchronously(false, 10);
-                    return this.getLoadingResponse(service, resourceId);
+                    return this.getLoadingResponse(service, resourceId, theme);
                 }
 
                 // Otherwise, loop until we have data
@@ -119,7 +120,7 @@ public class ArbitraryDataRenderer {
                 byte[] data = Files.readAllBytes(Paths.get(filePath)); // TODO: limit file size that can be read into memory
                 HTMLParser htmlParser = new HTMLParser(resourceId, inPath, prefix, usePrefix, data);
                 htmlParser.addAdditionalHeaderTags();
-                response.addHeader("Content-Security-Policy", "default-src 'self' 'unsafe-inline' 'unsafe-eval'; media-src 'self' blob:");
+                response.addHeader("Content-Security-Policy", "default-src 'self' 'unsafe-inline' 'unsafe-eval'; media-src 'self' blob:; img-src 'self' data: blob:;");
                 response.setContentType(context.getMimeType(filename));
                 response.setContentLength(htmlParser.getData().length);
                 response.getOutputStream().write(htmlParser.getData());
@@ -171,7 +172,7 @@ public class ArbitraryDataRenderer {
         return userPath;
     }
 
-    private HttpServletResponse getLoadingResponse(Service service, String name) {
+    private HttpServletResponse getLoadingResponse(Service service, String name, String theme) {
         String responseString = "";
         URL url = Resources.getResource("loading/index.html");
         try {
@@ -180,6 +181,7 @@ public class ArbitraryDataRenderer {
             // Replace vars
             responseString = responseString.replace("%%SERVICE%%", service.toString());
             responseString = responseString.replace("%%NAME%%", name);
+            responseString = responseString.replace("%%THEME%%", theme);
 
         } catch (IOException e) {
             LOGGER.info("Unable to show loading screen: {}", e.getMessage());
@@ -210,4 +212,8 @@ public class ArbitraryDataRenderer {
         return indexFiles;
     }
 
+    public void setTheme(String theme) {
+        this.theme = theme;
+    }
+
 }

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

@@ -551,7 +551,7 @@ public class QortalATAPI extends API {
 	 * <p>
 	 * Otherwise, assume B is a public key.
 	 */
-	private Account getAccountFromB(MachineState state) {
+	/*package*/ Account getAccountFromB(MachineState state) {
 		byte[] bBytes = this.getB(state);
 
 		if ((bBytes[0] == Crypto.ADDRESS_VERSION || bBytes[0] == Crypto.AT_ADDRESS_VERSION)

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

@@ -10,9 +10,11 @@ import org.ciyam.at.ExecutionException;
 import org.ciyam.at.FunctionData;
 import org.ciyam.at.IllegalFunctionCodeException;
 import org.ciyam.at.MachineState;
+import org.qortal.account.Account;
 import org.qortal.crosschain.Bitcoin;
 import org.qortal.crypto.Crypto;
 import org.qortal.data.transaction.TransactionData;
+import org.qortal.repository.DataException;
 import org.qortal.settings.Settings;
 
 /**
@@ -160,6 +162,68 @@ public enum QortalFunctionCode {
 		protected void postCheckExecute(FunctionData functionData, MachineState state, short rawFunctionCode) throws ExecutionException {
 			convertAddressInB(Crypto.ADDRESS_VERSION, state);
 		}
+	},
+	/**
+	 * Returns account level of account in B.<br>
+	 * <tt>0x0520</tt><br>
+	 * B should contain either Qortal address or public key,<br>
+	 * e.g. as a result of calling function {@link org.ciyam.at.FunctionCode#PUT_ADDRESS_FROM_TX_IN_A_INTO_B}</code>.
+	 * <p></p>
+	 * Returns account level, or -1 if account unknown.
+	 * <p></p>
+	 * @see QortalATAPI#getAccountFromB(MachineState)
+	 */
+	GET_ACCOUNT_LEVEL_FROM_ACCOUNT_IN_B(0x0520, 0, true) {
+		@Override
+		protected void postCheckExecute(FunctionData functionData, MachineState state, short rawFunctionCode) throws ExecutionException {
+			QortalATAPI api = (QortalATAPI) state.getAPI();
+			Account account = api.getAccountFromB(state);
+
+			Integer accountLevel = null;
+
+			if (account != null) {
+				try {
+					accountLevel = account.getLevel();
+				} catch (DataException e) {
+					throw new RuntimeException("AT API unable to fetch account level?", e);
+				}
+			}
+
+			functionData.returnValue = accountLevel != null
+					? accountLevel.longValue()
+					: -1;
+		}
+	},
+	/**
+	 * Returns account's minted block count of account in B.<br>
+	 * <tt>0x0521</tt><br>
+	 * B should contain either Qortal address or public key,<br>
+	 * e.g. as a result of calling function {@link org.ciyam.at.FunctionCode#PUT_ADDRESS_FROM_TX_IN_A_INTO_B}</code>.
+	 * <p></p>
+	 * Returns account level, or -1 if account unknown.
+	 * <p></p>
+	 * @see QortalATAPI#getAccountFromB(MachineState)
+	 */
+	GET_BLOCKS_MINTED_FROM_ACCOUNT_IN_B(0x0521, 0, true) {
+		@Override
+		protected void postCheckExecute(FunctionData functionData, MachineState state, short rawFunctionCode) throws ExecutionException {
+			QortalATAPI api = (QortalATAPI) state.getAPI();
+			Account account = api.getAccountFromB(state);
+
+			Integer blocksMinted = null;
+
+			if (account != null) {
+				try {
+					blocksMinted = account.getBlocksMinted();
+				} catch (DataException e) {
+					throw new RuntimeException("AT API unable to fetch account's minted block count?", e);
+				}
+			}
+
+			functionData.returnValue = blocksMinted != null
+					? blocksMinted.longValue()
+					: -1;
+		}
 	};
 
 	public final short value;

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

@@ -3,18 +3,16 @@ package org.qortal.block;
 import static java.util.Arrays.stream;
 import static java.util.stream.Collectors.toMap;
 
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
 import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.math.RoundingMode;
+import java.nio.charset.StandardCharsets;
 import java.text.DecimalFormat;
+import java.text.MessageFormat;
 import java.text.NumberFormat;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;
 import java.util.stream.Collectors;
 
 import org.apache.logging.log4j.Level;
@@ -28,8 +26,9 @@ import org.qortal.asset.Asset;
 import org.qortal.at.AT;
 import org.qortal.block.BlockChain.BlockTimingByHeight;
 import org.qortal.block.BlockChain.AccountLevelShareBin;
-import org.qortal.controller.Controller;
+import org.qortal.controller.OnlineAccountsManager;
 import org.qortal.crypto.Crypto;
+import org.qortal.crypto.Qortal25519Extras;
 import org.qortal.data.account.AccountBalanceData;
 import org.qortal.data.account.AccountData;
 import org.qortal.data.account.EligibleQoraHolderData;
@@ -124,6 +123,8 @@ public class Block {
 
 	/** Remote/imported/loaded AT states */
 	protected List<ATStateData> atStates;
+	/** Remote hash of AT states - in lieu of full AT state data in {@code atStates} */
+	protected byte[] atStatesHash;
 	/** Locally-generated AT states */
 	protected List<ATStateData> ourAtStates;
 	/** Locally-generated AT fees */
@@ -198,6 +199,11 @@ public class Block {
 
 		}
 
+		public boolean hasShareBin(AccountLevelShareBin shareBin, int blockHeight) {
+			AccountLevelShareBin ourShareBin = this.getShareBin(blockHeight);
+			return ourShareBin != null && shareBin.id == ourShareBin.id;
+		}
+
 		public long distribute(long accountAmount, Map<String, Long> balanceChanges) {
 			if (this.isRecipientAlsoMinter) {
 				// minter & recipient the same - simpler case
@@ -222,11 +228,10 @@ public class Block {
 			return accountAmount;
 		}
 	}
+
 	/** Always use getExpandedAccounts() to access this, as it's lazy-instantiated. */
 	private List<ExpandedAccount> cachedExpandedAccounts = null;
 
-	/** Opportunistic cache of this block's valid online accounts. Only created by call to isValid(). */
-	private List<OnlineAccountData> cachedValidOnlineAccounts = null;
 	/** Opportunistic cache of this block's valid online reward-shares. Only created by call to isValid(). */
 	private List<RewardShareData> cachedOnlineRewardShares = null;
 
@@ -261,7 +266,7 @@ public class Block {
 	 * Constructs new Block using passed transaction and AT states.
 	 * <p>
 	 * This constructor typically used when receiving a serialized block over the network.
-	 * 
+	 *
 	 * @param repository
 	 * @param blockData
 	 * @param transactions
@@ -287,6 +292,35 @@ public class Block {
 		this.blockData.setTotalFees(totalFees);
 	}
 
+	/**
+	 * Constructs new Block using passed transaction and minimal AT state info.
+	 * <p>
+	 * This constructor typically used when receiving a serialized block over the network.
+	 *
+	 * @param repository
+	 * @param blockData
+	 * @param transactions
+	 * @param atStatesHash
+	 */
+	public Block(Repository repository, BlockData blockData, List<TransactionData> transactions, byte[] atStatesHash) {
+		this(repository, blockData);
+
+		this.transactions = new ArrayList<>();
+
+		long totalFees = 0;
+
+		// We have to sum fees too
+		for (TransactionData transactionData : transactions) {
+			this.transactions.add(Transaction.fromData(repository, transactionData));
+			totalFees += transactionData.getFee();
+		}
+
+		this.atStatesHash = atStatesHash;
+		totalFees += this.blockData.getATFees();
+
+		this.blockData.setTotalFees(totalFees);
+	}
+
 	/**
 	 * Constructs new Block with empty transaction list, using passed minter account.
 	 * 
@@ -319,28 +353,32 @@ public class Block {
 		int version = parentBlock.getNextBlockVersion();
 		byte[] reference = parentBlockData.getSignature();
 
+		// Qortal: minter is always a reward-share, so find actual minter and get their effective minting level
+		int minterLevel = Account.getRewardShareEffectiveMintingLevel(repository, minter.getPublicKey());
+		if (minterLevel == 0) {
+			LOGGER.error("Minter effective level returned zero?");
+			return null;
+		}
+
+		long timestamp = calcTimestamp(parentBlockData, minter.getPublicKey(), minterLevel);
+		long onlineAccountsTimestamp = OnlineAccountsManager.getCurrentOnlineAccountTimestamp();
+
 		// Fetch our list of online accounts
-		List<OnlineAccountData> onlineAccounts = Controller.getInstance().getOnlineAccounts();
+		List<OnlineAccountData> onlineAccounts = OnlineAccountsManager.getInstance().getOnlineAccounts(onlineAccountsTimestamp);
 		if (onlineAccounts.isEmpty()) {
 			LOGGER.error("No online accounts - not even our own?");
 			return null;
 		}
 
-		// Find newest online accounts timestamp
-		long onlineAccountsTimestamp = 0;
-		for (OnlineAccountData onlineAccountData : onlineAccounts) {
-			if (onlineAccountData.getTimestamp() > onlineAccountsTimestamp)
-				onlineAccountsTimestamp = onlineAccountData.getTimestamp();
-		}
+		// Load sorted list of reward share public keys into memory, so that the indexes can be obtained.
+		// This is up to 100x faster than querying each index separately. For 4150 reward share keys, it
+		// was taking around 5000ms to query individually, vs 50ms using this approach.
+		List<byte[]> allRewardSharePublicKeys = repository.getAccountRepository().getRewardSharePublicKeys();
 
 		// Map using index into sorted list of reward-shares as key
 		Map<Integer, OnlineAccountData> indexedOnlineAccounts = new HashMap<>();
 		for (OnlineAccountData onlineAccountData : onlineAccounts) {
-			// Disregard online accounts with different timestamps
-			if (onlineAccountData.getTimestamp() != onlineAccountsTimestamp)
-				continue;
-
-			Integer accountIndex = repository.getAccountRepository().getRewardShareIndex(onlineAccountData.getPublicKey());
+			Integer accountIndex = getRewardShareIndex(onlineAccountData.getPublicKey(), allRewardSharePublicKeys);
 			if (accountIndex == null)
 				// Online account (reward-share) with current timestamp but reward-share cancelled
 				continue;
@@ -356,26 +394,29 @@ public class Block {
 		byte[] encodedOnlineAccounts = BlockTransformer.encodeOnlineAccounts(onlineAccountsSet);
 		int onlineAccountsCount = onlineAccountsSet.size();
 
-		// Concatenate online account timestamp signatures (in correct order)
-		byte[] onlineAccountsSignatures = new byte[onlineAccountsCount * Transformer.SIGNATURE_LENGTH];
-		for (int i = 0; i < onlineAccountsCount; ++i) {
-			Integer accountIndex = accountIndexes.get(i);
-			OnlineAccountData onlineAccountData = indexedOnlineAccounts.get(accountIndex);
-			System.arraycopy(onlineAccountData.getSignature(), 0, onlineAccountsSignatures, i * Transformer.SIGNATURE_LENGTH, Transformer.SIGNATURE_LENGTH);
+		byte[] onlineAccountsSignatures;
+		if (timestamp >= BlockChain.getInstance().getAggregateSignatureTimestamp()) {
+			// Collate all signatures
+			Collection<byte[]> signaturesToAggregate = indexedOnlineAccounts.values()
+					.stream()
+					.map(OnlineAccountData::getSignature)
+					.collect(Collectors.toList());
+
+			// Aggregated, single signature
+			onlineAccountsSignatures = Qortal25519Extras.aggregateSignatures(signaturesToAggregate);
+		} else {
+			// Concatenate online account timestamp signatures (in correct order)
+			onlineAccountsSignatures = new byte[onlineAccountsCount * Transformer.SIGNATURE_LENGTH];
+			for (int i = 0; i < onlineAccountsCount; ++i) {
+				Integer accountIndex = accountIndexes.get(i);
+				OnlineAccountData onlineAccountData = indexedOnlineAccounts.get(accountIndex);
+				System.arraycopy(onlineAccountData.getSignature(), 0, onlineAccountsSignatures, i * Transformer.SIGNATURE_LENGTH, Transformer.SIGNATURE_LENGTH);
+			}
 		}
 
 		byte[] minterSignature = minter.sign(BlockTransformer.getBytesForMinterSignature(parentBlockData,
 				minter.getPublicKey(), encodedOnlineAccounts));
 
-		// Qortal: minter is always a reward-share, so find actual minter and get their effective minting level
-		int minterLevel = Account.getRewardShareEffectiveMintingLevel(repository, minter.getPublicKey());
-		if (minterLevel == 0) {
-			LOGGER.error("Minter effective level returned zero?");
-			return null;
-		}
-
-		long timestamp = calcTimestamp(parentBlockData, minter.getPublicKey(), minterLevel);
-
 		int transactionCount = 0;
 		byte[] transactionsSignature = null;
 		int height = parentBlockData.getHeight() + 1;
@@ -980,49 +1021,59 @@ public class Block {
 		if (this.blockData.getOnlineAccountsSignatures() == null || this.blockData.getOnlineAccountsSignatures().length == 0)
 			return ValidationResult.ONLINE_ACCOUNT_SIGNATURES_MISSING;
 
-		if (this.blockData.getOnlineAccountsSignatures().length != onlineRewardShares.size() * Transformer.SIGNATURE_LENGTH)
-			return ValidationResult.ONLINE_ACCOUNT_SIGNATURES_MALFORMED;
+		if (this.blockData.getTimestamp() >= BlockChain.getInstance().getAggregateSignatureTimestamp()) {
+			// We expect just the one, aggregated signature
+			if (this.blockData.getOnlineAccountsSignatures().length != Transformer.SIGNATURE_LENGTH)
+				return ValidationResult.ONLINE_ACCOUNT_SIGNATURES_MALFORMED;
+		} else {
+			if (this.blockData.getOnlineAccountsSignatures().length != onlineRewardShares.size() * Transformer.SIGNATURE_LENGTH)
+				return ValidationResult.ONLINE_ACCOUNT_SIGNATURES_MALFORMED;
+		}
 
 		// Check signatures
 		long onlineTimestamp = this.blockData.getOnlineAccountsTimestamp();
 		byte[] onlineTimestampBytes = Longs.toByteArray(onlineTimestamp);
 
-		// If this block is much older than current online timestamp, then there's no point checking current online accounts
-		List<OnlineAccountData> currentOnlineAccounts = onlineTimestamp < NTP.getTime() - Controller.ONLINE_TIMESTAMP_MODULUS
-				? null
-				: Controller.getInstance().getOnlineAccounts();
-		List<OnlineAccountData> latestBlocksOnlineAccounts = Controller.getInstance().getLatestBlocksOnlineAccounts();
-
-		// Extract online accounts' timestamp signatures from block data
+		// Extract online accounts' timestamp signatures from block data. Only one signature if aggregated.
 		List<byte[]> onlineAccountsSignatures = BlockTransformer.decodeTimestampSignatures(this.blockData.getOnlineAccountsSignatures());
 
-		// We'll build up a list of online accounts to hand over to Controller if block is added to chain
-		// and this will become latestBlocksOnlineAccounts (above) to reduce CPU load when we process next block...
-		List<OnlineAccountData> ourOnlineAccounts = new ArrayList<>();
+		if (this.blockData.getTimestamp() >= BlockChain.getInstance().getAggregateSignatureTimestamp()) {
+			// Aggregate all public keys
+			Collection<byte[]> publicKeys = onlineRewardShares.stream()
+					.map(RewardShareData::getRewardSharePublicKey)
+					.collect(Collectors.toList());
 
-		for (int i = 0; i < onlineAccountsSignatures.size(); ++i) {
-			byte[] signature = onlineAccountsSignatures.get(i);
-			byte[] publicKey = onlineRewardShares.get(i).getRewardSharePublicKey();
+			byte[] aggregatePublicKey = Qortal25519Extras.aggregatePublicKeys(publicKeys);
 
-			OnlineAccountData onlineAccountData = new OnlineAccountData(onlineTimestamp, signature, publicKey);
-			ourOnlineAccounts.add(onlineAccountData);
+			byte[] aggregateSignature = onlineAccountsSignatures.get(0);
 
-			// If signature is still current then no need to perform Ed25519 verify
-			if (currentOnlineAccounts != null && currentOnlineAccounts.remove(onlineAccountData))
-				// remove() returned true, so online account still current
-				// and one less entry in currentOnlineAccounts to check next time
-				continue;
-
-			// If signature was okay in latest block then no need to perform Ed25519 verify
-			if (latestBlocksOnlineAccounts != null && latestBlocksOnlineAccounts.contains(onlineAccountData))
-				continue;
-
-			if (!Crypto.verify(publicKey, signature, onlineTimestampBytes))
+			// One-step verification of aggregate signature using aggregate public key
+			if (!Qortal25519Extras.verifyAggregated(aggregatePublicKey, aggregateSignature, onlineTimestampBytes))
 				return ValidationResult.ONLINE_ACCOUNT_SIGNATURE_INCORRECT;
+		} else {
+			// Build block's view of online accounts
+			Set<OnlineAccountData> onlineAccounts = new HashSet<>();
+			for (int i = 0; i < onlineAccountsSignatures.size(); ++i) {
+				byte[] signature = onlineAccountsSignatures.get(i);
+				byte[] publicKey = onlineRewardShares.get(i).getRewardSharePublicKey();
+
+				OnlineAccountData onlineAccountData = new OnlineAccountData(onlineTimestamp, signature, publicKey);
+				onlineAccounts.add(onlineAccountData);
+			}
+
+			// Remove those already validated & cached by online accounts manager - no need to re-validate them
+			OnlineAccountsManager.getInstance().removeKnown(onlineAccounts, onlineTimestamp);
+
+			// Validate the rest
+			for (OnlineAccountData onlineAccount : onlineAccounts)
+				if (!Crypto.verify(onlineAccount.getPublicKey(), onlineAccount.getSignature(), onlineTimestampBytes))
+					return ValidationResult.ONLINE_ACCOUNT_SIGNATURE_INCORRECT;
+
+			// We've validated these, so allow online accounts manager to cache
+			OnlineAccountsManager.getInstance().addBlocksOnlineAccounts(onlineAccounts, onlineTimestamp);
 		}
 
 		// All online accounts valid, so save our list of online accounts for potential later use
-		this.cachedValidOnlineAccounts = ourOnlineAccounts;
 		this.cachedOnlineRewardShares = onlineRewardShares;
 
 		return ValidationResult.OK;
@@ -1169,6 +1220,7 @@ public class Block {
 				}
 			}
 		} catch (DataException e) {
+			LOGGER.info("DataException during transaction validation", e);
 			return ValidationResult.TRANSACTION_INVALID;
 		} finally {
 			// Rollback repository changes made by test-processing transactions above
@@ -1195,7 +1247,7 @@ public class Block {
 	 */
 	private ValidationResult areAtsValid() throws DataException {
 		// Locally generated AT states should be valid so no need to re-execute them
-		if (this.ourAtStates == this.getATStates()) // Note object reference compare
+		if (this.ourAtStates != null && this.ourAtStates == this.atStates) // Note object reference compare
 			return ValidationResult.OK;
 
 		// Generate local AT states for comparison
@@ -1209,8 +1261,33 @@ public class Block {
 		if (this.ourAtFees != this.blockData.getATFees())
 			return ValidationResult.AT_STATES_MISMATCH;
 
-		// Note: this.atStates fully loaded thanks to this.getATStates() call above
-		for (int s = 0; s < this.atStates.size(); ++s) {
+		// If we have a single AT states hash then compare that in preference
+		if (this.atStatesHash != null) {
+			int atBytesLength = blockData.getATCount() * BlockTransformer.AT_ENTRY_LENGTH;
+			ByteArrayOutputStream atHashBytes = new ByteArrayOutputStream(atBytesLength);
+
+			try {
+				for (ATStateData atStateData : this.ourAtStates) {
+					atHashBytes.write(atStateData.getATAddress().getBytes(StandardCharsets.UTF_8));
+					atHashBytes.write(atStateData.getStateHash());
+					atHashBytes.write(Longs.toByteArray(atStateData.getFees()));
+				}
+			} catch (IOException e) {
+				throw new DataException("Couldn't validate AT states hash due to serialization issue?", e);
+			}
+
+			byte[] ourAtStatesHash = Crypto.digest(atHashBytes.toByteArray());
+			if (!Arrays.equals(ourAtStatesHash, this.atStatesHash))
+				return ValidationResult.AT_STATES_MISMATCH;
+
+			// Use our AT state data from now on
+			this.atStates = this.ourAtStates;
+			return ValidationResult.OK;
+		}
+
+		// Note: this.atStates fully loaded thanks to this.getATStates() call:
+		this.getATStates();
+		for (int s = 0; s < this.ourAtStates.size(); ++s) {
 			ATStateData ourAtState = this.ourAtStates.get(s);
 			ATStateData theirAtState = this.atStates.get(s);
 
@@ -1368,9 +1445,6 @@ public class Block {
 
 		postBlockTidy();
 
-		// Give Controller our cached, valid online accounts data (if any) to help reduce CPU load for next block
-		Controller.getInstance().pushLatestBlocksOnlineAccounts(this.cachedValidOnlineAccounts);
-
 		// Log some debugging info relating to the block weight calculation
 		this.logDebugInfo();
 	}
@@ -1586,9 +1660,6 @@ public class Block {
 		this.blockData.setHeight(null);
 
 		postBlockTidy();
-
-		// Remove any cached, valid online accounts data from Controller
-		Controller.getInstance().popLatestBlocksOnlineAccounts();
 	}
 
 	protected void orphanTransactionsFromBlock() throws DataException {
@@ -1826,12 +1897,67 @@ public class Block {
 		final boolean haveFounders = !onlineFounderAccounts.isEmpty();
 
 		// Determine reward candidates based on account level
-		List<AccountLevelShareBin> accountLevelShareBins = BlockChain.getInstance().getAccountLevelShareBins();
-		for (int binIndex = 0; binIndex < accountLevelShareBins.size(); ++binIndex) {
-			// Find all accounts in share bin. getShareBin() returns null for minter accounts that are also founders, so they are effectively filtered out.
+		// This needs a deep copy, so the shares can be modified when tiers aren't activated yet
+		List<AccountLevelShareBin> accountLevelShareBins = new ArrayList<>();
+		for (AccountLevelShareBin accountLevelShareBin : BlockChain.getInstance().getAccountLevelShareBins()) {
+			accountLevelShareBins.add((AccountLevelShareBin) accountLevelShareBin.clone());
+		}
+
+		Map<Integer, List<ExpandedAccount>> accountsForShareBin = new HashMap<>();
+
+		// We might need to combine some share bins if they haven't reached the minimum number of minters yet
+		for (int binIndex = accountLevelShareBins.size()-1; binIndex >= 0; --binIndex) {
 			AccountLevelShareBin accountLevelShareBin = accountLevelShareBins.get(binIndex);
-			// Object reference compare is OK as all references are read-only from blockchain config.
-			List<ExpandedAccount> binnedAccounts = expandedAccounts.stream().filter(accountInfo -> accountInfo.getShareBin(this.blockData.getHeight()) == accountLevelShareBin).collect(Collectors.toList());
+
+			// Find all accounts in share bin. getShareBin() returns null for minter accounts that are also founders, so they are effectively filtered out.
+			List<ExpandedAccount> binnedAccounts = expandedAccounts.stream().filter(accountInfo -> accountInfo.hasShareBin(accountLevelShareBin, this.blockData.getHeight())).collect(Collectors.toList());
+			// Add any accounts that have been moved down from a higher tier
+			List<ExpandedAccount> existingBinnedAccounts = accountsForShareBin.get(binIndex);
+			if (existingBinnedAccounts != null)
+				binnedAccounts.addAll(existingBinnedAccounts);
+
+			// Logic below may only apply to higher levels, and only for share bins with a specific range of online accounts
+			if (accountLevelShareBin.levels.get(0) < BlockChain.getInstance().getShareBinActivationMinLevel() ||
+					binnedAccounts.isEmpty() || binnedAccounts.size() >= BlockChain.getInstance().getMinAccountsToActivateShareBin()) {
+				// Add all accounts for this share bin to the accountsForShareBin list
+				accountsForShareBin.put(binIndex, binnedAccounts);
+				continue;
+			}
+
+			// Share bin contains more than one, but less than the minimum number of minters. We treat this share bin
+			// as not activated yet. In these cases, the rewards and minters are combined and paid out to the previous
+			// share bin, to prevent a single or handful of accounts receiving the entire rewards for a share bin.
+			//
+			// Example:
+			//
+			// - Share bin for levels 5 and 6 has 100 minters
+			// - Share bin for levels 7 and 8 has 10 minters
+			//
+			// This is below the minimum of 30, so share bins are reconstructed as follows:
+			//
+			// - Share bin for levels 5 and 6 now contains 110 minters
+			// - Share bin for levels 7 and 8 now contains 0 minters
+			// - Share bin for levels 5 and 6 now pays out rewards for levels 5, 6, 7, and 8
+			// - Share bin for levels 7 and 8 pays zero rewards
+			//
+			// This process is iterative, so will combine several tiers if needed.
+
+			// Designate this share bin as empty
+			accountsForShareBin.put(binIndex, new ArrayList<>());
+
+			// Move the accounts originally intended for this share bin to the previous one
+			accountsForShareBin.put(binIndex - 1, binnedAccounts);
+
+			// Move the block reward from this share bin to the previous one
+			AccountLevelShareBin previousShareBin = accountLevelShareBins.get(binIndex - 1);
+			previousShareBin.share += accountLevelShareBin.share;
+			accountLevelShareBin.share = 0L;
+		}
+
+		// Now loop through (potentially modified) share bins and determine the reward candidates
+		for (int binIndex = 0; binIndex < accountLevelShareBins.size(); ++binIndex) {
+			AccountLevelShareBin accountLevelShareBin = accountLevelShareBins.get(binIndex);
+			List<ExpandedAccount> binnedAccounts = accountsForShareBin.get(binIndex);
 
 			// No online accounts in this bin? Skip to next one
 			if (binnedAccounts.isEmpty())
@@ -2029,6 +2155,26 @@ public class Block {
 		this.repository.getAccountRepository().tidy();
 	}
 
+	// Utils
+
+	/**
+	 * Find index of rewardSharePublicKey in list of rewardSharePublicKeys
+	 *
+	 * @param rewardSharePublicKey - the key to query
+	 * @param rewardSharePublicKeys - a sorted list of keys
+	 * @return - the index of the key, or null if not found
+	 */
+	private static Integer getRewardShareIndex(byte[] rewardSharePublicKey, List<byte[]> rewardSharePublicKeys) {
+		int index = 0;
+		for (byte[] publicKey : rewardSharePublicKeys) {
+			if (Arrays.equals(rewardSharePublicKey, publicKey)) {
+				return index;
+			}
+			index++;
+		}
+		return null;
+	}
+
 	private void logDebugInfo() {
 		try {
 			// Avoid calculations if possible. We have to check against INFO here, since Level.isMoreSpecificThan() confusingly uses <= rather than just <

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

@@ -68,14 +68,22 @@ public class BlockChain {
 		atFindNextTransactionFix,
 		newBlockSigHeight,
 		shareBinFix,
+		rewardShareLimitTimestamp,
 		calcChainWeightTimestamp,
-		transactionV5Timestamp;
+		transactionV5Timestamp,
+		transactionV6Timestamp,
+		disableReferenceTimestamp,
+		aggregateSignatureTimestamp;
 	}
 
 	// Custom transaction fees
-	@XmlJavaTypeAdapter(value = org.qortal.api.AmountTypeAdapter.class)
-	private long nameRegistrationUnitFee;
-	private long nameRegistrationUnitFeeTimestamp;
+	/** Unit fees by transaction timestamp */
+	public static class UnitFeesByTimestamp {
+		public long timestamp;
+		@XmlJavaTypeAdapter(value = org.qortal.api.AmountTypeAdapter.class)
+		public long fee;
+	}
+	private List<UnitFeesByTimestamp> nameRegistrationUnitFees;
 
 	/** Map of which blockchain features are enabled when (height/timestamp) */
 	@XmlJavaTypeAdapter(StringLongMapXmlAdapter.class)
@@ -96,10 +104,23 @@ public class BlockChain {
 	private List<RewardByHeight> rewardsByHeight;
 
 	/** Share of block reward/fees by account level */
-	public static class AccountLevelShareBin {
+	public static class AccountLevelShareBin implements Cloneable {
+		public int id;
 		public List<Integer> levels;
 		@XmlJavaTypeAdapter(value = org.qortal.api.AmountTypeAdapter.class)
 		public long share;
+
+		public Object clone() {
+			AccountLevelShareBin shareBinCopy = new AccountLevelShareBin();
+			List<Integer> levelsCopy = new ArrayList<>();
+			for (Integer level : this.levels) {
+				levelsCopy.add(level);
+			}
+			shareBinCopy.id = this.id;
+			shareBinCopy.levels = levelsCopy;
+			shareBinCopy.share = this.share;
+			return shareBinCopy;
+		}
 	}
 	private List<AccountLevelShareBin> sharesByLevel;
 	/** Generated lookup of share-bin by account level */
@@ -113,6 +134,12 @@ public class BlockChain {
 	@XmlJavaTypeAdapter(value = org.qortal.api.AmountTypeAdapter.class)
 	private Long qoraPerQortReward;
 
+	/** Minimum number of accounts before a share bin is considered activated */
+	private int minAccountsToActivateShareBin;
+
+	/** Min level at which share bin activation takes place; lower levels allow less than minAccountsPerShareBin */
+	private int shareBinActivationMinLevel;
+
 	/**
 	 * Number of minted blocks required to reach next level from previous.
 	 * <p>
@@ -150,7 +177,7 @@ public class BlockChain {
 	private int minAccountLevelToMint;
 	private int minAccountLevelForBlockSubmissions;
 	private int minAccountLevelToRewardShare;
-	private int maxRewardSharesPerMintingAccount;
+	private int maxRewardSharesPerFounderMintingAccount;
 	private int founderEffectiveMintingLevel;
 
 	/** Minimum time to retain online account signatures (ms) for block validity checks. */
@@ -158,6 +185,17 @@ public class BlockChain {
 	/** Maximum time to retain online account signatures (ms) for block validity checks, to allow for clock variance. */
 	private long onlineAccountSignaturesMaxLifetime;
 
+	/** Feature trigger timestamp for ONLINE_ACCOUNTS_MODULUS time interval increase. Can't use
+	 * featureTriggers because unit tests need to set this value via Reflection. */
+	private long onlineAccountsModulusV2Timestamp;
+
+	/** Max reward shares by block height */
+	public static class MaxRewardSharesByTimestamp {
+		public long timestamp;
+		public int maxShares;
+	}
+	private List<MaxRewardSharesByTimestamp> maxRewardSharesByTimestamp;
+
 	/** Settings relating to CIYAM AT feature. */
 	public static class CiyamAtSettings {
 		/** Fee per step/op-code executed. */
@@ -306,14 +344,9 @@ public class BlockChain {
 		return this.maxBlockSize;
 	}
 
-	// Custom transaction fees
-	public long getNameRegistrationUnitFee() {
-		return this.nameRegistrationUnitFee;
-	}
-
-	public long getNameRegistrationUnitFeeTimestamp() {
-		// FUTURE: we could use a separate structure to indicate fee adjustments for different transaction types
-		return this.nameRegistrationUnitFeeTimestamp;
+	// Online accounts
+	public long getOnlineAccountsModulusV2Timestamp() {
+		return this.onlineAccountsModulusV2Timestamp;
 	}
 
 	/** Returns true if approval-needing transaction types require a txGroupId other than NO_GROUP. */
@@ -357,6 +390,14 @@ public class BlockChain {
 		return this.qoraPerQortReward;
 	}
 
+	public int getMinAccountsToActivateShareBin() {
+		return this.minAccountsToActivateShareBin;
+	}
+
+	public int getShareBinActivationMinLevel() {
+		return this.shareBinActivationMinLevel;
+	}
+
 	public int getMinAccountLevelToMint() {
 		return this.minAccountLevelToMint;
 	}
@@ -369,8 +410,8 @@ public class BlockChain {
 		return this.minAccountLevelToRewardShare;
 	}
 
-	public int getMaxRewardSharesPerMintingAccount() {
-		return this.maxRewardSharesPerMintingAccount;
+	public int getMaxRewardSharesPerFounderMintingAccount() {
+		return this.maxRewardSharesPerFounderMintingAccount;
 	}
 
 	public int getFounderEffectiveMintingLevel() {
@@ -403,6 +444,10 @@ public class BlockChain {
 		return this.featureTriggers.get(FeatureTrigger.shareBinFix.name()).intValue();
 	}
 
+	public long getRewardShareLimitTimestamp() {
+		return this.featureTriggers.get(FeatureTrigger.rewardShareLimitTimestamp.name()).longValue();
+	}
+
 	public long getCalcChainWeightTimestamp() {
 		return this.featureTriggers.get(FeatureTrigger.calcChainWeightTimestamp.name()).longValue();
 	}
@@ -411,6 +456,18 @@ public class BlockChain {
 		return this.featureTriggers.get(FeatureTrigger.transactionV5Timestamp.name()).longValue();
 	}
 
+	public long getTransactionV6Timestamp() {
+		return this.featureTriggers.get(FeatureTrigger.transactionV6Timestamp.name()).longValue();
+	}
+
+	public long getDisableReferenceTimestamp() {
+		return this.featureTriggers.get(FeatureTrigger.disableReferenceTimestamp.name()).longValue();
+	}
+
+	public long getAggregateSignatureTimestamp() {
+		return this.featureTriggers.get(FeatureTrigger.aggregateSignatureTimestamp.name()).longValue();
+	}
+
 	// More complex getters for aspects that change by height or timestamp
 
 	public long getRewardAtHeight(int ourHeight) {
@@ -430,6 +487,23 @@ public class BlockChain {
 		throw new IllegalStateException(String.format("No block timing info available for height %d", ourHeight));
 	}
 
+	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();
+	}
+
+	public int getMaxRewardSharesAtTimestamp(long ourTimestamp) {
+		for (int i = maxRewardSharesByTimestamp.size() - 1; i >= 0; --i)
+			if (maxRewardSharesByTimestamp.get(i).timestamp <= ourTimestamp)
+				return maxRewardSharesByTimestamp.get(i).maxShares;
+
+		return 0;
+	}
+
 	/** Validate blockchain config read from JSON */
 	private void validateConfig() {
 		if (this.genesisInfo == null)

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

@@ -15,6 +15,7 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.concurrent.TimeoutException;
+import java.util.stream.Collectors;
 
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
@@ -40,6 +41,7 @@ public class AutoUpdate extends Thread {
 
 	public static final String JAR_FILENAME = "qortal.jar";
 	public static final String NEW_JAR_FILENAME = "new-" + JAR_FILENAME;
+	public static final String AGENTLIB_JVM_HOLDER_ARG = "-DQORTAL_agentlib=";
 
 	private static final Logger LOGGER = LogManager.getLogger(AutoUpdate.class);
 	private static final long CHECK_INTERVAL = 20 * 60 * 1000L; // ms
@@ -243,6 +245,11 @@ public class AutoUpdate extends Thread {
 			// JVM arguments
 			javaCmd.addAll(ManagementFactory.getRuntimeMXBean().getInputArguments());
 
+			// Disable, but retain, any -agentlib JVM arg as sub-process might fail if it tries to reuse same port
+			javaCmd = javaCmd.stream()
+					.map(arg -> arg.replace("-agentlib", AGENTLIB_JVM_HOLDER_ARG))
+					.collect(Collectors.toList());
+
 			// Remove JNI options as they won't be supported by command-line 'java'
 			// These are typically added by the AdvancedInstaller Java launcher EXE
 			javaCmd.removeAll(Arrays.asList("abort", "exit", "vfprintf"));
@@ -261,10 +268,19 @@ public class AutoUpdate extends Thread {
 					Translator.INSTANCE.translate("SysTray", "APPLYING_UPDATE_AND_RESTARTING"),
 					MessageType.INFO);
 
-			new ProcessBuilder(javaCmd).start();
+			ProcessBuilder processBuilder = new ProcessBuilder(javaCmd);
+
+			// New process will inherit our stdout and stderr
+			processBuilder.redirectOutput(ProcessBuilder.Redirect.INHERIT);
+			processBuilder.redirectError(ProcessBuilder.Redirect.INHERIT);
+
+			Process process = processBuilder.start();
+
+			// Nothing to pipe to new process, so close output stream (process's stdin)
+			process.getOutputStream().close();
 
 			return true; // applying update OK
-		} catch (IOException e) {
+		} catch (Exception e) {
 			LOGGER.error(String.format("Failed to apply update: %s", e.getMessage()));
 
 			try {

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

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

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

@@ -0,0 +1,189 @@
+package org.qortal.controller;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.qortal.data.account.AccountBalanceData;
+import org.qortal.data.account.AccountData;
+import org.qortal.data.naming.NameData;
+import org.qortal.data.transaction.TransactionData;
+import org.qortal.network.Network;
+import org.qortal.network.Peer;
+import org.qortal.network.message.*;
+
+import java.security.SecureRandom;
+import java.util.*;
+
+import static org.qortal.network.message.MessageType.*;
+
+public class LiteNode {
+
+    private static final Logger LOGGER = LogManager.getLogger(LiteNode.class);
+
+    private static LiteNode instance;
+
+
+    public Map<Integer, Long> pendingRequests = Collections.synchronizedMap(new HashMap<>());
+
+    public int MAX_TRANSACTIONS_PER_MESSAGE = 100;
+
+
+    public LiteNode() {
+
+    }
+
+    public static synchronized LiteNode getInstance() {
+        if (instance == null) {
+            instance = new LiteNode();
+        }
+
+        return instance;
+    }
+
+
+    /**
+     * Fetch account data from peers for given QORT address
+     * @param address - the QORT address to query
+     * @return accountData - the account data for this address, or null if not retrieved
+     */
+    public AccountData fetchAccountData(String address) {
+        GetAccountMessage getAccountMessage = new GetAccountMessage(address);
+        AccountMessage accountMessage = (AccountMessage) this.sendMessage(getAccountMessage, ACCOUNT);
+        if (accountMessage == null) {
+            return null;
+        }
+        return accountMessage.getAccountData();
+    }
+
+    /**
+     * Fetch account balance data from peers for given QORT address and asset ID
+     * @param address - the QORT address to query
+     * @return balance - the balance for this address and assetId, or null if not retrieved
+     */
+    public AccountBalanceData fetchAccountBalance(String address, long assetId) {
+        GetAccountBalanceMessage getAccountMessage = new GetAccountBalanceMessage(address, assetId);
+        AccountBalanceMessage accountMessage = (AccountBalanceMessage) this.sendMessage(getAccountMessage, ACCOUNT_BALANCE);
+        if (accountMessage == null) {
+            return null;
+        }
+        return accountMessage.getAccountBalanceData();
+    }
+
+    /**
+     * Fetch list of transactions for given QORT address
+     * @param address - the QORT address to query
+     * @param limit - the maximum number of results to return
+     * @param offset - the starting index
+     * @return a list of TransactionData objects, or null if not retrieved
+     */
+    public List<TransactionData> fetchAccountTransactions(String address, int limit, int offset) {
+        List<TransactionData> allTransactions = new ArrayList<>();
+        if (limit == 0) {
+            limit = Integer.MAX_VALUE;
+        }
+        int batchSize = Math.min(limit, MAX_TRANSACTIONS_PER_MESSAGE);
+
+        while (allTransactions.size() < limit) {
+            GetAccountTransactionsMessage getAccountTransactionsMessage = new GetAccountTransactionsMessage(address, batchSize, offset);
+            TransactionsMessage transactionsMessage = (TransactionsMessage) this.sendMessage(getAccountTransactionsMessage, TRANSACTIONS);
+            if (transactionsMessage == null) {
+                // An error occurred, so give up instead of returning partial results
+                return null;
+            }
+            allTransactions.addAll(transactionsMessage.getTransactions());
+            if (transactionsMessage.getTransactions().size() < batchSize) {
+                // No more transactions to fetch
+                break;
+            }
+            offset += batchSize;
+        }
+        return allTransactions;
+    }
+
+    /**
+     * Fetch list of names for given QORT address
+     * @param address - the QORT address to query
+     * @return a list of NameData objects, or null if not retrieved
+     */
+    public List<NameData> fetchAccountNames(String address) {
+        GetAccountNamesMessage getAccountNamesMessage = new GetAccountNamesMessage(address);
+        NamesMessage namesMessage = (NamesMessage) this.sendMessage(getAccountNamesMessage, NAMES);
+        if (namesMessage == null) {
+            return null;
+        }
+        return namesMessage.getNameDataList();
+    }
+
+    /**
+     * Fetch info about a registered name
+     * @param name - the name to query
+     * @return a NameData object, or null if not retrieved
+     */
+    public NameData fetchNameData(String name) {
+        GetNameMessage getNameMessage = new GetNameMessage(name);
+        NamesMessage namesMessage = (NamesMessage) this.sendMessage(getNameMessage, NAMES);
+        if (namesMessage == null) {
+            return null;
+        }
+        List<NameData> nameDataList = namesMessage.getNameDataList();
+        if (nameDataList == null || nameDataList.size() != 1) {
+            return null;
+        }
+        // We are only expecting a single item in the list
+        return nameDataList.get(0);
+    }
+
+
+    private Message sendMessage(Message message, MessageType expectedResponseMessageType) {
+        // This asks a random peer for the data
+        // TODO: ask multiple peers, and disregard everything if there are any significant differences in the responses
+
+        // Needs a mutable copy of the unmodifiableList
+        List<Peer> peers = new ArrayList<>(Network.getInstance().getImmutableHandshakedPeers());
+
+        // Disregard peers that have "misbehaved" recently
+        peers.removeIf(Controller.hasMisbehaved);
+
+        // Disregard peers that only have genesis block
+        // TODO: peers.removeIf(Controller.hasOnlyGenesisBlock);
+
+        // Disregard peers that are on an old version
+        peers.removeIf(Controller.hasOldVersion);
+
+        // Disregard peers that are on a known inferior chain tip
+        // TODO: peers.removeIf(Controller.hasInferiorChainTip);
+
+        if (peers.isEmpty()) {
+            LOGGER.info("No peers available to send {} message to", message.getType());
+            return null;
+        }
+
+        // Pick random peer
+        int index = new SecureRandom().nextInt(peers.size());
+        Peer peer = peers.get(index);
+
+        LOGGER.info("Sending {} message to peer {}...", message.getType(), peer);
+
+        Message responseMessage;
+
+        try {
+            responseMessage = peer.getResponse(message);
+
+        } catch (InterruptedException e) {
+            return null;
+        }
+
+        if (responseMessage == null) {
+            LOGGER.info("Peer {} didn't respond to {} message", peer, message.getType());
+            return null;
+        }
+        else if (responseMessage.getType() != expectedResponseMessageType) {
+            LOGGER.info("Peer responded with unexpected message type {} (should be {})", peer, responseMessage.getType(), expectedResponseMessageType);
+            return null;
+        }
+
+        LOGGER.info("Peer {} responded with {} message", peer, responseMessage.getType());
+
+        return responseMessage;
+    }
+
+}

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

@@ -0,0 +1,729 @@
+package org.qortal.controller;
+
+import com.google.common.hash.HashCode;
+import com.google.common.primitives.Longs;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.qortal.account.Account;
+import org.qortal.account.PrivateKeyAccount;
+import org.qortal.block.Block;
+import org.qortal.block.BlockChain;
+import org.qortal.crypto.Crypto;
+import org.qortal.crypto.Qortal25519Extras;
+import org.qortal.data.account.MintingAccountData;
+import org.qortal.data.account.RewardShareData;
+import org.qortal.data.network.OnlineAccountData;
+import org.qortal.network.Network;
+import org.qortal.network.Peer;
+import org.qortal.network.message.*;
+import org.qortal.repository.DataException;
+import org.qortal.repository.Repository;
+import org.qortal.repository.RepositoryManager;
+import org.qortal.utils.Base58;
+import org.qortal.utils.NTP;
+import org.qortal.utils.NamedThreadFactory;
+
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.stream.Collectors;
+
+public class OnlineAccountsManager {
+
+    private static final Logger LOGGER = LogManager.getLogger(OnlineAccountsManager.class);
+
+    // 'Current' as in 'now'
+
+    /**
+     * How long online accounts signatures last before they expire.
+     */
+    private static final long ONLINE_TIMESTAMP_MODULUS_V1 = 5 * 60 * 1000L;
+    private static final long ONLINE_TIMESTAMP_MODULUS_V2 = 30 * 60 * 1000L;
+
+    /**
+     * How many 'current' timestamp-sets of online accounts we cache.
+     */
+    private static final int MAX_CACHED_TIMESTAMP_SETS = 2;
+
+    /**
+     * How many timestamp-sets of online accounts we cache for 'latest blocks'.
+     */
+    private static final int MAX_BLOCKS_CACHED_ONLINE_ACCOUNTS = 3;
+
+    private static final long ONLINE_ACCOUNTS_QUEUE_INTERVAL = 100L; //ms
+    private static final long ONLINE_ACCOUNTS_TASKS_INTERVAL = 10 * 1000L; // ms
+    private static final long ONLINE_ACCOUNTS_LEGACY_BROADCAST_INTERVAL = 60 * 1000L; // ms
+    private static final long ONLINE_ACCOUNTS_BROADCAST_INTERVAL = 15 * 1000L; // ms
+
+    private static final long ONLINE_ACCOUNTS_V2_PEER_VERSION = 0x0300020000L; // v3.2.0
+    private static final long ONLINE_ACCOUNTS_V3_PEER_VERSION = 0x0300040000L; // v3.4.0
+
+    private final ScheduledExecutorService executor = Executors.newScheduledThreadPool(4, new NamedThreadFactory("OnlineAccounts"));
+    private volatile boolean isStopping = false;
+
+    private final Set<OnlineAccountData> onlineAccountsImportQueue = ConcurrentHashMap.newKeySet();
+
+    /**
+     * Cache of 'current' online accounts, keyed by timestamp
+     */
+    private final Map<Long, Set<OnlineAccountData>> currentOnlineAccounts = new ConcurrentHashMap<>();
+    /**
+     * Cache of hash-summary of 'current' online accounts, keyed by timestamp, then leading byte of public key.
+     */
+    private final Map<Long, Map<Byte, byte[]>> currentOnlineAccountsHashes = new ConcurrentHashMap<>();
+
+    /**
+     * Cache of online accounts for latest blocks - not necessarily 'current' / now.
+     * <i>Probably</i> only accessed / modified by a single Synchronizer thread.
+     */
+    private final SortedMap<Long, Set<OnlineAccountData>> latestBlocksOnlineAccounts = new ConcurrentSkipListMap<>();
+
+    private boolean hasOurOnlineAccounts = false;
+
+    public static long getOnlineTimestampModulus() {
+        Long now = NTP.getTime();
+        if (now != null && now >= BlockChain.getInstance().getOnlineAccountsModulusV2Timestamp()) {
+            return ONLINE_TIMESTAMP_MODULUS_V2;
+        }
+        return ONLINE_TIMESTAMP_MODULUS_V1;
+    }
+    public static Long getCurrentOnlineAccountTimestamp() {
+        Long now = NTP.getTime();
+        if (now == null)
+            return null;
+
+        long onlineTimestampModulus = getOnlineTimestampModulus();
+        return (now / onlineTimestampModulus) * onlineTimestampModulus;
+    }
+
+    private OnlineAccountsManager() {
+    }
+
+    private static class SingletonContainer {
+        private static final OnlineAccountsManager INSTANCE = new OnlineAccountsManager();
+    }
+
+    public static OnlineAccountsManager getInstance() {
+        return SingletonContainer.INSTANCE;
+    }
+
+    public void start() {
+        // Expire old online accounts signatures
+        executor.scheduleAtFixedRate(this::expireOldOnlineAccounts, ONLINE_ACCOUNTS_TASKS_INTERVAL, ONLINE_ACCOUNTS_TASKS_INTERVAL, TimeUnit.MILLISECONDS);
+
+        // Send our online accounts
+        executor.scheduleAtFixedRate(this::sendOurOnlineAccountsInfo, ONLINE_ACCOUNTS_BROADCAST_INTERVAL, ONLINE_ACCOUNTS_BROADCAST_INTERVAL, TimeUnit.MILLISECONDS);
+
+        // Request online accounts from peers (legacy)
+        executor.scheduleAtFixedRate(this::requestLegacyRemoteOnlineAccounts, ONLINE_ACCOUNTS_LEGACY_BROADCAST_INTERVAL, ONLINE_ACCOUNTS_LEGACY_BROADCAST_INTERVAL, TimeUnit.MILLISECONDS);
+        // Request online accounts from peers (V3+)
+        executor.scheduleAtFixedRate(this::requestRemoteOnlineAccounts, ONLINE_ACCOUNTS_BROADCAST_INTERVAL, ONLINE_ACCOUNTS_BROADCAST_INTERVAL, TimeUnit.MILLISECONDS);
+
+        // Process import queue
+        executor.scheduleWithFixedDelay(this::processOnlineAccountsImportQueue, ONLINE_ACCOUNTS_QUEUE_INTERVAL, ONLINE_ACCOUNTS_QUEUE_INTERVAL, TimeUnit.MILLISECONDS);
+    }
+
+    public void shutdown() {
+        isStopping = true;
+        executor.shutdownNow();
+    }
+
+    // Testing support
+    public void ensureTestingAccountsOnline(PrivateKeyAccount... onlineAccounts) {
+        if (!BlockChain.getInstance().isTestChain()) {
+            LOGGER.warn("Ignoring attempt to ensure test account is online for non-test chain!");
+            return;
+        }
+
+        final Long onlineAccountsTimestamp = getCurrentOnlineAccountTimestamp();
+        if (onlineAccountsTimestamp == null)
+            return;
+
+        byte[] timestampBytes = Longs.toByteArray(onlineAccountsTimestamp);
+        final boolean useAggregateCompatibleSignature = onlineAccountsTimestamp >= BlockChain.getInstance().getAggregateSignatureTimestamp();
+
+        Set<OnlineAccountData> replacementAccounts = new HashSet<>();
+        for (PrivateKeyAccount onlineAccount : onlineAccounts) {
+            // Check mintingAccount is actually reward-share?
+
+            byte[] signature = useAggregateCompatibleSignature
+                    ? Qortal25519Extras.signForAggregation(onlineAccount.getPrivateKey(), timestampBytes)
+                    : onlineAccount.sign(timestampBytes);
+            byte[] publicKey = onlineAccount.getPublicKey();
+
+            OnlineAccountData ourOnlineAccountData = new OnlineAccountData(onlineAccountsTimestamp, signature, publicKey);
+            replacementAccounts.add(ourOnlineAccountData);
+        }
+
+        this.currentOnlineAccounts.clear();
+        addAccounts(replacementAccounts);
+    }
+
+    // Online accounts import queue
+
+    private void processOnlineAccountsImportQueue() {
+        if (this.onlineAccountsImportQueue.isEmpty())
+            // Nothing to do
+            return;
+
+        LOGGER.debug("Processing online accounts import queue (size: {})", this.onlineAccountsImportQueue.size());
+
+        Set<OnlineAccountData> onlineAccountsToAdd = new HashSet<>();
+        try (final Repository repository = RepositoryManager.getRepository()) {
+            for (OnlineAccountData onlineAccountData : this.onlineAccountsImportQueue) {
+                if (isStopping)
+                    return;
+
+                boolean isValid = this.isValidCurrentAccount(repository, onlineAccountData);
+                if (isValid)
+                    onlineAccountsToAdd.add(onlineAccountData);
+
+                // Remove from queue
+                onlineAccountsImportQueue.remove(onlineAccountData);
+            }
+        } catch (DataException e) {
+            LOGGER.error("Repository issue while verifying online accounts", e);
+        }
+
+        if (!onlineAccountsToAdd.isEmpty()) {
+            LOGGER.debug("Merging {} validated online accounts from import queue", onlineAccountsToAdd.size());
+            addAccounts(onlineAccountsToAdd);
+        }
+    }
+
+    // Utilities
+
+    public static byte[] xorByteArrayInPlace(byte[] inplaceArray, byte[] otherArray) {
+        if (inplaceArray == null)
+            return Arrays.copyOf(otherArray, otherArray.length);
+
+        // Start from index 1 to enforce static leading byte
+        for (int i = 1; i < otherArray.length; i++)
+            inplaceArray[i] ^= otherArray[i];
+
+        return inplaceArray;
+    }
+
+    private static boolean isValidCurrentAccount(Repository repository, OnlineAccountData onlineAccountData) throws DataException {
+        final Long now = NTP.getTime();
+        if (now == null)
+            return false;
+
+        byte[] rewardSharePublicKey = onlineAccountData.getPublicKey();
+        long onlineAccountTimestamp = onlineAccountData.getTimestamp();
+
+        // Check timestamp is 'recent' here
+        if (Math.abs(onlineAccountTimestamp - now) > getOnlineTimestampModulus() * 2) {
+            LOGGER.trace(() -> String.format("Rejecting online account %s with out of range timestamp %d", Base58.encode(rewardSharePublicKey), onlineAccountTimestamp));
+            return false;
+        }
+
+        // Check timestamp is a multiple of online timestamp modulus
+        if (onlineAccountTimestamp % getOnlineTimestampModulus() != 0) {
+            LOGGER.trace(() -> String.format("Rejecting online account %s with invalid timestamp %d", Base58.encode(rewardSharePublicKey), onlineAccountTimestamp));
+            return false;
+        }
+
+        // Verify signature
+        byte[] data = Longs.toByteArray(onlineAccountData.getTimestamp());
+        boolean isSignatureValid = onlineAccountTimestamp >= BlockChain.getInstance().getAggregateSignatureTimestamp()
+                ? Qortal25519Extras.verifyAggregated(rewardSharePublicKey, onlineAccountData.getSignature(), data)
+                : Crypto.verify(rewardSharePublicKey, onlineAccountData.getSignature(), data);
+        if (!isSignatureValid) {
+            LOGGER.trace(() -> String.format("Rejecting invalid online account %s", Base58.encode(rewardSharePublicKey)));
+            return false;
+        }
+
+        // Qortal: check online account is actually reward-share
+        RewardShareData rewardShareData = repository.getAccountRepository().getRewardShare(rewardSharePublicKey);
+        if (rewardShareData == null) {
+            // Reward-share doesn't even exist - probably not a good sign
+            LOGGER.trace(() -> String.format("Rejecting unknown online reward-share public key %s", Base58.encode(rewardSharePublicKey)));
+            return false;
+        }
+
+        Account mintingAccount = new Account(repository, rewardShareData.getMinter());
+        if (!mintingAccount.canMint()) {
+            // Minting-account component of reward-share can no longer mint - disregard
+            LOGGER.trace(() -> String.format("Rejecting online reward-share with non-minting account %s", mintingAccount.getAddress()));
+            return false;
+        }
+
+        return true;
+    }
+
+    /** Adds accounts, maybe rebuilds hashes, returns whether any new accounts were added / hashes rebuilt. */
+    private boolean addAccounts(Collection<OnlineAccountData> onlineAccountsToAdd) {
+        // For keeping track of which hashes to rebuild
+        Map<Long, Set<Byte>> hashesToRebuild = new HashMap<>();
+
+        for (OnlineAccountData onlineAccountData : onlineAccountsToAdd) {
+            boolean isNewEntry = this.addAccount(onlineAccountData);
+
+            if (isNewEntry)
+                hashesToRebuild.computeIfAbsent(onlineAccountData.getTimestamp(), k -> new HashSet<>()).add(onlineAccountData.getPublicKey()[0]);
+        }
+
+        if (hashesToRebuild.isEmpty())
+            return false;
+
+        for (var entry : hashesToRebuild.entrySet()) {
+            Long timestamp = entry.getKey();
+
+            LOGGER.debug(() -> String.format("Rehashing for timestamp %d and leading bytes %s",
+                            timestamp,
+                            entry.getValue().stream().sorted(Byte::compareUnsigned).map(leadingByte -> String.format("%02x", leadingByte)).collect(Collectors.joining(", "))
+                    )
+            );
+
+            for (Byte leadingByte : entry.getValue()) {
+                byte[] pubkeyHash = currentOnlineAccounts.get(timestamp).stream()
+                        .map(OnlineAccountData::getPublicKey)
+                        .filter(publicKey -> leadingByte == publicKey[0])
+                        .reduce(null, OnlineAccountsManager::xorByteArrayInPlace);
+
+                currentOnlineAccountsHashes.computeIfAbsent(timestamp, k -> new ConcurrentHashMap<>()).put(leadingByte, pubkeyHash);
+
+                LOGGER.trace(() -> String.format("Rebuilt hash %s for timestamp %d and leading byte %02x using %d public keys",
+                        HashCode.fromBytes(pubkeyHash),
+                        timestamp,
+                        leadingByte,
+                        currentOnlineAccounts.get(timestamp).stream()
+                                .map(OnlineAccountData::getPublicKey)
+                                .filter(publicKey -> leadingByte == publicKey[0])
+                                .count()
+                ));
+            }
+        }
+
+        LOGGER.debug(String.format("we have online accounts for timestamps: %s", String.join(", ", this.currentOnlineAccounts.keySet().stream().map(l -> Long.toString(l)).collect(Collectors.joining(", ")))));
+
+        return true;
+    }
+
+    private boolean addAccount(OnlineAccountData onlineAccountData) {
+        byte[] rewardSharePublicKey = onlineAccountData.getPublicKey();
+        long onlineAccountTimestamp = onlineAccountData.getTimestamp();
+
+        Set<OnlineAccountData> onlineAccounts = this.currentOnlineAccounts.computeIfAbsent(onlineAccountTimestamp, k -> ConcurrentHashMap.newKeySet());
+        boolean isNewEntry = onlineAccounts.add(onlineAccountData);
+
+        if (isNewEntry)
+            LOGGER.trace(() -> String.format("Added online account %s with timestamp %d", Base58.encode(rewardSharePublicKey), onlineAccountTimestamp));
+        else
+            LOGGER.trace(() -> String.format("Not updating existing online account %s with timestamp %d", Base58.encode(rewardSharePublicKey), onlineAccountTimestamp));
+
+        return isNewEntry;
+    }
+
+    /**
+     * Expire old entries.
+     */
+    private void expireOldOnlineAccounts() {
+        final Long now = NTP.getTime();
+        if (now == null)
+            return;
+
+        final long cutoffThreshold = now - MAX_CACHED_TIMESTAMP_SETS * getOnlineTimestampModulus();
+        this.currentOnlineAccounts.keySet().removeIf(timestamp -> timestamp < cutoffThreshold);
+        this.currentOnlineAccountsHashes.keySet().removeIf(timestamp -> timestamp < cutoffThreshold);
+    }
+
+    /**
+     * Request data from other peers. (Pre-V3)
+     */
+    private void requestLegacyRemoteOnlineAccounts() {
+        final Long now = NTP.getTime();
+        if (now == null)
+            return;
+
+        // Don't bother if we're not up to date
+        if (!Controller.getInstance().isUpToDate())
+            return;
+
+        List<OnlineAccountData> mergedOnlineAccounts = Set.copyOf(this.currentOnlineAccounts.values()).stream().flatMap(Set::stream).collect(Collectors.toList());
+
+        Message messageV2 = new GetOnlineAccountsV2Message(mergedOnlineAccounts);
+
+        Network.getInstance().broadcast(peer ->
+                peer.getPeersVersion() < ONLINE_ACCOUNTS_V3_PEER_VERSION
+                        ? messageV2
+                        : null
+        );
+    }
+
+    /**
+     * Request data from other peers. V3+
+     */
+    private void requestRemoteOnlineAccounts() {
+        final Long now = NTP.getTime();
+        if (now == null)
+            return;
+
+        // Don't bother if we're not up to date
+        if (!Controller.getInstance().isUpToDate())
+            return;
+
+        Message messageV3 = new GetOnlineAccountsV3Message(currentOnlineAccountsHashes);
+
+        Network.getInstance().broadcast(peer ->
+                peer.getPeersVersion() >= ONLINE_ACCOUNTS_V3_PEER_VERSION
+                        ? messageV3
+                        : null
+        );
+    }
+
+    /**
+     * Send online accounts that are minting on this node.
+     */
+    private void sendOurOnlineAccountsInfo() {
+        // 'current' timestamp
+        final Long onlineAccountsTimestamp = getCurrentOnlineAccountTimestamp();
+        if (onlineAccountsTimestamp == null)
+            return;
+
+        Long now = NTP.getTime();
+        if (now == null) {
+            return;
+        }
+
+        // Don't submit if we're more than 2 hours out of sync (unless we're in recovery mode)
+        final Long minLatestBlockTimestamp = now - (2 * 60 * 60 * 1000L);
+        if (!Controller.getInstance().isUpToDate(minLatestBlockTimestamp) && !Synchronizer.getInstance().getRecoveryMode()) {
+            return;
+        }
+
+        List<MintingAccountData> mintingAccounts;
+        try (final Repository repository = RepositoryManager.getRepository()) {
+            mintingAccounts = repository.getAccountRepository().getMintingAccounts();
+
+            // We have no accounts to send
+            if (mintingAccounts.isEmpty())
+                return;
+
+            // Only active reward-shares allowed
+            Iterator<MintingAccountData> iterator = mintingAccounts.iterator();
+            while (iterator.hasNext()) {
+                MintingAccountData mintingAccountData = iterator.next();
+
+                RewardShareData rewardShareData = repository.getAccountRepository().getRewardShare(mintingAccountData.getPublicKey());
+                if (rewardShareData == null) {
+                    // Reward-share doesn't even exist - probably not a good sign
+                    iterator.remove();
+                    continue;
+                }
+
+                Account mintingAccount = new Account(repository, rewardShareData.getMinter());
+                if (!mintingAccount.canMint()) {
+                    // Minting-account component of reward-share can no longer mint - disregard
+                    iterator.remove();
+                    continue;
+                }
+            }
+        } catch (DataException e) {
+            LOGGER.warn(String.format("Repository issue trying to fetch minting accounts: %s", e.getMessage()));
+            return;
+        }
+
+        final boolean useAggregateCompatibleSignature = onlineAccountsTimestamp >= BlockChain.getInstance().getAggregateSignatureTimestamp();
+
+        byte[] timestampBytes = Longs.toByteArray(onlineAccountsTimestamp);
+        List<OnlineAccountData> ourOnlineAccounts = new ArrayList<>();
+
+        for (MintingAccountData mintingAccountData : mintingAccounts) {
+            byte[] privateKey = mintingAccountData.getPrivateKey();
+            byte[] publicKey = Crypto.toPublicKey(privateKey);
+
+            byte[] signature = useAggregateCompatibleSignature
+                    ? Qortal25519Extras.signForAggregation(privateKey, timestampBytes)
+                    : Crypto.sign(privateKey, timestampBytes);
+
+            // Our account is online
+            OnlineAccountData ourOnlineAccountData = new OnlineAccountData(onlineAccountsTimestamp, signature, publicKey);
+            ourOnlineAccounts.add(ourOnlineAccountData);
+        }
+
+        this.hasOurOnlineAccounts = !ourOnlineAccounts.isEmpty();
+
+        boolean hasInfoChanged = addAccounts(ourOnlineAccounts);
+
+        if (!hasInfoChanged)
+            return;
+
+        Message messageV1 = new OnlineAccountsMessage(ourOnlineAccounts);
+        Message messageV2 = new OnlineAccountsV2Message(ourOnlineAccounts);
+        Message messageV3 = new OnlineAccountsV2Message(ourOnlineAccounts); // TODO: V3 message
+
+        Network.getInstance().broadcast(peer ->
+                peer.getPeersVersion() >= ONLINE_ACCOUNTS_V3_PEER_VERSION
+                        ? messageV3
+                        : peer.getPeersVersion() >= ONLINE_ACCOUNTS_V2_PEER_VERSION
+                        ? messageV2
+                        : messageV1
+        );
+
+        LOGGER.debug("Broadcasted {} online account{} with timestamp {}", ourOnlineAccounts.size(), (ourOnlineAccounts.size() != 1 ? "s" : ""), onlineAccountsTimestamp);
+    }
+
+    /**
+     * Returns whether online accounts manager has any online accounts with timestamp recent enough to be considered currently online.
+     */
+    // BlockMinter: only calls this to check whether returned list is empty or not, to determine whether minting is even possible or not
+    public boolean hasOnlineAccounts() {
+        // 'current' timestamp
+        final Long onlineAccountsTimestamp = getCurrentOnlineAccountTimestamp();
+        if (onlineAccountsTimestamp == null)
+            return false;
+
+        return this.currentOnlineAccounts.containsKey(onlineAccountsTimestamp);
+    }
+
+    /**
+     * Whether we have submitted - or attempted to submit - our online account
+     * signature(s) to the network.
+     * @return true if our signature(s) have been submitted recently.
+     */
+    public boolean hasActiveOnlineAccountSignatures() {
+        final Long minLatestBlockTimestamp = NTP.getTime() - (2 * 60 * 60 * 1000L);
+        boolean isUpToDate = Controller.getInstance().isUpToDate(minLatestBlockTimestamp);
+
+        return isUpToDate && hasOurOnlineAccounts();
+    }
+
+    public boolean hasOurOnlineAccounts() {
+        return this.hasOurOnlineAccounts;
+    }
+
+    /**
+     * Returns list of online accounts matching given timestamp.
+     */
+    // Block::mint() - only wants online accounts with (online) timestamp that matches block's (online) timestamp so they can be added to new block
+    public List<OnlineAccountData> getOnlineAccounts(long onlineTimestamp) {
+        LOGGER.info(String.format("caller's timestamp: %d, our timestamps: %s", onlineTimestamp, String.join(", ", this.currentOnlineAccounts.keySet().stream().map(l -> Long.toString(l)).collect(Collectors.joining(", ")))));
+
+        return new ArrayList<>(Set.copyOf(this.currentOnlineAccounts.getOrDefault(onlineTimestamp, Collections.emptySet())));
+    }
+
+    /**
+     * Returns list of online accounts with timestamp recent enough to be considered currently online.
+     */
+    // API: calls this to return list of online accounts - probably expects ALL timestamps - but going to get 'current' from now on
+    public List<OnlineAccountData> getOnlineAccounts() {
+        // 'current' timestamp
+        final Long onlineAccountsTimestamp = getCurrentOnlineAccountTimestamp();
+        if (onlineAccountsTimestamp == null)
+            return Collections.emptyList();
+
+        return getOnlineAccounts(onlineAccountsTimestamp);
+    }
+
+    // Block processing
+
+    /**
+     * Removes previously validated entries from block's online accounts.
+     * <p>
+     * Checks both 'current' and block caches.
+     * <p>
+     * Typically called by {@link Block#areOnlineAccountsValid()}
+     */
+    public void removeKnown(Set<OnlineAccountData> blocksOnlineAccounts, Long timestamp) {
+        Set<OnlineAccountData> onlineAccounts = this.currentOnlineAccounts.get(timestamp);
+
+        // If not 'current' timestamp - try block cache instead
+        if (onlineAccounts == null)
+            onlineAccounts = this.latestBlocksOnlineAccounts.get(timestamp);
+
+        if (onlineAccounts != null)
+            blocksOnlineAccounts.removeAll(onlineAccounts);
+    }
+
+    /**
+     * Adds block's online accounts to one of OnlineAccountManager's caches.
+     * <p>
+     * It is assumed that the online accounts have been verified.
+     * <p>
+     * Typically called by {@link Block#areOnlineAccountsValid()}
+     */
+    public void addBlocksOnlineAccounts(Set<OnlineAccountData> blocksOnlineAccounts, Long timestamp) {
+        // We want to add to 'current' in preference if possible
+        if (this.currentOnlineAccounts.containsKey(timestamp)) {
+            addAccounts(blocksOnlineAccounts);
+            return;
+        }
+
+        // Add to block cache instead
+        this.latestBlocksOnlineAccounts.computeIfAbsent(timestamp, k -> ConcurrentHashMap.newKeySet())
+                .addAll(blocksOnlineAccounts);
+
+        // If block cache has grown too large then we need to trim.
+        if (this.latestBlocksOnlineAccounts.size() > MAX_BLOCKS_CACHED_ONLINE_ACCOUNTS) {
+            // However, be careful to trim the opposite end to the entry we just added!
+            Long firstKey = this.latestBlocksOnlineAccounts.firstKey();
+            if (!firstKey.equals(timestamp))
+                this.latestBlocksOnlineAccounts.remove(firstKey);
+            else
+                this.latestBlocksOnlineAccounts.remove(this.latestBlocksOnlineAccounts.lastKey());
+        }
+    }
+
+
+    // Network handlers
+
+    public void onNetworkGetOnlineAccountsMessage(Peer peer, Message message) {
+        GetOnlineAccountsMessage getOnlineAccountsMessage = (GetOnlineAccountsMessage) message;
+
+        List<OnlineAccountData> excludeAccounts = getOnlineAccountsMessage.getOnlineAccounts();
+
+        // Send online accounts info, excluding entries with matching timestamp & public key from excludeAccounts
+        List<OnlineAccountData> accountsToSend = Set.copyOf(this.currentOnlineAccounts.values()).stream().flatMap(Set::stream).collect(Collectors.toList());
+        int prefilterSize = accountsToSend.size();
+
+        Iterator<OnlineAccountData> iterator = accountsToSend.iterator();
+        while (iterator.hasNext()) {
+            OnlineAccountData onlineAccountData = iterator.next();
+
+            for (OnlineAccountData excludeAccountData : excludeAccounts) {
+                if (onlineAccountData.getTimestamp() == excludeAccountData.getTimestamp() && Arrays.equals(onlineAccountData.getPublicKey(), excludeAccountData.getPublicKey())) {
+                    iterator.remove();
+                    break;
+                }
+            }
+        }
+
+        if (accountsToSend.isEmpty())
+            return;
+
+        Message onlineAccountsMessage = new OnlineAccountsMessage(accountsToSend);
+        peer.sendMessage(onlineAccountsMessage);
+
+        LOGGER.debug("Sent {} of our {} online accounts to {}", accountsToSend.size(), prefilterSize, peer);
+    }
+
+    public void onNetworkOnlineAccountsMessage(Peer peer, Message message) {
+        OnlineAccountsMessage onlineAccountsMessage = (OnlineAccountsMessage) message;
+
+        List<OnlineAccountData> peersOnlineAccounts = onlineAccountsMessage.getOnlineAccounts();
+        LOGGER.debug("Received {} online accounts from {}", peersOnlineAccounts.size(), peer);
+
+        int importCount = 0;
+
+        // Add any online accounts to the queue that aren't already present
+        for (OnlineAccountData onlineAccountData : peersOnlineAccounts) {
+            boolean isNewEntry = onlineAccountsImportQueue.add(onlineAccountData);
+
+            if (isNewEntry)
+                importCount++;
+        }
+
+        if (importCount > 0)
+            LOGGER.debug("Added {} online accounts to queue", importCount);
+    }
+
+    public void onNetworkGetOnlineAccountsV2Message(Peer peer, Message message) {
+        GetOnlineAccountsV2Message getOnlineAccountsMessage = (GetOnlineAccountsV2Message) message;
+
+        List<OnlineAccountData> excludeAccounts = getOnlineAccountsMessage.getOnlineAccounts();
+
+        // Send online accounts info, excluding entries with matching timestamp & public key from excludeAccounts
+        List<OnlineAccountData> accountsToSend = Set.copyOf(this.currentOnlineAccounts.values()).stream().flatMap(Set::stream).collect(Collectors.toList());
+        int prefilterSize = accountsToSend.size();
+
+        Iterator<OnlineAccountData> iterator = accountsToSend.iterator();
+        while (iterator.hasNext()) {
+            OnlineAccountData onlineAccountData = iterator.next();
+
+            for (OnlineAccountData excludeAccountData : excludeAccounts) {
+                if (onlineAccountData.getTimestamp() == excludeAccountData.getTimestamp() && Arrays.equals(onlineAccountData.getPublicKey(), excludeAccountData.getPublicKey())) {
+                    iterator.remove();
+                    break;
+                }
+            }
+        }
+
+        if (accountsToSend.isEmpty())
+            return;
+
+        Message onlineAccountsMessage = new OnlineAccountsV2Message(accountsToSend);
+        peer.sendMessage(onlineAccountsMessage);
+
+        LOGGER.debug("Sent {} of our {} online accounts to {}", accountsToSend.size(), prefilterSize, peer);
+    }
+
+    public void onNetworkOnlineAccountsV2Message(Peer peer, Message message) {
+        OnlineAccountsV2Message onlineAccountsMessage = (OnlineAccountsV2Message) message;
+
+        List<OnlineAccountData> peersOnlineAccounts = onlineAccountsMessage.getOnlineAccounts();
+        LOGGER.debug("Received {} online accounts from {}", peersOnlineAccounts.size(), peer);
+
+        int importCount = 0;
+
+        // Add any online accounts to the queue that aren't already present
+        for (OnlineAccountData onlineAccountData : peersOnlineAccounts) {
+            boolean isNewEntry = onlineAccountsImportQueue.add(onlineAccountData);
+
+            if (isNewEntry)
+                importCount++;
+        }
+
+        if (importCount > 0)
+            LOGGER.debug("Added {} online accounts to queue", importCount);
+    }
+
+    public void onNetworkGetOnlineAccountsV3Message(Peer peer, Message message) {
+        GetOnlineAccountsV3Message getOnlineAccountsMessage = (GetOnlineAccountsV3Message) message;
+
+        Map<Long, Map<Byte, byte[]>> peersHashes = getOnlineAccountsMessage.getHashesByTimestampThenByte();
+        List<OnlineAccountData> outgoingOnlineAccounts = new ArrayList<>();
+
+        // Warning: no double-checking/fetching - we must be ConcurrentMap compatible!
+        // So no contains()-then-get() or multiple get()s on the same key/map.
+        // We also use getOrDefault() with emptySet() on currentOnlineAccounts in case corresponding timestamp entry isn't there.
+        for (var ourOuterMapEntry : currentOnlineAccountsHashes.entrySet()) {
+            Long timestamp = ourOuterMapEntry.getKey();
+
+            var ourInnerMap = ourOuterMapEntry.getValue();
+            var peersInnerMap = peersHashes.get(timestamp);
+
+            if (peersInnerMap == null) {
+                // Peer doesn't have this timestamp, so if it's valid (i.e. not too old) then we'd have to send all of ours
+                Set<OnlineAccountData> timestampsOnlineAccounts = this.currentOnlineAccounts.getOrDefault(timestamp, Collections.emptySet());
+                outgoingOnlineAccounts.addAll(timestampsOnlineAccounts);
+
+                LOGGER.debug(() -> String.format("Going to send all %d online accounts for timestamp %d", timestampsOnlineAccounts.size(), timestamp));
+            } else {
+                // Quick cache of which leading bytes to send so we only have to filter once
+                Set<Byte> outgoingLeadingBytes = new HashSet<>();
+
+                // We have entries for this timestamp so compare against peer's entries
+                for (var ourInnerMapEntry : ourInnerMap.entrySet()) {
+                    Byte leadingByte = ourInnerMapEntry.getKey();
+                    byte[] peersHash = peersInnerMap.get(leadingByte);
+
+                    if (!Arrays.equals(ourInnerMapEntry.getValue(), peersHash)) {
+                        // For this leading byte: hashes don't match or peer doesn't have entry
+                        // Send all online accounts for this timestamp and leading byte
+                        outgoingLeadingBytes.add(leadingByte);
+                    }
+                }
+
+                int beforeAddSize = outgoingOnlineAccounts.size();
+
+                this.currentOnlineAccounts.getOrDefault(timestamp, Collections.emptySet()).stream()
+                        .filter(account -> outgoingLeadingBytes.contains(account.getPublicKey()[0]))
+                        .forEach(outgoingOnlineAccounts::add);
+
+                if (outgoingOnlineAccounts.size() > beforeAddSize)
+                    LOGGER.debug(String.format("Going to send %d online accounts for timestamp %d and leading bytes %s",
+                            outgoingOnlineAccounts.size() - beforeAddSize,
+                            timestamp,
+                            outgoingLeadingBytes.stream().sorted(Byte::compareUnsigned).map(leadingByte -> String.format("%02x", leadingByte)).collect(Collectors.joining(", "))
+                            )
+                    );
+            }
+        }
+
+        Message onlineAccountsMessage = new OnlineAccountsV2Message(outgoingOnlineAccounts); // TODO: V3 message
+        peer.sendMessage(onlineAccountsMessage);
+
+        LOGGER.debug("Sent {} online accounts to {}", outgoingOnlineAccounts.size(), peer);
+    }
+}

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

@@ -0,0 +1,398 @@
+package org.qortal.controller;
+
+import com.rust.litewalletjni.LiteWalletJni;
+import org.apache.commons.io.FileUtils;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.json.JSONObject;
+import org.qortal.arbitrary.ArbitraryDataFile;
+import org.qortal.arbitrary.ArbitraryDataReader;
+import org.qortal.arbitrary.ArbitraryDataResource;
+import org.qortal.arbitrary.exception.MissingDataException;
+import org.qortal.crosschain.ForeignBlockchainException;
+import org.qortal.crosschain.PirateWallet;
+import org.qortal.data.arbitrary.ArbitraryResourceStatus;
+import org.qortal.data.transaction.ArbitraryTransactionData;
+import org.qortal.data.transaction.TransactionData;
+import org.qortal.network.Network;
+import org.qortal.network.Peer;
+import org.qortal.repository.DataException;
+import org.qortal.repository.Repository;
+import org.qortal.repository.RepositoryManager;
+import org.qortal.settings.Settings;
+import org.qortal.transaction.ArbitraryTransaction;
+import org.qortal.utils.ArbitraryTransactionUtils;
+import org.qortal.utils.Base58;
+import org.qortal.utils.FilesystemUtils;
+import org.qortal.utils.NTP;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.List;
+import java.util.Objects;
+
+public class PirateChainWalletController extends Thread {
+
+    protected static final Logger LOGGER = LogManager.getLogger(PirateChainWalletController.class);
+
+    private static PirateChainWalletController instance;
+
+    final private static long SAVE_INTERVAL = 60 * 60 * 1000L; // 1 hour
+    private long lastSaveTime = 0L;
+
+    private boolean running;
+    private PirateWallet currentWallet = null;
+    private boolean shouldLoadWallet = false;
+    private String loadStatus = null;
+
+    private static String qdnWalletSignature = "EsfUw54perxkEtfoUoL7Z97XPrNsZRZXePVZPz3cwRm9qyEPSofD5KmgVpDqVitQp7LhnZRmL6z2V9hEe1YS45T";
+
+
+    private PirateChainWalletController() {
+        this.running = true;
+    }
+
+    public static PirateChainWalletController getInstance() {
+        if (instance == null)
+            instance = new PirateChainWalletController();
+
+        return instance;
+    }
+
+    @Override
+    public void run() {
+        Thread.currentThread().setName("Pirate Chain Wallet Controller");
+
+        try {
+            while (running && !Controller.isStopping()) {
+                Thread.sleep(1000);
+
+                // Wait until we have a request to load the wallet
+                if (!shouldLoadWallet) {
+                    continue;
+                }
+
+                if (!LiteWalletJni.isLoaded()) {
+                    this.loadLibrary();
+
+                    // If still not loaded, sleep to prevent too many requests
+                    if (!LiteWalletJni.isLoaded()) {
+                        Thread.sleep(5 * 1000);
+                        continue;
+                    }
+                }
+
+                // Wallet is downloaded, so clear the status
+                this.loadStatus = null;
+
+                if (this.currentWallet == null) {
+                    // Nothing to do yet
+                    continue;
+                }
+                if (this.currentWallet.isNullSeedWallet()) {
+                    // Don't sync the null seed wallet
+                    continue;
+                }
+
+                LOGGER.debug("Syncing Pirate Chain wallet...");
+                String response = LiteWalletJni.execute("sync", "");
+                LOGGER.debug("sync response: {}", response);
+                JSONObject json = new JSONObject(response);
+                if (json.has("result")) {
+                    String result = json.getString("result");
+
+                    // We may have to set wallet to ready if this is the first ever successful sync
+                    if (Objects.equals(result, "success")) {
+                        this.currentWallet.setReady(true);
+                    }
+                }
+
+                // Rate limit sync attempts
+                Thread.sleep(30000);
+
+                // Save wallet if needed
+                Long now = NTP.getTime();
+                if (now != null && now-SAVE_INTERVAL >= this.lastSaveTime) {
+                    this.saveCurrentWallet();
+                }
+            }
+        } catch (InterruptedException e) {
+            // Fall-through to exit
+        }
+    }
+
+    public void shutdown() {
+        // Save the wallet
+        this.saveCurrentWallet();
+
+        this.running = false;
+        this.interrupt();
+    }
+
+
+    // QDN & wallet libraries
+
+    private void loadLibrary() throws InterruptedException {
+        try (final Repository repository = RepositoryManager.getRepository()) {
+
+            // Check if architecture is supported
+            String libFileName = PirateChainWalletController.getRustLibFilename();
+            if (libFileName == null) {
+                String osName = System.getProperty("os.name");
+                String osArchitecture = System.getProperty("os.arch");
+                this.loadStatus = String.format("Unsupported architecture (%s %s)", osName, osArchitecture);
+                return;
+            }
+
+            // Check if the library exists in the wallets folder
+            Path libDirectory = PirateChainWalletController.getRustLibOuterDirectory();
+            Path libPath = Paths.get(libDirectory.toString(), libFileName);
+            if (Files.exists(libPath)) {
+                // Already downloaded; we can load the library right away
+                LiteWalletJni.loadLibrary();
+                return;
+            }
+
+            // Library not found, so check if we've fetched the resource from QDN
+            ArbitraryTransactionData t = this.getTransactionData(repository);
+            if (t == null) {
+                // Can't find the transaction - maybe on a different chain?
+                return;
+            }
+
+            // Wait until we have a sufficient number of peers to attempt QDN downloads
+            List<Peer> handshakedPeers = Network.getInstance().getImmutableHandshakedPeers();
+            if (handshakedPeers.size() < Settings.getInstance().getMinBlockchainPeers()) {
+                // Wait for more peers
+                this.loadStatus = String.format("Searching for peers...");
+                return;
+            }
+
+            // Build resource
+            ArbitraryDataReader arbitraryDataReader = new ArbitraryDataReader(t.getName(),
+                    ArbitraryDataFile.ResourceIdType.NAME, t.getService(), t.getIdentifier());
+            try {
+                arbitraryDataReader.loadSynchronously(false);
+            } catch (MissingDataException e) {
+                LOGGER.info("Missing data when loading Pirate Chain library");
+            }
+
+            // Check its status
+            ArbitraryResourceStatus status = ArbitraryTransactionUtils.getStatus(
+                    t.getService(), t.getName(), t.getIdentifier(), false);
+
+            if (status.getStatus() != ArbitraryResourceStatus.Status.READY) {
+                LOGGER.info("Not ready yet: {}", status.getTitle());
+                this.loadStatus = String.format("Downloading files from QDN... (%d / %d)", status.getLocalChunkCount(), status.getTotalChunkCount());
+                return;
+            }
+
+            // Files are downloaded, so copy the necessary files to the wallets folder
+            // Delete the wallets/*/lib directory first, in case earlier versions of the wallet are present
+            Path walletsLibDirectory = PirateChainWalletController.getWalletsLibDirectory();
+            if (Files.exists(walletsLibDirectory)) {
+                FilesystemUtils.safeDeleteDirectory(walletsLibDirectory, false);
+            }
+            Files.createDirectories(libDirectory);
+            FileUtils.copyDirectory(arbitraryDataReader.getFilePath().toFile(), libDirectory.toFile());
+
+            // Clear reader cache so only one copy exists
+            ArbitraryDataResource resource = new ArbitraryDataResource(t.getName(),
+                    ArbitraryDataFile.ResourceIdType.NAME, t.getService(), t.getIdentifier());
+            resource.deleteCache();
+
+            // Finally, load the library
+            LiteWalletJni.loadLibrary();
+
+        } catch (DataException e) {
+            LOGGER.error("Repository issue when loading Pirate Chain library", e);
+        } catch (IOException e) {
+            LOGGER.error("Error when loading Pirate Chain library", e);
+        }
+    }
+
+    private ArbitraryTransactionData getTransactionData(Repository repository) {
+        try {
+            byte[] signature = Base58.decode(qdnWalletSignature);
+            TransactionData transactionData = repository.getTransactionRepository().fromSignature(signature);
+            if (!(transactionData instanceof ArbitraryTransactionData))
+                return null;
+
+            ArbitraryTransaction arbitraryTransaction = new ArbitraryTransaction(repository, transactionData);
+            if (arbitraryTransaction != null) {
+                return (ArbitraryTransactionData) arbitraryTransaction.getTransactionData();
+            }
+
+            return null;
+        } catch (DataException e) {
+            return null;
+        }
+    }
+
+    public static String getRustLibFilename() {
+        String osName = System.getProperty("os.name");
+        String osArchitecture = System.getProperty("os.arch");
+
+        if (osName.equals("Mac OS X") && osArchitecture.equals("x86_64")) {
+            return "librust-macos-x86_64.dylib";
+        }
+        else if (osName.equals("Linux") && osArchitecture.equals("aarch64")) {
+            return "librust-linux-aarch64.so";
+        }
+        else if (osName.equals("Linux") && osArchitecture.equals("amd64")) {
+            return "librust-linux-x86_64.so";
+        }
+        else if (osName.contains("Windows") && osArchitecture.equals("amd64")) {
+            return "librust-windows-x86_64.dll";
+        }
+
+        return null;
+    }
+
+    public static Path getWalletsLibDirectory() {
+        return Paths.get(Settings.getInstance().getWalletsPath(), "PirateChain", "lib");
+    }
+
+    public static Path getRustLibOuterDirectory() {
+        String sigPrefix = qdnWalletSignature.substring(0, 8);
+        return Paths.get(Settings.getInstance().getWalletsPath(), "PirateChain", "lib", sigPrefix);
+    }
+
+
+    // Wallet functions
+
+    public boolean initWithEntropy58(String entropy58) {
+        return this.initWithEntropy58(entropy58, false);
+    }
+
+    public boolean initNullSeedWallet() {
+        return this.initWithEntropy58(Base58.encode(new byte[32]), true);
+    }
+
+    private boolean initWithEntropy58(String entropy58, boolean isNullSeedWallet) {
+        // If the JNI library isn't loaded yet then we can't proceed
+        if (!LiteWalletJni.isLoaded()) {
+            shouldLoadWallet = true;
+            return false;
+        }
+
+        byte[] entropyBytes = Base58.decode(entropy58);
+
+        if (entropyBytes == null || entropyBytes.length != 32) {
+            LOGGER.info("Invalid entropy bytes");
+            return false;
+        }
+
+        if (this.currentWallet != null) {
+            if (this.currentWallet.entropyBytesEqual(entropyBytes)) {
+                // Wallet already active - nothing to do
+                return true;
+            }
+            else {
+                // Different wallet requested - close the existing one and switch over
+                this.closeCurrentWallet();
+            }
+        }
+
+        try {
+            this.currentWallet = new PirateWallet(entropyBytes, isNullSeedWallet);
+            if (!this.currentWallet.isReady()) {
+                // Don't persist wallets that aren't ready
+                this.currentWallet = null;
+            }
+            return true;
+        } catch (IOException e) {
+            LOGGER.info("Unable to initialize wallet: {}", e.getMessage());
+        }
+
+        return false;
+    }
+
+    private void saveCurrentWallet() {
+        if (this.currentWallet == null) {
+            // Nothing to do
+            return;
+        }
+        try {
+            if (this.currentWallet.save()) {
+                Long now = NTP.getTime();
+                if (now != null) {
+                    this.lastSaveTime = now;
+                }
+            }
+        } catch (IOException e) {
+            LOGGER.info("Unable to save wallet");
+        }
+    }
+
+    public PirateWallet getCurrentWallet() {
+        return this.currentWallet;
+    }
+
+    private void closeCurrentWallet() {
+        this.saveCurrentWallet();
+        this.currentWallet = null;
+    }
+
+    public void ensureInitialized() throws ForeignBlockchainException {
+        if (!LiteWalletJni.isLoaded() || this.currentWallet == null || !this.currentWallet.isInitialized()) {
+            throw new ForeignBlockchainException("Pirate wallet isn't initialized yet");
+        }
+    }
+
+    public void ensureNotNullSeed() throws ForeignBlockchainException {
+        // Safety check to make sure funds aren't sent to a null seed wallet
+        if (this.currentWallet == null || this.currentWallet.isNullSeedWallet()) {
+            throw new ForeignBlockchainException("Invalid wallet");
+        }
+    }
+
+    public void ensureSynchronized() throws ForeignBlockchainException {
+        if (this.currentWallet == null || !this.currentWallet.isSynchronized()) {
+            throw new ForeignBlockchainException("Wallet isn't synchronized yet");
+        }
+
+        String response = LiteWalletJni.execute("syncStatus", "");
+        JSONObject json = new JSONObject(response);
+        if (json.has("syncing")) {
+            boolean isSyncing = Boolean.valueOf(json.getString("syncing"));
+            if (isSyncing) {
+                long syncedBlocks = json.getLong("synced_blocks");
+                long totalBlocks = json.getLong("total_blocks");
+
+                throw new ForeignBlockchainException(String.format("Sync in progress (%d / %d). Please try again later.", syncedBlocks, totalBlocks));
+            }
+        }
+    }
+
+    public String getSyncStatus() {
+        if (this.currentWallet == null || !this.currentWallet.isInitialized()) {
+            if (this.loadStatus != null) {
+                return this.loadStatus;
+            }
+
+            return "Not initialized yet";
+        }
+
+        String syncStatusResponse = LiteWalletJni.execute("syncStatus", "");
+        org.json.JSONObject json = new JSONObject(syncStatusResponse);
+        if (json.has("syncing")) {
+            boolean isSyncing = Boolean.valueOf(json.getString("syncing"));
+            if (isSyncing) {
+                long syncedBlocks = json.getLong("synced_blocks");
+                long totalBlocks = json.getLong("total_blocks");
+                return String.format("Sync in progress (%d / %d)", syncedBlocks, totalBlocks);
+            }
+        }
+
+        boolean isSynchronized = this.currentWallet.isSynchronized();
+        if (isSynchronized) {
+            return "Synchronized";
+        }
+
+        return "Initializing wallet...";
+    }
+
+}

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

@@ -26,14 +26,7 @@ import org.qortal.event.Event;
 import org.qortal.event.EventBus;
 import org.qortal.network.Network;
 import org.qortal.network.Peer;
-import org.qortal.network.message.BlockMessage;
-import org.qortal.network.message.BlockSummariesMessage;
-import org.qortal.network.message.GetBlockMessage;
-import org.qortal.network.message.GetBlockSummariesMessage;
-import org.qortal.network.message.GetSignaturesV2Message;
-import org.qortal.network.message.Message;
-import org.qortal.network.message.SignaturesMessage;
-import org.qortal.network.message.Message.MessageType;
+import org.qortal.network.message.*;
 import org.qortal.repository.DataException;
 import org.qortal.repository.Repository;
 import org.qortal.repository.RepositoryManager;
@@ -88,14 +81,14 @@ public class Synchronizer extends Thread {
 	private boolean syncRequestPending = false;
 
 	// Keep track of invalid blocks so that we don't keep trying to sync them
-	private Map<String, Long> invalidBlockSignatures = Collections.synchronizedMap(new HashMap<>());
+	private Map<ByteArray, Long> invalidBlockSignatures = Collections.synchronizedMap(new HashMap<>());
 	public Long timeValidBlockLastReceived = null;
 	public Long timeInvalidBlockLastReceived = null;
 
 	private static Synchronizer instance;
 
 	public enum SynchronizationResult {
-		OK, NOTHING_TO_DO, GENESIS_ONLY, NO_COMMON_BLOCK, TOO_DIVERGENT, NO_REPLY, INFERIOR_CHAIN, INVALID_DATA, NO_BLOCKCHAIN_LOCK, REPOSITORY_ISSUE, SHUTTING_DOWN;
+		OK, NOTHING_TO_DO, GENESIS_ONLY, NO_COMMON_BLOCK, TOO_DIVERGENT, NO_REPLY, INFERIOR_CHAIN, INVALID_DATA, NO_BLOCKCHAIN_LOCK, REPOSITORY_ISSUE, SHUTTING_DOWN, CHAIN_TIP_TOO_OLD;
 	}
 
 	public static class NewChainTipEvent implements Event {
@@ -134,6 +127,11 @@ public class Synchronizer extends Thread {
 	public void run() {
 		Thread.currentThread().setName("Synchronizer");
 
+		if (Settings.getInstance().isLite()) {
+			// Lite nodes don't need to sync
+			return;
+		}
+
 		try {
 			while (running && !Controller.isStopping()) {
 				Thread.sleep(1000);
@@ -173,6 +171,12 @@ public class Synchronizer extends Thread {
 
 	public Integer getSyncPercent() {
 		synchronized (this.syncLock) {
+			// Report as 100% synced if the latest block is within the last 60 mins
+			final Long minLatestBlockTimestamp = NTP.getTime() - (60 * 60 * 1000L);
+			if (Controller.getInstance().isUpToDate(minLatestBlockTimestamp)) {
+				return 100;
+			}
+
 			return this.isSynchronizing ? this.syncPercent : null;
 		}
 	}
@@ -195,7 +199,8 @@ public class Synchronizer extends Thread {
 		if (this.isSynchronizing)
 			return true;
 
-		List<Peer> peers = Network.getInstance().getHandshakedPeers();
+		// Needs a mutable copy of the unmodifiableList
+		List<Peer> peers = new ArrayList<>(Network.getInstance().getImmutableHandshakedPeers());
 
 		// Disregard peers that have "misbehaved" recently
 		peers.removeIf(Controller.hasMisbehaved);
@@ -211,7 +216,8 @@ public class Synchronizer extends Thread {
 
 		checkRecoveryModeForPeers(peers);
 		if (recoveryMode) {
-			peers = Network.getInstance().getHandshakedPeers();
+			// 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);
@@ -238,6 +244,12 @@ public class Synchronizer extends Thread {
 		// We may have added more inferior chain tips when comparing peers, so remove any peers that are currently on those chains
 		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);
+		}
+
 		final int peersRemoved = peersBeforeComparison - peers.size();
 		if (peersRemoved > 0 && peers.size() > 0)
 			LOGGER.debug(String.format("Ignoring %d peers on inferior chains. Peers remaining: %d", peersRemoved, peers.size()));
@@ -300,7 +312,7 @@ public class Synchronizer extends Thread {
 
 				case INFERIOR_CHAIN: {
 					// Update our list of inferior chain tips
-					ByteArray inferiorChainSignature = new ByteArray(peer.getChainTipData().getLastBlockSignature());
+					ByteArray inferiorChainSignature = ByteArray.wrap(peer.getChainTipData().getLastBlockSignature());
 					if (!inferiorChainSignatures.contains(inferiorChainSignature))
 						inferiorChainSignatures.add(inferiorChainSignature);
 
@@ -316,6 +328,7 @@ public class Synchronizer extends Thread {
 				case NO_REPLY:
 				case NO_BLOCKCHAIN_LOCK:
 				case REPOSITORY_ISSUE:
+				case CHAIN_TIP_TOO_OLD:
 					// These are minor failure results so fine to try again
 					LOGGER.debug(() -> String.format("Failed to synchronize with peer %s (%s)", peer, syncResult.name()));
 					break;
@@ -328,7 +341,7 @@ public class Synchronizer extends Thread {
 					// fall-through...
 				case NOTHING_TO_DO: {
 					// Update our list of inferior chain tips
-					ByteArray inferiorChainSignature = new ByteArray(peer.getChainTipData().getLastBlockSignature());
+					ByteArray inferiorChainSignature = ByteArray.wrap(peer.getChainTipData().getLastBlockSignature());
 					if (!inferiorChainSignatures.contains(inferiorChainSignature))
 						inferiorChainSignatures.add(inferiorChainSignature);
 
@@ -370,7 +383,7 @@ public class Synchronizer extends Thread {
 	}
 
 	private boolean checkRecoveryModeForPeers(List<Peer> qualifiedPeers) {
-		List<Peer> handshakedPeers = Network.getInstance().getHandshakedPeers();
+		List<Peer> handshakedPeers = Network.getInstance().getImmutableHandshakedPeers();
 
 		if (handshakedPeers.size() > 0) {
 			// There is at least one handshaked peer
@@ -404,7 +417,7 @@ public class Synchronizer extends Thread {
 
 	public void addInferiorChainSignature(byte[] inferiorSignature) {
 		// Update our list of inferior chain tips
-		ByteArray inferiorChainSignature = new ByteArray(inferiorSignature);
+		ByteArray inferiorChainSignature = ByteArray.wrap(inferiorSignature);
 		if (!inferiorChainSignatures.contains(inferiorChainSignature))
 			inferiorChainSignatures.add(inferiorChainSignature);
 	}
@@ -555,7 +568,7 @@ public class Synchronizer extends Thread {
 				// If our latest block is very old, it's best that we don't try and determine the best peers to sync to.
 				// This is because it can involve very large chain comparisons, which is too intensive.
 				// In reality, most forking problems occur near the chain tips, so we will reserve this functionality for those situations.
-				final Long minLatestBlockTimestamp = Controller.getMinimumLatestBlockTimestamp();
+				Long minLatestBlockTimestamp = Controller.getMinimumLatestBlockTimestamp();
 				if (minLatestBlockTimestamp == null)
 					return peers;
 
@@ -604,7 +617,7 @@ public class Synchronizer extends Thread {
 							// We have already determined that the correct chain diverged from a lower height. We are safe to skip these peers.
 							for (Peer peer : peersSharingCommonBlock) {
 								LOGGER.debug(String.format("Peer %s has common block at height %d but the superior chain is at height %d. Removing it from this round.", peer, commonBlockSummary.getHeight(), dropPeersAfterCommonBlockHeight));
-								this.addInferiorChainSignature(peer.getChainTipData().getLastBlockSignature());
+								//this.addInferiorChainSignature(peer.getChainTipData().getLastBlockSignature());
 							}
 							continue;
 						}
@@ -615,7 +628,9 @@ public class Synchronizer extends Thread {
 					int minChainLength = this.calculateMinChainLengthOfPeers(peersSharingCommonBlock, commonBlockSummary);
 
 					// Fetch block summaries from each peer
-					for (Peer peer : peersSharingCommonBlock) {
+					Iterator peersSharingCommonBlockIterator = peersSharingCommonBlock.iterator();
+					while (peersSharingCommonBlockIterator.hasNext()) {
+						Peer peer = (Peer) peersSharingCommonBlockIterator.next();
 
 						// If we're shutting down, just return the latest peer list
 						if (Controller.isStopping())
@@ -672,6 +687,8 @@ public class Synchronizer extends Thread {
 						if (this.containsInvalidBlockSummary(peer.getCommonBlockData().getBlockSummariesAfterCommonBlock())) {
 							LOGGER.debug("Ignoring peer %s because it holds an invalid block", peer);
 							peers.remove(peer);
+							peersSharingCommonBlockIterator.remove();
+							continue;
 						}
 
 						// Reduce minChainLength if needed. If we don't have any blocks, this peer will be excluded from chain weight comparisons later in the process, so we shouldn't update minChainLength
@@ -711,6 +728,7 @@ public class Synchronizer extends Thread {
 					LOGGER.debug(String.format("Listing peers with common block %.8s...", Base58.encode(commonBlockSummary.getSignature())));
 					for (Peer peer : peersSharingCommonBlock) {
 						final int peerHeight = peer.getChainTipData().getLastHeight();
+						final Long peerLastBlockTimestamp = peer.getChainTipData().getLastBlockTimestamp();
 						final int peerAdditionalBlocksAfterCommonBlock = peerHeight - commonBlockSummary.getHeight();
 						final CommonBlockData peerCommonBlockData = peer.getCommonBlockData();
 
@@ -721,6 +739,14 @@ public class Synchronizer extends Thread {
 							continue;
 						}
 
+						// If peer is our of date (since our last check), we should exclude it from this round
+						minLatestBlockTimestamp = Controller.getMinimumLatestBlockTimestamp();
+						if (peerLastBlockTimestamp == null || peerLastBlockTimestamp < minLatestBlockTimestamp) {
+							LOGGER.debug(String.format("Peer %s is out of date - removing it from this round", peer));
+							peers.remove(peer);
+							continue;
+						}
+
 						final List<BlockSummaryData> peerBlockSummariesAfterCommonBlock = peerCommonBlockData.getBlockSummariesAfterCommonBlock();
 						populateBlockSummariesMinterLevels(repository, peerBlockSummariesAfterCommonBlock);
 
@@ -818,6 +844,10 @@ public class Synchronizer extends Thread {
 
 	/* Invalid block signature tracking */
 
+	public Map<ByteArray, Long> getInvalidBlockSignatures() {
+		return this.invalidBlockSignatures;
+	}
+
 	private void addInvalidBlockSignature(byte[] signature) {
 		Long now = NTP.getTime();
 		if (now == null) {
@@ -825,8 +855,7 @@ public class Synchronizer extends Thread {
 		}
 
 		// Add or update existing entry
-		String sig58 = Base58.encode(signature);
-		invalidBlockSignatures.put(sig58, now);
+		invalidBlockSignatures.put(ByteArray.wrap(signature), now);
 	}
 	private void deleteOlderInvalidSignatures(Long now) {
 		if (now == null) {
@@ -845,17 +874,16 @@ public class Synchronizer extends Thread {
 			}
 		}
 	}
-	private boolean containsInvalidBlockSummary(List<BlockSummaryData> blockSummaries) {
+	public boolean containsInvalidBlockSummary(List<BlockSummaryData> blockSummaries) {
 		if (blockSummaries == null || invalidBlockSignatures == null) {
 			return false;
 		}
 
 		// Loop through our known invalid blocks and check each one against supplied block summaries
-		for (String invalidSignature58 : invalidBlockSignatures.keySet()) {
-			byte[] invalidSignature = Base58.decode(invalidSignature58);
+		for (ByteArray invalidSignature : invalidBlockSignatures.keySet()) {
 			for (BlockSummaryData blockSummary : blockSummaries) {
 				byte[] signature = blockSummary.getSignature();
-				if (Arrays.equals(signature, invalidSignature)) {
+				if (Arrays.equals(signature, invalidSignature.value)) {
 					return true;
 				}
 			}
@@ -868,10 +896,9 @@ public class Synchronizer extends Thread {
 		}
 
 		// Loop through our known invalid blocks and check each one against supplied block signatures
-		for (String invalidSignature58 : invalidBlockSignatures.keySet()) {
-			byte[] invalidSignature = Base58.decode(invalidSignature58);
+		for (ByteArray invalidSignature : invalidBlockSignatures.keySet()) {
 			for (byte[] signature : blockSignatures) {
-				if (Arrays.equals(signature, invalidSignature)) {
+				if (Arrays.equals(signature, invalidSignature.value)) {
 					return true;
 				}
 			}
@@ -1283,6 +1310,16 @@ 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 Long minLatestBlockTimestamp = Controller.getMinimumLatestBlockTimestamp();
+				final Long peerLastBlockTimestamp = peer.getChainTipData().getLastBlockTimestamp();
+				if (peerLastBlockTimestamp == null || peerLastBlockTimestamp < minLatestBlockTimestamp) {
+					LOGGER.info(String.format("Peer %s is out of date, so abandoning sync attempt", peer));
+					return SynchronizationResult.CHAIN_TIP_TOO_OLD;
+				}
+			}
+
 			byte[] nextPeerSignature = peerBlockSignatures.get(0);
 			int nextHeight = height + 1;
 
@@ -1540,12 +1577,23 @@ public class Synchronizer extends Thread {
 		Message getBlockMessage = new GetBlockMessage(signature);
 
 		Message message = peer.getResponse(getBlockMessage);
-		if (message == null || message.getType() != MessageType.BLOCK)
+		if (message == null)
 			return null;
 
-		BlockMessage blockMessage = (BlockMessage) message;
+		switch (message.getType()) {
+			case BLOCK: {
+				BlockMessage blockMessage = (BlockMessage) message;
+				return new Block(repository, blockMessage.getBlockData(), blockMessage.getTransactions(), blockMessage.getAtStates());
+			}
 
-		return new Block(repository, blockMessage.getBlockData(), blockMessage.getTransactions(), blockMessage.getAtStates());
+			case BLOCK_V2: {
+				BlockV2Message blockMessage = (BlockV2Message) message;
+				return new Block(repository, blockMessage.getBlockData(), blockMessage.getTransactions(), blockMessage.getAtStatesHash());
+			}
+
+			default:
+				return null;
+		}
 	}
 
 	public void populateBlockSummariesMinterLevels(Repository repository, List<BlockSummaryData> blockSummaries) throws DataException {

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

@@ -0,0 +1,441 @@
+package org.qortal.controller;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.qortal.data.block.BlockData;
+import org.qortal.data.transaction.TransactionData;
+import org.qortal.network.Network;
+import org.qortal.network.Peer;
+import org.qortal.network.message.GetTransactionMessage;
+import org.qortal.network.message.Message;
+import org.qortal.network.message.TransactionMessage;
+import org.qortal.network.message.TransactionSignaturesMessage;
+import org.qortal.repository.DataException;
+import org.qortal.repository.Repository;
+import org.qortal.repository.RepositoryManager;
+import org.qortal.settings.Settings;
+import org.qortal.transaction.Transaction;
+import org.qortal.transform.TransformationException;
+import org.qortal.utils.Base58;
+import org.qortal.utils.NTP;
+
+import java.util.*;
+import java.util.concurrent.locks.ReentrantLock;
+import java.util.stream.Collectors;
+
+public class TransactionImporter extends Thread {
+
+    private static final Logger LOGGER = LogManager.getLogger(TransactionImporter.class);
+
+    private static TransactionImporter instance;
+    private volatile boolean isStopping = false;
+
+    private static final int MAX_INCOMING_TRANSACTIONS = 5000;
+
+    /** Minimum time before considering an invalid unconfirmed transaction as "stale" */
+    public static final long INVALID_TRANSACTION_STALE_TIMEOUT = 30 * 60 * 1000L; // ms
+    /** Minimum frequency to re-request stale unconfirmed transactions from peers, to recheck validity */
+    public static final long INVALID_TRANSACTION_RECHECK_INTERVAL = 60 * 60 * 1000L; // ms\
+    /** Minimum frequency to re-request expired unconfirmed transactions from peers, to recheck validity
+     * This mainly exists to stop expired transactions from bloating the list */
+    public static final long EXPIRED_TRANSACTION_RECHECK_INTERVAL = 10 * 60 * 1000L; // ms
+
+
+    /** Map of incoming transaction that are in the import queue. Key is transaction data, value is whether signature has been validated. */
+    private final Map<TransactionData, Boolean> incomingTransactions = Collections.synchronizedMap(new HashMap<>());
+
+    /** 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<>());
+
+
+    public static synchronized TransactionImporter getInstance() {
+        if (instance == null) {
+            instance = new TransactionImporter();
+        }
+
+        return instance;
+    }
+
+    @Override
+    public void run() {
+        Thread.currentThread().setName("Transaction Importer");
+
+        try {
+            while (!Controller.isStopping()) {
+                Thread.sleep(500L);
+
+                // Process incoming transactions queue
+                validateTransactionsInQueue();
+                importTransactionsInQueue();
+
+                // Clean up invalid incoming transactions list
+                cleanupInvalidTransactionsList(NTP.getTime());
+            }
+        } catch (InterruptedException e) {
+            // Fall through to exit thread
+        }
+    }
+
+    public void shutdown() {
+        isStopping = true;
+        this.interrupt();
+    }
+
+
+    // Incoming transactions queue
+
+    private boolean incomingTransactionQueueContains(byte[] signature) {
+        synchronized (incomingTransactions) {
+            return incomingTransactions.keySet().stream().anyMatch(t -> Arrays.equals(t.getSignature(), signature));
+        }
+    }
+
+    private void removeIncomingTransaction(byte[] signature) {
+        incomingTransactions.keySet().removeIf(t -> Arrays.equals(t.getSignature(), signature));
+    }
+
+    /**
+     * Retrieve all pending unconfirmed transactions that have had their signatures validated.
+     * @return a list of TransactionData objects, with valid signatures.
+     */
+    private List<TransactionData> getCachedSigValidTransactions() {
+        synchronized (this.incomingTransactions) {
+            return this.incomingTransactions.entrySet().stream()
+                    .filter(t -> Boolean.TRUE.equals(t.getValue()))
+                    .map(Map.Entry::getKey)
+                    .collect(Collectors.toList());
+        }
+    }
+
+    /**
+     * Validate the signatures of any transactions pending import, then update their
+     * entries in the queue to mark them as valid/invalid.
+     *
+     * No database lock is required.
+     */
+    private void validateTransactionsInQueue() {
+        if (this.incomingTransactions.isEmpty()) {
+            // Nothing to do?
+            return;
+        }
+
+        try (final Repository repository = RepositoryManager.getRepository()) {
+            // Take a snapshot of incomingTransactions, so we don't need to lock it while processing
+            Map<TransactionData, Boolean> incomingTransactionsCopy = Map.copyOf(this.incomingTransactions);
+
+            int unvalidatedCount = Collections.frequency(incomingTransactionsCopy.values(), Boolean.FALSE);
+            int validatedCount = 0;
+
+            if (unvalidatedCount > 0) {
+                LOGGER.debug("Validating signatures in incoming transactions queue (size {})...", unvalidatedCount);
+            }
+
+            // A list of all currently pending transactions that have valid signatures
+            List<Transaction> sigValidTransactions = new ArrayList<>();
+
+            // A list of signatures that became valid in this round
+            List<byte[]> newlyValidSignatures = new ArrayList<>();
+
+            boolean isLiteNode = Settings.getInstance().isLite();
+
+            // We need the latest block in order to check for expired transactions
+            BlockData latestBlock = Controller.getInstance().getChainTip();
+
+            // Signature validation round - does not require blockchain lock
+            for (Map.Entry<TransactionData, Boolean> transactionEntry : incomingTransactionsCopy.entrySet()) {
+                // Quick exit?
+                if (isStopping) {
+                    return;
+                }
+
+                TransactionData transactionData = transactionEntry.getKey();
+                Transaction transaction = Transaction.fromData(repository, transactionData);
+                String signature58 = Base58.encode(transactionData.getSignature());
+
+                Long now = NTP.getTime();
+                if (now == null) {
+                    return;
+                }
+
+                // Drop expired transactions before they are considered "sig valid"
+                if (latestBlock != null && transaction.getDeadline() <= latestBlock.getTimestamp()) {
+                    LOGGER.debug("Removing expired {} transaction {} from import queue", transactionData.getType().name(), signature58);
+                    removeIncomingTransaction(transactionData.getSignature());
+                    invalidUnconfirmedTransactions.put(signature58, (now + EXPIRED_TRANSACTION_RECHECK_INTERVAL));
+                    continue;
+                }
+
+                // Only validate signature if we haven't already done so
+                Boolean isSigValid = transactionEntry.getValue();
+                if (!Boolean.TRUE.equals(isSigValid)) {
+                    if (isLiteNode) {
+                        // Lite nodes can't easily validate transactions, so for now we will have to assume that everything is valid
+                        sigValidTransactions.add(transaction);
+                        newlyValidSignatures.add(transactionData.getSignature());
+                        // Add mark signature as valid if transaction still exists in import queue
+                        incomingTransactions.computeIfPresent(transactionData, (k, v) -> Boolean.TRUE);
+                        continue;
+                    }
+
+                    if (!transaction.isSignatureValid()) {
+                        LOGGER.debug("Ignoring {} transaction {} with invalid signature", transactionData.getType().name(), signature58);
+                        removeIncomingTransaction(transactionData.getSignature());
+
+                        // Also add to invalidIncomingTransactions map
+                        now = NTP.getTime();
+                        if (now != null) {
+                            Long expiry = now + INVALID_TRANSACTION_RECHECK_INTERVAL;
+                            LOGGER.trace("Adding invalid transaction {} to invalidUnconfirmedTransactions...", signature58);
+                            // Add to invalidUnconfirmedTransactions so that we don't keep requesting it
+                            invalidUnconfirmedTransactions.put(signature58, expiry);
+                        }
+
+                        // We're done with this transaction
+                        continue;
+                    }
+
+                    // Count the number that were validated in this round, for logging purposes
+                    validatedCount++;
+
+                    // Add mark signature as valid if transaction still exists in import queue
+                    incomingTransactions.computeIfPresent(transactionData, (k, v) -> Boolean.TRUE);
+
+                    // Signature validated in this round
+                    newlyValidSignatures.add(transactionData.getSignature());
+
+                } else {
+                    LOGGER.trace(() -> String.format("Transaction %s known to have valid signature", Base58.encode(transactionData.getSignature())));
+                }
+
+                // Signature valid - add to shortlist
+                sigValidTransactions.add(transaction);
+            }
+
+            if (unvalidatedCount > 0) {
+                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);
+        }
+    }
+
+    /**
+     * Import any transactions in the queue that have valid signatures.
+     *
+     * A database lock is required.
+     */
+    private void importTransactionsInQueue() {
+        List<TransactionData> sigValidTransactions = this.getCachedSigValidTransactions();
+        if (sigValidTransactions.isEmpty()) {
+            // Don't bother locking if there are no new transactions to process
+            return;
+        }
+
+        if (Synchronizer.getInstance().isSyncRequested() || Synchronizer.getInstance().isSynchronizing()) {
+            // Prioritize syncing, and don't attempt to lock
+            return;
+        }
+
+        ReentrantLock blockchainLock = Controller.getInstance().getBlockchainLock();
+        if (!blockchainLock.tryLock()) {
+            LOGGER.debug("Too busy to import incoming transactions queue");
+            return;
+        }
+
+        LOGGER.debug("Importing incoming transactions queue (size {})...", sigValidTransactions.size());
+
+        int processedCount = 0;
+        try (final Repository repository = RepositoryManager.getRepository()) {
+
+            // Import transactions with valid signatures
+            try {
+                for (int i = 0; i < sigValidTransactions.size(); ++i) {
+                    if (isStopping) {
+                        return;
+                    }
+
+                    if (Synchronizer.getInstance().isSyncRequestPending()) {
+                        LOGGER.debug("Breaking out of transaction importing with {} remaining, because a sync request is pending", sigValidTransactions.size() - i);
+                        return;
+                    }
+
+                    TransactionData transactionData = sigValidTransactions.get(i);
+                    Transaction transaction = Transaction.fromData(repository, transactionData);
+
+                    Transaction.ValidationResult validationResult = transaction.importAsUnconfirmed();
+                    processedCount++;
+
+                    switch (validationResult) {
+                        case TRANSACTION_ALREADY_EXISTS: {
+                            LOGGER.trace(() -> String.format("Ignoring existing transaction %s", Base58.encode(transactionData.getSignature())));
+                            break;
+                        }
+
+                        case NO_BLOCKCHAIN_LOCK: {
+                            // Is this even possible considering we acquired blockchain lock above?
+                            LOGGER.trace(() -> String.format("Couldn't lock blockchain to import unconfirmed transaction %s", Base58.encode(transactionData.getSignature())));
+                            break;
+                        }
+
+                        case OK: {
+                            LOGGER.debug(() -> String.format("Imported %s transaction %s", transactionData.getType().name(), Base58.encode(transactionData.getSignature())));
+                            break;
+                        }
+
+                        // All other invalid cases:
+                        default: {
+                            final String signature58 = Base58.encode(transactionData.getSignature());
+                            LOGGER.debug(() -> String.format("Ignoring invalid (%s) %s transaction %s", validationResult.name(), transactionData.getType().name(), signature58));
+
+                            Long now = NTP.getTime();
+                            if (now != null && now - transactionData.getTimestamp() > INVALID_TRANSACTION_STALE_TIMEOUT) {
+                                Long expiryLength = INVALID_TRANSACTION_RECHECK_INTERVAL;
+
+                                if (validationResult == Transaction.ValidationResult.TIMESTAMP_TOO_OLD) {
+                                    // Use shorter recheck interval for expired transactions
+                                    expiryLength = EXPIRED_TRANSACTION_RECHECK_INTERVAL;
+                                }
+
+                                Long expiry = now + expiryLength;
+                                LOGGER.trace("Adding stale invalid transaction {} to invalidUnconfirmedTransactions...", signature58);
+                                // Invalid, unconfirmed transaction has become stale - add to invalidUnconfirmedTransactions so that we don't keep requesting it
+                                invalidUnconfirmedTransactions.put(signature58, expiry);
+                            }
+                        }
+                    }
+
+                    // Transaction has been processed, even if only to reject it
+                    removeIncomingTransaction(transactionData.getSignature());
+                }
+            } finally {
+                LOGGER.debug("Finished importing {} incoming transaction{}", processedCount, (processedCount == 1 ? "" : "s"));
+                blockchainLock.unlock();
+            }
+        } catch (DataException e) {
+            LOGGER.error("Repository issue while importing incoming transactions", e);
+        }
+    }
+
+    private void cleanupInvalidTransactionsList(Long now) {
+        if (now == null) {
+            return;
+        }
+        // Periodically remove invalid unconfirmed transactions from the list, so that they can be fetched again
+        invalidUnconfirmedTransactions.entrySet().removeIf(entry -> entry.getValue() == null || entry.getValue() < now);
+    }
+
+
+    // Network handlers
+
+    public void onNetworkTransactionMessage(Peer peer, Message message) {
+        TransactionMessage transactionMessage = (TransactionMessage) message;
+        TransactionData transactionData = transactionMessage.getTransactionData();
+
+        if (this.incomingTransactions.size() < MAX_INCOMING_TRANSACTIONS) {
+            synchronized (this.incomingTransactions) {
+                if (!incomingTransactionQueueContains(transactionData.getSignature())) {
+                    this.incomingTransactions.put(transactionData, Boolean.FALSE);
+                }
+            }
+        }
+    }
+
+    public void onNetworkGetTransactionMessage(Peer peer, Message message) {
+        GetTransactionMessage getTransactionMessage = (GetTransactionMessage) message;
+        byte[] signature = getTransactionMessage.getSignature();
+
+        try (final Repository repository = RepositoryManager.getRepository()) {
+            // Firstly check the sig-valid transactions that are currently queued for import
+            TransactionData transactionData = this.getCachedSigValidTransactions().stream()
+                    .filter(t -> Arrays.equals(signature, t.getSignature()))
+                    .findFirst().orElse(null);
+
+            if (transactionData == null) {
+                // Not found in import queue, so try the database
+                transactionData = repository.getTransactionRepository().fromSignature(signature);
+            }
+
+            if (transactionData == null) {
+                // Still not found - so we don't have this transaction
+                LOGGER.debug(() -> String.format("Ignoring GET_TRANSACTION request from peer %s for unknown transaction %s", peer, Base58.encode(signature)));
+                // Send no response at all???
+                return;
+            }
+
+            Message transactionMessage = new TransactionMessage(transactionData);
+            transactionMessage.setId(message.getId());
+            if (!peer.sendMessage(transactionMessage))
+                peer.disconnect("failed to send transaction");
+        } catch (DataException e) {
+            LOGGER.error(String.format("Repository issue while sending transaction %s to peer %s", Base58.encode(signature), peer), e);
+        } catch (TransformationException e) {
+            LOGGER.error(String.format("Serialization issue while sending transaction %s to peer %s", Base58.encode(signature), peer), e);
+        }
+    }
+
+    public void onNetworkGetUnconfirmedTransactionsMessage(Peer peer, Message message) {
+        try (final Repository repository = RepositoryManager.getRepository()) {
+            List<byte[]> signatures = Collections.emptyList();
+
+            // If we're NOT up-to-date then don't send out unconfirmed transactions
+            // as it's possible they are already included in a later block that we don't have.
+            if (Controller.getInstance().isUpToDate())
+                signatures = repository.getTransactionRepository().getUnconfirmedTransactionSignatures();
+
+            Message transactionSignaturesMessage = new TransactionSignaturesMessage(signatures);
+            if (!peer.sendMessage(transactionSignaturesMessage))
+                peer.disconnect("failed to send unconfirmed transaction signatures");
+        } catch (DataException e) {
+            LOGGER.error(String.format("Repository issue while sending unconfirmed transaction signatures to peer %s", peer), e);
+        }
+    }
+
+    public void onNetworkTransactionSignaturesMessage(Peer peer, Message message) {
+        TransactionSignaturesMessage transactionSignaturesMessage = (TransactionSignaturesMessage) message;
+        List<byte[]> signatures = transactionSignaturesMessage.getSignatures();
+
+        try (final Repository repository = RepositoryManager.getRepository()) {
+            for (byte[] signature : signatures) {
+                String signature58 = Base58.encode(signature);
+                if (invalidUnconfirmedTransactions.containsKey(signature58)) {
+                    // Previously invalid transaction - don't keep requesting it
+                    // It will be periodically removed from invalidUnconfirmedTransactions to allow for rechecks
+                    continue;
+                }
+
+                // Ignore if this transaction is in the queue
+                if (incomingTransactionQueueContains(signature)) {
+                    LOGGER.trace(() -> String.format("Ignoring existing queued transaction %s from peer %s", Base58.encode(signature), peer));
+                    continue;
+                }
+
+                // Do we have it already? (Before requesting transaction data itself)
+                if (repository.getTransactionRepository().exists(signature)) {
+                    LOGGER.trace(() -> String.format("Ignoring existing transaction %s from peer %s", Base58.encode(signature), peer));
+                    continue;
+                }
+
+                // Check isInterrupted() here and exit fast
+                if (Thread.currentThread().isInterrupted())
+                    return;
+
+                // Fetch actual transaction data from peer
+                Message getTransactionMessage = new GetTransactionMessage(signature);
+                if (!peer.sendMessage(getTransactionMessage)) {
+                    peer.disconnect("failed to request transaction");
+                    return;
+                }
+            }
+        } catch (DataException e) {
+            LOGGER.error(String.format("Repository issue while processing unconfirmed transactions from peer %s", peer), e);
+        }
+    }
+
+}

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

@@ -180,9 +180,6 @@ public class ArbitraryDataCleanupManager extends Thread {
 									arbitraryTransactionData.getName(), Base58.encode(signature)));
 
 							ArbitraryTransactionUtils.deleteCompleteFileAndChunks(arbitraryTransactionData);
-
-							// We should also remove peers for this transaction from the lookup table to save space
-							this.removePeersHostingTransactionData(repository, arbitraryTransactionData);
 							continue;
 						}
 
@@ -437,16 +434,6 @@ public class ArbitraryDataCleanupManager extends Thread {
 		return false;
 	}
 
-	private void removePeersHostingTransactionData(Repository repository, ArbitraryTransactionData transactionData) {
-		byte[] signature = transactionData.getSignature();
-		try {
-			repository.getArbitraryRepository().deleteArbitraryPeersWithSignature(signature);
-			repository.saveChanges();
-		} catch (DataException e) {
-			LOGGER.debug("Unable to delete peers from lookup table for signature: {}", Base58.encode(signature));
-		}
-	}
-
 	private void cleanupTempDirectory(String folder, long now, long minAge) {
 		String baseDir = Settings.getInstance().getTempDataPath();
 		Path tempDir = Paths.get(baseDir, folder);

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

@@ -5,6 +5,8 @@ import org.apache.logging.log4j.Logger;
 import org.qortal.arbitrary.ArbitraryDataFile;
 import org.qortal.arbitrary.ArbitraryDataFileChunk;
 import org.qortal.controller.Controller;
+import org.qortal.data.arbitrary.ArbitraryDirectConnectionInfo;
+import org.qortal.data.arbitrary.ArbitraryFileListResponseInfo;
 import org.qortal.data.arbitrary.ArbitraryRelayInfo;
 import org.qortal.data.transaction.ArbitraryTransactionData;
 import org.qortal.data.transaction.TransactionData;
@@ -23,6 +25,8 @@ import org.qortal.utils.Triple;
 
 import java.util.*;
 
+import static org.qortal.controller.arbitrary.ArbitraryDataFileManager.MAX_FILE_HASH_RESPONSES;
+
 public class ArbitraryDataFileListManager {
 
     private static final Logger LOGGER = LogManager.getLogger(ArbitraryDataFileListManager.class);
@@ -63,6 +67,9 @@ public class ArbitraryDataFileListManager {
     /** Maximum number of hops that a file list relay request is allowed to make */
     public static int RELAY_REQUEST_MAX_HOPS = 4;
 
+    /** Minimum peer version to use relay */
+    public static String RELAY_MIN_PEER_VERSION = "3.4.0";
+
 
     private ArbitraryDataFileListManager() {
     }
@@ -116,12 +123,22 @@ public class ArbitraryDataFileListManager {
             }
         }
 
-        // Then allow another 5 attempts, each 5 minutes apart
+        // Then allow another 3 attempts, each 5 minutes apart
         if (timeSinceLastAttempt > 5 * 60 * 1000L) {
             // We haven't tried for at least 5 minutes
 
-            if (networkBroadcastCount < 5) {
-                // We've made less than 5 total attempts
+            if (networkBroadcastCount < 6) {
+                // We've made less than 6 total attempts
+                return true;
+            }
+        }
+
+        // Then allow another 4 attempts, each 30 minutes apart
+        if (timeSinceLastAttempt > 30 * 60 * 1000L) {
+            // We haven't tried for at least 5 minutes
+
+            if (networkBroadcastCount < 10) {
+                // We've made less than 10 total attempts
                 return true;
             }
         }
@@ -180,8 +197,8 @@ public class ArbitraryDataFileListManager {
             }
         }
 
-        if (timeSinceLastAttempt > 24 * 60 * 60 * 1000L) {
-            // We haven't tried for at least 24 hours
+        if (timeSinceLastAttempt > 60 * 60 * 1000L) {
+            // We haven't tried for at least 1 hour
             return true;
         }
 
@@ -264,7 +281,7 @@ public class ArbitraryDataFileListManager {
         }
         this.addToSignatureRequests(signature58, true, false);
 
-        List<Peer> handshakedPeers = Network.getInstance().getHandshakedPeers();
+        List<Peer> handshakedPeers = Network.getInstance().getImmutableHandshakedPeers();
         List<byte[]> missingHashes = null;
 
         // Find hashes that we are missing
@@ -279,8 +296,11 @@ public class ArbitraryDataFileListManager {
 
         LOGGER.debug(String.format("Sending data file list request for signature %s with %d hashes to %d peers...", signature58, hashCount, handshakedPeers.size()));
 
+        // Send our address as requestingPeer, to allow for potential direct connections with seeds/peers
+        String requestingPeer = Network.getInstance().getOurExternalIpAddressAndPort();
+
         // Build request
-        Message getArbitraryDataFileListMessage = new GetArbitraryDataFileListMessage(signature, missingHashes, now, 0);
+        Message getArbitraryDataFileListMessage = new GetArbitraryDataFileListMessage(signature, missingHashes, now, 0, requestingPeer);
 
         // Save our request into requests map
         Triple<String, Peer, Long> requestEntry = new Triple<>(signature58, null, NTP.getTime());
@@ -338,7 +358,7 @@ public class ArbitraryDataFileListManager {
         // This could be optimized in the future
         long timestamp = now - 60000L;
         List<byte[]> hashes = null;
-        Message getArbitraryDataFileListMessage = new GetArbitraryDataFileListMessage(signature, hashes, timestamp, 0);
+        Message getArbitraryDataFileListMessage = new GetArbitraryDataFileListMessage(signature, hashes, timestamp, 0, null);
 
         // Save our request into requests map
         Triple<String, Peer, Long> requestEntry = new Triple<>(signature58, null, NTP.getTime());
@@ -431,7 +451,6 @@ public class ArbitraryDataFileListManager {
         }
 
         ArbitraryTransactionData arbitraryTransactionData = null;
-        ArbitraryDataFileManager arbitraryDataFileManager = ArbitraryDataFileManager.getInstance();
 
         // Check transaction exists and hashes are correct
         try (final Repository repository = RepositoryManager.getRepository()) {
@@ -458,16 +477,28 @@ public class ArbitraryDataFileListManager {
 //			}
 
             if (!isRelayRequest || !Settings.getInstance().isRelayModeEnabled()) {
-                // Keep track of the hashes this peer reports to have access to
                 Long now = NTP.getTime();
-                for (byte[] hash : hashes) {
-                    String hash58 = Base58.encode(hash);
-                    String sig58 = Base58.encode(signature);
-                    ArbitraryDataFileManager.getInstance().arbitraryDataFileHashResponses.put(hash58, new Triple<>(peer, sig58, now));
+
+                if (ArbitraryDataFileManager.getInstance().arbitraryDataFileHashResponses.size() < MAX_FILE_HASH_RESPONSES) {
+                    // Keep track of the hashes this peer reports to have access to
+                    for (byte[] hash : hashes) {
+                        String hash58 = Base58.encode(hash);
+
+                        // Treat null request hops as 100, so that they are able to be sorted (and put to the end of the list)
+                        int requestHops = arbitraryDataFileListMessage.getRequestHops() != null ? arbitraryDataFileListMessage.getRequestHops() : 100;
+
+                        ArbitraryFileListResponseInfo responseInfo = new ArbitraryFileListResponseInfo(hash58, signature58,
+                                peer, now, arbitraryDataFileListMessage.getRequestTime(), requestHops);
+
+                        ArbitraryDataFileManager.getInstance().arbitraryDataFileHashResponses.add(responseInfo);
+                    }
                 }
 
-                // Go and fetch the actual data, since this isn't a relay request
-                arbitraryDataFileManager.fetchArbitraryDataFiles(repository, peer, signature, arbitraryTransactionData, hashes);
+                // Keep track of the source peer, for direct connections
+                if (arbitraryDataFileListMessage.getPeerAddress() != null) {
+                    ArbitraryDataFileManager.getInstance().addDirectConnectionInfoIfUnique(
+                            new ArbitraryDirectConnectionInfo(signature, arbitraryDataFileListMessage.getPeerAddress(), hashes, now));
+                }
             }
 
         } catch (DataException e) {
@@ -493,18 +524,24 @@ public class ArbitraryDataFileListManager {
 
                     // Bump requestHops if it exists
                     if (requestHops != null) {
-                        arbitraryDataFileListMessage.setRequestHops(++requestHops);
+                        requestHops++;
                     }
 
+                    ArbitraryDataFileListMessage forwardArbitraryDataFileListMessage;
+
                     // Remove optional parameters if the requesting peer doesn't support it yet
                     // A message with less statistical data is better than no message at all
                     if (!requestingPeer.isAtLeastVersion(MIN_PEER_VERSION_FOR_FILE_LIST_STATS)) {
-                        arbitraryDataFileListMessage.removeOptionalStats();
+                        forwardArbitraryDataFileListMessage = new ArbitraryDataFileListMessage(signature, hashes);
+                    } else {
+                        forwardArbitraryDataFileListMessage = new ArbitraryDataFileListMessage(signature, hashes, requestTime, requestHops,
+                                arbitraryDataFileListMessage.getPeerAddress(), arbitraryDataFileListMessage.isRelayPossible());
                     }
+                    forwardArbitraryDataFileListMessage.setId(message.getId());
 
                     // Forward to requesting peer
                     LOGGER.debug("Forwarding file list with {} hashes to requesting peer: {}", hashes.size(), requestingPeer);
-                    if (!requestingPeer.sendMessage(arbitraryDataFileListMessage)) {
+                    if (!requestingPeer.sendMessage(forwardArbitraryDataFileListMessage)) {
                         requestingPeer.disconnect("failed to forward arbitrary data file list");
                     }
                 }
@@ -523,7 +560,6 @@ public class ArbitraryDataFileListManager {
         GetArbitraryDataFileListMessage getArbitraryDataFileListMessage = (GetArbitraryDataFileListMessage) message;
         byte[] signature = getArbitraryDataFileListMessage.getSignature();
         String signature58 = Base58.encode(signature);
-        List<byte[]> requestedHashes = getArbitraryDataFileListMessage.getHashes();
         Long now = NTP.getTime();
         Triple<String, Peer, Long> newEntry = new Triple<>(signature58, peer, now);
 
@@ -533,7 +569,16 @@ public class ArbitraryDataFileListManager {
             return;
         }
 
-        LOGGER.debug("Received hash list request from peer {} for signature {}", peer, signature58);
+        List<byte[]> requestedHashes = getArbitraryDataFileListMessage.getHashes();
+        int hashCount = requestedHashes != null ? requestedHashes.size() : 0;
+        String requestingPeer = getArbitraryDataFileListMessage.getRequestingPeer();
+
+        if (requestingPeer != null) {
+            LOGGER.debug("Received hash list request with {} hashes from peer {} (requesting peer {}) for signature {}", hashCount, peer, requestingPeer, signature58);
+        }
+        else {
+            LOGGER.debug("Received hash list request with {} hashes from peer {} for signature {}", hashCount, peer, signature58);
+        }
 
         List<byte[]> hashes = new ArrayList<>();
         ArbitraryTransactionData transactionData = null;
@@ -605,6 +650,9 @@ public class ArbitraryDataFileListManager {
         // We should only respond if we have at least one hash
         if (hashes.size() > 0) {
 
+            // Firstly we should keep track of the requesting peer, to allow for potential direct connections later
+            ArbitraryDataFileManager.getInstance().addRecentDataRequest(requestingPeer);
+
             // We have all the chunks, so update requests map to reflect that we've sent it
             // There is no need to keep track of the request, as we can serve all the chunks
             if (allChunksExist) {
@@ -612,17 +660,20 @@ public class ArbitraryDataFileListManager {
                 arbitraryDataFileListRequests.put(message.getId(), newEntry);
             }
 
-            String ourAddress = Network.getInstance().getOurExternalIpAddress();
-            ArbitraryDataFileListMessage arbitraryDataFileListMessage = new ArbitraryDataFileListMessage(signature,
-                    hashes, NTP.getTime(), 0, ourAddress, true);
-            arbitraryDataFileListMessage.setId(message.getId());
+            String ourAddress = Network.getInstance().getOurExternalIpAddressAndPort();
+            ArbitraryDataFileListMessage arbitraryDataFileListMessage;
 
             // Remove optional parameters if the requesting peer doesn't support it yet
             // A message with less statistical data is better than no message at all
             if (!peer.isAtLeastVersion(MIN_PEER_VERSION_FOR_FILE_LIST_STATS)) {
-                arbitraryDataFileListMessage.removeOptionalStats();
+                arbitraryDataFileListMessage = new ArbitraryDataFileListMessage(signature, hashes);
+            } else {
+                arbitraryDataFileListMessage = new ArbitraryDataFileListMessage(signature,
+                        hashes, NTP.getTime(), 0, ourAddress, true);
             }
 
+            arbitraryDataFileListMessage.setId(message.getId());
+
             if (!peer.sendMessage(arbitraryDataFileListMessage)) {
                 LOGGER.debug("Couldn't send list of hashes");
                 peer.disconnect("failed to send list of hashes");
@@ -644,8 +695,7 @@ public class ArbitraryDataFileListManager {
             // In relay mode - so ask our other peers if they have it
 
             long requestTime = getArbitraryDataFileListMessage.getRequestTime();
-            int requestHops = getArbitraryDataFileListMessage.getRequestHops();
-            getArbitraryDataFileListMessage.setRequestHops(++requestHops);
+            int requestHops = getArbitraryDataFileListMessage.getRequestHops() + 1;
             long totalRequestTime = now - requestTime;
 
             if (totalRequestTime < RELAY_REQUEST_MAX_DURATION) {
@@ -653,11 +703,15 @@ public class ArbitraryDataFileListManager {
                 if (requestHops < RELAY_REQUEST_MAX_HOPS) {
                     // Relay request hasn't reached the maximum number of hops yet, so can be rebroadcast
 
+                    Message relayGetArbitraryDataFileListMessage = new GetArbitraryDataFileListMessage(signature, hashes, requestTime, requestHops, requestingPeer);
+                    relayGetArbitraryDataFileListMessage.setId(message.getId());
+
                     LOGGER.debug("Rebroadcasting hash list request from peer {} for signature {} to our other peers... totalRequestTime: {}, requestHops: {}", peer, Base58.encode(signature), totalRequestTime, requestHops);
                     Network.getInstance().broadcast(
-                            broadcastPeer -> broadcastPeer == peer ||
-                                    Objects.equals(broadcastPeer.getPeerData().getAddress().getHost(), peer.getPeerData().getAddress().getHost())
-                                    ? null : getArbitraryDataFileListMessage);
+                            broadcastPeer ->
+                                    !broadcastPeer.isAtLeastVersion(RELAY_MIN_PEER_VERSION) ? null :
+                                    broadcastPeer == peer || Objects.equals(broadcastPeer.getPeerData().getAddress().getHost(), peer.getPeerData().getAddress().getHost()) ? null : relayGetArbitraryDataFileListMessage
+                    );
 
                 }
                 else {

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

@@ -1,11 +1,13 @@
 package org.qortal.controller.arbitrary;
 
+import com.google.common.net.InetAddresses;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.qortal.arbitrary.ArbitraryDataFile;
 import org.qortal.controller.Controller;
+import org.qortal.data.arbitrary.ArbitraryDirectConnectionInfo;
+import org.qortal.data.arbitrary.ArbitraryFileListResponseInfo;
 import org.qortal.data.arbitrary.ArbitraryRelayInfo;
-import org.qortal.data.network.ArbitraryPeerData;
 import org.qortal.data.network.PeerData;
 import org.qortal.data.transaction.ArbitraryTransactionData;
 import org.qortal.network.Network;
@@ -18,7 +20,6 @@ import org.qortal.settings.Settings;
 import org.qortal.utils.ArbitraryTransactionUtils;
 import org.qortal.utils.Base58;
 import org.qortal.utils.NTP;
-import org.qortal.utils.Triple;
 
 import java.security.SecureRandom;
 import java.util.*;
@@ -45,11 +46,24 @@ public class ArbitraryDataFileManager extends Thread {
     public List<ArbitraryRelayInfo> arbitraryRelayMap = Collections.synchronizedList(new ArrayList<>());
 
     /**
-     * Map to keep track of any arbitrary data file hash responses
-     * Key: string - the hash encoded in base58
-     * Value: Triple<respondingPeer, signature58, timeResponded>
+     * List to keep track of any arbitrary data file hash responses
      */
-    public Map<String, Triple<Peer, String, Long>> arbitraryDataFileHashResponses = Collections.synchronizedMap(new HashMap<>());
+    public final List<ArbitraryFileListResponseInfo> arbitraryDataFileHashResponses = Collections.synchronizedList(new ArrayList<>());
+
+    /**
+     * List to keep track of peers potentially available for direct connections, based on recent requests
+     */
+    private List<ArbitraryDirectConnectionInfo> directConnectionInfo = Collections.synchronizedList(new ArrayList<>());
+
+    /**
+     * Map to keep track of peers requesting QDN data that we hold.
+     * Key = peer address string, value = time of last request.
+     * This allows for additional "burst" connections beyond existing limits.
+     */
+    private Map<String, Long> recentDataRequests = Collections.synchronizedMap(new HashMap<>());
+
+
+    public static int MAX_FILE_HASH_RESPONSES = 1000;
 
 
     private ArbitraryDataFileManager() {
@@ -98,7 +112,13 @@ public class ArbitraryDataFileManager extends Thread {
 
         final long relayMinimumTimestamp = now - ArbitraryDataManager.getInstance().ARBITRARY_RELAY_TIMEOUT;
         arbitraryRelayMap.removeIf(entry -> entry == null || entry.getTimestamp() == null || entry.getTimestamp() < relayMinimumTimestamp);
-        arbitraryDataFileHashResponses.entrySet().removeIf(entry -> entry.getValue().getC() == null || entry.getValue().getC() < relayMinimumTimestamp);
+        arbitraryDataFileHashResponses.removeIf(entry -> entry.getTimestamp() < relayMinimumTimestamp);
+
+        final long directConnectionInfoMinimumTimestamp = now - ArbitraryDataManager.getInstance().ARBITRARY_DIRECT_CONNECTION_INFO_TIMEOUT;
+        directConnectionInfo.removeIf(entry -> entry.getTimestamp() < directConnectionInfoMinimumTimestamp);
+
+        final long recentDataRequestMinimumTimestamp = now - ArbitraryDataManager.getInstance().ARBITRARY_RECENT_DATA_REQUESTS_TIMEOUT;
+        recentDataRequests.entrySet().removeIf(entry -> entry.getValue() < recentDataRequestMinimumTimestamp);
     }
 
 
@@ -130,7 +150,7 @@ public class ArbitraryDataFileManager extends Thread {
                     Long startTime = NTP.getTime();
                     ArbitraryDataFileMessage receivedArbitraryDataFileMessage = fetchArbitraryDataFile(peer, null, signature, hash, null);
                     Long endTime = NTP.getTime();
-                    if (receivedArbitraryDataFileMessage != null) {
+                    if (receivedArbitraryDataFileMessage != null && receivedArbitraryDataFileMessage.getArbitraryDataFile() != null) {
                         LOGGER.debug("Received data file {} from peer {}. Time taken: {} ms", receivedArbitraryDataFileMessage.getArbitraryDataFile().getHash58(), peer, (endTime-startTime));
                         receivedAtLeastOneFile = true;
 
@@ -158,16 +178,6 @@ public class ArbitraryDataFileManager extends Thread {
         }
 
         if (receivedAtLeastOneFile) {
-            // Update our lookup table to indicate that this peer holds data for this signature
-            String peerAddress = peer.getPeerData().getAddress().toString();
-            ArbitraryPeerData arbitraryPeerData = new ArbitraryPeerData(signature, peer);
-            repository.discardChanges();
-            if (arbitraryPeerData.isPeerAddressValid()) {
-                LOGGER.debug("Adding arbitrary peer: {} for signature {}", peerAddress, Base58.encode(signature));
-                repository.getArbitraryRepository().save(arbitraryPeerData);
-                repository.saveChanges();
-            }
-
             // Invalidate the hosted transactions cache as we are now hosting something new
             ArbitraryDataStorageManager.getInstance().invalidateHostedTransactionsCache();
 
@@ -177,16 +187,7 @@ public class ArbitraryDataFileManager extends Thread {
                 // We have all the chunks for this transaction, so we should invalidate the transaction's name's
                 // data cache so that it is rebuilt the next time we serve it
                 ArbitraryDataManager.getInstance().invalidateCache(arbitraryTransactionData);
-
-                // We may also need to broadcast to the network that we are now hosting files for this transaction,
-                // but only if these files are in accordance with our storage policy
-                if (ArbitraryDataStorageManager.getInstance().canStoreData(arbitraryTransactionData)) {
-                    // Use a null peer address to indicate our own
-                    Message newArbitrarySignatureMessage = new ArbitrarySignaturesMessage(null, 0, Arrays.asList(signature));
-                    Network.getInstance().broadcast(broadcastPeer -> newArbitrarySignatureMessage);
-                }
             }
-
         }
 
         return receivedAtLeastOneFile;
@@ -196,7 +197,7 @@ public class ArbitraryDataFileManager extends Thread {
         ArbitraryDataFile existingFile = ArbitraryDataFile.fromHash(hash, signature);
         boolean fileAlreadyExists = existingFile.exists();
         String hash58 = Base58.encode(hash);
-        Message message = null;
+        ArbitraryDataFileMessage arbitraryDataFileMessage;
 
         // Fetch the file if it doesn't exist locally
         if (!fileAlreadyExists) {
@@ -204,10 +205,11 @@ public class ArbitraryDataFileManager extends Thread {
             arbitraryDataFileRequests.put(hash58, NTP.getTime());
             Message getArbitraryDataFileMessage = new GetArbitraryDataFileMessage(signature, hash);
 
+            Message response = null;
             try {
-                message = peer.getResponseWithTimeout(getArbitraryDataFileMessage, (int) ArbitraryDataManager.ARBITRARY_REQUEST_TIMEOUT);
+                response = peer.getResponseWithTimeout(getArbitraryDataFileMessage, (int) ArbitraryDataManager.ARBITRARY_REQUEST_TIMEOUT);
             } catch (InterruptedException e) {
-                // Will return below due to null message
+                // Will return below due to null response
             }
             arbitraryDataFileRequests.remove(hash58);
             LOGGER.trace(String.format("Removed hash %.8s from arbitraryDataFileRequests", hash58));
@@ -215,22 +217,24 @@ public class ArbitraryDataFileManager extends Thread {
             // We may need to remove the file list request, if we have all the files for this transaction
             this.handleFileListRequests(signature);
 
-            if (message == null) {
-                LOGGER.debug("Received null message from peer {}", peer);
+            if (response == null) {
+                LOGGER.debug("Received null response from peer {}", peer);
                 return null;
             }
-            if (message.getType() != Message.MessageType.ARBITRARY_DATA_FILE) {
-                LOGGER.debug("Received message with invalid type: {} from peer {}", message.getType(), peer);
+            if (response.getType() != MessageType.ARBITRARY_DATA_FILE) {
+                LOGGER.debug("Received response with invalid type: {} from peer {}", response.getType(), peer);
                 return null;
             }
-        }
-        else {
+
+            ArbitraryDataFileMessage peersArbitraryDataFileMessage = (ArbitraryDataFileMessage) response;
+            arbitraryDataFileMessage = new ArbitraryDataFileMessage(signature, peersArbitraryDataFileMessage.getArbitraryDataFile());
+        } else {
             LOGGER.debug(String.format("File hash %s already exists, so skipping the request", hash58));
+            arbitraryDataFileMessage = new ArbitraryDataFileMessage(signature, existingFile);
         }
-        ArbitraryDataFileMessage arbitraryDataFileMessage = (ArbitraryDataFileMessage) message;
 
         // We might want to forward the request to the peer that originally requested it
-        this.handleArbitraryDataFileForwarding(requestingPeer, message, originalMessage);
+        this.handleArbitraryDataFileForwarding(requestingPeer, arbitraryDataFileMessage, originalMessage);
 
         boolean isRelayRequest = (requestingPeer != null);
         if (isRelayRequest) {
@@ -296,89 +300,135 @@ public class ArbitraryDataFileManager extends Thread {
 
     // Fetch data directly from peers
 
+    private List<ArbitraryDirectConnectionInfo> getDirectConnectionInfoForSignature(byte[] signature) {
+        synchronized (directConnectionInfo) {
+            return directConnectionInfo.stream().filter(i -> Arrays.equals(i.getSignature(), signature)).collect(Collectors.toList());
+        }
+    }
+
+    /**
+     * Add an ArbitraryDirectConnectionInfo item, but only if one with this peer-signature combination
+     * doesn't already exist.
+     * @param connectionInfo - the direct connection info to add
+     */
+    public void addDirectConnectionInfoIfUnique(ArbitraryDirectConnectionInfo connectionInfo) {
+        boolean peerAlreadyExists;
+        synchronized (directConnectionInfo) {
+            peerAlreadyExists = directConnectionInfo.stream()
+                    .anyMatch(i -> Arrays.equals(i.getSignature(), connectionInfo.getSignature())
+                            && Objects.equals(i.getPeerAddress(), connectionInfo.getPeerAddress()));
+        }
+        if (!peerAlreadyExists) {
+            directConnectionInfo.add(connectionInfo);
+        }
+    }
+
+    private void removeDirectConnectionInfo(ArbitraryDirectConnectionInfo connectionInfo) {
+        this.directConnectionInfo.remove(connectionInfo);
+    }
+
     public boolean fetchDataFilesFromPeersForSignature(byte[] signature) {
         String signature58 = Base58.encode(signature);
-        ArbitraryDataFileListManager.getInstance().addToSignatureRequests(signature58, false, true);
 
-        // Firstly fetch peers that claim to be hosting files for this signature
-        try (final Repository repository = RepositoryManager.getRepository()) {
+        boolean success = false;
 
-            List<ArbitraryPeerData> peers = repository.getArbitraryRepository().getArbitraryPeerDataForSignature(signature);
-            if (peers == null || peers.isEmpty()) {
-                LOGGER.debug("No peers found for signature {}", signature58);
-                return false;
-            }
-
-            LOGGER.debug("Attempting a direct peer connection for signature {}...", signature58);
-
-            // Peers found, so pick a random one and request data from it
-            int index = new SecureRandom().nextInt(peers.size());
-            ArbitraryPeerData arbitraryPeerData = peers.get(index);
-            String peerAddressString = arbitraryPeerData.getPeerAddress();
-            boolean success = Network.getInstance().requestDataFromPeer(peerAddressString, signature);
-
-            // Parse the peer address to find the host and port
-            String host = null;
-            int port = -1;
-            String[] parts = peerAddressString.split(":");
-            if (parts.length > 1) {
-                host = parts[0];
-                port = Integer.parseInt(parts[1]);
-            }
-
-            // If unsuccessful, and using a non-standard port, try a second connection with the default listen port,
-            // since almost all nodes use that. This is a workaround to account for any ephemeral ports that may
-            // have made it into the dataset.
-            if (!success) {
-                if (host != null && port > 0) {
-                    int defaultPort = Settings.getInstance().getDefaultListenPort();
-                    if (port != defaultPort) {
-                        String newPeerAddressString = String.format("%s:%d", host, defaultPort);
-                        success = Network.getInstance().requestDataFromPeer(newPeerAddressString, signature);
-                    }
+        try {
+            while (!success) {
+                if (isStopping) {
+                    return false;
                 }
-            }
+                Thread.sleep(500L);
 
-            // If _still_ unsuccessful, try matching the peer's IP address with some known peers, and then connect
-            // to each of those in turn until one succeeds.
-            if (!success) {
-                if (host != null) {
-                    final String finalHost = host;
-                    List<PeerData> knownPeers = Network.getInstance().getAllKnownPeers().stream()
-                            .filter(knownPeerData -> knownPeerData.getAddress().getHost().equals(finalHost))
-                            .collect(Collectors.toList());
-                    // Loop through each match and attempt a connection
-                    for (PeerData matchingPeer : knownPeers) {
-                        String matchingPeerAddress = matchingPeer.getAddress().toString();
-                        success = Network.getInstance().requestDataFromPeer(matchingPeerAddress, signature);
-                        if (success) {
-                            // Successfully connected, so stop making connections
-                            break;
+                // Firstly fetch peers that claim to be hosting files for this signature
+                List<ArbitraryDirectConnectionInfo> connectionInfoList = getDirectConnectionInfoForSignature(signature);
+                if (connectionInfoList == null || connectionInfoList.isEmpty()) {
+                    LOGGER.debug("No remaining direct connection peers found for signature {}", signature58);
+                    return false;
+                }
+
+                LOGGER.debug("Attempting a direct peer connection for signature {}...", signature58);
+
+                // Peers found, so pick one with the highest number of chunks
+                Comparator<ArbitraryDirectConnectionInfo> highestChunkCountFirstComparator =
+                        Comparator.comparingInt(ArbitraryDirectConnectionInfo::getHashCount).reversed();
+                ArbitraryDirectConnectionInfo directConnectionInfo = connectionInfoList.stream()
+                        .sorted(highestChunkCountFirstComparator).findFirst().orElse(null);
+
+                if (directConnectionInfo == null) {
+                    return false;
+                }
+
+                // Remove from the list so that a different peer is tried next time
+                removeDirectConnectionInfo(directConnectionInfo);
+
+                String peerAddressString = directConnectionInfo.getPeerAddress();
+
+                // Parse the peer address to find the host and port
+                String host = null;
+                int port = -1;
+                String[] parts = peerAddressString.split(":");
+                if (parts.length > 1) {
+                    host = parts[0];
+                    port = Integer.parseInt(parts[1]);
+                } else {
+                    // Assume no port included
+                    host = peerAddressString;
+                    // Use default listen port
+                    port = Settings.getInstance().getDefaultListenPort();
+                }
+
+                String peerAddressStringWithPort = String.format("%s:%d", host, port);
+                success = Network.getInstance().requestDataFromPeer(peerAddressStringWithPort, signature);
+
+                int defaultPort = Settings.getInstance().getDefaultListenPort();
+
+                // If unsuccessful, and using a non-standard port, try a second connection with the default listen port,
+                // since almost all nodes use that. This is a workaround to account for any ephemeral ports that may
+                // have made it into the dataset.
+                if (!success) {
+                    if (host != null && port > 0) {
+                        if (port != defaultPort) {
+                            String newPeerAddressString = String.format("%s:%d", host, defaultPort);
+                            success = Network.getInstance().requestDataFromPeer(newPeerAddressString, signature);
                         }
                     }
                 }
-            }
 
-            // Keep track of the success or failure
-            arbitraryPeerData.markAsAttempted();
-            if (success) {
-                arbitraryPeerData.markAsRetrieved();
-                arbitraryPeerData.incrementSuccesses();
-            }
-            else {
-                arbitraryPeerData.incrementFailures();
-            }
-            repository.discardChanges();
-            repository.getArbitraryRepository().save(arbitraryPeerData);
-            repository.saveChanges();
+                // If _still_ unsuccessful, try matching the peer's IP address with some known peers, and then connect
+                // to each of those in turn until one succeeds.
+                if (!success) {
+                    if (host != null) {
+                        final String finalHost = host;
+                        List<PeerData> knownPeers = Network.getInstance().getAllKnownPeers().stream()
+                                .filter(knownPeerData -> knownPeerData.getAddress().getHost().equals(finalHost))
+                                .collect(Collectors.toList());
+                        // Loop through each match and attempt a connection
+                        for (PeerData matchingPeer : knownPeers) {
+                            String matchingPeerAddress = matchingPeer.getAddress().toString();
+                            int matchingPeerPort = matchingPeer.getAddress().getPort();
+                            // Make sure that it's not a port we've already tried
+                            if (matchingPeerPort != port && matchingPeerPort != defaultPort) {
+                                success = Network.getInstance().requestDataFromPeer(matchingPeerAddress, signature);
+                                if (success) {
+                                    // Successfully connected, so stop making connections
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
 
-            return success;
+                if (success) {
+                    // We were able to connect with a peer, so track the request
+                    ArbitraryDataFileListManager.getInstance().addToSignatureRequests(signature58, false, true);
+                }
 
-        } catch (DataException e) {
-            LOGGER.debug("Unable to fetch peer list from repository");
+            }
+        } catch (InterruptedException e) {
+            // Do nothing
         }
 
-        return false;
+        return success;
     }
 
 
@@ -451,6 +501,45 @@ public class ArbitraryDataFileManager extends Thread {
     }
 
 
+    // Peers requesting QDN data from us
+
+    /**
+     * Add an address string of a peer that is trying to request data from us.
+     * @param peerAddress
+     */
+    public void addRecentDataRequest(String peerAddress) {
+        if (peerAddress == null) {
+            return;
+        }
+
+        Long now = NTP.getTime();
+        if (now == null) {
+            return;
+        }
+
+        // Make sure to remove the port, since it isn't guaranteed to match next time
+        String[] parts = peerAddress.split(":");
+        if (parts.length == 0) {
+            return;
+        }
+        String host = parts[0];
+        if (!InetAddresses.isInetAddress(host)) {
+            // Invalid host
+            return;
+        }
+
+        this.recentDataRequests.put(host, now);
+    }
+
+    public boolean isPeerRequestingData(String peerAddressWithoutPort) {
+        return this.recentDataRequests.containsKey(peerAddressWithoutPort);
+    }
+
+    public boolean hasPendingDataRequest() {
+        return !this.recentDataRequests.isEmpty();
+    }
+
+
     // Network handlers
 
     public void onNetworkGetArbitraryDataFileMessage(Peer peer, Message message) {

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

@@ -3,6 +3,7 @@ package org.qortal.controller.arbitrary;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.qortal.controller.Controller;
+import org.qortal.data.arbitrary.ArbitraryFileListResponseInfo;
 import org.qortal.data.transaction.ArbitraryTransactionData;
 import org.qortal.network.Peer;
 import org.qortal.repository.DataException;
@@ -11,11 +12,9 @@ import org.qortal.repository.RepositoryManager;
 import org.qortal.utils.ArbitraryTransactionUtils;
 import org.qortal.utils.Base58;
 import org.qortal.utils.NTP;
-import org.qortal.utils.Triple;
 
-import java.util.Arrays;
-import java.util.Iterator;
-import java.util.Map;
+import java.util.*;
+import java.util.stream.Collectors;
 
 public class ArbitraryDataFileRequestThread implements Runnable {
 
@@ -51,45 +50,47 @@ public class ArbitraryDataFileRequestThread implements Runnable {
         boolean shouldProcess = false;
 
         synchronized (arbitraryDataFileManager.arbitraryDataFileHashResponses) {
-            Iterator iterator = arbitraryDataFileManager.arbitraryDataFileHashResponses.entrySet().iterator();
-            while (iterator.hasNext()) {
-                if (Controller.isStopping()) {
-                    return;
-                }
+            if (!arbitraryDataFileManager.arbitraryDataFileHashResponses.isEmpty()) {
 
-                Map.Entry entry = (Map.Entry) iterator.next();
-                if (entry == null || entry.getKey() == null || entry.getValue() == null) {
+                // Sort by lowest number of node hops first
+                Comparator<ArbitraryFileListResponseInfo> lowestHopsFirstComparator =
+                        Comparator.comparingInt(ArbitraryFileListResponseInfo::getRequestHops);
+                arbitraryDataFileManager.arbitraryDataFileHashResponses.sort(lowestHopsFirstComparator);
+
+                Iterator iterator = arbitraryDataFileManager.arbitraryDataFileHashResponses.iterator();
+                while (iterator.hasNext()) {
+                    if (Controller.isStopping()) {
+                        return;
+                    }
+
+                    ArbitraryFileListResponseInfo responseInfo = (ArbitraryFileListResponseInfo) iterator.next();
+                    if (responseInfo == null) {
+                        iterator.remove();
+                        continue;
+                    }
+
+                    hash58 = responseInfo.getHash58();
+                    peer = responseInfo.getPeer();
+                    signature58 = responseInfo.getSignature58();
+                    Long timestamp = responseInfo.getTimestamp();
+
+                    if (now - timestamp >= ArbitraryDataManager.ARBITRARY_RELAY_TIMEOUT || signature58 == null || peer == null) {
+                        // Ignore - to be deleted
+                        iterator.remove();
+                        continue;
+                    }
+
+                    // Skip if already requesting, but don't remove, as we might want to retry later
+                    if (arbitraryDataFileManager.arbitraryDataFileRequests.containsKey(hash58)) {
+                        // Already requesting - leave this attempt for later
+                        continue;
+                    }
+
+                    // We want to process this file
+                    shouldProcess = true;
                     iterator.remove();
-                    continue;
+                    break;
                 }
-
-                hash58 = (String) entry.getKey();
-                Triple<Peer, String, Long> value = (Triple<Peer, String, Long>) entry.getValue();
-                if (value == null) {
-                    iterator.remove();
-                    continue;
-                }
-
-                peer = value.getA();
-                signature58 = value.getB();
-                Long timestamp = value.getC();
-
-                if (now - timestamp >= ArbitraryDataManager.ARBITRARY_RELAY_TIMEOUT || signature58 == null || peer == null) {
-                    // Ignore - to be deleted
-                    iterator.remove();
-                    continue;
-                }
-
-                // Skip if already requesting, but don't remove, as we might want to retry later
-                if (arbitraryDataFileManager.arbitraryDataFileRequests.containsKey(hash58)) {
-                    // Already requesting - leave this attempt for later
-                    continue;
-                }
-
-                // We want to process this file
-                shouldProcess = true;
-                iterator.remove();
-                break;
             }
         }
 

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

@@ -1,8 +1,10 @@
 package org.qortal.controller.arbitrary;
 
 import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
 import java.util.*;
-import java.util.stream.Collectors;
 
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
@@ -12,13 +14,11 @@ import org.qortal.arbitrary.ArbitraryDataResource;
 import org.qortal.arbitrary.metadata.ArbitraryDataTransactionMetadata;
 import org.qortal.arbitrary.misc.Service;
 import org.qortal.controller.Controller;
-import org.qortal.data.network.ArbitraryPeerData;
 import org.qortal.data.transaction.ArbitraryTransactionData;
 import org.qortal.data.transaction.TransactionData;
 import org.qortal.list.ResourceListManager;
 import org.qortal.network.Network;
 import org.qortal.network.Peer;
-import org.qortal.network.message.*;
 import org.qortal.repository.DataException;
 import org.qortal.repository.Repository;
 import org.qortal.repository.RepositoryManager;
@@ -44,9 +44,21 @@ public class ArbitraryDataManager extends Thread {
 	/** Maximum time to hold information about an in-progress relay */
 	public static final long ARBITRARY_RELAY_TIMEOUT = 60 * 1000L; // ms
 
+	/** Maximum time to hold direct peer connection information */
+	public static final long ARBITRARY_DIRECT_CONNECTION_INFO_TIMEOUT = 2 * 60 * 1000L; // ms
+
+	/** Maximum time to hold information about recent data requests that we can fulfil */
+	public static final long ARBITRARY_RECENT_DATA_REQUESTS_TIMEOUT = 2 * 60 * 1000L; // ms
+
 	/** Maximum number of hops that an arbitrary signatures request is allowed to make */
 	private static int ARBITRARY_SIGNATURES_REQUEST_MAX_HOPS = 3;
 
+	private long lastMetadataFetchTime = 0L;
+	private static long METADATA_FETCH_INTERVAL = 5 * 60 * 1000L;
+
+	private long lastDataFetchTime = 0L;
+	private static long DATA_FETCH_INTERVAL = 1 * 60 * 1000L;
+
 	private static ArbitraryDataManager instance;
 	private final Object peerDataLock = new Object();
 
@@ -80,6 +92,9 @@ public class ArbitraryDataManager extends Thread {
 	public void run() {
 		Thread.currentThread().setName("Arbitrary Data Manager");
 
+		// Create data directory in case it doesn't exist yet
+		this.createDataDirectory();
+
 		try {
 			// Wait for node to finish starting up and making connections
 			Thread.sleep(2 * 60 * 1000L);
@@ -93,7 +108,13 @@ public class ArbitraryDataManager extends Thread {
 					continue;
 				}
 
-				List<Peer> peers = Network.getInstance().getHandshakedPeers();
+				Long now = NTP.getTime();
+				if (now == null) {
+					continue;
+				}
+
+				// Needs a mutable copy of the unmodifiableList
+				List<Peer> peers = new ArrayList<>(Network.getInstance().getImmutableHandshakedPeers());
 
 				// Disregard peers that have "misbehaved" recently
 				peers.removeIf(Controller.hasMisbehaved);
@@ -104,8 +125,19 @@ public class ArbitraryDataManager extends Thread {
 				}
 
 				// Fetch metadata
-				// Disabled for now. TODO: re-enable later.
-				// this.fetchAllMetadata();
+				if (NTP.getTime() - lastMetadataFetchTime >= METADATA_FETCH_INTERVAL) {
+					this.fetchAllMetadata();
+					lastMetadataFetchTime = NTP.getTime();
+				}
+
+				// Check if we need to fetch any data
+				if (NTP.getTime() - lastDataFetchTime < DATA_FETCH_INTERVAL) {
+					// Nothing to do yet
+					continue;
+				}
+
+				// In case the data directory has been deleted...
+				this.createDataDirectory();
 
 				// Fetch data according to storage policy
 				switch (Settings.getInstance().getStoragePolicy()) {
@@ -116,6 +148,7 @@ public class ArbitraryDataManager extends Thread {
 
 					case ALL:
 						this.processAll();
+						break;
 
 					case NONE:
 					case VIEWED:
@@ -124,6 +157,8 @@ public class ArbitraryDataManager extends Thread {
 						Thread.sleep(60000);
 						break;
 				}
+
+				lastDataFetchTime = NTP.getTime();
 			}
 		} catch (InterruptedException e) {
 			// Fall-through to exit thread...
@@ -135,7 +170,7 @@ public class ArbitraryDataManager extends Thread {
 		this.interrupt();
 	}
 
-	private void processNames() {
+	private void processNames() throws InterruptedException {
 		// Fetch latest list of followed names
 		List<String> followedNames = ResourceListManager.getInstance().getStringsInList("followedNames");
 		if (followedNames == null || followedNames.isEmpty()) {
@@ -148,11 +183,11 @@ public class ArbitraryDataManager extends Thread {
 		}
 	}
 
-	private void processAll() {
+	private void processAll() throws InterruptedException {
 		this.fetchAndProcessTransactions(null);
 	}
 
-	private void fetchAndProcessTransactions(String name) {
+	private void fetchAndProcessTransactions(String name) throws InterruptedException {
 		ArbitraryDataStorageManager storageManager = ArbitraryDataStorageManager.getInstance();
 
 		// Paginate queries when fetching arbitrary transactions
@@ -160,6 +195,7 @@ public class ArbitraryDataManager extends Thread {
 		int offset = 0;
 
 		while (!isStopping) {
+			Thread.sleep(1000L);
 
 			// Any arbitrary transactions we want to fetch data for?
 			try (final Repository repository = RepositoryManager.getRepository()) {
@@ -174,6 +210,7 @@ public class ArbitraryDataManager extends Thread {
 				// Loop through signatures and remove ones we don't need to process
 				Iterator iterator = signatures.iterator();
 				while (iterator.hasNext()) {
+					Thread.sleep(25L); // Reduce CPU usage
 					byte[] signature = (byte[]) iterator.next();
 
 					ArbitraryTransaction arbitraryTransaction = fetchTransaction(repository, signature);
@@ -230,7 +267,7 @@ public class ArbitraryDataManager extends Thread {
 		}
 	}
 
-	private void fetchAllMetadata() {
+	private void fetchAllMetadata() throws InterruptedException {
 		ArbitraryDataStorageManager storageManager = ArbitraryDataStorageManager.getInstance();
 
 		// Paginate queries when fetching arbitrary transactions
@@ -238,6 +275,7 @@ public class ArbitraryDataManager extends Thread {
 		int offset = 0;
 
 		while (!isStopping) {
+			Thread.sleep(1000L);
 
 			// Any arbitrary transactions we want to fetch data for?
 			try (final Repository repository = RepositoryManager.getRepository()) {
@@ -252,6 +290,7 @@ public class ArbitraryDataManager extends Thread {
 				// Loop through signatures and remove ones we don't need to process
 				Iterator iterator = signatures.iterator();
 				while (iterator.hasNext()) {
+					Thread.sleep(25L); // Reduce CPU usage
 					byte[] signature = (byte[]) iterator.next();
 
 					ArbitraryTransaction arbitraryTransaction = fetchTransaction(repository, signature);
@@ -335,6 +374,12 @@ public class ArbitraryDataManager extends Thread {
 			ArbitraryTransactionData arbitraryTransactionData = (ArbitraryTransactionData) arbitraryTransaction.getTransactionData();
 			byte[] signature = arbitraryTransactionData.getSignature();
 			byte[] metadataHash = arbitraryTransactionData.getMetadataHash();
+
+			if (metadataHash == null) {
+				// This transaction doesn't have metadata associated with it, so return true to indicate that we have everything
+				return true;
+			}
+
 			ArbitraryDataFile metadataFile = ArbitraryDataFile.fromHash(metadataHash, signature);
 
 			return metadataFile.exists();
@@ -476,95 +521,19 @@ public class ArbitraryDataManager extends Thread {
 		}
 	}
 
-
-	// Broadcast list of hosted signatures
-
-	public void broadcastHostedSignatureList() {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			List<ArbitraryTransactionData> hostedTransactions = ArbitraryDataStorageManager.getInstance().listAllHostedTransactions(repository, null, null);
-			List<byte[]> hostedSignatures = hostedTransactions.stream().map(ArbitraryTransactionData::getSignature).collect(Collectors.toList());
-			if (!hostedSignatures.isEmpty()) {
-				// Broadcast the list, using null to represent our peer address
-				LOGGER.info("Broadcasting list of hosted signatures...");
-				Message arbitrarySignatureMessage = new ArbitrarySignaturesMessage(null, 0, hostedSignatures);
-				Network.getInstance().broadcast(broadcastPeer -> arbitrarySignatureMessage);
-			}
-		} catch (DataException e) {
-			LOGGER.error("Repository issue when fetching arbitrary transaction data for broadcast", e);
+	private boolean createDataDirectory() {
+		// Create the data directory if it doesn't exist
+		String dataPath = Settings.getInstance().getDataPath();
+		Path dataDirectory = Paths.get(dataPath);
+		try {
+			Files.createDirectories(dataDirectory);
+		} catch (IOException e) {
+			LOGGER.error("Unable to create data directory");
+			return false;
 		}
+		return true;
 	}
 
-
-	// Handle incoming arbitrary signatures messages
-
-	public void onNetworkArbitrarySignaturesMessage(Peer peer, Message message) {
-		// Don't process if QDN is disabled
-		if (!Settings.getInstance().isQdnEnabled()) {
-			return;
-		}
-
-		LOGGER.debug("Received arbitrary signature list from peer {}", peer);
-
-		ArbitrarySignaturesMessage arbitrarySignaturesMessage = (ArbitrarySignaturesMessage) message;
-		List<byte[]> signatures = arbitrarySignaturesMessage.getSignatures();
-
-		String peerAddress = peer.getPeerData().getAddress().toString();
-		if (arbitrarySignaturesMessage.getPeerAddress() != null && !arbitrarySignaturesMessage.getPeerAddress().isEmpty()) {
-			// This message is about a different peer than the one that sent it
-			peerAddress = arbitrarySignaturesMessage.getPeerAddress();
-		}
-
-		boolean containsNewEntry = false;
-
-		// Synchronize peer data lookups to make this process thread safe. Otherwise we could broadcast
-		// the same data multiple times, due to more than one thread processing the same message from different peers
-		synchronized (this.peerDataLock) {
-			try (final Repository repository = RepositoryManager.getRepository()) {
-				for (byte[] signature : signatures) {
-
-					// Check if a record already exists for this hash/host combination
-					// The port is not checked here - only the host/ip - in order to avoid duplicates
-					// from filling up the db due to dynamic/ephemeral ports
-					ArbitraryPeerData existingEntry = repository.getArbitraryRepository()
-							.getArbitraryPeerDataForSignatureAndHost(signature, peer.getPeerData().getAddress().getHost());
-
-					if (existingEntry == null) {
-						// We haven't got a record of this mapping yet, so add it
-						ArbitraryPeerData arbitraryPeerData = new ArbitraryPeerData(signature, peerAddress);
-						repository.discardChanges();
-						if (arbitraryPeerData.isPeerAddressValid()) {
-							LOGGER.debug("Adding arbitrary peer: {} for signature {}", peerAddress, Base58.encode(signature));
-							repository.getArbitraryRepository().save(arbitraryPeerData);
-							repository.saveChanges();
-
-							// Remember that this data is new, so that it can be rebroadcast later
-							containsNewEntry = true;
-						}
-					}
-				}
-
-				// If at least one signature in this batch was new to us, we should rebroadcast the message to the
-				// network in case some peers haven't received it yet
-				if (containsNewEntry) {
-					int requestHops = arbitrarySignaturesMessage.getRequestHops();
-					arbitrarySignaturesMessage.setRequestHops(++requestHops);
-					if (requestHops < ARBITRARY_SIGNATURES_REQUEST_MAX_HOPS) {
-						LOGGER.debug("Rebroadcasting arbitrary signature list for peer {}. requestHops: {}", peerAddress, requestHops);
-						Network.getInstance().broadcast(broadcastPeer -> broadcastPeer == peer ? null : arbitrarySignaturesMessage);
-					}
-				} else {
-					// Don't rebroadcast as otherwise we could get into a loop
-				}
-
-				// If anything needed saving, it would already have called saveChanges() above
-				repository.discardChanges();
-			} catch (DataException e) {
-				LOGGER.error(String.format("Repository issue while processing arbitrary transaction signature list from peer %s", peer), e);
-			}
-		}
-	}
-
-
 	public int getPowDifficulty() {
 		return this.powDifficulty;
 	}

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

@@ -22,8 +22,7 @@ import org.qortal.utils.Triple;
 import java.io.IOException;
 import java.util.*;
 
-import static org.qortal.controller.arbitrary.ArbitraryDataFileListManager.RELAY_REQUEST_MAX_DURATION;
-import static org.qortal.controller.arbitrary.ArbitraryDataFileListManager.RELAY_REQUEST_MAX_HOPS;
+import static org.qortal.controller.arbitrary.ArbitraryDataFileListManager.*;
 
 public class ArbitraryMetadataManager {
 
@@ -139,7 +138,7 @@ public class ArbitraryMetadataManager {
         }
         this.addToSignatureRequests(signature58, true, false);
 
-        List<Peer> handshakedPeers = Network.getInstance().getHandshakedPeers();
+        List<Peer> handshakedPeers = Network.getInstance().getImmutableHandshakedPeers();
         LOGGER.debug(String.format("Sending metadata request for signature %s to %d peers...", signature58, handshakedPeers.size()));
 
         // Build request
@@ -183,7 +182,9 @@ public class ArbitraryMetadataManager {
 
         try {
             ArbitraryDataFile metadataFile = ArbitraryDataFile.fromHash(metadataHash, signature);
-            return metadataFile.getBytes();
+            if (metadataFile.exists()) {
+                return metadataFile.getBytes();
+            }
         } catch (DataException e) {
             // Do nothing
         }
@@ -214,9 +215,19 @@ public class ArbitraryMetadataManager {
 
         long timeSinceLastAttempt = NTP.getTime() - lastAttemptTimestamp;
 
-        // Allow a second attempt after 15 seconds, and another after 30 seconds
-        if (timeSinceLastAttempt > 15 * 1000L) {
-            // We haven't tried for at least 15 seconds
+        // Allow a second attempt after 60 seconds
+        if (timeSinceLastAttempt > 60 * 1000L) {
+            // We haven't tried for at least 60 seconds
+
+            if (networkBroadcastCount < 2) {
+                // We've made less than 2 total attempts
+                return true;
+            }
+        }
+
+        // Then allow another attempt after 60 minutes
+        if (timeSinceLastAttempt > 60 * 60 * 1000L) {
+            // We haven't tried for at least 60 minutes
 
             if (networkBroadcastCount < 3) {
                 // We've made less than 3 total attempts
@@ -224,22 +235,6 @@ public class ArbitraryMetadataManager {
             }
         }
 
-        // Then allow another 5 attempts, each 5 minutes apart
-        if (timeSinceLastAttempt > 5 * 60 * 1000L) {
-            // We haven't tried for at least 5 minutes
-
-            if (networkBroadcastCount < 5) {
-                // We've made less than 5 total attempts
-                return true;
-            }
-        }
-
-        // From then on, only try once every 24 hours, to reduce network spam
-        if (timeSinceLastAttempt > 24 * 60 * 60 * 1000L) {
-            // We haven't tried for at least 24 hours
-            return true;
-        }
-
         return false;
     }
 
@@ -342,9 +337,12 @@ public class ArbitraryMetadataManager {
                 Peer requestingPeer = request.getB();
                 if (requestingPeer != null) {
 
+                    ArbitraryMetadataMessage forwardArbitraryMetadataMessage = new ArbitraryMetadataMessage(signature, arbitraryMetadataMessage.getArbitraryMetadataFile());
+                    forwardArbitraryMetadataMessage.setId(arbitraryMetadataMessage.getId());
+
                     // Forward to requesting peer
                     LOGGER.debug("Forwarding metadata to requesting peer: {}", requestingPeer);
-                    if (!requestingPeer.sendMessage(arbitraryMetadataMessage)) {
+                    if (!requestingPeer.sendMessage(forwardArbitraryMetadataMessage)) {
                         requestingPeer.disconnect("failed to forward arbitrary metadata");
                     }
                 }
@@ -427,8 +425,7 @@ public class ArbitraryMetadataManager {
             // In relay mode - so ask our other peers if they have it
 
             long requestTime = getArbitraryMetadataMessage.getRequestTime();
-            int requestHops = getArbitraryMetadataMessage.getRequestHops();
-            getArbitraryMetadataMessage.setRequestHops(++requestHops);
+            int requestHops = getArbitraryMetadataMessage.getRequestHops() + 1;
             long totalRequestTime = now - requestTime;
 
             if (totalRequestTime < RELAY_REQUEST_MAX_DURATION) {
@@ -436,11 +433,14 @@ public class ArbitraryMetadataManager {
                 if (requestHops < RELAY_REQUEST_MAX_HOPS) {
                     // Relay request hasn't reached the maximum number of hops yet, so can be rebroadcast
 
+                    Message relayGetArbitraryMetadataMessage = new GetArbitraryMetadataMessage(signature, requestTime, requestHops);
+                    relayGetArbitraryMetadataMessage.setId(message.getId());
+
                     LOGGER.debug("Rebroadcasting metadata request from peer {} for signature {} to our other peers... totalRequestTime: {}, requestHops: {}", peer, Base58.encode(signature), totalRequestTime, requestHops);
                     Network.getInstance().broadcast(
-                            broadcastPeer -> broadcastPeer == peer ||
-                                    Objects.equals(broadcastPeer.getPeerData().getAddress().getHost(), peer.getPeerData().getAddress().getHost())
-                                    ? null : getArbitraryMetadataMessage);
+                            broadcastPeer ->
+                                    !broadcastPeer.isAtLeastVersion(RELAY_MIN_PEER_VERSION) ? null :
+                                    broadcastPeer == peer || Objects.equals(broadcastPeer.getPeerData().getAddress().getHost(), peer.getPeerData().getAddress().getHost()) ? null : relayGetArbitraryMetadataMessage);
 
                 }
                 else {

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

@@ -19,6 +19,11 @@ public class AtStatesPruner implements Runnable {
 	public void run() {
 		Thread.currentThread().setName("AT States pruner");
 
+		if (Settings.getInstance().isLite()) {
+			// Nothing to prune in lite mode
+			return;
+		}
+
 		boolean archiveMode = false;
 		if (!Settings.getInstance().isTopOnly()) {
 			// Top-only mode isn't enabled, but we might want to prune for the purposes of archiving

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

@@ -19,6 +19,11 @@ public class AtStatesTrimmer implements Runnable {
 	public void run() {
 		Thread.currentThread().setName("AT States trimmer");
 
+		if (Settings.getInstance().isLite()) {
+			// Nothing to trim in lite mode
+			return;
+		}
+
 		try (final Repository repository = RepositoryManager.getRepository()) {
 			int trimStartHeight = repository.getATRepository().getAtTrimHeight();
 

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

@@ -21,7 +21,7 @@ public class BlockArchiver implements Runnable {
 	public void run() {
 		Thread.currentThread().setName("Block archiver");
 
-		if (!Settings.getInstance().isArchiveEnabled()) {
+		if (!Settings.getInstance().isArchiveEnabled() || Settings.getInstance().isLite()) {
 			return;
 		}
 

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

@@ -19,6 +19,11 @@ public class BlockPruner implements Runnable {
 	public void run() {
 		Thread.currentThread().setName("Block pruner");
 
+		if (Settings.getInstance().isLite()) {
+			// Nothing to prune in lite mode
+			return;
+		}
+
 		boolean archiveMode = false;
 		if (!Settings.getInstance().isTopOnly()) {
 			// Top-only mode isn't enabled, but we might want to prune for the purposes of archiving

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

@@ -29,6 +29,15 @@ public class NamesDatabaseIntegrityCheck {
     private List<TransactionData> nameTransactions = new ArrayList<>();
 
     public int rebuildName(String name, Repository repository) {
+        return this.rebuildName(name, repository, null);
+    }
+
+    public int rebuildName(String name, Repository repository, List<String> referenceNames) {
+        // "referenceNames" tracks the linked names that have already been rebuilt, to prevent circular dependencies
+        if (referenceNames == null) {
+            referenceNames = new ArrayList<>();
+        }
+
         int modificationCount = 0;
         try {
             List<TransactionData> transactions = this.fetchAllTransactionsInvolvingName(name, repository);
@@ -56,7 +65,14 @@ public class NamesDatabaseIntegrityCheck {
                     if (Objects.equals(updateNameTransactionData.getNewName(), name) &&
                             !Objects.equals(updateNameTransactionData.getName(), updateNameTransactionData.getNewName())) {
                         // This renames an existing name, so we need to process that instead
-                        this.rebuildName(updateNameTransactionData.getName(), repository);
+
+                        if (!referenceNames.contains(name)) {
+                            referenceNames.add(name);
+                            this.rebuildName(updateNameTransactionData.getName(), repository, referenceNames);
+                        }
+                        else {
+                            // We've already processed this name so there's nothing more to do
+                        }
                     }
                     else {
                         Name nameObj = new Name(repository, name);
@@ -91,7 +107,7 @@ public class NamesDatabaseIntegrityCheck {
                     BuyNameTransactionData buyNameTransactionData = (BuyNameTransactionData) currentTransaction;
                     Name nameObj = new Name(repository, buyNameTransactionData.getName());
                     if (nameObj != null && nameObj.getNameData() != null) {
-                        nameObj.buy(buyNameTransactionData);
+                        nameObj.buy(buyNameTransactionData, false);
                         modificationCount++;
                         LOGGER.trace("Processed BUY_NAME transaction for name {}", name);
                     }
@@ -193,7 +209,12 @@ public class NamesDatabaseIntegrityCheck {
                                 newName = registeredName;
                             }
                             NameData newNameData = repository.getNameRepository().fromName(newName);
-                            if (!Objects.equals(creator.getAddress(), newNameData.getOwner())) {
+                            if (newNameData == null) {
+                                LOGGER.info("Error: registered name {} has no new name data. This is likely due to account {} " +
+                                                "being renamed another time, which is a scenario that is not yet checked automatically.",
+                                        updateNameTransactionData.getNewName(), creator.getAddress());
+                            }
+                            else if (!Objects.equals(creator.getAddress(), newNameData.getOwner())) {
                                 LOGGER.info("Error: registered name {} is owned by {}, but it should be {}",
                                         updateNameTransactionData.getNewName(), newNameData.getOwner(), creator.getAddress());
                                 integrityCheckFailed = true;
@@ -313,6 +334,10 @@ public class NamesDatabaseIntegrityCheck {
                 transactions.add(transactionData);
             }
         }
+
+        // Sort by lowest timestamp first
+        transactions.sort(Comparator.comparingLong(TransactionData::getTimestamp));
+
         return transactions;
     }
 

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

@@ -21,6 +21,11 @@ public class OnlineAccountsSignaturesTrimmer implements Runnable {
 	public void run() {
 		Thread.currentThread().setName("Online Accounts trimmer");
 
+		if (Settings.getInstance().isLite()) {
+			// Nothing to trim in lite mode
+			return;
+		}
+
 		try (final Repository repository = RepositoryManager.getRepository()) {
 			// Don't even start trimming until initial rush has ended
 			Thread.sleep(INITIAL_SLEEP_PERIOD);

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

@@ -0,0 +1,885 @@
+package org.qortal.controller.tradebot;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.bitcoinj.core.*;
+import org.bitcoinj.script.Script.ScriptType;
+import org.qortal.account.PrivateKeyAccount;
+import org.qortal.account.PublicKeyAccount;
+import org.qortal.api.model.crosschain.TradeBotCreateRequest;
+import org.qortal.asset.Asset;
+import org.qortal.crosschain.*;
+import org.qortal.crypto.Crypto;
+import org.qortal.data.at.ATData;
+import org.qortal.data.crosschain.CrossChainTradeData;
+import org.qortal.data.crosschain.TradeBotData;
+import org.qortal.data.transaction.BaseTransactionData;
+import org.qortal.data.transaction.DeployAtTransactionData;
+import org.qortal.data.transaction.MessageTransactionData;
+import org.qortal.group.Group;
+import org.qortal.repository.DataException;
+import org.qortal.repository.Repository;
+import org.qortal.transaction.DeployAtTransaction;
+import org.qortal.transaction.MessageTransaction;
+import org.qortal.transaction.Transaction.ValidationResult;
+import org.qortal.transform.TransformationException;
+import org.qortal.transform.transaction.DeployAtTransactionTransformer;
+import org.qortal.utils.Base58;
+import org.qortal.utils.NTP;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import static java.util.Arrays.stream;
+import static java.util.stream.Collectors.toMap;
+
+/**
+ * Performing cross-chain trading steps on behalf of user.
+ * <p>
+ * We deal with three different independent state-spaces here:
+ * <ul>
+ * 	<li>Qortal blockchain</li>
+ * 	<li>Foreign blockchain</li>
+ * 	<li>Trade-bot entries</li>
+ * </ul>
+ */
+public class BitcoinACCTv3TradeBot implements AcctTradeBot {
+
+	private static final Logger LOGGER = LogManager.getLogger(BitcoinACCTv3TradeBot.class);
+
+	public enum State implements TradeBot.StateNameAndValueSupplier {
+		BOB_WAITING_FOR_AT_CONFIRM(10, false, false),
+		BOB_WAITING_FOR_MESSAGE(15, true, true),
+		BOB_WAITING_FOR_AT_REDEEM(25, true, true),
+		BOB_DONE(30, false, false),
+		BOB_REFUNDED(35, false, false),
+
+		ALICE_WAITING_FOR_AT_LOCK(85, true, true),
+		ALICE_DONE(95, false, false),
+		ALICE_REFUNDING_A(105, true, true),
+		ALICE_REFUNDED(110, false, false);
+
+		private static final Map<Integer, State> map = stream(State.values()).collect(toMap(state -> state.value, state -> state));
+
+		public final int value;
+		public final boolean requiresAtData;
+		public final boolean requiresTradeData;
+
+		State(int value, boolean requiresAtData, boolean requiresTradeData) {
+			this.value = value;
+			this.requiresAtData = requiresAtData;
+			this.requiresTradeData = requiresTradeData;
+		}
+
+		public static State valueOf(int value) {
+			return map.get(value);
+		}
+
+		@Override
+		public String getState() {
+			return this.name();
+		}
+
+		@Override
+		public int getStateValue() {
+			return this.value;
+		}
+	}
+
+	/** Maximum time Bob waits for his AT creation transaction to be confirmed into a block. (milliseconds) */
+	private static final long MAX_AT_CONFIRMATION_PERIOD = 24 * 60 * 60 * 1000L; // ms
+
+	private static BitcoinACCTv3TradeBot instance;
+
+	private final List<String> endStates = Arrays.asList(State.BOB_DONE, State.BOB_REFUNDED, State.ALICE_DONE, State.ALICE_REFUNDING_A, State.ALICE_REFUNDED).stream()
+			.map(State::name)
+			.collect(Collectors.toUnmodifiableList());
+
+	private BitcoinACCTv3TradeBot() {
+	}
+
+	public static synchronized BitcoinACCTv3TradeBot getInstance() {
+		if (instance == null)
+			instance = new BitcoinACCTv3TradeBot();
+
+		return instance;
+	}
+
+	@Override
+	public List<String> getEndStates() {
+		return this.endStates;
+	}
+
+	/**
+	 * Creates a new trade-bot entry from the "Bob" viewpoint, i.e. OFFERing QORT in exchange for BTC.
+	 * <p>
+	 * Generates:
+	 * <ul>
+	 * 	<li>new 'trade' private key</li>
+	 * </ul>
+	 * Derives:
+	 * <ul>
+	 * 	<li>'native' (as in Qortal) public key, public key hash, address (starting with Q)</li>
+	 * 	<li>'foreign' (as in Bitcoin) public key, public key hash</li>
+	 * </ul>
+	 * A Qortal AT is then constructed including the following as constants in the 'data segment':
+	 * <ul>
+	 * 	<li>'native'/Qortal 'trade' address - used as a MESSAGE contact</li>
+	 * 	<li>'foreign'/Bitcoin public key hash - used by Alice's P2SH scripts to allow redeem</li>
+	 * 	<li>QORT amount on offer by Bob</li>
+	 * 	<li>BTC amount expected in return by Bob (from Alice)</li>
+	 * 	<li>trading timeout, in case things go wrong and everyone needs to refund</li>
+	 * </ul>
+	 * Returns a DEPLOY_AT transaction that needs to be signed and broadcast to the Qortal network.
+	 * <p>
+	 * Trade-bot will wait for Bob's AT to be deployed before taking next step.
+	 * <p>
+	 * @param repository
+	 * @param tradeBotCreateRequest
+	 * @return raw, unsigned DEPLOY_AT transaction
+	 * @throws DataException
+	 */
+	public byte[] createTrade(Repository repository, TradeBotCreateRequest tradeBotCreateRequest) throws DataException {
+		byte[] tradePrivateKey = TradeBot.generateTradePrivateKey();
+
+		byte[] tradeNativePublicKey = TradeBot.deriveTradeNativePublicKey(tradePrivateKey);
+		byte[] tradeNativePublicKeyHash = Crypto.hash160(tradeNativePublicKey);
+		String tradeNativeAddress = Crypto.toAddress(tradeNativePublicKey);
+
+		byte[] tradeForeignPublicKey = TradeBot.deriveTradeForeignPublicKey(tradePrivateKey);
+		byte[] tradeForeignPublicKeyHash = Crypto.hash160(tradeForeignPublicKey);
+
+		// Convert Bitcoin receiving address into public key hash (we only support P2PKH at this time)
+		Address bitcoinReceivingAddress;
+		try {
+			bitcoinReceivingAddress = Address.fromString(Bitcoin.getInstance().getNetworkParameters(), tradeBotCreateRequest.receivingAddress);
+		} catch (AddressFormatException e) {
+			throw new DataException("Unsupported Bitcoin receiving address: " + tradeBotCreateRequest.receivingAddress);
+		}
+		if (bitcoinReceivingAddress.getOutputScriptType() != ScriptType.P2PKH)
+			throw new DataException("Unsupported Bitcoin receiving address: " + tradeBotCreateRequest.receivingAddress);
+
+		byte[] bitcoinReceivingAccountInfo = bitcoinReceivingAddress.getHash();
+
+		PublicKeyAccount creator = new PublicKeyAccount(repository, tradeBotCreateRequest.creatorPublicKey);
+
+		// Deploy AT
+		long timestamp = NTP.getTime();
+		byte[] reference = creator.getLastReference();
+		long fee = 0L;
+		byte[] signature = null;
+		BaseTransactionData baseTransactionData = new BaseTransactionData(timestamp, Group.NO_GROUP, reference, creator.getPublicKey(), fee, signature);
+
+		String name = "QORT/BTC ACCT";
+		String description = "QORT/BTC cross-chain trade";
+		String aTType = "ACCT";
+		String tags = "ACCT QORT BTC";
+		byte[] creationBytes = BitcoinACCTv3.buildQortalAT(tradeNativeAddress, tradeForeignPublicKeyHash, tradeBotCreateRequest.qortAmount,
+				tradeBotCreateRequest.foreignAmount, tradeBotCreateRequest.tradeTimeout);
+		long amount = tradeBotCreateRequest.fundingQortAmount;
+
+		DeployAtTransactionData deployAtTransactionData = new DeployAtTransactionData(baseTransactionData, name, description, aTType, tags, creationBytes, amount, Asset.QORT);
+
+		DeployAtTransaction deployAtTransaction = new DeployAtTransaction(repository, deployAtTransactionData);
+		fee = deployAtTransaction.calcRecommendedFee();
+		deployAtTransactionData.setFee(fee);
+
+		DeployAtTransaction.ensureATAddress(deployAtTransactionData);
+		String atAddress = deployAtTransactionData.getAtAddress();
+
+		TradeBotData tradeBotData =  new TradeBotData(tradePrivateKey, BitcoinACCTv3.NAME,
+				State.BOB_WAITING_FOR_AT_CONFIRM.name(), State.BOB_WAITING_FOR_AT_CONFIRM.value,
+				creator.getAddress(), atAddress, timestamp, tradeBotCreateRequest.qortAmount,
+				tradeNativePublicKey, tradeNativePublicKeyHash, tradeNativeAddress,
+				null, null,
+				SupportedBlockchain.BITCOIN.name(),
+				tradeForeignPublicKey, tradeForeignPublicKeyHash,
+				tradeBotCreateRequest.foreignAmount, null, null, null, bitcoinReceivingAccountInfo);
+
+		TradeBot.updateTradeBotState(repository, tradeBotData, () -> String.format("Built AT %s. Waiting for deployment", atAddress));
+
+		// Attempt to backup the trade bot data
+		TradeBot.backupTradeBotData(repository, null);
+
+		// Return to user for signing and broadcast as we don't have their Qortal private key
+		try {
+			return DeployAtTransactionTransformer.toBytes(deployAtTransactionData);
+		} catch (TransformationException e) {
+			throw new DataException("Failed to transform DEPLOY_AT transaction?", e);
+		}
+	}
+
+	/**
+	 * Creates a trade-bot entry from the 'Alice' viewpoint, i.e. matching BTC to an existing offer.
+	 * <p>
+	 * Requires a chosen trade offer from Bob, passed by <tt>crossChainTradeData</tt>
+	 * and access to a Bitcoin wallet via <tt>xprv58</tt>.
+	 * <p>
+	 * The <tt>crossChainTradeData</tt> contains the current trade offer state
+	 * as extracted from the AT's data segment.
+	 * <p>
+	 * Access to a funded wallet is via a Bitcoin BIP32 hierarchical deterministic key,
+	 * passed via <tt>xprv58</tt>.
+	 * <b>This key will be stored in your node's database</b>
+	 * to allow trade-bot to create/fund the necessary P2SH transactions!
+	 * However, due to the nature of BIP32 keys, it is possible to give the trade-bot
+	 * only a subset of wallet access (see BIP32 for more details).
+	 * <p>
+	 * As an example, the xprv58 can be extract from a <i>legacy, password-less</i>
+	 * Electrum wallet by going to the console tab and entering:<br>
+	 * <tt>wallet.keystore.xprv</tt><br>
+	 * which should result in a base58 string starting with either 'xprv' (for Bitcoin main-net)
+	 * or 'tprv' for (Bitcoin test-net).
+	 * <p>
+	 * It is envisaged that the value in <tt>xprv58</tt> will actually come from a Qortal-UI-managed wallet.
+	 * <p>
+	 * If sufficient funds are available, <b>this method will actually fund the P2SH-A</b>
+	 * with the Bitcoin amount expected by 'Bob'.
+	 * <p>
+	 * If the Bitcoin transaction is successfully broadcast to the network then
+	 * we also send a MESSAGE to Bob's trade-bot to let them know.
+	 * <p>
+	 * The trade-bot entry is saved to the repository and the cross-chain trading process commences.
+	 * <p>
+	 * @param repository
+	 * @param crossChainTradeData chosen trade OFFER that Alice wants to match
+	 * @param xprv58 funded wallet xprv in base58
+	 * @return true if P2SH-A funding transaction successfully broadcast to Bitcoin network, false otherwise
+	 * @throws DataException
+	 */
+	public ResponseResult startResponse(Repository repository, ATData atData, ACCT acct, CrossChainTradeData crossChainTradeData, String xprv58, String receivingAddress) throws DataException {
+		byte[] tradePrivateKey = TradeBot.generateTradePrivateKey();
+		byte[] secretA = TradeBot.generateSecret();
+		byte[] hashOfSecretA = Crypto.hash160(secretA);
+
+		byte[] tradeNativePublicKey = TradeBot.deriveTradeNativePublicKey(tradePrivateKey);
+		byte[] tradeNativePublicKeyHash = Crypto.hash160(tradeNativePublicKey);
+		String tradeNativeAddress = Crypto.toAddress(tradeNativePublicKey);
+
+		byte[] tradeForeignPublicKey = TradeBot.deriveTradeForeignPublicKey(tradePrivateKey);
+		byte[] tradeForeignPublicKeyHash = Crypto.hash160(tradeForeignPublicKey);
+		byte[] receivingPublicKeyHash = Base58.decode(receivingAddress); // Actually the whole address, not just PKH
+
+		// We need to generate lockTime-A: add tradeTimeout to now
+		long now = NTP.getTime();
+		int lockTimeA = crossChainTradeData.tradeTimeout * 60 + (int) (now / 1000L);
+
+		TradeBotData tradeBotData =  new TradeBotData(tradePrivateKey, BitcoinACCTv3.NAME,
+				State.ALICE_WAITING_FOR_AT_LOCK.name(), State.ALICE_WAITING_FOR_AT_LOCK.value,
+				receivingAddress, crossChainTradeData.qortalAtAddress, now, crossChainTradeData.qortAmount,
+				tradeNativePublicKey, tradeNativePublicKeyHash, tradeNativeAddress,
+				secretA, hashOfSecretA,
+				SupportedBlockchain.BITCOIN.name(),
+				tradeForeignPublicKey, tradeForeignPublicKeyHash,
+				crossChainTradeData.expectedForeignAmount, xprv58, null, lockTimeA, receivingPublicKeyHash);
+
+		// Attempt to backup the trade bot data
+		// Include tradeBotData as an additional parameter, since it's not in the repository yet
+		TradeBot.backupTradeBotData(repository, Arrays.asList(tradeBotData));
+
+		// Check we have enough funds via xprv58 to fund P2SH to cover expectedForeignAmount
+		long p2shFee;
+		try {
+			p2shFee = Bitcoin.getInstance().getP2shFee(now);
+		} catch (ForeignBlockchainException e) {
+			LOGGER.debug("Couldn't estimate Bitcoin fees?");
+			return ResponseResult.NETWORK_ISSUE;
+		}
+
+		// Fee for redeem/refund is subtracted from P2SH-A balance.
+		// Do not include fee for funding transaction as this is covered by buildSpend()
+		long amountA = crossChainTradeData.expectedForeignAmount + p2shFee /*redeeming/refunding P2SH-A*/;
+
+		// P2SH-A to be funded
+		byte[] redeemScriptBytes = BitcoinyHTLC.buildScript(tradeForeignPublicKeyHash, lockTimeA, crossChainTradeData.creatorForeignPKH, hashOfSecretA);
+		String p2shAddress = Bitcoin.getInstance().deriveP2shAddress(redeemScriptBytes);
+
+		// Build transaction for funding P2SH-A
+		Transaction p2shFundingTransaction = Bitcoin.getInstance().buildSpend(tradeBotData.getForeignKey(), p2shAddress, amountA);
+		if (p2shFundingTransaction == null) {
+			LOGGER.debug("Unable to build P2SH-A funding transaction - lack of funds?");
+			return ResponseResult.BALANCE_ISSUE;
+		}
+
+		try {
+			Bitcoin.getInstance().broadcastTransaction(p2shFundingTransaction);
+		} catch (ForeignBlockchainException e) {
+			// We couldn't fund P2SH-A at this time
+			LOGGER.debug("Couldn't broadcast P2SH-A funding transaction?");
+			return ResponseResult.NETWORK_ISSUE;
+		}
+
+		// Attempt to send MESSAGE to Bob's Qortal trade address
+		byte[] messageData = BitcoinACCTv3.buildOfferMessage(tradeBotData.getTradeForeignPublicKeyHash(), tradeBotData.getHashOfSecret(), tradeBotData.getLockTimeA());
+		String messageRecipient = crossChainTradeData.qortalCreatorTradeAddress;
+
+		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);
+
+			messageTransaction.computeNonce();
+			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 Bob's trade-bot %s: %s", messageRecipient, result.name()));
+				return ResponseResult.NETWORK_ISSUE;
+			}
+		}
+
+		TradeBot.updateTradeBotState(repository, tradeBotData, () -> String.format("Funding P2SH-A %s. Messaged Bob. Waiting for AT-lock", p2shAddress));
+
+		return ResponseResult.OK;
+	}
+
+	@Override
+	public boolean canDelete(Repository repository, TradeBotData tradeBotData) throws DataException {
+		State tradeBotState = State.valueOf(tradeBotData.getStateValue());
+		if (tradeBotState == null)
+			return true;
+
+		// If the AT doesn't exist then we might as well let the user tidy up
+		if (!repository.getATRepository().exists(tradeBotData.getAtAddress()))
+			return true;
+
+		switch (tradeBotState) {
+			case BOB_WAITING_FOR_AT_CONFIRM:
+			case ALICE_DONE:
+			case BOB_DONE:
+			case ALICE_REFUNDED:
+			case BOB_REFUNDED:
+			case ALICE_REFUNDING_A:
+				return true;
+
+			default:
+				return false;
+		}
+	}
+
+	@Override
+	public void progress(Repository repository, TradeBotData tradeBotData) throws DataException, ForeignBlockchainException {
+		State tradeBotState = State.valueOf(tradeBotData.getStateValue());
+		if (tradeBotState == null) {
+			LOGGER.info(() -> String.format("Trade-bot entry for AT %s has invalid state?", tradeBotData.getAtAddress()));
+			return;
+		}
+
+		ATData atData = null;
+		CrossChainTradeData tradeData = null;
+
+		if (tradeBotState.requiresAtData) {
+			// Attempt to fetch AT data
+			atData = repository.getATRepository().fromATAddress(tradeBotData.getAtAddress());
+			if (atData == null) {
+				LOGGER.debug(() -> String.format("Unable to fetch trade AT %s from repository", tradeBotData.getAtAddress()));
+				return;
+			}
+
+			if (tradeBotState.requiresTradeData) {
+				tradeData = BitcoinACCTv3.getInstance().populateTradeData(repository, atData);
+				if (tradeData == null) {
+					LOGGER.warn(() -> String.format("Unable to fetch ACCT trade data for AT %s from repository", tradeBotData.getAtAddress()));
+					return;
+				}
+			}
+		}
+
+		switch (tradeBotState) {
+			case BOB_WAITING_FOR_AT_CONFIRM:
+				handleBobWaitingForAtConfirm(repository, tradeBotData);
+				break;
+
+			case BOB_WAITING_FOR_MESSAGE:
+				TradeBot.getInstance().updatePresence(repository, tradeBotData, tradeData);
+				handleBobWaitingForMessage(repository, tradeBotData, atData, tradeData);
+				break;
+
+			case ALICE_WAITING_FOR_AT_LOCK:
+				TradeBot.getInstance().updatePresence(repository, tradeBotData, tradeData);
+				handleAliceWaitingForAtLock(repository, tradeBotData, atData, tradeData);
+				break;
+
+			case BOB_WAITING_FOR_AT_REDEEM:
+				TradeBot.getInstance().updatePresence(repository, tradeBotData, tradeData);
+				handleBobWaitingForAtRedeem(repository, tradeBotData, atData, tradeData);
+				break;
+
+			case ALICE_DONE:
+			case BOB_DONE:
+				break;
+
+			case ALICE_REFUNDING_A:
+				TradeBot.getInstance().updatePresence(repository, tradeBotData, tradeData);
+				handleAliceRefundingP2shA(repository, tradeBotData, atData, tradeData);
+				break;
+
+			case ALICE_REFUNDED:
+			case BOB_REFUNDED:
+				break;
+		}
+	}
+
+	/**
+	 * Trade-bot is waiting for Bob's AT to deploy.
+	 * <p>
+	 * If AT is deployed, then trade-bot's next step is to wait for MESSAGE from Alice.
+	 */
+	private void handleBobWaitingForAtConfirm(Repository repository, TradeBotData tradeBotData) throws DataException {
+		if (!repository.getATRepository().exists(tradeBotData.getAtAddress())) {
+			if (NTP.getTime() - tradeBotData.getTimestamp() <= MAX_AT_CONFIRMATION_PERIOD)
+				return;
+
+			// We've waited ages for AT to be confirmed into a block but something has gone awry.
+			// After this long we assume transaction loss so give up with trade-bot entry too.
+			tradeBotData.setState(State.BOB_REFUNDED.name());
+			tradeBotData.setStateValue(State.BOB_REFUNDED.value);
+			tradeBotData.setTimestamp(NTP.getTime());
+			// We delete trade-bot entry here instead of saving, hence not using updateTradeBotState()
+			repository.getCrossChainRepository().delete(tradeBotData.getTradePrivateKey());
+			repository.saveChanges();
+
+			LOGGER.info(() -> String.format("AT %s never confirmed. Giving up on trade", tradeBotData.getAtAddress()));
+			TradeBot.notifyStateChange(tradeBotData);
+			return;
+		}
+
+		TradeBot.updateTradeBotState(repository, tradeBotData, State.BOB_WAITING_FOR_MESSAGE,
+				() -> String.format("AT %s confirmed ready. Waiting for trade message", tradeBotData.getAtAddress()));
+	}
+
+	/**
+	 * Trade-bot is waiting for MESSAGE from Alice's trade-bot, containing Alice's trade info.
+	 * <p>
+	 * It's possible Bob has cancelling his trade offer, receiving an automatic QORT refund,
+	 * in which case trade-bot is done with this specific trade and finalizes on refunded state.
+	 * <p>
+	 * Assuming trade is still on offer, trade-bot checks the contents of MESSAGE from Alice's trade-bot.
+	 * <p>
+	 * Details from Alice are used to derive P2SH-A address and this is checked for funding balance.
+	 * <p>
+	 * Assuming P2SH-A has at least expected Bitcoin balance,
+	 * Bob's trade-bot constructs a zero-fee, PoW MESSAGE to send to Bob's AT with more trade details.
+	 * <p>
+	 * On processing this MESSAGE, Bob's AT should switch into 'TRADE' mode and only trade with Alice.
+	 * <p>
+	 * Trade-bot's next step is to wait for Alice to redeem the AT, which will allow Bob to
+	 * extract secret-A needed to redeem Alice's P2SH.
+	 * @throws ForeignBlockchainException
+	 */
+	private void handleBobWaitingForMessage(Repository repository, TradeBotData tradeBotData,
+			ATData atData, CrossChainTradeData crossChainTradeData) throws DataException, ForeignBlockchainException {
+		// If AT has finished then Bob likely cancelled his trade offer
+		if (atData.getIsFinished()) {
+			TradeBot.updateTradeBotState(repository, tradeBotData, State.BOB_REFUNDED,
+					() -> String.format("AT %s cancelled - trading aborted", tradeBotData.getAtAddress()));
+			return;
+		}
+
+		Bitcoin bitcoin = Bitcoin.getInstance();
+
+		String address = tradeBotData.getTradeNativeAddress();
+		List<MessageTransactionData> messageTransactionsData = repository.getMessageRepository().getMessagesByParticipants(null, address, null, null, null);
+
+		for (MessageTransactionData messageTransactionData : messageTransactionsData) {
+			if (messageTransactionData.isText())
+				continue;
+
+			// We're expecting: HASH160(secret-A), Alice's Bitcoin pubkeyhash and lockTime-A
+			byte[] messageData = messageTransactionData.getData();
+			BitcoinACCTv3.OfferMessageData offerMessageData = BitcoinACCTv3.extractOfferMessageData(messageData);
+			if (offerMessageData == null)
+				continue;
+
+			byte[] aliceForeignPublicKeyHash = offerMessageData.partnerBitcoinPKH;
+			byte[] hashOfSecretA = offerMessageData.hashOfSecretA;
+			int lockTimeA = (int) offerMessageData.lockTimeA;
+			long messageTimestamp = messageTransactionData.getTimestamp();
+			int refundTimeout = BitcoinACCTv3.calcRefundTimeout(messageTimestamp, lockTimeA);
+
+			// Determine P2SH-A address and confirm funded
+			byte[] redeemScriptA = BitcoinyHTLC.buildScript(aliceForeignPublicKeyHash, lockTimeA, tradeBotData.getTradeForeignPublicKeyHash(), hashOfSecretA);
+			String p2shAddressA = bitcoin.deriveP2shAddress(redeemScriptA);
+
+			long feeTimestamp = calcFeeTimestamp(lockTimeA, crossChainTradeData.tradeTimeout);
+			long p2shFee = Bitcoin.getInstance().getP2shFee(feeTimestamp);
+			final long minimumAmountA = tradeBotData.getForeignAmount() + p2shFee;
+
+			BitcoinyHTLC.Status htlcStatusA = BitcoinyHTLC.determineHtlcStatus(bitcoin.getBlockchainProvider(), p2shAddressA, minimumAmountA);
+
+			switch (htlcStatusA) {
+				case UNFUNDED:
+				case FUNDING_IN_PROGRESS:
+					// There might be another MESSAGE from someone else with an actually funded P2SH-A...
+					continue;
+
+				case REDEEM_IN_PROGRESS:
+				case REDEEMED:
+					// We've already redeemed this?
+					TradeBot.updateTradeBotState(repository, tradeBotData, State.BOB_DONE,
+							() -> String.format("P2SH-A %s already spent? Assuming trade complete", p2shAddressA));
+					return;
+
+				case REFUND_IN_PROGRESS:
+				case REFUNDED:
+					// This P2SH-A is burnt, but there might be another MESSAGE from someone else with an actually funded P2SH-A...
+					continue;
+
+				case FUNDED:
+					// Fall-through out of switch...
+					break;
+			}
+
+			// Good to go - send MESSAGE to AT
+
+			String aliceNativeAddress = Crypto.toAddress(messageTransactionData.getCreatorPublicKey());
+
+			// Build outgoing message, padding each part to 32 bytes to make it easier for AT to consume
+			byte[] outgoingMessageData = BitcoinACCTv3.buildTradeMessage(aliceNativeAddress, aliceForeignPublicKeyHash, hashOfSecretA, lockTimeA, refundTimeout);
+			String messageRecipient = tradeBotData.getAtAddress();
+
+			boolean isMessageAlreadySent = repository.getMessageRepository().exists(tradeBotData.getTradeNativePublicKey(), messageRecipient, outgoingMessageData);
+			if (!isMessageAlreadySent) {
+				PrivateKeyAccount sender = new PrivateKeyAccount(repository, tradeBotData.getTradePrivateKey());
+				MessageTransaction outgoingMessageTransaction = MessageTransaction.build(repository, sender, Group.NO_GROUP, messageRecipient, outgoingMessageData, false, false);
+
+				outgoingMessageTransaction.computeNonce();
+				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()));
+					return;
+				}
+			}
+
+			TradeBot.updateTradeBotState(repository, tradeBotData, State.BOB_WAITING_FOR_AT_REDEEM,
+					() -> String.format("Locked AT %s to %s. Waiting for AT redeem", tradeBotData.getAtAddress(), aliceNativeAddress));
+
+			return;
+		}
+	}
+
+	/**
+	 * Trade-bot is waiting for Bob's AT to switch to TRADE mode and lock trade to Alice only.
+	 * <p>
+	 * It's possible that Bob has cancelled his trade offer in the mean time, or that somehow
+	 * this process has taken so long that we've reached P2SH-A's locktime, or that someone else
+	 * has managed to trade with Bob. In any of these cases, trade-bot switches to begin the refunding process.
+	 * <p>
+	 * Assuming Bob's AT is locked to Alice, trade-bot checks AT's state data to make sure it is correct.
+	 * <p>
+	 * If all is well, trade-bot then redeems AT using Alice's secret-A, releasing Bob's QORT to Alice.
+	 * <p>
+	 * In revealing a valid secret-A, Bob can then redeem the BTC funds from P2SH-A.
+	 * <p>
+	 * @throws ForeignBlockchainException
+	 */
+	private void handleAliceWaitingForAtLock(Repository repository, TradeBotData tradeBotData,
+			ATData atData, CrossChainTradeData crossChainTradeData) throws DataException, ForeignBlockchainException {
+		if (aliceUnexpectedState(repository, tradeBotData, atData, crossChainTradeData))
+			return;
+
+		Bitcoin bitcoin = Bitcoin.getInstance();
+		int lockTimeA = tradeBotData.getLockTimeA();
+
+		// Refund P2SH-A if we've passed lockTime-A
+		if (NTP.getTime() >= lockTimeA * 1000L) {
+			byte[] redeemScriptA = BitcoinyHTLC.buildScript(tradeBotData.getTradeForeignPublicKeyHash(), lockTimeA, crossChainTradeData.creatorForeignPKH, tradeBotData.getHashOfSecret());
+			String p2shAddressA = bitcoin.deriveP2shAddress(redeemScriptA);
+
+			long feeTimestamp = calcFeeTimestamp(lockTimeA, crossChainTradeData.tradeTimeout);
+			long p2shFee = Bitcoin.getInstance().getP2shFee(feeTimestamp);
+			long minimumAmountA = crossChainTradeData.expectedForeignAmount + p2shFee;
+
+			BitcoinyHTLC.Status htlcStatusA = BitcoinyHTLC.determineHtlcStatus(bitcoin.getBlockchainProvider(), p2shAddressA, minimumAmountA);
+
+			switch (htlcStatusA) {
+				case UNFUNDED:
+				case FUNDING_IN_PROGRESS:
+				case FUNDED:
+					break;
+
+				case REDEEM_IN_PROGRESS:
+				case REDEEMED:
+					// Already redeemed?
+					TradeBot.updateTradeBotState(repository, tradeBotData, State.ALICE_DONE,
+							() -> String.format("P2SH-A %s already spent? Assuming trade completed", p2shAddressA));
+					return;
+
+				case REFUND_IN_PROGRESS:
+				case REFUNDED:
+					TradeBot.updateTradeBotState(repository, tradeBotData, State.ALICE_REFUNDED,
+							() -> String.format("P2SH-A %s already refunded. Trade aborted", p2shAddressA));
+					return;
+
+			}
+
+			TradeBot.updateTradeBotState(repository, tradeBotData, State.ALICE_REFUNDING_A,
+					() -> atData.getIsFinished()
+					? String.format("AT %s cancelled. Refunding P2SH-A %s - aborting trade", tradeBotData.getAtAddress(), p2shAddressA)
+					: String.format("LockTime-A reached, refunding P2SH-A %s - aborting trade", p2shAddressA));
+
+			return;
+		}
+
+		// We're waiting for AT to be in TRADE mode
+		if (crossChainTradeData.mode != AcctMode.TRADING)
+			return;
+
+		// AT is in TRADE mode and locked to us as checked by aliceUnexpectedState() above
+
+		// Find our MESSAGE to AT from previous state
+		List<MessageTransactionData> messageTransactionsData = repository.getMessageRepository().getMessagesByParticipants(tradeBotData.getTradeNativePublicKey(),
+				crossChainTradeData.qortalCreatorTradeAddress, null, null, null);
+		if (messageTransactionsData == null || messageTransactionsData.isEmpty()) {
+			LOGGER.warn(() -> String.format("Unable to find our message to trade creator %s?", crossChainTradeData.qortalCreatorTradeAddress));
+			return;
+		}
+
+		long recipientMessageTimestamp = messageTransactionsData.get(0).getTimestamp();
+		int refundTimeout = BitcoinACCTv3.calcRefundTimeout(recipientMessageTimestamp, lockTimeA);
+
+		// Our calculated refundTimeout should match AT's refundTimeout
+		if (refundTimeout != crossChainTradeData.refundTimeout) {
+			LOGGER.debug(() -> String.format("Trade AT refundTimeout '%d' doesn't match our refundTimeout '%d'", crossChainTradeData.refundTimeout, refundTimeout));
+			// We'll eventually refund
+			return;
+		}
+
+		// We're good to redeem AT
+
+		// Send 'redeem' MESSAGE to AT using both secret
+		byte[] secretA = tradeBotData.getSecret();
+		String qortalReceivingAddress = Base58.encode(tradeBotData.getReceivingAccountInfo()); // Actually contains whole address, not just PKH
+		byte[] messageData = BitcoinACCTv3.buildRedeemMessage(secretA, qortalReceivingAddress);
+		String messageRecipient = tradeBotData.getAtAddress();
+
+		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);
+
+			messageTransaction.computeNonce();
+			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()));
+				return;
+			}
+		}
+
+		TradeBot.updateTradeBotState(repository, tradeBotData, State.ALICE_DONE,
+				() -> String.format("Redeeming AT %s. Funds should arrive at %s",
+						tradeBotData.getAtAddress(), qortalReceivingAddress));
+	}
+
+	/**
+	 * Trade-bot is waiting for Alice to redeem Bob's AT, thus revealing secret-A which is required to spend the BTC funds from P2SH-A.
+	 * <p>
+	 * It's possible that Bob's AT has reached its trading timeout and automatically refunded QORT back to Bob. In which case,
+	 * trade-bot is done with this specific trade and finalizes in refunded state.
+	 * <p>
+	 * Assuming trade-bot can extract a valid secret-A from Alice's MESSAGE then trade-bot uses that to redeem the BTC funds from P2SH-A
+	 * to Bob's 'foreign'/Bitcoin trade legacy-format address, as derived from trade private key.
+	 * <p>
+	 * (This could potentially be 'improved' to send BTC to any address of Bob's choosing by changing the transaction output).
+	 * <p>
+	 * If trade-bot successfully broadcasts the transaction, then this specific trade is done.
+	 * @throws ForeignBlockchainException
+	 */
+	private void handleBobWaitingForAtRedeem(Repository repository, TradeBotData tradeBotData,
+			ATData atData, CrossChainTradeData crossChainTradeData) throws DataException, ForeignBlockchainException {
+		// AT should be 'finished' once Alice has redeemed QORT funds
+		if (!atData.getIsFinished())
+			// Not finished yet
+			return;
+
+		// If AT is REFUNDED or CANCELLED then something has gone wrong
+		if (crossChainTradeData.mode == AcctMode.REFUNDED || crossChainTradeData.mode == AcctMode.CANCELLED) {
+			// Alice hasn't redeemed the QORT, so there is no point in trying to redeem the BTC
+			TradeBot.updateTradeBotState(repository, tradeBotData, State.BOB_REFUNDED,
+					() -> String.format("AT %s has auto-refunded - trade aborted", tradeBotData.getAtAddress()));
+
+			return;
+		}
+
+		byte[] secretA = BitcoinACCTv3.getInstance().findSecretA(repository, crossChainTradeData);
+		if (secretA == null) {
+			LOGGER.debug(() -> String.format("Unable to find secret-A from redeem message to AT %s?", tradeBotData.getAtAddress()));
+			return;
+		}
+
+		// Use secret-A to redeem P2SH-A
+
+		Bitcoin bitcoin = Bitcoin.getInstance();
+
+		byte[] receivingAccountInfo = tradeBotData.getReceivingAccountInfo();
+		int lockTimeA = crossChainTradeData.lockTimeA;
+		byte[] redeemScriptA = BitcoinyHTLC.buildScript(crossChainTradeData.partnerForeignPKH, lockTimeA, crossChainTradeData.creatorForeignPKH, crossChainTradeData.hashOfSecretA);
+		String p2shAddressA = bitcoin.deriveP2shAddress(redeemScriptA);
+
+		// Fee for redeem/refund is subtracted from P2SH-A balance.
+		long feeTimestamp = calcFeeTimestamp(lockTimeA, crossChainTradeData.tradeTimeout);
+		long p2shFee = Bitcoin.getInstance().getP2shFee(feeTimestamp);
+		long minimumAmountA = crossChainTradeData.expectedForeignAmount + p2shFee;
+		BitcoinyHTLC.Status htlcStatusA = BitcoinyHTLC.determineHtlcStatus(bitcoin.getBlockchainProvider(), p2shAddressA, minimumAmountA);
+
+		switch (htlcStatusA) {
+			case UNFUNDED:
+			case FUNDING_IN_PROGRESS:
+				// P2SH-A suddenly not funded? Our best bet at this point is to hope for AT auto-refund
+				return;
+
+			case REDEEM_IN_PROGRESS:
+			case REDEEMED:
+				// Double-check that we have redeemed P2SH-A...
+				break;
+
+			case REFUND_IN_PROGRESS:
+			case REFUNDED:
+				// Wait for AT to auto-refund
+				return;
+
+			case FUNDED: {
+				Coin redeemAmount = Coin.valueOf(crossChainTradeData.expectedForeignAmount);
+				ECKey redeemKey = ECKey.fromPrivate(tradeBotData.getTradePrivateKey());
+				List<TransactionOutput> fundingOutputs = bitcoin.getUnspentOutputs(p2shAddressA);
+
+				Transaction p2shRedeemTransaction = BitcoinyHTLC.buildRedeemTransaction(bitcoin.getNetworkParameters(), redeemAmount, redeemKey,
+						fundingOutputs, redeemScriptA, secretA, receivingAccountInfo);
+
+				bitcoin.broadcastTransaction(p2shRedeemTransaction);
+				break;
+			}
+		}
+
+		String receivingAddress = bitcoin.pkhToAddress(receivingAccountInfo);
+
+		TradeBot.updateTradeBotState(repository, tradeBotData, State.BOB_DONE,
+				() -> String.format("P2SH-A %s redeemed. Funds should arrive at %s", tradeBotData.getAtAddress(), receivingAddress));
+	}
+
+	/**
+	 * Trade-bot is attempting to refund P2SH-A.
+	 * @throws ForeignBlockchainException
+	 */
+	private void handleAliceRefundingP2shA(Repository repository, TradeBotData tradeBotData,
+			ATData atData, CrossChainTradeData crossChainTradeData) throws DataException, ForeignBlockchainException {
+		int lockTimeA = tradeBotData.getLockTimeA();
+
+		// We can't refund P2SH-A until lockTime-A has passed
+		if (NTP.getTime() <= lockTimeA * 1000L)
+			return;
+
+		Bitcoin bitcoin = Bitcoin.getInstance();
+
+		// We can't refund P2SH-A until median block time has passed lockTime-A (see BIP113)
+		int medianBlockTime = bitcoin.getMedianBlockTime();
+		if (medianBlockTime <= lockTimeA)
+			return;
+
+		byte[] redeemScriptA = BitcoinyHTLC.buildScript(tradeBotData.getTradeForeignPublicKeyHash(), lockTimeA, crossChainTradeData.creatorForeignPKH, tradeBotData.getHashOfSecret());
+		String p2shAddressA = bitcoin.deriveP2shAddress(redeemScriptA);
+
+		// Fee for redeem/refund is subtracted from P2SH-A balance.
+		long feeTimestamp = calcFeeTimestamp(lockTimeA, crossChainTradeData.tradeTimeout);
+		long p2shFee = Bitcoin.getInstance().getP2shFee(feeTimestamp);
+		long minimumAmountA = crossChainTradeData.expectedForeignAmount + p2shFee;
+		BitcoinyHTLC.Status htlcStatusA = BitcoinyHTLC.determineHtlcStatus(bitcoin.getBlockchainProvider(), p2shAddressA, minimumAmountA);
+
+		switch (htlcStatusA) {
+			case UNFUNDED:
+			case FUNDING_IN_PROGRESS:
+				// Still waiting for P2SH-A to be funded...
+				return;
+
+			case REDEEM_IN_PROGRESS:
+			case REDEEMED:
+				// Too late!
+				TradeBot.updateTradeBotState(repository, tradeBotData, State.ALICE_DONE,
+						() -> String.format("P2SH-A %s already spent!", p2shAddressA));
+				return;
+
+			case REFUND_IN_PROGRESS:
+			case REFUNDED:
+				break;
+
+			case FUNDED:{
+				Coin refundAmount = Coin.valueOf(crossChainTradeData.expectedForeignAmount);
+				ECKey refundKey = ECKey.fromPrivate(tradeBotData.getTradePrivateKey());
+				List<TransactionOutput> fundingOutputs = bitcoin.getUnspentOutputs(p2shAddressA);
+
+				// Determine receive address for refund
+				String receiveAddress = bitcoin.getUnusedReceiveAddress(tradeBotData.getForeignKey());
+				Address receiving = Address.fromString(bitcoin.getNetworkParameters(), receiveAddress);
+
+				Transaction p2shRefundTransaction = BitcoinyHTLC.buildRefundTransaction(bitcoin.getNetworkParameters(), refundAmount, refundKey,
+						fundingOutputs, redeemScriptA, lockTimeA, receiving.getHash());
+
+				bitcoin.broadcastTransaction(p2shRefundTransaction);
+				break;
+			}
+		}
+
+		TradeBot.updateTradeBotState(repository, tradeBotData, State.ALICE_REFUNDED,
+				() -> String.format("LockTime-A reached. Refunded P2SH-A %s. Trade aborted", p2shAddressA));
+	}
+
+	/**
+	 * Returns true if Alice finds AT unexpectedly cancelled, refunded, redeemed or locked to someone else.
+	 * <p>
+	 * Will automatically update trade-bot state to <tt>ALICE_REFUNDING_A</tt> or <tt>ALICE_DONE</tt> as necessary.
+	 * 
+	 * @throws DataException
+	 * @throws ForeignBlockchainException
+	 */
+	private boolean aliceUnexpectedState(Repository repository, TradeBotData tradeBotData,
+			ATData atData, CrossChainTradeData crossChainTradeData) throws DataException, ForeignBlockchainException {
+		// This is OK
+		if (!atData.getIsFinished() && crossChainTradeData.mode == AcctMode.OFFERING)
+			return false;
+
+		boolean isAtLockedToUs = tradeBotData.getTradeNativeAddress().equals(crossChainTradeData.qortalPartnerAddress);
+
+		if (!atData.getIsFinished() && crossChainTradeData.mode == AcctMode.TRADING)
+			if (isAtLockedToUs) {
+				// AT is trading with us - OK
+				return false;
+			} else {
+				TradeBot.updateTradeBotState(repository, tradeBotData, State.ALICE_REFUNDING_A,
+						() -> String.format("AT %s trading with someone else: %s. Refunding & aborting trade", tradeBotData.getAtAddress(), crossChainTradeData.qortalPartnerAddress));
+
+				return true;
+			}
+
+		if (atData.getIsFinished() && crossChainTradeData.mode == AcctMode.REDEEMED && isAtLockedToUs) {
+			// We've redeemed already?
+			TradeBot.updateTradeBotState(repository, tradeBotData, State.ALICE_DONE,
+					() -> String.format("AT %s already redeemed by us. Trade completed", tradeBotData.getAtAddress()));
+		} else {
+			// Any other state is not good, so start defensive refund
+			TradeBot.updateTradeBotState(repository, tradeBotData, State.ALICE_REFUNDING_A,
+					() -> String.format("AT %s cancelled/refunded/redeemed by someone else/invalid state. Refunding & aborting trade", tradeBotData.getAtAddress()));
+		}
+
+		return true;
+	}
+
+	private long calcFeeTimestamp(int lockTimeA, int tradeTimeout) {
+		return (lockTimeA - tradeTimeout * 60) * 1000L;
+	}
+
+}

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

@@ -0,0 +1,885 @@
+package org.qortal.controller.tradebot;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.bitcoinj.core.*;
+import org.bitcoinj.script.Script.ScriptType;
+import org.qortal.account.PrivateKeyAccount;
+import org.qortal.account.PublicKeyAccount;
+import org.qortal.api.model.crosschain.TradeBotCreateRequest;
+import org.qortal.asset.Asset;
+import org.qortal.crosschain.*;
+import org.qortal.crypto.Crypto;
+import org.qortal.data.at.ATData;
+import org.qortal.data.crosschain.CrossChainTradeData;
+import org.qortal.data.crosschain.TradeBotData;
+import org.qortal.data.transaction.BaseTransactionData;
+import org.qortal.data.transaction.DeployAtTransactionData;
+import org.qortal.data.transaction.MessageTransactionData;
+import org.qortal.group.Group;
+import org.qortal.repository.DataException;
+import org.qortal.repository.Repository;
+import org.qortal.transaction.DeployAtTransaction;
+import org.qortal.transaction.MessageTransaction;
+import org.qortal.transaction.Transaction.ValidationResult;
+import org.qortal.transform.TransformationException;
+import org.qortal.transform.transaction.DeployAtTransactionTransformer;
+import org.qortal.utils.Base58;
+import org.qortal.utils.NTP;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import static java.util.Arrays.stream;
+import static java.util.stream.Collectors.toMap;
+
+/**
+ * Performing cross-chain trading steps on behalf of user.
+ * <p>
+ * We deal with three different independent state-spaces here:
+ * <ul>
+ * 	<li>Qortal blockchain</li>
+ * 	<li>Foreign blockchain</li>
+ * 	<li>Trade-bot entries</li>
+ * </ul>
+ */
+public class DigibyteACCTv3TradeBot implements AcctTradeBot {
+
+	private static final Logger LOGGER = LogManager.getLogger(DigibyteACCTv3TradeBot.class);
+
+	public enum State implements TradeBot.StateNameAndValueSupplier {
+		BOB_WAITING_FOR_AT_CONFIRM(10, false, false),
+		BOB_WAITING_FOR_MESSAGE(15, true, true),
+		BOB_WAITING_FOR_AT_REDEEM(25, true, true),
+		BOB_DONE(30, false, false),
+		BOB_REFUNDED(35, false, false),
+
+		ALICE_WAITING_FOR_AT_LOCK(85, true, true),
+		ALICE_DONE(95, false, false),
+		ALICE_REFUNDING_A(105, true, true),
+		ALICE_REFUNDED(110, false, false);
+
+		private static final Map<Integer, State> map = stream(State.values()).collect(toMap(state -> state.value, state -> state));
+
+		public final int value;
+		public final boolean requiresAtData;
+		public final boolean requiresTradeData;
+
+		State(int value, boolean requiresAtData, boolean requiresTradeData) {
+			this.value = value;
+			this.requiresAtData = requiresAtData;
+			this.requiresTradeData = requiresTradeData;
+		}
+
+		public static State valueOf(int value) {
+			return map.get(value);
+		}
+
+		@Override
+		public String getState() {
+			return this.name();
+		}
+
+		@Override
+		public int getStateValue() {
+			return this.value;
+		}
+	}
+
+	/** Maximum time Bob waits for his AT creation transaction to be confirmed into a block. (milliseconds) */
+	private static final long MAX_AT_CONFIRMATION_PERIOD = 24 * 60 * 60 * 1000L; // ms
+
+	private static DigibyteACCTv3TradeBot instance;
+
+	private final List<String> endStates = Arrays.asList(State.BOB_DONE, State.BOB_REFUNDED, State.ALICE_DONE, State.ALICE_REFUNDING_A, State.ALICE_REFUNDED).stream()
+			.map(State::name)
+			.collect(Collectors.toUnmodifiableList());
+
+	private DigibyteACCTv3TradeBot() {
+	}
+
+	public static synchronized DigibyteACCTv3TradeBot getInstance() {
+		if (instance == null)
+			instance = new DigibyteACCTv3TradeBot();
+
+		return instance;
+	}
+
+	@Override
+	public List<String> getEndStates() {
+		return this.endStates;
+	}
+
+	/**
+	 * Creates a new trade-bot entry from the "Bob" viewpoint, i.e. OFFERing QORT in exchange for DGB.
+	 * <p>
+	 * Generates:
+	 * <ul>
+	 * 	<li>new 'trade' private key</li>
+	 * </ul>
+	 * Derives:
+	 * <ul>
+	 * 	<li>'native' (as in Qortal) public key, public key hash, address (starting with Q)</li>
+	 * 	<li>'foreign' (as in Digibyte) public key, public key hash</li>
+	 * </ul>
+	 * A Qortal AT is then constructed including the following as constants in the 'data segment':
+	 * <ul>
+	 * 	<li>'native'/Qortal 'trade' address - used as a MESSAGE contact</li>
+	 * 	<li>'foreign'/Digibyte public key hash - used by Alice's P2SH scripts to allow redeem</li>
+	 * 	<li>QORT amount on offer by Bob</li>
+	 * 	<li>DGB amount expected in return by Bob (from Alice)</li>
+	 * 	<li>trading timeout, in case things go wrong and everyone needs to refund</li>
+	 * </ul>
+	 * Returns a DEPLOY_AT transaction that needs to be signed and broadcast to the Qortal network.
+	 * <p>
+	 * Trade-bot will wait for Bob's AT to be deployed before taking next step.
+	 * <p>
+	 * @param repository
+	 * @param tradeBotCreateRequest
+	 * @return raw, unsigned DEPLOY_AT transaction
+	 * @throws DataException
+	 */
+	public byte[] createTrade(Repository repository, TradeBotCreateRequest tradeBotCreateRequest) throws DataException {
+		byte[] tradePrivateKey = TradeBot.generateTradePrivateKey();
+
+		byte[] tradeNativePublicKey = TradeBot.deriveTradeNativePublicKey(tradePrivateKey);
+		byte[] tradeNativePublicKeyHash = Crypto.hash160(tradeNativePublicKey);
+		String tradeNativeAddress = Crypto.toAddress(tradeNativePublicKey);
+
+		byte[] tradeForeignPublicKey = TradeBot.deriveTradeForeignPublicKey(tradePrivateKey);
+		byte[] tradeForeignPublicKeyHash = Crypto.hash160(tradeForeignPublicKey);
+
+		// Convert Digibyte receiving address into public key hash (we only support P2PKH at this time)
+		Address digibyteReceivingAddress;
+		try {
+			digibyteReceivingAddress = Address.fromString(Digibyte.getInstance().getNetworkParameters(), tradeBotCreateRequest.receivingAddress);
+		} catch (AddressFormatException e) {
+			throw new DataException("Unsupported Digibyte receiving address: " + tradeBotCreateRequest.receivingAddress);
+		}
+		if (digibyteReceivingAddress.getOutputScriptType() != ScriptType.P2PKH)
+			throw new DataException("Unsupported Digibyte receiving address: " + tradeBotCreateRequest.receivingAddress);
+
+		byte[] digibyteReceivingAccountInfo = digibyteReceivingAddress.getHash();
+
+		PublicKeyAccount creator = new PublicKeyAccount(repository, tradeBotCreateRequest.creatorPublicKey);
+
+		// Deploy AT
+		long timestamp = NTP.getTime();
+		byte[] reference = creator.getLastReference();
+		long fee = 0L;
+		byte[] signature = null;
+		BaseTransactionData baseTransactionData = new BaseTransactionData(timestamp, Group.NO_GROUP, reference, creator.getPublicKey(), fee, signature);
+
+		String name = "QORT/DGB ACCT";
+		String description = "QORT/DGB cross-chain trade";
+		String aTType = "ACCT";
+		String tags = "ACCT QORT DGB";
+		byte[] creationBytes = DigibyteACCTv3.buildQortalAT(tradeNativeAddress, tradeForeignPublicKeyHash, tradeBotCreateRequest.qortAmount,
+				tradeBotCreateRequest.foreignAmount, tradeBotCreateRequest.tradeTimeout);
+		long amount = tradeBotCreateRequest.fundingQortAmount;
+
+		DeployAtTransactionData deployAtTransactionData = new DeployAtTransactionData(baseTransactionData, name, description, aTType, tags, creationBytes, amount, Asset.QORT);
+
+		DeployAtTransaction deployAtTransaction = new DeployAtTransaction(repository, deployAtTransactionData);
+		fee = deployAtTransaction.calcRecommendedFee();
+		deployAtTransactionData.setFee(fee);
+
+		DeployAtTransaction.ensureATAddress(deployAtTransactionData);
+		String atAddress = deployAtTransactionData.getAtAddress();
+
+		TradeBotData tradeBotData =  new TradeBotData(tradePrivateKey, DigibyteACCTv3.NAME,
+				State.BOB_WAITING_FOR_AT_CONFIRM.name(), State.BOB_WAITING_FOR_AT_CONFIRM.value,
+				creator.getAddress(), atAddress, timestamp, tradeBotCreateRequest.qortAmount,
+				tradeNativePublicKey, tradeNativePublicKeyHash, tradeNativeAddress,
+				null, null,
+				SupportedBlockchain.DIGIBYTE.name(),
+				tradeForeignPublicKey, tradeForeignPublicKeyHash,
+				tradeBotCreateRequest.foreignAmount, null, null, null, digibyteReceivingAccountInfo);
+
+		TradeBot.updateTradeBotState(repository, tradeBotData, () -> String.format("Built AT %s. Waiting for deployment", atAddress));
+
+		// Attempt to backup the trade bot data
+		TradeBot.backupTradeBotData(repository, null);
+
+		// Return to user for signing and broadcast as we don't have their Qortal private key
+		try {
+			return DeployAtTransactionTransformer.toBytes(deployAtTransactionData);
+		} catch (TransformationException e) {
+			throw new DataException("Failed to transform DEPLOY_AT transaction?", e);
+		}
+	}
+
+	/**
+	 * Creates a trade-bot entry from the 'Alice' viewpoint, i.e. matching DGB to an existing offer.
+	 * <p>
+	 * Requires a chosen trade offer from Bob, passed by <tt>crossChainTradeData</tt>
+	 * and access to a Digibyte wallet via <tt>xprv58</tt>.
+	 * <p>
+	 * The <tt>crossChainTradeData</tt> contains the current trade offer state
+	 * as extracted from the AT's data segment.
+	 * <p>
+	 * Access to a funded wallet is via a Digibyte BIP32 hierarchical deterministic key,
+	 * passed via <tt>xprv58</tt>.
+	 * <b>This key will be stored in your node's database</b>
+	 * to allow trade-bot to create/fund the necessary P2SH transactions!
+	 * However, due to the nature of BIP32 keys, it is possible to give the trade-bot
+	 * only a subset of wallet access (see BIP32 for more details).
+	 * <p>
+	 * As an example, the xprv58 can be extract from a <i>legacy, password-less</i>
+	 * Electrum wallet by going to the console tab and entering:<br>
+	 * <tt>wallet.keystore.xprv</tt><br>
+	 * which should result in a base58 string starting with either 'xprv' (for Digibyte main-net)
+	 * or 'tprv' for (Digibyte test-net).
+	 * <p>
+	 * It is envisaged that the value in <tt>xprv58</tt> will actually come from a Qortal-UI-managed wallet.
+	 * <p>
+	 * If sufficient funds are available, <b>this method will actually fund the P2SH-A</b>
+	 * with the Digibyte amount expected by 'Bob'.
+	 * <p>
+	 * If the Digibyte transaction is successfully broadcast to the network then
+	 * we also send a MESSAGE to Bob's trade-bot to let them know.
+	 * <p>
+	 * The trade-bot entry is saved to the repository and the cross-chain trading process commences.
+	 * <p>
+	 * @param repository
+	 * @param crossChainTradeData chosen trade OFFER that Alice wants to match
+	 * @param xprv58 funded wallet xprv in base58
+	 * @return true if P2SH-A funding transaction successfully broadcast to Digibyte network, false otherwise
+	 * @throws DataException
+	 */
+	public ResponseResult startResponse(Repository repository, ATData atData, ACCT acct, CrossChainTradeData crossChainTradeData, String xprv58, String receivingAddress) throws DataException {
+		byte[] tradePrivateKey = TradeBot.generateTradePrivateKey();
+		byte[] secretA = TradeBot.generateSecret();
+		byte[] hashOfSecretA = Crypto.hash160(secretA);
+
+		byte[] tradeNativePublicKey = TradeBot.deriveTradeNativePublicKey(tradePrivateKey);
+		byte[] tradeNativePublicKeyHash = Crypto.hash160(tradeNativePublicKey);
+		String tradeNativeAddress = Crypto.toAddress(tradeNativePublicKey);
+
+		byte[] tradeForeignPublicKey = TradeBot.deriveTradeForeignPublicKey(tradePrivateKey);
+		byte[] tradeForeignPublicKeyHash = Crypto.hash160(tradeForeignPublicKey);
+		byte[] receivingPublicKeyHash = Base58.decode(receivingAddress); // Actually the whole address, not just PKH
+
+		// We need to generate lockTime-A: add tradeTimeout to now
+		long now = NTP.getTime();
+		int lockTimeA = crossChainTradeData.tradeTimeout * 60 + (int) (now / 1000L);
+
+		TradeBotData tradeBotData =  new TradeBotData(tradePrivateKey, DigibyteACCTv3.NAME,
+				State.ALICE_WAITING_FOR_AT_LOCK.name(), State.ALICE_WAITING_FOR_AT_LOCK.value,
+				receivingAddress, crossChainTradeData.qortalAtAddress, now, crossChainTradeData.qortAmount,
+				tradeNativePublicKey, tradeNativePublicKeyHash, tradeNativeAddress,
+				secretA, hashOfSecretA,
+				SupportedBlockchain.DIGIBYTE.name(),
+				tradeForeignPublicKey, tradeForeignPublicKeyHash,
+				crossChainTradeData.expectedForeignAmount, xprv58, null, lockTimeA, receivingPublicKeyHash);
+
+		// Attempt to backup the trade bot data
+		// Include tradeBotData as an additional parameter, since it's not in the repository yet
+		TradeBot.backupTradeBotData(repository, Arrays.asList(tradeBotData));
+
+		// Check we have enough funds via xprv58 to fund P2SH to cover expectedForeignAmount
+		long p2shFee;
+		try {
+			p2shFee = Digibyte.getInstance().getP2shFee(now);
+		} catch (ForeignBlockchainException e) {
+			LOGGER.debug("Couldn't estimate Digibyte fees?");
+			return ResponseResult.NETWORK_ISSUE;
+		}
+
+		// Fee for redeem/refund is subtracted from P2SH-A balance.
+		// Do not include fee for funding transaction as this is covered by buildSpend()
+		long amountA = crossChainTradeData.expectedForeignAmount + p2shFee /*redeeming/refunding P2SH-A*/;
+
+		// P2SH-A to be funded
+		byte[] redeemScriptBytes = BitcoinyHTLC.buildScript(tradeForeignPublicKeyHash, lockTimeA, crossChainTradeData.creatorForeignPKH, hashOfSecretA);
+		String p2shAddress = Digibyte.getInstance().deriveP2shAddress(redeemScriptBytes);
+
+		// Build transaction for funding P2SH-A
+		Transaction p2shFundingTransaction = Digibyte.getInstance().buildSpend(tradeBotData.getForeignKey(), p2shAddress, amountA);
+		if (p2shFundingTransaction == null) {
+			LOGGER.debug("Unable to build P2SH-A funding transaction - lack of funds?");
+			return ResponseResult.BALANCE_ISSUE;
+		}
+
+		try {
+			Digibyte.getInstance().broadcastTransaction(p2shFundingTransaction);
+		} catch (ForeignBlockchainException e) {
+			// We couldn't fund P2SH-A at this time
+			LOGGER.debug("Couldn't broadcast P2SH-A funding transaction?");
+			return ResponseResult.NETWORK_ISSUE;
+		}
+
+		// Attempt to send MESSAGE to Bob's Qortal trade address
+		byte[] messageData = DigibyteACCTv3.buildOfferMessage(tradeBotData.getTradeForeignPublicKeyHash(), tradeBotData.getHashOfSecret(), tradeBotData.getLockTimeA());
+		String messageRecipient = crossChainTradeData.qortalCreatorTradeAddress;
+
+		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);
+
+			messageTransaction.computeNonce();
+			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 Bob's trade-bot %s: %s", messageRecipient, result.name()));
+				return ResponseResult.NETWORK_ISSUE;
+			}
+		}
+
+		TradeBot.updateTradeBotState(repository, tradeBotData, () -> String.format("Funding P2SH-A %s. Messaged Bob. Waiting for AT-lock", p2shAddress));
+
+		return ResponseResult.OK;
+	}
+
+	@Override
+	public boolean canDelete(Repository repository, TradeBotData tradeBotData) throws DataException {
+		State tradeBotState = State.valueOf(tradeBotData.getStateValue());
+		if (tradeBotState == null)
+			return true;
+
+		// If the AT doesn't exist then we might as well let the user tidy up
+		if (!repository.getATRepository().exists(tradeBotData.getAtAddress()))
+			return true;
+
+		switch (tradeBotState) {
+			case BOB_WAITING_FOR_AT_CONFIRM:
+			case ALICE_DONE:
+			case BOB_DONE:
+			case ALICE_REFUNDED:
+			case BOB_REFUNDED:
+			case ALICE_REFUNDING_A:
+				return true;
+
+			default:
+				return false;
+		}
+	}
+
+	@Override
+	public void progress(Repository repository, TradeBotData tradeBotData) throws DataException, ForeignBlockchainException {
+		State tradeBotState = State.valueOf(tradeBotData.getStateValue());
+		if (tradeBotState == null) {
+			LOGGER.info(() -> String.format("Trade-bot entry for AT %s has invalid state?", tradeBotData.getAtAddress()));
+			return;
+		}
+
+		ATData atData = null;
+		CrossChainTradeData tradeData = null;
+
+		if (tradeBotState.requiresAtData) {
+			// Attempt to fetch AT data
+			atData = repository.getATRepository().fromATAddress(tradeBotData.getAtAddress());
+			if (atData == null) {
+				LOGGER.debug(() -> String.format("Unable to fetch trade AT %s from repository", tradeBotData.getAtAddress()));
+				return;
+			}
+
+			if (tradeBotState.requiresTradeData) {
+				tradeData = DigibyteACCTv3.getInstance().populateTradeData(repository, atData);
+				if (tradeData == null) {
+					LOGGER.warn(() -> String.format("Unable to fetch ACCT trade data for AT %s from repository", tradeBotData.getAtAddress()));
+					return;
+				}
+			}
+		}
+
+		switch (tradeBotState) {
+			case BOB_WAITING_FOR_AT_CONFIRM:
+				handleBobWaitingForAtConfirm(repository, tradeBotData);
+				break;
+
+			case BOB_WAITING_FOR_MESSAGE:
+				TradeBot.getInstance().updatePresence(repository, tradeBotData, tradeData);
+				handleBobWaitingForMessage(repository, tradeBotData, atData, tradeData);
+				break;
+
+			case ALICE_WAITING_FOR_AT_LOCK:
+				TradeBot.getInstance().updatePresence(repository, tradeBotData, tradeData);
+				handleAliceWaitingForAtLock(repository, tradeBotData, atData, tradeData);
+				break;
+
+			case BOB_WAITING_FOR_AT_REDEEM:
+				TradeBot.getInstance().updatePresence(repository, tradeBotData, tradeData);
+				handleBobWaitingForAtRedeem(repository, tradeBotData, atData, tradeData);
+				break;
+
+			case ALICE_DONE:
+			case BOB_DONE:
+				break;
+
+			case ALICE_REFUNDING_A:
+				TradeBot.getInstance().updatePresence(repository, tradeBotData, tradeData);
+				handleAliceRefundingP2shA(repository, tradeBotData, atData, tradeData);
+				break;
+
+			case ALICE_REFUNDED:
+			case BOB_REFUNDED:
+				break;
+		}
+	}
+
+	/**
+	 * Trade-bot is waiting for Bob's AT to deploy.
+	 * <p>
+	 * If AT is deployed, then trade-bot's next step is to wait for MESSAGE from Alice.
+	 */
+	private void handleBobWaitingForAtConfirm(Repository repository, TradeBotData tradeBotData) throws DataException {
+		if (!repository.getATRepository().exists(tradeBotData.getAtAddress())) {
+			if (NTP.getTime() - tradeBotData.getTimestamp() <= MAX_AT_CONFIRMATION_PERIOD)
+				return;
+
+			// We've waited ages for AT to be confirmed into a block but something has gone awry.
+			// After this long we assume transaction loss so give up with trade-bot entry too.
+			tradeBotData.setState(State.BOB_REFUNDED.name());
+			tradeBotData.setStateValue(State.BOB_REFUNDED.value);
+			tradeBotData.setTimestamp(NTP.getTime());
+			// We delete trade-bot entry here instead of saving, hence not using updateTradeBotState()
+			repository.getCrossChainRepository().delete(tradeBotData.getTradePrivateKey());
+			repository.saveChanges();
+
+			LOGGER.info(() -> String.format("AT %s never confirmed. Giving up on trade", tradeBotData.getAtAddress()));
+			TradeBot.notifyStateChange(tradeBotData);
+			return;
+		}
+
+		TradeBot.updateTradeBotState(repository, tradeBotData, State.BOB_WAITING_FOR_MESSAGE,
+				() -> String.format("AT %s confirmed ready. Waiting for trade message", tradeBotData.getAtAddress()));
+	}
+
+	/**
+	 * Trade-bot is waiting for MESSAGE from Alice's trade-bot, containing Alice's trade info.
+	 * <p>
+	 * It's possible Bob has cancelling his trade offer, receiving an automatic QORT refund,
+	 * in which case trade-bot is done with this specific trade and finalizes on refunded state.
+	 * <p>
+	 * Assuming trade is still on offer, trade-bot checks the contents of MESSAGE from Alice's trade-bot.
+	 * <p>
+	 * Details from Alice are used to derive P2SH-A address and this is checked for funding balance.
+	 * <p>
+	 * Assuming P2SH-A has at least expected Digibyte balance,
+	 * Bob's trade-bot constructs a zero-fee, PoW MESSAGE to send to Bob's AT with more trade details.
+	 * <p>
+	 * On processing this MESSAGE, Bob's AT should switch into 'TRADE' mode and only trade with Alice.
+	 * <p>
+	 * Trade-bot's next step is to wait for Alice to redeem the AT, which will allow Bob to
+	 * extract secret-A needed to redeem Alice's P2SH.
+	 * @throws ForeignBlockchainException
+	 */
+	private void handleBobWaitingForMessage(Repository repository, TradeBotData tradeBotData,
+			ATData atData, CrossChainTradeData crossChainTradeData) throws DataException, ForeignBlockchainException {
+		// If AT has finished then Bob likely cancelled his trade offer
+		if (atData.getIsFinished()) {
+			TradeBot.updateTradeBotState(repository, tradeBotData, State.BOB_REFUNDED,
+					() -> String.format("AT %s cancelled - trading aborted", tradeBotData.getAtAddress()));
+			return;
+		}
+
+		Digibyte digibyte = Digibyte.getInstance();
+
+		String address = tradeBotData.getTradeNativeAddress();
+		List<MessageTransactionData> messageTransactionsData = repository.getMessageRepository().getMessagesByParticipants(null, address, null, null, null);
+
+		for (MessageTransactionData messageTransactionData : messageTransactionsData) {
+			if (messageTransactionData.isText())
+				continue;
+
+			// We're expecting: HASH160(secret-A), Alice's Digibyte pubkeyhash and lockTime-A
+			byte[] messageData = messageTransactionData.getData();
+			DigibyteACCTv3.OfferMessageData offerMessageData = DigibyteACCTv3.extractOfferMessageData(messageData);
+			if (offerMessageData == null)
+				continue;
+
+			byte[] aliceForeignPublicKeyHash = offerMessageData.partnerDigibytePKH;
+			byte[] hashOfSecretA = offerMessageData.hashOfSecretA;
+			int lockTimeA = (int) offerMessageData.lockTimeA;
+			long messageTimestamp = messageTransactionData.getTimestamp();
+			int refundTimeout = DigibyteACCTv3.calcRefundTimeout(messageTimestamp, lockTimeA);
+
+			// Determine P2SH-A address and confirm funded
+			byte[] redeemScriptA = BitcoinyHTLC.buildScript(aliceForeignPublicKeyHash, lockTimeA, tradeBotData.getTradeForeignPublicKeyHash(), hashOfSecretA);
+			String p2shAddressA = digibyte.deriveP2shAddress(redeemScriptA);
+
+			long feeTimestamp = calcFeeTimestamp(lockTimeA, crossChainTradeData.tradeTimeout);
+			long p2shFee = Digibyte.getInstance().getP2shFee(feeTimestamp);
+			final long minimumAmountA = tradeBotData.getForeignAmount() + p2shFee;
+
+			BitcoinyHTLC.Status htlcStatusA = BitcoinyHTLC.determineHtlcStatus(digibyte.getBlockchainProvider(), p2shAddressA, minimumAmountA);
+
+			switch (htlcStatusA) {
+				case UNFUNDED:
+				case FUNDING_IN_PROGRESS:
+					// There might be another MESSAGE from someone else with an actually funded P2SH-A...
+					continue;
+
+				case REDEEM_IN_PROGRESS:
+				case REDEEMED:
+					// We've already redeemed this?
+					TradeBot.updateTradeBotState(repository, tradeBotData, State.BOB_DONE,
+							() -> String.format("P2SH-A %s already spent? Assuming trade complete", p2shAddressA));
+					return;
+
+				case REFUND_IN_PROGRESS:
+				case REFUNDED:
+					// This P2SH-A is burnt, but there might be another MESSAGE from someone else with an actually funded P2SH-A...
+					continue;
+
+				case FUNDED:
+					// Fall-through out of switch...
+					break;
+			}
+
+			// Good to go - send MESSAGE to AT
+
+			String aliceNativeAddress = Crypto.toAddress(messageTransactionData.getCreatorPublicKey());
+
+			// Build outgoing message, padding each part to 32 bytes to make it easier for AT to consume
+			byte[] outgoingMessageData = DigibyteACCTv3.buildTradeMessage(aliceNativeAddress, aliceForeignPublicKeyHash, hashOfSecretA, lockTimeA, refundTimeout);
+			String messageRecipient = tradeBotData.getAtAddress();
+
+			boolean isMessageAlreadySent = repository.getMessageRepository().exists(tradeBotData.getTradeNativePublicKey(), messageRecipient, outgoingMessageData);
+			if (!isMessageAlreadySent) {
+				PrivateKeyAccount sender = new PrivateKeyAccount(repository, tradeBotData.getTradePrivateKey());
+				MessageTransaction outgoingMessageTransaction = MessageTransaction.build(repository, sender, Group.NO_GROUP, messageRecipient, outgoingMessageData, false, false);
+
+				outgoingMessageTransaction.computeNonce();
+				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()));
+					return;
+				}
+			}
+
+			TradeBot.updateTradeBotState(repository, tradeBotData, State.BOB_WAITING_FOR_AT_REDEEM,
+					() -> String.format("Locked AT %s to %s. Waiting for AT redeem", tradeBotData.getAtAddress(), aliceNativeAddress));
+
+			return;
+		}
+	}
+
+	/**
+	 * Trade-bot is waiting for Bob's AT to switch to TRADE mode and lock trade to Alice only.
+	 * <p>
+	 * It's possible that Bob has cancelled his trade offer in the mean time, or that somehow
+	 * this process has taken so long that we've reached P2SH-A's locktime, or that someone else
+	 * has managed to trade with Bob. In any of these cases, trade-bot switches to begin the refunding process.
+	 * <p>
+	 * Assuming Bob's AT is locked to Alice, trade-bot checks AT's state data to make sure it is correct.
+	 * <p>
+	 * If all is well, trade-bot then redeems AT using Alice's secret-A, releasing Bob's QORT to Alice.
+	 * <p>
+	 * In revealing a valid secret-A, Bob can then redeem the DGB funds from P2SH-A.
+	 * <p>
+	 * @throws ForeignBlockchainException
+	 */
+	private void handleAliceWaitingForAtLock(Repository repository, TradeBotData tradeBotData,
+			ATData atData, CrossChainTradeData crossChainTradeData) throws DataException, ForeignBlockchainException {
+		if (aliceUnexpectedState(repository, tradeBotData, atData, crossChainTradeData))
+			return;
+
+		Digibyte digibyte = Digibyte.getInstance();
+		int lockTimeA = tradeBotData.getLockTimeA();
+
+		// Refund P2SH-A if we've passed lockTime-A
+		if (NTP.getTime() >= lockTimeA * 1000L) {
+			byte[] redeemScriptA = BitcoinyHTLC.buildScript(tradeBotData.getTradeForeignPublicKeyHash(), lockTimeA, crossChainTradeData.creatorForeignPKH, tradeBotData.getHashOfSecret());
+			String p2shAddressA = digibyte.deriveP2shAddress(redeemScriptA);
+
+			long feeTimestamp = calcFeeTimestamp(lockTimeA, crossChainTradeData.tradeTimeout);
+			long p2shFee = Digibyte.getInstance().getP2shFee(feeTimestamp);
+			long minimumAmountA = crossChainTradeData.expectedForeignAmount + p2shFee;
+
+			BitcoinyHTLC.Status htlcStatusA = BitcoinyHTLC.determineHtlcStatus(digibyte.getBlockchainProvider(), p2shAddressA, minimumAmountA);
+
+			switch (htlcStatusA) {
+				case UNFUNDED:
+				case FUNDING_IN_PROGRESS:
+				case FUNDED:
+					break;
+
+				case REDEEM_IN_PROGRESS:
+				case REDEEMED:
+					// Already redeemed?
+					TradeBot.updateTradeBotState(repository, tradeBotData, State.ALICE_DONE,
+							() -> String.format("P2SH-A %s already spent? Assuming trade completed", p2shAddressA));
+					return;
+
+				case REFUND_IN_PROGRESS:
+				case REFUNDED:
+					TradeBot.updateTradeBotState(repository, tradeBotData, State.ALICE_REFUNDED,
+							() -> String.format("P2SH-A %s already refunded. Trade aborted", p2shAddressA));
+					return;
+
+			}
+
+			TradeBot.updateTradeBotState(repository, tradeBotData, State.ALICE_REFUNDING_A,
+					() -> atData.getIsFinished()
+					? String.format("AT %s cancelled. Refunding P2SH-A %s - aborting trade", tradeBotData.getAtAddress(), p2shAddressA)
+					: String.format("LockTime-A reached, refunding P2SH-A %s - aborting trade", p2shAddressA));
+
+			return;
+		}
+
+		// We're waiting for AT to be in TRADE mode
+		if (crossChainTradeData.mode != AcctMode.TRADING)
+			return;
+
+		// AT is in TRADE mode and locked to us as checked by aliceUnexpectedState() above
+
+		// Find our MESSAGE to AT from previous state
+		List<MessageTransactionData> messageTransactionsData = repository.getMessageRepository().getMessagesByParticipants(tradeBotData.getTradeNativePublicKey(),
+				crossChainTradeData.qortalCreatorTradeAddress, null, null, null);
+		if (messageTransactionsData == null || messageTransactionsData.isEmpty()) {
+			LOGGER.warn(() -> String.format("Unable to find our message to trade creator %s?", crossChainTradeData.qortalCreatorTradeAddress));
+			return;
+		}
+
+		long recipientMessageTimestamp = messageTransactionsData.get(0).getTimestamp();
+		int refundTimeout = DigibyteACCTv3.calcRefundTimeout(recipientMessageTimestamp, lockTimeA);
+
+		// Our calculated refundTimeout should match AT's refundTimeout
+		if (refundTimeout != crossChainTradeData.refundTimeout) {
+			LOGGER.debug(() -> String.format("Trade AT refundTimeout '%d' doesn't match our refundTimeout '%d'", crossChainTradeData.refundTimeout, refundTimeout));
+			// We'll eventually refund
+			return;
+		}
+
+		// We're good to redeem AT
+
+		// Send 'redeem' MESSAGE to AT using both secret
+		byte[] secretA = tradeBotData.getSecret();
+		String qortalReceivingAddress = Base58.encode(tradeBotData.getReceivingAccountInfo()); // Actually contains whole address, not just PKH
+		byte[] messageData = DigibyteACCTv3.buildRedeemMessage(secretA, qortalReceivingAddress);
+		String messageRecipient = tradeBotData.getAtAddress();
+
+		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);
+
+			messageTransaction.computeNonce();
+			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()));
+				return;
+			}
+		}
+
+		TradeBot.updateTradeBotState(repository, tradeBotData, State.ALICE_DONE,
+				() -> String.format("Redeeming AT %s. Funds should arrive at %s",
+						tradeBotData.getAtAddress(), qortalReceivingAddress));
+	}
+
+	/**
+	 * Trade-bot is waiting for Alice to redeem Bob's AT, thus revealing secret-A which is required to spend the DGB funds from P2SH-A.
+	 * <p>
+	 * It's possible that Bob's AT has reached its trading timeout and automatically refunded QORT back to Bob. In which case,
+	 * trade-bot is done with this specific trade and finalizes in refunded state.
+	 * <p>
+	 * Assuming trade-bot can extract a valid secret-A from Alice's MESSAGE then trade-bot uses that to redeem the DGB funds from P2SH-A
+	 * to Bob's 'foreign'/Digibyte trade legacy-format address, as derived from trade private key.
+	 * <p>
+	 * (This could potentially be 'improved' to send DGB to any address of Bob's choosing by changing the transaction output).
+	 * <p>
+	 * If trade-bot successfully broadcasts the transaction, then this specific trade is done.
+	 * @throws ForeignBlockchainException
+	 */
+	private void handleBobWaitingForAtRedeem(Repository repository, TradeBotData tradeBotData,
+			ATData atData, CrossChainTradeData crossChainTradeData) throws DataException, ForeignBlockchainException {
+		// AT should be 'finished' once Alice has redeemed QORT funds
+		if (!atData.getIsFinished())
+			// Not finished yet
+			return;
+
+		// If AT is REFUNDED or CANCELLED then something has gone wrong
+		if (crossChainTradeData.mode == AcctMode.REFUNDED || crossChainTradeData.mode == AcctMode.CANCELLED) {
+			// Alice hasn't redeemed the QORT, so there is no point in trying to redeem the DGB
+			TradeBot.updateTradeBotState(repository, tradeBotData, State.BOB_REFUNDED,
+					() -> String.format("AT %s has auto-refunded - trade aborted", tradeBotData.getAtAddress()));
+
+			return;
+		}
+
+		byte[] secretA = DigibyteACCTv3.getInstance().findSecretA(repository, crossChainTradeData);
+		if (secretA == null) {
+			LOGGER.debug(() -> String.format("Unable to find secret-A from redeem message to AT %s?", tradeBotData.getAtAddress()));
+			return;
+		}
+
+		// Use secret-A to redeem P2SH-A
+
+		Digibyte digibyte = Digibyte.getInstance();
+
+		byte[] receivingAccountInfo = tradeBotData.getReceivingAccountInfo();
+		int lockTimeA = crossChainTradeData.lockTimeA;
+		byte[] redeemScriptA = BitcoinyHTLC.buildScript(crossChainTradeData.partnerForeignPKH, lockTimeA, crossChainTradeData.creatorForeignPKH, crossChainTradeData.hashOfSecretA);
+		String p2shAddressA = digibyte.deriveP2shAddress(redeemScriptA);
+
+		// Fee for redeem/refund is subtracted from P2SH-A balance.
+		long feeTimestamp = calcFeeTimestamp(lockTimeA, crossChainTradeData.tradeTimeout);
+		long p2shFee = Digibyte.getInstance().getP2shFee(feeTimestamp);
+		long minimumAmountA = crossChainTradeData.expectedForeignAmount + p2shFee;
+		BitcoinyHTLC.Status htlcStatusA = BitcoinyHTLC.determineHtlcStatus(digibyte.getBlockchainProvider(), p2shAddressA, minimumAmountA);
+
+		switch (htlcStatusA) {
+			case UNFUNDED:
+			case FUNDING_IN_PROGRESS:
+				// P2SH-A suddenly not funded? Our best bet at this point is to hope for AT auto-refund
+				return;
+
+			case REDEEM_IN_PROGRESS:
+			case REDEEMED:
+				// Double-check that we have redeemed P2SH-A...
+				break;
+
+			case REFUND_IN_PROGRESS:
+			case REFUNDED:
+				// Wait for AT to auto-refund
+				return;
+
+			case FUNDED: {
+				Coin redeemAmount = Coin.valueOf(crossChainTradeData.expectedForeignAmount);
+				ECKey redeemKey = ECKey.fromPrivate(tradeBotData.getTradePrivateKey());
+				List<TransactionOutput> fundingOutputs = digibyte.getUnspentOutputs(p2shAddressA);
+
+				Transaction p2shRedeemTransaction = BitcoinyHTLC.buildRedeemTransaction(digibyte.getNetworkParameters(), redeemAmount, redeemKey,
+						fundingOutputs, redeemScriptA, secretA, receivingAccountInfo);
+
+				digibyte.broadcastTransaction(p2shRedeemTransaction);
+				break;
+			}
+		}
+
+		String receivingAddress = digibyte.pkhToAddress(receivingAccountInfo);
+
+		TradeBot.updateTradeBotState(repository, tradeBotData, State.BOB_DONE,
+				() -> String.format("P2SH-A %s redeemed. Funds should arrive at %s", tradeBotData.getAtAddress(), receivingAddress));
+	}
+
+	/**
+	 * Trade-bot is attempting to refund P2SH-A.
+	 * @throws ForeignBlockchainException
+	 */
+	private void handleAliceRefundingP2shA(Repository repository, TradeBotData tradeBotData,
+			ATData atData, CrossChainTradeData crossChainTradeData) throws DataException, ForeignBlockchainException {
+		int lockTimeA = tradeBotData.getLockTimeA();
+
+		// We can't refund P2SH-A until lockTime-A has passed
+		if (NTP.getTime() <= lockTimeA * 1000L)
+			return;
+
+		Digibyte digibyte = Digibyte.getInstance();
+
+		// We can't refund P2SH-A until median block time has passed lockTime-A (see BIP113)
+		int medianBlockTime = digibyte.getMedianBlockTime();
+		if (medianBlockTime <= lockTimeA)
+			return;
+
+		byte[] redeemScriptA = BitcoinyHTLC.buildScript(tradeBotData.getTradeForeignPublicKeyHash(), lockTimeA, crossChainTradeData.creatorForeignPKH, tradeBotData.getHashOfSecret());
+		String p2shAddressA = digibyte.deriveP2shAddress(redeemScriptA);
+
+		// Fee for redeem/refund is subtracted from P2SH-A balance.
+		long feeTimestamp = calcFeeTimestamp(lockTimeA, crossChainTradeData.tradeTimeout);
+		long p2shFee = Digibyte.getInstance().getP2shFee(feeTimestamp);
+		long minimumAmountA = crossChainTradeData.expectedForeignAmount + p2shFee;
+		BitcoinyHTLC.Status htlcStatusA = BitcoinyHTLC.determineHtlcStatus(digibyte.getBlockchainProvider(), p2shAddressA, minimumAmountA);
+
+		switch (htlcStatusA) {
+			case UNFUNDED:
+			case FUNDING_IN_PROGRESS:
+				// Still waiting for P2SH-A to be funded...
+				return;
+
+			case REDEEM_IN_PROGRESS:
+			case REDEEMED:
+				// Too late!
+				TradeBot.updateTradeBotState(repository, tradeBotData, State.ALICE_DONE,
+						() -> String.format("P2SH-A %s already spent!", p2shAddressA));
+				return;
+
+			case REFUND_IN_PROGRESS:
+			case REFUNDED:
+				break;
+
+			case FUNDED:{
+				Coin refundAmount = Coin.valueOf(crossChainTradeData.expectedForeignAmount);
+				ECKey refundKey = ECKey.fromPrivate(tradeBotData.getTradePrivateKey());
+				List<TransactionOutput> fundingOutputs = digibyte.getUnspentOutputs(p2shAddressA);
+
+				// Determine receive address for refund
+				String receiveAddress = digibyte.getUnusedReceiveAddress(tradeBotData.getForeignKey());
+				Address receiving = Address.fromString(digibyte.getNetworkParameters(), receiveAddress);
+
+				Transaction p2shRefundTransaction = BitcoinyHTLC.buildRefundTransaction(digibyte.getNetworkParameters(), refundAmount, refundKey,
+						fundingOutputs, redeemScriptA, lockTimeA, receiving.getHash());
+
+				digibyte.broadcastTransaction(p2shRefundTransaction);
+				break;
+			}
+		}
+
+		TradeBot.updateTradeBotState(repository, tradeBotData, State.ALICE_REFUNDED,
+				() -> String.format("LockTime-A reached. Refunded P2SH-A %s. Trade aborted", p2shAddressA));
+	}
+
+	/**
+	 * Returns true if Alice finds AT unexpectedly cancelled, refunded, redeemed or locked to someone else.
+	 * <p>
+	 * Will automatically update trade-bot state to <tt>ALICE_REFUNDING_A</tt> or <tt>ALICE_DONE</tt> as necessary.
+	 * 
+	 * @throws DataException
+	 * @throws ForeignBlockchainException
+	 */
+	private boolean aliceUnexpectedState(Repository repository, TradeBotData tradeBotData,
+			ATData atData, CrossChainTradeData crossChainTradeData) throws DataException, ForeignBlockchainException {
+		// This is OK
+		if (!atData.getIsFinished() && crossChainTradeData.mode == AcctMode.OFFERING)
+			return false;
+
+		boolean isAtLockedToUs = tradeBotData.getTradeNativeAddress().equals(crossChainTradeData.qortalPartnerAddress);
+
+		if (!atData.getIsFinished() && crossChainTradeData.mode == AcctMode.TRADING)
+			if (isAtLockedToUs) {
+				// AT is trading with us - OK
+				return false;
+			} else {
+				TradeBot.updateTradeBotState(repository, tradeBotData, State.ALICE_REFUNDING_A,
+						() -> String.format("AT %s trading with someone else: %s. Refunding & aborting trade", tradeBotData.getAtAddress(), crossChainTradeData.qortalPartnerAddress));
+
+				return true;
+			}
+
+		if (atData.getIsFinished() && crossChainTradeData.mode == AcctMode.REDEEMED && isAtLockedToUs) {
+			// We've redeemed already?
+			TradeBot.updateTradeBotState(repository, tradeBotData, State.ALICE_DONE,
+					() -> String.format("AT %s already redeemed by us. Trade completed", tradeBotData.getAtAddress()));
+		} else {
+			// Any other state is not good, so start defensive refund
+			TradeBot.updateTradeBotState(repository, tradeBotData, State.ALICE_REFUNDING_A,
+					() -> String.format("AT %s cancelled/refunded/redeemed by someone else/invalid state. Refunding & aborting trade", tradeBotData.getAtAddress()));
+		}
+
+		return true;
+	}
+
+	private long calcFeeTimestamp(int lockTimeA, int tradeTimeout) {
+		return (lockTimeA - tradeTimeout * 60) * 1000L;
+	}
+
+}

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

@@ -0,0 +1,913 @@
+package org.qortal.controller.tradebot;
+
+import com.google.common.hash.HashCode;
+import com.rust.litewalletjni.LiteWalletJni;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.bitcoinj.core.*;
+import org.qortal.account.PrivateKeyAccount;
+import org.qortal.account.PublicKeyAccount;
+import org.qortal.api.model.crosschain.TradeBotCreateRequest;
+import org.qortal.asset.Asset;
+import org.qortal.crosschain.*;
+import org.qortal.crypto.Crypto;
+import org.qortal.data.at.ATData;
+import org.qortal.data.crosschain.CrossChainTradeData;
+import org.qortal.data.crosschain.TradeBotData;
+import org.qortal.data.transaction.BaseTransactionData;
+import org.qortal.data.transaction.DeployAtTransactionData;
+import org.qortal.data.transaction.MessageTransactionData;
+import org.qortal.group.Group;
+import org.qortal.repository.DataException;
+import org.qortal.repository.Repository;
+import org.qortal.transaction.DeployAtTransaction;
+import org.qortal.transaction.MessageTransaction;
+import org.qortal.transaction.Transaction.ValidationResult;
+import org.qortal.transform.TransformationException;
+import org.qortal.transform.transaction.DeployAtTransactionTransformer;
+import org.qortal.utils.Base58;
+import org.qortal.utils.NTP;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import static java.util.Arrays.stream;
+import static java.util.stream.Collectors.toMap;
+
+/**
+ * Performing cross-chain trading steps on behalf of user.
+ * <p>
+ * We deal with three different independent state-spaces here:
+ * <ul>
+ * 	<li>Qortal blockchain</li>
+ * 	<li>Foreign blockchain</li>
+ * 	<li>Trade-bot entries</li>
+ * </ul>
+ */
+public class PirateChainACCTv3TradeBot implements AcctTradeBot {
+
+	private static final Logger LOGGER = LogManager.getLogger(PirateChainACCTv3TradeBot.class);
+
+	public enum State implements TradeBot.StateNameAndValueSupplier {
+		BOB_WAITING_FOR_AT_CONFIRM(10, false, false),
+		BOB_WAITING_FOR_MESSAGE(15, true, true),
+		BOB_WAITING_FOR_AT_REDEEM(25, true, true),
+		BOB_DONE(30, false, false),
+		BOB_REFUNDED(35, false, false),
+
+		ALICE_WAITING_FOR_AT_LOCK(85, true, true),
+		ALICE_DONE(95, false, false),
+		ALICE_REFUNDING_A(105, true, true),
+		ALICE_REFUNDED(110, false, false);
+
+		private static final Map<Integer, State> map = stream(State.values()).collect(toMap(state -> state.value, state -> state));
+
+		public final int value;
+		public final boolean requiresAtData;
+		public final boolean requiresTradeData;
+
+		State(int value, boolean requiresAtData, boolean requiresTradeData) {
+			this.value = value;
+			this.requiresAtData = requiresAtData;
+			this.requiresTradeData = requiresTradeData;
+		}
+
+		public static State valueOf(int value) {
+			return map.get(value);
+		}
+
+		@Override
+		public String getState() {
+			return this.name();
+		}
+
+		@Override
+		public int getStateValue() {
+			return this.value;
+		}
+	}
+
+	/** Maximum time Bob waits for his AT creation transaction to be confirmed into a block. (milliseconds) */
+	private static final long MAX_AT_CONFIRMATION_PERIOD = 24 * 60 * 60 * 1000L; // ms
+
+	private static PirateChainACCTv3TradeBot instance;
+
+	private final List<String> endStates = Arrays.asList(State.BOB_DONE, State.BOB_REFUNDED, State.ALICE_DONE, State.ALICE_REFUNDING_A, State.ALICE_REFUNDED).stream()
+			.map(State::name)
+			.collect(Collectors.toUnmodifiableList());
+
+	private PirateChainACCTv3TradeBot() {
+	}
+
+	public static synchronized PirateChainACCTv3TradeBot getInstance() {
+		if (instance == null)
+			instance = new PirateChainACCTv3TradeBot();
+
+		return instance;
+	}
+
+	@Override
+	public List<String> getEndStates() {
+		return this.endStates;
+	}
+
+	/**
+	 * Creates a new trade-bot entry from the "Bob" viewpoint, i.e. OFFERing QORT in exchange for ARRR.
+	 * <p>
+	 * Generates:
+	 * <ul>
+	 * 	<li>new 'trade' private key</li>
+	 * </ul>
+	 * Derives:
+	 * <ul>
+	 * 	<li>'native' (as in Qortal) public key, public key hash, address (starting with Q)</li>
+	 * 	<li>'foreign' (as in PirateChain) public key, public key hash</li>
+	 * </ul>
+	 * A Qortal AT is then constructed including the following as constants in the 'data segment':
+	 * <ul>
+	 * 	<li>'native'/Qortal 'trade' address - used as a MESSAGE contact</li>
+	 * 	<li>'foreign'/PirateChain public key hash - used by Alice's P2SH scripts to allow redeem</li>
+	 * 	<li>QORT amount on offer by Bob</li>
+	 * 	<li>ARRR amount expected in return by Bob (from Alice)</li>
+	 * 	<li>trading timeout, in case things go wrong and everyone needs to refund</li>
+	 * </ul>
+	 * Returns a DEPLOY_AT transaction that needs to be signed and broadcast to the Qortal network.
+	 * <p>
+	 * Trade-bot will wait for Bob's AT to be deployed before taking next step.
+	 * <p>
+	 * @param repository
+	 * @param tradeBotCreateRequest
+	 * @return raw, unsigned DEPLOY_AT transaction
+	 * @throws DataException
+	 */
+	public byte[] createTrade(Repository repository, TradeBotCreateRequest tradeBotCreateRequest) throws DataException {
+		byte[] tradePrivateKey = TradeBot.generateTradePrivateKey();
+
+		byte[] tradeNativePublicKey = TradeBot.deriveTradeNativePublicKey(tradePrivateKey);
+		byte[] tradeNativePublicKeyHash = Crypto.hash160(tradeNativePublicKey);
+		String tradeNativeAddress = Crypto.toAddress(tradeNativePublicKey);
+
+		byte[] tradeForeignPublicKey = TradeBot.deriveTradeForeignPublicKey(tradePrivateKey);
+		byte[] tradeForeignPublicKeyHash = Crypto.hash160(tradeForeignPublicKey);
+
+		// ARRR wallet must be loaded before a trade can be created
+		// This is to stop trades from nodes on unsupported architectures (e.g. 32bit)
+		if (!LiteWalletJni.isLoaded()) {
+			throw new DataException("Pirate wallet not found. Check wallets screen for details.");
+		}
+
+		if (!PirateChain.getInstance().isValidAddress(tradeBotCreateRequest.receivingAddress)) {
+			throw new DataException("Unsupported Pirate Chain receiving address: " + tradeBotCreateRequest.receivingAddress);
+		}
+
+		Bech32.Bech32Data decodedReceivingAddress = Bech32.decode(tradeBotCreateRequest.receivingAddress);
+		byte[] pirateChainReceivingAccountInfo = decodedReceivingAddress.data;
+
+		PublicKeyAccount creator = new PublicKeyAccount(repository, tradeBotCreateRequest.creatorPublicKey);
+
+		// Deploy AT
+		long timestamp = NTP.getTime();
+		byte[] reference = creator.getLastReference();
+		long fee = 0L;
+		byte[] signature = null;
+		BaseTransactionData baseTransactionData = new BaseTransactionData(timestamp, Group.NO_GROUP, reference, creator.getPublicKey(), fee, signature);
+
+		String name = "QORT/ARRR ACCT";
+		String description = "QORT/ARRR cross-chain trade";
+		String aTType = "ACCT";
+		String tags = "ACCT QORT ARRR";
+		byte[] creationBytes = PirateChainACCTv3.buildQortalAT(tradeNativeAddress, tradeForeignPublicKey, tradeBotCreateRequest.qortAmount,
+				tradeBotCreateRequest.foreignAmount, tradeBotCreateRequest.tradeTimeout);
+		long amount = tradeBotCreateRequest.fundingQortAmount;
+
+		DeployAtTransactionData deployAtTransactionData = new DeployAtTransactionData(baseTransactionData, name, description, aTType, tags, creationBytes, amount, Asset.QORT);
+
+		DeployAtTransaction deployAtTransaction = new DeployAtTransaction(repository, deployAtTransactionData);
+		fee = deployAtTransaction.calcRecommendedFee();
+		deployAtTransactionData.setFee(fee);
+
+		DeployAtTransaction.ensureATAddress(deployAtTransactionData);
+		String atAddress = deployAtTransactionData.getAtAddress();
+
+		TradeBotData tradeBotData =  new TradeBotData(tradePrivateKey, PirateChainACCTv3.NAME,
+				State.BOB_WAITING_FOR_AT_CONFIRM.name(), State.BOB_WAITING_FOR_AT_CONFIRM.value,
+				creator.getAddress(), atAddress, timestamp, tradeBotCreateRequest.qortAmount,
+				tradeNativePublicKey, tradeNativePublicKeyHash, tradeNativeAddress,
+				null, null,
+				SupportedBlockchain.PIRATECHAIN.name(),
+				tradeForeignPublicKey, tradeForeignPublicKeyHash,
+				tradeBotCreateRequest.foreignAmount, null, null, null, pirateChainReceivingAccountInfo);
+
+		TradeBot.updateTradeBotState(repository, tradeBotData, () -> String.format("Built AT %s. Waiting for deployment", atAddress));
+
+		// Attempt to backup the trade bot data
+		TradeBot.backupTradeBotData(repository, null);
+
+		// Return to user for signing and broadcast as we don't have their Qortal private key
+		try {
+			return DeployAtTransactionTransformer.toBytes(deployAtTransactionData);
+		} catch (TransformationException e) {
+			throw new DataException("Failed to transform DEPLOY_AT transaction?", e);
+		}
+	}
+
+	/**
+	 * Creates a trade-bot entry from the 'Alice' viewpoint, i.e. matching ARRR to an existing offer.
+	 * <p>
+	 * Requires a chosen trade offer from Bob, passed by <tt>crossChainTradeData</tt>
+	 * and access to a PirateChain wallet via <tt>xprv58</tt>.
+	 * <p>
+	 * The <tt>crossChainTradeData</tt> contains the current trade offer state
+	 * as extracted from the AT's data segment.
+	 * <p>
+	 * Access to a funded wallet is via a PirateChain BIP32 hierarchical deterministic key,
+	 * passed via <tt>xprv58</tt>.
+	 * <b>This key will be stored in your node's database</b>
+	 * to allow trade-bot to create/fund the necessary P2SH transactions!
+	 * However, due to the nature of BIP32 keys, it is possible to give the trade-bot
+	 * only a subset of wallet access (see BIP32 for more details).
+	 * <p>
+	 * As an example, the xprv58 can be extract from a <i>legacy, password-less</i>
+	 * Electrum wallet by going to the console tab and entering:<br>
+	 * <tt>wallet.keystore.xprv</tt><br>
+	 * which should result in a base58 string starting with either 'xprv' (for PirateChain main-net)
+	 * or 'tprv' for (PirateChain test-net).
+	 * <p>
+	 * It is envisaged that the value in <tt>xprv58</tt> will actually come from a Qortal-UI-managed wallet.
+	 * <p>
+	 * If sufficient funds are available, <b>this method will actually fund the P2SH-A</b>
+	 * with the PirateChain amount expected by 'Bob'.
+	 * <p>
+	 * If the PirateChain transaction is successfully broadcast to the network then
+	 * we also send a MESSAGE to Bob's trade-bot to let them know.
+	 * <p>
+	 * The trade-bot entry is saved to the repository and the cross-chain trading process commences.
+	 * <p>
+	 * @param repository
+	 * @param crossChainTradeData chosen trade OFFER that Alice wants to match
+	 * @param seed58 funded wallet xprv in base58
+	 * @return true if P2SH-A funding transaction successfully broadcast to PirateChain network, false otherwise
+	 * @throws DataException
+	 */
+	public ResponseResult startResponse(Repository repository, ATData atData, ACCT acct, CrossChainTradeData crossChainTradeData, String seed58, String receivingAddress) throws DataException {
+		byte[] tradePrivateKey = TradeBot.generateTradePrivateKey();
+		byte[] secretA = TradeBot.generateSecret();
+		byte[] hashOfSecretA = Crypto.hash160(secretA);
+
+		byte[] tradeNativePublicKey = TradeBot.deriveTradeNativePublicKey(tradePrivateKey);
+		byte[] tradeNativePublicKeyHash = Crypto.hash160(tradeNativePublicKey);
+		String tradeNativeAddress = Crypto.toAddress(tradeNativePublicKey);
+
+		byte[] tradeForeignPublicKey = TradeBot.deriveTradeForeignPublicKey(tradePrivateKey);
+		byte[] tradeForeignPublicKeyHash = Crypto.hash160(tradeForeignPublicKey);
+		byte[] receivingPublicKeyHash = Base58.decode(receivingAddress); // Actually the whole address, not just PKH
+
+		String tradePrivateKey58 = Base58.encode(tradePrivateKey);
+        String tradeForeignPublicKey58 = Base58.encode(tradeForeignPublicKey);
+		String secret58 = Base58.encode(secretA);
+
+		// We need to generate lockTime-A: add tradeTimeout to now
+		long now = NTP.getTime();
+		int lockTimeA = crossChainTradeData.tradeTimeout * 60 + (int) (now / 1000L);
+
+		TradeBotData tradeBotData =  new TradeBotData(tradePrivateKey, PirateChainACCTv3.NAME,
+				State.ALICE_WAITING_FOR_AT_LOCK.name(), State.ALICE_WAITING_FOR_AT_LOCK.value,
+				receivingAddress, crossChainTradeData.qortalAtAddress, now, crossChainTradeData.qortAmount,
+				tradeNativePublicKey, tradeNativePublicKeyHash, tradeNativeAddress,
+				secretA, hashOfSecretA,
+				SupportedBlockchain.PIRATECHAIN.name(),
+				tradeForeignPublicKey, tradeForeignPublicKeyHash,
+				crossChainTradeData.expectedForeignAmount, seed58, null, lockTimeA, receivingPublicKeyHash);
+
+		// Attempt to backup the trade bot data
+		// Include tradeBotData as an additional parameter, since it's not in the repository yet
+		TradeBot.backupTradeBotData(repository, Arrays.asList(tradeBotData));
+
+		// Check we have enough funds via xprv58 to fund P2SH to cover expectedForeignAmount
+		long p2shFee;
+		try {
+			p2shFee = PirateChain.getInstance().getP2shFee(now);
+		} catch (ForeignBlockchainException e) {
+			LOGGER.debug("Couldn't estimate PirateChain fees?");
+			return ResponseResult.NETWORK_ISSUE;
+		}
+
+		// Fee for redeem/refund is subtracted from P2SH-A balance.
+		// Do not include fee for funding transaction as this is covered by buildSpend()
+		long amountA = crossChainTradeData.expectedForeignAmount + p2shFee /*redeeming/refunding P2SH-A*/;
+
+		// P2SH-A to be funded
+		byte[] redeemScriptBytes = PirateChainHTLC.buildScript(tradeForeignPublicKey, lockTimeA, crossChainTradeData.creatorForeignPKH, hashOfSecretA);
+		String p2shAddressT3 = PirateChain.getInstance().deriveP2shAddress(redeemScriptBytes); // Use t3 prefix when funding
+		byte[] redeemScriptWithPrefixBytes = PirateChainHTLC.buildScriptWithPrefix(tradeForeignPublicKey, lockTimeA, crossChainTradeData.creatorForeignPKH, hashOfSecretA);
+		String redeemScriptWithPrefix58 = Base58.encode(redeemScriptWithPrefixBytes);
+
+		// Send to P2SH address
+		try {
+			String txid = PirateChain.getInstance().fundP2SH(seed58, p2shAddressT3, amountA, redeemScriptWithPrefix58);
+			LOGGER.info("fundingTxidHex: {}", txid);
+
+		} catch (ForeignBlockchainException e) {
+			LOGGER.debug("Unable to build and send P2SH-A funding transaction - lack of funds?");
+			return ResponseResult.BALANCE_ISSUE;
+		}
+
+		// Attempt to send MESSAGE to Bob's Qortal trade address
+		byte[] messageData = PirateChainACCTv3.buildOfferMessage(tradeBotData.getTradeForeignPublicKey(), tradeBotData.getHashOfSecret(), tradeBotData.getLockTimeA());
+		String messageRecipient = crossChainTradeData.qortalCreatorTradeAddress;
+
+		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);
+
+			messageTransaction.computeNonce();
+			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 Bob's trade-bot %s: %s", messageRecipient, result.name()));
+				return ResponseResult.NETWORK_ISSUE;
+			}
+		}
+
+		TradeBot.updateTradeBotState(repository, tradeBotData, () -> String.format("Funding P2SH-A %s. Messaged Bob. Waiting for AT-lock", p2shAddressT3));
+
+		return ResponseResult.OK;
+	}
+
+	public static String hex(byte[] bytes) {
+		StringBuilder result = new StringBuilder();
+		for (byte aByte : bytes) {
+			result.append(String.format("%02x", aByte));
+			// upper case
+			// result.append(String.format("%02X", aByte));
+		}
+		return result.toString();
+	}
+
+	@Override
+	public boolean canDelete(Repository repository, TradeBotData tradeBotData) throws DataException {
+		State tradeBotState = State.valueOf(tradeBotData.getStateValue());
+		if (tradeBotState == null)
+			return true;
+
+		// If the AT doesn't exist then we might as well let the user tidy up
+		if (!repository.getATRepository().exists(tradeBotData.getAtAddress()))
+			return true;
+
+		switch (tradeBotState) {
+			case BOB_WAITING_FOR_AT_CONFIRM:
+			case ALICE_DONE:
+			case BOB_DONE:
+			case ALICE_REFUNDED:
+			case BOB_REFUNDED:
+			case ALICE_REFUNDING_A:
+				return true;
+
+			default:
+				return false;
+		}
+	}
+
+	@Override
+	public void progress(Repository repository, TradeBotData tradeBotData) throws DataException, ForeignBlockchainException {
+		State tradeBotState = State.valueOf(tradeBotData.getStateValue());
+		if (tradeBotState == null) {
+			LOGGER.info(() -> String.format("Trade-bot entry for AT %s has invalid state?", tradeBotData.getAtAddress()));
+			return;
+		}
+
+		ATData atData = null;
+		CrossChainTradeData tradeData = null;
+
+		if (tradeBotState.requiresAtData) {
+			// Attempt to fetch AT data
+			atData = repository.getATRepository().fromATAddress(tradeBotData.getAtAddress());
+			if (atData == null) {
+				LOGGER.debug(() -> String.format("Unable to fetch trade AT %s from repository", tradeBotData.getAtAddress()));
+				return;
+			}
+
+			if (tradeBotState.requiresTradeData) {
+				tradeData = PirateChainACCTv3.getInstance().populateTradeData(repository, atData);
+				if (tradeData == null) {
+					LOGGER.warn(() -> String.format("Unable to fetch ACCT trade data for AT %s from repository", tradeBotData.getAtAddress()));
+					return;
+				}
+			}
+		}
+
+		switch (tradeBotState) {
+			case BOB_WAITING_FOR_AT_CONFIRM:
+				handleBobWaitingForAtConfirm(repository, tradeBotData);
+				break;
+
+			case BOB_WAITING_FOR_MESSAGE:
+				TradeBot.getInstance().updatePresence(repository, tradeBotData, tradeData);
+				handleBobWaitingForMessage(repository, tradeBotData, atData, tradeData);
+				break;
+
+			case ALICE_WAITING_FOR_AT_LOCK:
+				TradeBot.getInstance().updatePresence(repository, tradeBotData, tradeData);
+				handleAliceWaitingForAtLock(repository, tradeBotData, atData, tradeData);
+				break;
+
+			case BOB_WAITING_FOR_AT_REDEEM:
+				TradeBot.getInstance().updatePresence(repository, tradeBotData, tradeData);
+				handleBobWaitingForAtRedeem(repository, tradeBotData, atData, tradeData);
+				break;
+
+			case ALICE_DONE:
+			case BOB_DONE:
+				break;
+
+			case ALICE_REFUNDING_A:
+				TradeBot.getInstance().updatePresence(repository, tradeBotData, tradeData);
+				handleAliceRefundingP2shA(repository, tradeBotData, atData, tradeData);
+				break;
+
+			case ALICE_REFUNDED:
+			case BOB_REFUNDED:
+				break;
+		}
+	}
+
+	/**
+	 * Trade-bot is waiting for Bob's AT to deploy.
+	 * <p>
+	 * If AT is deployed, then trade-bot's next step is to wait for MESSAGE from Alice.
+	 */
+	private void handleBobWaitingForAtConfirm(Repository repository, TradeBotData tradeBotData) throws DataException {
+		if (!repository.getATRepository().exists(tradeBotData.getAtAddress())) {
+			if (NTP.getTime() - tradeBotData.getTimestamp() <= MAX_AT_CONFIRMATION_PERIOD)
+				return;
+
+			// We've waited ages for AT to be confirmed into a block but something has gone awry.
+			// After this long we assume transaction loss so give up with trade-bot entry too.
+			tradeBotData.setState(State.BOB_REFUNDED.name());
+			tradeBotData.setStateValue(State.BOB_REFUNDED.value);
+			tradeBotData.setTimestamp(NTP.getTime());
+			// We delete trade-bot entry here instead of saving, hence not using updateTradeBotState()
+			repository.getCrossChainRepository().delete(tradeBotData.getTradePrivateKey());
+			repository.saveChanges();
+
+			LOGGER.info(() -> String.format("AT %s never confirmed. Giving up on trade", tradeBotData.getAtAddress()));
+			TradeBot.notifyStateChange(tradeBotData);
+			return;
+		}
+
+		TradeBot.updateTradeBotState(repository, tradeBotData, State.BOB_WAITING_FOR_MESSAGE,
+				() -> String.format("AT %s confirmed ready. Waiting for trade message", tradeBotData.getAtAddress()));
+	}
+
+	/**
+	 * Trade-bot is waiting for MESSAGE from Alice's trade-bot, containing Alice's trade info.
+	 * <p>
+	 * It's possible Bob has cancelling his trade offer, receiving an automatic QORT refund,
+	 * in which case trade-bot is done with this specific trade and finalizes on refunded state.
+	 * <p>
+	 * Assuming trade is still on offer, trade-bot checks the contents of MESSAGE from Alice's trade-bot.
+	 * <p>
+	 * Details from Alice are used to derive P2SH-A address and this is checked for funding balance.
+	 * <p>
+	 * Assuming P2SH-A has at least expected PirateChain balance,
+	 * Bob's trade-bot constructs a zero-fee, PoW MESSAGE to send to Bob's AT with more trade details.
+	 * <p>
+	 * On processing this MESSAGE, Bob's AT should switch into 'TRADE' mode and only trade with Alice.
+	 * <p>
+	 * Trade-bot's next step is to wait for Alice to redeem the AT, which will allow Bob to
+	 * extract secret-A needed to redeem Alice's P2SH.
+	 * @throws ForeignBlockchainException
+	 */
+	private void handleBobWaitingForMessage(Repository repository, TradeBotData tradeBotData,
+			ATData atData, CrossChainTradeData crossChainTradeData) throws DataException, ForeignBlockchainException {
+		// If AT has finished then Bob likely cancelled his trade offer
+		if (atData.getIsFinished()) {
+			TradeBot.updateTradeBotState(repository, tradeBotData, State.BOB_REFUNDED,
+					() -> String.format("AT %s cancelled - trading aborted", tradeBotData.getAtAddress()));
+			return;
+		}
+
+		PirateChain pirateChain = PirateChain.getInstance();
+
+		String address = tradeBotData.getTradeNativeAddress();
+		List<MessageTransactionData> messageTransactionsData = repository.getMessageRepository().getMessagesByParticipants(null, address, null, null, null);
+
+		for (MessageTransactionData messageTransactionData : messageTransactionsData) {
+			if (messageTransactionData.isText())
+				continue;
+
+			// We're expecting: HASH160(secret-A), Alice's PirateChain pubkeyhash and lockTime-A
+			byte[] messageData = messageTransactionData.getData();
+			PirateChainACCTv3.OfferMessageData offerMessageData = PirateChainACCTv3.extractOfferMessageData(messageData);
+			if (offerMessageData == null)
+				continue;
+
+			byte[] aliceForeignPublicKey = offerMessageData.partnerPirateChainPublicKey;
+			byte[] hashOfSecretA = offerMessageData.hashOfSecretA;
+			int lockTimeA = (int) offerMessageData.lockTimeA;
+			long messageTimestamp = messageTransactionData.getTimestamp();
+			int refundTimeout = PirateChainACCTv3.calcRefundTimeout(messageTimestamp, lockTimeA);
+
+			// Determine P2SH-A address and confirm funded
+			byte[] redeemScriptA = PirateChainHTLC.buildScript(aliceForeignPublicKey, lockTimeA, tradeBotData.getTradeForeignPublicKey(), hashOfSecretA);
+			String p2shAddress = pirateChain.deriveP2shAddressBPrefix(redeemScriptA); // Use 'b' prefix when checking status
+
+			long feeTimestamp = calcFeeTimestamp(lockTimeA, crossChainTradeData.tradeTimeout);
+			long p2shFee = PirateChain.getInstance().getP2shFee(feeTimestamp);
+			final long minimumAmountA = tradeBotData.getForeignAmount() + p2shFee;
+
+			PirateChainHTLC.Status htlcStatusA = PirateChainHTLC.determineHtlcStatus(pirateChain.getBlockchainProvider(), p2shAddress, minimumAmountA);
+
+			switch (htlcStatusA) {
+				case UNFUNDED:
+				case FUNDING_IN_PROGRESS:
+					// There might be another MESSAGE from someone else with an actually funded P2SH-A...
+					continue;
+
+				case REDEEM_IN_PROGRESS:
+				case REDEEMED:
+					// We've already redeemed this?
+					TradeBot.updateTradeBotState(repository, tradeBotData, State.BOB_DONE,
+							() -> String.format("P2SH-A %s already spent? Assuming trade complete", p2shAddress));
+					return;
+
+				case REFUND_IN_PROGRESS:
+				case REFUNDED:
+					// This P2SH-A is burnt, but there might be another MESSAGE from someone else with an actually funded P2SH-A...
+					continue;
+
+				case FUNDED:
+					// Fall-through out of switch...
+					break;
+			}
+
+			// Good to go - send MESSAGE to AT
+
+			String aliceNativeAddress = Crypto.toAddress(messageTransactionData.getCreatorPublicKey());
+
+			// Build outgoing message, padding each part to 32 bytes to make it easier for AT to consume
+			byte[] outgoingMessageData = PirateChainACCTv3.buildTradeMessage(aliceNativeAddress, aliceForeignPublicKey, hashOfSecretA, lockTimeA, refundTimeout);
+			String messageRecipient = tradeBotData.getAtAddress();
+
+			boolean isMessageAlreadySent = repository.getMessageRepository().exists(tradeBotData.getTradeNativePublicKey(), messageRecipient, outgoingMessageData);
+			if (!isMessageAlreadySent) {
+				PrivateKeyAccount sender = new PrivateKeyAccount(repository, tradeBotData.getTradePrivateKey());
+				MessageTransaction outgoingMessageTransaction = MessageTransaction.build(repository, sender, Group.NO_GROUP, messageRecipient, outgoingMessageData, false, false);
+
+				outgoingMessageTransaction.computeNonce();
+				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()));
+					return;
+				}
+			}
+
+			TradeBot.updateTradeBotState(repository, tradeBotData, State.BOB_WAITING_FOR_AT_REDEEM,
+					() -> String.format("Locked AT %s to %s. Waiting for AT redeem", tradeBotData.getAtAddress(), aliceNativeAddress));
+
+			return;
+		}
+	}
+
+	/**
+	 * Trade-bot is waiting for Bob's AT to switch to TRADE mode and lock trade to Alice only.
+	 * <p>
+	 * It's possible that Bob has cancelled his trade offer in the mean time, or that somehow
+	 * this process has taken so long that we've reached P2SH-A's locktime, or that someone else
+	 * has managed to trade with Bob. In any of these cases, trade-bot switches to begin the refunding process.
+	 * <p>
+	 * Assuming Bob's AT is locked to Alice, trade-bot checks AT's state data to make sure it is correct.
+	 * <p>
+	 * If all is well, trade-bot then redeems AT using Alice's secret-A, releasing Bob's QORT to Alice.
+	 * <p>
+	 * In revealing a valid secret-A, Bob can then redeem the ARRR funds from P2SH-A.
+	 * <p>
+	 * @throws ForeignBlockchainException
+	 */
+	private void handleAliceWaitingForAtLock(Repository repository, TradeBotData tradeBotData,
+			ATData atData, CrossChainTradeData crossChainTradeData) throws DataException, ForeignBlockchainException {
+		if (aliceUnexpectedState(repository, tradeBotData, atData, crossChainTradeData))
+			return;
+
+		PirateChain pirateChain = PirateChain.getInstance();
+		int lockTimeA = tradeBotData.getLockTimeA();
+
+		// Refund P2SH-A if we've passed lockTime-A
+		if (NTP.getTime() >= lockTimeA * 1000L) {
+			byte[] redeemScriptA = PirateChainHTLC.buildScript(tradeBotData.getTradeForeignPublicKey(), lockTimeA, crossChainTradeData.creatorForeignPKH, tradeBotData.getHashOfSecret());
+			String p2shAddress = pirateChain.deriveP2shAddressBPrefix(redeemScriptA); // Use 'b' prefix when checking status
+
+			long feeTimestamp = calcFeeTimestamp(lockTimeA, crossChainTradeData.tradeTimeout);
+			long p2shFee = PirateChain.getInstance().getP2shFee(feeTimestamp);
+			long minimumAmountA = crossChainTradeData.expectedForeignAmount + p2shFee;
+
+			PirateChainHTLC.Status htlcStatusA = PirateChainHTLC.determineHtlcStatus(pirateChain.getBlockchainProvider(), p2shAddress, minimumAmountA);
+
+			switch (htlcStatusA) {
+				case UNFUNDED:
+				case FUNDING_IN_PROGRESS:
+				case FUNDED:
+					break;
+
+				case REDEEM_IN_PROGRESS:
+				case REDEEMED:
+					// Already redeemed?
+					TradeBot.updateTradeBotState(repository, tradeBotData, State.ALICE_DONE,
+							() -> String.format("P2SH-A %s already spent? Assuming trade completed", p2shAddress));
+					return;
+
+				case REFUND_IN_PROGRESS:
+				case REFUNDED:
+					TradeBot.updateTradeBotState(repository, tradeBotData, State.ALICE_REFUNDED,
+							() -> String.format("P2SH-A %s already refunded. Trade aborted", p2shAddress));
+					return;
+
+			}
+
+			TradeBot.updateTradeBotState(repository, tradeBotData, State.ALICE_REFUNDING_A,
+					() -> atData.getIsFinished()
+					? String.format("AT %s cancelled. Refunding P2SH-A %s - aborting trade", tradeBotData.getAtAddress(), p2shAddress)
+					: String.format("LockTime-A reached, refunding P2SH-A %s - aborting trade", p2shAddress));
+
+			return;
+		}
+
+		// We're waiting for AT to be in TRADE mode
+		if (crossChainTradeData.mode != AcctMode.TRADING)
+			return;
+
+		// AT is in TRADE mode and locked to us as checked by aliceUnexpectedState() above
+
+		// Find our MESSAGE to AT from previous state
+		List<MessageTransactionData> messageTransactionsData = repository.getMessageRepository().getMessagesByParticipants(tradeBotData.getTradeNativePublicKey(),
+				crossChainTradeData.qortalCreatorTradeAddress, null, null, null);
+		if (messageTransactionsData == null || messageTransactionsData.isEmpty()) {
+			LOGGER.warn(() -> String.format("Unable to find our message to trade creator %s?", crossChainTradeData.qortalCreatorTradeAddress));
+			return;
+		}
+
+		long recipientMessageTimestamp = messageTransactionsData.get(0).getTimestamp();
+		int refundTimeout = PirateChainACCTv3.calcRefundTimeout(recipientMessageTimestamp, lockTimeA);
+
+		// Our calculated refundTimeout should match AT's refundTimeout
+		if (refundTimeout != crossChainTradeData.refundTimeout) {
+			LOGGER.debug(() -> String.format("Trade AT refundTimeout '%d' doesn't match our refundTimeout '%d'", crossChainTradeData.refundTimeout, refundTimeout));
+			// We'll eventually refund
+			return;
+		}
+
+		// We're good to redeem AT
+
+		// Send 'redeem' MESSAGE to AT using both secret
+		byte[] secretA = tradeBotData.getSecret();
+		String qortalReceivingAddress = Base58.encode(tradeBotData.getReceivingAccountInfo()); // Actually contains whole address, not just PKH
+		byte[] messageData = PirateChainACCTv3.buildRedeemMessage(secretA, qortalReceivingAddress);
+		String messageRecipient = tradeBotData.getAtAddress();
+
+		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);
+
+			messageTransaction.computeNonce();
+			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()));
+				return;
+			}
+		}
+
+		TradeBot.updateTradeBotState(repository, tradeBotData, State.ALICE_DONE,
+				() -> String.format("Redeeming AT %s. Funds should arrive at %s",
+						tradeBotData.getAtAddress(), qortalReceivingAddress));
+	}
+
+	/**
+	 * Trade-bot is waiting for Alice to redeem Bob's AT, thus revealing secret-A which is required to spend the ARRR funds from P2SH-A.
+	 * <p>
+	 * It's possible that Bob's AT has reached its trading timeout and automatically refunded QORT back to Bob. In which case,
+	 * trade-bot is done with this specific trade and finalizes in refunded state.
+	 * <p>
+	 * Assuming trade-bot can extract a valid secret-A from Alice's MESSAGE then trade-bot uses that to redeem the ARRR funds from P2SH-A
+	 * to Bob's 'foreign'/PirateChain trade legacy-format address, as derived from trade private key.
+	 * <p>
+	 * (This could potentially be 'improved' to send ARRR to any address of Bob's choosing by changing the transaction output).
+	 * <p>
+	 * If trade-bot successfully broadcasts the transaction, then this specific trade is done.
+	 * @throws ForeignBlockchainException
+	 */
+	private void handleBobWaitingForAtRedeem(Repository repository, TradeBotData tradeBotData,
+			ATData atData, CrossChainTradeData crossChainTradeData) throws DataException, ForeignBlockchainException {
+		// AT should be 'finished' once Alice has redeemed QORT funds
+		if (!atData.getIsFinished())
+			// Not finished yet
+			return;
+
+		// If AT is REFUNDED or CANCELLED then something has gone wrong
+		if (crossChainTradeData.mode == AcctMode.REFUNDED || crossChainTradeData.mode == AcctMode.CANCELLED) {
+			// Alice hasn't redeemed the QORT, so there is no point in trying to redeem the ARRR
+			TradeBot.updateTradeBotState(repository, tradeBotData, State.BOB_REFUNDED,
+					() -> String.format("AT %s has auto-refunded - trade aborted", tradeBotData.getAtAddress()));
+
+			return;
+		}
+
+		byte[] secretA = PirateChainACCTv3.getInstance().findSecretA(repository, crossChainTradeData);
+		if (secretA == null) {
+			LOGGER.debug(() -> String.format("Unable to find secret-A from redeem message to AT %s?", tradeBotData.getAtAddress()));
+			return;
+		}
+
+		// Use secret-A to redeem P2SH-A
+
+		PirateChain pirateChain = PirateChain.getInstance();
+
+		byte[] receivingAccountInfo = tradeBotData.getReceivingAccountInfo();
+		int lockTimeA = crossChainTradeData.lockTimeA;
+		byte[] redeemScriptA = PirateChainHTLC.buildScript(crossChainTradeData.partnerForeignPKH, lockTimeA, crossChainTradeData.creatorForeignPKH, crossChainTradeData.hashOfSecretA);
+		String p2shAddress = pirateChain.deriveP2shAddressBPrefix(redeemScriptA); // Use 'b' prefix when checking status
+		String p2shAddressT3 = pirateChain.deriveP2shAddress(redeemScriptA); // Use 't3' prefix when refunding
+
+		// Fee for redeem/refund is subtracted from P2SH-A balance.
+		long feeTimestamp = calcFeeTimestamp(lockTimeA, crossChainTradeData.tradeTimeout);
+		long p2shFee = PirateChain.getInstance().getP2shFee(feeTimestamp);
+		long minimumAmountA = crossChainTradeData.expectedForeignAmount + p2shFee;
+		String receivingAddress = Bech32.encode("zs", receivingAccountInfo);
+
+		PirateChainHTLC.Status htlcStatusA = PirateChainHTLC.determineHtlcStatus(pirateChain.getBlockchainProvider(), p2shAddress, minimumAmountA);
+
+		switch (htlcStatusA) {
+			case UNFUNDED:
+			case FUNDING_IN_PROGRESS:
+				// P2SH-A suddenly not funded? Our best bet at this point is to hope for AT auto-refund
+				return;
+
+			case REDEEM_IN_PROGRESS:
+			case REDEEMED:
+				// Double-check that we have redeemed P2SH-A...
+				break;
+
+			case REFUND_IN_PROGRESS:
+			case REFUNDED:
+				// Wait for AT to auto-refund
+				return;
+
+			case FUNDED: {
+				// Get funding txid
+				String fundingTxidHex = PirateChainHTLC.getUnspentFundingTxid(pirateChain.getBlockchainProvider(), p2shAddress, minimumAmountA);
+				if (fundingTxidHex == null) {
+					throw new ForeignBlockchainException("Missing funding txid when redeeming P2SH");
+				}
+				String fundingTxid58 = Base58.encode(HashCode.fromString(fundingTxidHex).asBytes());
+
+				// Redeem P2SH
+				Coin redeemAmount = Coin.valueOf(crossChainTradeData.expectedForeignAmount);
+				byte[] privateKey = tradeBotData.getTradePrivateKey();
+				String secret58 = Base58.encode(secretA);
+				String privateKey58 = Base58.encode(privateKey);
+				String redeemScript58 = Base58.encode(redeemScriptA);
+
+				String txid = PirateChain.getInstance().redeemP2sh(p2shAddressT3, receivingAddress, redeemAmount.value,
+						redeemScript58, fundingTxid58, secret58, privateKey58);
+				LOGGER.info("Redeem txid: {}", txid);
+				break;
+			}
+		}
+
+		TradeBot.updateTradeBotState(repository, tradeBotData, State.BOB_DONE,
+				() -> String.format("P2SH-A %s redeemed. Funds should arrive at %s", tradeBotData.getAtAddress(), receivingAddress));
+	}
+
+	/**
+	 * Trade-bot is attempting to refund P2SH-A.
+	 * @throws ForeignBlockchainException
+	 */
+	private void handleAliceRefundingP2shA(Repository repository, TradeBotData tradeBotData,
+			ATData atData, CrossChainTradeData crossChainTradeData) throws DataException, ForeignBlockchainException {
+		int lockTimeA = tradeBotData.getLockTimeA();
+
+		// We can't refund P2SH-A until lockTime-A has passed
+		if (NTP.getTime() <= lockTimeA * 1000L)
+			return;
+
+		PirateChain pirateChain = PirateChain.getInstance();
+
+		// We can't refund P2SH-A until median block time has passed lockTime-A (see BIP113)
+		int medianBlockTime = pirateChain.getMedianBlockTime();
+		if (medianBlockTime <= lockTimeA)
+			return;
+
+		byte[] redeemScriptA = PirateChainHTLC.buildScript(tradeBotData.getTradeForeignPublicKey(), lockTimeA, crossChainTradeData.creatorForeignPKH, tradeBotData.getHashOfSecret());
+		String p2shAddress = pirateChain.deriveP2shAddressBPrefix(redeemScriptA); // Use 'b' prefix when checking status
+		String p2shAddressT3 = pirateChain.deriveP2shAddress(redeemScriptA); // Use 't3' prefix when refunding
+
+		// Fee for redeem/refund is subtracted from P2SH-A balance.
+		long feeTimestamp = calcFeeTimestamp(lockTimeA, crossChainTradeData.tradeTimeout);
+		long p2shFee = PirateChain.getInstance().getP2shFee(feeTimestamp);
+		long minimumAmountA = crossChainTradeData.expectedForeignAmount + p2shFee;
+		PirateChainHTLC.Status htlcStatusA = PirateChainHTLC.determineHtlcStatus(pirateChain.getBlockchainProvider(), p2shAddress, minimumAmountA);
+
+		switch (htlcStatusA) {
+			case UNFUNDED:
+			case FUNDING_IN_PROGRESS:
+				// Still waiting for P2SH-A to be funded...
+				return;
+
+			case REDEEM_IN_PROGRESS:
+			case REDEEMED:
+				// Too late!
+				TradeBot.updateTradeBotState(repository, tradeBotData, State.ALICE_DONE,
+						() -> String.format("P2SH-A %s already spent!", p2shAddress));
+				return;
+
+			case REFUND_IN_PROGRESS:
+			case REFUNDED:
+				break;
+
+			case FUNDED:{
+				// Get funding txid
+				String fundingTxidHex = PirateChainHTLC.getUnspentFundingTxid(pirateChain.getBlockchainProvider(), p2shAddress, minimumAmountA);
+				if (fundingTxidHex == null) {
+					throw new ForeignBlockchainException("Missing funding txid when refunding P2SH");
+				}
+				String fundingTxid58 = Base58.encode(HashCode.fromString(fundingTxidHex).asBytes());
+
+				Coin refundAmount = Coin.valueOf(crossChainTradeData.expectedForeignAmount);
+				byte[] privateKey = tradeBotData.getTradePrivateKey();
+				String privateKey58 = Base58.encode(privateKey);
+				String redeemScript58 = Base58.encode(redeemScriptA);
+				String receivingAddress = pirateChain.getWalletAddress(tradeBotData.getForeignKey());
+
+				String txid = PirateChain.getInstance().refundP2sh(p2shAddressT3,
+						receivingAddress, refundAmount.value, redeemScript58, fundingTxid58, lockTimeA, privateKey58);
+				LOGGER.info("Refund txid: {}", txid);
+				break;
+			}
+		}
+
+		TradeBot.updateTradeBotState(repository, tradeBotData, State.ALICE_REFUNDED,
+				() -> String.format("LockTime-A reached. Refunded P2SH-A %s. Trade aborted", p2shAddress));
+	}
+
+	/**
+	 * Returns true if Alice finds AT unexpectedly cancelled, refunded, redeemed or locked to someone else.
+	 * <p>
+	 * Will automatically update trade-bot state to <tt>ALICE_REFUNDING_A</tt> or <tt>ALICE_DONE</tt> as necessary.
+	 * 
+	 * @throws DataException
+	 * @throws ForeignBlockchainException
+	 */
+	private boolean aliceUnexpectedState(Repository repository, TradeBotData tradeBotData,
+			ATData atData, CrossChainTradeData crossChainTradeData) throws DataException, ForeignBlockchainException {
+		// This is OK
+		if (!atData.getIsFinished() && crossChainTradeData.mode == AcctMode.OFFERING)
+			return false;
+
+		boolean isAtLockedToUs = tradeBotData.getTradeNativeAddress().equals(crossChainTradeData.qortalPartnerAddress);
+
+		if (!atData.getIsFinished() && crossChainTradeData.mode == AcctMode.TRADING)
+			if (isAtLockedToUs) {
+				// AT is trading with us - OK
+				return false;
+			} else {
+				TradeBot.updateTradeBotState(repository, tradeBotData, State.ALICE_REFUNDING_A,
+						() -> String.format("AT %s trading with someone else: %s. Refunding & aborting trade", tradeBotData.getAtAddress(), crossChainTradeData.qortalPartnerAddress));
+
+				return true;
+			}
+
+		if (atData.getIsFinished() && crossChainTradeData.mode == AcctMode.REDEEMED && isAtLockedToUs) {
+			// We've redeemed already?
+			TradeBot.updateTradeBotState(repository, tradeBotData, State.ALICE_DONE,
+					() -> String.format("AT %s already redeemed by us. Trade completed", tradeBotData.getAtAddress()));
+		} else {
+			// Any other state is not good, so start defensive refund
+			TradeBot.updateTradeBotState(repository, tradeBotData, State.ALICE_REFUNDING_A,
+					() -> String.format("AT %s cancelled/refunded/redeemed by someone else/invalid state. Refunding & aborting trade", tradeBotData.getAtAddress()));
+		}
+
+		return true;
+	}
+
+	private long calcFeeTimestamp(int lockTimeA, int tradeTimeout) {
+		return (lockTimeA - tradeTimeout * 60) * 1000L;
+	}
+
+}

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

@@ -0,0 +1,885 @@
+package org.qortal.controller.tradebot;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.bitcoinj.core.*;
+import org.bitcoinj.script.Script.ScriptType;
+import org.qortal.account.PrivateKeyAccount;
+import org.qortal.account.PublicKeyAccount;
+import org.qortal.api.model.crosschain.TradeBotCreateRequest;
+import org.qortal.asset.Asset;
+import org.qortal.crosschain.*;
+import org.qortal.crypto.Crypto;
+import org.qortal.data.at.ATData;
+import org.qortal.data.crosschain.CrossChainTradeData;
+import org.qortal.data.crosschain.TradeBotData;
+import org.qortal.data.transaction.BaseTransactionData;
+import org.qortal.data.transaction.DeployAtTransactionData;
+import org.qortal.data.transaction.MessageTransactionData;
+import org.qortal.group.Group;
+import org.qortal.repository.DataException;
+import org.qortal.repository.Repository;
+import org.qortal.transaction.DeployAtTransaction;
+import org.qortal.transaction.MessageTransaction;
+import org.qortal.transaction.Transaction.ValidationResult;
+import org.qortal.transform.TransformationException;
+import org.qortal.transform.transaction.DeployAtTransactionTransformer;
+import org.qortal.utils.Base58;
+import org.qortal.utils.NTP;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import static java.util.Arrays.stream;
+import static java.util.stream.Collectors.toMap;
+
+/**
+ * Performing cross-chain trading steps on behalf of user.
+ * <p>
+ * We deal with three different independent state-spaces here:
+ * <ul>
+ * 	<li>Qortal blockchain</li>
+ * 	<li>Foreign blockchain</li>
+ * 	<li>Trade-bot entries</li>
+ * </ul>
+ */
+public class RavencoinACCTv3TradeBot implements AcctTradeBot {
+
+	private static final Logger LOGGER = LogManager.getLogger(RavencoinACCTv3TradeBot.class);
+
+	public enum State implements TradeBot.StateNameAndValueSupplier {
+		BOB_WAITING_FOR_AT_CONFIRM(10, false, false),
+		BOB_WAITING_FOR_MESSAGE(15, true, true),
+		BOB_WAITING_FOR_AT_REDEEM(25, true, true),
+		BOB_DONE(30, false, false),
+		BOB_REFUNDED(35, false, false),
+
+		ALICE_WAITING_FOR_AT_LOCK(85, true, true),
+		ALICE_DONE(95, false, false),
+		ALICE_REFUNDING_A(105, true, true),
+		ALICE_REFUNDED(110, false, false);
+
+		private static final Map<Integer, State> map = stream(State.values()).collect(toMap(state -> state.value, state -> state));
+
+		public final int value;
+		public final boolean requiresAtData;
+		public final boolean requiresTradeData;
+
+		State(int value, boolean requiresAtData, boolean requiresTradeData) {
+			this.value = value;
+			this.requiresAtData = requiresAtData;
+			this.requiresTradeData = requiresTradeData;
+		}
+
+		public static State valueOf(int value) {
+			return map.get(value);
+		}
+
+		@Override
+		public String getState() {
+			return this.name();
+		}
+
+		@Override
+		public int getStateValue() {
+			return this.value;
+		}
+	}
+
+	/** Maximum time Bob waits for his AT creation transaction to be confirmed into a block. (milliseconds) */
+	private static final long MAX_AT_CONFIRMATION_PERIOD = 24 * 60 * 60 * 1000L; // ms
+
+	private static RavencoinACCTv3TradeBot instance;
+
+	private final List<String> endStates = Arrays.asList(State.BOB_DONE, State.BOB_REFUNDED, State.ALICE_DONE, State.ALICE_REFUNDING_A, State.ALICE_REFUNDED).stream()
+			.map(State::name)
+			.collect(Collectors.toUnmodifiableList());
+
+	private RavencoinACCTv3TradeBot() {
+	}
+
+	public static synchronized RavencoinACCTv3TradeBot getInstance() {
+		if (instance == null)
+			instance = new RavencoinACCTv3TradeBot();
+
+		return instance;
+	}
+
+	@Override
+	public List<String> getEndStates() {
+		return this.endStates;
+	}
+
+	/**
+	 * Creates a new trade-bot entry from the "Bob" viewpoint, i.e. OFFERing QORT in exchange for RVN.
+	 * <p>
+	 * Generates:
+	 * <ul>
+	 * 	<li>new 'trade' private key</li>
+	 * </ul>
+	 * Derives:
+	 * <ul>
+	 * 	<li>'native' (as in Qortal) public key, public key hash, address (starting with Q)</li>
+	 * 	<li>'foreign' (as in Ravencoin) public key, public key hash</li>
+	 * </ul>
+	 * A Qortal AT is then constructed including the following as constants in the 'data segment':
+	 * <ul>
+	 * 	<li>'native'/Qortal 'trade' address - used as a MESSAGE contact</li>
+	 * 	<li>'foreign'/Ravencoin public key hash - used by Alice's P2SH scripts to allow redeem</li>
+	 * 	<li>QORT amount on offer by Bob</li>
+	 * 	<li>RVN amount expected in return by Bob (from Alice)</li>
+	 * 	<li>trading timeout, in case things go wrong and everyone needs to refund</li>
+	 * </ul>
+	 * Returns a DEPLOY_AT transaction that needs to be signed and broadcast to the Qortal network.
+	 * <p>
+	 * Trade-bot will wait for Bob's AT to be deployed before taking next step.
+	 * <p>
+	 * @param repository
+	 * @param tradeBotCreateRequest
+	 * @return raw, unsigned DEPLOY_AT transaction
+	 * @throws DataException
+	 */
+	public byte[] createTrade(Repository repository, TradeBotCreateRequest tradeBotCreateRequest) throws DataException {
+		byte[] tradePrivateKey = TradeBot.generateTradePrivateKey();
+
+		byte[] tradeNativePublicKey = TradeBot.deriveTradeNativePublicKey(tradePrivateKey);
+		byte[] tradeNativePublicKeyHash = Crypto.hash160(tradeNativePublicKey);
+		String tradeNativeAddress = Crypto.toAddress(tradeNativePublicKey);
+
+		byte[] tradeForeignPublicKey = TradeBot.deriveTradeForeignPublicKey(tradePrivateKey);
+		byte[] tradeForeignPublicKeyHash = Crypto.hash160(tradeForeignPublicKey);
+
+		// Convert Ravencoin receiving address into public key hash (we only support P2PKH at this time)
+		Address ravencoinReceivingAddress;
+		try {
+			ravencoinReceivingAddress = Address.fromString(Ravencoin.getInstance().getNetworkParameters(), tradeBotCreateRequest.receivingAddress);
+		} catch (AddressFormatException e) {
+			throw new DataException("Unsupported Ravencoin receiving address: " + tradeBotCreateRequest.receivingAddress);
+		}
+		if (ravencoinReceivingAddress.getOutputScriptType() != ScriptType.P2PKH)
+			throw new DataException("Unsupported Ravencoin receiving address: " + tradeBotCreateRequest.receivingAddress);
+
+		byte[] ravencoinReceivingAccountInfo = ravencoinReceivingAddress.getHash();
+
+		PublicKeyAccount creator = new PublicKeyAccount(repository, tradeBotCreateRequest.creatorPublicKey);
+
+		// Deploy AT
+		long timestamp = NTP.getTime();
+		byte[] reference = creator.getLastReference();
+		long fee = 0L;
+		byte[] signature = null;
+		BaseTransactionData baseTransactionData = new BaseTransactionData(timestamp, Group.NO_GROUP, reference, creator.getPublicKey(), fee, signature);
+
+		String name = "QORT/RVN ACCT";
+		String description = "QORT/RVN cross-chain trade";
+		String aTType = "ACCT";
+		String tags = "ACCT QORT RVN";
+		byte[] creationBytes = RavencoinACCTv3.buildQortalAT(tradeNativeAddress, tradeForeignPublicKeyHash, tradeBotCreateRequest.qortAmount,
+				tradeBotCreateRequest.foreignAmount, tradeBotCreateRequest.tradeTimeout);
+		long amount = tradeBotCreateRequest.fundingQortAmount;
+
+		DeployAtTransactionData deployAtTransactionData = new DeployAtTransactionData(baseTransactionData, name, description, aTType, tags, creationBytes, amount, Asset.QORT);
+
+		DeployAtTransaction deployAtTransaction = new DeployAtTransaction(repository, deployAtTransactionData);
+		fee = deployAtTransaction.calcRecommendedFee();
+		deployAtTransactionData.setFee(fee);
+
+		DeployAtTransaction.ensureATAddress(deployAtTransactionData);
+		String atAddress = deployAtTransactionData.getAtAddress();
+
+		TradeBotData tradeBotData =  new TradeBotData(tradePrivateKey, RavencoinACCTv3.NAME,
+				State.BOB_WAITING_FOR_AT_CONFIRM.name(), State.BOB_WAITING_FOR_AT_CONFIRM.value,
+				creator.getAddress(), atAddress, timestamp, tradeBotCreateRequest.qortAmount,
+				tradeNativePublicKey, tradeNativePublicKeyHash, tradeNativeAddress,
+				null, null,
+				SupportedBlockchain.RAVENCOIN.name(),
+				tradeForeignPublicKey, tradeForeignPublicKeyHash,
+				tradeBotCreateRequest.foreignAmount, null, null, null, ravencoinReceivingAccountInfo);
+
+		TradeBot.updateTradeBotState(repository, tradeBotData, () -> String.format("Built AT %s. Waiting for deployment", atAddress));
+
+		// Attempt to backup the trade bot data
+		TradeBot.backupTradeBotData(repository, null);
+
+		// Return to user for signing and broadcast as we don't have their Qortal private key
+		try {
+			return DeployAtTransactionTransformer.toBytes(deployAtTransactionData);
+		} catch (TransformationException e) {
+			throw new DataException("Failed to transform DEPLOY_AT transaction?", e);
+		}
+	}
+
+	/**
+	 * Creates a trade-bot entry from the 'Alice' viewpoint, i.e. matching RVN to an existing offer.
+	 * <p>
+	 * Requires a chosen trade offer from Bob, passed by <tt>crossChainTradeData</tt>
+	 * and access to a Ravencoin wallet via <tt>xprv58</tt>.
+	 * <p>
+	 * The <tt>crossChainTradeData</tt> contains the current trade offer state
+	 * as extracted from the AT's data segment.
+	 * <p>
+	 * Access to a funded wallet is via a Ravencoin BIP32 hierarchical deterministic key,
+	 * passed via <tt>xprv58</tt>.
+	 * <b>This key will be stored in your node's database</b>
+	 * to allow trade-bot to create/fund the necessary P2SH transactions!
+	 * However, due to the nature of BIP32 keys, it is possible to give the trade-bot
+	 * only a subset of wallet access (see BIP32 for more details).
+	 * <p>
+	 * As an example, the xprv58 can be extract from a <i>legacy, password-less</i>
+	 * Electrum wallet by going to the console tab and entering:<br>
+	 * <tt>wallet.keystore.xprv</tt><br>
+	 * which should result in a base58 string starting with either 'xprv' (for Ravencoin main-net)
+	 * or 'tprv' for (Ravencoin test-net).
+	 * <p>
+	 * It is envisaged that the value in <tt>xprv58</tt> will actually come from a Qortal-UI-managed wallet.
+	 * <p>
+	 * If sufficient funds are available, <b>this method will actually fund the P2SH-A</b>
+	 * with the Ravencoin amount expected by 'Bob'.
+	 * <p>
+	 * If the Ravencoin transaction is successfully broadcast to the network then
+	 * we also send a MESSAGE to Bob's trade-bot to let them know.
+	 * <p>
+	 * The trade-bot entry is saved to the repository and the cross-chain trading process commences.
+	 * <p>
+	 * @param repository
+	 * @param crossChainTradeData chosen trade OFFER that Alice wants to match
+	 * @param xprv58 funded wallet xprv in base58
+	 * @return true if P2SH-A funding transaction successfully broadcast to Ravencoin network, false otherwise
+	 * @throws DataException
+	 */
+	public ResponseResult startResponse(Repository repository, ATData atData, ACCT acct, CrossChainTradeData crossChainTradeData, String xprv58, String receivingAddress) throws DataException {
+		byte[] tradePrivateKey = TradeBot.generateTradePrivateKey();
+		byte[] secretA = TradeBot.generateSecret();
+		byte[] hashOfSecretA = Crypto.hash160(secretA);
+
+		byte[] tradeNativePublicKey = TradeBot.deriveTradeNativePublicKey(tradePrivateKey);
+		byte[] tradeNativePublicKeyHash = Crypto.hash160(tradeNativePublicKey);
+		String tradeNativeAddress = Crypto.toAddress(tradeNativePublicKey);
+
+		byte[] tradeForeignPublicKey = TradeBot.deriveTradeForeignPublicKey(tradePrivateKey);
+		byte[] tradeForeignPublicKeyHash = Crypto.hash160(tradeForeignPublicKey);
+		byte[] receivingPublicKeyHash = Base58.decode(receivingAddress); // Actually the whole address, not just PKH
+
+		// We need to generate lockTime-A: add tradeTimeout to now
+		long now = NTP.getTime();
+		int lockTimeA = crossChainTradeData.tradeTimeout * 60 + (int) (now / 1000L);
+
+		TradeBotData tradeBotData =  new TradeBotData(tradePrivateKey, RavencoinACCTv3.NAME,
+				State.ALICE_WAITING_FOR_AT_LOCK.name(), State.ALICE_WAITING_FOR_AT_LOCK.value,
+				receivingAddress, crossChainTradeData.qortalAtAddress, now, crossChainTradeData.qortAmount,
+				tradeNativePublicKey, tradeNativePublicKeyHash, tradeNativeAddress,
+				secretA, hashOfSecretA,
+				SupportedBlockchain.RAVENCOIN.name(),
+				tradeForeignPublicKey, tradeForeignPublicKeyHash,
+				crossChainTradeData.expectedForeignAmount, xprv58, null, lockTimeA, receivingPublicKeyHash);
+
+		// Attempt to backup the trade bot data
+		// Include tradeBotData as an additional parameter, since it's not in the repository yet
+		TradeBot.backupTradeBotData(repository, Arrays.asList(tradeBotData));
+
+		// Check we have enough funds via xprv58 to fund P2SH to cover expectedForeignAmount
+		long p2shFee;
+		try {
+			p2shFee = Ravencoin.getInstance().getP2shFee(now);
+		} catch (ForeignBlockchainException e) {
+			LOGGER.debug("Couldn't estimate Ravencoin fees?");
+			return ResponseResult.NETWORK_ISSUE;
+		}
+
+		// Fee for redeem/refund is subtracted from P2SH-A balance.
+		// Do not include fee for funding transaction as this is covered by buildSpend()
+		long amountA = crossChainTradeData.expectedForeignAmount + p2shFee /*redeeming/refunding P2SH-A*/;
+
+		// P2SH-A to be funded
+		byte[] redeemScriptBytes = BitcoinyHTLC.buildScript(tradeForeignPublicKeyHash, lockTimeA, crossChainTradeData.creatorForeignPKH, hashOfSecretA);
+		String p2shAddress = Ravencoin.getInstance().deriveP2shAddress(redeemScriptBytes);
+
+		// Build transaction for funding P2SH-A
+		Transaction p2shFundingTransaction = Ravencoin.getInstance().buildSpend(tradeBotData.getForeignKey(), p2shAddress, amountA);
+		if (p2shFundingTransaction == null) {
+			LOGGER.debug("Unable to build P2SH-A funding transaction - lack of funds?");
+			return ResponseResult.BALANCE_ISSUE;
+		}
+
+		try {
+			Ravencoin.getInstance().broadcastTransaction(p2shFundingTransaction);
+		} catch (ForeignBlockchainException e) {
+			// We couldn't fund P2SH-A at this time
+			LOGGER.debug("Couldn't broadcast P2SH-A funding transaction?");
+			return ResponseResult.NETWORK_ISSUE;
+		}
+
+		// Attempt to send MESSAGE to Bob's Qortal trade address
+		byte[] messageData = RavencoinACCTv3.buildOfferMessage(tradeBotData.getTradeForeignPublicKeyHash(), tradeBotData.getHashOfSecret(), tradeBotData.getLockTimeA());
+		String messageRecipient = crossChainTradeData.qortalCreatorTradeAddress;
+
+		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);
+
+			messageTransaction.computeNonce();
+			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 Bob's trade-bot %s: %s", messageRecipient, result.name()));
+				return ResponseResult.NETWORK_ISSUE;
+			}
+		}
+
+		TradeBot.updateTradeBotState(repository, tradeBotData, () -> String.format("Funding P2SH-A %s. Messaged Bob. Waiting for AT-lock", p2shAddress));
+
+		return ResponseResult.OK;
+	}
+
+	@Override
+	public boolean canDelete(Repository repository, TradeBotData tradeBotData) throws DataException {
+		State tradeBotState = State.valueOf(tradeBotData.getStateValue());
+		if (tradeBotState == null)
+			return true;
+
+		// If the AT doesn't exist then we might as well let the user tidy up
+		if (!repository.getATRepository().exists(tradeBotData.getAtAddress()))
+			return true;
+
+		switch (tradeBotState) {
+			case BOB_WAITING_FOR_AT_CONFIRM:
+			case ALICE_DONE:
+			case BOB_DONE:
+			case ALICE_REFUNDED:
+			case BOB_REFUNDED:
+			case ALICE_REFUNDING_A:
+				return true;
+
+			default:
+				return false;
+		}
+	}
+
+	@Override
+	public void progress(Repository repository, TradeBotData tradeBotData) throws DataException, ForeignBlockchainException {
+		State tradeBotState = State.valueOf(tradeBotData.getStateValue());
+		if (tradeBotState == null) {
+			LOGGER.info(() -> String.format("Trade-bot entry for AT %s has invalid state?", tradeBotData.getAtAddress()));
+			return;
+		}
+
+		ATData atData = null;
+		CrossChainTradeData tradeData = null;
+
+		if (tradeBotState.requiresAtData) {
+			// Attempt to fetch AT data
+			atData = repository.getATRepository().fromATAddress(tradeBotData.getAtAddress());
+			if (atData == null) {
+				LOGGER.debug(() -> String.format("Unable to fetch trade AT %s from repository", tradeBotData.getAtAddress()));
+				return;
+			}
+
+			if (tradeBotState.requiresTradeData) {
+				tradeData = RavencoinACCTv3.getInstance().populateTradeData(repository, atData);
+				if (tradeData == null) {
+					LOGGER.warn(() -> String.format("Unable to fetch ACCT trade data for AT %s from repository", tradeBotData.getAtAddress()));
+					return;
+				}
+			}
+		}
+
+		switch (tradeBotState) {
+			case BOB_WAITING_FOR_AT_CONFIRM:
+				handleBobWaitingForAtConfirm(repository, tradeBotData);
+				break;
+
+			case BOB_WAITING_FOR_MESSAGE:
+				TradeBot.getInstance().updatePresence(repository, tradeBotData, tradeData);
+				handleBobWaitingForMessage(repository, tradeBotData, atData, tradeData);
+				break;
+
+			case ALICE_WAITING_FOR_AT_LOCK:
+				TradeBot.getInstance().updatePresence(repository, tradeBotData, tradeData);
+				handleAliceWaitingForAtLock(repository, tradeBotData, atData, tradeData);
+				break;
+
+			case BOB_WAITING_FOR_AT_REDEEM:
+				TradeBot.getInstance().updatePresence(repository, tradeBotData, tradeData);
+				handleBobWaitingForAtRedeem(repository, tradeBotData, atData, tradeData);
+				break;
+
+			case ALICE_DONE:
+			case BOB_DONE:
+				break;
+
+			case ALICE_REFUNDING_A:
+				TradeBot.getInstance().updatePresence(repository, tradeBotData, tradeData);
+				handleAliceRefundingP2shA(repository, tradeBotData, atData, tradeData);
+				break;
+
+			case ALICE_REFUNDED:
+			case BOB_REFUNDED:
+				break;
+		}
+	}
+
+	/**
+	 * Trade-bot is waiting for Bob's AT to deploy.
+	 * <p>
+	 * If AT is deployed, then trade-bot's next step is to wait for MESSAGE from Alice.
+	 */
+	private void handleBobWaitingForAtConfirm(Repository repository, TradeBotData tradeBotData) throws DataException {
+		if (!repository.getATRepository().exists(tradeBotData.getAtAddress())) {
+			if (NTP.getTime() - tradeBotData.getTimestamp() <= MAX_AT_CONFIRMATION_PERIOD)
+				return;
+
+			// We've waited ages for AT to be confirmed into a block but something has gone awry.
+			// After this long we assume transaction loss so give up with trade-bot entry too.
+			tradeBotData.setState(State.BOB_REFUNDED.name());
+			tradeBotData.setStateValue(State.BOB_REFUNDED.value);
+			tradeBotData.setTimestamp(NTP.getTime());
+			// We delete trade-bot entry here instead of saving, hence not using updateTradeBotState()
+			repository.getCrossChainRepository().delete(tradeBotData.getTradePrivateKey());
+			repository.saveChanges();
+
+			LOGGER.info(() -> String.format("AT %s never confirmed. Giving up on trade", tradeBotData.getAtAddress()));
+			TradeBot.notifyStateChange(tradeBotData);
+			return;
+		}
+
+		TradeBot.updateTradeBotState(repository, tradeBotData, State.BOB_WAITING_FOR_MESSAGE,
+				() -> String.format("AT %s confirmed ready. Waiting for trade message", tradeBotData.getAtAddress()));
+	}
+
+	/**
+	 * Trade-bot is waiting for MESSAGE from Alice's trade-bot, containing Alice's trade info.
+	 * <p>
+	 * It's possible Bob has cancelling his trade offer, receiving an automatic QORT refund,
+	 * in which case trade-bot is done with this specific trade and finalizes on refunded state.
+	 * <p>
+	 * Assuming trade is still on offer, trade-bot checks the contents of MESSAGE from Alice's trade-bot.
+	 * <p>
+	 * Details from Alice are used to derive P2SH-A address and this is checked for funding balance.
+	 * <p>
+	 * Assuming P2SH-A has at least expected Ravencoin balance,
+	 * Bob's trade-bot constructs a zero-fee, PoW MESSAGE to send to Bob's AT with more trade details.
+	 * <p>
+	 * On processing this MESSAGE, Bob's AT should switch into 'TRADE' mode and only trade with Alice.
+	 * <p>
+	 * Trade-bot's next step is to wait for Alice to redeem the AT, which will allow Bob to
+	 * extract secret-A needed to redeem Alice's P2SH.
+	 * @throws ForeignBlockchainException
+	 */
+	private void handleBobWaitingForMessage(Repository repository, TradeBotData tradeBotData,
+			ATData atData, CrossChainTradeData crossChainTradeData) throws DataException, ForeignBlockchainException {
+		// If AT has finished then Bob likely cancelled his trade offer
+		if (atData.getIsFinished()) {
+			TradeBot.updateTradeBotState(repository, tradeBotData, State.BOB_REFUNDED,
+					() -> String.format("AT %s cancelled - trading aborted", tradeBotData.getAtAddress()));
+			return;
+		}
+
+		Ravencoin ravencoin = Ravencoin.getInstance();
+
+		String address = tradeBotData.getTradeNativeAddress();
+		List<MessageTransactionData> messageTransactionsData = repository.getMessageRepository().getMessagesByParticipants(null, address, null, null, null);
+
+		for (MessageTransactionData messageTransactionData : messageTransactionsData) {
+			if (messageTransactionData.isText())
+				continue;
+
+			// We're expecting: HASH160(secret-A), Alice's Ravencoin pubkeyhash and lockTime-A
+			byte[] messageData = messageTransactionData.getData();
+			RavencoinACCTv3.OfferMessageData offerMessageData = RavencoinACCTv3.extractOfferMessageData(messageData);
+			if (offerMessageData == null)
+				continue;
+
+			byte[] aliceForeignPublicKeyHash = offerMessageData.partnerRavencoinPKH;
+			byte[] hashOfSecretA = offerMessageData.hashOfSecretA;
+			int lockTimeA = (int) offerMessageData.lockTimeA;
+			long messageTimestamp = messageTransactionData.getTimestamp();
+			int refundTimeout = RavencoinACCTv3.calcRefundTimeout(messageTimestamp, lockTimeA);
+
+			// Determine P2SH-A address and confirm funded
+			byte[] redeemScriptA = BitcoinyHTLC.buildScript(aliceForeignPublicKeyHash, lockTimeA, tradeBotData.getTradeForeignPublicKeyHash(), hashOfSecretA);
+			String p2shAddressA = ravencoin.deriveP2shAddress(redeemScriptA);
+
+			long feeTimestamp = calcFeeTimestamp(lockTimeA, crossChainTradeData.tradeTimeout);
+			long p2shFee = Ravencoin.getInstance().getP2shFee(feeTimestamp);
+			final long minimumAmountA = tradeBotData.getForeignAmount() + p2shFee;
+
+			BitcoinyHTLC.Status htlcStatusA = BitcoinyHTLC.determineHtlcStatus(ravencoin.getBlockchainProvider(), p2shAddressA, minimumAmountA);
+
+			switch (htlcStatusA) {
+				case UNFUNDED:
+				case FUNDING_IN_PROGRESS:
+					// There might be another MESSAGE from someone else with an actually funded P2SH-A...
+					continue;
+
+				case REDEEM_IN_PROGRESS:
+				case REDEEMED:
+					// We've already redeemed this?
+					TradeBot.updateTradeBotState(repository, tradeBotData, State.BOB_DONE,
+							() -> String.format("P2SH-A %s already spent? Assuming trade complete", p2shAddressA));
+					return;
+
+				case REFUND_IN_PROGRESS:
+				case REFUNDED:
+					// This P2SH-A is burnt, but there might be another MESSAGE from someone else with an actually funded P2SH-A...
+					continue;
+
+				case FUNDED:
+					// Fall-through out of switch...
+					break;
+			}
+
+			// Good to go - send MESSAGE to AT
+
+			String aliceNativeAddress = Crypto.toAddress(messageTransactionData.getCreatorPublicKey());
+
+			// Build outgoing message, padding each part to 32 bytes to make it easier for AT to consume
+			byte[] outgoingMessageData = RavencoinACCTv3.buildTradeMessage(aliceNativeAddress, aliceForeignPublicKeyHash, hashOfSecretA, lockTimeA, refundTimeout);
+			String messageRecipient = tradeBotData.getAtAddress();
+
+			boolean isMessageAlreadySent = repository.getMessageRepository().exists(tradeBotData.getTradeNativePublicKey(), messageRecipient, outgoingMessageData);
+			if (!isMessageAlreadySent) {
+				PrivateKeyAccount sender = new PrivateKeyAccount(repository, tradeBotData.getTradePrivateKey());
+				MessageTransaction outgoingMessageTransaction = MessageTransaction.build(repository, sender, Group.NO_GROUP, messageRecipient, outgoingMessageData, false, false);
+
+				outgoingMessageTransaction.computeNonce();
+				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()));
+					return;
+				}
+			}
+
+			TradeBot.updateTradeBotState(repository, tradeBotData, State.BOB_WAITING_FOR_AT_REDEEM,
+					() -> String.format("Locked AT %s to %s. Waiting for AT redeem", tradeBotData.getAtAddress(), aliceNativeAddress));
+
+			return;
+		}
+	}
+
+	/**
+	 * Trade-bot is waiting for Bob's AT to switch to TRADE mode and lock trade to Alice only.
+	 * <p>
+	 * It's possible that Bob has cancelled his trade offer in the mean time, or that somehow
+	 * this process has taken so long that we've reached P2SH-A's locktime, or that someone else
+	 * has managed to trade with Bob. In any of these cases, trade-bot switches to begin the refunding process.
+	 * <p>
+	 * Assuming Bob's AT is locked to Alice, trade-bot checks AT's state data to make sure it is correct.
+	 * <p>
+	 * If all is well, trade-bot then redeems AT using Alice's secret-A, releasing Bob's QORT to Alice.
+	 * <p>
+	 * In revealing a valid secret-A, Bob can then redeem the RVN funds from P2SH-A.
+	 * <p>
+	 * @throws ForeignBlockchainException
+	 */
+	private void handleAliceWaitingForAtLock(Repository repository, TradeBotData tradeBotData,
+			ATData atData, CrossChainTradeData crossChainTradeData) throws DataException, ForeignBlockchainException {
+		if (aliceUnexpectedState(repository, tradeBotData, atData, crossChainTradeData))
+			return;
+
+		Ravencoin ravencoin = Ravencoin.getInstance();
+		int lockTimeA = tradeBotData.getLockTimeA();
+
+		// Refund P2SH-A if we've passed lockTime-A
+		if (NTP.getTime() >= lockTimeA * 1000L) {
+			byte[] redeemScriptA = BitcoinyHTLC.buildScript(tradeBotData.getTradeForeignPublicKeyHash(), lockTimeA, crossChainTradeData.creatorForeignPKH, tradeBotData.getHashOfSecret());
+			String p2shAddressA = ravencoin.deriveP2shAddress(redeemScriptA);
+
+			long feeTimestamp = calcFeeTimestamp(lockTimeA, crossChainTradeData.tradeTimeout);
+			long p2shFee = Ravencoin.getInstance().getP2shFee(feeTimestamp);
+			long minimumAmountA = crossChainTradeData.expectedForeignAmount + p2shFee;
+
+			BitcoinyHTLC.Status htlcStatusA = BitcoinyHTLC.determineHtlcStatus(ravencoin.getBlockchainProvider(), p2shAddressA, minimumAmountA);
+
+			switch (htlcStatusA) {
+				case UNFUNDED:
+				case FUNDING_IN_PROGRESS:
+				case FUNDED:
+					break;
+
+				case REDEEM_IN_PROGRESS:
+				case REDEEMED:
+					// Already redeemed?
+					TradeBot.updateTradeBotState(repository, tradeBotData, State.ALICE_DONE,
+							() -> String.format("P2SH-A %s already spent? Assuming trade completed", p2shAddressA));
+					return;
+
+				case REFUND_IN_PROGRESS:
+				case REFUNDED:
+					TradeBot.updateTradeBotState(repository, tradeBotData, State.ALICE_REFUNDED,
+							() -> String.format("P2SH-A %s already refunded. Trade aborted", p2shAddressA));
+					return;
+
+			}
+
+			TradeBot.updateTradeBotState(repository, tradeBotData, State.ALICE_REFUNDING_A,
+					() -> atData.getIsFinished()
+					? String.format("AT %s cancelled. Refunding P2SH-A %s - aborting trade", tradeBotData.getAtAddress(), p2shAddressA)
+					: String.format("LockTime-A reached, refunding P2SH-A %s - aborting trade", p2shAddressA));
+
+			return;
+		}
+
+		// We're waiting for AT to be in TRADE mode
+		if (crossChainTradeData.mode != AcctMode.TRADING)
+			return;
+
+		// AT is in TRADE mode and locked to us as checked by aliceUnexpectedState() above
+
+		// Find our MESSAGE to AT from previous state
+		List<MessageTransactionData> messageTransactionsData = repository.getMessageRepository().getMessagesByParticipants(tradeBotData.getTradeNativePublicKey(),
+				crossChainTradeData.qortalCreatorTradeAddress, null, null, null);
+		if (messageTransactionsData == null || messageTransactionsData.isEmpty()) {
+			LOGGER.warn(() -> String.format("Unable to find our message to trade creator %s?", crossChainTradeData.qortalCreatorTradeAddress));
+			return;
+		}
+
+		long recipientMessageTimestamp = messageTransactionsData.get(0).getTimestamp();
+		int refundTimeout = RavencoinACCTv3.calcRefundTimeout(recipientMessageTimestamp, lockTimeA);
+
+		// Our calculated refundTimeout should match AT's refundTimeout
+		if (refundTimeout != crossChainTradeData.refundTimeout) {
+			LOGGER.debug(() -> String.format("Trade AT refundTimeout '%d' doesn't match our refundTimeout '%d'", crossChainTradeData.refundTimeout, refundTimeout));
+			// We'll eventually refund
+			return;
+		}
+
+		// We're good to redeem AT
+
+		// Send 'redeem' MESSAGE to AT using both secret
+		byte[] secretA = tradeBotData.getSecret();
+		String qortalReceivingAddress = Base58.encode(tradeBotData.getReceivingAccountInfo()); // Actually contains whole address, not just PKH
+		byte[] messageData = RavencoinACCTv3.buildRedeemMessage(secretA, qortalReceivingAddress);
+		String messageRecipient = tradeBotData.getAtAddress();
+
+		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);
+
+			messageTransaction.computeNonce();
+			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()));
+				return;
+			}
+		}
+
+		TradeBot.updateTradeBotState(repository, tradeBotData, State.ALICE_DONE,
+				() -> String.format("Redeeming AT %s. Funds should arrive at %s",
+						tradeBotData.getAtAddress(), qortalReceivingAddress));
+	}
+
+	/**
+	 * Trade-bot is waiting for Alice to redeem Bob's AT, thus revealing secret-A which is required to spend the RVN funds from P2SH-A.
+	 * <p>
+	 * It's possible that Bob's AT has reached its trading timeout and automatically refunded QORT back to Bob. In which case,
+	 * trade-bot is done with this specific trade and finalizes in refunded state.
+	 * <p>
+	 * Assuming trade-bot can extract a valid secret-A from Alice's MESSAGE then trade-bot uses that to redeem the RVN funds from P2SH-A
+	 * to Bob's 'foreign'/Ravencoin trade legacy-format address, as derived from trade private key.
+	 * <p>
+	 * (This could potentially be 'improved' to send RVN to any address of Bob's choosing by changing the transaction output).
+	 * <p>
+	 * If trade-bot successfully broadcasts the transaction, then this specific trade is done.
+	 * @throws ForeignBlockchainException
+	 */
+	private void handleBobWaitingForAtRedeem(Repository repository, TradeBotData tradeBotData,
+			ATData atData, CrossChainTradeData crossChainTradeData) throws DataException, ForeignBlockchainException {
+		// AT should be 'finished' once Alice has redeemed QORT funds
+		if (!atData.getIsFinished())
+			// Not finished yet
+			return;
+
+		// If AT is REFUNDED or CANCELLED then something has gone wrong
+		if (crossChainTradeData.mode == AcctMode.REFUNDED || crossChainTradeData.mode == AcctMode.CANCELLED) {
+			// Alice hasn't redeemed the QORT, so there is no point in trying to redeem the RVN
+			TradeBot.updateTradeBotState(repository, tradeBotData, State.BOB_REFUNDED,
+					() -> String.format("AT %s has auto-refunded - trade aborted", tradeBotData.getAtAddress()));
+
+			return;
+		}
+
+		byte[] secretA = RavencoinACCTv3.getInstance().findSecretA(repository, crossChainTradeData);
+		if (secretA == null) {
+			LOGGER.debug(() -> String.format("Unable to find secret-A from redeem message to AT %s?", tradeBotData.getAtAddress()));
+			return;
+		}
+
+		// Use secret-A to redeem P2SH-A
+
+		Ravencoin ravencoin = Ravencoin.getInstance();
+
+		byte[] receivingAccountInfo = tradeBotData.getReceivingAccountInfo();
+		int lockTimeA = crossChainTradeData.lockTimeA;
+		byte[] redeemScriptA = BitcoinyHTLC.buildScript(crossChainTradeData.partnerForeignPKH, lockTimeA, crossChainTradeData.creatorForeignPKH, crossChainTradeData.hashOfSecretA);
+		String p2shAddressA = ravencoin.deriveP2shAddress(redeemScriptA);
+
+		// Fee for redeem/refund is subtracted from P2SH-A balance.
+		long feeTimestamp = calcFeeTimestamp(lockTimeA, crossChainTradeData.tradeTimeout);
+		long p2shFee = Ravencoin.getInstance().getP2shFee(feeTimestamp);
+		long minimumAmountA = crossChainTradeData.expectedForeignAmount + p2shFee;
+		BitcoinyHTLC.Status htlcStatusA = BitcoinyHTLC.determineHtlcStatus(ravencoin.getBlockchainProvider(), p2shAddressA, minimumAmountA);
+
+		switch (htlcStatusA) {
+			case UNFUNDED:
+			case FUNDING_IN_PROGRESS:
+				// P2SH-A suddenly not funded? Our best bet at this point is to hope for AT auto-refund
+				return;
+
+			case REDEEM_IN_PROGRESS:
+			case REDEEMED:
+				// Double-check that we have redeemed P2SH-A...
+				break;
+
+			case REFUND_IN_PROGRESS:
+			case REFUNDED:
+				// Wait for AT to auto-refund
+				return;
+
+			case FUNDED: {
+				Coin redeemAmount = Coin.valueOf(crossChainTradeData.expectedForeignAmount);
+				ECKey redeemKey = ECKey.fromPrivate(tradeBotData.getTradePrivateKey());
+				List<TransactionOutput> fundingOutputs = ravencoin.getUnspentOutputs(p2shAddressA);
+
+				Transaction p2shRedeemTransaction = BitcoinyHTLC.buildRedeemTransaction(ravencoin.getNetworkParameters(), redeemAmount, redeemKey,
+						fundingOutputs, redeemScriptA, secretA, receivingAccountInfo);
+
+				ravencoin.broadcastTransaction(p2shRedeemTransaction);
+				break;
+			}
+		}
+
+		String receivingAddress = ravencoin.pkhToAddress(receivingAccountInfo);
+
+		TradeBot.updateTradeBotState(repository, tradeBotData, State.BOB_DONE,
+				() -> String.format("P2SH-A %s redeemed. Funds should arrive at %s", tradeBotData.getAtAddress(), receivingAddress));
+	}
+
+	/**
+	 * Trade-bot is attempting to refund P2SH-A.
+	 * @throws ForeignBlockchainException
+	 */
+	private void handleAliceRefundingP2shA(Repository repository, TradeBotData tradeBotData,
+			ATData atData, CrossChainTradeData crossChainTradeData) throws DataException, ForeignBlockchainException {
+		int lockTimeA = tradeBotData.getLockTimeA();
+
+		// We can't refund P2SH-A until lockTime-A has passed
+		if (NTP.getTime() <= lockTimeA * 1000L)
+			return;
+
+		Ravencoin ravencoin = Ravencoin.getInstance();
+
+		// We can't refund P2SH-A until median block time has passed lockTime-A (see BIP113)
+		int medianBlockTime = ravencoin.getMedianBlockTime();
+		if (medianBlockTime <= lockTimeA)
+			return;
+
+		byte[] redeemScriptA = BitcoinyHTLC.buildScript(tradeBotData.getTradeForeignPublicKeyHash(), lockTimeA, crossChainTradeData.creatorForeignPKH, tradeBotData.getHashOfSecret());
+		String p2shAddressA = ravencoin.deriveP2shAddress(redeemScriptA);
+
+		// Fee for redeem/refund is subtracted from P2SH-A balance.
+		long feeTimestamp = calcFeeTimestamp(lockTimeA, crossChainTradeData.tradeTimeout);
+		long p2shFee = Ravencoin.getInstance().getP2shFee(feeTimestamp);
+		long minimumAmountA = crossChainTradeData.expectedForeignAmount + p2shFee;
+		BitcoinyHTLC.Status htlcStatusA = BitcoinyHTLC.determineHtlcStatus(ravencoin.getBlockchainProvider(), p2shAddressA, minimumAmountA);
+
+		switch (htlcStatusA) {
+			case UNFUNDED:
+			case FUNDING_IN_PROGRESS:
+				// Still waiting for P2SH-A to be funded...
+				return;
+
+			case REDEEM_IN_PROGRESS:
+			case REDEEMED:
+				// Too late!
+				TradeBot.updateTradeBotState(repository, tradeBotData, State.ALICE_DONE,
+						() -> String.format("P2SH-A %s already spent!", p2shAddressA));
+				return;
+
+			case REFUND_IN_PROGRESS:
+			case REFUNDED:
+				break;
+
+			case FUNDED:{
+				Coin refundAmount = Coin.valueOf(crossChainTradeData.expectedForeignAmount);
+				ECKey refundKey = ECKey.fromPrivate(tradeBotData.getTradePrivateKey());
+				List<TransactionOutput> fundingOutputs = ravencoin.getUnspentOutputs(p2shAddressA);
+
+				// Determine receive address for refund
+				String receiveAddress = ravencoin.getUnusedReceiveAddress(tradeBotData.getForeignKey());
+				Address receiving = Address.fromString(ravencoin.getNetworkParameters(), receiveAddress);
+
+				Transaction p2shRefundTransaction = BitcoinyHTLC.buildRefundTransaction(ravencoin.getNetworkParameters(), refundAmount, refundKey,
+						fundingOutputs, redeemScriptA, lockTimeA, receiving.getHash());
+
+				ravencoin.broadcastTransaction(p2shRefundTransaction);
+				break;
+			}
+		}
+
+		TradeBot.updateTradeBotState(repository, tradeBotData, State.ALICE_REFUNDED,
+				() -> String.format("LockTime-A reached. Refunded P2SH-A %s. Trade aborted", p2shAddressA));
+	}
+
+	/**
+	 * Returns true if Alice finds AT unexpectedly cancelled, refunded, redeemed or locked to someone else.
+	 * <p>
+	 * Will automatically update trade-bot state to <tt>ALICE_REFUNDING_A</tt> or <tt>ALICE_DONE</tt> as necessary.
+	 * 
+	 * @throws DataException
+	 * @throws ForeignBlockchainException
+	 */
+	private boolean aliceUnexpectedState(Repository repository, TradeBotData tradeBotData,
+			ATData atData, CrossChainTradeData crossChainTradeData) throws DataException, ForeignBlockchainException {
+		// This is OK
+		if (!atData.getIsFinished() && crossChainTradeData.mode == AcctMode.OFFERING)
+			return false;
+
+		boolean isAtLockedToUs = tradeBotData.getTradeNativeAddress().equals(crossChainTradeData.qortalPartnerAddress);
+
+		if (!atData.getIsFinished() && crossChainTradeData.mode == AcctMode.TRADING)
+			if (isAtLockedToUs) {
+				// AT is trading with us - OK
+				return false;
+			} else {
+				TradeBot.updateTradeBotState(repository, tradeBotData, State.ALICE_REFUNDING_A,
+						() -> String.format("AT %s trading with someone else: %s. Refunding & aborting trade", tradeBotData.getAtAddress(), crossChainTradeData.qortalPartnerAddress));
+
+				return true;
+			}
+
+		if (atData.getIsFinished() && crossChainTradeData.mode == AcctMode.REDEEMED && isAtLockedToUs) {
+			// We've redeemed already?
+			TradeBot.updateTradeBotState(repository, tradeBotData, State.ALICE_DONE,
+					() -> String.format("AT %s already redeemed by us. Trade completed", tradeBotData.getAtAddress()));
+		} else {
+			// Any other state is not good, so start defensive refund
+			TradeBot.updateTradeBotState(repository, tradeBotData, State.ALICE_REFUNDING_A,
+					() -> String.format("AT %s cancelled/refunded/redeemed by someone else/invalid state. Refunding & aborting trade", tradeBotData.getAtAddress()));
+		}
+
+		return true;
+	}
+
+	private long calcFeeTimestamp(int lockTimeA, int tradeTimeout) {
+		return (lockTimeA - tradeTimeout * 60) * 1000L;
+	}
+
+}

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

@@ -94,12 +94,16 @@ public class TradeBot implements Listener {
 	private static final Map<Class<? extends ACCT>, Supplier<AcctTradeBot>> acctTradeBotSuppliers = new HashMap<>();
 	static {
 		acctTradeBotSuppliers.put(BitcoinACCTv1.class, BitcoinACCTv1TradeBot::getInstance);
+		acctTradeBotSuppliers.put(BitcoinACCTv3.class, BitcoinACCTv3TradeBot::getInstance);
 		acctTradeBotSuppliers.put(LitecoinACCTv1.class, LitecoinACCTv1TradeBot::getInstance);
 		acctTradeBotSuppliers.put(LitecoinACCTv2.class, LitecoinACCTv2TradeBot::getInstance);
 		acctTradeBotSuppliers.put(LitecoinACCTv3.class, LitecoinACCTv3TradeBot::getInstance);
 		acctTradeBotSuppliers.put(DogecoinACCTv1.class, DogecoinACCTv1TradeBot::getInstance);
 		acctTradeBotSuppliers.put(DogecoinACCTv2.class, DogecoinACCTv2TradeBot::getInstance);
 		acctTradeBotSuppliers.put(DogecoinACCTv3.class, DogecoinACCTv3TradeBot::getInstance);
+		acctTradeBotSuppliers.put(DigibyteACCTv3.class, DigibyteACCTv3TradeBot::getInstance);
+		acctTradeBotSuppliers.put(RavencoinACCTv3.class, RavencoinACCTv3TradeBot::getInstance);
+		acctTradeBotSuppliers.put(PirateChainACCTv3.class, PirateChainACCTv3TradeBot::getInstance);
 	}
 
 	private static TradeBot instance;
@@ -239,6 +243,11 @@ public class TradeBot implements Listener {
 		if (!(event instanceof Synchronizer.NewChainTipEvent))
 			return;
 
+		// Don't process trade bots or broadcast presence timestamps if our chain is more than 60 minutes old
+		final Long minLatestBlockTimestamp = NTP.getTime() - (60 * 60 * 1000L);
+		if (!Controller.getInstance().isUpToDate(minLatestBlockTimestamp))
+			return;
+
 		synchronized (this) {
 			expireOldPresenceTimestamps();
 
@@ -284,14 +293,14 @@ public class TradeBot implements Listener {
 	}
 
 	public static byte[] deriveTradeNativePublicKey(byte[] privateKey) {
-		return PrivateKeyAccount.toPublicKey(privateKey);
+		return Crypto.toPublicKey(privateKey);
 	}
 
 	public static byte[] deriveTradeForeignPublicKey(byte[] privateKey) {
 		return ECKey.fromPrivate(privateKey).getPubKey();
 	}
 
-	/*package*/ static byte[] generateSecret() {
+	/*package*/ public static byte[] generateSecret() {
 		byte[] secret = new byte[32];
 		RANDOM.nextBytes(secret);
 		return secret;
@@ -397,7 +406,7 @@ public class TradeBot implements Listener {
 
 		long now = NTP.getTime();
 		long newExpiry = generateExpiry(now);
-		ByteArray pubkeyByteArray = ByteArray.of(tradeNativeAccount.getPublicKey());
+		ByteArray pubkeyByteArray = ByteArray.wrap(tradeNativeAccount.getPublicKey());
 
 		// If map entry's timestamp is missing, or within early renewal period, use the new expiry - otherwise use existing timestamp.
 		synchronized (this.ourTradePresenceTimestampsByPubkey) {
@@ -484,7 +493,7 @@ public class TradeBot implements Listener {
 		int knownCount = entriesUnknownToPeer.size();
 
 		for (TradePresenceData peersTradePresence : peersTradePresences) {
-			ByteArray pubkeyByteArray = ByteArray.of(peersTradePresence.getPublicKey());
+			ByteArray pubkeyByteArray = ByteArray.wrap(peersTradePresence.getPublicKey());
 
 			TradePresenceData ourEntry = entriesUnknownToPeer.get(pubkeyByteArray);
 
@@ -541,7 +550,7 @@ public class TradeBot implements Listener {
 					continue;
 				}
 
-				ByteArray pubkeyByteArray = ByteArray.of(peersTradePresence.getPublicKey());
+				ByteArray pubkeyByteArray = ByteArray.wrap(peersTradePresence.getPublicKey());
 
 				// Ignore if we've previously verified this timestamp+publickey combo or sent timestamp is older
 				TradePresenceData existingTradeData = this.safeAllTradePresencesByPubkey.get(pubkeyByteArray);
@@ -584,7 +593,7 @@ public class TradeBot implements Listener {
 					continue;
 				}
 
-				ByteArray atCodeHash = new ByteArray(atData.getCodeHash());
+				ByteArray atCodeHash = ByteArray.wrap(atData.getCodeHash());
 				Supplier<ACCT> acctSupplier = acctSuppliersByCodeHash.get(atCodeHash);
 				if (acctSupplier == null) {
 					LOGGER.trace("Ignoring trade presence {} from peer {} as AT isn't a known ACCT?",
@@ -637,7 +646,7 @@ public class TradeBot implements Listener {
 
 	public void bridgePresence(long timestamp, byte[] publicKey, byte[] signature, String atAddress) {
 		long expiry = generateExpiry(timestamp);
-		ByteArray pubkeyByteArray = ByteArray.of(publicKey);
+		ByteArray pubkeyByteArray = ByteArray.wrap(publicKey);
 
 		TradePresenceData fakeTradePresenceData = new TradePresenceData(expiry, publicKey, signature, atAddress);
 

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

@@ -7,6 +7,7 @@ import java.util.Map;
 
 import org.bitcoinj.core.Context;
 import org.bitcoinj.core.NetworkParameters;
+import org.bitcoinj.core.Transaction;
 import org.bitcoinj.params.MainNetParams;
 import org.bitcoinj.params.RegTestParams;
 import org.bitcoinj.params.TestNet3Params;
@@ -18,10 +19,12 @@ public class Bitcoin extends Bitcoiny {
 
 	public static final String CURRENCY_CODE = "BTC";
 
+	private static final long MINIMUM_ORDER_AMOUNT = 100000; // 0.001 BTC minimum order, due to high fees
+
 	// Temporary values until a dynamic fee system is written.
 	private static final long OLD_FEE_AMOUNT = 4_000L; // Not 5000 so that existing P2SH-B can output 1000, avoiding dust issue, leaving 4000 for fees.
 	private static final long NEW_FEE_TIMESTAMP = 1598280000000L; // milliseconds since epoch
-	private static final long NEW_FEE_AMOUNT = 10_000L;
+	private static final long NEW_FEE_AMOUNT = 6_000L;
 
 	private static final long NON_MAINNET_FEE = 1000L; // enough for TESTNET3 and should be OK for REGTEST
 
@@ -42,30 +45,40 @@ public class Bitcoin extends Bitcoiny {
 			public Collection<ElectrumX.Server> getServers() {
 				return Arrays.asList(
 						// Servers chosen on NO BASIS WHATSOEVER from various sources!
-						new Server("hodlers.beer", Server.ConnectionType.SSL, 50002),
-						new Server("btc.lastingcoin.net", Server.ConnectionType.SSL, 50002),
-						new Server("electrum.bitaroo.net", Server.ConnectionType.SSL, 50002),
-						new Server("bitcoin.grey.pw", Server.ConnectionType.SSL, 50002),
+						// 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.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),
+						new Server("104.248.139.211", 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("alviss.coinjoined.com", Server.ConnectionType.SSL, 50002),
-						new Server("btc.litepay.ch", Server.ConnectionType.SSL, 50002),
-						new Server("xtrum.com", Server.ConnectionType.SSL, 50002),
-						new Server("electrum.acinq.co", Server.ConnectionType.SSL, 50002),
-						new Server("caleb.vegas", Server.ConnectionType.SSL, 50002),
-						new Server("electrum.coinext.com.br", Server.ConnectionType.TCP, 50001),
-						new Server("korea.electrum-server.com", Server.ConnectionType.TCP, 50001),
-						new Server("eai.coincited.net", Server.ConnectionType.TCP, 50001),
-						new Server("electrum.coinext.com.br", Server.ConnectionType.SSL, 50002),
-						new Server("node1.btccuracao.com", Server.ConnectionType.SSL, 50002),
-						new Server("korea.electrum-server.com", Server.ConnectionType.SSL, 50002),
-						new Server("btce.iiiiiii.biz", Server.ConnectionType.SSL, 50002),
+						new Server("68.183.188.105", Server.ConnectionType.SSL, 50002),
 						new Server("bitcoin.lukechilds.co", Server.ConnectionType.SSL, 50002),
-						new Server("guichet.centure.cc", Server.ConnectionType.SSL, 50002),
-						new Server("electrumx.hodlwallet.com", Server.ConnectionType.SSL, 50002),
+						new Server("blkhub.net", Server.ConnectionType.SSL, 50002),
+						new Server("btc.lastingcoin.net", 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("prospero.bitsrc.net", Server.ConnectionType.SSL, 50002),
-						new Server("gd42.org", Server.ConnectionType.SSL, 50002),
-						new Server("electrum.pabu.io", Server.ConnectionType.SSL, 50002));
+						new Server("electrum.bitaroo.net", Server.ConnectionType.SSL, 50002),
+						new Server("electrumx.dev", Server.ConnectionType.SSL, 50002),
+						new Server("elx.bitske.com", Server.ConnectionType.SSL, 50002),
+						new Server("fortress.qtornado.com", Server.ConnectionType.SSL, 50002),
+						new Server("guichet.centure.cc", Server.ConnectionType.SSL, 50002),
+						new Server("kareoke.qoppa.org", Server.ConnectionType.SSL, 50002),
+						new Server("hodlers.beer", Server.ConnectionType.SSL, 50002),
+						new Server("node1.btccuracao.com", Server.ConnectionType.SSL, 50002),
+						new Server("xtrum.com", Server.ConnectionType.SSL, 50002));
 			}
 
 			@Override
@@ -161,6 +174,8 @@ public class Bitcoin extends Bitcoiny {
 			Context bitcoinjContext = new Context(bitcoinNet.getParams());
 
 			instance = new Bitcoin(bitcoinNet, electrumX, bitcoinjContext, CURRENCY_CODE);
+
+			electrumX.setBlockchain(instance);
 		}
 
 		return instance;
@@ -172,6 +187,11 @@ public class Bitcoin extends Bitcoiny {
 		instance = null;
 	}
 
+	@Override
+	public long getMinimumOrderAmount() {
+		return MINIMUM_ORDER_AMOUNT;
+	}
+
 	// Actual useful methods for use by other classes
 
 	/**
@@ -185,4 +205,17 @@ public class Bitcoin extends Bitcoiny {
 		return this.bitcoinNet.getP2shFee(timestamp);
 	}
 
+	/**
+ 	* Returns bitcoinj transaction sending <tt>amount</tt> to <tt>recipient</tt> using 20 sat/byte fee.
+ 	*
+ 	* @param xprv58 BIP32 private key
+ 	* @param recipient P2PKH address
+ 	* @param amount unscaled amount
+ 	* @return transaction, or null if insufficient funds
+ 	*/
+	@Override
+	public Transaction buildSpend(String xprv58, String recipient, long amount) {
+		return buildSpend(xprv58, recipient, amount, 20L);
+	}
+
 }

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

@@ -0,0 +1,858 @@
+package org.qortal.crosschain;
+
+import com.google.common.hash.HashCode;
+import com.google.common.primitives.Bytes;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.ciyam.at.*;
+import org.qortal.account.Account;
+import org.qortal.asset.Asset;
+import org.qortal.at.QortalFunctionCode;
+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.MessageTransactionData;
+import org.qortal.repository.DataException;
+import org.qortal.repository.Repository;
+import org.qortal.utils.Base58;
+import org.qortal.utils.BitTwiddling;
+
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.ciyam.at.OpCode.calcOffset;
+
+/**
+ * Cross-chain trade AT
+ * 
+ * <p>
+ * <ul>
+ * <li>Bob generates Bitcoin & Qortal 'trade' keys
+ * 		<ul>
+ * 			<li>private key required to sign P2SH redeem tx</li>
+ * 			<li>private key could be used to create 'secret' (e.g. double-SHA256)</li>
+ * 			<li>encrypted private key could be stored in Qortal AT for access by Bob from any node</li>
+ * 		</ul>
+ * </li>
+ * <li>Bob deploys Qortal AT
+ * 		<ul>
+ * 		</ul>
+ * </li>
+ * <li>Alice finds Qortal AT and wants to trade
+ * 		<ul>
+ * 			<li>Alice generates Bitcoin & Qortal 'trade' keys</li>
+ * 			<li>Alice funds Bitcoin P2SH-A</li>
+ * 			<li>Alice sends 'offer' MESSAGE to Bob from her Qortal trade address, containing:
+ * 				<ul>
+ * 					<li>hash-of-secret-A</li>
+ * 					<li>her 'trade' Bitcoin PKH</li>
+ * 				</ul>
+ * 			</li>
+ * 		</ul>
+ * </li>
+ * <li>Bob receives "offer" MESSAGE
+ * 		<ul>
+ * 			<li>Checks Alice's P2SH-A</li>
+ * 			<li>Sends 'trade' MESSAGE to Qortal AT from his trade address, containing:
+ * 				<ul>
+ * 					<li>Alice's trade Qortal address</li>
+ * 					<li>Alice's trade Bitcoin PKH</li>
+ * 					<li>hash-of-secret-A</li>
+ * 				</ul>
+ * 			</li>
+ * 		</ul>
+ * </li>
+ * <li>Alice checks Qortal AT to confirm it's locked to her
+ * 		<ul>
+ * 			<li>Alice sends 'redeem' MESSAGE to Qortal AT from her trade address, containing:
+ * 				<ul>
+ * 					<li>secret-A</li>
+ * 					<li>Qortal receiving address of her chosing</li>
+ * 				</ul>
+ * 			</li>
+ * 			<li>AT's QORT funds are sent to Qortal receiving address</li>
+ * 		</ul>
+ * </li>
+ * <li>Bob checks AT, extracts secret-A
+ * 		<ul>
+ * 			<li>Bob redeems P2SH-A using his Bitcoin trade key and secret-A</li>
+ * 			<li>P2SH-A BTC funds end up at Bitcoin address determined by redeem transaction output(s)</li>
+ * 		</ul>
+ * </li>
+ * </ul>
+ */
+public class BitcoinACCTv3 implements ACCT {
+
+	private static final Logger LOGGER = LogManager.getLogger(BitcoinACCTv3.class);
+
+	public static final String NAME = BitcoinACCTv3.class.getSimpleName();
+	public static final byte[] CODE_BYTES_HASH = HashCode.fromString("676fb9350708dafa054eb0262d655039e393c1eb4918ec582f8d45524c9b4860").asBytes(); // SHA256 of AT code bytes
+
+	public static final int SECRET_LENGTH = 32;
+
+	/** <b>Value</b> offset into AT segment where 'mode' variable (long) is stored. (Multiply by MachineState.VALUE_SIZE for byte offset). */
+	private static final int MODE_VALUE_OFFSET = 61;
+	/** <b>Byte</b> offset into AT state data where 'mode' variable (long) is stored. */
+	public static final int MODE_BYTE_OFFSET = MachineState.HEADER_LENGTH + (MODE_VALUE_OFFSET * MachineState.VALUE_SIZE);
+
+	public static class OfferMessageData {
+		public byte[] partnerBitcoinPKH;
+		public byte[] hashOfSecretA;
+		public long lockTimeA;
+	}
+	public static final int OFFER_MESSAGE_LENGTH = 20 /*partnerBitcoinPKH*/ + 20 /*hashOfSecretA*/ + 8 /*lockTimeA*/;
+	public static final int TRADE_MESSAGE_LENGTH = 32 /*partner's Qortal trade address (padded from 25 to 32)*/
+			+ 24 /*partner's Bitcoin PKH (padded from 20 to 24)*/
+			+ 8 /*AT trade timeout (minutes)*/
+			+ 24 /*hash of secret-A (padded from 20 to 24)*/
+			+ 8 /*lockTimeA*/;
+	public static final int REDEEM_MESSAGE_LENGTH = 32 /*secret-A*/ + 32 /*partner's Qortal receiving address padded from 25 to 32*/;
+	public static final int CANCEL_MESSAGE_LENGTH = 32 /*AT creator's Qortal address*/;
+
+	private static BitcoinACCTv3 instance;
+
+	private BitcoinACCTv3() {
+	}
+
+	public static synchronized BitcoinACCTv3 getInstance() {
+		if (instance == null)
+			instance = new BitcoinACCTv3();
+
+		return instance;
+	}
+
+	@Override
+	public byte[] getCodeBytesHash() {
+		return CODE_BYTES_HASH;
+	}
+
+	@Override
+	public int getModeByteOffset() {
+		return MODE_BYTE_OFFSET;
+	}
+
+	@Override
+	public ForeignBlockchain getBlockchain() {
+		return Bitcoin.getInstance();
+	}
+
+	/**
+	 * Returns Qortal AT creation bytes for cross-chain trading AT.
+	 * <p>
+	 * <tt>tradeTimeout</tt> (minutes) is the time window for the trade partner to send the
+	 * 32-byte secret to the AT, before the AT automatically refunds the AT's creator.
+	 * 
+	 * @param creatorTradeAddress AT creator's trade Qortal address
+	 * @param bitcoinPublicKeyHash 20-byte HASH160 of creator's trade Bitcoin public key
+	 * @param qortAmount how much QORT to pay trade partner if they send correct 32-byte secrets to AT
+	 * @param bitcoinAmount how much BTC the AT creator is expecting to trade
+	 * @param tradeTimeout suggested timeout for entire trade
+	 */
+	public static byte[] buildQortalAT(String creatorTradeAddress, byte[] bitcoinPublicKeyHash, long qortAmount, long bitcoinAmount, int tradeTimeout) {
+		if (bitcoinPublicKeyHash.length != 20)
+			throw new IllegalArgumentException("Bitcoin public key hash should be 20 bytes");
+
+		// Labels for data segment addresses
+		int addrCounter = 0;
+
+		// Constants (with corresponding dataByteBuffer.put*() calls below)
+
+		final int addrCreatorTradeAddress1 = addrCounter++;
+		final int addrCreatorTradeAddress2 = addrCounter++;
+		final int addrCreatorTradeAddress3 = addrCounter++;
+		final int addrCreatorTradeAddress4 = addrCounter++;
+
+		final int addrBitcoinPublicKeyHash = addrCounter;
+		addrCounter += 4;
+
+		final int addrQortAmount = addrCounter++;
+		final int addrBitcoinAmount = addrCounter++;
+		final int addrTradeTimeout = addrCounter++;
+
+		final int addrMessageTxnType = addrCounter++;
+		final int addrExpectedTradeMessageLength = addrCounter++;
+		final int addrExpectedRedeemMessageLength = addrCounter++;
+
+		final int addrCreatorAddressPointer = addrCounter++;
+		final int addrQortalPartnerAddressPointer = addrCounter++;
+		final int addrMessageSenderPointer = addrCounter++;
+
+		final int addrTradeMessagePartnerBitcoinPKHOffset = addrCounter++;
+		final int addrPartnerBitcoinPKHPointer = addrCounter++;
+		final int addrTradeMessageHashOfSecretAOffset = addrCounter++;
+		final int addrHashOfSecretAPointer = addrCounter++;
+
+		final int addrRedeemMessageReceivingAddressOffset = addrCounter++;
+
+		final int addrMessageDataPointer = addrCounter++;
+		final int addrMessageDataLength = addrCounter++;
+
+		final int addrPartnerReceivingAddressPointer = addrCounter++;
+
+		final int addrEndOfConstants = addrCounter;
+
+		// Variables
+
+		final int addrCreatorAddress1 = addrCounter++;
+		final int addrCreatorAddress2 = addrCounter++;
+		final int addrCreatorAddress3 = addrCounter++;
+		final int addrCreatorAddress4 = addrCounter++;
+
+		final int addrQortalPartnerAddress1 = addrCounter++;
+		final int addrQortalPartnerAddress2 = addrCounter++;
+		final int addrQortalPartnerAddress3 = addrCounter++;
+		final int addrQortalPartnerAddress4 = addrCounter++;
+
+		final int addrLockTimeA = addrCounter++;
+		final int addrRefundTimeout = addrCounter++;
+		final int addrRefundTimestamp = addrCounter++;
+		final int addrLastTxnTimestamp = addrCounter++;
+		final int addrBlockTimestamp = addrCounter++;
+		final int addrTxnType = addrCounter++;
+		final int addrResult = addrCounter++;
+
+		final int addrMessageSender1 = addrCounter++;
+		final int addrMessageSender2 = addrCounter++;
+		final int addrMessageSender3 = addrCounter++;
+		final int addrMessageSender4 = addrCounter++;
+
+		final int addrMessageLength = addrCounter++;
+
+		final int addrMessageData = addrCounter;
+		addrCounter += 4;
+
+		final int addrHashOfSecretA = addrCounter;
+		addrCounter += 4;
+
+		final int addrPartnerBitcoinPKH = addrCounter;
+		addrCounter += 4;
+
+		final int addrPartnerReceivingAddress = addrCounter;
+		addrCounter += 4;
+
+		final int addrMode = addrCounter++;
+		assert addrMode == MODE_VALUE_OFFSET : String.format("addrMode %d does not match MODE_VALUE_OFFSET %d", addrMode, MODE_VALUE_OFFSET);
+
+		// Data segment
+		ByteBuffer dataByteBuffer = ByteBuffer.allocate(addrCounter * MachineState.VALUE_SIZE);
+
+		// AT creator's trade Qortal address, decoded from Base58
+		assert dataByteBuffer.position() == addrCreatorTradeAddress1 * MachineState.VALUE_SIZE : "addrCreatorTradeAddress1 incorrect";
+		byte[] creatorTradeAddressBytes = Base58.decode(creatorTradeAddress);
+		dataByteBuffer.put(Bytes.ensureCapacity(creatorTradeAddressBytes, 32, 0));
+
+		// Bitcoin public key hash
+		assert dataByteBuffer.position() == addrBitcoinPublicKeyHash * MachineState.VALUE_SIZE : "addrBitcoinPublicKeyHash incorrect";
+		dataByteBuffer.put(Bytes.ensureCapacity(bitcoinPublicKeyHash, 32, 0));
+
+		// Redeem Qort amount
+		assert dataByteBuffer.position() == addrQortAmount * MachineState.VALUE_SIZE : "addrQortAmount incorrect";
+		dataByteBuffer.putLong(qortAmount);
+
+		// Expected Bitcoin amount
+		assert dataByteBuffer.position() == addrBitcoinAmount * MachineState.VALUE_SIZE : "addrBitcoinAmount incorrect";
+		dataByteBuffer.putLong(bitcoinAmount);
+
+		// Suggested trade timeout (minutes)
+		assert dataByteBuffer.position() == addrTradeTimeout * MachineState.VALUE_SIZE : "addrTradeTimeout incorrect";
+		dataByteBuffer.putLong(tradeTimeout);
+
+		// We're only interested in MESSAGE transactions
+		assert dataByteBuffer.position() == addrMessageTxnType * MachineState.VALUE_SIZE : "addrMessageTxnType incorrect";
+		dataByteBuffer.putLong(API.ATTransactionType.MESSAGE.value);
+
+		// Expected length of 'trade' MESSAGE data from AT creator
+		assert dataByteBuffer.position() == addrExpectedTradeMessageLength * MachineState.VALUE_SIZE : "addrExpectedTradeMessageLength incorrect";
+		dataByteBuffer.putLong(TRADE_MESSAGE_LENGTH);
+
+		// Expected length of 'redeem' MESSAGE data from trade partner
+		assert dataByteBuffer.position() == addrExpectedRedeemMessageLength * MachineState.VALUE_SIZE : "addrExpectedRedeemMessageLength incorrect";
+		dataByteBuffer.putLong(REDEEM_MESSAGE_LENGTH);
+
+		// Index into data segment of AT creator's address, used by GET_B_IND
+		assert dataByteBuffer.position() == addrCreatorAddressPointer * MachineState.VALUE_SIZE : "addrCreatorAddressPointer incorrect";
+		dataByteBuffer.putLong(addrCreatorAddress1);
+
+		// Index into data segment of partner's Qortal address, used by SET_B_IND
+		assert dataByteBuffer.position() == addrQortalPartnerAddressPointer * MachineState.VALUE_SIZE : "addrQortalPartnerAddressPointer incorrect";
+		dataByteBuffer.putLong(addrQortalPartnerAddress1);
+
+		// Index into data segment of (temporary) transaction's sender's address, used by GET_B_IND
+		assert dataByteBuffer.position() == addrMessageSenderPointer * MachineState.VALUE_SIZE : "addrMessageSenderPointer incorrect";
+		dataByteBuffer.putLong(addrMessageSender1);
+
+		// Offset into 'trade' MESSAGE data payload for extracting partner's Bitcoin PKH
+		assert dataByteBuffer.position() == addrTradeMessagePartnerBitcoinPKHOffset * MachineState.VALUE_SIZE : "addrTradeMessagePartnerBitcoinPKHOffset incorrect";
+		dataByteBuffer.putLong(32L);
+
+		// Index into data segment of partner's Bitcoin PKH, used by GET_B_IND
+		assert dataByteBuffer.position() == addrPartnerBitcoinPKHPointer * MachineState.VALUE_SIZE : "addrPartnerBitcoinPKHPointer incorrect";
+		dataByteBuffer.putLong(addrPartnerBitcoinPKH);
+
+		// Offset into 'trade' MESSAGE data payload for extracting hash-of-secret-A
+		assert dataByteBuffer.position() == addrTradeMessageHashOfSecretAOffset * MachineState.VALUE_SIZE : "addrTradeMessageHashOfSecretAOffset incorrect";
+		dataByteBuffer.putLong(64L);
+
+		// Index into data segment to hash of secret A, used by GET_B_IND
+		assert dataByteBuffer.position() == addrHashOfSecretAPointer * MachineState.VALUE_SIZE : "addrHashOfSecretAPointer incorrect";
+		dataByteBuffer.putLong(addrHashOfSecretA);
+
+		// Offset into 'redeem' MESSAGE data payload for extracting Qortal receiving address
+		assert dataByteBuffer.position() == addrRedeemMessageReceivingAddressOffset * MachineState.VALUE_SIZE : "addrRedeemMessageReceivingAddressOffset incorrect";
+		dataByteBuffer.putLong(32L);
+
+		// Source location and length for hashing any passed secret
+		assert dataByteBuffer.position() == addrMessageDataPointer * MachineState.VALUE_SIZE : "addrMessageDataPointer incorrect";
+		dataByteBuffer.putLong(addrMessageData);
+		assert dataByteBuffer.position() == addrMessageDataLength * MachineState.VALUE_SIZE : "addrMessageDataLength incorrect";
+		dataByteBuffer.putLong(32L);
+
+		// Pointer into data segment of where to save partner's receiving Qortal address, used by GET_B_IND
+		assert dataByteBuffer.position() == addrPartnerReceivingAddressPointer * MachineState.VALUE_SIZE : "addrPartnerReceivingAddressPointer incorrect";
+		dataByteBuffer.putLong(addrPartnerReceivingAddress);
+
+		assert dataByteBuffer.position() == addrEndOfConstants * MachineState.VALUE_SIZE : "dataByteBuffer position not at end of constants";
+
+		// Code labels
+		Integer labelRefund = null;
+
+		Integer labelTradeTxnLoop = null;
+		Integer labelCheckTradeTxn = null;
+		Integer labelCheckCancelTxn = null;
+		Integer labelNotTradeNorCancelTxn = null;
+		Integer labelCheckNonRefundTradeTxn = null;
+		Integer labelTradeTxnExtract = null;
+		Integer labelRedeemTxnLoop = null;
+		Integer labelCheckRedeemTxn = null;
+		Integer labelCheckRedeemTxnSender = null;
+		Integer labelPayout = null;
+
+		ByteBuffer codeByteBuffer = ByteBuffer.allocate(768);
+
+		// Two-pass version
+		for (int pass = 0; pass < 2; ++pass) {
+			codeByteBuffer.clear();
+
+			try {
+				/* Initialization */
+
+				// Use AT creation 'timestamp' as starting point for finding transactions sent to AT
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(FunctionCode.GET_CREATION_TIMESTAMP, addrLastTxnTimestamp));
+
+				// Load B register with AT creator's address so we can save it into addrCreatorAddress1-4
+				codeByteBuffer.put(OpCode.EXT_FUN.compile(FunctionCode.PUT_CREATOR_INTO_B));
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.GET_B_IND, addrCreatorAddressPointer));
+
+				// Set restart position to after this opcode
+				codeByteBuffer.put(OpCode.SET_PCS.compile());
+
+				/* Loop, waiting for message from AT creator's trade address containing trade partner details, or AT owner's address to cancel offer */
+
+				/* Transaction processing loop */
+				labelTradeTxnLoop = codeByteBuffer.position();
+
+				/* Sleep until message arrives */
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(QortalFunctionCode.SLEEP_UNTIL_MESSAGE.value, addrLastTxnTimestamp));
+
+				// Find next transaction (if any) to this AT since the last one (referenced by addrLastTxnTimestamp)
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.PUT_TX_AFTER_TIMESTAMP_INTO_A, addrLastTxnTimestamp));
+				// If no transaction found, A will be zero. If A is zero, set addrResult to 1, otherwise 0.
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(FunctionCode.CHECK_A_IS_ZERO, addrResult));
+				// If addrResult is zero (i.e. A is non-zero, transaction was found) then go check transaction
+				codeByteBuffer.put(OpCode.BZR_DAT.compile(addrResult, calcOffset(codeByteBuffer, labelCheckTradeTxn)));
+				// Stop and wait for next block
+				codeByteBuffer.put(OpCode.STP_IMD.compile());
+
+				/* Check transaction */
+				labelCheckTradeTxn = codeByteBuffer.position();
+
+				// Update our 'last found transaction's timestamp' using 'timestamp' from transaction
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(FunctionCode.GET_TIMESTAMP_FROM_TX_IN_A, addrLastTxnTimestamp));
+				// Extract transaction type (message/payment) from transaction and save type in addrTxnType
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(FunctionCode.GET_TYPE_FROM_TX_IN_A, addrTxnType));
+				// If transaction type is not MESSAGE type then go look for another transaction
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrTxnType, addrMessageTxnType, calcOffset(codeByteBuffer, labelTradeTxnLoop)));
+
+				/* Check transaction's sender. We're expecting AT creator's trade address for 'trade' message, or AT creator's own address for 'cancel' message. */
+
+				// Extract sender address from transaction into B register
+				codeByteBuffer.put(OpCode.EXT_FUN.compile(FunctionCode.PUT_ADDRESS_FROM_TX_IN_A_INTO_B));
+				// Save B register into data segment starting at addrMessageSender1 (as pointed to by addrMessageSenderPointer)
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.GET_B_IND, addrMessageSenderPointer));
+				// Compare each part of message sender's address with AT creator's trade address. If they don't match, check for cancel situation.
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender1, addrCreatorTradeAddress1, calcOffset(codeByteBuffer, labelCheckCancelTxn)));
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender2, addrCreatorTradeAddress2, calcOffset(codeByteBuffer, labelCheckCancelTxn)));
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender3, addrCreatorTradeAddress3, calcOffset(codeByteBuffer, labelCheckCancelTxn)));
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender4, addrCreatorTradeAddress4, calcOffset(codeByteBuffer, labelCheckCancelTxn)));
+				// Message sender's address matches AT creator's trade address so go process 'trade' message
+				codeByteBuffer.put(OpCode.JMP_ADR.compile(labelCheckNonRefundTradeTxn == null ? 0 : labelCheckNonRefundTradeTxn));
+
+				/* Checking message sender for possible cancel message */
+				labelCheckCancelTxn = codeByteBuffer.position();
+
+				// Compare each part of message sender's address with AT creator's address. If they don't match, look for another transaction.
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender1, addrCreatorAddress1, calcOffset(codeByteBuffer, labelNotTradeNorCancelTxn)));
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender2, addrCreatorAddress2, calcOffset(codeByteBuffer, labelNotTradeNorCancelTxn)));
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender3, addrCreatorAddress3, calcOffset(codeByteBuffer, labelNotTradeNorCancelTxn)));
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender4, addrCreatorAddress4, calcOffset(codeByteBuffer, labelNotTradeNorCancelTxn)));
+				// Partner address is AT creator's address, so cancel offer and finish.
+				codeByteBuffer.put(OpCode.SET_VAL.compile(addrMode, AcctMode.CANCELLED.value));
+				// We're finished forever (finishing auto-refunds remaining balance to AT creator)
+				codeByteBuffer.put(OpCode.FIN_IMD.compile());
+
+				/* Not trade nor cancel message */
+				labelNotTradeNorCancelTxn = codeByteBuffer.position();
+
+				// Loop to find another transaction
+				codeByteBuffer.put(OpCode.JMP_ADR.compile(labelTradeTxnLoop == null ? 0 : labelTradeTxnLoop));
+
+				/* Possible switch-to-trade-mode message */
+				labelCheckNonRefundTradeTxn = codeByteBuffer.position();
+
+				// Check 'trade' message we received has expected number of message bytes
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(QortalFunctionCode.GET_MESSAGE_LENGTH_FROM_TX_IN_A.value, addrMessageLength));
+				// If message length matches, branch to info extraction code
+				codeByteBuffer.put(OpCode.BEQ_DAT.compile(addrMessageLength, addrExpectedTradeMessageLength, calcOffset(codeByteBuffer, labelTradeTxnExtract)));
+				// Message length didn't match - go back to finding another 'trade' MESSAGE transaction
+				codeByteBuffer.put(OpCode.JMP_ADR.compile(labelTradeTxnLoop == null ? 0 : labelTradeTxnLoop));
+
+				/* Extracting info from 'trade' MESSAGE transaction */
+				labelTradeTxnExtract = codeByteBuffer.position();
+
+				// Extract message from transaction into B register
+				codeByteBuffer.put(OpCode.EXT_FUN.compile(FunctionCode.PUT_MESSAGE_FROM_TX_IN_A_INTO_B));
+				// Save B register into data segment starting at addrQortalPartnerAddress1 (as pointed to by addrQortalPartnerAddressPointer)
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.GET_B_IND, addrQortalPartnerAddressPointer));
+
+				// Extract trade partner's Bitcoin public key hash (PKH) from message into B
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(QortalFunctionCode.PUT_PARTIAL_MESSAGE_FROM_TX_IN_A_INTO_B.value, addrTradeMessagePartnerBitcoinPKHOffset));
+				// Store partner's Bitcoin PKH (we only really use values from B1-B3)
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.GET_B_IND, addrPartnerBitcoinPKHPointer));
+				// Extract AT trade timeout (minutes) (from B4)
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(FunctionCode.GET_B4, addrRefundTimeout));
+
+				// Grab next 32 bytes
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(QortalFunctionCode.PUT_PARTIAL_MESSAGE_FROM_TX_IN_A_INTO_B.value, addrTradeMessageHashOfSecretAOffset));
+
+				// Extract hash-of-secret-A (we only really use values from B1-B3)
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.GET_B_IND, addrHashOfSecretAPointer));
+				// Extract lockTime-A (from B4)
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(FunctionCode.GET_B4, addrLockTimeA));
+
+				// Calculate trade timeout refund 'timestamp' by adding addrRefundTimeout minutes to this transaction's 'timestamp', then save into addrRefundTimestamp
+				codeByteBuffer.put(OpCode.EXT_FUN_RET_DAT_2.compile(FunctionCode.ADD_MINUTES_TO_TIMESTAMP, addrRefundTimestamp, addrLastTxnTimestamp, addrRefundTimeout));
+
+				/* We are in 'trade mode' */
+				codeByteBuffer.put(OpCode.SET_VAL.compile(addrMode, AcctMode.TRADING.value));
+
+				// Set restart position to after this opcode
+				codeByteBuffer.put(OpCode.SET_PCS.compile());
+
+				/* Loop, waiting for trade timeout or 'redeem' MESSAGE from Qortal trade partner */
+
+				// Fetch current block 'timestamp'
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(FunctionCode.GET_BLOCK_TIMESTAMP, addrBlockTimestamp));
+				// If we're not past refund 'timestamp' then look for next transaction
+				codeByteBuffer.put(OpCode.BLT_DAT.compile(addrBlockTimestamp, addrRefundTimestamp, calcOffset(codeByteBuffer, labelRedeemTxnLoop)));
+				// We're past refund 'timestamp' so go refund everything back to AT creator
+				codeByteBuffer.put(OpCode.JMP_ADR.compile(labelRefund == null ? 0 : labelRefund));
+
+				/* Transaction processing loop */
+				labelRedeemTxnLoop = codeByteBuffer.position();
+
+				// Find next transaction to this AT since the last one (if any)
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.PUT_TX_AFTER_TIMESTAMP_INTO_A, addrLastTxnTimestamp));
+				// If no transaction found, A will be zero. If A is zero, set addrComparator to 1, otherwise 0.
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(FunctionCode.CHECK_A_IS_ZERO, addrResult));
+				// If addrResult is zero (i.e. A is non-zero, transaction was found) then go check transaction
+				codeByteBuffer.put(OpCode.BZR_DAT.compile(addrResult, calcOffset(codeByteBuffer, labelCheckRedeemTxn)));
+				// Stop and wait for next block
+				codeByteBuffer.put(OpCode.STP_IMD.compile());
+
+				/* Check transaction */
+				labelCheckRedeemTxn = codeByteBuffer.position();
+
+				// Update our 'last found transaction's timestamp' using 'timestamp' from transaction
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(FunctionCode.GET_TIMESTAMP_FROM_TX_IN_A, addrLastTxnTimestamp));
+				// Extract transaction type (message/payment) from transaction and save type in addrTxnType
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(FunctionCode.GET_TYPE_FROM_TX_IN_A, addrTxnType));
+				// If transaction type is not MESSAGE type then go look for another transaction
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrTxnType, addrMessageTxnType, calcOffset(codeByteBuffer, labelRedeemTxnLoop)));
+
+				/* Check message payload length */
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(QortalFunctionCode.GET_MESSAGE_LENGTH_FROM_TX_IN_A.value, addrMessageLength));
+				// If message length matches, branch to sender checking code
+				codeByteBuffer.put(OpCode.BEQ_DAT.compile(addrMessageLength, addrExpectedRedeemMessageLength, calcOffset(codeByteBuffer, labelCheckRedeemTxnSender)));
+				// Message length didn't match - go back to finding another 'redeem' MESSAGE transaction
+				codeByteBuffer.put(OpCode.JMP_ADR.compile(labelRedeemTxnLoop == null ? 0 : labelRedeemTxnLoop));
+
+				/* Check transaction's sender */
+				labelCheckRedeemTxnSender = codeByteBuffer.position();
+
+				// Extract sender address from transaction into B register
+				codeByteBuffer.put(OpCode.EXT_FUN.compile(FunctionCode.PUT_ADDRESS_FROM_TX_IN_A_INTO_B));
+				// Save B register into data segment starting at addrMessageSender1 (as pointed to by addrMessageSenderPointer)
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.GET_B_IND, addrMessageSenderPointer));
+				// Compare each part of transaction's sender's address with expected address. If they don't match, look for another transaction.
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender1, addrQortalPartnerAddress1, calcOffset(codeByteBuffer, labelRedeemTxnLoop)));
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender2, addrQortalPartnerAddress2, calcOffset(codeByteBuffer, labelRedeemTxnLoop)));
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender3, addrQortalPartnerAddress3, calcOffset(codeByteBuffer, labelRedeemTxnLoop)));
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender4, addrQortalPartnerAddress4, calcOffset(codeByteBuffer, labelRedeemTxnLoop)));
+
+				/* Check 'secret-A' in transaction's message */
+
+				// Extract secret-A from first 32 bytes of message from transaction into B register
+				codeByteBuffer.put(OpCode.EXT_FUN.compile(FunctionCode.PUT_MESSAGE_FROM_TX_IN_A_INTO_B));
+				// Save B register into data segment starting at addrMessageData (as pointed to by addrMessageDataPointer)
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.GET_B_IND, addrMessageDataPointer));
+				// Load B register with expected hash result (as pointed to by addrHashOfSecretAPointer)
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.SET_B_IND, addrHashOfSecretAPointer));
+				// Perform HASH160 using source data at addrMessageData. (Location and length specified via addrMessageDataPointer and addrMessageDataLength).
+				// Save the equality result (1 if they match, 0 otherwise) into addrResult.
+				codeByteBuffer.put(OpCode.EXT_FUN_RET_DAT_2.compile(FunctionCode.CHECK_HASH160_WITH_B, addrResult, addrMessageDataPointer, addrMessageDataLength));
+				// If hashes don't match, addrResult will be zero so go find another transaction
+				codeByteBuffer.put(OpCode.BNZ_DAT.compile(addrResult, calcOffset(codeByteBuffer, labelPayout)));
+				codeByteBuffer.put(OpCode.JMP_ADR.compile(labelRedeemTxnLoop == null ? 0 : labelRedeemTxnLoop));
+
+				/* Success! Pay arranged amount to receiving address */
+				labelPayout = codeByteBuffer.position();
+
+				// Extract Qortal receiving address from next 32 bytes of message from transaction into B register
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(QortalFunctionCode.PUT_PARTIAL_MESSAGE_FROM_TX_IN_A_INTO_B.value, addrRedeemMessageReceivingAddressOffset));
+				// Save B register into data segment starting at addrPartnerReceivingAddress (as pointed to by addrPartnerReceivingAddressPointer)
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.GET_B_IND, addrPartnerReceivingAddressPointer));
+				// Pay AT's balance to receiving address
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.PAY_TO_ADDRESS_IN_B, addrQortAmount));
+				// Set redeemed mode
+				codeByteBuffer.put(OpCode.SET_VAL.compile(addrMode, AcctMode.REDEEMED.value));
+				// We're finished forever (finishing auto-refunds remaining balance to AT creator)
+				codeByteBuffer.put(OpCode.FIN_IMD.compile());
+
+				// Fall-through to refunding any remaining balance back to AT creator
+
+				/* Refund balance back to AT creator */
+				labelRefund = codeByteBuffer.position();
+
+				/* NOP - to ensure BITCOIN ACCT is unique */
+				codeByteBuffer.put(OpCode.NOP.compile());
+
+				// Set refunded mode
+				codeByteBuffer.put(OpCode.SET_VAL.compile(addrMode, AcctMode.REFUNDED.value));
+				// We're finished forever (finishing auto-refunds remaining balance to AT creator)
+				codeByteBuffer.put(OpCode.FIN_IMD.compile());
+			} catch (CompilationException e) {
+				throw new IllegalStateException("Unable to compile BTC-QORT ACCT?", e);
+			}
+		}
+
+		codeByteBuffer.flip();
+
+		byte[] codeBytes = new byte[codeByteBuffer.limit()];
+		codeByteBuffer.get(codeBytes);
+
+		assert Arrays.equals(Crypto.digest(codeBytes), BitcoinACCTv3.CODE_BYTES_HASH)
+			: String.format("BTCACCT.CODE_BYTES_HASH mismatch: expected %s, actual %s", HashCode.fromBytes(CODE_BYTES_HASH), HashCode.fromBytes(Crypto.digest(codeBytes)));
+
+		final short ciyamAtVersion = 2;
+		final short numCallStackPages = 0;
+		final short numUserStackPages = 0;
+		final long minActivationAmount = 0L;
+
+		return MachineState.toCreationBytes(ciyamAtVersion, codeBytes, dataByteBuffer.array(), numCallStackPages, numUserStackPages, minActivationAmount);
+	}
+
+	/**
+	 * Returns CrossChainTradeData with useful info extracted from AT.
+	 */
+	@Override
+	public CrossChainTradeData populateTradeData(Repository repository, ATData atData) throws DataException {
+		ATStateData atStateData = repository.getATRepository().getLatestATState(atData.getATAddress());
+		return populateTradeData(repository, atData.getCreatorPublicKey(), atData.getCreation(), atStateData);
+	}
+
+	/**
+	 * Returns CrossChainTradeData with useful info extracted from AT.
+	 */
+	@Override
+	public CrossChainTradeData populateTradeData(Repository repository, ATStateData atStateData) throws DataException {
+		ATData atData = repository.getATRepository().fromATAddress(atStateData.getATAddress());
+		return populateTradeData(repository, atData.getCreatorPublicKey(), atData.getCreation(), atStateData);
+	}
+
+	/**
+	 * Returns CrossChainTradeData with useful info extracted from AT.
+	 */
+	public CrossChainTradeData populateTradeData(Repository repository, byte[] creatorPublicKey, long creationTimestamp, ATStateData atStateData) throws DataException {
+		byte[] addressBytes = new byte[25]; // for general use
+		String atAddress = atStateData.getATAddress();
+
+		CrossChainTradeData tradeData = new CrossChainTradeData();
+
+		tradeData.foreignBlockchain = SupportedBlockchain.BITCOIN.name();
+		tradeData.acctName = NAME;
+
+		tradeData.qortalAtAddress = atAddress;
+		tradeData.qortalCreator = Crypto.toAddress(creatorPublicKey);
+		tradeData.creationTimestamp = creationTimestamp;
+
+		Account atAccount = new Account(repository, atAddress);
+		tradeData.qortBalance = atAccount.getConfirmedBalance(Asset.QORT);
+
+		byte[] stateData = atStateData.getStateData();
+		ByteBuffer dataByteBuffer = ByteBuffer.wrap(stateData);
+		dataByteBuffer.position(MachineState.HEADER_LENGTH);
+
+		/* Constants */
+
+		// Skip creator's trade address
+		dataByteBuffer.get(addressBytes);
+		tradeData.qortalCreatorTradeAddress = Base58.encode(addressBytes);
+		dataByteBuffer.position(dataByteBuffer.position() + 32 - addressBytes.length);
+
+		// Creator's Bitcoin/foreign public key hash
+		tradeData.creatorForeignPKH = new byte[20];
+		dataByteBuffer.get(tradeData.creatorForeignPKH);
+		dataByteBuffer.position(dataByteBuffer.position() + 32 - tradeData.creatorForeignPKH.length); // skip to 32 bytes
+
+		// We don't use secret-B
+		tradeData.hashOfSecretB = null;
+
+		// Redeem payout
+		tradeData.qortAmount = dataByteBuffer.getLong();
+
+		// Expected BTC amount
+		tradeData.expectedForeignAmount = dataByteBuffer.getLong();
+
+		// Trade timeout
+		tradeData.tradeTimeout = (int) dataByteBuffer.getLong();
+
+		// Skip MESSAGE transaction type
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip expected 'trade' message length
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip expected 'redeem' message length
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip pointer to creator's address
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip pointer to partner's Qortal trade address
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip pointer to message sender
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip 'trade' message data offset for partner's Bitcoin PKH
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip pointer to partner's Bitcoin PKH
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip 'trade' message data offset for hash-of-secret-A
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip pointer to hash-of-secret-A
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip 'redeem' message data offset for partner's Qortal receiving address
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip pointer to message data
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip message data length
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip pointer to partner's receiving address
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		/* End of constants / begin variables */
+
+		// Skip AT creator's address
+		dataByteBuffer.position(dataByteBuffer.position() + 8 * 4);
+
+		// Partner's trade address (if present)
+		dataByteBuffer.get(addressBytes);
+		String qortalRecipient = Base58.encode(addressBytes);
+		dataByteBuffer.position(dataByteBuffer.position() + 32 - addressBytes.length);
+
+		// Potential lockTimeA (if in trade mode)
+		int lockTimeA = (int) dataByteBuffer.getLong();
+
+		// AT refund timeout (probably only useful for debugging)
+		int refundTimeout = (int) dataByteBuffer.getLong();
+
+		// Trade-mode refund timestamp (AT 'timestamp' converted to Qortal block height)
+		long tradeRefundTimestamp = dataByteBuffer.getLong();
+
+		// Skip last transaction timestamp
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip block timestamp
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip transaction type
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip temporary result
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip temporary message sender
+		dataByteBuffer.position(dataByteBuffer.position() + 8 * 4);
+
+		// Skip message length
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip temporary message data
+		dataByteBuffer.position(dataByteBuffer.position() + 8 * 4);
+
+		// Potential hash160 of secret A
+		byte[] hashOfSecretA = new byte[20];
+		dataByteBuffer.get(hashOfSecretA);
+		dataByteBuffer.position(dataByteBuffer.position() + 32 - hashOfSecretA.length); // skip to 32 bytes
+
+		// Potential partner's Bitcoin PKH
+		byte[] partnerBitcoinPKH = new byte[20];
+		dataByteBuffer.get(partnerBitcoinPKH);
+		dataByteBuffer.position(dataByteBuffer.position() + 32 - partnerBitcoinPKH.length); // skip to 32 bytes
+
+		// Partner's receiving address (if present)
+		byte[] partnerReceivingAddress = new byte[25];
+		dataByteBuffer.get(partnerReceivingAddress);
+		dataByteBuffer.position(dataByteBuffer.position() + 32 - partnerReceivingAddress.length); // skip to 32 bytes
+
+		// Trade AT's 'mode'
+		long modeValue = dataByteBuffer.getLong();
+		AcctMode mode = AcctMode.valueOf((int) (modeValue & 0xffL));
+
+		/* End of variables */
+
+		if (mode != null && mode != AcctMode.OFFERING) {
+			tradeData.mode = mode;
+			tradeData.refundTimeout = refundTimeout;
+			tradeData.tradeRefundHeight = new Timestamp(tradeRefundTimestamp).blockHeight;
+			tradeData.qortalPartnerAddress = qortalRecipient;
+			tradeData.hashOfSecretA = hashOfSecretA;
+			tradeData.partnerForeignPKH = partnerBitcoinPKH;
+			tradeData.lockTimeA = lockTimeA;
+
+			if (mode == AcctMode.REDEEMED)
+				tradeData.qortalPartnerReceivingAddress = Base58.encode(partnerReceivingAddress);
+		} else {
+			tradeData.mode = AcctMode.OFFERING;
+		}
+
+		tradeData.duplicateDeprecated();
+
+		return tradeData;
+	}
+
+	/** Returns 'offer' MESSAGE payload for trade partner to send to AT creator's trade address. */
+	public static byte[] buildOfferMessage(byte[] partnerBitcoinPKH, byte[] hashOfSecretA, int lockTimeA) {
+		byte[] lockTimeABytes = BitTwiddling.toBEByteArray((long) lockTimeA);
+		return Bytes.concat(partnerBitcoinPKH, hashOfSecretA, lockTimeABytes);
+	}
+
+	/** Returns info extracted from 'offer' MESSAGE payload sent by trade partner to AT creator's trade address, or null if not valid. */
+	public static OfferMessageData extractOfferMessageData(byte[] messageData) {
+		if (messageData == null || messageData.length != OFFER_MESSAGE_LENGTH)
+			return null;
+
+		OfferMessageData offerMessageData = new OfferMessageData();
+		offerMessageData.partnerBitcoinPKH = Arrays.copyOfRange(messageData, 0, 20);
+		offerMessageData.hashOfSecretA = Arrays.copyOfRange(messageData, 20, 40);
+		offerMessageData.lockTimeA = BitTwiddling.longFromBEBytes(messageData, 40);
+
+		return offerMessageData;
+	}
+
+	/** Returns 'trade' MESSAGE payload for AT creator to send to AT. */
+	public static byte[] buildTradeMessage(String partnerQortalTradeAddress, byte[] partnerBitcoinPKH, byte[] hashOfSecretA, int lockTimeA, int refundTimeout) {
+		byte[] data = new byte[TRADE_MESSAGE_LENGTH];
+		byte[] partnerQortalAddressBytes = Base58.decode(partnerQortalTradeAddress);
+		byte[] lockTimeABytes = BitTwiddling.toBEByteArray((long) lockTimeA);
+		byte[] refundTimeoutBytes = BitTwiddling.toBEByteArray((long) refundTimeout);
+
+		System.arraycopy(partnerQortalAddressBytes, 0, data, 0, partnerQortalAddressBytes.length);
+		System.arraycopy(partnerBitcoinPKH, 0, data, 32, partnerBitcoinPKH.length);
+		System.arraycopy(refundTimeoutBytes, 0, data, 56, refundTimeoutBytes.length);
+		System.arraycopy(hashOfSecretA, 0, data, 64, hashOfSecretA.length);
+		System.arraycopy(lockTimeABytes, 0, data, 88, lockTimeABytes.length);
+
+		return data;
+	}
+
+	/** Returns 'cancel' MESSAGE payload for AT creator to cancel trade AT. */
+	@Override
+	public byte[] buildCancelMessage(String creatorQortalAddress) {
+		byte[] data = new byte[CANCEL_MESSAGE_LENGTH];
+		byte[] creatorQortalAddressBytes = Base58.decode(creatorQortalAddress);
+
+		System.arraycopy(creatorQortalAddressBytes, 0, data, 0, creatorQortalAddressBytes.length);
+
+		return data;
+	}
+
+	/** Returns 'redeem' MESSAGE payload for trade partner to send to AT. */
+	public static byte[] buildRedeemMessage(byte[] secretA, String qortalReceivingAddress) {
+		byte[] data = new byte[REDEEM_MESSAGE_LENGTH];
+		byte[] qortalReceivingAddressBytes = Base58.decode(qortalReceivingAddress);
+
+		System.arraycopy(secretA, 0, data, 0, secretA.length);
+		System.arraycopy(qortalReceivingAddressBytes, 0, data, 32, qortalReceivingAddressBytes.length);
+
+		return data;
+	}
+
+	/** Returns refund timeout (minutes) based on trade partner's 'offer' MESSAGE timestamp and P2SH-A locktime. */
+	public static int calcRefundTimeout(long offerMessageTimestamp, int lockTimeA) {
+		// refund should be triggered halfway between offerMessageTimestamp and lockTimeA
+		return (int) ((lockTimeA - (offerMessageTimestamp / 1000L)) / 2L / 60L);
+	}
+
+	@Override
+	public byte[] findSecretA(Repository repository, CrossChainTradeData crossChainTradeData) throws DataException {
+		String atAddress = crossChainTradeData.qortalAtAddress;
+		String redeemerAddress = crossChainTradeData.qortalPartnerAddress;
+
+		// We don't have partner's public key so we check every message to AT
+		List<MessageTransactionData> messageTransactionsData = repository.getMessageRepository().getMessagesByParticipants(null, atAddress, null, null, null);
+		if (messageTransactionsData == null)
+			return null;
+
+		// Find 'redeem' message
+		for (MessageTransactionData messageTransactionData : messageTransactionsData) {
+			// Check message payload type/encryption
+			if (messageTransactionData.isText() || messageTransactionData.isEncrypted())
+				continue;
+
+			// Check message payload size
+			byte[] messageData = messageTransactionData.getData();
+			if (messageData.length != REDEEM_MESSAGE_LENGTH)
+				// Wrong payload length
+				continue;
+
+			// Check sender
+			if (!Crypto.toAddress(messageTransactionData.getSenderPublicKey()).equals(redeemerAddress))
+				// Wrong sender;
+				continue;
+
+			// Extract secretA
+			byte[] secretA = new byte[32];
+			System.arraycopy(messageData, 0, secretA, 0, secretA.length);
+
+			byte[] hashOfSecretA = Crypto.hash160(secretA);
+			if (!Arrays.equals(hashOfSecretA, crossChainTradeData.hashOfSecretA))
+				continue;
+
+			return secretA;
+		}
+
+		return null;
+	}
+
+}

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

@@ -29,6 +29,7 @@ import org.bitcoinj.wallet.SendRequest;
 import org.bitcoinj.wallet.Wallet;
 import org.qortal.api.model.SimpleForeignTransaction;
 import org.qortal.crypto.Crypto;
+import org.qortal.settings.Settings;
 import org.qortal.utils.Amounts;
 import org.qortal.utils.BitTwiddling;
 
@@ -42,7 +43,7 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 
 	public static final int HASH160_LENGTH = 20;
 
-	protected final BitcoinyBlockchainProvider blockchain;
+	protected final BitcoinyBlockchainProvider blockchainProvider;
 	protected final Context bitcoinjContext;
 	protected final String currencyCode;
 
@@ -61,18 +62,13 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 	/** How many wallet keys to generate in each batch. */
 	private static final int WALLET_KEY_LOOKAHEAD_INCREMENT = 3;
 
-	/** How many wallet keys to generate when using bitcoinj as the data provider.
-	 * We must use a higher value here since we are unable to request multiple batches of keys.
-	 * Without this, the bitcoinj state can be missing transactions, causing errors such as "insufficient balance". */
-	private static final int WALLET_KEY_LOOKAHEAD_INCREMENT_BITCOINJ = 50;
-
 	/** Byte offset into raw block headers to block timestamp. */
 	private static final int TIMESTAMP_OFFSET = 4 + 32 + 32;
 
 	// Constructors and instance
 
-	protected Bitcoiny(BitcoinyBlockchainProvider blockchain, Context bitcoinjContext, String currencyCode) {
-		this.blockchain = blockchain;
+	protected Bitcoiny(BitcoinyBlockchainProvider blockchainProvider, Context bitcoinjContext, String currencyCode) {
+		this.blockchainProvider = blockchainProvider;
 		this.bitcoinjContext = bitcoinjContext;
 		this.currencyCode = currencyCode;
 
@@ -82,7 +78,7 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 	// Getters & setters
 
 	public BitcoinyBlockchainProvider getBlockchainProvider() {
-		return this.blockchain;
+		return this.blockchainProvider;
 	}
 
 	public Context getBitcoinjContext() {
@@ -155,10 +151,10 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 	 * @throws ForeignBlockchainException if error occurs
 	 */
 	public int getMedianBlockTime() throws ForeignBlockchainException {
-		int height = this.blockchain.getCurrentHeight();
+		int height = this.blockchainProvider.getCurrentHeight();
 
 		// Grab latest 11 blocks
-		List<byte[]> blockHeaders = this.blockchain.getRawBlockHeaders(height - 11, 11);
+		List<byte[]> blockHeaders = this.blockchainProvider.getRawBlockHeaders(height - 11, 11);
 		if (blockHeaders.size() < 11)
 			throw new ForeignBlockchainException("Not enough blocks to determine median block time");
 
@@ -197,7 +193,7 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 	 * @throws ForeignBlockchainException if there was an error
 	 */
 	public long getConfirmedBalance(String base58Address) throws ForeignBlockchainException {
-		return this.blockchain.getConfirmedBalance(addressToScriptPubKey(base58Address));
+		return this.blockchainProvider.getConfirmedBalance(addressToScriptPubKey(base58Address));
 	}
 
 	/**
@@ -208,7 +204,7 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 	 */
 	// TODO: don't return bitcoinj-based objects like TransactionOutput, use BitcoinyTransaction.Output instead
 	public List<TransactionOutput> getUnspentOutputs(String base58Address) throws ForeignBlockchainException {
-		List<UnspentOutput> unspentOutputs = this.blockchain.getUnspentOutputs(addressToScriptPubKey(base58Address), false);
+		List<UnspentOutput> unspentOutputs = this.blockchainProvider.getUnspentOutputs(addressToScriptPubKey(base58Address), false);
 
 		List<TransactionOutput> unspentTransactionOutputs = new ArrayList<>();
 		for (UnspentOutput unspentOutput : unspentOutputs) {
@@ -228,7 +224,7 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 	 */
 	// TODO: don't return bitcoinj-based objects like TransactionOutput, use BitcoinyTransaction.Output instead
 	public List<TransactionOutput> getOutputs(byte[] txHash) throws ForeignBlockchainException {
-		byte[] rawTransactionBytes = this.blockchain.getRawTransaction(txHash);
+		byte[] rawTransactionBytes = this.blockchainProvider.getRawTransaction(txHash);
 
 		Context.propagate(bitcoinjContext);
 		Transaction transaction = new Transaction(this.params, rawTransactionBytes);
@@ -245,7 +241,7 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 		ForeignBlockchainException e2 = null;
 		while (retries <= 3) {
 			try {
-				return this.blockchain.getAddressTransactions(scriptPubKey, includeUnconfirmed);
+				return this.blockchainProvider.getAddressTransactions(scriptPubKey, includeUnconfirmed);
 			} catch (ForeignBlockchainException e) {
 				e2 = e;
 				retries++;
@@ -261,7 +257,7 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 	 * @throws ForeignBlockchainException if there was an error.
 	 */
 	public List<TransactionHash> getAddressTransactions(String base58Address, boolean includeUnconfirmed) throws ForeignBlockchainException {
-		return this.blockchain.getAddressTransactions(addressToScriptPubKey(base58Address), includeUnconfirmed);
+		return this.blockchainProvider.getAddressTransactions(addressToScriptPubKey(base58Address), includeUnconfirmed);
 	}
 
 	/**
@@ -270,11 +266,11 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 	 * @throws ForeignBlockchainException if there was an error
 	 */
 	public List<byte[]> getAddressTransactions(String base58Address) throws ForeignBlockchainException {
-		List<TransactionHash> transactionHashes = this.blockchain.getAddressTransactions(addressToScriptPubKey(base58Address), false);
+		List<TransactionHash> transactionHashes = this.blockchainProvider.getAddressTransactions(addressToScriptPubKey(base58Address), false);
 
 		List<byte[]> rawTransactions = new ArrayList<>();
 		for (TransactionHash transactionInfo : transactionHashes) {
-			byte[] rawTransaction = this.blockchain.getRawTransaction(HashCode.fromString(transactionInfo.txHash).asBytes());
+			byte[] rawTransaction = this.blockchainProvider.getRawTransaction(HashCode.fromString(transactionInfo.txHash).asBytes());
 			rawTransactions.add(rawTransaction);
 		}
 
@@ -292,7 +288,7 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 		ForeignBlockchainException e2 = null;
 		while (retries <= 3) {
 			try {
-				return this.blockchain.getTransaction(txHash);
+				return this.blockchainProvider.getTransaction(txHash);
 			} catch (ForeignBlockchainException e) {
 				e2 = e;
 				retries++;
@@ -307,7 +303,7 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 	 * @throws ForeignBlockchainException if error occurs
 	 */
 	public void broadcastTransaction(Transaction transaction) throws ForeignBlockchainException {
-		this.blockchain.broadcastTransaction(transaction.bitcoinSerialize());
+		this.blockchainProvider.broadcastTransaction(transaction.bitcoinSerialize());
 	}
 
 	/**
@@ -360,22 +356,25 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 	 * @param key58 BIP32/HD extended Bitcoin private/public key
 	 * @return unspent BTC balance, or null if unable to determine balance
 	 */
-	public Long getWalletBalance(String key58) {
-		Context.propagate(bitcoinjContext);
+	public Long getWalletBalance(String key58) throws ForeignBlockchainException {
+		// It's more accurate to calculate the balance from the transactions, rather than asking Bitcoinj
+		return this.getWalletBalanceFromTransactions(key58);
 
-		Wallet wallet = walletFromDeterministicKey58(key58);
-		wallet.setUTXOProvider(new WalletAwareUTXOProvider(this, wallet));
-
-		Coin balance = wallet.getBalance();
-		if (balance == null)
-			return null;
-
-		return balance.value;
+//		Context.propagate(bitcoinjContext);
+//
+//		Wallet wallet = walletFromDeterministicKey58(key58);
+//		wallet.setUTXOProvider(new WalletAwareUTXOProvider(this, wallet));
+//
+//		Coin balance = wallet.getBalance();
+//		if (balance == null)
+//			return null;
+//
+//		return balance.value;
 	}
 
 	public Long getWalletBalanceFromTransactions(String key58) throws ForeignBlockchainException {
 		long balance = 0;
-		Comparator<SimpleTransaction> oldestTimestampFirstComparator = Comparator.comparingInt(SimpleTransaction::getTimestamp);
+		Comparator<SimpleTransaction> oldestTimestampFirstComparator = Comparator.comparingLong(SimpleTransaction::getTimestamp);
 		List<SimpleTransaction> transactions = getWalletTransactions(key58).stream().sorted(oldestTimestampFirstComparator).collect(Collectors.toList());
 		for (SimpleTransaction transaction : transactions) {
 			balance += transaction.getTotalAmount();
@@ -409,9 +408,6 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 			Set<BitcoinyTransaction> walletTransactions = new HashSet<>();
 			Set<String> keySet = new HashSet<>();
 
-			// Set the number of consecutive empty batches required before giving up
-			final int numberOfAdditionalBatchesToSearch = 7;
-
 			int unusedCounter = 0;
 			int ki = 0;
 			do {
@@ -438,12 +434,12 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 
 				if (areAllKeysUnused) {
 					// No transactions
-					if (unusedCounter >= numberOfAdditionalBatchesToSearch) {
+					if (unusedCounter >= Settings.getInstance().getGapLimit()) {
 						// ... and we've hit our search limit
 						break;
 					}
 					// We haven't hit our search limit yet so increment the counter and keep looking
-					unusedCounter++;
+					unusedCounter += WALLET_KEY_LOOKAHEAD_INCREMENT;
 				} else {
 					// Some keys in this batch were used, so reset the counter
 					unusedCounter = 0;
@@ -455,7 +451,7 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 				// Process new keys
 			} while (true);
 
-			Comparator<SimpleTransaction> newestTimestampFirstComparator = Comparator.comparingInt(SimpleTransaction::getTimestamp).reversed();
+			Comparator<SimpleTransaction> newestTimestampFirstComparator = Comparator.comparingLong(SimpleTransaction::getTimestamp).reversed();
 
 			// Update cache and return
 			transactionsCacheTimestamp = NTP.getTime();
@@ -537,7 +533,8 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 			// All inputs and outputs relate to this wallet, so the balance should be unaffected
 			amount = 0;
 		}
-		return new SimpleTransaction(t.txHash, t.timestamp, amount, fee, inputs, outputs);
+		long timestampMillis = t.timestamp * 1000L;
+		return new SimpleTransaction(t.txHash, timestampMillis, amount, fee, inputs, outputs, null);
 	}
 
 	/**
@@ -573,7 +570,7 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 				Address address = Address.fromKey(this.params, dKey, ScriptType.P2PKH);
 				byte[] script = ScriptBuilder.createOutputScript(address).getProgram();
 
-				List<UnspentOutput> unspentOutputs = this.blockchain.getUnspentOutputs(script, false);
+				List<UnspentOutput> unspentOutputs = this.blockchainProvider.getUnspentOutputs(script, false);
 
 				/*
 				 * If there are no unspent outputs then either:
@@ -591,7 +588,7 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 					}
 
 					// Ask for transaction history - if it's empty then key has never been used
-					List<TransactionHash> historicTransactionHashes = this.blockchain.getAddressTransactions(script, false);
+					List<TransactionHash> historicTransactionHashes = this.blockchainProvider.getAddressTransactions(script, false);
 
 					if (!historicTransactionHashes.isEmpty()) {
 						// Fully spent key - case (a)
@@ -629,7 +626,7 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 			this.keyChain = this.wallet.getActiveKeyChain();
 
 			// Set up wallet's key chain
-			this.keyChain.setLookaheadSize(Bitcoiny.WALLET_KEY_LOOKAHEAD_INCREMENT_BITCOINJ);
+			this.keyChain.setLookaheadSize(Settings.getInstance().getBitcoinjLookaheadSize());
 			this.keyChain.maybeLookAhead();
 		}
 
@@ -650,7 +647,7 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 
 					List<UnspentOutput> unspentOutputs;
 					try {
-						unspentOutputs = this.bitcoiny.blockchain.getUnspentOutputs(script, false);
+						unspentOutputs = this.bitcoiny.blockchainProvider.getUnspentOutputs(script, false);
 					} catch (ForeignBlockchainException e) {
 						throw new UTXOProviderException(String.format("Unable to fetch unspent outputs for %s", address));
 					}
@@ -674,7 +671,7 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 						// Ask for transaction history - if it's empty then key has never been used
 						List<TransactionHash> historicTransactionHashes;
 						try {
-							historicTransactionHashes = this.bitcoiny.blockchain.getAddressTransactions(script, false);
+							historicTransactionHashes = this.bitcoiny.blockchainProvider.getAddressTransactions(script, false);
 						} catch (ForeignBlockchainException e) {
 							throw new UTXOProviderException(String.format("Unable to fetch transaction history for %s", address));
 						}
@@ -727,7 +724,7 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 		@Override
 		public int getChainHeadHeight() throws UTXOProviderException {
 			try {
-				return this.bitcoiny.blockchain.getCurrentHeight();
+				return this.bitcoiny.blockchainProvider.getCurrentHeight();
 			} catch (ForeignBlockchainException e) {
 				throw new UTXOProviderException("Unable to determine Bitcoiny chain height");
 			}

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

@@ -1,5 +1,7 @@
 package org.qortal.crosschain;
 
+import cash.z.wallet.sdk.rpc.CompactFormats.*;
+
 import java.util.List;
 
 public abstract class BitcoinyBlockchainProvider {
@@ -7,18 +9,32 @@ public abstract class BitcoinyBlockchainProvider {
 	public static final boolean INCLUDE_UNCONFIRMED = true;
 	public static final boolean EXCLUDE_UNCONFIRMED = false;
 
+	/** Sets the blockchain using this provider instance */
+	public abstract void setBlockchain(Bitcoiny blockchain);
+
 	/** Returns ID unique to bitcoiny network (e.g. "Litecoin-TEST3") */
 	public abstract String getNetId();
 
 	/** Returns current blockchain height. */
 	public abstract int getCurrentHeight() throws ForeignBlockchainException;
 
+	/** Returns a list of compact blocks, starting at <tt>startHeight</tt> (inclusive), up to <tt>count</tt> max.
+	 * Used for Pirate/Zcash only. If ever needed for other blockchains, the response format will need to be
+	 * made generic. */
+	public abstract List<CompactBlock> getCompactBlocks(int startHeight, int count) throws ForeignBlockchainException;
+
 	/** Returns a list of raw block headers, starting at <tt>startHeight</tt> (inclusive), up to <tt>count</tt> max. */
 	public abstract List<byte[]> getRawBlockHeaders(int startHeight, int count) throws ForeignBlockchainException;
 
+	/** Returns a list of block timestamps, starting at <tt>startHeight</tt> (inclusive), up to <tt>count</tt> max. */
+	public abstract List<Long> getBlockTimestamps(int startHeight, int count) throws ForeignBlockchainException;
+
 	/** Returns balance of address represented by <tt>scriptPubKey</tt>. */
 	public abstract long getConfirmedBalance(byte[] scriptPubKey) throws ForeignBlockchainException;
 
+	/** Returns balance of base58 encoded address. */
+	public abstract long getConfirmedAddressBalance(String base58Address) throws ForeignBlockchainException;
+
 	/** Returns raw, serialized, transaction bytes given <tt>txHash</tt>. */
 	public abstract byte[] getRawTransaction(String txHash) throws ForeignBlockchainException;
 
@@ -31,6 +47,12 @@ public abstract class BitcoinyBlockchainProvider {
 	/** Returns list of transaction hashes (and heights) for address represented by <tt>scriptPubKey</tt>, optionally including unconfirmed transactions. */
 	public abstract List<TransactionHash> getAddressTransactions(byte[] scriptPubKey, boolean includeUnconfirmed) throws ForeignBlockchainException;
 
+	/** Returns list of BitcoinyTransaction objects for <tt>address</tt>, optionally including unconfirmed transactions. */
+	public abstract List<BitcoinyTransaction> getAddressBitcoinyTransactions(String address, boolean includeUnconfirmed) throws ForeignBlockchainException;
+
+		/** Returns list of unspent transaction outputs for <tt>address</tt>, optionally including unconfirmed transactions. */
+	public abstract List<UnspentOutput> getUnspentOutputs(String address, boolean includeUnconfirmed) throws ForeignBlockchainException;
+
 	/** Returns list of unspent transaction outputs for address represented by <tt>scriptPubKey</tt>, optionally including unconfirmed transactions. */
 	public abstract List<UnspentOutput> getUnspentOutputs(byte[] scriptPubKey, boolean includeUnconfirmed) throws ForeignBlockchainException;
 

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

@@ -1,5 +1,6 @@
 package org.qortal.crosschain;
 
+import java.util.Comparator;
 import java.util.List;
 import java.util.stream.Collectors;
 
@@ -10,8 +11,13 @@ import javax.xml.bind.annotation.XmlTransient;
 @XmlAccessorType(XmlAccessType.FIELD)
 public class BitcoinyTransaction {
 
+	public static final Comparator<BitcoinyTransaction> CONFIRMED_FIRST = (a, b) -> Boolean.compare(a.height != 0, b.height != 0);
+
 	public final String txHash;
 
+	@XmlTransient
+	public Integer height;
+
 	@XmlTransient
 	public final int size;
 
@@ -113,6 +119,10 @@ public class BitcoinyTransaction {
 		this.totalAmount = outputs.stream().map(output -> output.value).reduce(0L, Long::sum);
 	}
 
+	public int getHeight() {
+		return this.height;
+	}
+
 	public String toString() {
 		return String.format("txHash %s, size %d, locktime %d, timestamp %d\n"
 				+ "\tinputs: [%s]\n"

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

@@ -0,0 +1,171 @@
+package org.qortal.crosschain;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.EnumMap;
+import java.util.Map;
+
+import org.bitcoinj.core.Coin;
+import org.bitcoinj.core.Context;
+import org.bitcoinj.core.NetworkParameters;
+import org.bitcoinj.params.RegTestParams;
+import org.bitcoinj.params.TestNet3Params;
+import org.libdohj.params.DigibyteMainNetParams;
+import org.qortal.crosschain.ElectrumX.Server;
+import org.qortal.crosschain.ElectrumX.Server.ConnectionType;
+import org.qortal.settings.Settings;
+
+public class Digibyte extends Bitcoiny {
+
+	public static final String CURRENCY_CODE = "DGB";
+
+	private static final Coin DEFAULT_FEE_PER_KB = Coin.valueOf(100000); // 0.001 DGB per 1000 bytes
+
+	private static final long MINIMUM_ORDER_AMOUNT = 1000000; // 0.01 DGB minimum order, to avoid dust errors
+
+	// Temporary values until a dynamic fee system is written.
+	private static final long MAINNET_FEE = 10000L;
+	private static final long NON_MAINNET_FEE = 10000L; // enough for TESTNET3 and should be OK for REGTEST
+
+	private static final Map<ConnectionType, Integer> DEFAULT_ELECTRUMX_PORTS = new EnumMap<>(ConnectionType.class);
+	static {
+		DEFAULT_ELECTRUMX_PORTS.put(ConnectionType.TCP, 50001);
+		DEFAULT_ELECTRUMX_PORTS.put(ConnectionType.SSL, 50002);
+	}
+
+	public enum DigibyteNet {
+		MAIN {
+			@Override
+			public NetworkParameters getParams() {
+				return DigibyteMainNetParams.get();
+			}
+
+			@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("electrum1.cipig.net", ConnectionType.SSL, 20059),
+						new Server("electrum2.cipig.net", ConnectionType.SSL, 20059),
+						new Server("electrum3.cipig.net", ConnectionType.SSL, 20059));
+			}
+
+			@Override
+			public String getGenesisHash() {
+				return "7497ea1b465eb39f1c8f507bc877078fe016d6fcb6dfad3a64c98dcc6e1e8496";
+			}
+
+			@Override
+			public long getP2shFee(Long timestamp) {
+				// TODO: This will need to be replaced with something better in the near future!
+				return MAINNET_FEE;
+			}
+		},
+		TEST3 {
+			@Override
+			public NetworkParameters getParams() {
+				return TestNet3Params.get();
+			}
+
+			@Override
+			public Collection<Server> getServers() {
+				return Arrays.asList(); // TODO: find testnet servers
+			}
+
+			@Override
+			public String getGenesisHash() {
+				return "308ea0711d5763be2995670dd9ca9872753561285a84da1d58be58acaa822252";
+			}
+
+			@Override
+			public long getP2shFee(Long timestamp) {
+				return NON_MAINNET_FEE;
+			}
+		},
+		REGTEST {
+			@Override
+			public NetworkParameters getParams() {
+				return RegTestParams.get();
+			}
+
+			@Override
+			public Collection<Server> getServers() {
+				return Arrays.asList(
+						new Server("localhost", ConnectionType.TCP, 50001),
+						new Server("localhost", ConnectionType.SSL, 50002));
+			}
+
+			@Override
+			public String getGenesisHash() {
+				// This is unique to each regtest instance
+				return null;
+			}
+
+			@Override
+			public long getP2shFee(Long timestamp) {
+				return NON_MAINNET_FEE;
+			}
+		};
+
+		public abstract NetworkParameters getParams();
+		public abstract Collection<Server> getServers();
+		public abstract String getGenesisHash();
+		public abstract long getP2shFee(Long timestamp) throws ForeignBlockchainException;
+	}
+
+	private static Digibyte instance;
+
+	private final DigibyteNet digibyteNet;
+
+	// Constructors and instance
+
+	private Digibyte(DigibyteNet digibyteNet, BitcoinyBlockchainProvider blockchain, Context bitcoinjContext, String currencyCode) {
+		super(blockchain, bitcoinjContext, currencyCode);
+		this.digibyteNet = digibyteNet;
+
+		LOGGER.info(() -> String.format("Starting Digibyte support using %s", this.digibyteNet.name()));
+	}
+
+	public static synchronized Digibyte getInstance() {
+		if (instance == null) {
+			DigibyteNet digibyteNet = Settings.getInstance().getDigibyteNet();
+
+			BitcoinyBlockchainProvider electrumX = new ElectrumX("Digibyte-" + digibyteNet.name(), digibyteNet.getGenesisHash(), digibyteNet.getServers(), DEFAULT_ELECTRUMX_PORTS);
+			Context bitcoinjContext = new Context(digibyteNet.getParams());
+
+			instance = new Digibyte(digibyteNet, electrumX, bitcoinjContext, CURRENCY_CODE);
+		}
+
+		return instance;
+	}
+
+	// Getters & setters
+
+	public static synchronized void resetForTesting() {
+		instance = null;
+	}
+
+	// Actual useful methods for use by other classes
+
+	@Override
+	public Coin getFeePerKb() {
+		return DEFAULT_FEE_PER_KB;
+	}
+
+	@Override
+	public long getMinimumOrderAmount() {
+		return MINIMUM_ORDER_AMOUNT;
+	}
+
+	/**
+	 * Returns estimated DGB fee, in sats per 1000bytes, optionally for historic timestamp.
+	 * 
+	 * @param timestamp optional milliseconds since epoch, or null for 'now'
+	 * @return sats per 1000bytes, or throws ForeignBlockchainException if something went wrong
+	 */
+	@Override
+	public long getP2shFee(Long timestamp) throws ForeignBlockchainException {
+		return this.digibyteNet.getP2shFee(timestamp);
+	}
+
+}

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

@@ -0,0 +1,858 @@
+package org.qortal.crosschain;
+
+import com.google.common.hash.HashCode;
+import com.google.common.primitives.Bytes;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.ciyam.at.*;
+import org.qortal.account.Account;
+import org.qortal.asset.Asset;
+import org.qortal.at.QortalFunctionCode;
+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.MessageTransactionData;
+import org.qortal.repository.DataException;
+import org.qortal.repository.Repository;
+import org.qortal.utils.Base58;
+import org.qortal.utils.BitTwiddling;
+
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.ciyam.at.OpCode.calcOffset;
+
+/**
+ * Cross-chain trade AT
+ * 
+ * <p>
+ * <ul>
+ * <li>Bob generates Digibyte & Qortal 'trade' keys
+ * 		<ul>
+ * 			<li>private key required to sign P2SH redeem tx</li>
+ * 			<li>private key could be used to create 'secret' (e.g. double-SHA256)</li>
+ * 			<li>encrypted private key could be stored in Qortal AT for access by Bob from any node</li>
+ * 		</ul>
+ * </li>
+ * <li>Bob deploys Qortal AT
+ * 		<ul>
+ * 		</ul>
+ * </li>
+ * <li>Alice finds Qortal AT and wants to trade
+ * 		<ul>
+ * 			<li>Alice generates Digibyte & Qortal 'trade' keys</li>
+ * 			<li>Alice funds Digibyte P2SH-A</li>
+ * 			<li>Alice sends 'offer' MESSAGE to Bob from her Qortal trade address, containing:
+ * 				<ul>
+ * 					<li>hash-of-secret-A</li>
+ * 					<li>her 'trade' Digibyte PKH</li>
+ * 				</ul>
+ * 			</li>
+ * 		</ul>
+ * </li>
+ * <li>Bob receives "offer" MESSAGE
+ * 		<ul>
+ * 			<li>Checks Alice's P2SH-A</li>
+ * 			<li>Sends 'trade' MESSAGE to Qortal AT from his trade address, containing:
+ * 				<ul>
+ * 					<li>Alice's trade Qortal address</li>
+ * 					<li>Alice's trade Digibyte PKH</li>
+ * 					<li>hash-of-secret-A</li>
+ * 				</ul>
+ * 			</li>
+ * 		</ul>
+ * </li>
+ * <li>Alice checks Qortal AT to confirm it's locked to her
+ * 		<ul>
+ * 			<li>Alice sends 'redeem' MESSAGE to Qortal AT from her trade address, containing:
+ * 				<ul>
+ * 					<li>secret-A</li>
+ * 					<li>Qortal receiving address of her chosing</li>
+ * 				</ul>
+ * 			</li>
+ * 			<li>AT's QORT funds are sent to Qortal receiving address</li>
+ * 		</ul>
+ * </li>
+ * <li>Bob checks AT, extracts secret-A
+ * 		<ul>
+ * 			<li>Bob redeems P2SH-A using his Digibyte trade key and secret-A</li>
+ * 			<li>P2SH-A DGB funds end up at Digibyte address determined by redeem transaction output(s)</li>
+ * 		</ul>
+ * </li>
+ * </ul>
+ */
+public class DigibyteACCTv3 implements ACCT {
+
+	private static final Logger LOGGER = LogManager.getLogger(DigibyteACCTv3.class);
+
+	public static final String NAME = DigibyteACCTv3.class.getSimpleName();
+	public static final byte[] CODE_BYTES_HASH = HashCode.fromString("e6a7dcd87296fae3ce7d80183bf7660c8e2cb4f8746c6a0421a17148f87a0e1d").asBytes(); // SHA256 of AT code bytes
+
+	public static final int SECRET_LENGTH = 32;
+
+	/** <b>Value</b> offset into AT segment where 'mode' variable (long) is stored. (Multiply by MachineState.VALUE_SIZE for byte offset). */
+	private static final int MODE_VALUE_OFFSET = 61;
+	/** <b>Byte</b> offset into AT state data where 'mode' variable (long) is stored. */
+	public static final int MODE_BYTE_OFFSET = MachineState.HEADER_LENGTH + (MODE_VALUE_OFFSET * MachineState.VALUE_SIZE);
+
+	public static class OfferMessageData {
+		public byte[] partnerDigibytePKH;
+		public byte[] hashOfSecretA;
+		public long lockTimeA;
+	}
+	public static final int OFFER_MESSAGE_LENGTH = 20 /*partnerDigibytePKH*/ + 20 /*hashOfSecretA*/ + 8 /*lockTimeA*/;
+	public static final int TRADE_MESSAGE_LENGTH = 32 /*partner's Qortal trade address (padded from 25 to 32)*/
+			+ 24 /*partner's Digibyte PKH (padded from 20 to 24)*/
+			+ 8 /*AT trade timeout (minutes)*/
+			+ 24 /*hash of secret-A (padded from 20 to 24)*/
+			+ 8 /*lockTimeA*/;
+	public static final int REDEEM_MESSAGE_LENGTH = 32 /*secret-A*/ + 32 /*partner's Qortal receiving address padded from 25 to 32*/;
+	public static final int CANCEL_MESSAGE_LENGTH = 32 /*AT creator's Qortal address*/;
+
+	private static DigibyteACCTv3 instance;
+
+	private DigibyteACCTv3() {
+	}
+
+	public static synchronized DigibyteACCTv3 getInstance() {
+		if (instance == null)
+			instance = new DigibyteACCTv3();
+
+		return instance;
+	}
+
+	@Override
+	public byte[] getCodeBytesHash() {
+		return CODE_BYTES_HASH;
+	}
+
+	@Override
+	public int getModeByteOffset() {
+		return MODE_BYTE_OFFSET;
+	}
+
+	@Override
+	public ForeignBlockchain getBlockchain() {
+		return Digibyte.getInstance();
+	}
+
+	/**
+	 * Returns Qortal AT creation bytes for cross-chain trading AT.
+	 * <p>
+	 * <tt>tradeTimeout</tt> (minutes) is the time window for the trade partner to send the
+	 * 32-byte secret to the AT, before the AT automatically refunds the AT's creator.
+	 * 
+	 * @param creatorTradeAddress AT creator's trade Qortal address
+	 * @param digibytePublicKeyHash 20-byte HASH160 of creator's trade Digibyte public key
+	 * @param qortAmount how much QORT to pay trade partner if they send correct 32-byte secrets to AT
+	 * @param digibyteAmount how much DGB the AT creator is expecting to trade
+	 * @param tradeTimeout suggested timeout for entire trade
+	 */
+	public static byte[] buildQortalAT(String creatorTradeAddress, byte[] digibytePublicKeyHash, long qortAmount, long digibyteAmount, int tradeTimeout) {
+		if (digibytePublicKeyHash.length != 20)
+			throw new IllegalArgumentException("Digibyte public key hash should be 20 bytes");
+
+		// Labels for data segment addresses
+		int addrCounter = 0;
+
+		// Constants (with corresponding dataByteBuffer.put*() calls below)
+
+		final int addrCreatorTradeAddress1 = addrCounter++;
+		final int addrCreatorTradeAddress2 = addrCounter++;
+		final int addrCreatorTradeAddress3 = addrCounter++;
+		final int addrCreatorTradeAddress4 = addrCounter++;
+
+		final int addrDigibytePublicKeyHash = addrCounter;
+		addrCounter += 4;
+
+		final int addrQortAmount = addrCounter++;
+		final int addrDigibyteAmount = addrCounter++;
+		final int addrTradeTimeout = addrCounter++;
+
+		final int addrMessageTxnType = addrCounter++;
+		final int addrExpectedTradeMessageLength = addrCounter++;
+		final int addrExpectedRedeemMessageLength = addrCounter++;
+
+		final int addrCreatorAddressPointer = addrCounter++;
+		final int addrQortalPartnerAddressPointer = addrCounter++;
+		final int addrMessageSenderPointer = addrCounter++;
+
+		final int addrTradeMessagePartnerDigibytePKHOffset = addrCounter++;
+		final int addrPartnerDigibytePKHPointer = addrCounter++;
+		final int addrTradeMessageHashOfSecretAOffset = addrCounter++;
+		final int addrHashOfSecretAPointer = addrCounter++;
+
+		final int addrRedeemMessageReceivingAddressOffset = addrCounter++;
+
+		final int addrMessageDataPointer = addrCounter++;
+		final int addrMessageDataLength = addrCounter++;
+
+		final int addrPartnerReceivingAddressPointer = addrCounter++;
+
+		final int addrEndOfConstants = addrCounter;
+
+		// Variables
+
+		final int addrCreatorAddress1 = addrCounter++;
+		final int addrCreatorAddress2 = addrCounter++;
+		final int addrCreatorAddress3 = addrCounter++;
+		final int addrCreatorAddress4 = addrCounter++;
+
+		final int addrQortalPartnerAddress1 = addrCounter++;
+		final int addrQortalPartnerAddress2 = addrCounter++;
+		final int addrQortalPartnerAddress3 = addrCounter++;
+		final int addrQortalPartnerAddress4 = addrCounter++;
+
+		final int addrLockTimeA = addrCounter++;
+		final int addrRefundTimeout = addrCounter++;
+		final int addrRefundTimestamp = addrCounter++;
+		final int addrLastTxnTimestamp = addrCounter++;
+		final int addrBlockTimestamp = addrCounter++;
+		final int addrTxnType = addrCounter++;
+		final int addrResult = addrCounter++;
+
+		final int addrMessageSender1 = addrCounter++;
+		final int addrMessageSender2 = addrCounter++;
+		final int addrMessageSender3 = addrCounter++;
+		final int addrMessageSender4 = addrCounter++;
+
+		final int addrMessageLength = addrCounter++;
+
+		final int addrMessageData = addrCounter;
+		addrCounter += 4;
+
+		final int addrHashOfSecretA = addrCounter;
+		addrCounter += 4;
+
+		final int addrPartnerDigibytePKH = addrCounter;
+		addrCounter += 4;
+
+		final int addrPartnerReceivingAddress = addrCounter;
+		addrCounter += 4;
+
+		final int addrMode = addrCounter++;
+		assert addrMode == MODE_VALUE_OFFSET : String.format("addrMode %d does not match MODE_VALUE_OFFSET %d", addrMode, MODE_VALUE_OFFSET);
+
+		// Data segment
+		ByteBuffer dataByteBuffer = ByteBuffer.allocate(addrCounter * MachineState.VALUE_SIZE);
+
+		// AT creator's trade Qortal address, decoded from Base58
+		assert dataByteBuffer.position() == addrCreatorTradeAddress1 * MachineState.VALUE_SIZE : "addrCreatorTradeAddress1 incorrect";
+		byte[] creatorTradeAddressBytes = Base58.decode(creatorTradeAddress);
+		dataByteBuffer.put(Bytes.ensureCapacity(creatorTradeAddressBytes, 32, 0));
+
+		// Digibyte public key hash
+		assert dataByteBuffer.position() == addrDigibytePublicKeyHash * MachineState.VALUE_SIZE : "addrDigibytePublicKeyHash incorrect";
+		dataByteBuffer.put(Bytes.ensureCapacity(digibytePublicKeyHash, 32, 0));
+
+		// Redeem Qort amount
+		assert dataByteBuffer.position() == addrQortAmount * MachineState.VALUE_SIZE : "addrQortAmount incorrect";
+		dataByteBuffer.putLong(qortAmount);
+
+		// Expected Digibyte amount
+		assert dataByteBuffer.position() == addrDigibyteAmount * MachineState.VALUE_SIZE : "addrDigibyteAmount incorrect";
+		dataByteBuffer.putLong(digibyteAmount);
+
+		// Suggested trade timeout (minutes)
+		assert dataByteBuffer.position() == addrTradeTimeout * MachineState.VALUE_SIZE : "addrTradeTimeout incorrect";
+		dataByteBuffer.putLong(tradeTimeout);
+
+		// We're only interested in MESSAGE transactions
+		assert dataByteBuffer.position() == addrMessageTxnType * MachineState.VALUE_SIZE : "addrMessageTxnType incorrect";
+		dataByteBuffer.putLong(API.ATTransactionType.MESSAGE.value);
+
+		// Expected length of 'trade' MESSAGE data from AT creator
+		assert dataByteBuffer.position() == addrExpectedTradeMessageLength * MachineState.VALUE_SIZE : "addrExpectedTradeMessageLength incorrect";
+		dataByteBuffer.putLong(TRADE_MESSAGE_LENGTH);
+
+		// Expected length of 'redeem' MESSAGE data from trade partner
+		assert dataByteBuffer.position() == addrExpectedRedeemMessageLength * MachineState.VALUE_SIZE : "addrExpectedRedeemMessageLength incorrect";
+		dataByteBuffer.putLong(REDEEM_MESSAGE_LENGTH);
+
+		// Index into data segment of AT creator's address, used by GET_B_IND
+		assert dataByteBuffer.position() == addrCreatorAddressPointer * MachineState.VALUE_SIZE : "addrCreatorAddressPointer incorrect";
+		dataByteBuffer.putLong(addrCreatorAddress1);
+
+		// Index into data segment of partner's Qortal address, used by SET_B_IND
+		assert dataByteBuffer.position() == addrQortalPartnerAddressPointer * MachineState.VALUE_SIZE : "addrQortalPartnerAddressPointer incorrect";
+		dataByteBuffer.putLong(addrQortalPartnerAddress1);
+
+		// Index into data segment of (temporary) transaction's sender's address, used by GET_B_IND
+		assert dataByteBuffer.position() == addrMessageSenderPointer * MachineState.VALUE_SIZE : "addrMessageSenderPointer incorrect";
+		dataByteBuffer.putLong(addrMessageSender1);
+
+		// Offset into 'trade' MESSAGE data payload for extracting partner's Digibyte PKH
+		assert dataByteBuffer.position() == addrTradeMessagePartnerDigibytePKHOffset * MachineState.VALUE_SIZE : "addrTradeMessagePartnerDigibytePKHOffset incorrect";
+		dataByteBuffer.putLong(32L);
+
+		// Index into data segment of partner's Digibyte PKH, used by GET_B_IND
+		assert dataByteBuffer.position() == addrPartnerDigibytePKHPointer * MachineState.VALUE_SIZE : "addrPartnerDigibytePKHPointer incorrect";
+		dataByteBuffer.putLong(addrPartnerDigibytePKH);
+
+		// Offset into 'trade' MESSAGE data payload for extracting hash-of-secret-A
+		assert dataByteBuffer.position() == addrTradeMessageHashOfSecretAOffset * MachineState.VALUE_SIZE : "addrTradeMessageHashOfSecretAOffset incorrect";
+		dataByteBuffer.putLong(64L);
+
+		// Index into data segment to hash of secret A, used by GET_B_IND
+		assert dataByteBuffer.position() == addrHashOfSecretAPointer * MachineState.VALUE_SIZE : "addrHashOfSecretAPointer incorrect";
+		dataByteBuffer.putLong(addrHashOfSecretA);
+
+		// Offset into 'redeem' MESSAGE data payload for extracting Qortal receiving address
+		assert dataByteBuffer.position() == addrRedeemMessageReceivingAddressOffset * MachineState.VALUE_SIZE : "addrRedeemMessageReceivingAddressOffset incorrect";
+		dataByteBuffer.putLong(32L);
+
+		// Source location and length for hashing any passed secret
+		assert dataByteBuffer.position() == addrMessageDataPointer * MachineState.VALUE_SIZE : "addrMessageDataPointer incorrect";
+		dataByteBuffer.putLong(addrMessageData);
+		assert dataByteBuffer.position() == addrMessageDataLength * MachineState.VALUE_SIZE : "addrMessageDataLength incorrect";
+		dataByteBuffer.putLong(32L);
+
+		// Pointer into data segment of where to save partner's receiving Qortal address, used by GET_B_IND
+		assert dataByteBuffer.position() == addrPartnerReceivingAddressPointer * MachineState.VALUE_SIZE : "addrPartnerReceivingAddressPointer incorrect";
+		dataByteBuffer.putLong(addrPartnerReceivingAddress);
+
+		assert dataByteBuffer.position() == addrEndOfConstants * MachineState.VALUE_SIZE : "dataByteBuffer position not at end of constants";
+
+		// Code labels
+		Integer labelRefund = null;
+
+		Integer labelTradeTxnLoop = null;
+		Integer labelCheckTradeTxn = null;
+		Integer labelCheckCancelTxn = null;
+		Integer labelNotTradeNorCancelTxn = null;
+		Integer labelCheckNonRefundTradeTxn = null;
+		Integer labelTradeTxnExtract = null;
+		Integer labelRedeemTxnLoop = null;
+		Integer labelCheckRedeemTxn = null;
+		Integer labelCheckRedeemTxnSender = null;
+		Integer labelPayout = null;
+
+		ByteBuffer codeByteBuffer = ByteBuffer.allocate(768);
+
+		// Two-pass version
+		for (int pass = 0; pass < 2; ++pass) {
+			codeByteBuffer.clear();
+
+			try {
+				/* Initialization */
+
+				// Use AT creation 'timestamp' as starting point for finding transactions sent to AT
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(FunctionCode.GET_CREATION_TIMESTAMP, addrLastTxnTimestamp));
+
+				/* NOP - to ensure DIGIBYTE ACCT is unique */
+				codeByteBuffer.put(OpCode.NOP.compile());
+
+				// Load B register with AT creator's address so we can save it into addrCreatorAddress1-4
+				codeByteBuffer.put(OpCode.EXT_FUN.compile(FunctionCode.PUT_CREATOR_INTO_B));
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.GET_B_IND, addrCreatorAddressPointer));
+
+				// Set restart position to after this opcode
+				codeByteBuffer.put(OpCode.SET_PCS.compile());
+
+				/* Loop, waiting for message from AT creator's trade address containing trade partner details, or AT owner's address to cancel offer */
+
+				/* Transaction processing loop */
+				labelTradeTxnLoop = codeByteBuffer.position();
+
+				/* Sleep until message arrives */
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(QortalFunctionCode.SLEEP_UNTIL_MESSAGE.value, addrLastTxnTimestamp));
+
+				// Find next transaction (if any) to this AT since the last one (referenced by addrLastTxnTimestamp)
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.PUT_TX_AFTER_TIMESTAMP_INTO_A, addrLastTxnTimestamp));
+				// If no transaction found, A will be zero. If A is zero, set addrResult to 1, otherwise 0.
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(FunctionCode.CHECK_A_IS_ZERO, addrResult));
+				// If addrResult is zero (i.e. A is non-zero, transaction was found) then go check transaction
+				codeByteBuffer.put(OpCode.BZR_DAT.compile(addrResult, calcOffset(codeByteBuffer, labelCheckTradeTxn)));
+				// Stop and wait for next block
+				codeByteBuffer.put(OpCode.STP_IMD.compile());
+
+				/* Check transaction */
+				labelCheckTradeTxn = codeByteBuffer.position();
+
+				// Update our 'last found transaction's timestamp' using 'timestamp' from transaction
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(FunctionCode.GET_TIMESTAMP_FROM_TX_IN_A, addrLastTxnTimestamp));
+				// Extract transaction type (message/payment) from transaction and save type in addrTxnType
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(FunctionCode.GET_TYPE_FROM_TX_IN_A, addrTxnType));
+				// If transaction type is not MESSAGE type then go look for another transaction
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrTxnType, addrMessageTxnType, calcOffset(codeByteBuffer, labelTradeTxnLoop)));
+
+				/* Check transaction's sender. We're expecting AT creator's trade address for 'trade' message, or AT creator's own address for 'cancel' message. */
+
+				// Extract sender address from transaction into B register
+				codeByteBuffer.put(OpCode.EXT_FUN.compile(FunctionCode.PUT_ADDRESS_FROM_TX_IN_A_INTO_B));
+				// Save B register into data segment starting at addrMessageSender1 (as pointed to by addrMessageSenderPointer)
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.GET_B_IND, addrMessageSenderPointer));
+				// Compare each part of message sender's address with AT creator's trade address. If they don't match, check for cancel situation.
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender1, addrCreatorTradeAddress1, calcOffset(codeByteBuffer, labelCheckCancelTxn)));
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender2, addrCreatorTradeAddress2, calcOffset(codeByteBuffer, labelCheckCancelTxn)));
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender3, addrCreatorTradeAddress3, calcOffset(codeByteBuffer, labelCheckCancelTxn)));
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender4, addrCreatorTradeAddress4, calcOffset(codeByteBuffer, labelCheckCancelTxn)));
+				// Message sender's address matches AT creator's trade address so go process 'trade' message
+				codeByteBuffer.put(OpCode.JMP_ADR.compile(labelCheckNonRefundTradeTxn == null ? 0 : labelCheckNonRefundTradeTxn));
+
+				/* Checking message sender for possible cancel message */
+				labelCheckCancelTxn = codeByteBuffer.position();
+
+				// Compare each part of message sender's address with AT creator's address. If they don't match, look for another transaction.
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender1, addrCreatorAddress1, calcOffset(codeByteBuffer, labelNotTradeNorCancelTxn)));
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender2, addrCreatorAddress2, calcOffset(codeByteBuffer, labelNotTradeNorCancelTxn)));
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender3, addrCreatorAddress3, calcOffset(codeByteBuffer, labelNotTradeNorCancelTxn)));
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender4, addrCreatorAddress4, calcOffset(codeByteBuffer, labelNotTradeNorCancelTxn)));
+				// Partner address is AT creator's address, so cancel offer and finish.
+				codeByteBuffer.put(OpCode.SET_VAL.compile(addrMode, AcctMode.CANCELLED.value));
+				// We're finished forever (finishing auto-refunds remaining balance to AT creator)
+				codeByteBuffer.put(OpCode.FIN_IMD.compile());
+
+				/* Not trade nor cancel message */
+				labelNotTradeNorCancelTxn = codeByteBuffer.position();
+
+				// Loop to find another transaction
+				codeByteBuffer.put(OpCode.JMP_ADR.compile(labelTradeTxnLoop == null ? 0 : labelTradeTxnLoop));
+
+				/* Possible switch-to-trade-mode message */
+				labelCheckNonRefundTradeTxn = codeByteBuffer.position();
+
+				// Check 'trade' message we received has expected number of message bytes
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(QortalFunctionCode.GET_MESSAGE_LENGTH_FROM_TX_IN_A.value, addrMessageLength));
+				// If message length matches, branch to info extraction code
+				codeByteBuffer.put(OpCode.BEQ_DAT.compile(addrMessageLength, addrExpectedTradeMessageLength, calcOffset(codeByteBuffer, labelTradeTxnExtract)));
+				// Message length didn't match - go back to finding another 'trade' MESSAGE transaction
+				codeByteBuffer.put(OpCode.JMP_ADR.compile(labelTradeTxnLoop == null ? 0 : labelTradeTxnLoop));
+
+				/* Extracting info from 'trade' MESSAGE transaction */
+				labelTradeTxnExtract = codeByteBuffer.position();
+
+				// Extract message from transaction into B register
+				codeByteBuffer.put(OpCode.EXT_FUN.compile(FunctionCode.PUT_MESSAGE_FROM_TX_IN_A_INTO_B));
+				// Save B register into data segment starting at addrQortalPartnerAddress1 (as pointed to by addrQortalPartnerAddressPointer)
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.GET_B_IND, addrQortalPartnerAddressPointer));
+
+				// Extract trade partner's Digibyte public key hash (PKH) from message into B
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(QortalFunctionCode.PUT_PARTIAL_MESSAGE_FROM_TX_IN_A_INTO_B.value, addrTradeMessagePartnerDigibytePKHOffset));
+				// Store partner's Digibyte PKH (we only really use values from B1-B3)
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.GET_B_IND, addrPartnerDigibytePKHPointer));
+				// Extract AT trade timeout (minutes) (from B4)
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(FunctionCode.GET_B4, addrRefundTimeout));
+
+				// Grab next 32 bytes
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(QortalFunctionCode.PUT_PARTIAL_MESSAGE_FROM_TX_IN_A_INTO_B.value, addrTradeMessageHashOfSecretAOffset));
+
+				// Extract hash-of-secret-A (we only really use values from B1-B3)
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.GET_B_IND, addrHashOfSecretAPointer));
+				// Extract lockTime-A (from B4)
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(FunctionCode.GET_B4, addrLockTimeA));
+
+				// Calculate trade timeout refund 'timestamp' by adding addrRefundTimeout minutes to this transaction's 'timestamp', then save into addrRefundTimestamp
+				codeByteBuffer.put(OpCode.EXT_FUN_RET_DAT_2.compile(FunctionCode.ADD_MINUTES_TO_TIMESTAMP, addrRefundTimestamp, addrLastTxnTimestamp, addrRefundTimeout));
+
+				/* We are in 'trade mode' */
+				codeByteBuffer.put(OpCode.SET_VAL.compile(addrMode, AcctMode.TRADING.value));
+
+				// Set restart position to after this opcode
+				codeByteBuffer.put(OpCode.SET_PCS.compile());
+
+				/* Loop, waiting for trade timeout or 'redeem' MESSAGE from Qortal trade partner */
+
+				// Fetch current block 'timestamp'
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(FunctionCode.GET_BLOCK_TIMESTAMP, addrBlockTimestamp));
+				// If we're not past refund 'timestamp' then look for next transaction
+				codeByteBuffer.put(OpCode.BLT_DAT.compile(addrBlockTimestamp, addrRefundTimestamp, calcOffset(codeByteBuffer, labelRedeemTxnLoop)));
+				// We're past refund 'timestamp' so go refund everything back to AT creator
+				codeByteBuffer.put(OpCode.JMP_ADR.compile(labelRefund == null ? 0 : labelRefund));
+
+				/* Transaction processing loop */
+				labelRedeemTxnLoop = codeByteBuffer.position();
+
+				// Find next transaction to this AT since the last one (if any)
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.PUT_TX_AFTER_TIMESTAMP_INTO_A, addrLastTxnTimestamp));
+				// If no transaction found, A will be zero. If A is zero, set addrComparator to 1, otherwise 0.
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(FunctionCode.CHECK_A_IS_ZERO, addrResult));
+				// If addrResult is zero (i.e. A is non-zero, transaction was found) then go check transaction
+				codeByteBuffer.put(OpCode.BZR_DAT.compile(addrResult, calcOffset(codeByteBuffer, labelCheckRedeemTxn)));
+				// Stop and wait for next block
+				codeByteBuffer.put(OpCode.STP_IMD.compile());
+
+				/* Check transaction */
+				labelCheckRedeemTxn = codeByteBuffer.position();
+
+				// Update our 'last found transaction's timestamp' using 'timestamp' from transaction
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(FunctionCode.GET_TIMESTAMP_FROM_TX_IN_A, addrLastTxnTimestamp));
+				// Extract transaction type (message/payment) from transaction and save type in addrTxnType
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(FunctionCode.GET_TYPE_FROM_TX_IN_A, addrTxnType));
+				// If transaction type is not MESSAGE type then go look for another transaction
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrTxnType, addrMessageTxnType, calcOffset(codeByteBuffer, labelRedeemTxnLoop)));
+
+				/* Check message payload length */
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(QortalFunctionCode.GET_MESSAGE_LENGTH_FROM_TX_IN_A.value, addrMessageLength));
+				// If message length matches, branch to sender checking code
+				codeByteBuffer.put(OpCode.BEQ_DAT.compile(addrMessageLength, addrExpectedRedeemMessageLength, calcOffset(codeByteBuffer, labelCheckRedeemTxnSender)));
+				// Message length didn't match - go back to finding another 'redeem' MESSAGE transaction
+				codeByteBuffer.put(OpCode.JMP_ADR.compile(labelRedeemTxnLoop == null ? 0 : labelRedeemTxnLoop));
+
+				/* Check transaction's sender */
+				labelCheckRedeemTxnSender = codeByteBuffer.position();
+
+				// Extract sender address from transaction into B register
+				codeByteBuffer.put(OpCode.EXT_FUN.compile(FunctionCode.PUT_ADDRESS_FROM_TX_IN_A_INTO_B));
+				// Save B register into data segment starting at addrMessageSender1 (as pointed to by addrMessageSenderPointer)
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.GET_B_IND, addrMessageSenderPointer));
+				// Compare each part of transaction's sender's address with expected address. If they don't match, look for another transaction.
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender1, addrQortalPartnerAddress1, calcOffset(codeByteBuffer, labelRedeemTxnLoop)));
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender2, addrQortalPartnerAddress2, calcOffset(codeByteBuffer, labelRedeemTxnLoop)));
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender3, addrQortalPartnerAddress3, calcOffset(codeByteBuffer, labelRedeemTxnLoop)));
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender4, addrQortalPartnerAddress4, calcOffset(codeByteBuffer, labelRedeemTxnLoop)));
+
+				/* Check 'secret-A' in transaction's message */
+
+				// Extract secret-A from first 32 bytes of message from transaction into B register
+				codeByteBuffer.put(OpCode.EXT_FUN.compile(FunctionCode.PUT_MESSAGE_FROM_TX_IN_A_INTO_B));
+				// Save B register into data segment starting at addrMessageData (as pointed to by addrMessageDataPointer)
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.GET_B_IND, addrMessageDataPointer));
+				// Load B register with expected hash result (as pointed to by addrHashOfSecretAPointer)
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.SET_B_IND, addrHashOfSecretAPointer));
+				// Perform HASH160 using source data at addrMessageData. (Location and length specified via addrMessageDataPointer and addrMessageDataLength).
+				// Save the equality result (1 if they match, 0 otherwise) into addrResult.
+				codeByteBuffer.put(OpCode.EXT_FUN_RET_DAT_2.compile(FunctionCode.CHECK_HASH160_WITH_B, addrResult, addrMessageDataPointer, addrMessageDataLength));
+				// If hashes don't match, addrResult will be zero so go find another transaction
+				codeByteBuffer.put(OpCode.BNZ_DAT.compile(addrResult, calcOffset(codeByteBuffer, labelPayout)));
+				codeByteBuffer.put(OpCode.JMP_ADR.compile(labelRedeemTxnLoop == null ? 0 : labelRedeemTxnLoop));
+
+				/* Success! Pay arranged amount to receiving address */
+				labelPayout = codeByteBuffer.position();
+
+				// Extract Qortal receiving address from next 32 bytes of message from transaction into B register
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(QortalFunctionCode.PUT_PARTIAL_MESSAGE_FROM_TX_IN_A_INTO_B.value, addrRedeemMessageReceivingAddressOffset));
+				// Save B register into data segment starting at addrPartnerReceivingAddress (as pointed to by addrPartnerReceivingAddressPointer)
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.GET_B_IND, addrPartnerReceivingAddressPointer));
+				// Pay AT's balance to receiving address
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.PAY_TO_ADDRESS_IN_B, addrQortAmount));
+				// Set redeemed mode
+				codeByteBuffer.put(OpCode.SET_VAL.compile(addrMode, AcctMode.REDEEMED.value));
+				// We're finished forever (finishing auto-refunds remaining balance to AT creator)
+				codeByteBuffer.put(OpCode.FIN_IMD.compile());
+
+				// Fall-through to refunding any remaining balance back to AT creator
+
+				/* Refund balance back to AT creator */
+				labelRefund = codeByteBuffer.position();
+
+				// Set refunded mode
+				codeByteBuffer.put(OpCode.SET_VAL.compile(addrMode, AcctMode.REFUNDED.value));
+				// We're finished forever (finishing auto-refunds remaining balance to AT creator)
+				codeByteBuffer.put(OpCode.FIN_IMD.compile());
+			} catch (CompilationException e) {
+				throw new IllegalStateException("Unable to compile DGB-QORT ACCT?", e);
+			}
+		}
+
+		codeByteBuffer.flip();
+
+		byte[] codeBytes = new byte[codeByteBuffer.limit()];
+		codeByteBuffer.get(codeBytes);
+
+		assert Arrays.equals(Crypto.digest(codeBytes), DigibyteACCTv3.CODE_BYTES_HASH)
+			: String.format("BTCACCT.CODE_BYTES_HASH mismatch: expected %s, actual %s", HashCode.fromBytes(CODE_BYTES_HASH), HashCode.fromBytes(Crypto.digest(codeBytes)));
+
+		final short ciyamAtVersion = 2;
+		final short numCallStackPages = 0;
+		final short numUserStackPages = 0;
+		final long minActivationAmount = 0L;
+
+		return MachineState.toCreationBytes(ciyamAtVersion, codeBytes, dataByteBuffer.array(), numCallStackPages, numUserStackPages, minActivationAmount);
+	}
+
+	/**
+	 * Returns CrossChainTradeData with useful info extracted from AT.
+	 */
+	@Override
+	public CrossChainTradeData populateTradeData(Repository repository, ATData atData) throws DataException {
+		ATStateData atStateData = repository.getATRepository().getLatestATState(atData.getATAddress());
+		return populateTradeData(repository, atData.getCreatorPublicKey(), atData.getCreation(), atStateData);
+	}
+
+	/**
+	 * Returns CrossChainTradeData with useful info extracted from AT.
+	 */
+	@Override
+	public CrossChainTradeData populateTradeData(Repository repository, ATStateData atStateData) throws DataException {
+		ATData atData = repository.getATRepository().fromATAddress(atStateData.getATAddress());
+		return populateTradeData(repository, atData.getCreatorPublicKey(), atData.getCreation(), atStateData);
+	}
+
+	/**
+	 * Returns CrossChainTradeData with useful info extracted from AT.
+	 */
+	public CrossChainTradeData populateTradeData(Repository repository, byte[] creatorPublicKey, long creationTimestamp, ATStateData atStateData) throws DataException {
+		byte[] addressBytes = new byte[25]; // for general use
+		String atAddress = atStateData.getATAddress();
+
+		CrossChainTradeData tradeData = new CrossChainTradeData();
+
+		tradeData.foreignBlockchain = SupportedBlockchain.DIGIBYTE.name();
+		tradeData.acctName = NAME;
+
+		tradeData.qortalAtAddress = atAddress;
+		tradeData.qortalCreator = Crypto.toAddress(creatorPublicKey);
+		tradeData.creationTimestamp = creationTimestamp;
+
+		Account atAccount = new Account(repository, atAddress);
+		tradeData.qortBalance = atAccount.getConfirmedBalance(Asset.QORT);
+
+		byte[] stateData = atStateData.getStateData();
+		ByteBuffer dataByteBuffer = ByteBuffer.wrap(stateData);
+		dataByteBuffer.position(MachineState.HEADER_LENGTH);
+
+		/* Constants */
+
+		// Skip creator's trade address
+		dataByteBuffer.get(addressBytes);
+		tradeData.qortalCreatorTradeAddress = Base58.encode(addressBytes);
+		dataByteBuffer.position(dataByteBuffer.position() + 32 - addressBytes.length);
+
+		// Creator's Digibyte/foreign public key hash
+		tradeData.creatorForeignPKH = new byte[20];
+		dataByteBuffer.get(tradeData.creatorForeignPKH);
+		dataByteBuffer.position(dataByteBuffer.position() + 32 - tradeData.creatorForeignPKH.length); // skip to 32 bytes
+
+		// We don't use secret-B
+		tradeData.hashOfSecretB = null;
+
+		// Redeem payout
+		tradeData.qortAmount = dataByteBuffer.getLong();
+
+		// Expected DGB amount
+		tradeData.expectedForeignAmount = dataByteBuffer.getLong();
+
+		// Trade timeout
+		tradeData.tradeTimeout = (int) dataByteBuffer.getLong();
+
+		// Skip MESSAGE transaction type
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip expected 'trade' message length
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip expected 'redeem' message length
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip pointer to creator's address
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip pointer to partner's Qortal trade address
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip pointer to message sender
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip 'trade' message data offset for partner's Digibyte PKH
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip pointer to partner's Digibyte PKH
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip 'trade' message data offset for hash-of-secret-A
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip pointer to hash-of-secret-A
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip 'redeem' message data offset for partner's Qortal receiving address
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip pointer to message data
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip message data length
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip pointer to partner's receiving address
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		/* End of constants / begin variables */
+
+		// Skip AT creator's address
+		dataByteBuffer.position(dataByteBuffer.position() + 8 * 4);
+
+		// Partner's trade address (if present)
+		dataByteBuffer.get(addressBytes);
+		String qortalRecipient = Base58.encode(addressBytes);
+		dataByteBuffer.position(dataByteBuffer.position() + 32 - addressBytes.length);
+
+		// Potential lockTimeA (if in trade mode)
+		int lockTimeA = (int) dataByteBuffer.getLong();
+
+		// AT refund timeout (probably only useful for debugging)
+		int refundTimeout = (int) dataByteBuffer.getLong();
+
+		// Trade-mode refund timestamp (AT 'timestamp' converted to Qortal block height)
+		long tradeRefundTimestamp = dataByteBuffer.getLong();
+
+		// Skip last transaction timestamp
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip block timestamp
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip transaction type
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip temporary result
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip temporary message sender
+		dataByteBuffer.position(dataByteBuffer.position() + 8 * 4);
+
+		// Skip message length
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip temporary message data
+		dataByteBuffer.position(dataByteBuffer.position() + 8 * 4);
+
+		// Potential hash160 of secret A
+		byte[] hashOfSecretA = new byte[20];
+		dataByteBuffer.get(hashOfSecretA);
+		dataByteBuffer.position(dataByteBuffer.position() + 32 - hashOfSecretA.length); // skip to 32 bytes
+
+		// Potential partner's Digibyte PKH
+		byte[] partnerDigibytePKH = new byte[20];
+		dataByteBuffer.get(partnerDigibytePKH);
+		dataByteBuffer.position(dataByteBuffer.position() + 32 - partnerDigibytePKH.length); // skip to 32 bytes
+
+		// Partner's receiving address (if present)
+		byte[] partnerReceivingAddress = new byte[25];
+		dataByteBuffer.get(partnerReceivingAddress);
+		dataByteBuffer.position(dataByteBuffer.position() + 32 - partnerReceivingAddress.length); // skip to 32 bytes
+
+		// Trade AT's 'mode'
+		long modeValue = dataByteBuffer.getLong();
+		AcctMode mode = AcctMode.valueOf((int) (modeValue & 0xffL));
+
+		/* End of variables */
+
+		if (mode != null && mode != AcctMode.OFFERING) {
+			tradeData.mode = mode;
+			tradeData.refundTimeout = refundTimeout;
+			tradeData.tradeRefundHeight = new Timestamp(tradeRefundTimestamp).blockHeight;
+			tradeData.qortalPartnerAddress = qortalRecipient;
+			tradeData.hashOfSecretA = hashOfSecretA;
+			tradeData.partnerForeignPKH = partnerDigibytePKH;
+			tradeData.lockTimeA = lockTimeA;
+
+			if (mode == AcctMode.REDEEMED)
+				tradeData.qortalPartnerReceivingAddress = Base58.encode(partnerReceivingAddress);
+		} else {
+			tradeData.mode = AcctMode.OFFERING;
+		}
+
+		tradeData.duplicateDeprecated();
+
+		return tradeData;
+	}
+
+	/** Returns 'offer' MESSAGE payload for trade partner to send to AT creator's trade address. */
+	public static byte[] buildOfferMessage(byte[] partnerBitcoinPKH, byte[] hashOfSecretA, int lockTimeA) {
+		byte[] lockTimeABytes = BitTwiddling.toBEByteArray((long) lockTimeA);
+		return Bytes.concat(partnerBitcoinPKH, hashOfSecretA, lockTimeABytes);
+	}
+
+	/** Returns info extracted from 'offer' MESSAGE payload sent by trade partner to AT creator's trade address, or null if not valid. */
+	public static OfferMessageData extractOfferMessageData(byte[] messageData) {
+		if (messageData == null || messageData.length != OFFER_MESSAGE_LENGTH)
+			return null;
+
+		OfferMessageData offerMessageData = new OfferMessageData();
+		offerMessageData.partnerDigibytePKH = Arrays.copyOfRange(messageData, 0, 20);
+		offerMessageData.hashOfSecretA = Arrays.copyOfRange(messageData, 20, 40);
+		offerMessageData.lockTimeA = BitTwiddling.longFromBEBytes(messageData, 40);
+
+		return offerMessageData;
+	}
+
+	/** Returns 'trade' MESSAGE payload for AT creator to send to AT. */
+	public static byte[] buildTradeMessage(String partnerQortalTradeAddress, byte[] partnerBitcoinPKH, byte[] hashOfSecretA, int lockTimeA, int refundTimeout) {
+		byte[] data = new byte[TRADE_MESSAGE_LENGTH];
+		byte[] partnerQortalAddressBytes = Base58.decode(partnerQortalTradeAddress);
+		byte[] lockTimeABytes = BitTwiddling.toBEByteArray((long) lockTimeA);
+		byte[] refundTimeoutBytes = BitTwiddling.toBEByteArray((long) refundTimeout);
+
+		System.arraycopy(partnerQortalAddressBytes, 0, data, 0, partnerQortalAddressBytes.length);
+		System.arraycopy(partnerBitcoinPKH, 0, data, 32, partnerBitcoinPKH.length);
+		System.arraycopy(refundTimeoutBytes, 0, data, 56, refundTimeoutBytes.length);
+		System.arraycopy(hashOfSecretA, 0, data, 64, hashOfSecretA.length);
+		System.arraycopy(lockTimeABytes, 0, data, 88, lockTimeABytes.length);
+
+		return data;
+	}
+
+	/** Returns 'cancel' MESSAGE payload for AT creator to cancel trade AT. */
+	@Override
+	public byte[] buildCancelMessage(String creatorQortalAddress) {
+		byte[] data = new byte[CANCEL_MESSAGE_LENGTH];
+		byte[] creatorQortalAddressBytes = Base58.decode(creatorQortalAddress);
+
+		System.arraycopy(creatorQortalAddressBytes, 0, data, 0, creatorQortalAddressBytes.length);
+
+		return data;
+	}
+
+	/** Returns 'redeem' MESSAGE payload for trade partner to send to AT. */
+	public static byte[] buildRedeemMessage(byte[] secretA, String qortalReceivingAddress) {
+		byte[] data = new byte[REDEEM_MESSAGE_LENGTH];
+		byte[] qortalReceivingAddressBytes = Base58.decode(qortalReceivingAddress);
+
+		System.arraycopy(secretA, 0, data, 0, secretA.length);
+		System.arraycopy(qortalReceivingAddressBytes, 0, data, 32, qortalReceivingAddressBytes.length);
+
+		return data;
+	}
+
+	/** Returns refund timeout (minutes) based on trade partner's 'offer' MESSAGE timestamp and P2SH-A locktime. */
+	public static int calcRefundTimeout(long offerMessageTimestamp, int lockTimeA) {
+		// refund should be triggered halfway between offerMessageTimestamp and lockTimeA
+		return (int) ((lockTimeA - (offerMessageTimestamp / 1000L)) / 2L / 60L);
+	}
+
+	@Override
+	public byte[] findSecretA(Repository repository, CrossChainTradeData crossChainTradeData) throws DataException {
+		String atAddress = crossChainTradeData.qortalAtAddress;
+		String redeemerAddress = crossChainTradeData.qortalPartnerAddress;
+
+		// We don't have partner's public key so we check every message to AT
+		List<MessageTransactionData> messageTransactionsData = repository.getMessageRepository().getMessagesByParticipants(null, atAddress, null, null, null);
+		if (messageTransactionsData == null)
+			return null;
+
+		// Find 'redeem' message
+		for (MessageTransactionData messageTransactionData : messageTransactionsData) {
+			// Check message payload type/encryption
+			if (messageTransactionData.isText() || messageTransactionData.isEncrypted())
+				continue;
+
+			// Check message payload size
+			byte[] messageData = messageTransactionData.getData();
+			if (messageData.length != REDEEM_MESSAGE_LENGTH)
+				// Wrong payload length
+				continue;
+
+			// Check sender
+			if (!Crypto.toAddress(messageTransactionData.getSenderPublicKey()).equals(redeemerAddress))
+				// Wrong sender;
+				continue;
+
+			// Extract secretA
+			byte[] secretA = new byte[32];
+			System.arraycopy(messageData, 0, secretA, 0, secretA.length);
+
+			byte[] hashOfSecretA = Crypto.hash160(secretA);
+			if (!Arrays.equals(hashOfSecretA, crossChainTradeData.hashOfSecretA))
+				continue;
+
+			return secretA;
+		}
+
+		return null;
+	}
+
+}

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

@@ -45,9 +45,9 @@ public class Dogecoin extends Bitcoiny {
 			public Collection<Server> getServers() {
 				return Arrays.asList(
 						// Servers chosen on NO BASIS WHATSOEVER from various sources!
-						new Server("electrum1.cipig.net", ConnectionType.TCP, 10060),
-						new Server("electrum2.cipig.net", ConnectionType.TCP, 10060),
-						new Server("electrum3.cipig.net", ConnectionType.TCP, 10060));
+						new Server("electrum1.cipig.net", ConnectionType.SSL, 20060),
+						new Server("electrum2.cipig.net", ConnectionType.SSL, 20060),
+						new Server("electrum3.cipig.net", ConnectionType.SSL, 20060));
 						// TODO: add more mainnet servers. It's too centralized.
 			}
 
@@ -135,6 +135,8 @@ public class Dogecoin extends Bitcoiny {
 			Context bitcoinjContext = new Context(dogecoinNet.getParams());
 
 			instance = new Dogecoin(dogecoinNet, electrumX, bitcoinjContext, CURRENCY_CODE);
+
+			electrumX.setBlockchain(instance);
 		}
 
 		return instance;

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

@@ -11,6 +11,7 @@ import java.util.regex.Pattern;
 
 import javax.net.ssl.SSLSocketFactory;
 
+import cash.z.wallet.sdk.rpc.CompactFormats.*;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.json.simple.JSONArray;
@@ -107,6 +108,7 @@ public class ElectrumX extends BitcoinyBlockchainProvider {
 	private final String netId;
 	private final String expectedGenesisHash;
 	private final Map<Server.ConnectionType, Integer> defaultPorts = new EnumMap<>(Server.ConnectionType.class);
+	private Bitcoiny blockchain;
 
 	private final Object serverLock = new Object();
 	private Server currentServer;
@@ -135,6 +137,11 @@ public class ElectrumX extends BitcoinyBlockchainProvider {
 
 	// Methods for use by other classes
 
+	@Override
+	public void setBlockchain(Bitcoiny blockchain) {
+		this.blockchain = blockchain;
+	}
+
 	@Override
 	public String getNetId() {
 		return this.netId;
@@ -161,6 +168,16 @@ public class ElectrumX extends BitcoinyBlockchainProvider {
 		return ((Long) heightObj).intValue();
 	}
 
+	/**
+	 * Returns list of raw blocks, starting from <tt>startHeight</tt> inclusive.
+	 * <p>
+	 * @throws ForeignBlockchainException if error occurs
+	 */
+	@Override
+	public List<CompactBlock> getCompactBlocks(int startHeight, int count) throws ForeignBlockchainException {
+		throw new ForeignBlockchainException("getCompactBlocks not implemented for ElectrumX due to being specific to zcash");
+	}
+
 	/**
 	 * Returns list of raw block headers, starting from <tt>startHeight</tt> inclusive.
 	 * <p>
@@ -222,6 +239,17 @@ public class ElectrumX extends BitcoinyBlockchainProvider {
 		return rawBlockHeaders;
 	}
 
+	/**
+	 * Returns list of raw block timestamps, starting from <tt>startHeight</tt> inclusive.
+	 * <p>
+	 * @throws ForeignBlockchainException if error occurs
+	 */
+	@Override
+	public List<Long> getBlockTimestamps(int startHeight, int count) throws ForeignBlockchainException {
+		// FUTURE: implement this if needed. For now we use getRawBlockHeaders directly
+		throw new ForeignBlockchainException("getBlockTimestamps not yet implemented for ElectrumX");
+	}
+
 	/**
 	 * Returns confirmed balance, based on passed payment script.
 	 * <p>
@@ -247,6 +275,29 @@ public class ElectrumX extends BitcoinyBlockchainProvider {
 		return (Long) balanceJson.get("confirmed");
 	}
 
+	/**
+	 * Returns confirmed balance, based on passed base58 encoded address.
+	 * <p>
+	 * @return confirmed balance, or zero if address unknown
+	 * @throws ForeignBlockchainException if there was an error
+	 */
+	@Override
+	public long getConfirmedAddressBalance(String base58Address) throws ForeignBlockchainException {
+		throw new ForeignBlockchainException("getConfirmedAddressBalance not yet implemented for ElectrumX");
+	}
+
+	/**
+	 * Returns list of unspent outputs pertaining to passed address.
+	 * <p>
+	 * @return list of unspent outputs, or empty list if address unknown
+	 * @throws ForeignBlockchainException if there was an error.
+	 */
+	@Override
+	public List<UnspentOutput> getUnspentOutputs(String address, boolean includeUnconfirmed) throws ForeignBlockchainException {
+		byte[] script = this.blockchain.addressToScriptPubKey(address);
+		return this.getUnspentOutputs(script, includeUnconfirmed);
+	}
+
 	/**
 	 * Returns list of unspent outputs pertaining to passed payment script.
 	 * <p>
@@ -482,6 +533,12 @@ public class ElectrumX extends BitcoinyBlockchainProvider {
 		return transactionHashes;
 	}
 
+	@Override
+	public List<BitcoinyTransaction> getAddressBitcoinyTransactions(String address, boolean includeUnconfirmed) throws ForeignBlockchainException {
+		// FUTURE: implement this if needed. For now we use getAddressTransactions() + getTransaction()
+		throw new ForeignBlockchainException("getAddressBitcoinyTransactions not yet implemented for ElectrumX");
+	}
+
 	/**
 	 * Broadcasts raw transaction to network.
 	 * <p>
@@ -682,6 +739,10 @@ public class ElectrumX extends BitcoinyBlockchainProvider {
 		} catch (IOException | NoSuchElementException e) {
 			// Unable to send, or receive -- try another server?
 			return null;
+		} catch (NoSuchMethodError e) {
+			// Likely an SSL dependency issue - retries are unlikely to succeed
+			LOGGER.error("ElectrumX output stream error", e);
+			return null;
 		}
 
 		long endTime = System.currentTimeMillis();

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

@@ -0,0 +1,254 @@
+/*
+ * Copyright 2011 Google Inc.
+ * Copyright 2014 Giannis Dzegoutanis
+ * Copyright 2015 Andreas Schildbach
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* Updated for Zcash in May 2022 by Qortal core dev team. Modifications allow
+* correct encoding of P2SH (t3) addresses only. */
+
+package org.qortal.crosschain;
+
+import org.bitcoinj.core.*;
+import org.bitcoinj.params.Networks;
+import org.bitcoinj.script.Script.ScriptType;
+
+import javax.annotation.Nullable;
+import java.util.Arrays;
+import java.util.Objects;
+
+/**
+ * <p>A Bitcoin address looks like 1MsScoe2fTJoq4ZPdQgqyhgWeoNamYPevy and is derived from an elliptic curve public key
+ * plus a set of network parameters. Not to be confused with a {@link PeerAddress} or {@link AddressMessage}
+ * which are about network (TCP) addresses.</p>
+ *
+ * <p>A standard address is built by taking the RIPE-MD160 hash of the public key bytes, with a version prefix and a
+ * checksum suffix, then encoding it textually as base58. The version prefix is used to both denote the network for
+ * which the address is valid (see {@link NetworkParameters}, and also to indicate how the bytes inside the address
+ * should be interpreted. Whilst almost all addresses today are hashes of public keys, another (currently unsupported
+ * type) can contain a hash of a script instead.</p>
+ */
+public class LegacyZcashAddress extends Address {
+    /**
+     * An address is a RIPEMD160 hash of a public key, therefore is always 160 bits or 20 bytes.
+     */
+    public static final int LENGTH = 20;
+
+    /** True if P2SH, false if P2PKH. */
+    public final boolean p2sh;
+
+    /* Zcash P2SH header bytes */
+    private static int P2SH_HEADER_1 = 28;
+    private static int P2SH_HEADER_2 = 189;
+
+    /**
+     * Private constructor. Use {@link #fromBase58(NetworkParameters, String)},
+     * {@link #fromPubKeyHash(NetworkParameters, byte[])}, {@link #fromScriptHash(NetworkParameters, byte[])} or
+     * {@link #fromKey(NetworkParameters, ECKey)}.
+     * 
+     * @param params
+     *            network this address is valid for
+     * @param p2sh
+     *            true if hash160 is hash of a script, false if it is hash of a pubkey
+     * @param hash160
+     *            20-byte hash of pubkey or script
+     */
+    private LegacyZcashAddress(NetworkParameters params, boolean p2sh, byte[] hash160) throws AddressFormatException {
+        super(params, hash160);
+        if (hash160.length != 20)
+            throw new AddressFormatException.InvalidDataLength(
+                    "Legacy addresses are 20 byte (160 bit) hashes, but got: " + hash160.length);
+        this.p2sh = p2sh;
+    }
+
+    /**
+     * Construct a {@link LegacyZcashAddress} that represents the given pubkey hash. The resulting address will be a P2PKH type of
+     * address.
+     * 
+     * @param params
+     *            network this address is valid for
+     * @param hash160
+     *            20-byte pubkey hash
+     * @return constructed address
+     */
+    public static LegacyZcashAddress fromPubKeyHash(NetworkParameters params, byte[] hash160) throws AddressFormatException {
+        return new LegacyZcashAddress(params, false, hash160);
+    }
+
+    /**
+     * Construct a {@link LegacyZcashAddress} that represents the public part of the given {@link ECKey}. Note that an address is
+     * derived from a hash of the public key and is not the public key itself.
+     * 
+     * @param params
+     *            network this address is valid for
+     * @param key
+     *            only the public part is used
+     * @return constructed address
+     */
+    public static LegacyZcashAddress fromKey(NetworkParameters params, ECKey key) {
+        return fromPubKeyHash(params, key.getPubKeyHash());
+    }
+
+    /**
+     * Construct a {@link LegacyZcashAddress} that represents the given P2SH script hash.
+     * 
+     * @param params
+     *            network this address is valid for
+     * @param hash160
+     *            P2SH script hash
+     * @return constructed address
+     */
+    public static LegacyZcashAddress fromScriptHash(NetworkParameters params, byte[] hash160) throws AddressFormatException {
+        return new LegacyZcashAddress(params, true, hash160);
+    }
+
+    /**
+     * Construct a {@link LegacyZcashAddress} from its base58 form.
+     * 
+     * @param params
+     *            expected network this address is valid for, or null if if the network should be derived from the
+     *            base58
+     * @param base58
+     *            base58-encoded textual form of the address
+     * @throws AddressFormatException
+     *             if the given base58 doesn't parse or the checksum is invalid
+     * @throws AddressFormatException.WrongNetwork
+     *             if the given address is valid but for a different chain (eg testnet vs mainnet)
+     */
+    public static LegacyZcashAddress fromBase58(@Nullable NetworkParameters params, String base58)
+            throws AddressFormatException, AddressFormatException.WrongNetwork {
+        byte[] versionAndDataBytes = Base58.decodeChecked(base58);
+        int version = versionAndDataBytes[0] & 0xFF;
+        byte[] bytes = Arrays.copyOfRange(versionAndDataBytes, 1, versionAndDataBytes.length);
+        if (params == null) {
+            for (NetworkParameters p : Networks.get()) {
+                if (version == p.getAddressHeader())
+                    return new LegacyZcashAddress(p, false, bytes);
+                else if (version == p.getP2SHHeader())
+                    return new LegacyZcashAddress(p, true, bytes);
+            }
+            throw new AddressFormatException.InvalidPrefix("No network found for " + base58);
+        } else {
+            if (version == params.getAddressHeader())
+                return new LegacyZcashAddress(params, false, bytes);
+            else if (version == params.getP2SHHeader())
+                return new LegacyZcashAddress(params, true, bytes);
+            throw new AddressFormatException.WrongNetwork(version);
+        }
+    }
+
+    /**
+     * Get the version header of an address. This is the first byte of a base58 encoded address.
+     * 
+     * @return version header as one byte
+     */
+    public int getVersion() {
+        return p2sh ? params.getP2SHHeader() : params.getAddressHeader();
+    }
+
+    /**
+     * Returns the base58-encoded textual form, including version and checksum bytes.
+     * 
+     * @return textual form
+     */
+    public String toBase58() {
+        return this.encodeChecked(getVersion(), bytes);
+    }
+
+    /** The (big endian) 20 byte hash that is the core of a Bitcoin address. */
+    @Override
+    public byte[] getHash() {
+        return bytes;
+    }
+
+    /**
+     * Get the type of output script that will be used for sending to the address. This is either
+     * {@link ScriptType#P2PKH} or {@link ScriptType#P2SH}.
+     * 
+     * @return type of output script
+     */
+    @Override
+    public ScriptType getOutputScriptType() {
+        return p2sh ? ScriptType.P2SH : ScriptType.P2PKH;
+    }
+
+    /**
+     * Given an address, examines the version byte and attempts to find a matching NetworkParameters. If you aren't sure
+     * which network the address is intended for (eg, it was provided by a user), you can use this to decide if it is
+     * compatible with the current wallet.
+     * 
+     * @return network the address is valid for
+     * @throws AddressFormatException if the given base58 doesn't parse or the checksum is invalid
+     */
+    public static NetworkParameters getParametersFromAddress(String address) throws AddressFormatException {
+        return LegacyZcashAddress.fromBase58(null, address).getParameters();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o)
+            return true;
+        if (o == null || getClass() != o.getClass())
+            return false;
+        LegacyZcashAddress other = (LegacyZcashAddress) o;
+        return super.equals(other) && this.p2sh == other.p2sh;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(super.hashCode(), p2sh);
+    }
+
+    @Override
+    public String toString() {
+        return toBase58();
+    }
+
+    @Override
+    public LegacyZcashAddress clone() throws CloneNotSupportedException {
+        return (LegacyZcashAddress) super.clone();
+    }
+
+    public static String encodeChecked(int version, byte[] payload) {
+        if (version < 0 || version > 255)
+            throw new IllegalArgumentException("Version not in range.");
+
+        // A stringified buffer is:
+        // 1 byte version + data bytes + 4 bytes check code (a truncated hash)
+        byte[] addressBytes = new byte[2 + payload.length + 4];
+        addressBytes[0] = (byte) P2SH_HEADER_1;
+        addressBytes[1] = (byte) P2SH_HEADER_2;
+        System.arraycopy(payload, 0, addressBytes, 2, payload.length);
+        byte[] checksum = Sha256Hash.hashTwice(addressBytes, 0, payload.length + 2);
+        System.arraycopy(checksum, 0, addressBytes, payload.length + 2, 4);
+        return Base58.encode(addressBytes);
+    }
+
+//    // Comparator for LegacyAddress, left argument must be LegacyAddress, right argument can be any Address
+//    private static final Comparator<Address> LEGACY_ADDRESS_COMPARATOR = Address.PARTIAL_ADDRESS_COMPARATOR
+//            .thenComparingInt(a -> ((LegacyZcashAddress) a).getVersion())                    // Then compare Legacy address version byte
+//            .thenComparing(a -> a.bytes, UnsignedBytes.lexicographicalComparator());    // Then compare Legacy bytes
+//
+//    /**
+//     * {@inheritDoc}
+//     *
+//     * @param o other {@code Address} object
+//     * @return comparison result
+//     */
+//    @Override
+//    public int compareTo(Address o) {
+//       return LEGACY_ADDRESS_COMPARATOR.compare(this, o);
+//    }
+}

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

@@ -44,23 +44,17 @@ public class Litecoin extends Bitcoiny {
 			public Collection<ElectrumX.Server> getServers() {
 				return Arrays.asList(
 						// Servers chosen on NO BASIS WHATSOEVER from various sources!
-						new Server("electrum-ltc.someguy123.net", Server.ConnectionType.SSL, 50002),
-						new Server("backup.electrum-ltc.org", Server.ConnectionType.TCP, 50001),
+						// Status verified at https://1209k.com/bitcoin-eye/ele.php?chain=ltc
+						//CLOSED new Server("electrum-ltc.petrkr.net", Server.ConnectionType.SSL, 60002),
+						//CLOSED new Server("electrum-ltc.someguy123.net", 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.ltc.xurious.com", Server.ConnectionType.TCP, 50001),
 						new Server("electrum.ltc.xurious.com", Server.ConnectionType.SSL, 50002),
-						new Server("electrum-ltc.bysh.me", 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("electrum3.cipig.net", ConnectionType.TCP, 10063),
-						new Server("electrum2.cipig.net", Server.ConnectionType.TCP, 10063),
-						new Server("electrum1.cipig.net", Server.ConnectionType.SSL, 20063),
-						new Server("electrum1.cipig.net", Server.ConnectionType.TCP, 10063),
-						new Server("electrum-ltc.petrkr.net", Server.ConnectionType.SSL, 60002),
 						new Server("ltc.litepay.ch", Server.ConnectionType.SSL, 50022),
-						new Server("electrum-ltc-bysh.me", Server.ConnectionType.TCP, 50002),
-						new Server("electrum.jochen-hoenicke.de", Server.ConnectionType.TCP, 50005),
-						new Server("node.ispol.sk", Server.ConnectionType.TCP, 50004));
+						new Server("ltc.rentonrisk.com", Server.ConnectionType.SSL, 50002));
 			}
 
 			@Override
@@ -151,6 +145,8 @@ public class Litecoin extends Bitcoiny {
 			Context bitcoinjContext = new Context(litecoinNet.getParams());
 
 			instance = new Litecoin(litecoinNet, electrumX, bitcoinjContext, CURRENCY_CODE);
+
+			electrumX.setBlockchain(instance);
 		}
 
 		return instance;

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

@@ -0,0 +1,647 @@
+package org.qortal.crosschain;
+
+import cash.z.wallet.sdk.rpc.CompactFormats;
+import com.google.common.hash.HashCode;
+import com.rust.litewalletjni.LiteWalletJni;
+import org.bitcoinj.core.*;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+import org.libdohj.params.LitecoinRegTestParams;
+import org.libdohj.params.LitecoinTestNet3Params;
+import org.libdohj.params.PirateChainMainNetParams;
+import org.qortal.api.model.crosschain.PirateChainSendRequest;
+import org.qortal.controller.PirateChainWalletController;
+import org.qortal.crosschain.PirateLightClient.Server;
+import org.qortal.crosschain.PirateLightClient.Server.ConnectionType;
+import org.qortal.crypto.Crypto;
+import org.qortal.settings.Settings;
+import org.qortal.transform.TransformationException;
+import org.qortal.utils.BitTwiddling;
+
+import java.nio.ByteBuffer;
+import java.util.*;
+
+public class PirateChain extends Bitcoiny {
+
+	public static final String CURRENCY_CODE = "ARRR";
+
+	private static final Coin DEFAULT_FEE_PER_KB = Coin.valueOf(10000); // 0.0001 ARRR per 1000 bytes
+
+	private static final long MINIMUM_ORDER_AMOUNT = 10000; // 0.0001 ARRR minimum order, to avoid dust errors // TODO: increase this
+
+	// Temporary values until a dynamic fee system is written.
+	private static final long MAINNET_FEE = 10000L; // 0.0001 ARRR
+	private static final long NON_MAINNET_FEE = 10000L; // 0.0001 ARRR
+
+	private static final Map<ConnectionType, Integer> DEFAULT_LITEWALLET_PORTS = new EnumMap<>(ConnectionType.class);
+	static {
+		DEFAULT_LITEWALLET_PORTS.put(ConnectionType.TCP, 9067);
+		DEFAULT_LITEWALLET_PORTS.put(ConnectionType.SSL, 443);
+	}
+
+	public enum PirateChainNet {
+		MAIN {
+			@Override
+			public NetworkParameters getParams() {
+				return PirateChainMainNetParams.get();
+			}
+
+			@Override
+			public Collection<Server> getServers() {
+				return Arrays.asList(
+						// Servers chosen on NO BASIS WHATSOEVER from various sources!
+						new Server("arrrlightd.qortal.online", ConnectionType.SSL, 443),
+						new Server("arrrlightd1.qortal.online", ConnectionType.SSL, 443),
+						new Server("arrrlightd2.qortal.online", ConnectionType.SSL, 443),
+						new Server("lightd.pirate.black", ConnectionType.SSL, 443));
+			}
+
+			@Override
+			public String getGenesisHash() {
+				return "027e3758c3a65b12aa1046462b486d0a63bfa1beae327897f56c5cfb7daaae71";
+			}
+
+			@Override
+			public long getP2shFee(Long timestamp) {
+				// TODO: This will need to be replaced with something better in the near future!
+				return MAINNET_FEE;
+			}
+		},
+		TEST3 {
+			@Override
+			public NetworkParameters getParams() {
+				return LitecoinTestNet3Params.get();
+			}
+
+			@Override
+			public Collection<Server> getServers() {
+				return Arrays.asList();
+			}
+
+			@Override
+			public String getGenesisHash() {
+				return "4966625a4b2851d9fdee139e56211a0d88575f59ed816ff5e6a63deb4e3e29a0";
+			}
+
+			@Override
+			public long getP2shFee(Long timestamp) {
+				return NON_MAINNET_FEE;
+			}
+		},
+		REGTEST {
+			@Override
+			public NetworkParameters getParams() {
+				return LitecoinRegTestParams.get();
+			}
+
+			@Override
+			public Collection<Server> getServers() {
+				return Arrays.asList(
+						new Server("localhost", ConnectionType.TCP, 9067),
+						new Server("localhost", ConnectionType.SSL, 443));
+			}
+
+			@Override
+			public String getGenesisHash() {
+				// This is unique to each regtest instance
+				return null;
+			}
+
+			@Override
+			public long getP2shFee(Long timestamp) {
+				return NON_MAINNET_FEE;
+			}
+		};
+
+		public abstract NetworkParameters getParams();
+		public abstract Collection<Server> getServers();
+		public abstract String getGenesisHash();
+		public abstract long getP2shFee(Long timestamp) throws ForeignBlockchainException;
+	}
+
+	private static PirateChain instance;
+
+	private final PirateChainNet pirateChainNet;
+
+	// Constructors and instance
+
+	private PirateChain(PirateChainNet pirateChainNet, BitcoinyBlockchainProvider blockchain, Context bitcoinjContext, String currencyCode) {
+		super(blockchain, bitcoinjContext, currencyCode);
+		this.pirateChainNet = pirateChainNet;
+
+		LOGGER.info(() -> String.format("Starting Pirate Chain support using %s", this.pirateChainNet.name()));
+	}
+
+	public static synchronized PirateChain getInstance() {
+		if (instance == null) {
+			PirateChainNet pirateChainNet = Settings.getInstance().getPirateChainNet();
+
+			BitcoinyBlockchainProvider pirateLightClient = new PirateLightClient("PirateChain-" + pirateChainNet.name(), pirateChainNet.getGenesisHash(), pirateChainNet.getServers(), DEFAULT_LITEWALLET_PORTS);
+			Context bitcoinjContext = new Context(pirateChainNet.getParams());
+
+			instance = new PirateChain(pirateChainNet, pirateLightClient, bitcoinjContext, CURRENCY_CODE);
+
+			pirateLightClient.setBlockchain(instance);
+		}
+
+		return instance;
+	}
+
+	// Getters & setters
+
+	public static synchronized void resetForTesting() {
+		instance = null;
+	}
+
+	// Actual useful methods for use by other classes
+
+	/** Default Litecoin fee is lower than Bitcoin: only 10sats/byte. */
+	@Override
+	public Coin getFeePerKb() {
+		return DEFAULT_FEE_PER_KB;
+	}
+
+	@Override
+	public long getMinimumOrderAmount() {
+		return MINIMUM_ORDER_AMOUNT;
+	}
+
+	/**
+	 * Returns estimated LTC fee, in sats per 1000bytes, optionally for historic timestamp.
+	 * 
+	 * @param timestamp optional milliseconds since epoch, or null for 'now'
+	 * @return sats per 1000bytes, or throws ForeignBlockchainException if something went wrong
+	 */
+	@Override
+	public long getP2shFee(Long timestamp) throws ForeignBlockchainException {
+		return this.pirateChainNet.getP2shFee(timestamp);
+	}
+
+	/**
+	 * Returns confirmed balance, based on passed payment script.
+	 * <p>
+	 * @return confirmed balance, or zero if balance unknown
+	 * @throws ForeignBlockchainException if there was an error
+	 */
+	public long getConfirmedBalance(String base58Address) throws ForeignBlockchainException {
+		return this.blockchainProvider.getConfirmedAddressBalance(base58Address);
+	}
+
+	/**
+	 * Returns median timestamp from latest 11 blocks, in seconds.
+	 * <p>
+	 * @throws ForeignBlockchainException if error occurs
+	 */
+	@Override
+	public int getMedianBlockTime() throws ForeignBlockchainException {
+		int height = this.blockchainProvider.getCurrentHeight();
+
+		// Grab latest 11 blocks
+		List<Long> blockTimestamps = this.blockchainProvider.getBlockTimestamps(height - 11, 11);
+		if (blockTimestamps.size() < 11)
+			throw new ForeignBlockchainException("Not enough blocks to determine median block time");
+
+		// Descending order
+		blockTimestamps.sort((a, b) -> Long.compare(b, a));
+
+		// Pick median
+		return Math.toIntExact(blockTimestamps.get(5));
+	}
+
+	/**
+	 * Returns list of compact blocks
+	 * <p>
+	 * @throws ForeignBlockchainException if error occurs
+	 */
+	public List<CompactFormats.CompactBlock> getCompactBlocks(int startHeight, int count) throws ForeignBlockchainException {
+		return this.blockchainProvider.getCompactBlocks(startHeight, count);
+	}
+
+
+	@Override
+	public boolean isValidAddress(String address) {
+		// Start with some simple checks
+		if (address == null || !address.toLowerCase().startsWith("zs") || address.length() != 78) {
+			return false;
+		}
+
+		// Now try Bech32 decoding the address (which includes checksum verification)
+		try {
+			Bech32.Bech32Data decoded = Bech32.decode(address);
+			return (decoded != null && Objects.equals("zs", decoded.hrp));
+		}
+		catch (AddressFormatException e) {
+			// Invalid address, checksum failed, etc
+			return false;
+		}
+	}
+
+	@Override
+	public boolean isValidWalletKey(String walletKey) {
+		// For Pirate Chain, we only care that the key is a random string
+		// 32 characters in length, as it is used as entropy for the seed.
+		return walletKey != null && Base58.decode(walletKey).length == 32;
+	}
+
+	/** Returns 't3' prefixed P2SH address using passed redeem script. */
+	public String deriveP2shAddress(byte[] redeemScriptBytes) {
+		Context.propagate(bitcoinjContext);
+		byte[] redeemScriptHash = Crypto.hash160(redeemScriptBytes);
+		return LegacyZcashAddress.fromScriptHash(this.params, redeemScriptHash).toString();
+	}
+
+	/** Returns 'b' prefixed P2SH address using passed redeem script. */
+	public String deriveP2shAddressBPrefix(byte[] redeemScriptBytes) {
+		Context.propagate(bitcoinjContext);
+		byte[] redeemScriptHash = Crypto.hash160(redeemScriptBytes);
+		return LegacyAddress.fromScriptHash(this.params, redeemScriptHash).toString();
+	}
+
+	public Long getWalletBalance(String entropy58) throws ForeignBlockchainException {
+		synchronized (this) {
+			PirateChainWalletController walletController = PirateChainWalletController.getInstance();
+			walletController.initWithEntropy58(entropy58);
+			walletController.ensureInitialized();
+			walletController.ensureSynchronized();
+			walletController.ensureNotNullSeed();
+
+			// Get balance
+			String response = LiteWalletJni.execute("balance", "");
+			JSONObject json = new JSONObject(response);
+			if (json.has("zbalance")) {
+				return json.getLong("zbalance");
+			}
+
+			throw new ForeignBlockchainException("Unable to determine balance");
+		}
+	}
+
+	public List<SimpleTransaction> getWalletTransactions(String entropy58) throws ForeignBlockchainException {
+		synchronized (this) {
+			PirateChainWalletController walletController = PirateChainWalletController.getInstance();
+			walletController.initWithEntropy58(entropy58);
+			walletController.ensureInitialized();
+			walletController.ensureSynchronized();
+			walletController.ensureNotNullSeed();
+
+			List<SimpleTransaction> transactions = new ArrayList<>();
+
+			// Get transactions list
+			String response = LiteWalletJni.execute("list", "");
+			JSONArray transactionsJson = new JSONArray(response);
+			if (transactionsJson != null) {
+				for (int i = 0; i < transactionsJson.length(); i++) {
+					JSONObject transactionJson = transactionsJson.getJSONObject(i);
+
+					if (transactionJson.has("txid")) {
+						String txId = transactionJson.getString("txid");
+						Long timestamp = transactionJson.getLong("datetime");
+						Long amount = transactionJson.getLong("amount");
+						Long fee = transactionJson.getLong("fee");
+						String memo = null;
+
+						if (transactionJson.has("incoming_metadata")) {
+							JSONArray incomingMetadatas = transactionJson.getJSONArray("incoming_metadata");
+							if (incomingMetadatas != null) {
+								for (int j = 0; j < incomingMetadatas.length(); j++) {
+									JSONObject incomingMetadata = incomingMetadatas.getJSONObject(j);
+									if (incomingMetadata.has("value")) {
+										//String address = incomingMetadata.getString("address");
+										Long value = incomingMetadata.getLong("value");
+										amount = value; // TODO: figure out how to parse transactions with multiple incomingMetadata entries
+									}
+
+									if (incomingMetadata.has("memo") && !incomingMetadata.isNull("memo")) {
+										memo = incomingMetadata.getString("memo");
+									}
+								}
+							}
+						}
+
+						if (transactionJson.has("outgoing_metadata")) {
+							JSONArray outgoingMetadatas = transactionJson.getJSONArray("outgoing_metadata");
+							for (int j = 0; j < outgoingMetadatas.length(); j++) {
+								JSONObject outgoingMetadata = outgoingMetadatas.getJSONObject(j);
+
+								if (outgoingMetadata.has("memo") && !outgoingMetadata.isNull("memo")) {
+									memo = outgoingMetadata.getString("memo");
+								}
+							}
+						}
+
+						long timestampMillis = Math.toIntExact(timestamp) * 1000L;
+						SimpleTransaction transaction = new SimpleTransaction(txId, timestampMillis, amount, fee, null, null, memo);
+						transactions.add(transaction);
+					}
+				}
+			}
+
+			return transactions;
+		}
+	}
+
+	public String getWalletAddress(String entropy58) throws ForeignBlockchainException {
+		synchronized (this) {
+			PirateChainWalletController walletController = PirateChainWalletController.getInstance();
+			walletController.initWithEntropy58(entropy58);
+			walletController.ensureInitialized();
+			walletController.ensureNotNullSeed();
+
+			return walletController.getCurrentWallet().getWalletAddress();
+		}
+	}
+
+	public String sendCoins(PirateChainSendRequest pirateChainSendRequest) throws ForeignBlockchainException {
+		PirateChainWalletController walletController = PirateChainWalletController.getInstance();
+		walletController.initWithEntropy58(pirateChainSendRequest.entropy58);
+		walletController.ensureInitialized();
+		walletController.ensureSynchronized();
+		walletController.ensureNotNullSeed();
+
+		// Unlock wallet
+		walletController.getCurrentWallet().unlock();
+
+		// Build spend
+		JSONObject txn = new JSONObject();
+		txn.put("input", walletController.getCurrentWallet().getWalletAddress());
+		txn.put("fee", MAINNET_FEE);
+
+		JSONObject output = new JSONObject();
+		output.put("address", pirateChainSendRequest.receivingAddress);
+		output.put("amount", pirateChainSendRequest.arrrAmount);
+		output.put("memo", pirateChainSendRequest.memo);
+
+		JSONArray outputs = new JSONArray();
+		outputs.put(output);
+		txn.put("output", outputs);
+
+		String txnString = txn.toString();
+
+		// Send the coins
+		String response = LiteWalletJni.execute("send", txnString);
+		JSONObject json = new JSONObject(response);
+		try {
+			if (json.has("txid")) { // Success
+				return json.getString("txid");
+			}
+			else if (json.has("error")) {
+				String error = json.getString("error");
+				throw new ForeignBlockchainException(error);
+			}
+
+		} catch (JSONException e) {
+			throw new ForeignBlockchainException(e.getMessage());
+		}
+
+		throw new ForeignBlockchainException("Something went wrong");
+	}
+
+	public String fundP2SH(String entropy58, String receivingAddress, long amount,
+						   String redeemScript58) throws ForeignBlockchainException {
+
+		PirateChainWalletController walletController = PirateChainWalletController.getInstance();
+		walletController.initWithEntropy58(entropy58);
+		walletController.ensureInitialized();
+		walletController.ensureSynchronized();
+		walletController.ensureNotNullSeed();
+
+		// Unlock wallet
+		walletController.getCurrentWallet().unlock();
+
+		// Build spend
+		JSONObject txn = new JSONObject();
+		txn.put("input", walletController.getCurrentWallet().getWalletAddress());
+		txn.put("fee", MAINNET_FEE);
+
+		JSONObject output = new JSONObject();
+		output.put("address", receivingAddress);
+		output.put("amount", amount);
+		//output.put("memo", memo);
+
+		JSONArray outputs = new JSONArray();
+		outputs.put(output);
+		txn.put("output", outputs);
+		txn.put("script", redeemScript58);
+
+		String txnString = txn.toString();
+
+		// Send the coins
+		String response = LiteWalletJni.execute("sendp2sh", txnString);
+		JSONObject json = new JSONObject(response);
+		try {
+			if (json.has("txid")) { // Success
+				return json.getString("txid");
+			}
+			else if (json.has("error")) {
+				String error = json.getString("error");
+				throw new ForeignBlockchainException(error);
+			}
+
+		} catch (JSONException e) {
+			throw new ForeignBlockchainException(e.getMessage());
+		}
+
+		throw new ForeignBlockchainException("Something went wrong");
+	}
+
+	public String redeemP2sh(String p2shAddress, String receivingAddress, long amount, String redeemScript58,
+							 String fundingTxid58, String secret58, String privateKey58) throws ForeignBlockchainException {
+
+		// Use null seed wallet since we may not have the entropy bytes for a real wallet's seed
+		PirateChainWalletController walletController = PirateChainWalletController.getInstance();
+		walletController.initNullSeedWallet();
+		walletController.ensureInitialized();
+
+		walletController.getCurrentWallet().unlock();
+
+		// Build spend
+		JSONObject txn = new JSONObject();
+		txn.put("input", p2shAddress);
+		txn.put("fee", MAINNET_FEE);
+
+		JSONObject output = new JSONObject();
+		output.put("address", receivingAddress);
+		output.put("amount", amount);
+		// output.put("memo", ""); // Maybe useful in future to include trade details?
+
+		JSONArray outputs = new JSONArray();
+		outputs.put(output);
+		txn.put("output", outputs);
+
+		txn.put("script", redeemScript58);
+		txn.put("txid", fundingTxid58);
+		txn.put("locktime", 0); // Must be 0 when redeeming
+		txn.put("secret", secret58);
+		txn.put("privkey", privateKey58);
+
+		String txnString = txn.toString();
+
+		// Redeem the P2SH
+		String response = LiteWalletJni.execute("redeemp2sh", txnString);
+		JSONObject json = new JSONObject(response);
+		try {
+			if (json.has("txid")) { // Success
+				return json.getString("txid");
+			}
+			else if (json.has("error")) {
+				String error = json.getString("error");
+				throw new ForeignBlockchainException(error);
+			}
+
+		} catch (JSONException e) {
+			throw new ForeignBlockchainException(e.getMessage());
+		}
+
+		throw new ForeignBlockchainException("Something went wrong");
+	}
+
+	public String refundP2sh(String p2shAddress, String receivingAddress, long amount, String redeemScript58,
+							 String fundingTxid58, int lockTime, String privateKey58) throws ForeignBlockchainException {
+
+		// Use null seed wallet since we may not have the entropy bytes for a real wallet's seed
+		PirateChainWalletController walletController = PirateChainWalletController.getInstance();
+		walletController.initNullSeedWallet();
+		walletController.ensureInitialized();
+
+		walletController.getCurrentWallet().unlock();
+
+		// Build spend
+		JSONObject txn = new JSONObject();
+		txn.put("input", p2shAddress);
+		txn.put("fee", MAINNET_FEE);
+
+		JSONObject output = new JSONObject();
+		output.put("address", receivingAddress);
+		output.put("amount", amount);
+		// output.put("memo", ""); // Maybe useful in future to include trade details?
+
+		JSONArray outputs = new JSONArray();
+		outputs.put(output);
+		txn.put("output", outputs);
+
+		txn.put("script", redeemScript58);
+		txn.put("txid", fundingTxid58);
+		txn.put("locktime", lockTime);
+		txn.put("secret", ""); // Must be blank when refunding
+		txn.put("privkey", privateKey58);
+
+		String txnString = txn.toString();
+
+		// Redeem the P2SH
+		String response = LiteWalletJni.execute("redeemp2sh", txnString);
+		JSONObject json = new JSONObject(response);
+		try {
+			if (json.has("txid")) { // Success
+				return json.getString("txid");
+			}
+			else if (json.has("error")) {
+				String error = json.getString("error");
+				throw new ForeignBlockchainException(error);
+			}
+
+		} catch (JSONException e) {
+			throw new ForeignBlockchainException(e.getMessage());
+		}
+
+		throw new ForeignBlockchainException("Something went wrong");
+	}
+
+	public String getSyncStatus(String entropy58) throws ForeignBlockchainException {
+		synchronized (this) {
+			PirateChainWalletController walletController = PirateChainWalletController.getInstance();
+			walletController.initWithEntropy58(entropy58);
+
+			return walletController.getSyncStatus();
+		}
+	}
+
+	public static BitcoinyTransaction deserializeRawTransaction(String rawTransactionHex) throws TransformationException {
+		byte[] rawTransactionData = HashCode.fromString(rawTransactionHex).asBytes();
+		ByteBuffer byteBuffer = ByteBuffer.wrap(rawTransactionData);
+
+		// Header
+		int header = BitTwiddling.readU32(byteBuffer);
+		boolean overwintered = ((header >> 31 & 0xff) == 255);
+		int version = header & 0x7FFFFFFF;
+
+		// Version group ID
+		int versionGroupId = 0;
+		if (overwintered) {
+			versionGroupId = BitTwiddling.readU32(byteBuffer);
+		}
+
+		boolean isOverwinterV3 = overwintered && versionGroupId == 0x03C48270 && version == 3;
+		boolean isSaplingV4 = overwintered && versionGroupId == 0x892F2085 && version == 4;
+		if (overwintered && !(isOverwinterV3 || isSaplingV4)) {
+			throw new TransformationException("Unknown transaction format");
+		}
+
+		// Inputs
+		List<BitcoinyTransaction.Input> inputs = new ArrayList<>();
+		int vinCount = BitTwiddling.readU8(byteBuffer);
+		for (int i=0; i<vinCount; i++) {
+			// Outpoint hash
+			byte[] outpointHashBytes = new byte[32];
+			byteBuffer.get(outpointHashBytes);
+			String outpointHash = HashCode.fromBytes(outpointHashBytes).toString();
+
+			// vout
+			int vout = BitTwiddling.readU32(byteBuffer);
+
+			// scriptSig
+			int scriptSigLength = BitTwiddling.readU8(byteBuffer);
+			byte[] scriptSigBytes = new byte[scriptSigLength];
+			byteBuffer.get(scriptSigBytes);
+			String scriptSig = HashCode.fromBytes(scriptSigBytes).toString();
+
+			int sequence = BitTwiddling.readU32(byteBuffer);
+
+			BitcoinyTransaction.Input input = new BitcoinyTransaction.Input(scriptSig, sequence, outpointHash, vout);
+			inputs.add(input);
+		}
+
+		// Outputs
+		List<BitcoinyTransaction.Output> outputs = new ArrayList<>();
+		int voutCount = BitTwiddling.readU8(byteBuffer);
+		for (int i=0; i<voutCount; i++) {
+			// Amount
+			byte[] amountBytes = new byte[8];
+			byteBuffer.get(amountBytes);
+			long amount = BitTwiddling.longFromLEBytes(amountBytes, 0);
+
+			// Script pubkey
+			int scriptPubkeySize = BitTwiddling.readU8(byteBuffer);
+			byte[] scriptPubkeyBytes = new byte[scriptPubkeySize];
+			byteBuffer.get(scriptPubkeyBytes);
+			String scriptPubKey = HashCode.fromBytes(scriptPubkeyBytes).toString();
+
+			outputs.add(new BitcoinyTransaction.Output(scriptPubKey, amount, null));
+		}
+
+		// Locktime
+		byte[] locktimeBytes = new byte[4];
+		byteBuffer.get(locktimeBytes);
+		int locktime = BitTwiddling.intFromLEBytes(locktimeBytes, 0);
+
+		// Expiry height
+		int expiryHeight = 0;
+		if (isOverwinterV3 || isSaplingV4) {
+			byte[] expiryHeightBytes = new byte[4];
+			byteBuffer.get(expiryHeightBytes);
+			expiryHeight = BitTwiddling.intFromLEBytes(expiryHeightBytes, 0);
+		}
+
+		String txHash = null; // Not present in raw transaction data
+		int size = 0; // Not present in raw transaction data
+		Integer timestamp = null; // Not present in raw transaction data
+
+		// Note: this is incomplete, as sapling spend info is not yet parsed. We don't need it for our
+		// current trade bot implementation, but it could be added in the future, for completeness.
+		// See link below for reference:
+		// https://github.com/PirateNetwork/librustzcash/blob/2981c4d2860f7cd73282fed885daac0323ff0280/zcash_primitives/src/transaction/mod.rs#L197
+
+		return new BitcoinyTransaction(txHash, size, locktime, timestamp, inputs, outputs);
+	}
+
+}

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

@@ -0,0 +1,875 @@
+package org.qortal.crosschain;
+
+import com.google.common.hash.HashCode;
+import com.google.common.primitives.Bytes;
+import org.ciyam.at.*;
+import org.qortal.account.Account;
+import org.qortal.asset.Asset;
+import org.qortal.at.QortalFunctionCode;
+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.MessageTransactionData;
+import org.qortal.repository.DataException;
+import org.qortal.repository.Repository;
+import org.qortal.utils.Base58;
+import org.qortal.utils.BitTwiddling;
+
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.ciyam.at.OpCode.calcOffset;
+
+/**
+ * Cross-chain trade AT
+ * 
+ * <p>
+ * <ul>
+ * <li>Bob generates PirateChain & Qortal 'trade' keys
+ * 		<ul>
+ * 			<li>private key required to sign P2SH redeem tx</li>
+ * 			<li>private key could be used to create 'secret' (e.g. double-SHA256)</li>
+ * 			<li>encrypted private key could be stored in Qortal AT for access by Bob from any node</li>
+ * 		</ul>
+ * </li>
+ * <li>Bob deploys Qortal AT
+ * 		<ul>
+ * 		</ul>
+ * </li>
+ * <li>Alice finds Qortal AT and wants to trade
+ * 		<ul>
+ * 			<li>Alice generates PirateChain & Qortal 'trade' keys</li>
+ * 			<li>Alice funds PirateChain P2SH-A</li>
+ * 			<li>Alice sends 'offer' MESSAGE to Bob from her Qortal trade address, containing:
+ * 				<ul>
+ * 					<li>hash-of-secret-A</li>
+ * 					<li>her 'trade' Pirate Chain public key</li>
+ * 				</ul>
+ * 			</li>
+ * 		</ul>
+ * </li>
+ * <li>Bob receives "offer" MESSAGE
+ * 		<ul>
+ * 			<li>Checks Alice's P2SH-A</li>
+ * 			<li>Sends 'trade' MESSAGE to Qortal AT from his trade address, containing:
+ * 				<ul>
+ * 					<li>Alice's trade Qortal address</li>
+ * 					<li>Alice's trade Pirate Chain public key</li>
+ * 					<li>hash-of-secret-A</li>
+ * 				</ul>
+ * 			</li>
+ * 		</ul>
+ * </li>
+ * <li>Alice checks Qortal AT to confirm it's locked to her
+ * 		<ul>
+ * 			<li>Alice sends 'redeem' MESSAGE to Qortal AT from her trade address, containing:
+ * 				<ul>
+ * 					<li>secret-A</li>
+ * 					<li>Qortal receiving address of her chosing</li>
+ * 				</ul>
+ * 			</li>
+ * 			<li>AT's QORT funds are sent to Qortal receiving address</li>
+ * 		</ul>
+ * </li>
+ * <li>Bob checks AT, extracts secret-A
+ * 		<ul>
+ * 			<li>Bob redeems P2SH-A using his PirateChain trade key and secret-A</li>
+ * 			<li>P2SH-A ARRR funds end up at PirateChain address determined by redeem transaction output(s)</li>
+ * 		</ul>
+ * </li>
+ * </ul>
+ */
+public class PirateChainACCTv3 implements ACCT {
+
+	public static final String NAME = PirateChainACCTv3.class.getSimpleName();
+	public static final byte[] CODE_BYTES_HASH = HashCode.fromString("fc2818ac0819ab658a065ab0d050e75f167921e2dce5969b9b7741e47e477d83").asBytes(); // SHA256 of AT code bytes
+
+	public static final int SECRET_LENGTH = 32;
+
+	/** <b>Value</b> offset into AT segment where 'mode' variable (long) is stored. (Multiply by MachineState.VALUE_SIZE for byte offset). */
+	private static final int MODE_VALUE_OFFSET = 68;
+	/** <b>Byte</b> offset into AT state data where 'mode' variable (long) is stored. */
+	public static final int MODE_BYTE_OFFSET = MachineState.HEADER_LENGTH + (MODE_VALUE_OFFSET * MachineState.VALUE_SIZE);
+
+	public static class OfferMessageData {
+		public byte[] partnerPirateChainPublicKey;
+		public byte[] hashOfSecretA;
+		public long lockTimeA;
+	}
+	public static final int OFFER_MESSAGE_LENGTH = 33 /*partnerPirateChainPublicKey*/ + 20 /*hashOfSecretA*/ + 8 /*lockTimeA*/;
+	public static final int TRADE_MESSAGE_LENGTH = 32 /*partner's Qortal trade address (padded from 25 to 32)*/
+			+ 40 /*partner's Pirate Chain public key (padded from 33 to 40)*/
+			+ 8 /*AT trade timeout (minutes)*/
+			+ 24 /*hash of secret-A (padded from 20 to 24)*/
+			+ 8 /*lockTimeA*/;
+	public static final int REDEEM_MESSAGE_LENGTH = 32 /*secret-A*/ + 32 /*partner's Qortal receiving address padded from 25 to 32*/;
+	public static final int CANCEL_MESSAGE_LENGTH = 32 /*AT creator's Qortal address*/;
+
+	private static PirateChainACCTv3 instance;
+
+	private PirateChainACCTv3() {
+	}
+
+	public static synchronized PirateChainACCTv3 getInstance() {
+		if (instance == null)
+			instance = new PirateChainACCTv3();
+
+		return instance;
+	}
+
+	@Override
+	public byte[] getCodeBytesHash() {
+		return CODE_BYTES_HASH;
+	}
+
+	@Override
+	public int getModeByteOffset() {
+		return MODE_BYTE_OFFSET;
+	}
+
+	@Override
+	public ForeignBlockchain getBlockchain() {
+		return PirateChain.getInstance();
+	}
+
+	/**
+	 * Returns Qortal AT creation bytes for cross-chain trading AT.
+	 * <p>
+	 * <tt>tradeTimeout</tt> (minutes) is the time window for the trade partner to send the
+	 * 32-byte secret to the AT, before the AT automatically refunds the AT's creator.
+	 * 
+	 * @param creatorTradeAddress AT creator's trade Qortal address
+	 * @param pirateChainPublicKeyHash 33-byte creator's trade PirateChain public key
+	 * @param qortAmount how much QORT to pay trade partner if they send correct 32-byte secrets to AT
+	 * @param arrrAmount how much ARRR the AT creator is expecting to trade
+	 * @param tradeTimeout suggested timeout for entire trade
+	 */
+	public static byte[] buildQortalAT(String creatorTradeAddress, byte[] pirateChainPublicKeyHash, long qortAmount, long arrrAmount, int tradeTimeout) {
+		if (pirateChainPublicKeyHash.length != 33)
+			throw new IllegalArgumentException("PirateChain public key hash should be 33 bytes");
+
+		// Labels for data segment addresses
+		int addrCounter = 0;
+
+		// Constants (with corresponding dataByteBuffer.put*() calls below)
+
+		final int addrCreatorTradeAddress1 = addrCounter++;
+		final int addrCreatorTradeAddress2 = addrCounter++;
+		final int addrCreatorTradeAddress3 = addrCounter++;
+		final int addrCreatorTradeAddress4 = addrCounter++;
+
+		final int addrPirateChainPublicKeyHash = addrCounter;
+		addrCounter += 5;
+
+		final int addrQortAmount = addrCounter++;
+		final int addrarrrAmount = addrCounter++;
+		final int addrTradeTimeout = addrCounter++;
+
+		final int addrMessageTxnType = addrCounter++;
+		final int addrExpectedTradeMessageLength = addrCounter++;
+		final int addrExpectedRedeemMessageLength = addrCounter++;
+
+		final int addrCreatorAddressPointer = addrCounter++;
+		final int addrQortalPartnerAddressPointer = addrCounter++;
+		final int addrMessageSenderPointer = addrCounter++;
+
+		final int addrTradeMessagePartnerPirateChainPublicKeyFirst32BytesOffset = addrCounter++;
+		final int addrTradeMessagePartnerPirateChainPublicKeyLastByteOffset = addrCounter++; // Remainder of public key, plus timeout
+		final int addrPartnerPirateChainPublicKeyFirst32BytesPointer = addrCounter++;
+		final int addrPartnerPirateChainPublicKeyLastBytePointer = addrCounter++; // Remainder of public key
+		final int addrTradeMessageHashOfSecretAOffset = addrCounter++;
+		final int addrHashOfSecretAPointer = addrCounter++;
+
+		final int addrRedeemMessageReceivingAddressOffset = addrCounter++;
+
+		final int addrMessageDataPointer = addrCounter++;
+		final int addrMessageDataLength = addrCounter++;
+
+		final int addrPartnerReceivingAddressPointer = addrCounter++;
+
+		final int addrEndOfConstants = addrCounter;
+
+		// Variables
+
+		final int addrCreatorAddress1 = addrCounter++;
+		final int addrCreatorAddress2 = addrCounter++;
+		final int addrCreatorAddress3 = addrCounter++;
+		final int addrCreatorAddress4 = addrCounter++;
+
+		final int addrQortalPartnerAddress1 = addrCounter++;
+		final int addrQortalPartnerAddress2 = addrCounter++;
+		final int addrQortalPartnerAddress3 = addrCounter++;
+		final int addrQortalPartnerAddress4 = addrCounter++;
+
+		final int addrLockTimeA = addrCounter++;
+		final int addrRefundTimeout = addrCounter++;
+		final int addrRefundTimestamp = addrCounter++;
+		final int addrLastTxnTimestamp = addrCounter++;
+		final int addrBlockTimestamp = addrCounter++;
+		final int addrTxnType = addrCounter++;
+		final int addrResult = addrCounter++;
+
+		final int addrMessageSender1 = addrCounter++;
+		final int addrMessageSender2 = addrCounter++;
+		final int addrMessageSender3 = addrCounter++;
+		final int addrMessageSender4 = addrCounter++;
+
+		final int addrMessageLength = addrCounter++;
+
+		final int addrMessageData = addrCounter;
+		addrCounter += 4;
+
+		final int addrHashOfSecretA = addrCounter;
+		addrCounter += 4;
+
+		final int addrPartnerPirateChainPublicKeyFirst32Bytes = addrCounter;
+		addrCounter += 4;
+
+		final int addrPartnerPirateChainPublicKeyLastByte = addrCounter;
+		addrCounter += 4; // We retrieve using GET_B_IND, so need to allow space for the full 32 bytes
+
+		final int addrPartnerReceivingAddress = addrCounter;
+		addrCounter += 4;
+
+		final int addrMode = addrCounter++;
+		assert addrMode == MODE_VALUE_OFFSET : String.format("addrMode %d does not match MODE_VALUE_OFFSET %d", addrMode, MODE_VALUE_OFFSET);
+
+		// Data segment
+		ByteBuffer dataByteBuffer = ByteBuffer.allocate(addrCounter * MachineState.VALUE_SIZE);
+
+		// AT creator's trade Qortal address, decoded from Base58
+		assert dataByteBuffer.position() == addrCreatorTradeAddress1 * MachineState.VALUE_SIZE : "addrCreatorTradeAddress1 incorrect";
+		byte[] creatorTradeAddressBytes = Base58.decode(creatorTradeAddress);
+		dataByteBuffer.put(Bytes.ensureCapacity(creatorTradeAddressBytes, 32, 0));
+
+		// PirateChain public key hash
+		assert dataByteBuffer.position() == addrPirateChainPublicKeyHash * MachineState.VALUE_SIZE : "addrPirateChainPublicKeyHash incorrect";
+		dataByteBuffer.put(Bytes.ensureCapacity(pirateChainPublicKeyHash, 40, 0));
+
+		// Redeem Qort amount
+		assert dataByteBuffer.position() == addrQortAmount * MachineState.VALUE_SIZE : "addrQortAmount incorrect";
+		dataByteBuffer.putLong(qortAmount);
+
+		// Expected PirateChain amount
+		assert dataByteBuffer.position() == addrarrrAmount * MachineState.VALUE_SIZE : "addrarrrAmount incorrect";
+		dataByteBuffer.putLong(arrrAmount);
+
+		// Suggested trade timeout (minutes)
+		assert dataByteBuffer.position() == addrTradeTimeout * MachineState.VALUE_SIZE : "addrTradeTimeout incorrect";
+		dataByteBuffer.putLong(tradeTimeout);
+
+		// We're only interested in MESSAGE transactions
+		assert dataByteBuffer.position() == addrMessageTxnType * MachineState.VALUE_SIZE : "addrMessageTxnType incorrect";
+		dataByteBuffer.putLong(API.ATTransactionType.MESSAGE.value);
+
+		// Expected length of 'trade' MESSAGE data from AT creator
+		assert dataByteBuffer.position() == addrExpectedTradeMessageLength * MachineState.VALUE_SIZE : "addrExpectedTradeMessageLength incorrect";
+		dataByteBuffer.putLong(TRADE_MESSAGE_LENGTH);
+
+		// Expected length of 'redeem' MESSAGE data from trade partner
+		assert dataByteBuffer.position() == addrExpectedRedeemMessageLength * MachineState.VALUE_SIZE : "addrExpectedRedeemMessageLength incorrect";
+		dataByteBuffer.putLong(REDEEM_MESSAGE_LENGTH);
+
+		// Index into data segment of AT creator's address, used by GET_B_IND
+		assert dataByteBuffer.position() == addrCreatorAddressPointer * MachineState.VALUE_SIZE : "addrCreatorAddressPointer incorrect";
+		dataByteBuffer.putLong(addrCreatorAddress1);
+
+		// Index into data segment of partner's Qortal address, used by SET_B_IND
+		assert dataByteBuffer.position() == addrQortalPartnerAddressPointer * MachineState.VALUE_SIZE : "addrQortalPartnerAddressPointer incorrect";
+		dataByteBuffer.putLong(addrQortalPartnerAddress1);
+
+		// Index into data segment of (temporary) transaction's sender's address, used by GET_B_IND
+		assert dataByteBuffer.position() == addrMessageSenderPointer * MachineState.VALUE_SIZE : "addrMessageSenderPointer incorrect";
+		dataByteBuffer.putLong(addrMessageSender1);
+
+		// Offset into 'trade' MESSAGE data payload for extracting first 32 bytes of partner's Pirate Chain public key
+		assert dataByteBuffer.position() == addrTradeMessagePartnerPirateChainPublicKeyFirst32BytesOffset * MachineState.VALUE_SIZE : "addrTradeMessagePartnerPirateChainPublicKeyFirst32BytesOffset incorrect";
+		dataByteBuffer.putLong(32L);
+
+		// Offset into 'trade' MESSAGE data payload for extracting last byte of public key
+		assert dataByteBuffer.position() == addrTradeMessagePartnerPirateChainPublicKeyLastByteOffset * MachineState.VALUE_SIZE : "addrTradeMessagePartnerPirateChainPublicKeyLastByteOffset incorrect";
+		dataByteBuffer.putLong(64L);
+
+		// Index into data segment of partner's Pirate Chain public key, used by GET_B_IND
+		assert dataByteBuffer.position() == addrPartnerPirateChainPublicKeyFirst32BytesPointer * MachineState.VALUE_SIZE : "addrPartnerPirateChainPublicKeyFirst32BytesPointer incorrect";
+		dataByteBuffer.putLong(addrPartnerPirateChainPublicKeyFirst32Bytes);
+
+		// Index into data segment of remainder of partner's Pirate Chain public key, used by GET_B_IND
+		assert dataByteBuffer.position() == addrPartnerPirateChainPublicKeyLastBytePointer * MachineState.VALUE_SIZE : "addrPartnerPirateChainPublicKeyLastBytePointer incorrect";
+		dataByteBuffer.putLong(addrPartnerPirateChainPublicKeyLastByte);
+
+		// Offset into 'trade' MESSAGE data payload for extracting hash-of-secret-A
+		assert dataByteBuffer.position() == addrTradeMessageHashOfSecretAOffset * MachineState.VALUE_SIZE : "addrTradeMessageHashOfSecretAOffset incorrect";
+		dataByteBuffer.putLong(80L);
+
+		// Index into data segment to hash of secret A, used by GET_B_IND
+		assert dataByteBuffer.position() == addrHashOfSecretAPointer * MachineState.VALUE_SIZE : "addrHashOfSecretAPointer incorrect";
+		dataByteBuffer.putLong(addrHashOfSecretA);
+
+		// Offset into 'redeem' MESSAGE data payload for extracting Qortal receiving address
+		assert dataByteBuffer.position() == addrRedeemMessageReceivingAddressOffset * MachineState.VALUE_SIZE : "addrRedeemMessageReceivingAddressOffset incorrect";
+		dataByteBuffer.putLong(32L);
+
+		// Source location and length for hashing any passed secret
+		assert dataByteBuffer.position() == addrMessageDataPointer * MachineState.VALUE_SIZE : "addrMessageDataPointer incorrect";
+		dataByteBuffer.putLong(addrMessageData);
+		assert dataByteBuffer.position() == addrMessageDataLength * MachineState.VALUE_SIZE : "addrMessageDataLength incorrect";
+		dataByteBuffer.putLong(32L);
+
+		// Pointer into data segment of where to save partner's receiving Qortal address, used by GET_B_IND
+		assert dataByteBuffer.position() == addrPartnerReceivingAddressPointer * MachineState.VALUE_SIZE : "addrPartnerReceivingAddressPointer incorrect";
+		dataByteBuffer.putLong(addrPartnerReceivingAddress);
+
+		assert dataByteBuffer.position() == addrEndOfConstants * MachineState.VALUE_SIZE : "dataByteBuffer position not at end of constants";
+
+		// Code labels
+		Integer labelRefund = null;
+
+		Integer labelTradeTxnLoop = null;
+		Integer labelCheckTradeTxn = null;
+		Integer labelCheckCancelTxn = null;
+		Integer labelNotTradeNorCancelTxn = null;
+		Integer labelCheckNonRefundTradeTxn = null;
+		Integer labelTradeTxnExtract = null;
+		Integer labelRedeemTxnLoop = null;
+		Integer labelCheckRedeemTxn = null;
+		Integer labelCheckRedeemTxnSender = null;
+		Integer labelPayout = null;
+
+		ByteBuffer codeByteBuffer = ByteBuffer.allocate(768);
+
+		// Two-pass version
+		for (int pass = 0; pass < 2; ++pass) {
+			codeByteBuffer.clear();
+
+			try {
+				/* Initialization */
+
+				// Use AT creation 'timestamp' as starting point for finding transactions sent to AT
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(FunctionCode.GET_CREATION_TIMESTAMP, addrLastTxnTimestamp));
+
+				// Load B register with AT creator's address so we can save it into addrCreatorAddress1-4
+				codeByteBuffer.put(OpCode.EXT_FUN.compile(FunctionCode.PUT_CREATOR_INTO_B));
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.GET_B_IND, addrCreatorAddressPointer));
+
+				// Set restart position to after this opcode
+				codeByteBuffer.put(OpCode.SET_PCS.compile());
+
+				/* Loop, waiting for message from AT creator's trade address containing trade partner details, or AT owner's address to cancel offer */
+
+				/* Transaction processing loop */
+				labelTradeTxnLoop = codeByteBuffer.position();
+
+				/* Sleep until message arrives */
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(QortalFunctionCode.SLEEP_UNTIL_MESSAGE.value, addrLastTxnTimestamp));
+
+				// Find next transaction (if any) to this AT since the last one (referenced by addrLastTxnTimestamp)
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.PUT_TX_AFTER_TIMESTAMP_INTO_A, addrLastTxnTimestamp));
+				// If no transaction found, A will be zero. If A is zero, set addrResult to 1, otherwise 0.
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(FunctionCode.CHECK_A_IS_ZERO, addrResult));
+				// If addrResult is zero (i.e. A is non-zero, transaction was found) then go check transaction
+				codeByteBuffer.put(OpCode.BZR_DAT.compile(addrResult, calcOffset(codeByteBuffer, labelCheckTradeTxn)));
+				// Stop and wait for next block
+				codeByteBuffer.put(OpCode.STP_IMD.compile());
+
+				/* Check transaction */
+				labelCheckTradeTxn = codeByteBuffer.position();
+
+				// Update our 'last found transaction's timestamp' using 'timestamp' from transaction
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(FunctionCode.GET_TIMESTAMP_FROM_TX_IN_A, addrLastTxnTimestamp));
+				// Extract transaction type (message/payment) from transaction and save type in addrTxnType
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(FunctionCode.GET_TYPE_FROM_TX_IN_A, addrTxnType));
+				// If transaction type is not MESSAGE type then go look for another transaction
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrTxnType, addrMessageTxnType, calcOffset(codeByteBuffer, labelTradeTxnLoop)));
+
+				/* Check transaction's sender. We're expecting AT creator's trade address for 'trade' message, or AT creator's own address for 'cancel' message. */
+
+				// Extract sender address from transaction into B register
+				codeByteBuffer.put(OpCode.EXT_FUN.compile(FunctionCode.PUT_ADDRESS_FROM_TX_IN_A_INTO_B));
+				// Save B register into data segment starting at addrMessageSender1 (as pointed to by addrMessageSenderPointer)
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.GET_B_IND, addrMessageSenderPointer));
+				// Compare each part of message sender's address with AT creator's trade address. If they don't match, check for cancel situation.
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender1, addrCreatorTradeAddress1, calcOffset(codeByteBuffer, labelCheckCancelTxn)));
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender2, addrCreatorTradeAddress2, calcOffset(codeByteBuffer, labelCheckCancelTxn)));
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender3, addrCreatorTradeAddress3, calcOffset(codeByteBuffer, labelCheckCancelTxn)));
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender4, addrCreatorTradeAddress4, calcOffset(codeByteBuffer, labelCheckCancelTxn)));
+				// Message sender's address matches AT creator's trade address so go process 'trade' message
+				codeByteBuffer.put(OpCode.JMP_ADR.compile(labelCheckNonRefundTradeTxn == null ? 0 : labelCheckNonRefundTradeTxn));
+
+				/* Checking message sender for possible cancel message */
+				labelCheckCancelTxn = codeByteBuffer.position();
+
+				// Compare each part of message sender's address with AT creator's address. If they don't match, look for another transaction.
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender1, addrCreatorAddress1, calcOffset(codeByteBuffer, labelNotTradeNorCancelTxn)));
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender2, addrCreatorAddress2, calcOffset(codeByteBuffer, labelNotTradeNorCancelTxn)));
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender3, addrCreatorAddress3, calcOffset(codeByteBuffer, labelNotTradeNorCancelTxn)));
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender4, addrCreatorAddress4, calcOffset(codeByteBuffer, labelNotTradeNorCancelTxn)));
+				// Partner address is AT creator's address, so cancel offer and finish.
+				codeByteBuffer.put(OpCode.SET_VAL.compile(addrMode, AcctMode.CANCELLED.value));
+				// We're finished forever (finishing auto-refunds remaining balance to AT creator)
+				codeByteBuffer.put(OpCode.FIN_IMD.compile());
+
+				/* Not trade nor cancel message */
+				labelNotTradeNorCancelTxn = codeByteBuffer.position();
+
+				// Loop to find another transaction
+				codeByteBuffer.put(OpCode.JMP_ADR.compile(labelTradeTxnLoop == null ? 0 : labelTradeTxnLoop));
+
+				/* Possible switch-to-trade-mode message */
+				labelCheckNonRefundTradeTxn = codeByteBuffer.position();
+
+				// Check 'trade' message we received has expected number of message bytes
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(QortalFunctionCode.GET_MESSAGE_LENGTH_FROM_TX_IN_A.value, addrMessageLength));
+				// If message length matches, branch to info extraction code
+				codeByteBuffer.put(OpCode.BEQ_DAT.compile(addrMessageLength, addrExpectedTradeMessageLength, calcOffset(codeByteBuffer, labelTradeTxnExtract)));
+				// Message length didn't match - go back to finding another 'trade' MESSAGE transaction
+				codeByteBuffer.put(OpCode.JMP_ADR.compile(labelTradeTxnLoop == null ? 0 : labelTradeTxnLoop));
+
+				/* Extracting info from 'trade' MESSAGE transaction */
+				labelTradeTxnExtract = codeByteBuffer.position();
+
+				// Extract message from transaction into B register
+				codeByteBuffer.put(OpCode.EXT_FUN.compile(FunctionCode.PUT_MESSAGE_FROM_TX_IN_A_INTO_B));
+				// Save B register into data segment starting at addrQortalPartnerAddress1 (as pointed to by addrQortalPartnerAddressPointer)
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.GET_B_IND, addrQortalPartnerAddressPointer));
+
+				// Extract first 32 bytes of trade partner's Pirate Chain public key from message into B
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(QortalFunctionCode.PUT_PARTIAL_MESSAGE_FROM_TX_IN_A_INTO_B.value, addrTradeMessagePartnerPirateChainPublicKeyFirst32BytesOffset));
+				// Store first 32 bytes of partner's Pirate Chain public key
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.GET_B_IND, addrPartnerPirateChainPublicKeyFirst32BytesPointer));
+
+				// Extract last byte of public key, plus trade timeout, from message into B
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(QortalFunctionCode.PUT_PARTIAL_MESSAGE_FROM_TX_IN_A_INTO_B.value, addrTradeMessagePartnerPirateChainPublicKeyLastByteOffset));
+				// Store last byte of partner's Pirate Chain public key
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.GET_B_IND, addrPartnerPirateChainPublicKeyLastBytePointer));
+				// Extract AT trade timeout (minutes) (from B2)
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(FunctionCode.GET_B2, addrRefundTimeout));
+
+				// Grab next 32 bytes
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(QortalFunctionCode.PUT_PARTIAL_MESSAGE_FROM_TX_IN_A_INTO_B.value, addrTradeMessageHashOfSecretAOffset));
+
+				// Extract hash-of-secret-A (we only really use values from B1-B3)
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.GET_B_IND, addrHashOfSecretAPointer));
+				// Extract lockTime-A (from B4)
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(FunctionCode.GET_B4, addrLockTimeA));
+
+				// Calculate trade timeout refund 'timestamp' by adding addrRefundTimeout minutes to this transaction's 'timestamp', then save into addrRefundTimestamp
+				codeByteBuffer.put(OpCode.EXT_FUN_RET_DAT_2.compile(FunctionCode.ADD_MINUTES_TO_TIMESTAMP, addrRefundTimestamp, addrLastTxnTimestamp, addrRefundTimeout));
+
+				/* We are in 'trade mode' */
+				codeByteBuffer.put(OpCode.SET_VAL.compile(addrMode, AcctMode.TRADING.value));
+
+				// Set restart position to after this opcode
+				codeByteBuffer.put(OpCode.SET_PCS.compile());
+
+				/* Loop, waiting for trade timeout or 'redeem' MESSAGE from Qortal trade partner */
+
+				// Fetch current block 'timestamp'
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(FunctionCode.GET_BLOCK_TIMESTAMP, addrBlockTimestamp));
+				// If we're not past refund 'timestamp' then look for next transaction
+				codeByteBuffer.put(OpCode.BLT_DAT.compile(addrBlockTimestamp, addrRefundTimestamp, calcOffset(codeByteBuffer, labelRedeemTxnLoop)));
+				// We're past refund 'timestamp' so go refund everything back to AT creator
+				codeByteBuffer.put(OpCode.JMP_ADR.compile(labelRefund == null ? 0 : labelRefund));
+
+				/* Transaction processing loop */
+				labelRedeemTxnLoop = codeByteBuffer.position();
+
+				// Find next transaction to this AT since the last one (if any)
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.PUT_TX_AFTER_TIMESTAMP_INTO_A, addrLastTxnTimestamp));
+				// If no transaction found, A will be zero. If A is zero, set addrComparator to 1, otherwise 0.
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(FunctionCode.CHECK_A_IS_ZERO, addrResult));
+				// If addrResult is zero (i.e. A is non-zero, transaction was found) then go check transaction
+				codeByteBuffer.put(OpCode.BZR_DAT.compile(addrResult, calcOffset(codeByteBuffer, labelCheckRedeemTxn)));
+				// Stop and wait for next block
+				codeByteBuffer.put(OpCode.STP_IMD.compile());
+
+				/* Check transaction */
+				labelCheckRedeemTxn = codeByteBuffer.position();
+
+				// Update our 'last found transaction's timestamp' using 'timestamp' from transaction
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(FunctionCode.GET_TIMESTAMP_FROM_TX_IN_A, addrLastTxnTimestamp));
+				// Extract transaction type (message/payment) from transaction and save type in addrTxnType
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(FunctionCode.GET_TYPE_FROM_TX_IN_A, addrTxnType));
+				// If transaction type is not MESSAGE type then go look for another transaction
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrTxnType, addrMessageTxnType, calcOffset(codeByteBuffer, labelRedeemTxnLoop)));
+
+				/* Check message payload length */
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(QortalFunctionCode.GET_MESSAGE_LENGTH_FROM_TX_IN_A.value, addrMessageLength));
+				// If message length matches, branch to sender checking code
+				codeByteBuffer.put(OpCode.BEQ_DAT.compile(addrMessageLength, addrExpectedRedeemMessageLength, calcOffset(codeByteBuffer, labelCheckRedeemTxnSender)));
+				// Message length didn't match - go back to finding another 'redeem' MESSAGE transaction
+				codeByteBuffer.put(OpCode.JMP_ADR.compile(labelRedeemTxnLoop == null ? 0 : labelRedeemTxnLoop));
+
+				/* Check transaction's sender */
+				labelCheckRedeemTxnSender = codeByteBuffer.position();
+
+				// Extract sender address from transaction into B register
+				codeByteBuffer.put(OpCode.EXT_FUN.compile(FunctionCode.PUT_ADDRESS_FROM_TX_IN_A_INTO_B));
+				// Save B register into data segment starting at addrMessageSender1 (as pointed to by addrMessageSenderPointer)
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.GET_B_IND, addrMessageSenderPointer));
+				// Compare each part of transaction's sender's address with expected address. If they don't match, look for another transaction.
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender1, addrQortalPartnerAddress1, calcOffset(codeByteBuffer, labelRedeemTxnLoop)));
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender2, addrQortalPartnerAddress2, calcOffset(codeByteBuffer, labelRedeemTxnLoop)));
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender3, addrQortalPartnerAddress3, calcOffset(codeByteBuffer, labelRedeemTxnLoop)));
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender4, addrQortalPartnerAddress4, calcOffset(codeByteBuffer, labelRedeemTxnLoop)));
+
+				/* Check 'secret-A' in transaction's message */
+
+				// Extract secret-A from first 32 bytes of message from transaction into B register
+				codeByteBuffer.put(OpCode.EXT_FUN.compile(FunctionCode.PUT_MESSAGE_FROM_TX_IN_A_INTO_B));
+				// Save B register into data segment starting at addrMessageData (as pointed to by addrMessageDataPointer)
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.GET_B_IND, addrMessageDataPointer));
+				// Load B register with expected hash result (as pointed to by addrHashOfSecretAPointer)
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.SET_B_IND, addrHashOfSecretAPointer));
+				// Perform HASH160 using source data at addrMessageData. (Location and length specified via addrMessageDataPointer and addrMessageDataLength).
+				// Save the equality result (1 if they match, 0 otherwise) into addrResult.
+				codeByteBuffer.put(OpCode.EXT_FUN_RET_DAT_2.compile(FunctionCode.CHECK_HASH160_WITH_B, addrResult, addrMessageDataPointer, addrMessageDataLength));
+				// If hashes don't match, addrResult will be zero so go find another transaction
+				codeByteBuffer.put(OpCode.BNZ_DAT.compile(addrResult, calcOffset(codeByteBuffer, labelPayout)));
+				codeByteBuffer.put(OpCode.JMP_ADR.compile(labelRedeemTxnLoop == null ? 0 : labelRedeemTxnLoop));
+
+				/* Success! Pay arranged amount to receiving address */
+				labelPayout = codeByteBuffer.position();
+
+				// Extract Qortal receiving address from next 32 bytes of message from transaction into B register
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(QortalFunctionCode.PUT_PARTIAL_MESSAGE_FROM_TX_IN_A_INTO_B.value, addrRedeemMessageReceivingAddressOffset));
+				// Save B register into data segment starting at addrPartnerReceivingAddress (as pointed to by addrPartnerReceivingAddressPointer)
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.GET_B_IND, addrPartnerReceivingAddressPointer));
+				// Pay AT's balance to receiving address
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.PAY_TO_ADDRESS_IN_B, addrQortAmount));
+				// Set redeemed mode
+				codeByteBuffer.put(OpCode.SET_VAL.compile(addrMode, AcctMode.REDEEMED.value));
+				// We're finished forever (finishing auto-refunds remaining balance to AT creator)
+				codeByteBuffer.put(OpCode.FIN_IMD.compile());
+
+				// Fall-through to refunding any remaining balance back to AT creator
+
+				/* Refund balance back to AT creator */
+				labelRefund = codeByteBuffer.position();
+
+				// Set refunded mode
+				codeByteBuffer.put(OpCode.SET_VAL.compile(addrMode, AcctMode.REFUNDED.value));
+				// We're finished forever (finishing auto-refunds remaining balance to AT creator)
+				codeByteBuffer.put(OpCode.FIN_IMD.compile());
+			} catch (CompilationException e) {
+				throw new IllegalStateException("Unable to compile ARRR-QORT ACCT?", e);
+			}
+		}
+
+		codeByteBuffer.flip();
+
+		byte[] codeBytes = new byte[codeByteBuffer.limit()];
+		codeByteBuffer.get(codeBytes);
+
+		assert Arrays.equals(Crypto.digest(codeBytes), PirateChainACCTv3.CODE_BYTES_HASH)
+			: String.format("BTCACCT.CODE_BYTES_HASH mismatch: expected %s, actual %s", HashCode.fromBytes(CODE_BYTES_HASH), HashCode.fromBytes(Crypto.digest(codeBytes)));
+
+		final short ciyamAtVersion = 2;
+		final short numCallStackPages = 0;
+		final short numUserStackPages = 0;
+		final long minActivationAmount = 0L;
+
+		return MachineState.toCreationBytes(ciyamAtVersion, codeBytes, dataByteBuffer.array(), numCallStackPages, numUserStackPages, minActivationAmount);
+	}
+
+	/**
+	 * Returns CrossChainTradeData with useful info extracted from AT.
+	 */
+	@Override
+	public CrossChainTradeData populateTradeData(Repository repository, ATData atData) throws DataException {
+		ATStateData atStateData = repository.getATRepository().getLatestATState(atData.getATAddress());
+		return populateTradeData(repository, atData.getCreatorPublicKey(), atData.getCreation(), atStateData);
+	}
+
+	/**
+	 * Returns CrossChainTradeData with useful info extracted from AT.
+	 */
+	@Override
+	public CrossChainTradeData populateTradeData(Repository repository, ATStateData atStateData) throws DataException {
+		ATData atData = repository.getATRepository().fromATAddress(atStateData.getATAddress());
+		return populateTradeData(repository, atData.getCreatorPublicKey(), atData.getCreation(), atStateData);
+	}
+
+	/**
+	 * Returns CrossChainTradeData with useful info extracted from AT.
+	 */
+	public CrossChainTradeData populateTradeData(Repository repository, byte[] creatorPublicKey, long creationTimestamp, ATStateData atStateData) throws DataException {
+		byte[] addressBytes = new byte[25]; // for general use
+		String atAddress = atStateData.getATAddress();
+
+		CrossChainTradeData tradeData = new CrossChainTradeData();
+
+		tradeData.foreignBlockchain = SupportedBlockchain.PIRATECHAIN.name();
+		tradeData.acctName = NAME;
+
+		tradeData.qortalAtAddress = atAddress;
+		tradeData.qortalCreator = Crypto.toAddress(creatorPublicKey);
+		tradeData.creationTimestamp = creationTimestamp;
+
+		Account atAccount = new Account(repository, atAddress);
+		tradeData.qortBalance = atAccount.getConfirmedBalance(Asset.QORT);
+
+		byte[] stateData = atStateData.getStateData();
+		ByteBuffer dataByteBuffer = ByteBuffer.wrap(stateData);
+		dataByteBuffer.position(MachineState.HEADER_LENGTH);
+
+		/* Constants */
+
+		// Skip creator's trade address
+		dataByteBuffer.get(addressBytes);
+		tradeData.qortalCreatorTradeAddress = Base58.encode(addressBytes);
+		dataByteBuffer.position(dataByteBuffer.position() + 32 - addressBytes.length);
+
+		// Creator's PirateChain/foreign public key (full 33 bytes, not hashed, so ignore references to "PKH")
+		tradeData.creatorForeignPKH = new byte[33];
+		dataByteBuffer.get(tradeData.creatorForeignPKH);
+		dataByteBuffer.position(dataByteBuffer.position() + 40 - tradeData.creatorForeignPKH.length); // skip to 40 bytes
+
+		// We don't use secret-B
+		tradeData.hashOfSecretB = null;
+
+		// Redeem payout
+		tradeData.qortAmount = dataByteBuffer.getLong();
+
+		// Expected ARRR amount
+		tradeData.expectedForeignAmount = dataByteBuffer.getLong();
+
+		// Trade timeout
+		tradeData.tradeTimeout = (int) dataByteBuffer.getLong();
+
+		// Skip MESSAGE transaction type
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip expected 'trade' message length
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip expected 'redeem' message length
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip pointer to creator's address
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip pointer to partner's Qortal trade address
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip pointer to message sender
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip 'trade' message data offset for first 32 bytes of partner's Pirate Chain public key
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip 'trade' message data offset for last 32 byte of partner's Pirate Chain public key
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip pointer to partner's Pirate Chain public key (first 32 bytes)
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip pointer to partner's Pirate Chain public key (last byte)
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip 'trade' message data offset for hash-of-secret-A
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip pointer to hash-of-secret-A
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip 'redeem' message data offset for partner's Qortal receiving address
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip pointer to message data
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip message data length
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip pointer to partner's receiving address
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		/* End of constants / begin variables */
+
+		// Skip AT creator's address
+		dataByteBuffer.position(dataByteBuffer.position() + 8 * 4);
+
+		// Partner's trade address (if present)
+		dataByteBuffer.get(addressBytes);
+		String qortalRecipient = Base58.encode(addressBytes);
+		dataByteBuffer.position(dataByteBuffer.position() + 32 - addressBytes.length);
+
+		// Potential lockTimeA (if in trade mode)
+		int lockTimeA = (int) dataByteBuffer.getLong();
+
+		// AT refund timeout (probably only useful for debugging)
+		int refundTimeout = (int) dataByteBuffer.getLong();
+
+		// Trade-mode refund timestamp (AT 'timestamp' converted to Qortal block height)
+		long tradeRefundTimestamp = dataByteBuffer.getLong();
+
+		// Skip last transaction timestamp
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip block timestamp
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip transaction type
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip temporary result
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip temporary message sender
+		dataByteBuffer.position(dataByteBuffer.position() + 8 * 4);
+
+		// Skip message length
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip temporary message data
+		dataByteBuffer.position(dataByteBuffer.position() + 8 * 4);
+
+		// Potential hash160 of secret A
+		byte[] hashOfSecretA = new byte[20];
+		dataByteBuffer.get(hashOfSecretA);
+		dataByteBuffer.position(dataByteBuffer.position() + 32 - hashOfSecretA.length); // skip to 32 bytes
+
+		// Potential partner's PirateChain public key
+		byte[] partnerPirateChainPublicKey = new byte[33];
+		dataByteBuffer.get(partnerPirateChainPublicKey);
+		dataByteBuffer.position(dataByteBuffer.position() + 64 - partnerPirateChainPublicKey.length); // skip to 64 bytes
+
+		// Partner's receiving address (if present)
+		byte[] partnerReceivingAddress = new byte[25];
+		dataByteBuffer.get(partnerReceivingAddress);
+		dataByteBuffer.position(dataByteBuffer.position() + 32 - partnerReceivingAddress.length); // skip to 32 bytes
+
+		// Trade AT's 'mode'
+		long modeValue = dataByteBuffer.getLong();
+		AcctMode mode = AcctMode.valueOf((int) (modeValue & 0xffL));
+
+		/* End of variables */
+
+		if (mode != null && mode != AcctMode.OFFERING) {
+			tradeData.mode = mode;
+			tradeData.refundTimeout = refundTimeout;
+			tradeData.tradeRefundHeight = new Timestamp(tradeRefundTimestamp).blockHeight;
+			tradeData.qortalPartnerAddress = qortalRecipient;
+			tradeData.hashOfSecretA = hashOfSecretA;
+			tradeData.partnerForeignPKH = partnerPirateChainPublicKey; // Not hashed
+			tradeData.lockTimeA = lockTimeA;
+
+			if (mode == AcctMode.REDEEMED)
+				tradeData.qortalPartnerReceivingAddress = Base58.encode(partnerReceivingAddress);
+		} else {
+			tradeData.mode = AcctMode.OFFERING;
+		}
+
+		tradeData.duplicateDeprecated();
+
+		return tradeData;
+	}
+
+	/** Returns 'offer' MESSAGE payload for trade partner to send to AT creator's trade address. */
+	public static byte[] buildOfferMessage(byte[] partnerBitcoinPublicKey, byte[] hashOfSecretA, int lockTimeA) {
+		byte[] lockTimeABytes = BitTwiddling.toBEByteArray((long) lockTimeA);
+		return Bytes.concat(partnerBitcoinPublicKey, hashOfSecretA, lockTimeABytes);
+	}
+
+	/** Returns info extracted from 'offer' MESSAGE payload sent by trade partner to AT creator's trade address, or null if not valid. */
+	public static OfferMessageData extractOfferMessageData(byte[] messageData) {
+		if (messageData == null || messageData.length != OFFER_MESSAGE_LENGTH)
+			return null;
+
+		OfferMessageData offerMessageData = new OfferMessageData();
+		offerMessageData.partnerPirateChainPublicKey = Arrays.copyOfRange(messageData, 0, 33);
+		offerMessageData.hashOfSecretA = Arrays.copyOfRange(messageData, 33, 53);
+		offerMessageData.lockTimeA = BitTwiddling.longFromBEBytes(messageData, 53);
+
+		return offerMessageData;
+	}
+
+	/** Returns 'trade' MESSAGE payload for AT creator to send to AT. */
+	public static byte[] buildTradeMessage(String partnerQortalTradeAddress, byte[] partnerBitcoinPublicKey, byte[] hashOfSecretA, int lockTimeA, int refundTimeout) {
+		byte[] data = new byte[TRADE_MESSAGE_LENGTH];
+		byte[] partnerQortalAddressBytes = Base58.decode(partnerQortalTradeAddress);
+		byte[] lockTimeABytes = BitTwiddling.toBEByteArray((long) lockTimeA);
+		byte[] refundTimeoutBytes = BitTwiddling.toBEByteArray((long) refundTimeout);
+
+		System.arraycopy(partnerQortalAddressBytes, 0, data, 0, partnerQortalAddressBytes.length);
+		System.arraycopy(partnerBitcoinPublicKey, 0, data, 32, partnerBitcoinPublicKey.length);
+		System.arraycopy(refundTimeoutBytes, 0, data, 72, refundTimeoutBytes.length);
+		System.arraycopy(hashOfSecretA, 0, data, 80, hashOfSecretA.length);
+		System.arraycopy(lockTimeABytes, 0, data, 104, lockTimeABytes.length);
+
+		return data;
+	}
+
+	/** Returns 'cancel' MESSAGE payload for AT creator to cancel trade AT. */
+	@Override
+	public byte[] buildCancelMessage(String creatorQortalAddress) {
+		byte[] data = new byte[CANCEL_MESSAGE_LENGTH];
+		byte[] creatorQortalAddressBytes = Base58.decode(creatorQortalAddress);
+
+		System.arraycopy(creatorQortalAddressBytes, 0, data, 0, creatorQortalAddressBytes.length);
+
+		return data;
+	}
+
+	/** Returns 'redeem' MESSAGE payload for trade partner to send to AT. */
+	public static byte[] buildRedeemMessage(byte[] secretA, String qortalReceivingAddress) {
+		byte[] data = new byte[REDEEM_MESSAGE_LENGTH];
+		byte[] qortalReceivingAddressBytes = Base58.decode(qortalReceivingAddress);
+
+		System.arraycopy(secretA, 0, data, 0, secretA.length);
+		System.arraycopy(qortalReceivingAddressBytes, 0, data, 32, qortalReceivingAddressBytes.length);
+
+		return data;
+	}
+
+	/** Returns refund timeout (minutes) based on trade partner's 'offer' MESSAGE timestamp and P2SH-A locktime. */
+	public static int calcRefundTimeout(long offerMessageTimestamp, int lockTimeA) {
+		// refund should be triggered halfway between offerMessageTimestamp and lockTimeA
+		return (int) ((lockTimeA - (offerMessageTimestamp / 1000L)) / 2L / 60L);
+	}
+
+	@Override
+	public byte[] findSecretA(Repository repository, CrossChainTradeData crossChainTradeData) throws DataException {
+		String atAddress = crossChainTradeData.qortalAtAddress;
+		String redeemerAddress = crossChainTradeData.qortalPartnerAddress;
+
+		// We don't have partner's public key so we check every message to AT
+		List<MessageTransactionData> messageTransactionsData = repository.getMessageRepository().getMessagesByParticipants(null, atAddress, null, null, null);
+		if (messageTransactionsData == null)
+			return null;
+
+		// Find 'redeem' message
+		for (MessageTransactionData messageTransactionData : messageTransactionsData) {
+			// Check message payload type/encryption
+			if (messageTransactionData.isText() || messageTransactionData.isEncrypted())
+				continue;
+
+			// Check message payload size
+			byte[] messageData = messageTransactionData.getData();
+			if (messageData.length != REDEEM_MESSAGE_LENGTH)
+				// Wrong payload length
+				continue;
+
+			// Check sender
+			if (!Crypto.toAddress(messageTransactionData.getSenderPublicKey()).equals(redeemerAddress))
+				// Wrong sender;
+				continue;
+
+			// Extract secretA
+			byte[] secretA = new byte[32];
+			System.arraycopy(messageData, 0, secretA, 0, secretA.length);
+
+			byte[] hashOfSecretA = Crypto.hash160(secretA);
+			if (!Arrays.equals(hashOfSecretA, crossChainTradeData.hashOfSecretA))
+				continue;
+
+			return secretA;
+		}
+
+		return null;
+	}
+
+}

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

@@ -0,0 +1,412 @@
+package org.qortal.crosschain;
+
+import com.google.common.hash.HashCode;
+import com.google.common.primitives.Bytes;
+import org.bitcoinj.core.*;
+import org.bitcoinj.core.Transaction.SigHash;
+import org.bitcoinj.crypto.TransactionSignature;
+import org.bitcoinj.script.Script;
+import org.bitcoinj.script.ScriptBuilder;
+import org.bitcoinj.script.ScriptChunk;
+import org.bitcoinj.script.ScriptOpCodes;
+import org.qortal.crypto.Crypto;
+import org.qortal.utils.Base58;
+import org.qortal.utils.BitTwiddling;
+
+import java.util.*;
+import java.util.function.Function;
+
+public class PirateChainHTLC {
+
+	public enum Status {
+		UNFUNDED, FUNDING_IN_PROGRESS, FUNDED, REDEEM_IN_PROGRESS, REDEEMED, REFUND_IN_PROGRESS, REFUNDED
+	}
+
+	public static final int SECRET_LENGTH = 32;
+	public static final int MIN_LOCKTIME = 1500000000;
+
+	public static final long NO_LOCKTIME_NO_RBF_SEQUENCE = 0xFFFFFFFFL;
+	public static final long LOCKTIME_NO_RBF_SEQUENCE = NO_LOCKTIME_NO_RBF_SEQUENCE - 1;
+
+	// Assuming node's trade-bot has no more than 100 entries?
+	private static final int MAX_CACHE_ENTRIES = 100;
+
+	// Max time-to-live for cache entries (milliseconds)
+	private static final long CACHE_TIMEOUT = 30_000L;
+
+	@SuppressWarnings("serial")
+	private static final Map<String, byte[]> SECRET_CACHE = new LinkedHashMap<>(MAX_CACHE_ENTRIES + 1, 0.75F, true) {
+		// This method is called just after a new entry has been added
+		@Override
+		public boolean removeEldestEntry(Map.Entry<String, byte[]> eldest) {
+			return size() > MAX_CACHE_ENTRIES;
+		}
+	};
+	private static final byte[] NO_SECRET_CACHE_ENTRY = new byte[0];
+
+	@SuppressWarnings("serial")
+	private static final Map<String, Status> STATUS_CACHE = new LinkedHashMap<>(MAX_CACHE_ENTRIES + 1, 0.75F, true) {
+		// This method is called just after a new entry has been added
+		@Override
+		public boolean removeEldestEntry(Map.Entry<String, Status> eldest) {
+			return size() > MAX_CACHE_ENTRIES;
+		}
+	};
+
+	/*
+	 * OP_RETURN + OP_PUSHDATA1 + bytes (not part of actual redeem script - used for "push only" secondary output when funding P2SH)
+	 *
+	 * OP_IF (if top stack value isn't false) (true=refund; false=redeem) (boolean is then removed from stack)
+	 * 		<push 4 bytes> <intended locktime>
+	 * 		OP_CHECKLOCKTIMEVERIFY (if stack locktime greater than transaction's lock time - i.e. refunding but too soon - then fail validation)
+	 * 		OP_DROP (remove locktime from top of stack)
+	 * 		<push 33 bytes> <intended refunder public key>
+	 * 		OP_CHECKSIG (check signature and public key are correct; returns 1 or 0)
+	 * OP_ELSE (if top stack value was false, i.e. attempting to redeem)
+	 * 		OP_SIZE (push length of top item - the secret - to the top of the stack)
+	 * 		<push 1 byte> 32
+	 * 		OP_EQUALVERIFY (unhashed secret must be 32 bytes in length)
+	 * 		OP_HASH160 (hash the secret)
+	 * 		<push 20 bytes> <intended secret hash>
+	 * 		OP_EQUALVERIFY (ensure hash of supplied secret matches intended secret hash; transaction invalid if no match)
+	 * 		<push 33 bytes> <intended redeemer public key>
+	 * 		OP_CHECKSIG (check signature and public key are correct; returns 1 or 0)
+	 * OP_ENDIF
+	 */
+
+	private static final byte[] pushOnlyPrefix = HashCode.fromString("6a4c").asBytes(); // OP_RETURN + push(redeem script)
+	private static final byte[] redeemScript1 = HashCode.fromString("6304").asBytes(); // OP_IF push(4 bytes locktime)
+	private static final byte[] redeemScript2 = HashCode.fromString("b17521").asBytes(); // OP_CHECKLOCKTIMEVERIFY OP_DROP push(33 bytes refund pubkey)
+	private static final byte[] redeemScript3 = HashCode.fromString("ac6782012088a914").asBytes(); // OP_CHECKSIG OP_ELSE OP_SIZE push(0x20) OP_EQUALVERIFY OP_HASH160 push(20 bytes hash of secret)
+	private static final byte[] redeemScript4 = HashCode.fromString("8821").asBytes(); // OP_EQUALVERIFY push(33 bytes redeem pubkey)
+	private static final byte[] redeemScript5 = HashCode.fromString("ac68").asBytes(); // OP_CHECKSIG OP_ENDIF
+
+	/**
+	 * Returns redeemScript used for cross-chain trading.
+	 * <p>
+	 * See comments in {@link PirateChainHTLC} for more details.
+	 * 
+	 * @param refunderPubKey 33-byte P2SH funder's public key, for refunding purposes
+	 * @param lockTime seconds-since-epoch threshold, after which P2SH funder can claim refund
+	 * @param redeemerPubKey 33-byte P2SH redeemer's public key
+	 * @param hashOfSecret 20-byte HASH160 of secret, used by P2SH redeemer to claim funds
+	 */
+	public static byte[] buildScript(byte[] refunderPubKey, int lockTime, byte[] redeemerPubKey, byte[] hashOfSecret) {
+		return Bytes.concat(redeemScript1, BitTwiddling.toLEByteArray((int) (lockTime & 0xffffffffL)), redeemScript2,
+				refunderPubKey, redeemScript3, hashOfSecret, redeemScript4, redeemerPubKey, redeemScript5);
+	}
+
+	/**
+	 * Alternative to buildScript() above, this time with a prefix suitable for adding the redeem script
+	 * to a "push only" output (via OP_RETURN followed by OP_PUSHDATA1)
+	 *
+	 * @param refunderPubKey 33-byte P2SH funder's public key, for refunding purposes
+	 * @param lockTime seconds-since-epoch threshold, after which P2SH funder can claim refund
+	 * @param redeemerPubKey 33-byte P2SH redeemer's public key
+	 * @param hashOfSecret 20-byte HASH160 of secret, used by P2SH redeemer to claim funds
+	 * @return
+	 */
+	public static byte[] buildScriptWithPrefix(byte[] refunderPubKey, int lockTime, byte[] redeemerPubKey, byte[] hashOfSecret) {
+		byte[] redeemScript = buildScript(refunderPubKey, lockTime, redeemerPubKey, hashOfSecret);
+		int size = redeemScript.length;
+		String sizeHex = Integer.toHexString(size & 0xFF);
+		return Bytes.concat(pushOnlyPrefix, HashCode.fromString(sizeHex).asBytes(), redeemScript);
+	}
+
+	/**
+	 * Returns 'secret', if any, given HTLC's P2SH address.
+	 * <p>
+	 * @throws ForeignBlockchainException
+	 */
+	public static byte[] findHtlcSecret(Bitcoiny bitcoiny, String p2shAddress) throws ForeignBlockchainException {
+		NetworkParameters params = bitcoiny.getNetworkParameters();
+		String compoundKey = String.format("%s-%s-%d", params.getId(), p2shAddress, System.currentTimeMillis() / CACHE_TIMEOUT);
+
+		byte[] secret = SECRET_CACHE.getOrDefault(compoundKey, NO_SECRET_CACHE_ENTRY);
+		if (secret != NO_SECRET_CACHE_ENTRY)
+			return secret;
+
+		List<byte[]> rawTransactions = bitcoiny.getAddressTransactions(p2shAddress);
+
+		for (byte[] rawTransaction : rawTransactions) {
+			Transaction transaction = new Transaction(params, rawTransaction);
+
+			// Cycle through inputs, looking for one that spends our HTLC
+			for (TransactionInput input : transaction.getInputs()) {
+				Script scriptSig = input.getScriptSig();
+				List<ScriptChunk> scriptChunks = scriptSig.getChunks();
+
+				// Expected number of script chunks for redeem. Refund might not have the same number.
+				int expectedChunkCount = 1 /*secret*/ + 1 /*sig*/ + 1 /*pubkey*/ + 1 /*redeemScript*/;
+				if (scriptChunks.size() != expectedChunkCount)
+					continue;
+
+				// We're expecting last chunk to contain the actual redeemScript
+				ScriptChunk lastChunk = scriptChunks.get(scriptChunks.size() - 1);
+				byte[] redeemScriptBytes = lastChunk.data;
+
+				// If non-push scripts, redeemScript will be null
+				if (redeemScriptBytes == null)
+					continue;
+
+				byte[] redeemScriptHash = Crypto.hash160(redeemScriptBytes);
+				Address inputAddress = LegacyAddress.fromScriptHash(params, redeemScriptHash);
+
+				if (!inputAddress.toString().equals(p2shAddress))
+					// Input isn't spending our HTLC
+					continue;
+
+				secret = scriptChunks.get(0).data;
+				if (secret.length != PirateChainHTLC.SECRET_LENGTH)
+					continue;
+
+				// Cache secret for a while
+				SECRET_CACHE.put(compoundKey, secret);
+
+				return secret;
+			}
+		}
+
+		// Cache negative result
+		SECRET_CACHE.put(compoundKey, null);
+
+		return null;
+	}
+
+	/**
+	 * Returns a string containing the txid of the transaction that funded supplied <tt>p2shAddress</tt>
+	 * We have to do this in a bit of a roundabout way due to the Pirate Light Client server omitting
+	 * transaction hashes from the raw transaction data.
+	 * <p>
+	 * @throws ForeignBlockchainException if error occurs
+	 */
+	public static String getFundingTxid(BitcoinyBlockchainProvider blockchain, String p2shAddress) throws ForeignBlockchainException {
+		byte[] ourScriptPubKey = addressToScriptPubKey(p2shAddress);
+		// HASH160(redeem script) for this p2shAddress
+		byte[] ourRedeemScriptHash = addressToRedeemScriptHash(p2shAddress);
+
+
+		// Firstly look for an unspent output
+
+		// Note: we can't include unconfirmed transactions here because the Pirate light wallet server requires a block range
+		List<UnspentOutput> unspentOutputs = blockchain.getUnspentOutputs(p2shAddress, false);
+		for (UnspentOutput unspentOutput : unspentOutputs) {
+
+			if (!Arrays.equals(ourScriptPubKey, unspentOutput.script)) {
+				continue;
+			}
+
+			return HashCode.fromBytes(unspentOutput.hash).toString();
+		}
+
+
+		// No valid unspent outputs, so must be already spent...
+
+		// Note: we can't include unconfirmed transactions here because the Pirate light wallet server requires a block range
+		List<BitcoinyTransaction> transactions = blockchain.getAddressBitcoinyTransactions(p2shAddress, BitcoinyBlockchainProvider.EXCLUDE_UNCONFIRMED);
+
+		// Sort by confirmed first, followed by ascending height
+		transactions.sort(BitcoinyTransaction.CONFIRMED_FIRST.thenComparing(BitcoinyTransaction::getHeight));
+
+		for (BitcoinyTransaction bitcoinyTransaction : transactions) {
+
+			// Acceptable funding is one transaction output, so we're expecting only one input
+			if (bitcoinyTransaction.inputs.size() != 1)
+				// Wrong number of inputs
+				continue;
+
+			String scriptSig = bitcoinyTransaction.inputs.get(0).scriptSig;
+
+			List<byte[]> scriptSigChunks = extractScriptSigChunks(HashCode.fromString(scriptSig).asBytes());
+			if (scriptSigChunks.size() < 3 || scriptSigChunks.size() > 4)
+				// Not valid chunks for our form of HTLC
+				continue;
+
+			// Last chunk is redeem script
+			byte[] redeemScriptBytes = scriptSigChunks.get(scriptSigChunks.size() - 1);
+			byte[] redeemScriptHash = Crypto.hash160(redeemScriptBytes);
+			if (!Arrays.equals(redeemScriptHash, ourRedeemScriptHash))
+				// Not spending our specific HTLC redeem script
+				continue;
+
+			return bitcoinyTransaction.inputs.get(0).outputTxHash;
+
+		}
+
+		return null;
+	}
+
+	/**
+	 * Returns a string containing the unspent txid of the transaction that funded supplied <tt>p2shAddress</tt>
+	 * and is at least the value specified in <tt>minimumAmount</tt>
+	 * <p>
+	 * @throws ForeignBlockchainException if error occurs
+	 */
+	public static String getUnspentFundingTxid(BitcoinyBlockchainProvider blockchain, String p2shAddress, long minimumAmount) throws ForeignBlockchainException {
+		byte[] ourScriptPubKey = addressToScriptPubKey(p2shAddress);
+
+		// Note: we can't include unconfirmed transactions here because the Pirate light wallet server requires a block range
+		List<UnspentOutput> unspentOutputs = blockchain.getUnspentOutputs(p2shAddress, false);
+		for (UnspentOutput unspentOutput : unspentOutputs) {
+
+			if (!Arrays.equals(ourScriptPubKey, unspentOutput.script)) {
+				// Not funding our specific HTLC script hash
+				continue;
+			}
+
+			if (unspentOutput.value < minimumAmount) {
+				// Not funding the required amount
+				continue;
+			}
+
+			return HashCode.fromBytes(unspentOutput.hash).toString();
+		}
+
+
+		// No valid unspent outputs, so must be already spent
+		return null;
+	}
+
+	/**
+	 * Returns HTLC status, given P2SH address and expected redeem/refund amount
+	 * <p>
+	 * @throws ForeignBlockchainException if error occurs
+	 */
+	public static Status determineHtlcStatus(BitcoinyBlockchainProvider blockchain, String p2shAddress, long minimumAmount) throws ForeignBlockchainException {
+		String compoundKey = String.format("%s-%s-%d", blockchain.getNetId(), p2shAddress, System.currentTimeMillis() / CACHE_TIMEOUT);
+
+		Status cachedStatus = STATUS_CACHE.getOrDefault(compoundKey, null);
+		if (cachedStatus != null)
+			return cachedStatus;
+
+		byte[] ourScriptPubKey = addressToScriptPubKey(p2shAddress);
+
+		// Note: we can't include unconfirmed transactions here because the Pirate light wallet server requires a block range
+		List<BitcoinyTransaction> transactions = blockchain.getAddressBitcoinyTransactions(p2shAddress, BitcoinyBlockchainProvider.EXCLUDE_UNCONFIRMED);
+
+		// Sort by confirmed first, followed by ascending height
+		transactions.sort(BitcoinyTransaction.CONFIRMED_FIRST.thenComparing(BitcoinyTransaction::getHeight));
+
+		// Transaction cache
+		//Map<String, BitcoinyTransaction> transactionsByHash = new HashMap<>();
+		// HASH160(redeem script) for this p2shAddress
+		byte[] ourRedeemScriptHash = addressToRedeemScriptHash(p2shAddress);
+
+		// Check for spends first, caching full transaction info as we progress just in case we don't return in this loop
+		for (BitcoinyTransaction bitcoinyTransaction : transactions) {
+
+			// Cache for possible later reuse
+			// transactionsByHash.put(transactionInfo.txHash, bitcoinyTransaction);
+
+			// Acceptable funding is one transaction output, so we're expecting only one input
+			if (bitcoinyTransaction.inputs.size() != 1)
+				// Wrong number of inputs
+				continue;
+
+			String scriptSig = bitcoinyTransaction.inputs.get(0).scriptSig;
+
+			List<byte[]> scriptSigChunks = extractScriptSigChunks(HashCode.fromString(scriptSig).asBytes());
+			if (scriptSigChunks.size() < 3 || scriptSigChunks.size() > 4)
+				// Not valid chunks for our form of HTLC
+				continue;
+
+			// Last chunk is redeem script
+			byte[] redeemScriptBytes = scriptSigChunks.get(scriptSigChunks.size() - 1);
+			byte[] redeemScriptHash = Crypto.hash160(redeemScriptBytes);
+			if (!Arrays.equals(redeemScriptHash, ourRedeemScriptHash))
+				// Not spending our specific HTLC redeem script
+				continue;
+
+			if (scriptSigChunks.size() == 4)
+				// If we have 4 chunks, then secret is present, hence redeem
+				cachedStatus = bitcoinyTransaction.height == 0 ? Status.REDEEM_IN_PROGRESS : Status.REDEEMED;
+			else
+				cachedStatus = bitcoinyTransaction.height == 0 ? Status.REFUND_IN_PROGRESS : Status.REFUNDED;
+
+			STATUS_CACHE.put(compoundKey, cachedStatus);
+			return cachedStatus;
+		}
+
+		String ourScriptPubKeyHex = HashCode.fromBytes(ourScriptPubKey).toString();
+
+		// Check for funding
+		for (BitcoinyTransaction bitcoinyTransaction : transactions) {
+			if (bitcoinyTransaction == null)
+				// Should be present in map!
+				throw new ForeignBlockchainException("Cached Bitcoin transaction now missing?");
+
+			// Check outputs for our specific P2SH
+			for (BitcoinyTransaction.Output output : bitcoinyTransaction.outputs) {
+				// Check amount
+				if (output.value < minimumAmount)
+					// Output amount too small (not taking fees into account)
+					continue;
+
+				String scriptPubKeyHex = output.scriptPubKey;
+				if (!scriptPubKeyHex.equals(ourScriptPubKeyHex))
+					// Not funding our specific P2SH
+					continue;
+
+				cachedStatus = bitcoinyTransaction.height == 0 ? Status.FUNDING_IN_PROGRESS : Status.FUNDED;
+				STATUS_CACHE.put(compoundKey, cachedStatus);
+				return cachedStatus;
+			}
+		}
+
+		cachedStatus = Status.UNFUNDED;
+		STATUS_CACHE.put(compoundKey, cachedStatus);
+		return cachedStatus;
+	}
+
+	private static List<byte[]> extractScriptSigChunks(byte[] scriptSigBytes) {
+		List<byte[]> chunks = new ArrayList<>();
+
+		int offset = 0;
+		int previousOffset = 0;
+		while (offset < scriptSigBytes.length) {
+			byte pushOp = scriptSigBytes[offset++];
+
+			if (pushOp < 0 || pushOp > 0x4c)
+				// Unacceptable OP
+				return Collections.emptyList();
+
+			// Special treatment for OP_PUSHDATA1
+			if (pushOp == 0x4c) {
+				if (offset >= scriptSigBytes.length)
+					// Run out of scriptSig bytes?
+					return Collections.emptyList();
+
+				pushOp = scriptSigBytes[offset++];
+			}
+
+			previousOffset = offset;
+			offset += Byte.toUnsignedInt(pushOp);
+
+			byte[] chunk = Arrays.copyOfRange(scriptSigBytes, previousOffset, offset);
+			chunks.add(chunk);
+		}
+
+		return chunks;
+	}
+
+	private static byte[] addressToScriptPubKey(String p2shAddress) {
+		// We want the HASH160 part of the P2SH address
+		byte[] p2shAddressBytes = Base58.decode(p2shAddress);
+
+		byte[] scriptPubKey = new byte[1 + 1 + 20 + 1];
+		scriptPubKey[0x00] = (byte) 0xa9; /* OP_HASH160 */
+		scriptPubKey[0x01] = (byte) 0x14; /* PUSH 0x14 bytes */
+		System.arraycopy(p2shAddressBytes, 1, scriptPubKey, 2, 0x14);
+		scriptPubKey[0x16] = (byte) 0x87; /* OP_EQUAL */
+
+		return scriptPubKey;
+	}
+
+	private static byte[] addressToRedeemScriptHash(String p2shAddress) {
+		// We want the HASH160 part of the P2SH address
+		byte[] p2shAddressBytes = Base58.decode(p2shAddress);
+
+		return Arrays.copyOfRange(p2shAddressBytes, 1, 1 + 20);
+	}
+
+}

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

@@ -0,0 +1,649 @@
+package org.qortal.crosschain;
+
+import cash.z.wallet.sdk.rpc.CompactFormats.*;
+import cash.z.wallet.sdk.rpc.CompactTxStreamerGrpc;
+import cash.z.wallet.sdk.rpc.Service;
+import cash.z.wallet.sdk.rpc.Service.*;
+import com.google.common.hash.HashCode;
+import com.google.protobuf.ByteString;
+import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.json.simple.JSONArray;
+import org.json.simple.JSONObject;
+import org.json.simple.parser.JSONParser;
+import org.json.simple.parser.ParseException;
+import org.qortal.settings.Settings;
+import org.qortal.transform.TransformationException;
+
+import java.math.BigDecimal;
+import java.util.*;
+import java.util.concurrent.TimeUnit;
+
+/** Pirate Chain network support for querying Bitcoiny-related info like block headers, transaction outputs, etc. */
+public class PirateLightClient extends BitcoinyBlockchainProvider {
+
+	private static final Logger LOGGER = LogManager.getLogger(PirateLightClient.class);
+	private static final Random RANDOM = new Random();
+
+	private static final int RESPONSE_TIME_READINGS = 5;
+	private static final long MAX_AVG_RESPONSE_TIME = 500L; // ms
+
+	public static class Server {
+		String hostname;
+
+		public enum ConnectionType { TCP, SSL }
+		ConnectionType connectionType;
+
+		int port;
+		private List<Long> responseTimes = new ArrayList<>();
+
+		public Server(String hostname, ConnectionType connectionType, int port) {
+			this.hostname = hostname;
+			this.connectionType = connectionType;
+			this.port = port;
+		}
+
+		public void addResponseTime(long responseTime) {
+			while (this.responseTimes.size() > RESPONSE_TIME_READINGS) {
+				this.responseTimes.remove(0);
+			}
+			this.responseTimes.add(responseTime);
+		}
+
+		public long averageResponseTime() {
+			if (this.responseTimes.size() < RESPONSE_TIME_READINGS) {
+				// Not enough readings yet
+				return 0L;
+			}
+			OptionalDouble average = this.responseTimes.stream().mapToDouble(a -> a).average();
+			if (average.isPresent()) {
+				return Double.valueOf(average.getAsDouble()).longValue();
+			}
+			return 0L;
+		}
+
+		@Override
+		public boolean equals(Object other) {
+			if (other == this)
+				return true;
+
+			if (!(other instanceof Server))
+				return false;
+
+			Server otherServer = (Server) other;
+
+			return this.connectionType == otherServer.connectionType
+					&& this.port == otherServer.port
+					&& this.hostname.equals(otherServer.hostname);
+		}
+
+		@Override
+		public int hashCode() {
+			return this.hostname.hashCode() ^ this.port;
+		}
+
+		@Override
+		public String toString() {
+			return String.format("%s:%s:%d", this.connectionType.name(), this.hostname, this.port);
+		}
+	}
+	private Set<Server> servers = new HashSet<>();
+	private List<Server> remainingServers = new ArrayList<>();
+	private Set<Server> uselessServers = Collections.synchronizedSet(new HashSet<>());
+
+	private final String netId;
+	private final String expectedGenesisHash;
+	private final Map<Server.ConnectionType, Integer> defaultPorts = new EnumMap<>(Server.ConnectionType.class);
+	private Bitcoiny blockchain;
+
+	private final Object serverLock = new Object();
+	private Server currentServer;
+	private ManagedChannel channel;
+	private int nextId = 1;
+
+	private static final int TX_CACHE_SIZE = 1000;
+	@SuppressWarnings("serial")
+	private final Map<String, BitcoinyTransaction> transactionCache = Collections.synchronizedMap(new LinkedHashMap<>(TX_CACHE_SIZE + 1, 0.75F, true) {
+		// This method is called just after a new entry has been added
+		@Override
+		public boolean removeEldestEntry(Map.Entry<String, BitcoinyTransaction> eldest) {
+			return size() > TX_CACHE_SIZE;
+		}
+	});
+
+	// Constructors
+
+	public PirateLightClient(String netId, String genesisHash, Collection<Server> initialServerList, Map<Server.ConnectionType, Integer> defaultPorts) {
+		this.netId = netId;
+		this.expectedGenesisHash = genesisHash;
+		this.servers.addAll(initialServerList);
+		this.defaultPorts.putAll(defaultPorts);
+	}
+
+	// Methods for use by other classes
+
+	@Override
+	public void setBlockchain(Bitcoiny blockchain) {
+		this.blockchain = blockchain;
+	}
+
+	@Override
+	public String getNetId() {
+		return this.netId;
+	}
+
+	/**
+	 * Returns current blockchain height.
+	 * <p>
+	 * @throws ForeignBlockchainException if error occurs
+	 */
+	@Override
+	public int getCurrentHeight() throws ForeignBlockchainException {
+		BlockID latestBlock = this.getCompactTxStreamerStub().getLatestBlock(null);
+
+		if (!(latestBlock instanceof BlockID))
+			throw new ForeignBlockchainException.NetworkException("Unexpected output from Pirate Chain getLatestBlock gRPC");
+
+		return (int)latestBlock.getHeight();
+	}
+
+	/**
+	 * Returns list of compact blocks, starting from <tt>startHeight</tt> inclusive.
+	 * <p>
+	 * @throws ForeignBlockchainException if error occurs
+	 * @return
+	 */
+	@Override
+	public List<CompactBlock> getCompactBlocks(int startHeight, int count) throws ForeignBlockchainException {
+		BlockID startBlock = BlockID.newBuilder().setHeight(startHeight).build();
+		BlockID endBlock = BlockID.newBuilder().setHeight(startHeight + count - 1).build();
+		BlockRange range = BlockRange.newBuilder().setStart(startBlock).setEnd(endBlock).build();
+
+		Iterator<CompactBlock> blocksIterator = this.getCompactTxStreamerStub().getBlockRange(range);
+
+		// Map from Iterator to List
+		List<CompactBlock> blocks = new ArrayList<>();
+		blocksIterator.forEachRemaining(blocks::add);
+
+		return blocks;
+	}
+
+	/**
+	 * Returns list of raw block headers, starting from <tt>startHeight</tt> inclusive.
+	 * <p>
+	 * @throws ForeignBlockchainException if error occurs
+	 */
+	@Override
+	public List<byte[]> getRawBlockHeaders(int startHeight, int count) throws ForeignBlockchainException {
+		BlockID startBlock = BlockID.newBuilder().setHeight(startHeight).build();
+		BlockID endBlock = BlockID.newBuilder().setHeight(startHeight + count - 1).build();
+		BlockRange range = BlockRange.newBuilder().setStart(startBlock).setEnd(endBlock).build();
+
+		Iterator<CompactBlock> blocks = this.getCompactTxStreamerStub().getBlockRange(range);
+
+		List<byte[]> rawBlockHeaders = new ArrayList<>();
+
+		while (blocks.hasNext()) {
+			CompactBlock block = blocks.next();
+
+			if (block.getHeader() == null) {
+				throw new ForeignBlockchainException.NetworkException("Unexpected output from Pirate Chain getBlockRange gRPC");
+			}
+
+			rawBlockHeaders.add(block.getHeader().toByteArray());
+		}
+
+		return rawBlockHeaders;
+	}
+
+	/**
+	 * Returns list of raw block timestamps, starting from <tt>startHeight</tt> inclusive.
+	 * <p>
+	 * @throws ForeignBlockchainException if error occurs
+	 */
+	@Override
+	public List<Long> getBlockTimestamps(int startHeight, int count) throws ForeignBlockchainException {
+		BlockID startBlock = BlockID.newBuilder().setHeight(startHeight).build();
+		BlockID endBlock = BlockID.newBuilder().setHeight(startHeight + count - 1).build();
+		BlockRange range = BlockRange.newBuilder().setStart(startBlock).setEnd(endBlock).build();
+
+		Iterator<CompactBlock> blocks = this.getCompactTxStreamerStub().getBlockRange(range);
+
+		List<Long> rawBlockTimestamps = new ArrayList<>();
+
+		while (blocks.hasNext()) {
+			CompactBlock block = blocks.next();
+
+			if (block.getTime() <= 0) {
+				throw new ForeignBlockchainException.NetworkException("Unexpected output from Pirate Chain getBlockRange gRPC");
+			}
+
+			rawBlockTimestamps.add(Long.valueOf(block.getTime()));
+		}
+
+		return rawBlockTimestamps;
+	}
+
+	/**
+	 * Returns confirmed balance, based on passed payment script.
+	 * <p>
+	 * @return confirmed balance, or zero if script unknown
+	 * @throws ForeignBlockchainException if there was an error
+	 */
+	@Override
+	public long getConfirmedBalance(byte[] script) throws ForeignBlockchainException {
+		throw new ForeignBlockchainException("getConfirmedBalance not yet implemented for Pirate Chain");
+	}
+
+	/**
+	 * Returns confirmed balance, based on passed base58 encoded address.
+	 * <p>
+	 * @return confirmed balance, or zero if address unknown
+	 * @throws ForeignBlockchainException if there was an error
+	 */
+	@Override
+	public long getConfirmedAddressBalance(String base58Address) throws ForeignBlockchainException {
+		AddressList addressList = AddressList.newBuilder().addAddresses(base58Address).build();
+		Balance balance = this.getCompactTxStreamerStub().getTaddressBalance(addressList);
+
+		if (!(balance instanceof Balance))
+			throw new ForeignBlockchainException.NetworkException("Unexpected output from Pirate Chain getConfirmedAddressBalance gRPC");
+
+		return balance.getValueZat();
+	}
+
+	/**
+	 * Returns list of unspent outputs pertaining to passed address.
+	 * <p>
+	 * @return list of unspent outputs, or empty list if address unknown
+	 * @throws ForeignBlockchainException if there was an error.
+	 */
+	@Override
+	public List<UnspentOutput> getUnspentOutputs(String address, boolean includeUnconfirmed) throws ForeignBlockchainException {
+		GetAddressUtxosArg getAddressUtxosArg = GetAddressUtxosArg.newBuilder().addAddresses(address).build();
+		GetAddressUtxosReplyList replyList = this.getCompactTxStreamerStub().getAddressUtxos(getAddressUtxosArg);
+
+		if (!(replyList instanceof GetAddressUtxosReplyList))
+			throw new ForeignBlockchainException.NetworkException("Unexpected output from Pirate Chain getUnspentOutputs gRPC");
+
+		List<GetAddressUtxosReply> unspentList = replyList.getAddressUtxosList();
+		if (unspentList == null)
+			throw new ForeignBlockchainException.NetworkException("Unexpected output from Pirate Chain getUnspentOutputs gRPC");
+
+		List<UnspentOutput> unspentOutputs = new ArrayList<>();
+		for (GetAddressUtxosReply unspent : unspentList) {
+
+			int height = (int)unspent.getHeight();
+			// We only want unspent outputs from confirmed transactions (and definitely not mempool duplicates with height 0)
+			if (!includeUnconfirmed && height <= 0)
+				continue;
+
+			byte[] txHash = unspent.getTxid().toByteArray();
+			int outputIndex = unspent.getIndex();
+			long value = unspent.getValueZat();
+			byte[] script = unspent.getScript().toByteArray();
+			String addressRes = unspent.getAddress();
+
+			unspentOutputs.add(new UnspentOutput(txHash, outputIndex, height, value, script, addressRes));
+		}
+
+		return unspentOutputs;
+	}
+
+	/**
+	 * Returns list of unspent outputs pertaining to passed payment script.
+	 * <p>
+	 * @return list of unspent outputs, or empty list if script unknown
+	 * @throws ForeignBlockchainException if there was an error.
+	 */
+	@Override
+	public List<UnspentOutput> getUnspentOutputs(byte[] script, boolean includeUnconfirmed) throws ForeignBlockchainException {
+		String address = this.blockchain.deriveP2shAddress(script);
+		return this.getUnspentOutputs(address, includeUnconfirmed);
+	}
+
+	/**
+	 * Returns raw transaction for passed transaction hash.
+	 * <p>
+	 * NOTE: Do not mutate returned byte[]!
+	 *
+	 * @throws ForeignBlockchainException.NotFoundException if transaction not found
+	 * @throws ForeignBlockchainException if error occurs
+	 */
+	@Override
+	public byte[] getRawTransaction(String txHash) throws ForeignBlockchainException {
+		return getRawTransaction(HashCode.fromString(txHash).asBytes());
+	}
+
+	/**
+	 * Returns raw transaction for passed transaction hash.
+	 * <p>
+	 * NOTE: Do not mutate returned byte[]!
+	 *
+	 * @throws ForeignBlockchainException.NotFoundException if transaction not found
+	 * @throws ForeignBlockchainException if error occurs
+	 */
+	@Override
+	public byte[] getRawTransaction(byte[] txHash) throws ForeignBlockchainException {
+		ByteString byteString = ByteString.copyFrom(txHash);
+		TxFilter txFilter = TxFilter.newBuilder().setHash(byteString).build();
+		RawTransaction rawTransaction = this.getCompactTxStreamerStub().getTransaction(txFilter);
+
+		if (!(rawTransaction instanceof RawTransaction))
+			throw new ForeignBlockchainException.NetworkException("Unexpected output from Pirate Chain getTransaction gRPC");
+
+		return rawTransaction.getData().toByteArray();
+	}
+
+	/**
+	 * Returns transaction info for passed transaction hash.
+	 * <p>
+	 * @throws ForeignBlockchainException.NotFoundException if transaction not found
+	 * @throws ForeignBlockchainException if error occurs
+	 */
+	@Override
+	public BitcoinyTransaction getTransaction(String txHash) throws ForeignBlockchainException {
+		// Check cache first
+		BitcoinyTransaction transaction = transactionCache.get(txHash);
+		if (transaction != null)
+			return transaction;
+
+		ByteString byteString = ByteString.copyFrom(HashCode.fromString(txHash).asBytes());
+		TxFilter txFilter = TxFilter.newBuilder().setHash(byteString).build();
+		RawTransaction rawTransaction = this.getCompactTxStreamerStub().getTransaction(txFilter);
+
+		if (!(rawTransaction instanceof RawTransaction))
+			throw new ForeignBlockchainException.NetworkException("Unexpected output from Pirate Chain getTransaction gRPC");
+
+		byte[] transactionData = rawTransaction.getData().toByteArray();
+		String transactionDataString = HashCode.fromBytes(transactionData).toString();
+
+		JSONParser parser = new JSONParser();
+		JSONObject transactionJson;
+		try {
+			transactionJson = (JSONObject) parser.parse(transactionDataString);
+		} catch (ParseException e) {
+			throw new ForeignBlockchainException.NetworkException("Expected JSON string from Pirate Chain getTransaction gRPC");
+		}
+
+		Object inputsObj = transactionJson.get("vin");
+		if (!(inputsObj instanceof JSONArray))
+			throw new ForeignBlockchainException.NetworkException("Expected JSONArray for 'vin' from Pirate Chain getTransaction gRPC");
+
+		Object outputsObj = transactionJson.get("vout");
+		if (!(outputsObj instanceof JSONArray))
+			throw new ForeignBlockchainException.NetworkException("Expected JSONArray for 'vout' from Pirate Chain getTransaction gRPC");
+
+		try {
+			int size = ((Long) transactionJson.get("size")).intValue();
+			int locktime = ((Long) transactionJson.get("locktime")).intValue();
+
+			// Timestamp might not be present, e.g. for unconfirmed transaction
+			Object timeObj = transactionJson.get("time");
+			Integer timestamp = timeObj != null
+					? ((Long) timeObj).intValue()
+					: null;
+
+			List<BitcoinyTransaction.Input> inputs = new ArrayList<>();
+			for (Object inputObj : (JSONArray) inputsObj) {
+				JSONObject inputJson = (JSONObject) inputObj;
+
+				String scriptSig = (String) ((JSONObject) inputJson.get("scriptSig")).get("hex");
+				int sequence = ((Long) inputJson.get("sequence")).intValue();
+				String outputTxHash = (String) inputJson.get("txid");
+				int outputVout = ((Long) inputJson.get("vout")).intValue();
+
+				inputs.add(new BitcoinyTransaction.Input(scriptSig, sequence, outputTxHash, outputVout));
+			}
+
+			List<BitcoinyTransaction.Output> outputs = new ArrayList<>();
+			for (Object outputObj : (JSONArray) outputsObj) {
+				JSONObject outputJson = (JSONObject) outputObj;
+
+				String scriptPubKey = (String) ((JSONObject) outputJson.get("scriptPubKey")).get("hex");
+				long value = BigDecimal.valueOf((Double) outputJson.get("value")).setScale(8).unscaledValue().longValue();
+
+				// address too, if present in the "addresses" array
+				List<String> addresses = null;
+				Object addressesObj = ((JSONObject) outputJson.get("scriptPubKey")).get("addresses");
+				if (addressesObj instanceof JSONArray) {
+					addresses = new ArrayList<>();
+					for (Object addressObj : (JSONArray) addressesObj) {
+						addresses.add((String) addressObj);
+					}
+				}
+
+				// some peers return a single "address" string
+				Object addressObj = ((JSONObject) outputJson.get("scriptPubKey")).get("address");
+				if (addressObj instanceof String) {
+					if (addresses == null) {
+						addresses = new ArrayList<>();
+					}
+					addresses.add((String) addressObj);
+				}
+
+				// For the purposes of Qortal we require all outputs to contain addresses
+				// Some servers omit this info, causing problems down the line with balance calculations
+				// Update: it turns out that they were just using a different key - "address" instead of "addresses"
+				// The code below can remain in place, just in case a peer returns a missing address in the future
+				if (addresses == null || addresses.isEmpty()) {
+					if (this.currentServer != null) {
+						this.uselessServers.add(this.currentServer);
+						this.closeServer(this.currentServer);
+					}
+					LOGGER.info("No output addresses returned for transaction {}", txHash);
+					throw new ForeignBlockchainException(String.format("No output addresses returned for transaction %s", txHash));
+				}
+
+				outputs.add(new BitcoinyTransaction.Output(scriptPubKey, value, addresses));
+			}
+
+			transaction = new BitcoinyTransaction(txHash, size, locktime, timestamp, inputs, outputs);
+
+			// Save into cache
+			transactionCache.put(txHash, transaction);
+
+			return transaction;
+		} catch (NullPointerException | ClassCastException e) {
+			// Unexpected / invalid response from ElectrumX server
+		}
+
+		throw new ForeignBlockchainException.NetworkException("Unexpected JSON format from Pirate Chain getTransaction gRPC");
+	}
+
+	/**
+	 * Returns list of transactions, relating to passed payment script.
+	 * <p>
+	 * @return list of related transactions, or empty list if script unknown
+	 * @throws ForeignBlockchainException if error occurs
+	 */
+	@Override
+	public List<TransactionHash> getAddressTransactions(byte[] script, boolean includeUnconfirmed) throws ForeignBlockchainException {
+		// FUTURE: implement this if needed. Probably not very useful for private blockchains.
+		throw new ForeignBlockchainException("getAddressTransactions not yet implemented for Pirate Chain");
+	}
+
+	@Override
+	public List<BitcoinyTransaction> getAddressBitcoinyTransactions(String address, boolean includeUnconfirmed) throws ForeignBlockchainException {
+		try {
+			// Firstly we need to get the latest block
+			int defaultBirthday = Settings.getInstance().getArrrDefaultBirthday();
+			BlockID endBlock = this.getCompactTxStreamerStub().getLatestBlock(null);
+			BlockID startBlock = BlockID.newBuilder().setHeight(defaultBirthday).build();
+			BlockRange blockRange = BlockRange.newBuilder().setStart(startBlock).setEnd(endBlock).build();
+
+			TransparentAddressBlockFilter blockFilter = TransparentAddressBlockFilter.newBuilder()
+					.setAddress(address)
+					.setRange(blockRange)
+					.build();
+			Iterator<Service.RawTransaction> transactionIterator = this.getCompactTxStreamerStub().getTaddressTxids(blockFilter);
+
+			// Map from Iterator to List
+			List<RawTransaction> rawTransactions = new ArrayList<>();
+			transactionIterator.forEachRemaining(rawTransactions::add);
+
+			List<BitcoinyTransaction> transactions = new ArrayList<>();
+
+			for (RawTransaction rawTransaction : rawTransactions) {
+
+				Long height = rawTransaction.getHeight();
+				if (!includeUnconfirmed && (height == null || height == 0))
+					// We only want confirmed transactions
+					continue;
+
+				byte[] transactionData = rawTransaction.getData().toByteArray();
+				String transactionDataHex = HashCode.fromBytes(transactionData).toString();
+				BitcoinyTransaction bitcoinyTransaction = PirateChain.deserializeRawTransaction(transactionDataHex);
+				bitcoinyTransaction.height = height.intValue();
+				transactions.add(bitcoinyTransaction);
+			}
+
+			return transactions;
+		}
+		catch (RuntimeException | TransformationException e) {
+			throw new ForeignBlockchainException(String.format("Unable to get transactions for address %s: %s", address, e.getMessage()));
+		}
+	}
+
+	/**
+	 * Broadcasts raw transaction to network.
+	 * <p>
+	 * @throws ForeignBlockchainException if error occurs
+	 */
+	@Override
+	public void broadcastTransaction(byte[] transactionBytes) throws ForeignBlockchainException {
+		ByteString byteString = ByteString.copyFrom(transactionBytes);
+		RawTransaction rawTransaction = RawTransaction.newBuilder().setData(byteString).build();
+		SendResponse sendResponse = this.getCompactTxStreamerStub().sendTransaction(rawTransaction);
+
+		if (!(sendResponse instanceof SendResponse))
+			throw new ForeignBlockchainException.NetworkException("Unexpected output from Pirate Chain broadcastTransaction gRPC");
+
+		if (sendResponse.getErrorCode() != 0)
+			throw new ForeignBlockchainException.NetworkException(String.format("Unexpected error code from Pirate Chain broadcastTransaction gRPC: %d", sendResponse.getErrorCode()));
+	}
+
+	// Class-private utility methods
+
+
+	/**
+	 * Performs RPC call, with automatic reconnection to different server if needed.
+	 * <p>
+	 * @return "result" object from within JSON output
+	 * @throws ForeignBlockchainException if server returns error or something goes wrong
+	 */
+	private CompactTxStreamerGrpc.CompactTxStreamerBlockingStub getCompactTxStreamerStub() throws ForeignBlockchainException {
+		synchronized (this.serverLock) {
+			if (this.remainingServers.isEmpty())
+				this.remainingServers.addAll(this.servers);
+
+			while (haveConnection()) {
+				// If we have more servers and the last one replied slowly, try another
+				if (!this.remainingServers.isEmpty()) {
+					long averageResponseTime = this.currentServer.averageResponseTime();
+					if (averageResponseTime > MAX_AVG_RESPONSE_TIME) {
+						LOGGER.info("Slow average response time {}ms from {} - trying another server...", averageResponseTime, this.currentServer.hostname);
+						this.closeServer();
+						continue;
+					}
+				}
+
+				return CompactTxStreamerGrpc.newBlockingStub(this.channel);
+
+//				// Didn't work, try another server...
+//				this.closeServer();
+			}
+
+			// Failed to perform RPC - maybe lack of servers?
+			LOGGER.info("Error: No connected Pirate Light servers when trying to make RPC call");
+			throw new ForeignBlockchainException.NetworkException("No connected Pirate Light servers when trying to make RPC call");
+		}
+	}
+
+	/** Returns true if we have, or create, a connection to an ElectrumX server. */
+	private boolean haveConnection() throws ForeignBlockchainException {
+		if (this.currentServer != null && this.channel != null && !this.channel.isShutdown())
+			return true;
+
+		while (!this.remainingServers.isEmpty()) {
+			Server server = this.remainingServers.remove(RANDOM.nextInt(this.remainingServers.size()));
+			LOGGER.trace(() -> String.format("Connecting to %s", server));
+
+			try {
+				this.channel = ManagedChannelBuilder.forAddress(server.hostname, server.port).build();
+
+				CompactTxStreamerGrpc.CompactTxStreamerBlockingStub stub = CompactTxStreamerGrpc.newBlockingStub(this.channel);
+				LightdInfo lightdInfo = stub.getLightdInfo(Empty.newBuilder().build());
+
+				if (lightdInfo == null || lightdInfo.getBlockHeight() <= 0)
+					continue;
+
+				// TODO: find a way to verify that the server is using the expected chain
+
+//				if (featuresJson == null || Double.valueOf((String) featuresJson.get("protocol_min")) < MIN_PROTOCOL_VERSION)
+//					continue;
+
+//				if (this.expectedGenesisHash != null && !((String) featuresJson.get("genesis_hash")).equals(this.expectedGenesisHash))
+//					continue;
+
+				LOGGER.debug(() -> String.format("Connected to %s", server));
+				this.currentServer = server;
+				return true;
+			} catch (Exception e) {
+				// Didn't work, try another server...
+				closeServer();
+			}
+		}
+
+		return false;
+	}
+
+	/**
+	 * Closes connection to <tt>server</tt> if it is currently connected server.
+	 * @param server
+	 */
+	private void closeServer(Server server) {
+		synchronized (this.serverLock) {
+			if (this.currentServer == null || !this.currentServer.equals(server) || this.channel == null) {
+				return;
+			}
+
+			// Close the gRPC managed-channel if not shut down already.
+			if (!this.channel.isShutdown()) {
+				try {
+					this.channel.shutdown();
+					if (!this.channel.awaitTermination(10, TimeUnit.SECONDS)) {
+						LOGGER.warn("Timed out gracefully shutting down connection: {}. ", this.channel);
+					}
+				} catch (Exception e) {
+					LOGGER.error("Unexpected exception while waiting for channel termination", e);
+				}
+			}
+
+			// Forceful shut down if still not terminated.
+			if (!this.channel.isTerminated()) {
+				try {
+					this.channel.shutdownNow();
+					if (!this.channel.awaitTermination(15, TimeUnit.SECONDS)) {
+						LOGGER.warn("Timed out forcefully shutting down connection: {}. ", this.channel);
+					}
+				} catch (Exception e) {
+					LOGGER.error("Unexpected exception while waiting for channel termination", e);
+				}
+			}
+
+			this.channel = null;
+			this.currentServer = null;
+		}
+	}
+
+	/** Closes connection to currently connected server (if any). */
+	private void closeServer() {
+		synchronized (this.serverLock) {
+			this.closeServer(this.currentServer);
+		}
+	}
+
+}

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

@@ -0,0 +1,409 @@
+package org.qortal.crosschain;
+
+import com.rust.litewalletjni.LiteWalletJni;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.bouncycastle.util.encoders.Base64;
+import org.bouncycastle.util.encoders.DecoderException;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+import org.qortal.controller.PirateChainWalletController;
+import org.qortal.crypto.Crypto;
+import org.qortal.settings.Settings;
+import org.qortal.utils.Base58;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.StandardOpenOption;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Objects;
+import java.util.Random;
+
+public class PirateWallet {
+
+    protected static final Logger LOGGER = LogManager.getLogger(PirateWallet.class);
+
+    private byte[] entropyBytes;
+    private final boolean isNullSeedWallet;
+    private String seedPhrase;
+    private boolean ready = false;
+
+    private String params;
+    private String saplingOutput64;
+    private String saplingSpend64;
+
+    private final static String COIN_PARAMS_FILENAME = "coinparams.json";
+    private final static String SAPLING_OUTPUT_FILENAME = "saplingoutput_base64";
+    private final static String SAPLING_SPEND_FILENAME = "saplingspend_base64";
+
+    public PirateWallet(byte[] entropyBytes, boolean isNullSeedWallet) throws IOException {
+        this.entropyBytes = entropyBytes;
+        this.isNullSeedWallet = isNullSeedWallet;
+
+        Path libDirectory = PirateChainWalletController.getRustLibOuterDirectory();
+        if (!Files.exists(Paths.get(libDirectory.toString(), COIN_PARAMS_FILENAME))) {
+            return;
+        }
+
+        this.params = Files.readString(Paths.get(libDirectory.toString(), COIN_PARAMS_FILENAME));
+        this.saplingOutput64 = Files.readString(Paths.get(libDirectory.toString(), SAPLING_OUTPUT_FILENAME));
+        this.saplingSpend64 = Files.readString(Paths.get(libDirectory.toString(), SAPLING_SPEND_FILENAME));
+
+        this.ready = this.initialize();
+    }
+
+    private boolean initialize() {
+        try {
+            LiteWalletJni.initlogging();
+
+            if (this.entropyBytes == null) {
+                return false;
+            }
+
+            // Pick a random server
+            PirateLightClient.Server server = this.getRandomServer();
+            String serverUri = String.format("https://%s:%d/", server.hostname, server.port);
+
+            // Pirate library uses base64 encoding
+            String entropy64 = Base64.toBase64String(this.entropyBytes);
+
+            // Derive seed phrase from entropy bytes
+            String inputSeedResponse = LiteWalletJni.getseedphrasefromentropyb64(entropy64);
+            JSONObject inputSeedJson =  new JSONObject(inputSeedResponse);
+            String inputSeedPhrase = null;
+            if (inputSeedJson.has("seedPhrase")) {
+                inputSeedPhrase = inputSeedJson.getString("seedPhrase");
+            }
+
+            String wallet = this.load();
+            if (wallet == null) {
+                // Wallet doesn't exist, so create a new one
+
+                int birthday = Settings.getInstance().getArrrDefaultBirthday();
+                if (this.isNullSeedWallet) {
+                    try {
+                        // Attempt to set birthday to the current block for null seed wallets
+                        birthday = PirateChain.getInstance().blockchainProvider.getCurrentHeight();
+                    }
+                    catch (ForeignBlockchainException e) {
+                        // Use the default height
+                    }
+                }
+
+                // Initialize new wallet
+                String birthdayString = String.format("%d", birthday);
+                String outputSeedResponse = LiteWalletJni.initfromseed(serverUri, this.params, inputSeedPhrase, birthdayString, this.saplingOutput64, this.saplingSpend64); // Thread-safe.
+                JSONObject outputSeedJson =  new JSONObject(outputSeedResponse);
+                String outputSeedPhrase = null;
+                if (outputSeedJson.has("seed")) {
+                    outputSeedPhrase = outputSeedJson.getString("seed");
+                }
+
+                // Ensure seed phrase in response matches supplied seed phrase
+                if (inputSeedPhrase == null || !Objects.equals(inputSeedPhrase, outputSeedPhrase)) {
+                    LOGGER.info("Unable to initialize Pirate Chain wallet: seed phrases do not match, or are null");
+                    return false;
+                }
+
+                this.seedPhrase = outputSeedPhrase;
+
+            } else {
+                // Restore existing wallet
+                String response = LiteWalletJni.initfromb64(serverUri, params, wallet, saplingOutput64, saplingSpend64);
+                if (response != null && !response.contains("\"initalized\":true")) {
+                    LOGGER.info("Unable to initialize Pirate Chain wallet: {}", response);
+                    return false;
+                }
+                this.seedPhrase = inputSeedPhrase;
+            }
+
+            // Check that we're able to communicate with the library
+            Integer ourHeight = this.getHeight();
+            return (ourHeight != null && ourHeight > 0);
+
+        } catch (IOException | JSONException | UnsatisfiedLinkError e) {
+            LOGGER.info("Unable to initialize Pirate Chain wallet: {}", e.getMessage());
+        }
+
+        return false;
+    }
+
+    public boolean isReady() {
+        return this.ready;
+    }
+
+    public void setReady(boolean ready) {
+        this.ready = ready;
+    }
+
+    public boolean entropyBytesEqual(byte[] testEntropyBytes) {
+        return Arrays.equals(testEntropyBytes, this.entropyBytes);
+    }
+
+    private void encrypt() {
+        if (this.isEncrypted()) {
+            // Nothing to do
+            return;
+        }
+
+        String encryptionKey = this.getEncryptionKey();
+        if (encryptionKey == null) {
+            // Can't encrypt without a key
+            return;
+        }
+
+        this.doEncrypt(encryptionKey);
+    }
+
+    private void decrypt() {
+        if (!this.isEncrypted()) {
+            // Nothing to do
+            return;
+        }
+
+        String encryptionKey = this.getEncryptionKey();
+        if (encryptionKey == null) {
+            // Can't encrypt without a key
+            return;
+        }
+
+        this.doDecrypt(encryptionKey);
+    }
+
+    public void unlock() {
+        if (!this.isEncrypted()) {
+            // Nothing to do
+            return;
+        }
+
+        String encryptionKey = this.getEncryptionKey();
+        if (encryptionKey == null) {
+            // Can't encrypt without a key
+            return;
+        }
+
+        this.doUnlock(encryptionKey);
+    }
+
+    public boolean save() throws IOException {
+        if (!isInitialized()) {
+            LOGGER.info("Error: can't save wallet, because no wallet it initialized");
+            return false;
+        }
+        if (this.isNullSeedWallet()) {
+            // Don't save wallets that have a null seed
+            return false;
+        }
+
+        // Encrypt first (will do nothing if already encrypted)
+        this.encrypt();
+
+        String wallet64 = LiteWalletJni.save();
+        byte[] wallet;
+        try {
+            wallet = Base64.decode(wallet64);
+        }
+        catch (DecoderException e) {
+            LOGGER.info("Unable to decode wallet");
+            return false;
+        }
+        if (wallet == null) {
+            LOGGER.info("Unable to save wallet");
+            return false;
+        }
+
+        Path walletPath = this.getCurrentWalletPath();
+        Files.createDirectories(walletPath.getParent());
+        Files.write(walletPath, wallet, StandardOpenOption.CREATE);
+
+        LOGGER.debug("Saved Pirate Chain wallet");
+
+        return true;
+    }
+
+    public String load() throws IOException {
+        if (this.isNullSeedWallet()) {
+            // Don't load wallets that have a null seed
+            return null;
+        }
+        Path walletPath = this.getCurrentWalletPath();
+        if (!Files.exists(walletPath)) {
+            return null;
+        }
+        byte[] wallet = Files.readAllBytes(walletPath);
+        if (wallet == null) {
+            return null;
+        }
+        String wallet64 = Base64.toBase64String(wallet);
+        return wallet64;
+    }
+
+    private String getEntropyHash58() {
+        if (this.entropyBytes == null) {
+            return null;
+        }
+        byte[] entropyHash = Crypto.digest(this.entropyBytes);
+        return Base58.encode(entropyHash);
+    }
+
+    public String getSeedPhrase() {
+        return this.seedPhrase;
+    }
+
+    private String getEncryptionKey() {
+        if (this.entropyBytes == null) {
+            return null;
+        }
+
+        // Prefix the bytes with a (deterministic) string, to ensure that the resulting hash is different
+        String prefix = "ARRRWalletEncryption";
+
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        try {
+            outputStream.write(prefix.getBytes(StandardCharsets.UTF_8));
+            outputStream.write(this.entropyBytes);
+
+        } catch (IOException e) {
+            return null;
+        }
+
+        byte[] encryptionKeyHash = Crypto.digest(outputStream.toByteArray());
+        return Base58.encode(encryptionKeyHash);
+    }
+
+    private Path getCurrentWalletPath() {
+        String entropyHash58 = this.getEntropyHash58();
+        String filename = String.format("wallet-%s.dat", entropyHash58);
+        return Paths.get(Settings.getInstance().getWalletsPath(), "PirateChain", filename);
+    }
+
+    public boolean isInitialized() {
+        return this.entropyBytes != null && this.ready;
+    }
+
+    public boolean isSynchronized() {
+        Integer height = this.getHeight();
+        Integer chainTip = this.getChainTip();
+
+        if (height == null || chainTip == null) {
+            return false;
+        }
+
+        // Assume synchronized if within 2 blocks of the chain tip
+        return height >= (chainTip - 2);
+    }
+
+
+    // APIs
+
+    public Integer getHeight() {
+        String response = LiteWalletJni.execute("height", "");
+        JSONObject json = new JSONObject(response);
+        if (json.has("height")) {
+            return json.getInt("height");
+        }
+        return null;
+    }
+
+    public Integer getChainTip() {
+        String response = LiteWalletJni.execute("info", "");
+        JSONObject json = new JSONObject(response);
+        if (json.has("latest_block_height")) {
+            return json.getInt("latest_block_height");
+        }
+        return null;
+    }
+
+    public boolean isNullSeedWallet() {
+        return this.isNullSeedWallet;
+    }
+
+    public Boolean isEncrypted() {
+        String response = LiteWalletJni.execute("encryptionstatus", "");
+        JSONObject json = new JSONObject(response);
+        if (json.has("encrypted")) {
+            return json.getBoolean("encrypted");
+        }
+        return null;
+    }
+
+    public boolean doEncrypt(String key) {
+        String response = LiteWalletJni.execute("encrypt", key);
+        JSONObject json = new JSONObject(response);
+        String result = json.getString("result");
+        if (json.has("result")) {
+            return (Objects.equals(result, "success"));
+        }
+        return false;
+    }
+
+    public boolean doDecrypt(String key) {
+        String response = LiteWalletJni.execute("decrypt", key);
+        JSONObject json = new JSONObject(response);
+        String result = json.getString("result");
+        if (json.has("result")) {
+            return (Objects.equals(result, "success"));
+        }
+        return false;
+    }
+
+    public boolean doUnlock(String key) {
+        String response = LiteWalletJni.execute("unlock", key);
+        JSONObject json = new JSONObject(response);
+        String result = json.getString("result");
+        if (json.has("result")) {
+            return (Objects.equals(result, "success"));
+        }
+        return false;
+    }
+
+    public String getWalletAddress() {
+        // Get balance, which also contains wallet addresses
+        String response = LiteWalletJni.execute("balance", "");
+        JSONObject json = new JSONObject(response);
+        String address = null;
+
+        if (json.has("z_addresses")) {
+            JSONArray z_addresses = json.getJSONArray("z_addresses");
+
+            if (z_addresses != null && !z_addresses.isEmpty()) {
+                JSONObject firstAddress = z_addresses.getJSONObject(0);
+                if (firstAddress.has("address")) {
+                    address = firstAddress.getString("address");
+                }
+            }
+        }
+        return address;
+    }
+
+    public String getPrivateKey() {
+        String response = LiteWalletJni.execute("export", "");
+        JSONArray addressesJson = new JSONArray(response);
+        if (!addressesJson.isEmpty()) {
+            JSONObject addressJson = addressesJson.getJSONObject(0);
+            if (addressJson.has("private_key")) {
+                //String address = addressJson.getString("address");
+                String privateKey = addressJson.getString("private_key");
+                //String viewingKey = addressJson.getString("viewing_key");
+
+                return privateKey;
+            }
+        }
+        return null;
+    }
+
+    public PirateLightClient.Server getRandomServer() {
+        PirateChain.PirateChainNet pirateChainNet = Settings.getInstance().getPirateChainNet();
+        Collection<PirateLightClient.Server> servers = pirateChainNet.getServers();
+        Random random = new Random();
+        int index = random.nextInt(servers.size());
+        return (PirateLightClient.Server) servers.toArray()[index];
+    }
+
+}

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

@@ -0,0 +1,175 @@
+package org.qortal.crosschain;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.EnumMap;
+import java.util.Map;
+
+import org.bitcoinj.core.Coin;
+import org.bitcoinj.core.Context;
+import org.bitcoinj.core.NetworkParameters;
+import org.bitcoinj.params.RegTestParams;
+import org.bitcoinj.params.TestNet3Params;
+import org.libdohj.params.RavencoinMainNetParams;
+import org.qortal.crosschain.ElectrumX.Server;
+import org.qortal.crosschain.ElectrumX.Server.ConnectionType;
+import org.qortal.settings.Settings;
+
+public class Ravencoin extends Bitcoiny {
+
+	public static final String CURRENCY_CODE = "RVN";
+
+	private static final Coin DEFAULT_FEE_PER_KB = Coin.valueOf(1125000); // 0.01125 RVN per 1000 bytes
+
+	private static final long MINIMUM_ORDER_AMOUNT = 1000000; // 0.01 RVN minimum order, to avoid dust errors
+
+	// Temporary values until a dynamic fee system is written.
+	private static final long MAINNET_FEE = 1000000L;
+	private static final long NON_MAINNET_FEE = 1000000L; // enough for TESTNET3 and should be OK for REGTEST
+
+	private static final Map<ConnectionType, Integer> DEFAULT_ELECTRUMX_PORTS = new EnumMap<>(ConnectionType.class);
+	static {
+		DEFAULT_ELECTRUMX_PORTS.put(ConnectionType.TCP, 50001);
+		DEFAULT_ELECTRUMX_PORTS.put(ConnectionType.SSL, 50002);
+	}
+
+	public enum RavencoinNet {
+		MAIN {
+			@Override
+			public NetworkParameters getParams() {
+				return RavencoinMainNetParams.get();
+			}
+
+			@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
+						new Server("aethyn.com", ConnectionType.SSL, 50002),
+						new Server("electrum2.rvn.rocks", ConnectionType.SSL, 50002),
+						new Server("rvn-dashboard.com", ConnectionType.SSL, 50002),
+						new Server("rvn4lyfe.com", 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));
+			}
+
+			@Override
+			public String getGenesisHash() {
+				return "0000006b444bc2f2ffe627be9d9e7e7a0730000870ef6eb6da46c8eae389df90";
+			}
+
+			@Override
+			public long getP2shFee(Long timestamp) {
+				// TODO: This will need to be replaced with something better in the near future!
+				return MAINNET_FEE;
+			}
+		},
+		TEST3 {
+			@Override
+			public NetworkParameters getParams() {
+				return TestNet3Params.get();
+			}
+
+			@Override
+			public Collection<Server> getServers() {
+				return Arrays.asList(); // TODO: find testnet servers
+			}
+
+			@Override
+			public String getGenesisHash() {
+				return "000000ecfc5e6324a079542221d00e10362bdc894d56500c414060eea8a3ad5a";
+			}
+
+			@Override
+			public long getP2shFee(Long timestamp) {
+				return NON_MAINNET_FEE;
+			}
+		},
+		REGTEST {
+			@Override
+			public NetworkParameters getParams() {
+				return RegTestParams.get();
+			}
+
+			@Override
+			public Collection<Server> getServers() {
+				return Arrays.asList(
+						new Server("localhost", ConnectionType.TCP, 50001),
+						new Server("localhost", ConnectionType.SSL, 50002));
+			}
+
+			@Override
+			public String getGenesisHash() {
+				// This is unique to each regtest instance
+				return null;
+			}
+
+			@Override
+			public long getP2shFee(Long timestamp) {
+				return NON_MAINNET_FEE;
+			}
+		};
+
+		public abstract NetworkParameters getParams();
+		public abstract Collection<Server> getServers();
+		public abstract String getGenesisHash();
+		public abstract long getP2shFee(Long timestamp) throws ForeignBlockchainException;
+	}
+
+	private static Ravencoin instance;
+
+	private final RavencoinNet ravencoinNet;
+
+	// Constructors and instance
+
+	private Ravencoin(RavencoinNet ravencoinNet, BitcoinyBlockchainProvider blockchain, Context bitcoinjContext, String currencyCode) {
+		super(blockchain, bitcoinjContext, currencyCode);
+		this.ravencoinNet = ravencoinNet;
+
+		LOGGER.info(() -> String.format("Starting Ravencoin support using %s", this.ravencoinNet.name()));
+	}
+
+	public static synchronized Ravencoin getInstance() {
+		if (instance == null) {
+			RavencoinNet ravencoinNet = Settings.getInstance().getRavencoinNet();
+
+			BitcoinyBlockchainProvider electrumX = new ElectrumX("Ravencoin-" + ravencoinNet.name(), ravencoinNet.getGenesisHash(), ravencoinNet.getServers(), DEFAULT_ELECTRUMX_PORTS);
+			Context bitcoinjContext = new Context(ravencoinNet.getParams());
+
+			instance = new Ravencoin(ravencoinNet, electrumX, bitcoinjContext, CURRENCY_CODE);
+		}
+
+		return instance;
+	}
+
+	// Getters & setters
+
+	public static synchronized void resetForTesting() {
+		instance = null;
+	}
+
+	// Actual useful methods for use by other classes
+
+	@Override
+	public Coin getFeePerKb() {
+		return DEFAULT_FEE_PER_KB;
+	}
+
+	@Override
+	public long getMinimumOrderAmount() {
+		return MINIMUM_ORDER_AMOUNT;
+	}
+
+	/**
+	 * Returns estimated RVN fee, in sats per 1000bytes, optionally for historic timestamp.
+	 * 
+	 * @param timestamp optional milliseconds since epoch, or null for 'now'
+	 * @return sats per 1000bytes, or throws ForeignBlockchainException if something went wrong
+	 */
+	@Override
+	public long getP2shFee(Long timestamp) throws ForeignBlockchainException {
+		return this.ravencoinNet.getP2shFee(timestamp);
+	}
+
+}

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

@@ -0,0 +1,858 @@
+package org.qortal.crosschain;
+
+import com.google.common.hash.HashCode;
+import com.google.common.primitives.Bytes;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.ciyam.at.*;
+import org.qortal.account.Account;
+import org.qortal.asset.Asset;
+import org.qortal.at.QortalFunctionCode;
+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.MessageTransactionData;
+import org.qortal.repository.DataException;
+import org.qortal.repository.Repository;
+import org.qortal.utils.Base58;
+import org.qortal.utils.BitTwiddling;
+
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.ciyam.at.OpCode.calcOffset;
+
+/**
+ * Cross-chain trade AT
+ * 
+ * <p>
+ * <ul>
+ * <li>Bob generates Ravencoin & Qortal 'trade' keys
+ * 		<ul>
+ * 			<li>private key required to sign P2SH redeem tx</li>
+ * 			<li>private key could be used to create 'secret' (e.g. double-SHA256)</li>
+ * 			<li>encrypted private key could be stored in Qortal AT for access by Bob from any node</li>
+ * 		</ul>
+ * </li>
+ * <li>Bob deploys Qortal AT
+ * 		<ul>
+ * 		</ul>
+ * </li>
+ * <li>Alice finds Qortal AT and wants to trade
+ * 		<ul>
+ * 			<li>Alice generates Ravencoin & Qortal 'trade' keys</li>
+ * 			<li>Alice funds Ravencoin P2SH-A</li>
+ * 			<li>Alice sends 'offer' MESSAGE to Bob from her Qortal trade address, containing:
+ * 				<ul>
+ * 					<li>hash-of-secret-A</li>
+ * 					<li>her 'trade' Ravencoin PKH</li>
+ * 				</ul>
+ * 			</li>
+ * 		</ul>
+ * </li>
+ * <li>Bob receives "offer" MESSAGE
+ * 		<ul>
+ * 			<li>Checks Alice's P2SH-A</li>
+ * 			<li>Sends 'trade' MESSAGE to Qortal AT from his trade address, containing:
+ * 				<ul>
+ * 					<li>Alice's trade Qortal address</li>
+ * 					<li>Alice's trade Ravencoin PKH</li>
+ * 					<li>hash-of-secret-A</li>
+ * 				</ul>
+ * 			</li>
+ * 		</ul>
+ * </li>
+ * <li>Alice checks Qortal AT to confirm it's locked to her
+ * 		<ul>
+ * 			<li>Alice sends 'redeem' MESSAGE to Qortal AT from her trade address, containing:
+ * 				<ul>
+ * 					<li>secret-A</li>
+ * 					<li>Qortal receiving address of her chosing</li>
+ * 				</ul>
+ * 			</li>
+ * 			<li>AT's QORT funds are sent to Qortal receiving address</li>
+ * 		</ul>
+ * </li>
+ * <li>Bob checks AT, extracts secret-A
+ * 		<ul>
+ * 			<li>Bob redeems P2SH-A using his Ravencoin trade key and secret-A</li>
+ * 			<li>P2SH-A RVN funds end up at Ravencoin address determined by redeem transaction output(s)</li>
+ * 		</ul>
+ * </li>
+ * </ul>
+ */
+public class RavencoinACCTv3 implements ACCT {
+
+	private static final Logger LOGGER = LogManager.getLogger(RavencoinACCTv3.class);
+
+	public static final String NAME = RavencoinACCTv3.class.getSimpleName();
+	public static final byte[] CODE_BYTES_HASH = HashCode.fromString("91395fa1ec0dfa35beddb0a7f4cc0a1bede157c38787ddb0af0cf03dfdc10f77").asBytes(); // SHA256 of AT code bytes
+
+	public static final int SECRET_LENGTH = 32;
+
+	/** <b>Value</b> offset into AT segment where 'mode' variable (long) is stored. (Multiply by MachineState.VALUE_SIZE for byte offset). */
+	private static final int MODE_VALUE_OFFSET = 61;
+	/** <b>Byte</b> offset into AT state data where 'mode' variable (long) is stored. */
+	public static final int MODE_BYTE_OFFSET = MachineState.HEADER_LENGTH + (MODE_VALUE_OFFSET * MachineState.VALUE_SIZE);
+
+	public static class OfferMessageData {
+		public byte[] partnerRavencoinPKH;
+		public byte[] hashOfSecretA;
+		public long lockTimeA;
+	}
+	public static final int OFFER_MESSAGE_LENGTH = 20 /*partnerRavencoinPKH*/ + 20 /*hashOfSecretA*/ + 8 /*lockTimeA*/;
+	public static final int TRADE_MESSAGE_LENGTH = 32 /*partner's Qortal trade address (padded from 25 to 32)*/
+			+ 24 /*partner's Ravencoin PKH (padded from 20 to 24)*/
+			+ 8 /*AT trade timeout (minutes)*/
+			+ 24 /*hash of secret-A (padded from 20 to 24)*/
+			+ 8 /*lockTimeA*/;
+	public static final int REDEEM_MESSAGE_LENGTH = 32 /*secret-A*/ + 32 /*partner's Qortal receiving address padded from 25 to 32*/;
+	public static final int CANCEL_MESSAGE_LENGTH = 32 /*AT creator's Qortal address*/;
+
+	private static RavencoinACCTv3 instance;
+
+	private RavencoinACCTv3() {
+	}
+
+	public static synchronized RavencoinACCTv3 getInstance() {
+		if (instance == null)
+			instance = new RavencoinACCTv3();
+
+		return instance;
+	}
+
+	@Override
+	public byte[] getCodeBytesHash() {
+		return CODE_BYTES_HASH;
+	}
+
+	@Override
+	public int getModeByteOffset() {
+		return MODE_BYTE_OFFSET;
+	}
+
+	@Override
+	public ForeignBlockchain getBlockchain() {
+		return Ravencoin.getInstance();
+	}
+
+	/**
+	 * Returns Qortal AT creation bytes for cross-chain trading AT.
+	 * <p>
+	 * <tt>tradeTimeout</tt> (minutes) is the time window for the trade partner to send the
+	 * 32-byte secret to the AT, before the AT automatically refunds the AT's creator.
+	 * 
+	 * @param creatorTradeAddress AT creator's trade Qortal address
+	 * @param ravencoinPublicKeyHash 20-byte HASH160 of creator's trade Ravencoin public key
+	 * @param qortAmount how much QORT to pay trade partner if they send correct 32-byte secrets to AT
+	 * @param ravencoinAmount how much RVN the AT creator is expecting to trade
+	 * @param tradeTimeout suggested timeout for entire trade
+	 */
+	public static byte[] buildQortalAT(String creatorTradeAddress, byte[] ravencoinPublicKeyHash, long qortAmount, long ravencoinAmount, int tradeTimeout) {
+		if (ravencoinPublicKeyHash.length != 20)
+			throw new IllegalArgumentException("Ravencoin public key hash should be 20 bytes");
+
+		// Labels for data segment addresses
+		int addrCounter = 0;
+
+		// Constants (with corresponding dataByteBuffer.put*() calls below)
+
+		final int addrCreatorTradeAddress1 = addrCounter++;
+		final int addrCreatorTradeAddress2 = addrCounter++;
+		final int addrCreatorTradeAddress3 = addrCounter++;
+		final int addrCreatorTradeAddress4 = addrCounter++;
+
+		final int addrRavencoinPublicKeyHash = addrCounter;
+		addrCounter += 4;
+
+		final int addrQortAmount = addrCounter++;
+		final int addrRavencoinAmount = addrCounter++;
+		final int addrTradeTimeout = addrCounter++;
+
+		final int addrMessageTxnType = addrCounter++;
+		final int addrExpectedTradeMessageLength = addrCounter++;
+		final int addrExpectedRedeemMessageLength = addrCounter++;
+
+		final int addrCreatorAddressPointer = addrCounter++;
+		final int addrQortalPartnerAddressPointer = addrCounter++;
+		final int addrMessageSenderPointer = addrCounter++;
+
+		final int addrTradeMessagePartnerRavencoinPKHOffset = addrCounter++;
+		final int addrPartnerRavencoinPKHPointer = addrCounter++;
+		final int addrTradeMessageHashOfSecretAOffset = addrCounter++;
+		final int addrHashOfSecretAPointer = addrCounter++;
+
+		final int addrRedeemMessageReceivingAddressOffset = addrCounter++;
+
+		final int addrMessageDataPointer = addrCounter++;
+		final int addrMessageDataLength = addrCounter++;
+
+		final int addrPartnerReceivingAddressPointer = addrCounter++;
+
+		final int addrEndOfConstants = addrCounter;
+
+		// Variables
+
+		final int addrCreatorAddress1 = addrCounter++;
+		final int addrCreatorAddress2 = addrCounter++;
+		final int addrCreatorAddress3 = addrCounter++;
+		final int addrCreatorAddress4 = addrCounter++;
+
+		final int addrQortalPartnerAddress1 = addrCounter++;
+		final int addrQortalPartnerAddress2 = addrCounter++;
+		final int addrQortalPartnerAddress3 = addrCounter++;
+		final int addrQortalPartnerAddress4 = addrCounter++;
+
+		final int addrLockTimeA = addrCounter++;
+		final int addrRefundTimeout = addrCounter++;
+		final int addrRefundTimestamp = addrCounter++;
+		final int addrLastTxnTimestamp = addrCounter++;
+		final int addrBlockTimestamp = addrCounter++;
+		final int addrTxnType = addrCounter++;
+		final int addrResult = addrCounter++;
+
+		final int addrMessageSender1 = addrCounter++;
+		final int addrMessageSender2 = addrCounter++;
+		final int addrMessageSender3 = addrCounter++;
+		final int addrMessageSender4 = addrCounter++;
+
+		final int addrMessageLength = addrCounter++;
+
+		final int addrMessageData = addrCounter;
+		addrCounter += 4;
+
+		final int addrHashOfSecretA = addrCounter;
+		addrCounter += 4;
+
+		final int addrPartnerRavencoinPKH = addrCounter;
+		addrCounter += 4;
+
+		final int addrPartnerReceivingAddress = addrCounter;
+		addrCounter += 4;
+
+		final int addrMode = addrCounter++;
+		assert addrMode == MODE_VALUE_OFFSET : String.format("addrMode %d does not match MODE_VALUE_OFFSET %d", addrMode, MODE_VALUE_OFFSET);
+
+		// Data segment
+		ByteBuffer dataByteBuffer = ByteBuffer.allocate(addrCounter * MachineState.VALUE_SIZE);
+
+		// AT creator's trade Qortal address, decoded from Base58
+		assert dataByteBuffer.position() == addrCreatorTradeAddress1 * MachineState.VALUE_SIZE : "addrCreatorTradeAddress1 incorrect";
+		byte[] creatorTradeAddressBytes = Base58.decode(creatorTradeAddress);
+		dataByteBuffer.put(Bytes.ensureCapacity(creatorTradeAddressBytes, 32, 0));
+
+		// Ravencoin public key hash
+		assert dataByteBuffer.position() == addrRavencoinPublicKeyHash * MachineState.VALUE_SIZE : "addrRavencoinPublicKeyHash incorrect";
+		dataByteBuffer.put(Bytes.ensureCapacity(ravencoinPublicKeyHash, 32, 0));
+
+		// Redeem Qort amount
+		assert dataByteBuffer.position() == addrQortAmount * MachineState.VALUE_SIZE : "addrQortAmount incorrect";
+		dataByteBuffer.putLong(qortAmount);
+
+		// Expected Ravencoin amount
+		assert dataByteBuffer.position() == addrRavencoinAmount * MachineState.VALUE_SIZE : "addrRavencoinAmount incorrect";
+		dataByteBuffer.putLong(ravencoinAmount);
+
+		// Suggested trade timeout (minutes)
+		assert dataByteBuffer.position() == addrTradeTimeout * MachineState.VALUE_SIZE : "addrTradeTimeout incorrect";
+		dataByteBuffer.putLong(tradeTimeout);
+
+		// We're only interested in MESSAGE transactions
+		assert dataByteBuffer.position() == addrMessageTxnType * MachineState.VALUE_SIZE : "addrMessageTxnType incorrect";
+		dataByteBuffer.putLong(API.ATTransactionType.MESSAGE.value);
+
+		// Expected length of 'trade' MESSAGE data from AT creator
+		assert dataByteBuffer.position() == addrExpectedTradeMessageLength * MachineState.VALUE_SIZE : "addrExpectedTradeMessageLength incorrect";
+		dataByteBuffer.putLong(TRADE_MESSAGE_LENGTH);
+
+		// Expected length of 'redeem' MESSAGE data from trade partner
+		assert dataByteBuffer.position() == addrExpectedRedeemMessageLength * MachineState.VALUE_SIZE : "addrExpectedRedeemMessageLength incorrect";
+		dataByteBuffer.putLong(REDEEM_MESSAGE_LENGTH);
+
+		// Index into data segment of AT creator's address, used by GET_B_IND
+		assert dataByteBuffer.position() == addrCreatorAddressPointer * MachineState.VALUE_SIZE : "addrCreatorAddressPointer incorrect";
+		dataByteBuffer.putLong(addrCreatorAddress1);
+
+		// Index into data segment of partner's Qortal address, used by SET_B_IND
+		assert dataByteBuffer.position() == addrQortalPartnerAddressPointer * MachineState.VALUE_SIZE : "addrQortalPartnerAddressPointer incorrect";
+		dataByteBuffer.putLong(addrQortalPartnerAddress1);
+
+		// Index into data segment of (temporary) transaction's sender's address, used by GET_B_IND
+		assert dataByteBuffer.position() == addrMessageSenderPointer * MachineState.VALUE_SIZE : "addrMessageSenderPointer incorrect";
+		dataByteBuffer.putLong(addrMessageSender1);
+
+		// Offset into 'trade' MESSAGE data payload for extracting partner's Ravencoin PKH
+		assert dataByteBuffer.position() == addrTradeMessagePartnerRavencoinPKHOffset * MachineState.VALUE_SIZE : "addrTradeMessagePartnerRavencoinPKHOffset incorrect";
+		dataByteBuffer.putLong(32L);
+
+		// Index into data segment of partner's Ravencoin PKH, used by GET_B_IND
+		assert dataByteBuffer.position() == addrPartnerRavencoinPKHPointer * MachineState.VALUE_SIZE : "addrPartnerRavencoinPKHPointer incorrect";
+		dataByteBuffer.putLong(addrPartnerRavencoinPKH);
+
+		// Offset into 'trade' MESSAGE data payload for extracting hash-of-secret-A
+		assert dataByteBuffer.position() == addrTradeMessageHashOfSecretAOffset * MachineState.VALUE_SIZE : "addrTradeMessageHashOfSecretAOffset incorrect";
+		dataByteBuffer.putLong(64L);
+
+		// Index into data segment to hash of secret A, used by GET_B_IND
+		assert dataByteBuffer.position() == addrHashOfSecretAPointer * MachineState.VALUE_SIZE : "addrHashOfSecretAPointer incorrect";
+		dataByteBuffer.putLong(addrHashOfSecretA);
+
+		// Offset into 'redeem' MESSAGE data payload for extracting Qortal receiving address
+		assert dataByteBuffer.position() == addrRedeemMessageReceivingAddressOffset * MachineState.VALUE_SIZE : "addrRedeemMessageReceivingAddressOffset incorrect";
+		dataByteBuffer.putLong(32L);
+
+		// Source location and length for hashing any passed secret
+		assert dataByteBuffer.position() == addrMessageDataPointer * MachineState.VALUE_SIZE : "addrMessageDataPointer incorrect";
+		dataByteBuffer.putLong(addrMessageData);
+		assert dataByteBuffer.position() == addrMessageDataLength * MachineState.VALUE_SIZE : "addrMessageDataLength incorrect";
+		dataByteBuffer.putLong(32L);
+
+		// Pointer into data segment of where to save partner's receiving Qortal address, used by GET_B_IND
+		assert dataByteBuffer.position() == addrPartnerReceivingAddressPointer * MachineState.VALUE_SIZE : "addrPartnerReceivingAddressPointer incorrect";
+		dataByteBuffer.putLong(addrPartnerReceivingAddress);
+
+		assert dataByteBuffer.position() == addrEndOfConstants * MachineState.VALUE_SIZE : "dataByteBuffer position not at end of constants";
+
+		// Code labels
+		Integer labelRefund = null;
+
+		Integer labelTradeTxnLoop = null;
+		Integer labelCheckTradeTxn = null;
+		Integer labelCheckCancelTxn = null;
+		Integer labelNotTradeNorCancelTxn = null;
+		Integer labelCheckNonRefundTradeTxn = null;
+		Integer labelTradeTxnExtract = null;
+		Integer labelRedeemTxnLoop = null;
+		Integer labelCheckRedeemTxn = null;
+		Integer labelCheckRedeemTxnSender = null;
+		Integer labelPayout = null;
+
+		ByteBuffer codeByteBuffer = ByteBuffer.allocate(768);
+
+		// Two-pass version
+		for (int pass = 0; pass < 2; ++pass) {
+			codeByteBuffer.clear();
+
+			try {
+				/* Initialization */
+
+				// Use AT creation 'timestamp' as starting point for finding transactions sent to AT
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(FunctionCode.GET_CREATION_TIMESTAMP, addrLastTxnTimestamp));
+
+				// Load B register with AT creator's address so we can save it into addrCreatorAddress1-4
+				codeByteBuffer.put(OpCode.EXT_FUN.compile(FunctionCode.PUT_CREATOR_INTO_B));
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.GET_B_IND, addrCreatorAddressPointer));
+
+				/* NOP - to ensure RAVENCOIN ACCT is unique */
+				codeByteBuffer.put(OpCode.NOP.compile());
+
+				// Set restart position to after this opcode
+				codeByteBuffer.put(OpCode.SET_PCS.compile());
+
+				/* Loop, waiting for message from AT creator's trade address containing trade partner details, or AT owner's address to cancel offer */
+
+				/* Transaction processing loop */
+				labelTradeTxnLoop = codeByteBuffer.position();
+
+				/* Sleep until message arrives */
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(QortalFunctionCode.SLEEP_UNTIL_MESSAGE.value, addrLastTxnTimestamp));
+
+				// Find next transaction (if any) to this AT since the last one (referenced by addrLastTxnTimestamp)
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.PUT_TX_AFTER_TIMESTAMP_INTO_A, addrLastTxnTimestamp));
+				// If no transaction found, A will be zero. If A is zero, set addrResult to 1, otherwise 0.
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(FunctionCode.CHECK_A_IS_ZERO, addrResult));
+				// If addrResult is zero (i.e. A is non-zero, transaction was found) then go check transaction
+				codeByteBuffer.put(OpCode.BZR_DAT.compile(addrResult, calcOffset(codeByteBuffer, labelCheckTradeTxn)));
+				// Stop and wait for next block
+				codeByteBuffer.put(OpCode.STP_IMD.compile());
+
+				/* Check transaction */
+				labelCheckTradeTxn = codeByteBuffer.position();
+
+				// Update our 'last found transaction's timestamp' using 'timestamp' from transaction
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(FunctionCode.GET_TIMESTAMP_FROM_TX_IN_A, addrLastTxnTimestamp));
+				// Extract transaction type (message/payment) from transaction and save type in addrTxnType
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(FunctionCode.GET_TYPE_FROM_TX_IN_A, addrTxnType));
+				// If transaction type is not MESSAGE type then go look for another transaction
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrTxnType, addrMessageTxnType, calcOffset(codeByteBuffer, labelTradeTxnLoop)));
+
+				/* Check transaction's sender. We're expecting AT creator's trade address for 'trade' message, or AT creator's own address for 'cancel' message. */
+
+				// Extract sender address from transaction into B register
+				codeByteBuffer.put(OpCode.EXT_FUN.compile(FunctionCode.PUT_ADDRESS_FROM_TX_IN_A_INTO_B));
+				// Save B register into data segment starting at addrMessageSender1 (as pointed to by addrMessageSenderPointer)
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.GET_B_IND, addrMessageSenderPointer));
+				// Compare each part of message sender's address with AT creator's trade address. If they don't match, check for cancel situation.
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender1, addrCreatorTradeAddress1, calcOffset(codeByteBuffer, labelCheckCancelTxn)));
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender2, addrCreatorTradeAddress2, calcOffset(codeByteBuffer, labelCheckCancelTxn)));
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender3, addrCreatorTradeAddress3, calcOffset(codeByteBuffer, labelCheckCancelTxn)));
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender4, addrCreatorTradeAddress4, calcOffset(codeByteBuffer, labelCheckCancelTxn)));
+				// Message sender's address matches AT creator's trade address so go process 'trade' message
+				codeByteBuffer.put(OpCode.JMP_ADR.compile(labelCheckNonRefundTradeTxn == null ? 0 : labelCheckNonRefundTradeTxn));
+
+				/* Checking message sender for possible cancel message */
+				labelCheckCancelTxn = codeByteBuffer.position();
+
+				// Compare each part of message sender's address with AT creator's address. If they don't match, look for another transaction.
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender1, addrCreatorAddress1, calcOffset(codeByteBuffer, labelNotTradeNorCancelTxn)));
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender2, addrCreatorAddress2, calcOffset(codeByteBuffer, labelNotTradeNorCancelTxn)));
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender3, addrCreatorAddress3, calcOffset(codeByteBuffer, labelNotTradeNorCancelTxn)));
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender4, addrCreatorAddress4, calcOffset(codeByteBuffer, labelNotTradeNorCancelTxn)));
+				// Partner address is AT creator's address, so cancel offer and finish.
+				codeByteBuffer.put(OpCode.SET_VAL.compile(addrMode, AcctMode.CANCELLED.value));
+				// We're finished forever (finishing auto-refunds remaining balance to AT creator)
+				codeByteBuffer.put(OpCode.FIN_IMD.compile());
+
+				/* Not trade nor cancel message */
+				labelNotTradeNorCancelTxn = codeByteBuffer.position();
+
+				// Loop to find another transaction
+				codeByteBuffer.put(OpCode.JMP_ADR.compile(labelTradeTxnLoop == null ? 0 : labelTradeTxnLoop));
+
+				/* Possible switch-to-trade-mode message */
+				labelCheckNonRefundTradeTxn = codeByteBuffer.position();
+
+				// Check 'trade' message we received has expected number of message bytes
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(QortalFunctionCode.GET_MESSAGE_LENGTH_FROM_TX_IN_A.value, addrMessageLength));
+				// If message length matches, branch to info extraction code
+				codeByteBuffer.put(OpCode.BEQ_DAT.compile(addrMessageLength, addrExpectedTradeMessageLength, calcOffset(codeByteBuffer, labelTradeTxnExtract)));
+				// Message length didn't match - go back to finding another 'trade' MESSAGE transaction
+				codeByteBuffer.put(OpCode.JMP_ADR.compile(labelTradeTxnLoop == null ? 0 : labelTradeTxnLoop));
+
+				/* Extracting info from 'trade' MESSAGE transaction */
+				labelTradeTxnExtract = codeByteBuffer.position();
+
+				// Extract message from transaction into B register
+				codeByteBuffer.put(OpCode.EXT_FUN.compile(FunctionCode.PUT_MESSAGE_FROM_TX_IN_A_INTO_B));
+				// Save B register into data segment starting at addrQortalPartnerAddress1 (as pointed to by addrQortalPartnerAddressPointer)
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.GET_B_IND, addrQortalPartnerAddressPointer));
+
+				// Extract trade partner's Ravencoin public key hash (PKH) from message into B
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(QortalFunctionCode.PUT_PARTIAL_MESSAGE_FROM_TX_IN_A_INTO_B.value, addrTradeMessagePartnerRavencoinPKHOffset));
+				// Store partner's Ravencoin PKH (we only really use values from B1-B3)
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.GET_B_IND, addrPartnerRavencoinPKHPointer));
+				// Extract AT trade timeout (minutes) (from B4)
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(FunctionCode.GET_B4, addrRefundTimeout));
+
+				// Grab next 32 bytes
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(QortalFunctionCode.PUT_PARTIAL_MESSAGE_FROM_TX_IN_A_INTO_B.value, addrTradeMessageHashOfSecretAOffset));
+
+				// Extract hash-of-secret-A (we only really use values from B1-B3)
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.GET_B_IND, addrHashOfSecretAPointer));
+				// Extract lockTime-A (from B4)
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(FunctionCode.GET_B4, addrLockTimeA));
+
+				// Calculate trade timeout refund 'timestamp' by adding addrRefundTimeout minutes to this transaction's 'timestamp', then save into addrRefundTimestamp
+				codeByteBuffer.put(OpCode.EXT_FUN_RET_DAT_2.compile(FunctionCode.ADD_MINUTES_TO_TIMESTAMP, addrRefundTimestamp, addrLastTxnTimestamp, addrRefundTimeout));
+
+				/* We are in 'trade mode' */
+				codeByteBuffer.put(OpCode.SET_VAL.compile(addrMode, AcctMode.TRADING.value));
+
+				// Set restart position to after this opcode
+				codeByteBuffer.put(OpCode.SET_PCS.compile());
+
+				/* Loop, waiting for trade timeout or 'redeem' MESSAGE from Qortal trade partner */
+
+				// Fetch current block 'timestamp'
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(FunctionCode.GET_BLOCK_TIMESTAMP, addrBlockTimestamp));
+				// If we're not past refund 'timestamp' then look for next transaction
+				codeByteBuffer.put(OpCode.BLT_DAT.compile(addrBlockTimestamp, addrRefundTimestamp, calcOffset(codeByteBuffer, labelRedeemTxnLoop)));
+				// We're past refund 'timestamp' so go refund everything back to AT creator
+				codeByteBuffer.put(OpCode.JMP_ADR.compile(labelRefund == null ? 0 : labelRefund));
+
+				/* Transaction processing loop */
+				labelRedeemTxnLoop = codeByteBuffer.position();
+
+				// Find next transaction to this AT since the last one (if any)
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.PUT_TX_AFTER_TIMESTAMP_INTO_A, addrLastTxnTimestamp));
+				// If no transaction found, A will be zero. If A is zero, set addrComparator to 1, otherwise 0.
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(FunctionCode.CHECK_A_IS_ZERO, addrResult));
+				// If addrResult is zero (i.e. A is non-zero, transaction was found) then go check transaction
+				codeByteBuffer.put(OpCode.BZR_DAT.compile(addrResult, calcOffset(codeByteBuffer, labelCheckRedeemTxn)));
+				// Stop and wait for next block
+				codeByteBuffer.put(OpCode.STP_IMD.compile());
+
+				/* Check transaction */
+				labelCheckRedeemTxn = codeByteBuffer.position();
+
+				// Update our 'last found transaction's timestamp' using 'timestamp' from transaction
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(FunctionCode.GET_TIMESTAMP_FROM_TX_IN_A, addrLastTxnTimestamp));
+				// Extract transaction type (message/payment) from transaction and save type in addrTxnType
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(FunctionCode.GET_TYPE_FROM_TX_IN_A, addrTxnType));
+				// If transaction type is not MESSAGE type then go look for another transaction
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrTxnType, addrMessageTxnType, calcOffset(codeByteBuffer, labelRedeemTxnLoop)));
+
+				/* Check message payload length */
+				codeByteBuffer.put(OpCode.EXT_FUN_RET.compile(QortalFunctionCode.GET_MESSAGE_LENGTH_FROM_TX_IN_A.value, addrMessageLength));
+				// If message length matches, branch to sender checking code
+				codeByteBuffer.put(OpCode.BEQ_DAT.compile(addrMessageLength, addrExpectedRedeemMessageLength, calcOffset(codeByteBuffer, labelCheckRedeemTxnSender)));
+				// Message length didn't match - go back to finding another 'redeem' MESSAGE transaction
+				codeByteBuffer.put(OpCode.JMP_ADR.compile(labelRedeemTxnLoop == null ? 0 : labelRedeemTxnLoop));
+
+				/* Check transaction's sender */
+				labelCheckRedeemTxnSender = codeByteBuffer.position();
+
+				// Extract sender address from transaction into B register
+				codeByteBuffer.put(OpCode.EXT_FUN.compile(FunctionCode.PUT_ADDRESS_FROM_TX_IN_A_INTO_B));
+				// Save B register into data segment starting at addrMessageSender1 (as pointed to by addrMessageSenderPointer)
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.GET_B_IND, addrMessageSenderPointer));
+				// Compare each part of transaction's sender's address with expected address. If they don't match, look for another transaction.
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender1, addrQortalPartnerAddress1, calcOffset(codeByteBuffer, labelRedeemTxnLoop)));
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender2, addrQortalPartnerAddress2, calcOffset(codeByteBuffer, labelRedeemTxnLoop)));
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender3, addrQortalPartnerAddress3, calcOffset(codeByteBuffer, labelRedeemTxnLoop)));
+				codeByteBuffer.put(OpCode.BNE_DAT.compile(addrMessageSender4, addrQortalPartnerAddress4, calcOffset(codeByteBuffer, labelRedeemTxnLoop)));
+
+				/* Check 'secret-A' in transaction's message */
+
+				// Extract secret-A from first 32 bytes of message from transaction into B register
+				codeByteBuffer.put(OpCode.EXT_FUN.compile(FunctionCode.PUT_MESSAGE_FROM_TX_IN_A_INTO_B));
+				// Save B register into data segment starting at addrMessageData (as pointed to by addrMessageDataPointer)
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.GET_B_IND, addrMessageDataPointer));
+				// Load B register with expected hash result (as pointed to by addrHashOfSecretAPointer)
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.SET_B_IND, addrHashOfSecretAPointer));
+				// Perform HASH160 using source data at addrMessageData. (Location and length specified via addrMessageDataPointer and addrMessageDataLength).
+				// Save the equality result (1 if they match, 0 otherwise) into addrResult.
+				codeByteBuffer.put(OpCode.EXT_FUN_RET_DAT_2.compile(FunctionCode.CHECK_HASH160_WITH_B, addrResult, addrMessageDataPointer, addrMessageDataLength));
+				// If hashes don't match, addrResult will be zero so go find another transaction
+				codeByteBuffer.put(OpCode.BNZ_DAT.compile(addrResult, calcOffset(codeByteBuffer, labelPayout)));
+				codeByteBuffer.put(OpCode.JMP_ADR.compile(labelRedeemTxnLoop == null ? 0 : labelRedeemTxnLoop));
+
+				/* Success! Pay arranged amount to receiving address */
+				labelPayout = codeByteBuffer.position();
+
+				// Extract Qortal receiving address from next 32 bytes of message from transaction into B register
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(QortalFunctionCode.PUT_PARTIAL_MESSAGE_FROM_TX_IN_A_INTO_B.value, addrRedeemMessageReceivingAddressOffset));
+				// Save B register into data segment starting at addrPartnerReceivingAddress (as pointed to by addrPartnerReceivingAddressPointer)
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.GET_B_IND, addrPartnerReceivingAddressPointer));
+				// Pay AT's balance to receiving address
+				codeByteBuffer.put(OpCode.EXT_FUN_DAT.compile(FunctionCode.PAY_TO_ADDRESS_IN_B, addrQortAmount));
+				// Set redeemed mode
+				codeByteBuffer.put(OpCode.SET_VAL.compile(addrMode, AcctMode.REDEEMED.value));
+				// We're finished forever (finishing auto-refunds remaining balance to AT creator)
+				codeByteBuffer.put(OpCode.FIN_IMD.compile());
+
+				// Fall-through to refunding any remaining balance back to AT creator
+
+				/* Refund balance back to AT creator */
+				labelRefund = codeByteBuffer.position();
+
+				// Set refunded mode
+				codeByteBuffer.put(OpCode.SET_VAL.compile(addrMode, AcctMode.REFUNDED.value));
+				// We're finished forever (finishing auto-refunds remaining balance to AT creator)
+				codeByteBuffer.put(OpCode.FIN_IMD.compile());
+			} catch (CompilationException e) {
+				throw new IllegalStateException("Unable to compile RVN-QORT ACCT?", e);
+			}
+		}
+
+		codeByteBuffer.flip();
+
+		byte[] codeBytes = new byte[codeByteBuffer.limit()];
+		codeByteBuffer.get(codeBytes);
+
+		assert Arrays.equals(Crypto.digest(codeBytes), RavencoinACCTv3.CODE_BYTES_HASH)
+			: String.format("BTCACCT.CODE_BYTES_HASH mismatch: expected %s, actual %s", HashCode.fromBytes(CODE_BYTES_HASH), HashCode.fromBytes(Crypto.digest(codeBytes)));
+
+		final short ciyamAtVersion = 2;
+		final short numCallStackPages = 0;
+		final short numUserStackPages = 0;
+		final long minActivationAmount = 0L;
+
+		return MachineState.toCreationBytes(ciyamAtVersion, codeBytes, dataByteBuffer.array(), numCallStackPages, numUserStackPages, minActivationAmount);
+	}
+
+	/**
+	 * Returns CrossChainTradeData with useful info extracted from AT.
+	 */
+	@Override
+	public CrossChainTradeData populateTradeData(Repository repository, ATData atData) throws DataException {
+		ATStateData atStateData = repository.getATRepository().getLatestATState(atData.getATAddress());
+		return populateTradeData(repository, atData.getCreatorPublicKey(), atData.getCreation(), atStateData);
+	}
+
+	/**
+	 * Returns CrossChainTradeData with useful info extracted from AT.
+	 */
+	@Override
+	public CrossChainTradeData populateTradeData(Repository repository, ATStateData atStateData) throws DataException {
+		ATData atData = repository.getATRepository().fromATAddress(atStateData.getATAddress());
+		return populateTradeData(repository, atData.getCreatorPublicKey(), atData.getCreation(), atStateData);
+	}
+
+	/**
+	 * Returns CrossChainTradeData with useful info extracted from AT.
+	 */
+	public CrossChainTradeData populateTradeData(Repository repository, byte[] creatorPublicKey, long creationTimestamp, ATStateData atStateData) throws DataException {
+		byte[] addressBytes = new byte[25]; // for general use
+		String atAddress = atStateData.getATAddress();
+
+		CrossChainTradeData tradeData = new CrossChainTradeData();
+
+		tradeData.foreignBlockchain = SupportedBlockchain.RAVENCOIN.name();
+		tradeData.acctName = NAME;
+
+		tradeData.qortalAtAddress = atAddress;
+		tradeData.qortalCreator = Crypto.toAddress(creatorPublicKey);
+		tradeData.creationTimestamp = creationTimestamp;
+
+		Account atAccount = new Account(repository, atAddress);
+		tradeData.qortBalance = atAccount.getConfirmedBalance(Asset.QORT);
+
+		byte[] stateData = atStateData.getStateData();
+		ByteBuffer dataByteBuffer = ByteBuffer.wrap(stateData);
+		dataByteBuffer.position(MachineState.HEADER_LENGTH);
+
+		/* Constants */
+
+		// Skip creator's trade address
+		dataByteBuffer.get(addressBytes);
+		tradeData.qortalCreatorTradeAddress = Base58.encode(addressBytes);
+		dataByteBuffer.position(dataByteBuffer.position() + 32 - addressBytes.length);
+
+		// Creator's Ravencoin/foreign public key hash
+		tradeData.creatorForeignPKH = new byte[20];
+		dataByteBuffer.get(tradeData.creatorForeignPKH);
+		dataByteBuffer.position(dataByteBuffer.position() + 32 - tradeData.creatorForeignPKH.length); // skip to 32 bytes
+
+		// We don't use secret-B
+		tradeData.hashOfSecretB = null;
+
+		// Redeem payout
+		tradeData.qortAmount = dataByteBuffer.getLong();
+
+		// Expected RVN amount
+		tradeData.expectedForeignAmount = dataByteBuffer.getLong();
+
+		// Trade timeout
+		tradeData.tradeTimeout = (int) dataByteBuffer.getLong();
+
+		// Skip MESSAGE transaction type
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip expected 'trade' message length
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip expected 'redeem' message length
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip pointer to creator's address
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip pointer to partner's Qortal trade address
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip pointer to message sender
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip 'trade' message data offset for partner's Ravencoin PKH
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip pointer to partner's Ravencoin PKH
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip 'trade' message data offset for hash-of-secret-A
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip pointer to hash-of-secret-A
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip 'redeem' message data offset for partner's Qortal receiving address
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip pointer to message data
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip message data length
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip pointer to partner's receiving address
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		/* End of constants / begin variables */
+
+		// Skip AT creator's address
+		dataByteBuffer.position(dataByteBuffer.position() + 8 * 4);
+
+		// Partner's trade address (if present)
+		dataByteBuffer.get(addressBytes);
+		String qortalRecipient = Base58.encode(addressBytes);
+		dataByteBuffer.position(dataByteBuffer.position() + 32 - addressBytes.length);
+
+		// Potential lockTimeA (if in trade mode)
+		int lockTimeA = (int) dataByteBuffer.getLong();
+
+		// AT refund timeout (probably only useful for debugging)
+		int refundTimeout = (int) dataByteBuffer.getLong();
+
+		// Trade-mode refund timestamp (AT 'timestamp' converted to Qortal block height)
+		long tradeRefundTimestamp = dataByteBuffer.getLong();
+
+		// Skip last transaction timestamp
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip block timestamp
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip transaction type
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip temporary result
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip temporary message sender
+		dataByteBuffer.position(dataByteBuffer.position() + 8 * 4);
+
+		// Skip message length
+		dataByteBuffer.position(dataByteBuffer.position() + 8);
+
+		// Skip temporary message data
+		dataByteBuffer.position(dataByteBuffer.position() + 8 * 4);
+
+		// Potential hash160 of secret A
+		byte[] hashOfSecretA = new byte[20];
+		dataByteBuffer.get(hashOfSecretA);
+		dataByteBuffer.position(dataByteBuffer.position() + 32 - hashOfSecretA.length); // skip to 32 bytes
+
+		// Potential partner's Ravencoin PKH
+		byte[] partnerRavencoinPKH = new byte[20];
+		dataByteBuffer.get(partnerRavencoinPKH);
+		dataByteBuffer.position(dataByteBuffer.position() + 32 - partnerRavencoinPKH.length); // skip to 32 bytes
+
+		// Partner's receiving address (if present)
+		byte[] partnerReceivingAddress = new byte[25];
+		dataByteBuffer.get(partnerReceivingAddress);
+		dataByteBuffer.position(dataByteBuffer.position() + 32 - partnerReceivingAddress.length); // skip to 32 bytes
+
+		// Trade AT's 'mode'
+		long modeValue = dataByteBuffer.getLong();
+		AcctMode mode = AcctMode.valueOf((int) (modeValue & 0xffL));
+
+		/* End of variables */
+
+		if (mode != null && mode != AcctMode.OFFERING) {
+			tradeData.mode = mode;
+			tradeData.refundTimeout = refundTimeout;
+			tradeData.tradeRefundHeight = new Timestamp(tradeRefundTimestamp).blockHeight;
+			tradeData.qortalPartnerAddress = qortalRecipient;
+			tradeData.hashOfSecretA = hashOfSecretA;
+			tradeData.partnerForeignPKH = partnerRavencoinPKH;
+			tradeData.lockTimeA = lockTimeA;
+
+			if (mode == AcctMode.REDEEMED)
+				tradeData.qortalPartnerReceivingAddress = Base58.encode(partnerReceivingAddress);
+		} else {
+			tradeData.mode = AcctMode.OFFERING;
+		}
+
+		tradeData.duplicateDeprecated();
+
+		return tradeData;
+	}
+
+	/** Returns 'offer' MESSAGE payload for trade partner to send to AT creator's trade address. */
+	public static byte[] buildOfferMessage(byte[] partnerBitcoinPKH, byte[] hashOfSecretA, int lockTimeA) {
+		byte[] lockTimeABytes = BitTwiddling.toBEByteArray((long) lockTimeA);
+		return Bytes.concat(partnerBitcoinPKH, hashOfSecretA, lockTimeABytes);
+	}
+
+	/** Returns info extracted from 'offer' MESSAGE payload sent by trade partner to AT creator's trade address, or null if not valid. */
+	public static OfferMessageData extractOfferMessageData(byte[] messageData) {
+		if (messageData == null || messageData.length != OFFER_MESSAGE_LENGTH)
+			return null;
+
+		OfferMessageData offerMessageData = new OfferMessageData();
+		offerMessageData.partnerRavencoinPKH = Arrays.copyOfRange(messageData, 0, 20);
+		offerMessageData.hashOfSecretA = Arrays.copyOfRange(messageData, 20, 40);
+		offerMessageData.lockTimeA = BitTwiddling.longFromBEBytes(messageData, 40);
+
+		return offerMessageData;
+	}
+
+	/** Returns 'trade' MESSAGE payload for AT creator to send to AT. */
+	public static byte[] buildTradeMessage(String partnerQortalTradeAddress, byte[] partnerBitcoinPKH, byte[] hashOfSecretA, int lockTimeA, int refundTimeout) {
+		byte[] data = new byte[TRADE_MESSAGE_LENGTH];
+		byte[] partnerQortalAddressBytes = Base58.decode(partnerQortalTradeAddress);
+		byte[] lockTimeABytes = BitTwiddling.toBEByteArray((long) lockTimeA);
+		byte[] refundTimeoutBytes = BitTwiddling.toBEByteArray((long) refundTimeout);
+
+		System.arraycopy(partnerQortalAddressBytes, 0, data, 0, partnerQortalAddressBytes.length);
+		System.arraycopy(partnerBitcoinPKH, 0, data, 32, partnerBitcoinPKH.length);
+		System.arraycopy(refundTimeoutBytes, 0, data, 56, refundTimeoutBytes.length);
+		System.arraycopy(hashOfSecretA, 0, data, 64, hashOfSecretA.length);
+		System.arraycopy(lockTimeABytes, 0, data, 88, lockTimeABytes.length);
+
+		return data;
+	}
+
+	/** Returns 'cancel' MESSAGE payload for AT creator to cancel trade AT. */
+	@Override
+	public byte[] buildCancelMessage(String creatorQortalAddress) {
+		byte[] data = new byte[CANCEL_MESSAGE_LENGTH];
+		byte[] creatorQortalAddressBytes = Base58.decode(creatorQortalAddress);
+
+		System.arraycopy(creatorQortalAddressBytes, 0, data, 0, creatorQortalAddressBytes.length);
+
+		return data;
+	}
+
+	/** Returns 'redeem' MESSAGE payload for trade partner to send to AT. */
+	public static byte[] buildRedeemMessage(byte[] secretA, String qortalReceivingAddress) {
+		byte[] data = new byte[REDEEM_MESSAGE_LENGTH];
+		byte[] qortalReceivingAddressBytes = Base58.decode(qortalReceivingAddress);
+
+		System.arraycopy(secretA, 0, data, 0, secretA.length);
+		System.arraycopy(qortalReceivingAddressBytes, 0, data, 32, qortalReceivingAddressBytes.length);
+
+		return data;
+	}
+
+	/** Returns refund timeout (minutes) based on trade partner's 'offer' MESSAGE timestamp and P2SH-A locktime. */
+	public static int calcRefundTimeout(long offerMessageTimestamp, int lockTimeA) {
+		// refund should be triggered halfway between offerMessageTimestamp and lockTimeA
+		return (int) ((lockTimeA - (offerMessageTimestamp / 1000L)) / 2L / 60L);
+	}
+
+	@Override
+	public byte[] findSecretA(Repository repository, CrossChainTradeData crossChainTradeData) throws DataException {
+		String atAddress = crossChainTradeData.qortalAtAddress;
+		String redeemerAddress = crossChainTradeData.qortalPartnerAddress;
+
+		// We don't have partner's public key so we check every message to AT
+		List<MessageTransactionData> messageTransactionsData = repository.getMessageRepository().getMessagesByParticipants(null, atAddress, null, null, null);
+		if (messageTransactionsData == null)
+			return null;
+
+		// Find 'redeem' message
+		for (MessageTransactionData messageTransactionData : messageTransactionsData) {
+			// Check message payload type/encryption
+			if (messageTransactionData.isText() || messageTransactionData.isEncrypted())
+				continue;
+
+			// Check message payload size
+			byte[] messageData = messageTransactionData.getData();
+			if (messageData.length != REDEEM_MESSAGE_LENGTH)
+				// Wrong payload length
+				continue;
+
+			// Check sender
+			if (!Crypto.toAddress(messageTransactionData.getSenderPublicKey()).equals(redeemerAddress))
+				// Wrong sender;
+				continue;
+
+			// Extract secretA
+			byte[] secretA = new byte[32];
+			System.arraycopy(messageData, 0, secretA, 0, secretA.length);
+
+			byte[] hashOfSecretA = Crypto.hash160(secretA);
+			if (!Arrays.equals(hashOfSecretA, crossChainTradeData.hashOfSecretA))
+				continue;
+
+			return secretA;
+		}
+
+		return null;
+	}
+
+}

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

@@ -7,11 +7,12 @@ import java.util.List;
 @XmlAccessorType(XmlAccessType.FIELD)
 public class SimpleTransaction {
     private String txHash;
-    private Integer timestamp;
+    private Long timestamp;
     private long totalAmount;
     private long feeAmount;
     private List<Input> inputs;
     private List<Output> outputs;
+    private String memo;
 
 
     @XmlAccessorType(XmlAccessType.FIELD)
@@ -74,20 +75,21 @@ public class SimpleTransaction {
     public SimpleTransaction() {
     }
 
-    public SimpleTransaction(String txHash, Integer timestamp, long totalAmount, long feeAmount, List<Input> inputs, List<Output> outputs) {
+    public SimpleTransaction(String txHash, Long timestamp, long totalAmount, long feeAmount, List<Input> inputs, List<Output> outputs, String memo) {
         this.txHash = txHash;
         this.timestamp = timestamp;
         this.totalAmount = totalAmount;
         this.feeAmount = feeAmount;
         this.inputs = inputs;
         this.outputs = outputs;
+        this.memo = memo;
     }
 
     public String getTxHash() {
         return txHash;
     }
 
-    public Integer getTimestamp() {
+    public Long getTimestamp() {
         return timestamp;
     }
 

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

@@ -13,8 +13,8 @@ import org.qortal.utils.Triple;
 public enum SupportedBlockchain {
 
 	BITCOIN(Arrays.asList(
-				Triple.valueOf(BitcoinACCTv1.NAME, BitcoinACCTv1.CODE_BYTES_HASH, BitcoinACCTv1::getInstance)
-				// Could add improved BitcoinACCTv2 here in the future
+				Triple.valueOf(BitcoinACCTv1.NAME, BitcoinACCTv1.CODE_BYTES_HASH, BitcoinACCTv1::getInstance),
+				Triple.valueOf(BitcoinACCTv3.NAME, BitcoinACCTv3.CODE_BYTES_HASH, BitcoinACCTv3::getInstance)
 			)) {
 		@Override
 		public ForeignBlockchain getInstance() {
@@ -23,7 +23,7 @@ public enum SupportedBlockchain {
 
 		@Override
 		public ACCT getLatestAcct() {
-			return BitcoinACCTv1.getInstance();
+			return BitcoinACCTv3.getInstance();
 		}
 	},
 
@@ -57,12 +57,54 @@ public enum SupportedBlockchain {
 		public ACCT getLatestAcct() {
 			return DogecoinACCTv3.getInstance();
 		}
+	},
+
+	DIGIBYTE(Arrays.asList(
+			Triple.valueOf(DigibyteACCTv3.NAME, DigibyteACCTv3.CODE_BYTES_HASH, DigibyteACCTv3::getInstance)
+		)) {
+		@Override
+		public ForeignBlockchain getInstance() {
+			return Digibyte.getInstance();
+		}
+
+		@Override
+		public ACCT getLatestAcct() {
+			return DigibyteACCTv3.getInstance();
+		}
+	},
+
+	RAVENCOIN(Arrays.asList(
+			Triple.valueOf(RavencoinACCTv3.NAME, RavencoinACCTv3.CODE_BYTES_HASH, RavencoinACCTv3::getInstance)
+		)) {
+		@Override
+		public ForeignBlockchain getInstance() {
+			return Ravencoin.getInstance();
+		}
+
+		@Override
+		public ACCT getLatestAcct() {
+			return RavencoinACCTv3.getInstance();
+		}
+	},
+
+	PIRATECHAIN(Arrays.asList(
+			Triple.valueOf(PirateChainACCTv3.NAME, PirateChainACCTv3.CODE_BYTES_HASH, PirateChainACCTv3::getInstance)
+	)) {
+		@Override
+		public ForeignBlockchain getInstance() {
+			return PirateChain.getInstance();
+		}
+
+		@Override
+		public ACCT getLatestAcct() {
+			return PirateChainACCTv3.getInstance();
+		}
 	};
 
 	private static final Map<ByteArray, Supplier<ACCT>> supportedAcctsByCodeHash = Arrays.stream(SupportedBlockchain.values())
 			.map(supportedBlockchain -> supportedBlockchain.supportedAccts)
 			.flatMap(List::stream)
-			.collect(Collectors.toUnmodifiableMap(triple -> new ByteArray(triple.getB()), Triple::getC));
+			.collect(Collectors.toUnmodifiableMap(triple -> ByteArray.wrap(triple.getB()), Triple::getC));
 
 	private static final Map<String, Supplier<ACCT>> supportedAcctsByName = Arrays.stream(SupportedBlockchain.values())
 			.map(supportedBlockchain -> supportedBlockchain.supportedAccts)
@@ -94,7 +136,7 @@ public enum SupportedBlockchain {
 			return getAcctMap();
 
 		return blockchain.supportedAccts.stream()
-				.collect(Collectors.toUnmodifiableMap(triple -> new ByteArray(triple.getB()), Triple::getC));
+				.collect(Collectors.toUnmodifiableMap(triple -> ByteArray.wrap(triple.getB()), Triple::getC));
 	}
 
 	public static Map<ByteArray, Supplier<ACCT>> getFilteredAcctMap(String specificBlockchain) {
@@ -109,7 +151,7 @@ public enum SupportedBlockchain {
 	}
 
 	public static ACCT getAcctByCodeHash(byte[] codeHash) {
-		ByteArray wrappedCodeHash = new ByteArray(codeHash);
+		ByteArray wrappedCodeHash = ByteArray.wrap(codeHash);
 
 		Supplier<ACCT> acctInstanceSupplier = supportedAcctsByCodeHash.get(wrappedCodeHash);
 

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

@@ -7,10 +7,20 @@ public class UnspentOutput {
 	public final int height;
 	public final long value;
 
-	public UnspentOutput(byte[] hash, int index, int height, long value) {
+	// Optional fields returned by Pirate Light Client server
+	public final byte[] script;
+	public final String address;
+
+	public UnspentOutput(byte[] hash, int index, int height, long value, byte[] script, String address) {
 		this.hash = hash;
 		this.index = index;
 		this.height = height;
 		this.value = value;
+		this.script = script;
+		this.address = address;
+	}
+
+	public UnspentOutput(byte[] hash, int index, int height, long value) {
+		this(hash, index, height, value, null, null);
 	}
 }

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

@@ -1,99 +0,0 @@
-package org.qortal.crypto;
-
-import java.lang.reflect.Constructor;
-import java.lang.reflect.Field;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.util.Arrays;
-
-import org.bouncycastle.crypto.Digest;
-import org.bouncycastle.math.ec.rfc7748.X25519;
-import org.bouncycastle.math.ec.rfc7748.X25519Field;
-import org.bouncycastle.math.ec.rfc8032.Ed25519;
-
-/** Additions to BouncyCastle providing Ed25519 to X25519 key conversion. */
-public class BouncyCastle25519 {
-
-	private static final Class<?> pointAffineClass;
-	private static final Constructor<?> pointAffineCtor;
-	private static final Method decodePointVarMethod;
-	private static final Field yField;
-
-	static {
-		try {
-			Class<?> ed25519Class = Ed25519.class;
-			pointAffineClass = Arrays.stream(ed25519Class.getDeclaredClasses()).filter(clazz -> clazz.getSimpleName().equals("PointAffine")).findFirst().get();
-			if (pointAffineClass == null)
-				throw new ClassNotFoundException("Can't locate PointExt inner class inside Ed25519");
-
-			decodePointVarMethod = ed25519Class.getDeclaredMethod("decodePointVar", byte[].class, int.class, boolean.class, pointAffineClass);
-			decodePointVarMethod.setAccessible(true);
-
-			pointAffineCtor = pointAffineClass.getDeclaredConstructors()[0];
-			pointAffineCtor.setAccessible(true);
-
-			yField = pointAffineClass.getDeclaredField("y");
-			yField.setAccessible(true);
-		} catch (NoSuchMethodException | SecurityException | IllegalArgumentException | NoSuchFieldException | ClassNotFoundException e) {
-			throw new RuntimeException("Can't initialize BouncyCastle25519 shim", e);
-		}
-	}
-
-	private static int[] obtainYFromPublicKey(byte[] ed25519PublicKey) {
-		try {
-			Object pA = pointAffineCtor.newInstance();
-
-			Boolean result = (Boolean) decodePointVarMethod.invoke(null, ed25519PublicKey, 0, true, pA);
-			if (result == null || !result)
-				return null;
-
-			return (int[]) yField.get(pA);
-		} catch (SecurityException | InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
-			throw new RuntimeException("Can't reflect into BouncyCastle", e);
-		}
-	}
-
-	public static byte[] toX25519PublicKey(byte[] ed25519PublicKey) {
-		int[] one = new int[X25519Field.SIZE];
-		X25519Field.one(one);
-
-		int[] y = obtainYFromPublicKey(ed25519PublicKey);
-
-		int[] oneMinusY = new int[X25519Field.SIZE];
-		X25519Field.sub(one, y, oneMinusY);
-
-		int[] onePlusY = new int[X25519Field.SIZE];
-		X25519Field.add(one, y, onePlusY);
-
-		int[] oneMinusYInverted = new int[X25519Field.SIZE];
-		X25519Field.inv(oneMinusY, oneMinusYInverted);
-
-		int[] u = new int[X25519Field.SIZE];
-		X25519Field.mul(onePlusY, oneMinusYInverted, u);
-
-		X25519Field.normalize(u);
-
-		byte[] x25519PublicKey = new byte[X25519.SCALAR_SIZE];
-		X25519Field.encode(u, x25519PublicKey, 0);
-
-		return x25519PublicKey;
-	}
-
-	public static byte[] toX25519PrivateKey(byte[] ed25519PrivateKey) {
-		Digest d = Ed25519.createPrehash();
-		byte[] h = new byte[d.getDigestSize()];
-
-		d.update(ed25519PrivateKey, 0, ed25519PrivateKey.length);
-		d.doFinal(h, 0);
-
-		byte[] s = new byte[X25519.SCALAR_SIZE];
-
-		System.arraycopy(h, 0, s, 0, X25519.SCALAR_SIZE);
-		s[0] &= 0xF8;
-		s[X25519.SCALAR_SIZE - 1] &= 0x7F;
-		s[X25519.SCALAR_SIZE - 1] |= 0x40;
-
-		return s;
-	}
-
-}

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

@@ -253,6 +253,10 @@ public abstract class Crypto {
 		return false;
 	}
 
+	public static byte[] toPublicKey(byte[] privateKey) {
+		return new Ed25519PrivateKeyParameters(privateKey, 0).generatePublicKey().getEncoded();
+	}
+
 	public static boolean verify(byte[] publicKey, byte[] signature, byte[] message) {
 		try {
 			return Ed25519.verify(signature, 0, publicKey, 0, message, 0, message.length);
@@ -264,16 +268,24 @@ public abstract class Crypto {
 	public static byte[] sign(Ed25519PrivateKeyParameters edPrivateKeyParams, byte[] message) {
 		byte[] signature = new byte[SIGNATURE_LENGTH];
 
-		edPrivateKeyParams.sign(Ed25519.Algorithm.Ed25519, edPrivateKeyParams.generatePublicKey(), null, message, 0, message.length, signature, 0);
+		edPrivateKeyParams.sign(Ed25519.Algorithm.Ed25519,null, message, 0, message.length, signature, 0);
+
+		return signature;
+	}
+
+	public static byte[] sign(byte[] privateKey, byte[] message) {
+		byte[] signature = new byte[SIGNATURE_LENGTH];
+
+		new Ed25519PrivateKeyParameters(privateKey, 0).sign(Ed25519.Algorithm.Ed25519,null, message, 0, message.length, signature, 0);
 
 		return signature;
 	}
 
 	public static byte[] getSharedSecret(byte[] privateKey, byte[] publicKey) {
-		byte[] x25519PrivateKey = BouncyCastle25519.toX25519PrivateKey(privateKey);
+		byte[] x25519PrivateKey = Qortal25519Extras.toX25519PrivateKey(privateKey);
 		X25519PrivateKeyParameters xPrivateKeyParams = new X25519PrivateKeyParameters(x25519PrivateKey, 0);
 
-		byte[] x25519PublicKey = BouncyCastle25519.toX25519PublicKey(publicKey);
+		byte[] x25519PublicKey = Qortal25519Extras.toX25519PublicKey(publicKey);
 		X25519PublicKeyParameters xPublicKeyParams = new X25519PublicKeyParameters(x25519PublicKey, 0);
 
 		byte[] sharedSecret = new byte[SHARED_SECRET_LENGTH];
@@ -281,5 +293,4 @@ public abstract class Crypto {
 
 		return sharedSecret;
 	}
-
 }

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

@@ -0,0 +1,234 @@
+package org.qortal.crypto;
+
+import org.bouncycastle.crypto.Digest;
+import org.bouncycastle.crypto.digests.SHA512Digest;
+import org.bouncycastle.math.ec.rfc7748.X25519;
+import org.bouncycastle.math.ec.rfc7748.X25519Field;
+import org.bouncycastle.math.ec.rfc8032.Ed25519;
+import org.bouncycastle.math.raw.Nat256;
+
+import java.security.SecureRandom;
+import java.util.Arrays;
+import java.util.Collection;
+
+/**
+ * Additions to BouncyCastle providing:
+ * <p></p>
+ * <ul>
+ *     <li>Ed25519 to X25519 key conversion</li>
+ *     <li>Aggregate public keys</li>
+ *     <li>Aggregate signatures</li>
+ * </ul>
+ */
+public abstract class Qortal25519Extras extends BouncyCastleEd25519 {
+
+	private static final SecureRandom SECURE_RANDOM = new SecureRandom();
+
+	public static byte[] toX25519PublicKey(byte[] ed25519PublicKey) {
+		int[] one = new int[X25519Field.SIZE];
+		X25519Field.one(one);
+
+		PointAffine pA = new PointAffine();
+		if (!decodePointVar(ed25519PublicKey, 0, true, pA))
+			return null;
+
+		int[] y = pA.y;
+
+		int[] oneMinusY = new int[X25519Field.SIZE];
+		X25519Field.sub(one, y, oneMinusY);
+
+		int[] onePlusY = new int[X25519Field.SIZE];
+		X25519Field.add(one, y, onePlusY);
+
+		int[] oneMinusYInverted = new int[X25519Field.SIZE];
+		X25519Field.inv(oneMinusY, oneMinusYInverted);
+
+		int[] u = new int[X25519Field.SIZE];
+		X25519Field.mul(onePlusY, oneMinusYInverted, u);
+
+		X25519Field.normalize(u);
+
+		byte[] x25519PublicKey = new byte[X25519.SCALAR_SIZE];
+		X25519Field.encode(u, x25519PublicKey, 0);
+
+		return x25519PublicKey;
+	}
+
+	public static byte[] toX25519PrivateKey(byte[] ed25519PrivateKey) {
+		Digest d = Ed25519.createPrehash();
+		byte[] h = new byte[d.getDigestSize()];
+
+		d.update(ed25519PrivateKey, 0, ed25519PrivateKey.length);
+		d.doFinal(h, 0);
+
+		byte[] s = new byte[X25519.SCALAR_SIZE];
+
+		System.arraycopy(h, 0, s, 0, X25519.SCALAR_SIZE);
+		s[0] &= 0xF8;
+		s[X25519.SCALAR_SIZE - 1] &= 0x7F;
+		s[X25519.SCALAR_SIZE - 1] |= 0x40;
+
+		return s;
+	}
+
+	// Mostly for test support
+	public static PointAccum newPointAccum() {
+		return new PointAccum();
+	}
+
+	public static byte[] aggregatePublicKeys(Collection<byte[]> publicKeys) {
+		PointAccum rAccum = null;
+
+		for (byte[] publicKey : publicKeys) {
+			PointAffine pA = new PointAffine();
+			if (!decodePointVar(publicKey, 0, false, pA))
+				// Failed to decode
+				return null;
+
+			if (rAccum == null) {
+				rAccum = new PointAccum();
+				pointCopy(pA, rAccum);
+			} else {
+				pointAdd(pointCopy(pA), rAccum);
+			}
+		}
+
+		byte[] publicKey = new byte[SCALAR_BYTES];
+		if (0 == encodePoint(rAccum, publicKey, 0))
+			// Failed to encode
+			return null;
+
+		return publicKey;
+	}
+
+	public static byte[] aggregateSignatures(Collection<byte[]> signatures) {
+		// Signatures are (R, s)
+		// R is a point
+		// s is a scalar
+		PointAccum rAccum = null;
+		int[] sAccum = new int[SCALAR_INTS];
+
+		byte[] rEncoded = new byte[POINT_BYTES];
+		int[] sPart = new int[SCALAR_INTS];
+		for (byte[] signature : signatures) {
+			System.arraycopy(signature,0, rEncoded, 0, rEncoded.length);
+
+			PointAffine pA = new PointAffine();
+			if (!decodePointVar(rEncoded, 0, false, pA))
+				// Failed to decode
+				return null;
+
+			if (rAccum == null) {
+				rAccum = new PointAccum();
+				pointCopy(pA, rAccum);
+
+				decode32(signature, rEncoded.length, sAccum, 0, SCALAR_INTS);
+			} else {
+				pointAdd(pointCopy(pA), rAccum);
+
+				decode32(signature, rEncoded.length, sPart, 0, SCALAR_INTS);
+				Nat256.addTo(sPart, sAccum);
+
+				// "mod L" on sAccum
+				if (Nat256.gte(sAccum, L))
+					Nat256.subFrom(L, sAccum);
+			}
+		}
+
+		byte[] signature = new byte[SIGNATURE_SIZE];
+		if (0 == encodePoint(rAccum, signature, 0))
+			// Failed to encode
+			return null;
+
+		for (int i = 0; i < sAccum.length; ++i) {
+			encode32(sAccum[i], signature, POINT_BYTES + i * 4);
+		}
+
+		return signature;
+	}
+
+	public static byte[] signForAggregation(byte[] privateKey, byte[] message) {
+		// Very similar to BouncyCastle's implementation except we use secure random nonce and different hash
+		Digest d = new SHA512Digest();
+		byte[] h = new byte[d.getDigestSize()];
+
+		d.reset();
+		d.update(privateKey, 0, privateKey.length);
+		d.doFinal(h, 0);
+
+		byte[] sH = new byte[SCALAR_BYTES];
+		pruneScalar(h, 0, sH);
+
+		byte[] publicKey = new byte[SCALAR_BYTES];
+		scalarMultBaseEncoded(sH, publicKey, 0);
+
+		byte[] rSeed = new byte[d.getDigestSize()];
+		SECURE_RANDOM.nextBytes(rSeed);
+
+		byte[] r = new byte[SCALAR_BYTES];
+		pruneScalar(rSeed, 0, r);
+
+		byte[] R = new byte[POINT_BYTES];
+		scalarMultBaseEncoded(r, R, 0);
+
+		d.reset();
+		d.update(message, 0, message.length);
+		d.doFinal(h, 0);
+		byte[] k = reduceScalar(h);
+
+		byte[] s = calculateS(r, k, sH);
+
+		byte[] signature = new byte[SIGNATURE_SIZE];
+		System.arraycopy(R, 0, signature, 0, POINT_BYTES);
+		System.arraycopy(s, 0, signature, POINT_BYTES, SCALAR_BYTES);
+
+		return signature;
+	}
+
+	public static boolean verifyAggregated(byte[] publicKey, byte[] signature, byte[] message) {
+		byte[] R = Arrays.copyOfRange(signature, 0, POINT_BYTES);
+
+		byte[] s = Arrays.copyOfRange(signature, POINT_BYTES, POINT_BYTES + SCALAR_BYTES);
+
+		if (!checkPointVar(R))
+			// R out of bounds
+			return false;
+
+		if (!checkScalarVar(s))
+			// s out of bounds
+			return false;
+
+		byte[] S = new byte[POINT_BYTES];
+		scalarMultBaseEncoded(s, S, 0);
+
+		PointAffine pA = new PointAffine();
+		if (!decodePointVar(publicKey, 0, true, pA))
+			// Failed to decode
+			return false;
+
+		Digest d = new SHA512Digest();
+		byte[] h = new byte[d.getDigestSize()];
+
+		d.update(message, 0, message.length);
+		d.doFinal(h, 0);
+
+		byte[] k = reduceScalar(h);
+
+		int[] nS = new int[SCALAR_INTS];
+		decodeScalar(s, 0, nS);
+
+		int[] nA = new int[SCALAR_INTS];
+		decodeScalar(k, 0, nA);
+
+		/*PointAccum*/
+		PointAccum pR = new PointAccum();
+		scalarMultStrausVar(nS, nA, pA, pR);
+
+		byte[] check = new byte[POINT_BYTES];
+		if (0 == encodePoint(pR, check, 0))
+			// Failed to encode
+			return false;
+
+		return Arrays.equals(check, R);
+	}
+}

src/main/java/org/qortal/data/arbitrary/ArbitraryDirectConnectionInfo.java

@@ -0,0 +1,59 @@
+package org.qortal.data.arbitrary;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+
+public class ArbitraryDirectConnectionInfo {
+
+    private final byte[] signature;
+    private final String peerAddress;
+    private final List<byte[]> hashes;
+    private final long timestamp;
+
+    public ArbitraryDirectConnectionInfo(byte[] signature, String peerAddress, List<byte[]> hashes, long timestamp) {
+        this.signature = signature;
+        this.peerAddress = peerAddress;
+        this.hashes = hashes;
+        this.timestamp = timestamp;
+    }
+
+    public byte[] getSignature() {
+        return this.signature;
+    }
+
+    public String getPeerAddress() {
+        return this.peerAddress;
+    }
+
+    public List<byte[]> getHashes() {
+        return this.hashes;
+    }
+    
+    public long getTimestamp() {
+        return this.timestamp;
+    }
+
+    public int getHashCount() {
+        if (this.hashes == null) {
+            return 0;
+        }
+        return this.hashes.size();
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (other == this)
+            return true;
+
+        if (!(other instanceof ArbitraryDirectConnectionInfo))
+            return false;
+
+        ArbitraryDirectConnectionInfo otherDirectConnectionInfo = (ArbitraryDirectConnectionInfo) other;
+
+        return Arrays.equals(this.signature, otherDirectConnectionInfo.getSignature())
+                && Objects.equals(this.peerAddress, otherDirectConnectionInfo.getPeerAddress())
+                && Objects.equals(this.hashes, otherDirectConnectionInfo.getHashes())
+                && Objects.equals(this.timestamp, otherDirectConnectionInfo.getTimestamp());
+    }
+}

src/main/java/org/qortal/data/arbitrary/ArbitraryFileListResponseInfo.java

@@ -0,0 +1,11 @@
+package org.qortal.data.arbitrary;
+
+import org.qortal.network.Peer;
+
+public class ArbitraryFileListResponseInfo extends  ArbitraryRelayInfo {
+
+    public ArbitraryFileListResponseInfo(String hash58, String signature58, Peer peer, Long timestamp, Long requestTime, Integer requestHops) {
+        super(hash58, signature58, peer, timestamp, requestTime, requestHops);
+    }
+
+}

src/main/java/org/qortal/data/arbitrary/ArbitraryResourceStatus.java

@@ -26,6 +26,7 @@ public class ArbitraryResourceStatus {
         }
     }
 
+    private Status status;
     private String id;
     private String title;
     private String description;
@@ -37,6 +38,7 @@ public class ArbitraryResourceStatus {
     }
 
     public ArbitraryResourceStatus(Status status, Integer localChunkCount, Integer totalChunkCount) {
+        this.status = status;
         this.id = status.toString();
         this.title = status.title;
         this.description = status.description;
@@ -47,4 +49,20 @@ public class ArbitraryResourceStatus {
     public ArbitraryResourceStatus(Status status) {
         this(status, null, null);
     }
+
+    public Status getStatus() {
+        return this.status;
+    }
+
+    public String getTitle() {
+        return this.title;
+    }
+
+    public Integer getLocalChunkCount() {
+        return this.localChunkCount;
+    }
+
+    public Integer getTotalChunkCount() {
+        return this.totalChunkCount;
+    }
 }

src/main/java/org/qortal/data/group/GroupData.java

@@ -23,6 +23,7 @@ public class GroupData {
 	private ApprovalThreshold approvalThreshold;
 	private int minimumBlockDelay;
 	private int maximumBlockDelay;
+	public int memberCount;
 
 	/** Reference to CREATE_GROUP or UPDATE_GROUP transaction, used to rebuild group during orphaning. */
 	// No need to ever expose this via API

src/main/java/org/qortal/data/network/OnlineAccountData.java

@@ -5,6 +5,7 @@ import java.util.Arrays;
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
 import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlTransient;
 
 import org.qortal.account.PublicKeyAccount;
 
@@ -16,6 +17,9 @@ public class OnlineAccountData {
 	protected byte[] signature;
 	protected byte[] publicKey;
 
+	@XmlTransient
+	private int hash;
+
 	// Constructors
 
 	// necessary for JAXB serialization
@@ -62,20 +66,23 @@ public class OnlineAccountData {
 		if (otherOnlineAccountData.timestamp != this.timestamp)
 			return false;
 
-		// Signature more likely to be unique than public key
-		if (!Arrays.equals(otherOnlineAccountData.signature, this.signature))
-			return false;
-
 		if (!Arrays.equals(otherOnlineAccountData.publicKey, this.publicKey))
 			return false;
 
+		// We don't compare signature because it's not our remit to verify and newer aggregate signatures use random nonces
+
 		return true;
 	}
 
 	@Override
 	public int hashCode() {
-		// Pretty lazy implementation
-		return (int) this.timestamp;
+		int h = this.hash;
+		if (h == 0) {
+			this.hash = h = Long.hashCode(this.timestamp)
+					^ Arrays.hashCode(this.publicKey);
+			// We don't use signature because newer aggregate signatures use random nonces
+		}
+		return h;
 	}
 
 }

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

@@ -48,6 +48,7 @@ public class UpdateNameTransactionData extends TransactionData {
 
 	public void afterUnmarshal(Unmarshaller u, Object parent) {
 		this.creatorPublicKey = this.ownerPublicKey;
+		this.reducedNewName = this.newName != null ? Unicode.sanitize(this.newName) : null;
 	}
 
 	/** From repository */
@@ -62,7 +63,7 @@ public class UpdateNameTransactionData extends TransactionData {
 		this.nameReference = nameReference;
 	}
 
-	/** From network/API */
+	/** From network */
 	public UpdateNameTransactionData(BaseTransactionData baseTransactionData, String name, String newName, String newData) {
 		this(baseTransactionData, name, newName, newData, Unicode.sanitize(newName), null);
 	}

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

@@ -4,6 +4,7 @@ import java.awt.GraphicsEnvironment;
 import java.awt.image.BufferedImage;
 import java.io.IOException;
 import java.io.InputStream;
+import java.util.ServiceConfigurationError;
 
 import javax.imageio.ImageIO;
 import javax.swing.JOptionPane;
@@ -49,7 +50,7 @@ public class Gui {
 	protected static BufferedImage loadImage(String resourceName) {
 		try (InputStream in = Gui.class.getResourceAsStream("/images/" + resourceName)) {
 			return ImageIO.read(in);
-		} catch (IllegalArgumentException | IOException e) {
+		} catch (IllegalArgumentException | IOException | ServiceConfigurationError e) {
 			LOGGER.warn(String.format("Couldn't locate image resource \"images/%s\"", resourceName));
 			return null;
 		}

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

@@ -23,6 +23,7 @@ import java.util.List;
 
 import javax.swing.JDialog;
 import javax.swing.JMenuItem;
+import javax.swing.JOptionPane;
 import javax.swing.JPopupMenu;
 import javax.swing.SwingWorker;
 import javax.swing.event.PopupMenuEvent;
@@ -178,6 +179,14 @@ public class SysTray {
 			menu.add(syncTime);
 		}
 
+		JMenuItem about = new JMenuItem(Translator.INSTANCE.translate("SysTray", "BUILD_VERSION"));
+		about.addActionListener(actionEvent -> {
+			destroyHiddenDialog();
+
+			JOptionPane.showMessageDialog(null,"Qortal Core\n" + Translator.INSTANCE.translate("SysTray", "BUILD_VERSION") + ":\n" + Controller.getInstance().getVersionStringWithoutPrefix(),"Qortal Core",1);
+		});
+		menu.add(about);
+
 		JMenuItem exit = new JMenuItem(Translator.INSTANCE.translate("SysTray", "EXIT"));
 		exit.addActionListener(actionEvent -> {
 			destroyHiddenDialog();

src/main/java/org/qortal/naming/Name.java

@@ -195,7 +195,7 @@ public class Name {
 		this.repository.getNameRepository().save(this.nameData);
 	}
 
-	public void buy(BuyNameTransactionData buyNameTransactionData) throws DataException {
+	public void buy(BuyNameTransactionData buyNameTransactionData, boolean modifyBalances) throws DataException {
 		// Save previous name-changing reference in this transaction's data
 		// Caller is expected to save
 		buyNameTransactionData.setNameReference(this.nameData.getReference());
@@ -203,15 +203,20 @@ public class Name {
 		// Mark not for-sale but leave price in case we want to orphan
 		this.nameData.setIsForSale(false);
 
-		// Update seller's balance
-		Account seller = new Account(this.repository, this.nameData.getOwner());
-		seller.modifyAssetBalance(Asset.QORT, buyNameTransactionData.getAmount());
+		if (modifyBalances) {
+			// Update seller's balance
+			Account seller = new Account(this.repository, this.nameData.getOwner());
+			seller.modifyAssetBalance(Asset.QORT, buyNameTransactionData.getAmount());
+		}
 
 		// Set new owner
 		Account buyer = new PublicKeyAccount(this.repository, buyNameTransactionData.getBuyerPublicKey());
 		this.nameData.setOwner(buyer.getAddress());
-		// Update buyer's balance
-		buyer.modifyAssetBalance(Asset.QORT, - buyNameTransactionData.getAmount());
+
+		if (modifyBalances) {
+			// Update buyer's balance
+			buyer.modifyAssetBalance(Asset.QORT, -buyNameTransactionData.getAmount());
+		}
 
 		// Set name-changing reference to this transaction
 		this.nameData.setReference(buyNameTransactionData.getSignature());

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

@@ -13,7 +13,7 @@ import org.qortal.crypto.MemoryPoW;
 import org.qortal.network.message.ChallengeMessage;
 import org.qortal.network.message.HelloMessage;
 import org.qortal.network.message.Message;
-import org.qortal.network.message.Message.MessageType;
+import org.qortal.network.message.MessageType;
 import org.qortal.settings.Settings;
 import org.qortal.network.message.ResponseMessage;
 import org.qortal.utils.DaemonThreadFactory;

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

@@ -8,11 +8,13 @@ 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.network.PeerData;
 import org.qortal.data.transaction.TransactionData;
 import org.qortal.network.message.*;
+import org.qortal.network.task.*;
 import org.qortal.repository.DataException;
 import org.qortal.repository.Repository;
 import org.qortal.repository.RepositoryManager;
@@ -32,6 +34,7 @@ import java.nio.channels.*;
 import java.security.SecureRandom;
 import java.util.*;
 import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicLong;
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;
 import java.util.function.Function;
@@ -41,9 +44,8 @@ import java.util.stream.Collectors;
 // For managing peers
 public class Network {
     private static final Logger LOGGER = LogManager.getLogger(Network.class);
-    private static Network instance;
 
-    private static final int LISTEN_BACKLOG = 10;
+    private static final int LISTEN_BACKLOG = 5;
     /**
      * How long before retrying after a connection failure, in milliseconds.
      */
@@ -100,25 +102,38 @@ public class Network {
     private long nextDisconnectionCheck = 0L;
 
     private final List<PeerData> allKnownPeers = new ArrayList<>();
-    private final List<Peer> connectedPeers = new ArrayList<>();
+
+    /**
+     * Maintain two lists for each subset of peers:
+     * - A synchronizedList, to be modified when peers are added/removed
+     * - An immutable List, which is rebuilt automatically to mirror the synchronized list, and is then served to consumers
+     * This allows for thread safety without having to synchronize every time a thread requests a peer list
+     */
+    private final List<Peer> connectedPeers = Collections.synchronizedList(new ArrayList<>());
+    private List<Peer> immutableConnectedPeers = Collections.emptyList(); // always rebuilt from mutable, synced list above
+
+    private final List<Peer> handshakedPeers = Collections.synchronizedList(new ArrayList<>());
+    private List<Peer> immutableHandshakedPeers = Collections.emptyList(); // always rebuilt from mutable, synced list above
+
+    private final List<Peer> outboundHandshakedPeers = Collections.synchronizedList(new ArrayList<>());
+    private List<Peer> immutableOutboundHandshakedPeers = Collections.emptyList(); // always rebuilt from mutable, synced list above
+
+
     private final List<PeerAddress> selfPeers = new ArrayList<>();
 
     private final ExecuteProduceConsume networkEPC;
     private Selector channelSelector;
     private ServerSocketChannel serverChannel;
-    private Iterator<SelectionKey> channelIterator = null;
-
-    // volatile because value is updated inside any one of the EPC threads
-    private volatile long nextConnectTaskTimestamp = 0L; // ms - try first connect once NTP syncs
-
-    private final ExecutorService broadcastExecutor = Executors.newCachedThreadPool();
-    // volatile because value is updated inside any one of the EPC threads
-    private volatile long nextBroadcastTimestamp = 0L; // ms - try first broadcast once NTP syncs
+    private SelectionKey serverSelectionKey;
+    private final Set<SelectableChannel> channelsPendingWrite = ConcurrentHashMap.newKeySet();
 
     private final Lock mergePeersLock = new ReentrantLock();
 
     private List<String> ourExternalIpAddressHistory = new ArrayList<>();
     private String ourExternalIpAddress = null;
+    private int ourExternalPort = Settings.getInstance().getListenPort();
+
+    private volatile boolean isShuttingDown = false;
 
     // Constructors
 
@@ -153,7 +168,7 @@ public class Network {
             serverChannel.configureBlocking(false);
             serverChannel.setOption(StandardSocketOptions.SO_REUSEADDR, true);
             serverChannel.bind(endpoint, LISTEN_BACKLOG);
-            serverChannel.register(channelSelector, SelectionKey.OP_ACCEPT);
+            serverSelectionKey = serverChannel.register(channelSelector, SelectionKey.OP_ACCEPT);
         } catch (UnknownHostException e) {
             LOGGER.error("Can't bind listen socket to address {}", Settings.getInstance().getBindAddress());
             throw new IOException("Can't bind listen socket to address", e);
@@ -163,7 +178,8 @@ public class Network {
         }
 
         // Load all known peers from repository
-        synchronized (this.allKnownPeers) { List<String> fixedNetwork = Settings.getInstance().getFixedNetwork();
+        synchronized (this.allKnownPeers) {
+            List<String> fixedNetwork = Settings.getInstance().getFixedNetwork();
             if (fixedNetwork != null && !fixedNetwork.isEmpty()) {
                 Long addedWhen = NTP.getTime();
                 String addedBy = "fixedNetwork";
@@ -197,12 +213,16 @@ public class Network {
 
     // Getters / setters
 
-    public static synchronized Network getInstance() {
-        if (instance == null) {
-            instance = new Network();
-        }
+    private static class SingletonContainer {
+        private static final Network INSTANCE = new Network();
+    }
 
-        return instance;
+    public static Network getInstance() {
+        return SingletonContainer.INSTANCE;
+    }
+
+    public int getMaxPeers() {
+        return this.maxPeers;
     }
 
     public byte[] getMessageMagic() {
@@ -236,10 +256,33 @@ public class Network {
         }
     }
 
-    public List<Peer> getConnectedPeers() {
-        synchronized (this.connectedPeers) {
-            return new ArrayList<>(this.connectedPeers);
-        }
+    public List<Peer> getImmutableConnectedPeers() {
+        return this.immutableConnectedPeers;
+    }
+
+    public List<Peer> getImmutableConnectedDataPeers() {
+        return this.getImmutableConnectedPeers().stream()
+                .filter(p -> p.isDataPeer())
+                .collect(Collectors.toList());
+    }
+
+    public List<Peer> getImmutableConnectedNonDataPeers() {
+        return this.getImmutableConnectedPeers().stream()
+                .filter(p -> !p.isDataPeer())
+                .collect(Collectors.toList());
+    }
+
+    public void addConnectedPeer(Peer peer) {
+        this.connectedPeers.add(peer); // thread safe thanks to synchronized list
+        this.immutableConnectedPeers = List.copyOf(this.connectedPeers); // also thread safe thanks to synchronized collection's toArray() being fed to List.of(array)
+    }
+
+    public void removeConnectedPeer(Peer peer) {
+        // Firstly remove from handshaked peers
+        this.removeHandshakedPeer(peer);
+
+        this.connectedPeers.remove(peer); // thread safe thanks to synchronized list
+        this.immutableConnectedPeers = List.copyOf(this.connectedPeers); // also thread safe thanks to synchronized collection's toArray() being fed to List.of(array)
     }
 
     public List<PeerAddress> getSelfPeers() {
@@ -274,16 +317,14 @@ public class Network {
             }
 
             // Check if we're already connected to and handshaked with this peer
-            Peer connectedPeer = null;
-            synchronized (this.connectedPeers) {
-                connectedPeer = this.connectedPeers.stream()
+            Peer connectedPeer = this.getImmutableConnectedPeers().stream()
                         .filter(p -> p.getPeerData().getAddress().equals(peerAddress))
                         .findFirst()
                         .orElse(null);
-            }
+
             boolean isConnected = (connectedPeer != null);
 
-            boolean isHandshaked = this.getHandshakedPeers().stream()
+            boolean isHandshaked = this.getImmutableHandshakedPeers().stream()
                     .anyMatch(p -> p.getPeerData().getAddress().equals(peerAddress));
 
             if (isConnected && isHandshaked) {
@@ -297,6 +338,7 @@ public class Network {
                         // Add this signature to the list of pending requests for this peer
                         LOGGER.info("Making connection to peer {} to request files for signature {}...", peerAddressString, Base58.encode(signature));
                         Peer peer = new Peer(peerData);
+                        peer.setIsDataPeer(true);
                         peer.addPendingSignatureRequest(signature);
                         return this.connectPeer(peer);
                         // If connection (and handshake) is successful, data will automatically be requested
@@ -327,35 +369,61 @@ public class Network {
     /**
      * Returns list of connected peers that have completed handshaking.
      */
-    public List<Peer> getHandshakedPeers() {
-        synchronized (this.connectedPeers) {
-            return this.connectedPeers.stream()
-                    .filter(peer -> peer.getHandshakeStatus() == Handshake.COMPLETED)
-                    .collect(Collectors.toList());
+    public List<Peer> getImmutableHandshakedPeers() {
+        return this.immutableHandshakedPeers;
+    }
+
+    public void addHandshakedPeer(Peer peer) {
+        this.handshakedPeers.add(peer); // thread safe thanks to synchronized list
+        this.immutableHandshakedPeers = List.copyOf(this.handshakedPeers); // also thread safe thanks to synchronized collection's toArray() being fed to List.of(array)
+
+        // Also add to outbound handshaked peers cache
+        if (peer.isOutbound()) {
+            this.addOutboundHandshakedPeer(peer);
+        }
+    }
+
+    public void removeHandshakedPeer(Peer peer) {
+        this.handshakedPeers.remove(peer); // thread safe thanks to synchronized list
+        this.immutableHandshakedPeers = List.copyOf(this.handshakedPeers); // also thread safe thanks to synchronized collection's toArray() being fed to List.of(array)
+
+        // Also remove from outbound handshaked peers cache
+        if (peer.isOutbound()) {
+            this.removeOutboundHandshakedPeer(peer);
         }
     }
 
     /**
      * Returns list of peers we connected to that have completed handshaking.
      */
-    public List<Peer> getOutboundHandshakedPeers() {
-        synchronized (this.connectedPeers) {
-            return this.connectedPeers.stream()
-                    .filter(peer -> peer.isOutbound() && peer.getHandshakeStatus() == Handshake.COMPLETED)
-                    .collect(Collectors.toList());
+    public List<Peer> getImmutableOutboundHandshakedPeers() {
+        return this.immutableOutboundHandshakedPeers;
+    }
+
+    public void addOutboundHandshakedPeer(Peer peer) {
+        if (!peer.isOutbound()) {
+            return;
         }
+        this.outboundHandshakedPeers.add(peer); // thread safe thanks to synchronized list
+        this.immutableOutboundHandshakedPeers = List.copyOf(this.outboundHandshakedPeers); // also thread safe thanks to synchronized collection's toArray() being fed to List.of(array)
+    }
+
+    public void removeOutboundHandshakedPeer(Peer peer) {
+        if (!peer.isOutbound()) {
+            return;
+        }
+        this.outboundHandshakedPeers.remove(peer); // thread safe thanks to synchronized list
+        this.immutableOutboundHandshakedPeers = List.copyOf(this.outboundHandshakedPeers); // also thread safe thanks to synchronized collection's toArray() being fed to List.of(array)
     }
 
     /**
      * Returns first peer that has completed handshaking and has matching public key.
      */
     public Peer getHandshakedPeerWithPublicKey(byte[] publicKey) {
-        synchronized (this.connectedPeers) {
-            return this.connectedPeers.stream()
-                    .filter(peer -> peer.getHandshakeStatus() == Handshake.COMPLETED
-                            && Arrays.equals(peer.getPeersPublicKey(), publicKey))
-                    .findFirst().orElse(null);
-        }
+        return this.getImmutableConnectedPeers().stream()
+                .filter(peer -> peer.getHandshakeStatus() == Handshake.COMPLETED
+                        && Arrays.equals(peer.getPeersPublicKey(), publicKey))
+                .findFirst().orElse(null);
     }
 
     // Peer list filters
@@ -368,21 +436,15 @@ public class Network {
         return this.selfPeers.stream().anyMatch(selfPeer -> selfPeer.equals(peerAddress));
     };
 
-    /**
-     * Must be inside <tt>synchronized (this.connectedPeers) {...}</tt>
-     */
     private final Predicate<PeerData> isConnectedPeer = peerData -> {
         PeerAddress peerAddress = peerData.getAddress();
-        return this.connectedPeers.stream().anyMatch(peer -> peer.getPeerData().getAddress().equals(peerAddress));
+        return this.getImmutableConnectedPeers().stream().anyMatch(peer -> peer.getPeerData().getAddress().equals(peerAddress));
     };
 
-    /**
-     * Must be inside <tt>synchronized (this.connectedPeers) {...}</tt>
-     */
     private final Predicate<PeerData> isResolvedAsConnectedPeer = peerData -> {
         try {
             InetSocketAddress resolvedSocketAddress = peerData.getAddress().toSocketAddress();
-            return this.connectedPeers.stream()
+            return this.getImmutableConnectedPeers().stream()
                     .anyMatch(peer -> peer.getResolvedAddress().equals(resolvedSocketAddress));
         } catch (UnknownHostException e) {
             // Can't resolve - no point even trying to connect
@@ -407,6 +469,13 @@ public class Network {
 
     class NetworkProcessor extends ExecuteProduceConsume {
 
+        private final Logger LOGGER = LogManager.getLogger(NetworkProcessor.class);
+
+        private final AtomicLong nextConnectTaskTimestamp = new AtomicLong(0L); // ms - try first connect once NTP syncs
+        private final AtomicLong nextBroadcastTimestamp = new AtomicLong(0L); // ms - try first broadcast once NTP syncs
+
+        private Iterator<SelectionKey> channelIterator = null;
+
         NetworkProcessor(ExecutorService executor) {
             super(executor);
         }
@@ -448,51 +517,31 @@ public class Network {
         }
 
         private Task maybeProducePeerMessageTask() {
-            for (Peer peer : getConnectedPeers()) {
-                Task peerTask = peer.getMessageTask();
-                if (peerTask != null) {
-                    return peerTask;
-                }
-            }
-
-            return null;
+            return getImmutableConnectedPeers().stream()
+                    .map(Peer::getMessageTask)
+                    .filter(Objects::nonNull)
+                    .findFirst()
+                    .orElse(null);
         }
 
         private Task maybeProducePeerPingTask(Long now) {
-            // Ask connected peers whether they need a ping
-            for (Peer peer : getHandshakedPeers()) {
-                Task peerTask = peer.getPingTask(now);
-                if (peerTask != null) {
-                    return peerTask;
-                }
-            }
-
-            return null;
-        }
-
-        class PeerConnectTask implements ExecuteProduceConsume.Task {
-            private final Peer peer;
-
-            PeerConnectTask(Peer peer) {
-                this.peer = peer;
-            }
-
-            @Override
-            public void perform() throws InterruptedException {
-                connectPeer(peer);
-            }
+            return getImmutableHandshakedPeers().stream()
+                    .map(peer -> peer.getPingTask(now))
+                    .filter(Objects::nonNull)
+                    .findFirst()
+                    .orElse(null);
         }
 
         private Task maybeProduceConnectPeerTask(Long now) throws InterruptedException {
-            if (now == null || now < nextConnectTaskTimestamp) {
+            if (now == null || now < nextConnectTaskTimestamp.get()) {
                 return null;
             }
 
-            if (getOutboundHandshakedPeers().size() >= minOutboundPeers) {
+            if (getImmutableOutboundHandshakedPeers().size() >= minOutboundPeers) {
                 return null;
             }
 
-            nextConnectTaskTimestamp = now + 1000L;
+            nextConnectTaskTimestamp.set(now + 1000L);
 
             Peer targetPeer = getConnectablePeer(now);
             if (targetPeer == null) {
@@ -504,66 +553,15 @@ public class Network {
         }
 
         private Task maybeProduceBroadcastTask(Long now) {
-            if (now == null || now < nextBroadcastTimestamp) {
+            if (now == null || now < nextBroadcastTimestamp.get()) {
                 return null;
             }
 
-            nextBroadcastTimestamp = now + BROADCAST_INTERVAL;
-            return () -> Controller.getInstance().doNetworkBroadcast();
-        }
-
-        class ChannelTask implements ExecuteProduceConsume.Task {
-            private final SelectionKey selectionKey;
-
-            ChannelTask(SelectionKey selectionKey) {
-                this.selectionKey = selectionKey;
-            }
-
-            @Override
-            public void perform() throws InterruptedException {
-                try {
-                    LOGGER.trace("Thread {} has pending channel: {}, with ops {}",
-                            Thread.currentThread().getId(), selectionKey.channel(), selectionKey.readyOps());
-
-                    // process pending channel task
-                    if (selectionKey.isReadable()) {
-                        connectionRead((SocketChannel) selectionKey.channel());
-                    } else if (selectionKey.isAcceptable()) {
-                        acceptConnection((ServerSocketChannel) selectionKey.channel());
-                    }
-
-                    LOGGER.trace("Thread {} processed channel: {}",
-                            Thread.currentThread().getId(), selectionKey.channel());
-                } catch (CancelledKeyException e) {
-                    LOGGER.trace("Thread {} encountered cancelled channel: {}",
-                            Thread.currentThread().getId(), selectionKey.channel());
-                }
-            }
-
-            private void connectionRead(SocketChannel socketChannel) {
-                Peer peer = getPeerFromChannel(socketChannel);
-                if (peer == null) {
-                    return;
-                }
-
-                try {
-                    peer.readChannel();
-                } catch (IOException e) {
-                    if (e.getMessage() != null && e.getMessage().toLowerCase().contains("connection reset")) {
-                        peer.disconnect("Connection reset");
-                        return;
-                    }
-
-                    LOGGER.trace("[{}] Network thread {} encountered I/O error: {}", peer.getPeerConnectionId(),
-                            Thread.currentThread().getId(), e.getMessage(), e);
-                    peer.disconnect("I/O error");
-                }
-            }
+            nextBroadcastTimestamp.set(now + BROADCAST_INTERVAL);
+            return new BroadcastTask();
         }
 
         private Task maybeProduceChannelTask(boolean canBlock) throws InterruptedException {
-            final SelectionKey nextSelectionKey;
-
             // Synchronization here to enforce thread-safety on channelIterator
             synchronized (channelSelector) {
                 // anything to do?
@@ -584,92 +582,73 @@ public class Network {
                     }
 
                     channelIterator = channelSelector.selectedKeys().iterator();
+                    LOGGER.trace("Thread {}, after {} select, channelIterator now {}",
+                            Thread.currentThread().getId(),
+                            canBlock ? "blocking": "non-blocking",
+                            channelIterator);
                 }
 
-                if (channelIterator.hasNext()) {
-                    nextSelectionKey = channelIterator.next();
-                    channelIterator.remove();
-                } else {
-                    nextSelectionKey = null;
+                if (!channelIterator.hasNext()) {
                     channelIterator = null; // Nothing to do so reset iterator to cause new select
+
+                    LOGGER.trace("Thread {}, channelIterator now null", Thread.currentThread().getId());
+                    return null;
                 }
 
-                LOGGER.trace("Thread {}, nextSelectionKey {}, channelIterator now {}",
-                        Thread.currentThread().getId(), nextSelectionKey, channelIterator);
-            }
+                final SelectionKey nextSelectionKey = channelIterator.next();
+                channelIterator.remove();
 
-            if (nextSelectionKey == null) {
-                return null;
-            }
+                // Just in case underlying socket channel already closed elsewhere, etc.
+                if (!nextSelectionKey.isValid())
+                    return null;
 
-            return new ChannelTask(nextSelectionKey);
-        }
-    }
+                LOGGER.trace("Thread {}, nextSelectionKey {}", Thread.currentThread().getId(), nextSelectionKey);
 
-    private void acceptConnection(ServerSocketChannel serverSocketChannel) throws InterruptedException {
-        SocketChannel socketChannel;
+                SelectableChannel socketChannel = nextSelectionKey.channel();
 
-        try {
-            socketChannel = serverSocketChannel.accept();
-        } catch (IOException e) {
-            return;
-        }
-
-        // No connection actually accepted?
-        if (socketChannel == null) {
-            return;
-        }
-        PeerAddress address = PeerAddress.fromSocket(socketChannel.socket());
-        List<String> fixedNetwork = Settings.getInstance().getFixedNetwork();
-        if (fixedNetwork != null && !fixedNetwork.isEmpty() && ipNotInFixedList(address, fixedNetwork)) {
-            try {
-                LOGGER.debug("Connection discarded from peer {} as not in the fixed network list", address);
-                socketChannel.close();
-            } catch (IOException e) {
-                // IGNORE
-            }
-            return;
-        }
-
-        final Long now = NTP.getTime();
-        Peer newPeer;
-
-        try {
-            if (now == null) {
-                LOGGER.debug("Connection discarded from peer {} due to lack of NTP sync", address);
-                socketChannel.close();
-                return;
-            }
-
-            synchronized (this.connectedPeers) {
-                if (connectedPeers.size() >= maxPeers) {
-                    // We have enough peers
-                    LOGGER.debug("Connection discarded from peer {} because the server is full", address);
-                    socketChannel.close();
-                    return;
-                }
-
-                LOGGER.debug("Connection accepted from peer {}", address);
-
-                newPeer = new Peer(socketChannel, channelSelector);
-                this.connectedPeers.add(newPeer);
-            }
-        } catch (IOException e) {
-            if (socketChannel.isOpen()) {
                 try {
-                    LOGGER.debug("Connection failed from peer {} while connecting/closing", address);
-                    socketChannel.close();
-                } catch (IOException ce) {
-                    // Couldn't close?
+                    if (nextSelectionKey.isReadable()) {
+                        clearInterestOps(nextSelectionKey, SelectionKey.OP_READ);
+                        Peer peer = getPeerFromChannel((SocketChannel) socketChannel);
+                        if (peer == null)
+                            return null;
+
+                        return new ChannelReadTask((SocketChannel) socketChannel, peer);
+                    }
+
+                    if (nextSelectionKey.isWritable()) {
+                        clearInterestOps(nextSelectionKey, SelectionKey.OP_WRITE);
+                        Peer peer = getPeerFromChannel((SocketChannel) socketChannel);
+                        if (peer == null)
+                            return null;
+
+                        // Any thread that queues a message to send can set OP_WRITE,
+                        // but we only allow one pending/active ChannelWriteTask per Peer
+                        if (!channelsPendingWrite.add(socketChannel))
+                            return null;
+
+                        return new ChannelWriteTask((SocketChannel) socketChannel, peer);
+                    }
+
+                    if (nextSelectionKey.isAcceptable()) {
+                        clearInterestOps(nextSelectionKey, SelectionKey.OP_ACCEPT);
+                        return new ChannelAcceptTask((ServerSocketChannel) socketChannel);
+                    }
+                } catch (CancelledKeyException e) {
+                    /*
+                     * Sometimes nextSelectionKey is cancelled / becomes invalid between the isValid() test at line 586
+                     * and later calls to isReadable() / isWritable() / isAcceptable() which themselves call isValid()!
+                     * Those isXXXable() calls could throw CancelledKeyException, so we catch it here and return null.
+                     */
+                    return null;
                 }
             }
-            return;
-        }
 
-        this.onPeerReady(newPeer);
+            return null;
+        }
     }
 
-    private boolean ipNotInFixedList(PeerAddress address, List<String> fixedNetwork) {
+    public boolean ipNotInFixedList(PeerAddress address, List<String> fixedNetwork) {
         for (String ipAddress : fixedNetwork) {
             String[] bits = ipAddress.split(":");
             if (bits.length >= 1 && bits.length <= 2 && address.getHost().equals(bits[0])) {
@@ -701,16 +680,15 @@ public class Network {
                 peers.removeIf(isSelfPeer);
             }
 
-            synchronized (this.connectedPeers) {
-                // Don't consider already connected peers (simple address match)
-                peers.removeIf(isConnectedPeer);
+            // Don't consider already connected peers (simple address match)
+            peers.removeIf(isConnectedPeer);
 
-                // Don't consider already connected peers (resolved address match)
-                // XXX This might be too slow if we end up waiting a long time for hostnames to resolve via DNS
-                peers.removeIf(isResolvedAsConnectedPeer);
+            // Don't consider already connected peers (resolved address match)
+            // Disabled because this might be too slow if we end up waiting a long time for hostnames to resolve via DNS
+            // Which is ok because duplicate connections to the same peer are handled during handshaking
+            // peers.removeIf(isResolvedAsConnectedPeer);
 
-                this.checkLongestConnection(now);
-            }
+            this.checkLongestConnection(now);
 
             // Any left?
             if (peers.isEmpty()) {
@@ -723,6 +701,7 @@ public class Network {
             // Pick candidate
             PeerData peerData = peers.get(peerIndex);
             Peer newPeer = new Peer(peerData);
+            newPeer.setIsDataPeer(false);
 
             // Update connection attempt info
             peerData.setLastAttempted(now);
@@ -738,8 +717,12 @@ public class Network {
         }
     }
 
-    private boolean connectPeer(Peer newPeer) throws InterruptedException {
-        SocketChannel socketChannel = newPeer.connect(this.channelSelector);
+    public boolean connectPeer(Peer newPeer) throws InterruptedException {
+        // Also checked before creating PeerConnectTask
+        if (getImmutableOutboundHandshakedPeers().size() >= minOutboundPeers)
+            return false;
+
+        SocketChannel socketChannel = newPeer.connect();
         if (socketChannel == null) {
             return false;
         }
@@ -748,21 +731,16 @@ public class Network {
             return false;
         }
 
-        synchronized (this.connectedPeers) {
-            this.connectedPeers.add(newPeer);
-        }
-
+        this.addConnectedPeer(newPeer);
         this.onPeerReady(newPeer);
 
         return true;
     }
 
-    private Peer getPeerFromChannel(SocketChannel socketChannel) {
-        synchronized (this.connectedPeers) {
-            for (Peer peer : this.connectedPeers) {
-                if (peer.getSocketChannel() == socketChannel) {
-                    return peer;
-                }
+    public Peer getPeerFromChannel(SocketChannel socketChannel) {
+        for (Peer peer : this.getImmutableConnectedPeers()) {
+            if (peer.getSocketChannel() == socketChannel) {
+                return peer;
             }
         }
 
@@ -775,7 +753,7 @@ public class Network {
         }
 
         // Find peers that have reached their maximum connection age, and disconnect them
-        List<Peer> peersToDisconnect = this.connectedPeers.stream()
+        List<Peer> peersToDisconnect = this.getImmutableConnectedPeers().stream()
                 .filter(peer -> !peer.isSyncInProgress())
                 .filter(peer -> peer.hasReachedMaxConnectionAge())
                 .collect(Collectors.toList());
@@ -792,7 +770,74 @@ public class Network {
         nextDisconnectionCheck = now + DISCONNECTION_CHECK_INTERVAL;
     }
 
-    // Peer callbacks
+    // SocketChannel interest-ops manipulations
+
+    private static final String[] OP_NAMES = new String[SelectionKey.OP_ACCEPT * 2];
+    static {
+        for (int i = 0; i < OP_NAMES.length; i++) {
+            StringJoiner joiner = new StringJoiner(",");
+
+            if ((i & SelectionKey.OP_READ) != 0) joiner.add("OP_READ");
+            if ((i & SelectionKey.OP_WRITE) != 0) joiner.add("OP_WRITE");
+            if ((i & SelectionKey.OP_CONNECT) != 0) joiner.add("OP_CONNECT");
+            if ((i & SelectionKey.OP_ACCEPT) != 0) joiner.add("OP_ACCEPT");
+
+            OP_NAMES[i] = joiner.toString();
+        }
+    }
+
+    public void clearInterestOps(SelectableChannel socketChannel, int interestOps) {
+        SelectionKey selectionKey = socketChannel.keyFor(channelSelector);
+        if (selectionKey == null)
+            return;
+
+        clearInterestOps(selectionKey, interestOps);
+    }
+
+    private void clearInterestOps(SelectionKey selectionKey, int interestOps) {
+        if (!selectionKey.channel().isOpen())
+            return;
+
+        LOGGER.trace("Thread {} clearing {} interest-ops on channel: {}",
+                Thread.currentThread().getId(),
+                OP_NAMES[interestOps],
+                selectionKey.channel());
+
+        selectionKey.interestOpsAnd(~interestOps);
+    }
+
+    public void setInterestOps(SelectableChannel socketChannel, int interestOps) {
+        SelectionKey selectionKey = socketChannel.keyFor(channelSelector);
+        if (selectionKey == null) {
+            try {
+                selectionKey = socketChannel.register(this.channelSelector, interestOps);
+            } catch (ClosedChannelException e) {
+                // Channel already closed so ignore
+                return;
+            }
+            // Fall-through to allow logging
+        }
+
+        setInterestOps(selectionKey, interestOps);
+    }
+
+    private void setInterestOps(SelectionKey selectionKey, int interestOps) {
+        if (!selectionKey.channel().isOpen())
+            return;
+
+        LOGGER.trace("Thread {} setting {} interest-ops on channel: {}",
+                Thread.currentThread().getId(),
+                OP_NAMES[interestOps],
+                selectionKey.channel());
+
+        selectionKey.interestOpsOr(interestOps);
+    }
+
+    // Peer / Task callbacks
+
+    public void notifyChannelNotWriting(SelectableChannel socketChannel) {
+        this.channelsPendingWrite.remove(socketChannel);
+    }
 
     protected void wakeupChannelSelector() {
         this.channelSelector.wakeup();
@@ -818,17 +863,32 @@ public class Network {
     }
 
     public void onDisconnect(Peer peer) {
-        // Notify Controller
-        Controller.getInstance().onPeerDisconnect(peer);
         if (peer.getConnectionEstablishedTime() > 0L) {
             LOGGER.debug("[{}] Disconnected from peer {}", peer.getPeerConnectionId(), peer);
         } else {
             LOGGER.debug("[{}] Failed to connect to peer {}", peer.getPeerConnectionId(), peer);
         }
 
-        synchronized (this.connectedPeers) {
-            this.connectedPeers.remove(peer);
+        this.removeConnectedPeer(peer);
+        this.channelsPendingWrite.remove(peer.getSocketChannel());
+
+        if (this.isShuttingDown)
+            // No need to do any further processing, like re-enabling listen socket or notifying Controller
+            return;
+
+        if (getImmutableConnectedPeers().size() < maxPeers - 1
+                && serverSelectionKey.isValid()
+                && (serverSelectionKey.interestOps() & SelectionKey.OP_ACCEPT) == 0) {
+            try {
+                LOGGER.debug("Re-enabling accepting incoming connections because the server is not longer full");
+                setInterestOps(serverSelectionKey, SelectionKey.OP_ACCEPT);
+            } catch (CancelledKeyException e) {
+                LOGGER.error("Failed to re-enable accepting of incoming connections: {}", e.getMessage());
+            }
         }
+
+        // Notify Controller
+        Controller.getInstance().onPeerDisconnect(peer);
     }
 
     public void peerMisbehaved(Peer peer) {
@@ -989,6 +1049,9 @@ public class Network {
             return;
         }
 
+        // Add to handshaked peers cache
+        this.addHandshakedPeer(peer);
+
         // Make a note that we've successfully completed handshake (and when)
         peer.getPeerData().setLastConnected(NTP.getTime());
 
@@ -1023,11 +1086,13 @@ public class Network {
         // (If inbound sent anything here, it's possible it could be processed out-of-order with handshake message).
 
         if (peer.isOutbound()) {
-            // Send our height
-            Message heightMessage = buildHeightMessage(peer, Controller.getInstance().getChainTip());
-            if (!peer.sendMessage(heightMessage)) {
-                peer.disconnect("failed to send height/info");
-                return;
+            if (!Settings.getInstance().isLite()) {
+                // Send our height
+                Message heightMessage = buildHeightMessage(peer, Controller.getInstance().getChainTip());
+                if (!peer.sendMessage(heightMessage)) {
+                    peer.disconnect("failed to send height/info");
+                    return;
+                }
             }
 
             // Send our peers list
@@ -1128,6 +1193,7 @@ public class Network {
             return;
         }
         String host = parts[0];
+        
         try {
             InetAddress addr = InetAddress.getByName(host);
             if (addr.isAnyLocalAddress() || addr.isSiteLocalAddress()) {
@@ -1138,6 +1204,9 @@ public class Network {
             return;
         }
 
+        // Keep track of the port
+        this.ourExternalPort = Integer.parseInt(parts[1]);
+
         // Add to the list
         this.ourExternalIpAddressHistory.add(host);
 
@@ -1191,8 +1260,6 @@ public class Network {
 
     public void onExternalIpUpdate(String ipAddress) {
         LOGGER.info("External IP address updated to {}", ipAddress);
-
-        //ArbitraryDataManager.getInstance().broadcastHostedSignatureList();
     }
 
     public String getOurExternalIpAddress() {
@@ -1200,6 +1267,14 @@ public class Network {
         return this.ourExternalIpAddress;
     }
 
+    public String getOurExternalIpAddressAndPort() {
+        String ipAddress = this.getOurExternalIpAddress();
+        if (ipAddress == null) {
+            return null;
+        }
+        return String.format("%s:%d", ipAddress, this.ourExternalPort);
+    }
+
 
     // Peer-management calls
 
@@ -1241,7 +1316,7 @@ public class Network {
             }
         }
 
-        for (Peer peer : this.getConnectedPeers()) {
+        for (Peer peer : this.getImmutableConnectedPeers()) {
             peer.disconnect("to be forgotten");
         }
 
@@ -1253,8 +1328,9 @@ public class Network {
         try {
             InetSocketAddress knownAddress = peerAddress.toSocketAddress();
 
-            List<Peer> peers = this.getConnectedPeers();
-            peers.removeIf(peer -> !Peer.addressEquals(knownAddress, peer.getResolvedAddress()));
+            List<Peer> peers = this.getImmutableConnectedPeers().stream()
+                    .filter(peer -> Peer.addressEquals(knownAddress, peer.getResolvedAddress()))
+                    .collect(Collectors.toList());
 
             for (Peer peer : peers) {
                 peer.disconnect("to be forgotten");
@@ -1273,7 +1349,8 @@ public class Network {
         }
 
         // Disconnect peers that are stuck during handshake
-        List<Peer> handshakePeers = this.getConnectedPeers();
+        // Needs a mutable copy of the unmodifiableList
+        List<Peer> handshakePeers = new ArrayList<>(this.getImmutableConnectedPeers());
 
         // Disregard peers that have completed handshake or only connected recently
         handshakePeers.removeIf(peer -> peer.getHandshakeStatus() == Handshake.COMPLETED
@@ -1315,9 +1392,7 @@ public class Network {
                 peers.removeIf(isNotOldPeer);
 
                 // Don't consider already connected peers (simple address match)
-                synchronized (this.connectedPeers) {
-                    peers.removeIf(isConnectedPeer);
-                }
+                peers.removeIf(isConnectedPeer);
 
                 for (PeerData peerData : peers) {
                     LOGGER.debug("Deleting old peer {} from repository", peerData.getAddress().toString());
@@ -1413,54 +1488,27 @@ public class Network {
     }
 
     public void broadcast(Function<Peer, Message> peerMessageBuilder) {
-        class Broadcaster implements Runnable {
-            private final Random random = new Random();
+        for (Peer peer : getImmutableHandshakedPeers()) {
+            if (this.isShuttingDown)
+                return;
 
-            private List<Peer> targetPeers;
-            private Function<Peer, Message> peerMessageBuilder;
+            Message message = peerMessageBuilder.apply(peer);
 
-            Broadcaster(List<Peer> targetPeers, Function<Peer, Message> peerMessageBuilder) {
-                this.targetPeers = targetPeers;
-                this.peerMessageBuilder = peerMessageBuilder;
+            if (message == null) {
+                continue;
             }
 
-            @Override
-            public void run() {
-                Thread.currentThread().setName("Network Broadcast");
-
-                for (Peer peer : targetPeers) {
-                    // Very short sleep to reduce strain, improve multi-threading and catch interrupts
-                    try {
-                        Thread.sleep(random.nextInt(20) + 20L);
-                    } catch (InterruptedException e) {
-                        break;
-                    }
-
-                    Message message = peerMessageBuilder.apply(peer);
-
-                    if (message == null) {
-                        continue;
-                    }
-
-                    if (!peer.sendMessage(message)) {
-                        peer.disconnect("failed to broadcast message");
-                    }
-                }
-
-                Thread.currentThread().setName("Network Broadcast (dormant)");
+            if (!peer.sendMessage(message)) {
+                peer.disconnect("failed to broadcast message");
             }
         }
-
-        try {
-            broadcastExecutor.execute(new Broadcaster(this.getHandshakedPeers(), peerMessageBuilder));
-        } catch (RejectedExecutionException e) {
-            // Can't execute - probably because we're shutting down, so ignore
-        }
     }
 
     // Shutdown
 
     public void shutdown() {
+        this.isShuttingDown = true;
+
         // Close listen socket to prevent more incoming connections
         if (this.serverChannel.isOpen()) {
             try {
@@ -1479,18 +1527,8 @@ public class Network {
             LOGGER.warn("Interrupted while waiting for networking threads to terminate");
         }
 
-        // Stop broadcasts
-        this.broadcastExecutor.shutdownNow();
-        try {
-            if (!this.broadcastExecutor.awaitTermination(1000, TimeUnit.MILLISECONDS)) {
-                LOGGER.warn("Broadcast threads failed to terminate");
-            }
-        } catch (InterruptedException e) {
-            LOGGER.warn("Interrupted while waiting for broadcast threads failed to terminate");
-        }
-
         // Close all peer connections
-        for (Peer peer : this.getConnectedPeers()) {
+        for (Peer peer : this.getImmutableConnectedPeers()) {
             peer.shutdown();
         }
     }

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

@@ -11,25 +11,24 @@ import org.qortal.data.network.PeerChainTipData;
 import org.qortal.data.network.PeerData;
 import org.qortal.network.message.ChallengeMessage;
 import org.qortal.network.message.Message;
-import org.qortal.network.message.Message.MessageException;
-import org.qortal.network.message.Message.MessageType;
-import org.qortal.network.message.PingMessage;
+import org.qortal.network.message.MessageException;
+import org.qortal.network.message.MessageType;
+import org.qortal.network.task.MessageTask;
+import org.qortal.network.task.PingTask;
 import org.qortal.settings.Settings;
-import org.qortal.utils.ExecuteProduceConsume;
+import org.qortal.utils.ExecuteProduceConsume.Task;
 import org.qortal.utils.NTP;
 
 import java.io.IOException;
 import java.net.*;
 import java.nio.ByteBuffer;
 import java.nio.channels.SelectionKey;
-import java.nio.channels.Selector;
 import java.nio.channels.SocketChannel;
 import java.security.SecureRandom;
 import java.util.*;
-import java.util.concurrent.ArrayBlockingQueue;
-import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.LinkedBlockingQueue;
-import java.util.concurrent.TimeUnit;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.LongAccumulator;
+import java.util.concurrent.atomic.LongAdder;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
@@ -48,9 +47,9 @@ public class Peer {
     private static final int RESPONSE_TIMEOUT = 3000; // ms
 
     /**
-     * Maximum time to wait for a peer to respond with blocks (ms)
+     * Maximum time to wait for a message to be added to sendQueue (ms)
      */
-    public static final int FETCH_BLOCKS_TIMEOUT = 10000;
+    private static final int QUEUE_TIMEOUT = 1000; // ms
 
     /**
      * Interval between PING messages to a peer. (ms)
@@ -68,13 +67,22 @@ public class Peer {
      */
     private boolean isLocal;
 
+    /**
+     * True if connected for the purposes of transfering specific QDN data
+     */
+    private boolean isDataPeer;
+
     private final UUID peerConnectionId = UUID.randomUUID();
     private final Object byteBufferLock = new Object();
     private ByteBuffer byteBuffer;
-
     private Map<Integer, BlockingQueue<Message>> replyQueues;
     private LinkedBlockingQueue<Message> pendingMessages;
 
+    private TransferQueue<Message> sendQueue;
+    private ByteBuffer outputBuffer;
+    private String outputMessageType;
+    private int outputMessageId;
+
     /**
      * True if we created connection to peer, false if we accepted incoming connection from peer.
      */
@@ -98,7 +106,7 @@ public class Peer {
     /**
      * When last PING message was sent, or null if pings not started yet.
      */
-    private Long lastPingSent;
+    private Long lastPingSent = null;
 
     byte[] ourChallenge;
 
@@ -147,6 +155,16 @@ public class Peer {
      */
     private CommonBlockData commonBlockData;
 
+    // Message stats
+
+    private static class MessageStats {
+        public final LongAdder count = new LongAdder();
+        public final LongAdder totalBytes = new LongAdder();
+    }
+
+    private final Map<MessageType, MessageStats> receivedMessageStats = new ConcurrentHashMap<>();
+    private final Map<MessageType, MessageStats> sentMessageStats = new ConcurrentHashMap<>();
+
     // Constructors
 
     /**
@@ -160,10 +178,10 @@ public class Peer {
     /**
      * Construct Peer using existing, connected socket
      */
-    public Peer(SocketChannel socketChannel, Selector channelSelector) throws IOException {
+    public Peer(SocketChannel socketChannel) throws IOException {
         this.isOutbound = false;
         this.socketChannel = socketChannel;
-        sharedSetup(channelSelector);
+        sharedSetup();
 
         this.resolvedAddress = ((InetSocketAddress) socketChannel.socket().getRemoteSocketAddress());
         this.isLocal = isAddressLocal(this.resolvedAddress.getAddress());
@@ -194,6 +212,14 @@ public class Peer {
         return this.isOutbound;
     }
 
+    public boolean isDataPeer() {
+        return isDataPeer;
+    }
+
+    public void setIsDataPeer(boolean isDataPeer) {
+        this.isDataPeer = isDataPeer;
+    }
+
     public Handshake getHandshakeStatus() {
         synchronized (this.handshakingLock) {
             return this.handshakeStatus;
@@ -211,6 +237,11 @@ public class Peer {
     }
 
     private void generateRandomMaxConnectionAge() {
+        if (this.maxConnectionAge > 0L) {
+            // Already generated, so we don't want to overwrite the existing value
+            return;
+        }
+
         // Retrieve the min and max connection time from the settings, and calculate the range
         final int minPeerConnectionTime = Settings.getInstance().getMinPeerConnectionTime();
         final int maxPeerConnectionTime = Settings.getInstance().getMaxPeerConnectionTime();
@@ -276,7 +307,7 @@ public class Peer {
         }
     }
 
-    protected void setLastPing(long lastPing) {
+    public void setLastPing(long lastPing) {
         synchronized (this.peerInfoLock) {
             this.lastPing = lastPing;
         }
@@ -346,12 +377,6 @@ public class Peer {
         }
     }
 
-    protected void queueMessage(Message message) {
-        if (!this.pendingMessages.offer(message)) {
-            LOGGER.info("[{}] No room to queue message from peer {} - discarding", this.peerConnectionId, this);
-        }
-    }
-
     public boolean isSyncInProgress() {
         return this.syncInProgress;
     }
@@ -396,13 +421,14 @@ public class Peer {
 
     // Processing
 
-    private void sharedSetup(Selector channelSelector) throws IOException {
+    private void sharedSetup() throws IOException {
         this.connectionTimestamp = NTP.getTime();
         this.socketChannel.setOption(StandardSocketOptions.TCP_NODELAY, true);
         this.socketChannel.configureBlocking(false);
-        this.socketChannel.register(channelSelector, SelectionKey.OP_READ);
+        Network.getInstance().setInterestOps(this.socketChannel, SelectionKey.OP_READ);
         this.byteBuffer = null; // Defer allocation to when we need it, to save memory. Sorry GC!
-        this.replyQueues = Collections.synchronizedMap(new HashMap<Integer, BlockingQueue<Message>>());
+        this.sendQueue = new LinkedTransferQueue<>();
+        this.replyQueues = new ConcurrentHashMap<>();
         this.pendingMessages = new LinkedBlockingQueue<>();
 
         Random random = new SecureRandom();
@@ -410,7 +436,7 @@ public class Peer {
         random.nextBytes(this.ourChallenge);
     }
 
-    public SocketChannel connect(Selector channelSelector) {
+    public SocketChannel connect() {
         LOGGER.trace("[{}] Connecting to peer {}", this.peerConnectionId, this);
 
         try {
@@ -418,6 +444,8 @@ public class Peer {
             this.isLocal = isAddressLocal(this.resolvedAddress.getAddress());
 
             this.socketChannel = SocketChannel.open();
+            InetAddress bindAddr = InetAddress.getByName(Settings.getInstance().getBindAddress());
+            this.socketChannel.socket().bind(new InetSocketAddress(bindAddr, 0));
             this.socketChannel.socket().connect(resolvedAddress, CONNECT_TIMEOUT);
         } catch (SocketTimeoutException e) {
             LOGGER.trace("[{}] Connection timed out to peer {}", this.peerConnectionId, this);
@@ -432,7 +460,7 @@ public class Peer {
 
         try {
             LOGGER.debug("[{}] Connected to peer {}", this.peerConnectionId, this);
-            sharedSetup(channelSelector);
+            sharedSetup();
             return socketChannel;
         } catch (IOException e) {
             LOGGER.trace("[{}] Post-connection setup failed, peer {}", this.peerConnectionId, this);
@@ -450,7 +478,7 @@ public class Peer {
      *
      * @throws IOException If this channel is not yet connected
      */
-    protected void readChannel() throws IOException {
+    public void readChannel() throws IOException {
         synchronized (this.byteBufferLock) {
             while (true) {
                 if (!this.socketChannel.isOpen() || this.socketChannel.socket().isClosed()) {
@@ -526,11 +554,22 @@ public class Peer {
                     // Tidy up buffers:
                     this.byteBuffer.flip();
                     // Read-only, flipped buffer's position will be after end of message, so copy that
+                    long messageByteSize = readOnlyBuffer.position();
                     this.byteBuffer.position(readOnlyBuffer.position());
                     // Copy bytes after read message to front of buffer,
                     // adjusting position accordingly, reset limit to capacity
                     this.byteBuffer.compact();
 
+                    // Record message stats
+                    MessageStats messageStats = this.receivedMessageStats.computeIfAbsent(message.getType(), k -> new MessageStats());
+                    // Ideally these two operations would be atomic, we could pack 'count' in top X bits of the 64-bit long, but meh
+                    messageStats.count.increment();
+                    messageStats.totalBytes.add(messageByteSize);
+
+                    // Unsupported message type? Discard with no further processing
+                    if (message.getType() == MessageType.UNSUPPORTED)
+                        continue;
+
                     BlockingQueue<Message> queue = this.replyQueues.get(message.getId());
                     if (queue != null) {
                         // Adding message to queue will unblock thread waiting for response
@@ -556,7 +595,73 @@ public class Peer {
         }
     }
 
-    protected ExecuteProduceConsume.Task getMessageTask() {
+    /** Maybe send some pending outgoing messages.
+     *
+     * @return true if more data is pending to be sent
+     */
+    public boolean writeChannel() throws IOException {
+        // It is the responsibility of ChannelWriteTask's producer to produce only one call to writeChannel() at a time
+
+        while (true) {
+            // If output byte buffer is null, fetch next message from queue (if any)
+            while (this.outputBuffer == null) {
+                Message message;
+
+                try {
+                    // Allow other thread time to add message to queue having raised OP_WRITE.
+                    // Timeout is overkill but not excessive enough to clog up networking / EPC.
+                    // This is to avoid race condition in sendMessageWithTimeout() below.
+                    message = this.sendQueue.poll(QUEUE_TIMEOUT, TimeUnit.MILLISECONDS);
+                } catch (InterruptedException e) {
+                    // Shutdown situation
+                    return false;
+                }
+
+                // No message? No further work to be done
+                if (message == null)
+                    return false;
+
+                try {
+                    this.outputBuffer = ByteBuffer.wrap(message.toBytes());
+                    this.outputMessageType = message.getType().name();
+                    this.outputMessageId = message.getId();
+
+                    LOGGER.trace("[{}] Sending {} message with ID {} to peer {}",
+                            this.peerConnectionId, this.outputMessageType, this.outputMessageId, this);
+
+                    // Record message stats
+                    MessageStats messageStats = this.sentMessageStats.computeIfAbsent(message.getType(), k -> new MessageStats());
+                    // Ideally these two operations would be atomic, we could pack 'count' in top X bits of the 64-bit long, but meh
+                    messageStats.count.increment();
+                    messageStats.totalBytes.add(this.outputBuffer.limit());
+                } catch (MessageException e) {
+                    // Something went wrong converting message to bytes, so discard but allow another round
+                    LOGGER.warn("[{}] Failed to send {} message with ID {} to peer {}: {}", this.peerConnectionId,
+                            message.getType().name(), message.getId(), this, e.getMessage());
+                }
+            }
+
+            // If output byte buffer is not null, send from that
+            int bytesWritten = this.socketChannel.write(outputBuffer);
+
+            LOGGER.trace("[{}] Sent {} bytes of {} message with ID {} to peer {} ({} total)", this.peerConnectionId,
+                    bytesWritten, this.outputMessageType, this.outputMessageId, this, outputBuffer.limit());
+
+            // If we've sent 0 bytes then socket buffer is full so we need to wait until it's empty again
+            if (bytesWritten == 0) {
+                return true;
+            }
+
+            // If we then exhaust the byte buffer, set it to null (otherwise loop and try to send more)
+            if (!this.outputBuffer.hasRemaining()) {
+                this.outputMessageType = null;
+                this.outputMessageId = 0;
+                this.outputBuffer = null;
+            }
+        }
+    }
+
+    protected Task getMessageTask() {
         /*
          * If we are still handshaking and there is a message yet to be processed then
          * don't produce another message task. This allows us to process handshake
@@ -580,7 +685,7 @@ public class Peer {
         }
 
         // Return a task to process message in queue
-        return () -> Network.getInstance().onMessage(this, nextMessage);
+        return new MessageTask(this, nextMessage);
     }
 
     /**
@@ -605,54 +710,25 @@ public class Peer {
         }
 
         try {
-            // Send message
-            LOGGER.trace("[{}] Sending {} message with ID {} to peer {}", this.peerConnectionId,
+            // Queue message, to be picked up by ChannelWriteTask and then peer.writeChannel()
+            LOGGER.trace("[{}] Queuing {} message with ID {} to peer {}", this.peerConnectionId,
                     message.getType().name(), message.getId(), this);
 
-            ByteBuffer outputBuffer = ByteBuffer.wrap(message.toBytes());
+            // Check message properly constructed
+            message.checkValidOutgoing();
 
-            synchronized (this.socketChannel) {
-                final long sendStart = System.currentTimeMillis();
-                long totalBytes = 0;
-
-                while (outputBuffer.hasRemaining()) {
-                    int bytesWritten = this.socketChannel.write(outputBuffer);
-                    totalBytes += bytesWritten;
-
-                    LOGGER.trace("[{}] Sent {} bytes of {} message with ID {} to peer {} ({} total)", this.peerConnectionId,
-                            bytesWritten, message.getType().name(), message.getId(), this, totalBytes);
-
-                    if (bytesWritten == 0) {
-                        // Underlying socket's internal buffer probably full,
-                        // so wait a short while for bytes to actually be transmitted over the wire
-
-                        /*
-                         * NOSONAR squid:S2276 - we don't want to use this.socketChannel.wait()
-                         * as this releases the lock held by synchronized() above
-                         * and would allow another thread to send another message,
-                         * potentially interleaving them on-the-wire, causing checksum failures
-                         * and connection loss.
-                         */
-                        Thread.sleep(1L); //NOSONAR squid:S2276
-
-                        if (System.currentTimeMillis() - sendStart > timeout) {
-                            // We've taken too long to send this message
-                            return false;
-                        }
-                    }
-                }
-            }
-        } catch (MessageException e) {
-            LOGGER.warn("[{}] Failed to send {} message with ID {} to peer {}: {}", this.peerConnectionId,
-                    message.getType().name(), message.getId(), this, e.getMessage());
-            return false;
-        } catch (IOException | InterruptedException e) {
+            // Possible race condition:
+            // We set OP_WRITE, EPC creates ChannelWriteTask which calls Peer.writeChannel, writeChannel's poll() finds no message to send
+            // Avoided by poll-with-timeout in writeChannel() above.
+            Network.getInstance().setInterestOps(this.socketChannel, SelectionKey.OP_WRITE);
+            return this.sendQueue.tryTransfer(message, timeout, TimeUnit.MILLISECONDS);
+        } catch (InterruptedException e) {
             // Send failure
             return false;
+        } catch (MessageException e) {
+            LOGGER.error(e.getMessage(), e);
+            return false;
         }
-
-        // Sent OK
-        return true;
     }
 
     /**
@@ -720,7 +796,7 @@ public class Peer {
         this.lastPingSent = NTP.getTime();
     }
 
-    protected ExecuteProduceConsume.Task getPingTask(Long now) {
+    protected Task getPingTask(Long now) {
         // Pings not enabled yet?
         if (now == null || this.lastPingSent == null) {
             return null;
@@ -734,19 +810,7 @@ public class Peer {
         // Not strictly true, but prevents this peer from being immediately chosen again
         this.lastPingSent = now;
 
-        return () -> {
-            PingMessage pingMessage = new PingMessage();
-            Message message = this.getResponse(pingMessage);
-
-            if (message == null || message.getType() != MessageType.PING) {
-                LOGGER.debug("[{}] Didn't receive reply from {} for PING ID {}", this.peerConnectionId, this,
-                        pingMessage.getId());
-                this.disconnect("no ping received");
-                return;
-            }
-
-            this.setLastPing(NTP.getTime() - now);
-        };
+        return new PingTask(this, now);
     }
 
     public void disconnect(String reason) {
@@ -760,8 +824,11 @@ public class Peer {
     }
 
     public void shutdown() {
+        boolean logStats = false;
+
         if (!isStopping) {
             LOGGER.debug("[{}] Shutting down peer {}", this.peerConnectionId, this);
+            logStats = true;
         }
         isStopping = true;
 
@@ -773,8 +840,34 @@ public class Peer {
                 LOGGER.debug("[{}] IOException while trying to close peer {}", this.peerConnectionId, this);
             }
         }
+
+        if (logStats && this.receivedMessageStats.size() > 0) {
+            StringBuilder statsBuilder = new StringBuilder(1024);
+            statsBuilder.append("peer ").append(this).append(" message stats:\n=received=");
+            appendMessageStats(statsBuilder, this.receivedMessageStats);
+            statsBuilder.append("\n=sent=");
+            appendMessageStats(statsBuilder, this.sentMessageStats);
+
+            LOGGER.debug(statsBuilder.toString());
+        }
     }
 
+    private static void appendMessageStats(StringBuilder statsBuilder, Map<MessageType, MessageStats> messageStats) {
+        if (messageStats.isEmpty()) {
+            statsBuilder.append("\n  none");
+            return;
+        }
+
+        messageStats.keySet().stream()
+                .sorted(Comparator.comparing(MessageType::name))
+                .forEach(messageType -> {
+                    MessageStats stats = messageStats.get(messageType);
+
+                    statsBuilder.append("\n  ").append(messageType.name())
+                            .append(": count=").append(stats.count.sum())
+                            .append(", total bytes=").append(stats.totalBytes.sum());
+                });
+    }
 
     // Minimum version
 
@@ -877,6 +970,10 @@ public class Peer {
         return maxConnectionAge;
     }
 
+    public void setMaxConnectionAge(long maxConnectionAge) {
+        this.maxConnectionAge = maxConnectionAge;
+    }
+
     public boolean hasReachedMaxConnectionAge() {
         return this.getConnectionAge() > this.getMaxConnectionAge();
     }