Bump version to 2.1.3-mempow.0

# Conflicts:
#	pom.xml

pom.xml

@@ -3,7 +3,7 @@
 	<modelVersion>4.0.0</modelVersion>
 	<groupId>org.qortal</groupId>
 	<artifactId>qortal</artifactId>
-	<version>2.1.3</version>
+	<version>2.1.3-mempow.0</version>
 	<packaging>jar</packaging>
 	<properties>
 		<skipTests>true</skipTests>

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

@@ -34,7 +34,7 @@ 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.OnlineAccountsManager;
 import org.qortal.crypto.Crypto;
 import org.qortal.data.account.AccountData;
 import org.qortal.data.account.RewardShareData;
@@ -160,7 +160,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()) {
@@ -195,7 +195,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/block/Block.java

@@ -28,7 +28,7 @@ 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.data.account.AccountBalanceData;
 import org.qortal.data.account.AccountData;
@@ -320,7 +320,7 @@ public class Block {
 		byte[] reference = parentBlockData.getSignature();
 
 		// Fetch our list of online accounts
-		List<OnlineAccountData> onlineAccounts = Controller.getInstance().getOnlineAccounts();
+		List<OnlineAccountData> onlineAccounts = OnlineAccountsManager.getInstance().getOnlineAccounts();
 		if (onlineAccounts.isEmpty()) {
 			LOGGER.error("No online accounts - not even our own?");
 			return null;
@@ -976,10 +976,10 @@ public class Block {
 		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
+		List<OnlineAccountData> currentOnlineAccounts = onlineTimestamp < NTP.getTime() - OnlineAccountsManager.ONLINE_TIMESTAMP_MODULUS
 				? null
-				: Controller.getInstance().getOnlineAccounts();
-		List<OnlineAccountData> latestBlocksOnlineAccounts = Controller.getInstance().getLatestBlocksOnlineAccounts();
+				: OnlineAccountsManager.getInstance().getOnlineAccounts();
+		List<OnlineAccountData> latestBlocksOnlineAccounts = OnlineAccountsManager.getInstance().getLatestBlocksOnlineAccounts();
 
 		// Extract online accounts' timestamp signatures from block data
 		List<byte[]> onlineAccountsSignatures = BlockTransformer.decodeTimestampSignatures(this.blockData.getOnlineAccountsSignatures());
@@ -1357,7 +1357,7 @@ 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);
+		OnlineAccountsManager.getInstance().pushLatestBlocksOnlineAccounts(this.cachedValidOnlineAccounts);
 
 		// Log some debugging info relating to the block weight calculation
 		this.logDebugInfo();
@@ -1575,8 +1575,8 @@ public class Block {
 
 		postBlockTidy();
 
-		// Remove any cached, valid online accounts data from Controller
-		Controller.getInstance().popLatestBlocksOnlineAccounts();
+		// Remove any cached, valid online accounts data from OnlineAccountsManager
+		OnlineAccountsManager.getInstance().popLatestBlocksOnlineAccounts();
 	}
 
 	protected void orphanTransactionsFromBlock() throws DataException {

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

@@ -109,7 +109,7 @@ public class BlockMinter extends Thread {
 					continue;
 
 				// No online accounts? (e.g. during startup)
-				if (Controller.getInstance().getOnlineAccounts().isEmpty())
+				if (OnlineAccountsManager.getInstance().getOnlineAccounts().isEmpty())
 					continue;
 
 				List<MintingAccountData> mintingAccountsData = repository.getAccountRepository().getMintingAccounts();
@@ -429,7 +429,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];
 

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

@@ -12,7 +12,6 @@ import java.security.Security;
 import java.time.LocalDateTime;
 import java.time.ZoneOffset;
 import java.time.format.DateTimeFormatter;
-import java.util.ArrayDeque;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
@@ -41,9 +40,6 @@ import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.bouncycastle.jce.provider.BouncyCastleProvider;
 import org.bouncycastle.jsse.provider.BouncyCastleJsseProvider;
-import org.qortal.account.Account;
-import org.qortal.account.PrivateKeyAccount;
-import org.qortal.account.PublicKeyAccount;
 import org.qortal.api.ApiService;
 import org.qortal.block.Block;
 import org.qortal.block.BlockChain;
@@ -53,11 +49,8 @@ import org.qortal.controller.repository.PruneManager;
 import org.qortal.controller.repository.NamesDatabaseIntegrityCheck;
 import org.qortal.controller.tradebot.TradeBot;
 import org.qortal.crypto.Crypto;
-import org.qortal.data.account.MintingAccountData;
-import org.qortal.data.account.RewardShareData;
 import org.qortal.data.block.BlockData;
 import org.qortal.data.block.BlockSummaryData;
-import org.qortal.data.network.OnlineAccountData;
 import org.qortal.data.network.PeerChainTipData;
 import org.qortal.data.network.PeerData;
 import org.qortal.data.transaction.ArbitraryTransactionData;
@@ -77,14 +70,12 @@ import org.qortal.network.message.CachedBlockMessage;
 import org.qortal.network.message.GetArbitraryDataMessage;
 import org.qortal.network.message.GetBlockMessage;
 import org.qortal.network.message.GetBlockSummariesMessage;
-import org.qortal.network.message.GetOnlineAccountsMessage;
 import org.qortal.network.message.GetPeersMessage;
 import org.qortal.network.message.GetSignaturesV2Message;
 import org.qortal.network.message.GetTransactionMessage;
 import org.qortal.network.message.GetUnconfirmedTransactionsMessage;
 import org.qortal.network.message.HeightV2Message;
 import org.qortal.network.message.Message;
-import org.qortal.network.message.OnlineAccountsMessage;
 import org.qortal.network.message.SignaturesMessage;
 import org.qortal.network.message.TransactionMessage;
 import org.qortal.network.message.TransactionSignaturesMessage;
@@ -97,7 +88,6 @@ import org.qortal.transaction.Transaction.TransactionType;
 import org.qortal.transaction.Transaction.ValidationResult;
 import org.qortal.utils.*;
 
-import com.google.common.primitives.Longs;
 
 public class Controller extends Thread {
 
@@ -122,14 +112,6 @@ public class Controller extends Thread {
 	private static final long DELETE_EXPIRED_INTERVAL = 5 * 60 * 1000L; // ms
 	private static final long RECOVERY_MODE_TIMEOUT = 10 * 60 * 1000L; // ms
 
-	// To do with online accounts list
-	private static final long ONLINE_ACCOUNTS_TASKS_INTERVAL = 10 * 1000L; // ms
-	private static final long ONLINE_ACCOUNTS_BROADCAST_INTERVAL = 1 * 60 * 1000L; // ms
-	public static final long ONLINE_TIMESTAMP_MODULUS = 5 * 60 * 1000L;
-	private static final long LAST_SEEN_EXPIRY_PERIOD = (ONLINE_TIMESTAMP_MODULUS * 2) + (1 * 60 * 1000L);
-	/** How many (latest) blocks' worth of online accounts we cache */
-	private static final int MAX_BLOCKS_CACHED_ONLINE_ACCOUNTS = 2;
-
 	private static volatile boolean isStopping = false;
 	private static BlockMinter blockMinter = null;
 	private static volatile boolean requestSync = false;
@@ -161,8 +143,6 @@ public class Controller extends Thread {
 	private long ntpCheckTimestamp = startTime; // ms
 	private long deleteExpiredTimestamp = startTime + DELETE_EXPIRED_INTERVAL; // ms
 
-	private long onlineAccountsTasksTimestamp = startTime + ONLINE_ACCOUNTS_TASKS_INTERVAL; // ms
-
 	/** Whether we can mint new blocks, as reported by BlockMinter. */
 	private volatile boolean isMintingPossible = false;
 
@@ -203,11 +183,6 @@ public class Controller extends Thread {
 	/** Lock for only allowing one blockchain-modifying codepath at a time. e.g. synchronization or newly minted block. */
 	private final ReentrantLock blockchainLock = new ReentrantLock();
 
-	/** Cache of current 'online accounts' */
-	List<OnlineAccountData> onlineAccounts = new ArrayList<>();
-	/** Cache of latest blocks' online accounts */
-	Deque<List<OnlineAccountData>> latestBlocksOnlineAccounts = new ArrayDeque<>(MAX_BLOCKS_CACHED_ONLINE_ACCOUNTS);
-
 	// Stats
 	@XmlAccessorType(XmlAccessType.FIELD)
 	public static class StatsSnapshot {
@@ -497,6 +472,10 @@ public class Controller extends Thread {
 		// LOGGER.info("Starting arbitrary-transaction data manager");
 		// ArbitraryDataManager.getInstance().start();
 
+		// Online accounts manager
+		LOGGER.info("Starting online accounts manager");
+		OnlineAccountsManager.getInstance().start();
+
 		// Auto-update service?
 		if (Settings.getInstance().isAutoUpdateEnabled()) {
 			LOGGER.info("Starting auto-update");
@@ -641,11 +620,9 @@ public class Controller extends Thread {
 					deleteExpiredTransactions();
 				}
 
-				// Perform tasks to do with managing online accounts list
-				if (now >= onlineAccountsTasksTimestamp) {
-					onlineAccountsTasksTimestamp = now + ONLINE_ACCOUNTS_TASKS_INTERVAL;
-					performOnlineAccountsTasks();
-				}
+				// Check and maybe perform online accounts tasks
+				OnlineAccountsManager.getInstance().checkOnlineAccountsTasks(now);
+
 			}
 		} catch (InterruptedException e) {
 			// Clear interrupted flag so we can shutdown trim threads
@@ -1058,6 +1035,10 @@ public class Controller extends Thread {
 				// LOGGER.info("Shutting down arbitrary-transaction data manager");
 				// ArbitraryDataManager.getInstance().shutdown();
 
+				// Online accounts manager
+				 LOGGER.info("Shutting down online accounts manager");
+				 OnlineAccountsManager.getInstance().shutdown();
+
 				if (blockMinter != null) {
 					LOGGER.info("Shutting down block minter");
 					blockMinter.shutdown();
@@ -1361,11 +1342,11 @@ public class Controller extends Thread {
 				break;
 
 			case GET_ONLINE_ACCOUNTS:
-				onNetworkGetOnlineAccountsMessage(peer, message);
+				OnlineAccountsManager.getInstance().onNetworkGetOnlineAccountsMessage(peer, message);
 				break;
 
 			case ONLINE_ACCOUNTS:
-				onNetworkOnlineAccountsMessage(peer, message);
+				OnlineAccountsManager.getInstance().onNetworkOnlineAccountsMessage(peer, message);
 				break;
 
 			default:
@@ -1830,299 +1811,6 @@ public class Controller extends Thread {
 		}
 	}
 
-	private 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;
-		synchronized (this.onlineAccounts) {
-			accountsToSend = new ArrayList<>(this.onlineAccounts);
-		}
-
-		Iterator<OnlineAccountData> iterator = accountsToSend.iterator();
-
-		SEND_ITERATOR:
-		while (iterator.hasNext()) {
-			OnlineAccountData onlineAccountData = iterator.next();
-
-			for (int i = 0; i < excludeAccounts.size(); ++i) {
-				OnlineAccountData excludeAccountData = excludeAccounts.get(i);
-
-				if (onlineAccountData.getTimestamp() == excludeAccountData.getTimestamp() && Arrays.equals(onlineAccountData.getPublicKey(), excludeAccountData.getPublicKey())) {
-					iterator.remove();
-					continue SEND_ITERATOR;
-				}
-			}
-		}
-
-		Message onlineAccountsMessage = new OnlineAccountsMessage(accountsToSend);
-		peer.sendMessage(onlineAccountsMessage);
-
-		LOGGER.trace(() -> String.format("Sent %d of our %d online accounts to %s", accountsToSend.size(), this.onlineAccounts.size(), peer));
-	}
-
-	private void onNetworkOnlineAccountsMessage(Peer peer, Message message) {
-		OnlineAccountsMessage onlineAccountsMessage = (OnlineAccountsMessage) message;
-
-		List<OnlineAccountData> peersOnlineAccounts = onlineAccountsMessage.getOnlineAccounts();
-		LOGGER.trace(() -> String.format("Received %d online accounts from %s", peersOnlineAccounts.size(), peer));
-
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			for (OnlineAccountData onlineAccountData : peersOnlineAccounts)
-				this.verifyAndAddAccount(repository, onlineAccountData);
-		} catch (DataException e) {
-			LOGGER.error(String.format("Repository issue while verifying online accounts from peer %s", peer), e);
-		}
-	}
-
-	// Utilities
-
-	private void verifyAndAddAccount(Repository repository, OnlineAccountData onlineAccountData) throws DataException {
-		final Long now = NTP.getTime();
-		if (now == null)
-			return;
-
-		PublicKeyAccount otherAccount = new PublicKeyAccount(repository, onlineAccountData.getPublicKey());
-
-		// Check timestamp is 'recent' here
-		if (Math.abs(onlineAccountData.getTimestamp() - now) > ONLINE_TIMESTAMP_MODULUS * 2) {
-			LOGGER.trace(() -> String.format("Rejecting online account %s with out of range timestamp %d", otherAccount.getAddress(), onlineAccountData.getTimestamp()));
-			return;
-		}
-
-		// Verify
-		byte[] data = Longs.toByteArray(onlineAccountData.getTimestamp());
-		if (!otherAccount.verify(onlineAccountData.getSignature(), data)) {
-			LOGGER.trace(() -> String.format("Rejecting invalid online account %s", otherAccount.getAddress()));
-			return;
-		}
-
-		// Qortal: check online account is actually reward-share
-		RewardShareData rewardShareData = repository.getAccountRepository().getRewardShare(onlineAccountData.getPublicKey());
-		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(onlineAccountData.getPublicKey())));
-			return;
-		}
-
-		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;
-		}
-
-		synchronized (this.onlineAccounts) {
-			OnlineAccountData existingAccountData = this.onlineAccounts.stream().filter(account -> Arrays.equals(account.getPublicKey(), onlineAccountData.getPublicKey())).findFirst().orElse(null);
-
-			if (existingAccountData != null) {
-				if (existingAccountData.getTimestamp() < onlineAccountData.getTimestamp()) {
-					this.onlineAccounts.remove(existingAccountData);
-
-					LOGGER.trace(() -> String.format("Updated online account %s with timestamp %d (was %d)", otherAccount.getAddress(), onlineAccountData.getTimestamp(), existingAccountData.getTimestamp()));
-				} else {
-					LOGGER.trace(() -> String.format("Not updating existing online account %s", otherAccount.getAddress()));
-
-					return;
-				}
-			} else {
-				LOGGER.trace(() -> String.format("Added online account %s with timestamp %d", otherAccount.getAddress(), onlineAccountData.getTimestamp()));
-			}
-
-			this.onlineAccounts.add(onlineAccountData);
-		}
-	}
-
-	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 now = NTP.getTime();
-		if (now == null)
-			return;
-
-		final long onlineAccountsTimestamp = Controller.toOnlineAccountTimestamp(now);
-		byte[] timestampBytes = Longs.toByteArray(onlineAccountsTimestamp);
-
-		synchronized (this.onlineAccounts) {
-			this.onlineAccounts.clear();
-
-			for (PrivateKeyAccount onlineAccount : onlineAccounts) {
-				// Check mintingAccount is actually reward-share?
-
-				byte[] signature = onlineAccount.sign(timestampBytes);
-				byte[] publicKey = onlineAccount.getPublicKey();
-
-				OnlineAccountData ourOnlineAccountData = new OnlineAccountData(onlineAccountsTimestamp, signature, publicKey);
-				this.onlineAccounts.add(ourOnlineAccountData);
-			}
-		}
-	}
-
-	private void performOnlineAccountsTasks() {
-		final Long now = NTP.getTime();
-		if (now == null)
-			return;
-
-		// Expire old entries
-		final long cutoffThreshold = now - LAST_SEEN_EXPIRY_PERIOD;
-		synchronized (this.onlineAccounts) {
-			Iterator<OnlineAccountData> iterator = this.onlineAccounts.iterator();
-			while (iterator.hasNext()) {
-				OnlineAccountData onlineAccountData = iterator.next();
-
-				if (onlineAccountData.getTimestamp() < cutoffThreshold) {
-					iterator.remove();
-
-					LOGGER.trace(() -> {
-						PublicKeyAccount otherAccount = new PublicKeyAccount(null, onlineAccountData.getPublicKey());
-						return String.format("Removed expired online account %s with timestamp %d", otherAccount.getAddress(), onlineAccountData.getTimestamp());
-					});
-				}
-			}
-		}
-
-		// Request data from other peers?
-		if ((this.onlineAccountsTasksTimestamp % ONLINE_ACCOUNTS_BROADCAST_INTERVAL) < ONLINE_ACCOUNTS_TASKS_INTERVAL) {
-			Message message;
-			synchronized (this.onlineAccounts) {
-				message = new GetOnlineAccountsMessage(this.onlineAccounts);
-			}
-			Network.getInstance().broadcast(peer -> message);
-		}
-
-		// Refresh our online accounts signatures?
-		sendOurOnlineAccountsInfo();
-	}
-
-	private void sendOurOnlineAccountsInfo() {
-		final Long now = NTP.getTime();
-		if (now == null)
-			return;
-
-		List<MintingAccountData> mintingAccounts;
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			mintingAccounts = repository.getAccountRepository().getMintingAccounts();
-
-			// We have no accounts, but don't reset timestamp
-			if (mintingAccounts.isEmpty())
-				return;
-
-			// Only reward-share accounts 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;
-		}
-
-		// 'current' timestamp
-		final long onlineAccountsTimestamp = Controller.toOnlineAccountTimestamp(now);
-		boolean hasInfoChanged = false;
-
-		byte[] timestampBytes = Longs.toByteArray(onlineAccountsTimestamp);
-		List<OnlineAccountData> ourOnlineAccounts = new ArrayList<>();
-
-		MINTING_ACCOUNTS:
-		for (MintingAccountData mintingAccountData : mintingAccounts) {
-			PrivateKeyAccount mintingAccount = new PrivateKeyAccount(null, mintingAccountData.getPrivateKey());
-
-			byte[] signature = mintingAccount.sign(timestampBytes);
-			byte[] publicKey = mintingAccount.getPublicKey();
-
-			// Our account is online
-			OnlineAccountData ourOnlineAccountData = new OnlineAccountData(onlineAccountsTimestamp, signature, publicKey);
-			synchronized (this.onlineAccounts) {
-				Iterator<OnlineAccountData> iterator = this.onlineAccounts.iterator();
-				while (iterator.hasNext()) {
-					OnlineAccountData existingOnlineAccountData = iterator.next();
-
-					if (Arrays.equals(existingOnlineAccountData.getPublicKey(), ourOnlineAccountData.getPublicKey())) {
-						// If our online account is already present, with same timestamp, then move on to next mintingAccount
-						if (existingOnlineAccountData.getTimestamp() == onlineAccountsTimestamp)
-							continue MINTING_ACCOUNTS;
-
-						// If our online account is already present, but with older timestamp, then remove it
-						iterator.remove();
-						break;
-					}
-				}
-
-				this.onlineAccounts.add(ourOnlineAccountData);
-			}
-
-			LOGGER.trace(() -> String.format("Added our online account %s with timestamp %d", mintingAccount.getAddress(), onlineAccountsTimestamp));
-			ourOnlineAccounts.add(ourOnlineAccountData);
-			hasInfoChanged = true;
-		}
-
-		if (!hasInfoChanged)
-			return;
-
-		Message message = new OnlineAccountsMessage(ourOnlineAccounts);
-		Network.getInstance().broadcast(peer -> message);
-
-		LOGGER.trace(()-> String.format("Broadcasted %d online account%s with timestamp %d", ourOnlineAccounts.size(), (ourOnlineAccounts.size() != 1 ? "s" : ""), onlineAccountsTimestamp));
-	}
-
-	public static long toOnlineAccountTimestamp(long timestamp) {
-		return (timestamp / ONLINE_TIMESTAMP_MODULUS) * ONLINE_TIMESTAMP_MODULUS;
-	}
-
-	/** Returns list of online accounts with timestamp recent enough to be considered currently online. */
-	public List<OnlineAccountData> getOnlineAccounts() {
-		final long onlineTimestamp = Controller.toOnlineAccountTimestamp(NTP.getTime());
-
-		synchronized (this.onlineAccounts) {
-			return this.onlineAccounts.stream().filter(account -> account.getTimestamp() == onlineTimestamp).collect(Collectors.toList());
-		}
-	}
-
-	/** Returns cached, unmodifiable list of latest block's online accounts. */
-	public List<OnlineAccountData> getLatestBlocksOnlineAccounts() {
-		synchronized (this.latestBlocksOnlineAccounts) {
-			return this.latestBlocksOnlineAccounts.peekFirst();
-		}
-	}
-
-	/** Caches list of latest block's online accounts. Typically called by Block.process() */
-	public void pushLatestBlocksOnlineAccounts(List<OnlineAccountData> latestBlocksOnlineAccounts) {
-		synchronized (this.latestBlocksOnlineAccounts) {
-			if (this.latestBlocksOnlineAccounts.size() == MAX_BLOCKS_CACHED_ONLINE_ACCOUNTS)
-				this.latestBlocksOnlineAccounts.pollLast();
-
-			this.latestBlocksOnlineAccounts.addFirst(latestBlocksOnlineAccounts == null
-					? Collections.emptyList()
-					: Collections.unmodifiableList(latestBlocksOnlineAccounts));
-		}
-	}
-
-	/** Reverts list of latest block's online accounts. Typically called by Block.orphan() */
-	public void popLatestBlocksOnlineAccounts() {
-		synchronized (this.latestBlocksOnlineAccounts) {
-			this.latestBlocksOnlineAccounts.pollFirst();
-		}
-	}
 
 	public byte[] fetchArbitraryData(byte[] signature) throws InterruptedException {
 		// Build request

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

@@ -0,0 +1,404 @@
+package org.qortal.controller;
+
+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.account.PublicKeyAccount;
+import org.qortal.block.BlockChain;
+import org.qortal.crypto.MemoryPoW;
+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.GetOnlineAccountsMessage;
+import org.qortal.network.message.Message;
+import org.qortal.network.message.OnlineAccountsMessage;
+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 java.util.*;
+import java.util.stream.Collectors;
+
+public class OnlineAccountsManager extends Thread {
+
+    private static final Logger LOGGER = LogManager.getLogger(OnlineAccountsManager.class);
+
+    private static OnlineAccountsManager instance;
+
+    private volatile boolean isStopping = false;
+
+    // To do with online accounts list
+    private static final long ONLINE_ACCOUNTS_TASKS_INTERVAL = 10 * 1000L; // ms
+    private static final long ONLINE_ACCOUNTS_BROADCAST_INTERVAL = 1 * 60 * 1000L; // ms
+    public static final long ONLINE_TIMESTAMP_MODULUS = 5 * 60 * 1000L;
+    private static final long LAST_SEEN_EXPIRY_PERIOD = (ONLINE_TIMESTAMP_MODULUS * 2) + (1 * 60 * 1000L);
+    /** How many (latest) blocks' worth of online accounts we cache */
+    private static final int MAX_BLOCKS_CACHED_ONLINE_ACCOUNTS = 2;
+
+    public static final int POW_BUFFER_SIZE = 8 * 1024 * 1024; // bytes
+
+    private long onlineAccountsTasksTimestamp = Controller.startTime + ONLINE_ACCOUNTS_TASKS_INTERVAL; // ms
+
+    /** Cache of current 'online accounts' */
+    List<OnlineAccountData> onlineAccounts = new ArrayList<>();
+    /** Cache of latest blocks' online accounts */
+    Deque<List<OnlineAccountData>> latestBlocksOnlineAccounts = new ArrayDeque<>(MAX_BLOCKS_CACHED_ONLINE_ACCOUNTS);
+
+    public OnlineAccountsManager() {
+
+    }
+
+    public static synchronized OnlineAccountsManager getInstance() {
+        if (instance == null) {
+            instance = new OnlineAccountsManager();
+        }
+
+        return instance;
+    }
+
+    @Override
+    public void run() {
+        Thread.currentThread().setName("Online Accounts Manager");
+
+        try {
+            while (!isStopping) {
+                Thread.sleep(2000);
+
+                int difficulty = 15;
+                long timestamp = System.currentTimeMillis();
+
+                LOGGER.info("Computing nonce at difficulty {} for timestamp {}...", difficulty, timestamp);
+
+                byte[] bytes = Longs.toByteArray(timestamp);
+                Integer nonce = MemoryPoW.compute2(bytes, POW_BUFFER_SIZE, difficulty);
+                long totalTime = System.currentTimeMillis() - timestamp;
+                double hashRate = nonce / (double)totalTime * 1000.0f;
+
+                LOGGER.info("Computed nonce: {}. Time taken: {} ms. Hashrate: {}", nonce, totalTime, hashRate);
+            }
+
+        } catch (InterruptedException e) {
+            // Fall-through to exit thread...
+        }
+    }
+
+    public void shutdown() {
+        isStopping = true;
+        this.interrupt();
+    }
+
+
+
+    public void checkOnlineAccountsTasks(long now) {
+        // Perform tasks to do with managing online accounts list
+        if (now >= onlineAccountsTasksTimestamp) {
+            onlineAccountsTasksTimestamp = now + ONLINE_ACCOUNTS_TASKS_INTERVAL;
+            performOnlineAccountsTasks();
+        }
+    }
+
+    private void sendOurOnlineAccountsInfo() {
+        final Long now = NTP.getTime();
+        if (now == null)
+            return;
+
+        List<MintingAccountData> mintingAccounts;
+        try (final Repository repository = RepositoryManager.getRepository()) {
+            mintingAccounts = repository.getAccountRepository().getMintingAccounts();
+
+            // We have no accounts, but don't reset timestamp
+            if (mintingAccounts.isEmpty())
+                return;
+
+            // Only reward-share accounts 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;
+        }
+
+        // 'current' timestamp
+        final long onlineAccountsTimestamp = OnlineAccountsManager.toOnlineAccountTimestamp(now);
+        boolean hasInfoChanged = false;
+
+        byte[] timestampBytes = Longs.toByteArray(onlineAccountsTimestamp);
+        List<OnlineAccountData> ourOnlineAccounts = new ArrayList<>();
+
+        MINTING_ACCOUNTS:
+        for (MintingAccountData mintingAccountData : mintingAccounts) {
+            PrivateKeyAccount mintingAccount = new PrivateKeyAccount(null, mintingAccountData.getPrivateKey());
+
+            byte[] signature = mintingAccount.sign(timestampBytes);
+            byte[] publicKey = mintingAccount.getPublicKey();
+
+            // Our account is online
+            OnlineAccountData ourOnlineAccountData = new OnlineAccountData(onlineAccountsTimestamp, signature, publicKey);
+            synchronized (this.onlineAccounts) {
+                Iterator<OnlineAccountData> iterator = this.onlineAccounts.iterator();
+                while (iterator.hasNext()) {
+                    OnlineAccountData existingOnlineAccountData = iterator.next();
+
+                    if (Arrays.equals(existingOnlineAccountData.getPublicKey(), ourOnlineAccountData.getPublicKey())) {
+                        // If our online account is already present, with same timestamp, then move on to next mintingAccount
+                        if (existingOnlineAccountData.getTimestamp() == onlineAccountsTimestamp)
+                            continue MINTING_ACCOUNTS;
+
+                        // If our online account is already present, but with older timestamp, then remove it
+                        iterator.remove();
+                        break;
+                    }
+                }
+
+                this.onlineAccounts.add(ourOnlineAccountData);
+            }
+
+            LOGGER.debug(() -> String.format("Added our online account %s with timestamp %d", mintingAccount.getAddress(), onlineAccountsTimestamp));
+            ourOnlineAccounts.add(ourOnlineAccountData);
+            hasInfoChanged = true;
+        }
+
+        if (!hasInfoChanged)
+            return;
+
+        Message message = new OnlineAccountsMessage(ourOnlineAccounts);
+        Network.getInstance().broadcast(peer -> message);
+
+        LOGGER.debug(()-> String.format("Broadcasted %d online account%s with timestamp %d", ourOnlineAccounts.size(), (ourOnlineAccounts.size() != 1 ? "s" : ""), onlineAccountsTimestamp));
+    }
+
+    private void performOnlineAccountsTasks() {
+        final Long now = NTP.getTime();
+        if (now == null)
+            return;
+
+        // Expire old entries
+        final long cutoffThreshold = now - LAST_SEEN_EXPIRY_PERIOD;
+        synchronized (this.onlineAccounts) {
+            Iterator<OnlineAccountData> iterator = this.onlineAccounts.iterator();
+            while (iterator.hasNext()) {
+                OnlineAccountData onlineAccountData = iterator.next();
+
+                if (onlineAccountData.getTimestamp() < cutoffThreshold) {
+                    iterator.remove();
+
+                    LOGGER.trace(() -> {
+                        PublicKeyAccount otherAccount = new PublicKeyAccount(null, onlineAccountData.getPublicKey());
+                        return String.format("Removed expired online account %s with timestamp %d", otherAccount.getAddress(), onlineAccountData.getTimestamp());
+                    });
+                }
+            }
+        }
+
+        // Request data from other peers?
+        if ((this.onlineAccountsTasksTimestamp % ONLINE_ACCOUNTS_BROADCAST_INTERVAL) < ONLINE_ACCOUNTS_TASKS_INTERVAL) {
+            Message message;
+            synchronized (this.onlineAccounts) {
+                message = new GetOnlineAccountsMessage(this.onlineAccounts);
+            }
+            Network.getInstance().broadcast(peer -> message);
+        }
+
+        // Refresh our online accounts signatures?
+        sendOurOnlineAccountsInfo();
+    }
+
+    public static long toOnlineAccountTimestamp(long timestamp) {
+        return (timestamp / ONLINE_TIMESTAMP_MODULUS) * ONLINE_TIMESTAMP_MODULUS;
+    }
+
+    /** Returns list of online accounts with timestamp recent enough to be considered currently online. */
+    public List<OnlineAccountData> getOnlineAccounts() {
+        final long onlineTimestamp = OnlineAccountsManager.toOnlineAccountTimestamp(NTP.getTime());
+
+        synchronized (this.onlineAccounts) {
+            return this.onlineAccounts.stream().filter(account -> account.getTimestamp() == onlineTimestamp).collect(Collectors.toList());
+        }
+    }
+
+    /** Returns cached, unmodifiable list of latest block's online accounts. */
+    public List<OnlineAccountData> getLatestBlocksOnlineAccounts() {
+        synchronized (this.latestBlocksOnlineAccounts) {
+            return this.latestBlocksOnlineAccounts.peekFirst();
+        }
+    }
+
+    /** Caches list of latest block's online accounts. Typically called by Block.process() */
+    public void pushLatestBlocksOnlineAccounts(List<OnlineAccountData> latestBlocksOnlineAccounts) {
+        synchronized (this.latestBlocksOnlineAccounts) {
+            if (this.latestBlocksOnlineAccounts.size() == MAX_BLOCKS_CACHED_ONLINE_ACCOUNTS)
+                this.latestBlocksOnlineAccounts.pollLast();
+
+            this.latestBlocksOnlineAccounts.addFirst(latestBlocksOnlineAccounts == null
+                    ? Collections.emptyList()
+                    : Collections.unmodifiableList(latestBlocksOnlineAccounts));
+        }
+    }
+
+    /** Reverts list of latest block's online accounts. Typically called by Block.orphan() */
+    public void popLatestBlocksOnlineAccounts() {
+        synchronized (this.latestBlocksOnlineAccounts) {
+            this.latestBlocksOnlineAccounts.pollFirst();
+        }
+    }
+
+
+    // Utilities
+
+    private void verifyAndAddAccount(Repository repository, OnlineAccountData onlineAccountData) throws DataException {
+        final Long now = NTP.getTime();
+        if (now == null)
+            return;
+
+        PublicKeyAccount otherAccount = new PublicKeyAccount(repository, onlineAccountData.getPublicKey());
+
+        // Check timestamp is 'recent' here
+        if (Math.abs(onlineAccountData.getTimestamp() - now) > ONLINE_TIMESTAMP_MODULUS * 2) {
+            LOGGER.trace(() -> String.format("Rejecting online account %s with out of range timestamp %d", otherAccount.getAddress(), onlineAccountData.getTimestamp()));
+            return;
+        }
+
+        // Verify
+        byte[] data = Longs.toByteArray(onlineAccountData.getTimestamp());
+        if (!otherAccount.verify(onlineAccountData.getSignature(), data)) {
+            LOGGER.trace(() -> String.format("Rejecting invalid online account %s", otherAccount.getAddress()));
+            return;
+        }
+
+        // Qortal: check online account is actually reward-share
+        RewardShareData rewardShareData = repository.getAccountRepository().getRewardShare(onlineAccountData.getPublicKey());
+        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(onlineAccountData.getPublicKey())));
+            return;
+        }
+
+        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;
+        }
+
+        synchronized (this.onlineAccounts) {
+            OnlineAccountData existingAccountData = this.onlineAccounts.stream().filter(account -> Arrays.equals(account.getPublicKey(), onlineAccountData.getPublicKey())).findFirst().orElse(null);
+
+            if (existingAccountData != null) {
+                if (existingAccountData.getTimestamp() < onlineAccountData.getTimestamp()) {
+                    this.onlineAccounts.remove(existingAccountData);
+
+                    LOGGER.trace(() -> String.format("Updated online account %s with timestamp %d (was %d)", otherAccount.getAddress(), onlineAccountData.getTimestamp(), existingAccountData.getTimestamp()));
+                } else {
+                    LOGGER.trace(() -> String.format("Not updating existing online account %s", otherAccount.getAddress()));
+
+                    return;
+                }
+            } else {
+                LOGGER.debug(() -> String.format("Added online account %s with timestamp %d", otherAccount.getAddress(), onlineAccountData.getTimestamp()));
+            }
+
+            this.onlineAccounts.add(onlineAccountData);
+        }
+    }
+
+    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 now = NTP.getTime();
+        if (now == null)
+            return;
+
+        final long onlineAccountsTimestamp = this.toOnlineAccountTimestamp(now);
+        byte[] timestampBytes = Longs.toByteArray(onlineAccountsTimestamp);
+
+        synchronized (this.onlineAccounts) {
+            this.onlineAccounts.clear();
+
+            for (PrivateKeyAccount onlineAccount : onlineAccounts) {
+                // Check mintingAccount is actually reward-share?
+
+                byte[] signature = onlineAccount.sign(timestampBytes);
+                byte[] publicKey = onlineAccount.getPublicKey();
+
+                OnlineAccountData ourOnlineAccountData = new OnlineAccountData(onlineAccountsTimestamp, signature, publicKey);
+                this.onlineAccounts.add(ourOnlineAccountData);
+            }
+        }
+    }
+
+
+    // 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;
+        synchronized (this.onlineAccounts) {
+            accountsToSend = new ArrayList<>(this.onlineAccounts);
+        }
+
+        Iterator<OnlineAccountData> iterator = accountsToSend.iterator();
+
+        SEND_ITERATOR:
+        while (iterator.hasNext()) {
+            OnlineAccountData onlineAccountData = iterator.next();
+
+            for (int i = 0; i < excludeAccounts.size(); ++i) {
+                OnlineAccountData excludeAccountData = excludeAccounts.get(i);
+
+                if (onlineAccountData.getTimestamp() == excludeAccountData.getTimestamp() && Arrays.equals(onlineAccountData.getPublicKey(), excludeAccountData.getPublicKey())) {
+                    iterator.remove();
+                    continue SEND_ITERATOR;
+                }
+            }
+        }
+
+        Message onlineAccountsMessage = new OnlineAccountsMessage(accountsToSend);
+        peer.sendMessage(onlineAccountsMessage);
+
+        LOGGER.debug(() -> String.format("Sent %d of our %d online accounts to %s", accountsToSend.size(), this.onlineAccounts.size(), peer));
+    }
+
+    public void onNetworkOnlineAccountsMessage(Peer peer, Message message) {
+        OnlineAccountsMessage onlineAccountsMessage = (OnlineAccountsMessage) message;
+
+        List<OnlineAccountData> peersOnlineAccounts = onlineAccountsMessage.getOnlineAccounts();
+        LOGGER.debug(() -> String.format("Received %d online accounts from %s", peersOnlineAccounts.size(), peer));
+
+        try (final Repository repository = RepositoryManager.getRepository()) {
+            for (OnlineAccountData onlineAccountData : peersOnlineAccounts)
+                this.verifyAndAddAccount(repository, onlineAccountData);
+        } catch (DataException e) {
+            LOGGER.error(String.format("Repository issue while verifying online accounts from peer %s", peer), e);
+        }
+    }
+
+}

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

@@ -1,5 +1,7 @@
 package org.qortal.crypto;
 
+import org.qortal.controller.Controller;
+
 import java.nio.ByteBuffer;
 
 public class MemoryPoW {
@@ -33,6 +35,10 @@ public class MemoryPoW {
 			if (Thread.currentThread().isInterrupted())
 				return -1;
 
+			// Or, if the Controller is stopping, do the same
+			if (Controller.isStopping())
+				return -1;
+
 			seed *= seedMultiplier; // per nonce
 
 			state[0] = longHash[0] ^ seed;

src/main/java/org/qortal/transaction/PresenceTransaction.java

@@ -12,7 +12,7 @@ import java.util.function.Supplier;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.qortal.account.Account;
-import org.qortal.controller.Controller;
+import org.qortal.controller.OnlineAccountsManager;
 import org.qortal.crosschain.ACCT;
 import org.qortal.crosschain.SupportedBlockchain;
 import org.qortal.crypto.Crypto;
@@ -47,7 +47,7 @@ public class PresenceTransaction extends Transaction {
 		REWARD_SHARE(0) {
 			@Override
 			public long getLifetime() {
-				return Controller.ONLINE_TIMESTAMP_MODULUS;
+				return OnlineAccountsManager.ONLINE_TIMESTAMP_MODULUS;
 			}
 		},
 		TRADE_BOT(1) {

src/test/java/org/qortal/test/minting/BlocksMintedCountTests.java

@@ -8,7 +8,7 @@ import org.junit.Before;
 import org.junit.Test;
 import org.qortal.account.PrivateKeyAccount;
 import org.qortal.controller.BlockMinter;
-import org.qortal.controller.Controller;
+import org.qortal.controller.OnlineAccountsManager;
 import org.qortal.data.account.RewardShareData;
 import org.qortal.repository.DataException;
 import org.qortal.repository.Repository;
@@ -77,7 +77,7 @@ public class BlocksMintedCountTests extends Common {
 			assertNotNull(testRewardShareData);
 
 			// Create signed timestamps
-			Controller.getInstance().ensureTestingAccountsOnline(mintingAccount, testRewardShareAccount);
+			OnlineAccountsManager.getInstance().ensureTestingAccountsOnline(mintingAccount, testRewardShareAccount);
 
 			// Even though Alice features in two online reward-shares, she should only gain +1 blocksMinted
 			// Bob only features in one online reward-share, so should also only gain +1 blocksMinted
@@ -87,7 +87,7 @@ public class BlocksMintedCountTests extends Common {
 
 	private void testRewardShare(Repository repository, PrivateKeyAccount testRewardShareAccount, int aliceDelta, int bobDelta) throws DataException {
 		// Create signed timestamps
-		Controller.getInstance().ensureTestingAccountsOnline(testRewardShareAccount);
+		OnlineAccountsManager.getInstance().ensureTestingAccountsOnline(testRewardShareAccount);
 
 		testRewardShareRetainingTimestamps(repository, testRewardShareAccount, aliceDelta, bobDelta);
 	}

src/test/java/org/qortal/test/minting/DisagreementTests.java

@@ -11,7 +11,7 @@ import org.junit.Before;
 import org.junit.Test;
 import org.qortal.account.PrivateKeyAccount;
 import org.qortal.controller.BlockMinter;
-import org.qortal.controller.Controller;
+import org.qortal.controller.OnlineAccountsManager;
 import org.qortal.data.account.RewardShareData;
 import org.qortal.data.block.BlockData;
 import org.qortal.data.transaction.TransactionData;
@@ -73,7 +73,7 @@ public class DisagreementTests extends Common {
 			assertNotNull(testRewardShareData);
 
 			// Create signed timestamps
-			Controller.getInstance().ensureTestingAccountsOnline(mintingAccount, testRewardShareAccount);
+			OnlineAccountsManager.getInstance().ensureTestingAccountsOnline(mintingAccount, testRewardShareAccount);
 
 			// Mint another block
 			BlockMinter.mintTestingBlockRetainingTimestamps(repository, mintingAccount);