Added BlockArchiveV2 tests, and updated the V1 tests now that we no longer support bulk archiving/pruning

When "archiveVersion" is set to 2 in settings, this should allow the archive size to reduce by over 90%. Some nodes might want to maintain an older/larger version, for the purposes of development/debugging, so this is currently opt-in.

.github/workflows/pr-testing.yml

@@ -8,16 +8,16 @@ jobs:
   mavenTesting:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
     - name: Cache local Maven repository
-      uses: actions/cache@v2
+      uses: actions/cache@v3
       with:
         path: ~/.m2/repository
         key: ${{ runner.os }}-maven-${{ hashFiles('**/pom.xml') }}
         restore-keys: |
           ${{ runner.os }}-maven-
     - name: Set up the Java JDK
-      uses: actions/setup-java@v2
+      uses: actions/setup-java@v3
       with:
         java-version: '11'
         distribution: 'adopt'

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:{6C93A96C-E3AF-42FD-BE11-7EC3734905C6} 1049:{754F5347-82E5-4251-AED0-F4141CDD11F5} 2052:{413BD7B3-A3F8-47D0-BCA4-5C7694A40936} 2057:{71450AC8-1E6F-4469-852D-0591FA693680} " Type="16"/>
+    <ROW Property="ProductCode" Value="1033:{CB85115E-ECCE-4B3D-BB7F-6251A2764922} 1049:{09AC1C62-4E33-4312-826A-38F597ED1B17} 2052:{3CF701B3-E118-4A31-A4B7-156CEA19FBCC} 2057:{468F337D-0EF8-41D1-B5DE-4EEE66BA2AF6} " Type="16"/>
     <ROW Property="ProductLanguage" Value="2057"/>
     <ROW Property="ProductName" Value="Qortal"/>
-    <ROW Property="ProductVersion" Value="3.8.3" Type="32"/>
+    <ROW Property="ProductVersion" Value="3.8.5" 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="{EC7B4AD9-F2D9-48C4-A586-C4697D9C380C}" Directory_="APPDIR" Attributes="260" KeyPath="DisplayName" Options="1"/>
+    <ROW Component="AI_CustomARPName" ComponentId="{094B5D07-2258-4A39-9917-2E2F7F6E210B}" 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,7 +3,7 @@
 	<modelVersion>4.0.0</modelVersion>
 	<groupId>org.qortal</groupId>
 	<artifactId>qortal</artifactId>
-	<version>3.8.4</version>
+	<version>3.8.9</version>
 	<packaging>jar</packaging>
 	<properties>
 		<skipTests>true</skipTests>
@@ -304,6 +304,7 @@
 									implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
 									<mainClass>org.qortal.controller.Controller</mainClass>
 									<manifestEntries>
+										<Multi-Release>true</Multi-Release>
 										<Class-Path>. ..</Class-Path>
 									</manifestEntries>
 								</transformer>

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

@@ -45,6 +45,7 @@ import org.qortal.block.BlockChain;
 import org.qortal.controller.Controller;
 import org.qortal.controller.Synchronizer;
 import org.qortal.controller.Synchronizer.SynchronizationResult;
+import org.qortal.controller.repository.BlockArchiveRebuilder;
 import org.qortal.data.account.MintingAccountData;
 import org.qortal.data.account.RewardShareData;
 import org.qortal.network.Network;
@@ -222,6 +223,42 @@ public class AdminResource {
 		}
 	}
 
+	@GET
+	@Path("/summary/alltime")
+	@Operation(
+			summary = "Summary of activity since genesis",
+			responses = {
+					@ApiResponse(
+							content = @Content(schema = @Schema(implementation = ActivitySummary.class))
+					)
+			}
+	)
+	@ApiErrors({ApiError.REPOSITORY_ISSUE})
+	@SecurityRequirement(name = "apiKey")
+	public ActivitySummary allTimeSummary(@HeaderParam(Security.API_KEY_HEADER) String apiKey) {
+		Security.checkApiCallAllowed(request);
+
+		ActivitySummary summary = new ActivitySummary();
+
+		try (final Repository repository = RepositoryManager.getRepository()) {
+			int startHeight = 1;
+			long start = repository.getBlockRepository().fromHeight(startHeight).getTimestamp();
+			int endHeight = repository.getBlockRepository().getBlockchainHeight();
+
+			summary.setBlockCount(endHeight - startHeight);
+
+			summary.setTransactionCountByType(repository.getTransactionRepository().getTransactionSummary(startHeight + 1, endHeight));
+
+			summary.setAssetsIssued(repository.getAssetRepository().getRecentAssetIds(start).size());
+
+			summary.setNamesRegistered (repository.getNameRepository().getRecentNames(start).size());
+
+			return summary;
+		} catch (DataException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.REPOSITORY_ISSUE, e);
+		}
+	}
+
 	@GET
 	@Path("/enginestats")
 	@Operation(
@@ -698,6 +735,64 @@ public class AdminResource {
 		}
 	}
 
+	@POST
+	@Path("/repository/archive/rebuild")
+	@Operation(
+			summary = "Rebuild archive",
+			description = "Rebuilds archive files, using the specified serialization version",
+			requestBody = @RequestBody(
+					required = true,
+					content = @Content(
+							mediaType = MediaType.TEXT_PLAIN,
+							schema = @Schema(
+									type = "number", example = "2"
+							)
+					)
+			),
+			responses = {
+					@ApiResponse(
+							description = "\"true\"",
+							content = @Content(mediaType = MediaType.TEXT_PLAIN, schema = @Schema(type = "string"))
+					)
+			}
+	)
+	@ApiErrors({ApiError.REPOSITORY_ISSUE})
+	@SecurityRequirement(name = "apiKey")
+	public String rebuildArchive(@HeaderParam(Security.API_KEY_HEADER) String apiKey, Integer serializationVersion) {
+		Security.checkApiCallAllowed(request);
+
+		// Default serialization version to value specified in settings
+		if (serializationVersion == null) {
+			serializationVersion = Settings.getInstance().getDefaultArchiveVersion();
+		}
+
+		try {
+			// We don't actually need to lock the blockchain here, but we'll do it anyway so that
+			// the node can focus on rebuilding rather than synchronizing / minting.
+			ReentrantLock blockchainLock = Controller.getInstance().getBlockchainLock();
+
+			blockchainLock.lockInterruptibly();
+
+			try {
+				BlockArchiveRebuilder blockArchiveRebuilder = new BlockArchiveRebuilder(serializationVersion);
+				blockArchiveRebuilder.start();
+
+				return "true";
+
+			} catch (IOException e) {
+				throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_CRITERIA, e);
+
+			} finally {
+				blockchainLock.unlock();
+			}
+		} catch (InterruptedException e) {
+			// We couldn't lock blockchain to perform rebuild
+			return "false";
+		} catch (DataException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.REPOSITORY_ISSUE, e);
+		}
+	}
+
 	@DELETE
 	@Path("/repository")
 	@Operation(

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

@@ -48,6 +48,7 @@ import org.qortal.repository.RepositoryManager;
 import org.qortal.transform.TransformationException;
 import org.qortal.transform.block.BlockTransformer;
 import org.qortal.utils.Base58;
+import org.qortal.utils.Triple;
 
 @Path("/blocks")
 @Tag(name = "Blocks")
@@ -165,10 +166,13 @@ public class BlocksResource {
             }
 
             // Not found, so try the block archive
-            byte[] bytes = BlockArchiveReader.getInstance().fetchSerializedBlockBytesForSignature(signature, false, repository);
-            if (bytes != null) {
-				if (version != 1) {
-					throw ApiExceptionFactory.INSTANCE.createCustomException(request, ApiError.INVALID_CRITERIA, "Archived blocks require version 1");
+            Triple<byte[], Integer, Integer> serializedBlock = BlockArchiveReader.getInstance().fetchSerializedBlockBytesForSignature(signature, false, repository);
+            if (serializedBlock != null) {
+				byte[] bytes = serializedBlock.getA();
+				Integer serializationVersion = serializedBlock.getB();
+				if (version != serializationVersion) {
+					// TODO: we could quite easily reserialize the block with the requested version
+					throw ApiExceptionFactory.INSTANCE.createCustomException(request, ApiError.INVALID_CRITERIA, "Block is not stored using requested serialization version.");
 				}
 				return Base58.encode(bytes);
             }

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

@@ -60,7 +60,7 @@ public class BootstrapResource {
 			bootstrap.validateBlockchain();
 			return bootstrap.create();
 
-		} catch (DataException | InterruptedException | IOException e) {
+		} catch (Exception e) {
 			LOGGER.info("Unable to create bootstrap", e);
 			throw ApiExceptionFactory.INSTANCE.createCustomException(request, ApiError.REPOSITORY_ISSUE, e.getMessage());
 		}

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

@@ -14,6 +14,7 @@ import java.util.List;
 import javax.servlet.http.HttpServletRequest;
 import javax.ws.rs.HeaderParam;
 import javax.ws.rs.POST;
+import javax.ws.rs.GET;
 import javax.ws.rs.Path;
 import javax.ws.rs.core.Context;
 import javax.ws.rs.core.MediaType;
@@ -35,6 +36,37 @@ public class CrossChainBitcoinResource {
 	@Context
 	HttpServletRequest request;
 
+	@GET
+	@Path("/height")
+	@Operation(
+		summary = "Returns current Bitcoin block height",
+		description = "Returns the height of the most recent block in the Bitcoin chain.",
+		responses = {
+			@ApiResponse(
+				content = @Content(
+					schema = @Schema(
+						type = "number"
+					)
+				)
+			)
+		}
+	)
+	@ApiErrors({ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE})
+	public String getBitcoinHeight() {
+		Bitcoin bitcoin = Bitcoin.getInstance();
+
+		try {
+			Integer height = bitcoin.getBlockchainHeight();
+			if (height == null)
+				throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE);
+
+			return height.toString();
+
+		} catch (ForeignBlockchainException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE);
+		}
+	}
+
 	@POST
 	@Path("/walletbalance")
 	@Operation(
@@ -118,6 +150,45 @@ public class CrossChainBitcoinResource {
 		}
 	}
 
+	@POST
+	@Path("/unusedaddress")
+	@Operation(
+		summary = "Returns first unused address 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 String getUnusedBitcoinReceiveAddress(@HeaderParam(Security.API_KEY_HEADER) String apiKey, String key58) {
+		Security.checkApiCallAllowed(request);
+
+		Bitcoin bitcoin = Bitcoin.getInstance();
+
+		if (!bitcoin.isValidDeterministicKey(key58))
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_PRIVATE_KEY);
+
+		try {
+			return bitcoin.getUnusedReceiveAddress(key58);
+		} catch (ForeignBlockchainException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE);
+		}
+	}
+
 	@POST
 	@Path("/send")
 	@Operation(

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

@@ -14,6 +14,7 @@ import java.util.List;
 import javax.servlet.http.HttpServletRequest;
 import javax.ws.rs.HeaderParam;
 import javax.ws.rs.POST;
+import javax.ws.rs.GET;
 import javax.ws.rs.Path;
 import javax.ws.rs.core.Context;
 import javax.ws.rs.core.MediaType;
@@ -35,6 +36,37 @@ public class CrossChainDigibyteResource {
 	@Context
 	HttpServletRequest request;
 
+	@GET
+	@Path("/height")
+	@Operation(
+		summary = "Returns current Digibyte block height",
+		description = "Returns the height of the most recent block in the Digibyte chain.",
+		responses = {
+			@ApiResponse(
+				content = @Content(
+					schema = @Schema(
+						type = "number"
+					)
+				)
+			)
+		}
+	)
+	@ApiErrors({ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE})
+	public String getDigibyteHeight() {
+		Digibyte digibyte = Digibyte.getInstance();
+
+		try {
+			Integer height = digibyte.getBlockchainHeight();
+			if (height == null)
+				throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE);
+
+			return height.toString();
+
+		} catch (ForeignBlockchainException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE);
+		}
+	}
+
 	@POST
 	@Path("/walletbalance")
 	@Operation(
@@ -118,6 +150,45 @@ public class CrossChainDigibyteResource {
 		}
 	}
 
+	@POST
+	@Path("/unusedaddress")
+	@Operation(
+		summary = "Returns first unused address 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 String getUnusedDigibyteReceiveAddress(@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.getUnusedReceiveAddress(key58);
+		} catch (ForeignBlockchainException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE);
+		}
+	}
+
 	@POST
 	@Path("/send")
 	@Operation(

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

@@ -21,6 +21,7 @@ import org.qortal.crosschain.SimpleTransaction;
 import javax.servlet.http.HttpServletRequest;
 import javax.ws.rs.HeaderParam;
 import javax.ws.rs.POST;
+import javax.ws.rs.GET;
 import javax.ws.rs.Path;
 import javax.ws.rs.core.Context;
 import javax.ws.rs.core.MediaType;
@@ -33,6 +34,37 @@ public class CrossChainDogecoinResource {
 	@Context
 	HttpServletRequest request;
 
+	@GET
+	@Path("/height")
+	@Operation(
+		summary = "Returns current Dogecoin block height",
+		description = "Returns the height of the most recent block in the Dogecoin chain.",
+		responses = {
+			@ApiResponse(
+				content = @Content(
+					schema = @Schema(
+						type = "number"
+					)
+				)
+			)
+		}
+	)
+	@ApiErrors({ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE})
+	public String getDogecoinHeight() {
+		Dogecoin dogecoin = Dogecoin.getInstance();
+
+		try {
+			Integer height = dogecoin.getBlockchainHeight();
+			if (height == null)
+				throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE);
+
+			return height.toString();
+
+		} catch (ForeignBlockchainException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE);
+		}
+	}
+
 	@POST
 	@Path("/walletbalance")
 	@Operation(
@@ -116,6 +148,45 @@ public class CrossChainDogecoinResource {
 		}
 	}
 
+	@POST
+	@Path("/unusedaddress")
+	@Operation(
+		summary = "Returns first unused address 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 String getUnusedDogecoinReceiveAddress(@HeaderParam(Security.API_KEY_HEADER) String apiKey, String key58) {
+		Security.checkApiCallAllowed(request);
+
+		Dogecoin dogecoin = Dogecoin.getInstance();
+
+		if (!dogecoin.isValidDeterministicKey(key58))
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_PRIVATE_KEY);
+
+		try {
+			return dogecoin.getUnusedReceiveAddress(key58);
+		} catch (ForeignBlockchainException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE);
+		}
+	}
+
 	@POST
 	@Path("/send")
 	@Operation(

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

@@ -14,6 +14,7 @@ import java.util.List;
 import javax.servlet.http.HttpServletRequest;
 import javax.ws.rs.HeaderParam;
 import javax.ws.rs.POST;
+import javax.ws.rs.GET;
 import javax.ws.rs.Path;
 import javax.ws.rs.core.Context;
 import javax.ws.rs.core.MediaType;
@@ -35,6 +36,37 @@ public class CrossChainLitecoinResource {
 	@Context
 	HttpServletRequest request;
 
+	@GET
+	@Path("/height")
+	@Operation(
+		summary = "Returns current Litecoin block height",
+		description = "Returns the height of the most recent block in the Litecoin chain.",
+		responses = {
+			@ApiResponse(
+				content = @Content(
+					schema = @Schema(
+						type = "number"
+					)
+				)
+			)
+		}
+	)
+	@ApiErrors({ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE})
+	public String getLitecoinHeight() {
+		Litecoin litecoin = Litecoin.getInstance();
+
+		try {
+			Integer height = litecoin.getBlockchainHeight();
+			if (height == null)
+				throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE);
+
+			return height.toString();
+
+		} catch (ForeignBlockchainException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE);
+		}
+	}
+
 	@POST
 	@Path("/walletbalance")
 	@Operation(
@@ -118,6 +150,45 @@ public class CrossChainLitecoinResource {
 		}
 	}
 
+	@POST
+	@Path("/unusedaddress")
+	@Operation(
+		summary = "Returns first unused address 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 String getUnusedLitecoinReceiveAddress(@HeaderParam(Security.API_KEY_HEADER) String apiKey, String key58) {
+		Security.checkApiCallAllowed(request);
+
+		Litecoin litecoin = Litecoin.getInstance();
+
+		if (!litecoin.isValidDeterministicKey(key58))
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_PRIVATE_KEY);
+
+		try {
+			return litecoin.getUnusedReceiveAddress(key58);
+		} catch (ForeignBlockchainException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE);
+		}
+	}
+
 	@POST
 	@Path("/send")
 	@Operation(

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

@@ -20,6 +20,7 @@ import org.qortal.crosschain.SimpleTransaction;
 import javax.servlet.http.HttpServletRequest;
 import javax.ws.rs.HeaderParam;
 import javax.ws.rs.POST;
+import javax.ws.rs.GET;
 import javax.ws.rs.Path;
 import javax.ws.rs.core.Context;
 import javax.ws.rs.core.MediaType;
@@ -32,6 +33,37 @@ public class CrossChainPirateChainResource {
 	@Context
 	HttpServletRequest request;
 
+	@GET
+	@Path("/height")
+	@Operation(
+		summary = "Returns current PirateChain block height",
+		description = "Returns the height of the most recent block in the PirateChain chain.",
+		responses = {
+			@ApiResponse(
+				content = @Content(
+					schema = @Schema(
+						type = "number"
+					)
+				)
+			)
+		}
+	)
+	@ApiErrors({ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE})
+	public String getPirateChainHeight() {
+		PirateChain pirateChain = PirateChain.getInstance();
+
+		try {
+			Integer height = pirateChain.getBlockchainHeight();
+			if (height == null)
+				throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE);
+
+			return height.toString();
+
+		} catch (ForeignBlockchainException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE);
+		}
+	}
+
 	@POST
 	@Path("/walletbalance")
 	@Operation(

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

@@ -14,6 +14,7 @@ import java.util.List;
 import javax.servlet.http.HttpServletRequest;
 import javax.ws.rs.HeaderParam;
 import javax.ws.rs.POST;
+import javax.ws.rs.GET;
 import javax.ws.rs.Path;
 import javax.ws.rs.core.Context;
 import javax.ws.rs.core.MediaType;
@@ -35,6 +36,37 @@ public class CrossChainRavencoinResource {
 	@Context
 	HttpServletRequest request;
 
+	@GET
+	@Path("/height")
+	@Operation(
+		summary = "Returns current Ravencoin block height",
+		description = "Returns the height of the most recent block in the Ravencoin chain.",
+		responses = {
+			@ApiResponse(
+				content = @Content(
+					schema = @Schema(
+						type = "number"
+					)
+				)
+			)
+		}
+	)
+	@ApiErrors({ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE})
+	public String getRavencoinHeight() {
+		Ravencoin ravencoin = Ravencoin.getInstance();
+
+		try {
+			Integer height = ravencoin.getBlockchainHeight();
+			if (height == null)
+				throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE);
+
+			return height.toString();
+
+		} catch (ForeignBlockchainException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE);
+		}
+	}
+
 	@POST
 	@Path("/walletbalance")
 	@Operation(
@@ -118,6 +150,45 @@ public class CrossChainRavencoinResource {
 		}
 	}
 
+	@POST
+	@Path("/unusedaddress")
+	@Operation(
+		summary = "Returns first unused address 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 String getUnusedRavencoinReceiveAddress(@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.getUnusedReceiveAddress(key58);
+		} catch (ForeignBlockchainException e) {
+			throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE);
+		}
+	}
+
 	@POST
 	@Path("/send")
 	@Operation(

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

@@ -11,6 +11,7 @@ import io.swagger.v3.oas.annotations.security.SecurityRequirement;
 import io.swagger.v3.oas.annotations.tags.Tag;
 
 import java.util.List;
+import java.util.Objects;
 import java.util.stream.Collectors;
 
 import javax.servlet.http.HttpServletRequest;
@@ -38,9 +39,12 @@ 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.MessageTransactionData;
+import org.qortal.data.transaction.TransactionData;
 import org.qortal.repository.DataException;
 import org.qortal.repository.Repository;
 import org.qortal.repository.RepositoryManager;
+import org.qortal.transaction.Transaction;
 import org.qortal.utils.Base58;
 import org.qortal.utils.NTP;
 
@@ -223,6 +227,17 @@ public class CrossChainTradeBotResource {
 			if (crossChainTradeData.mode != AcctMode.OFFERING)
 				throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_CRITERIA);
 
+			// Check if there is a buy or a cancel request in progress for this trade
+			List<Transaction.TransactionType> txTypes = List.of(Transaction.TransactionType.MESSAGE);
+			List<TransactionData> unconfirmed = repository.getTransactionRepository().getUnconfirmedTransactions(txTypes, null, 0, 0, false);
+			for (TransactionData  transactionData : unconfirmed) {
+				MessageTransactionData messageTransactionData = (MessageTransactionData) transactionData;
+				if (Objects.equals(messageTransactionData.getRecipient(), atAddress)) {
+					// There is a pending request for this trade, so block this buy attempt to reduce the risk of refunds
+					throw ApiExceptionFactory.INSTANCE.createCustomException(request, ApiError.INVALID_CRITERIA, "Trade has an existing buy request or is pending cancellation.");
+				}
+			}
+
 			AcctTradeBot.ResponseResult result = TradeBot.getInstance().startResponse(repository, atData, acct, crossChainTradeData,
 					tradeBotRespondRequest.foreignKey, tradeBotRespondRequest.receivingAddress);
 

src/main/java/org/qortal/arbitrary/misc/Service.java

@@ -84,6 +84,8 @@ public enum Service {
     QCHAT_IMAGE(420, true, 500*1024L, null),
     VIDEO(500, false, null, null),
     AUDIO(600, false, null, null),
+    QCHAT_AUDIO(610, true, 10*1024*1024L, null),
+    QCHAT_VOICE(620, true, 10*1024*1024L, null),
     BLOG(700, false, null, null),
     BLOG_POST(777, false, null, null),
     BLOG_COMMENT(778, false, null, null),

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

@@ -657,6 +657,10 @@ public class Block {
 		return this.atStates;
 	}
 
+	public byte[] getAtStatesHash() {
+		return this.atStatesHash;
+	}
+
 	/**
 	 * Return expanded info on block's online accounts.
 	 * <p>

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

@@ -400,12 +400,8 @@ public class Controller extends Thread {
 			RepositoryFactory repositoryFactory = new HSQLDBRepositoryFactory(getRepositoryUrl());
 			RepositoryManager.setRepositoryFactory(repositoryFactory);
 			RepositoryManager.setRequestedCheckpoint(Boolean.TRUE);
-
-			try (final Repository repository = RepositoryManager.getRepository()) {
-				RepositoryManager.archive(repository);
-				RepositoryManager.prune(repository);
-			}
-		} catch (DataException e) {
+		}
+		catch (DataException e) {
 			// If exception has no cause then repository is in use by some other process.
 			if (e.getCause() == null) {
 				LOGGER.info("Repository in use by another process?");
@@ -1379,9 +1375,24 @@ public class Controller extends Thread {
 			// If we have no block data, we should check the archive in case it's there
 			if (blockData == null) {
 				if (Settings.getInstance().isArchiveEnabled()) {
-					byte[] bytes = BlockArchiveReader.getInstance().fetchSerializedBlockBytesForSignature(signature, true, repository);
-					if (bytes != null) {
-						CachedBlockMessage blockMessage = new CachedBlockMessage(bytes);
+					Triple<byte[], Integer, Integer> serializedBlock = BlockArchiveReader.getInstance().fetchSerializedBlockBytesForSignature(signature, true, repository);
+					if (serializedBlock != null) {
+						byte[] bytes = serializedBlock.getA();
+						Integer serializationVersion = serializedBlock.getB();
+
+						Message blockMessage;
+						switch (serializationVersion) {
+							case 1:
+								blockMessage = new CachedBlockMessage(bytes);
+								break;
+
+							case 2:
+								blockMessage = new CachedBlockV2Message(bytes);
+								break;
+
+							default:
+								return;
+						}
 						blockMessage.setId(message.getId());
 
 						// This call also causes the other needed data to be pulled in from repository

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

@@ -204,7 +204,7 @@ public class ArbitraryDataCleanupManager extends Thread {
 
 						if (completeFileExists && !allChunksExist) {
 							// We have the complete file but not the chunks, so let's convert it
-							LOGGER.info(String.format("Transaction %s has complete file but no chunks",
+							LOGGER.debug(String.format("Transaction %s has complete file but no chunks",
 									Base58.encode(arbitraryTransactionData.getSignature())));
 
 							ArbitraryTransactionUtils.convertFileToChunks(arbitraryTransactionData, now, STALE_FILE_TIMEOUT);

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

@@ -39,9 +39,10 @@ public class AtStatesPruner implements Runnable {
 
 		try (final Repository repository = RepositoryManager.getRepository()) {
 			int pruneStartHeight = repository.getATRepository().getAtPruneHeight();
+			int maxLatestAtStatesHeight = PruneManager.getMaxHeightForLatestAtStates(repository);
 
 			repository.discardChanges();
-			repository.getATRepository().rebuildLatestAtStates();
+			repository.getATRepository().rebuildLatestAtStates(maxLatestAtStatesHeight);
 			repository.saveChanges();
 
 			while (!Controller.isStopping()) {
@@ -92,7 +93,8 @@ public class AtStatesPruner implements Runnable {
 					if (upperPrunableHeight > upperBatchHeight) {
 						pruneStartHeight = upperBatchHeight;
 						repository.getATRepository().setAtPruneHeight(pruneStartHeight);
-						repository.getATRepository().rebuildLatestAtStates();
+						maxLatestAtStatesHeight = PruneManager.getMaxHeightForLatestAtStates(repository);
+						repository.getATRepository().rebuildLatestAtStates(maxLatestAtStatesHeight);
 						repository.saveChanges();
 
 						final int finalPruneStartHeight = pruneStartHeight;

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

@@ -26,9 +26,10 @@ public class AtStatesTrimmer implements Runnable {
 
 		try (final Repository repository = RepositoryManager.getRepository()) {
 			int trimStartHeight = repository.getATRepository().getAtTrimHeight();
+			int maxLatestAtStatesHeight = PruneManager.getMaxHeightForLatestAtStates(repository);
 
 			repository.discardChanges();
-			repository.getATRepository().rebuildLatestAtStates();
+			repository.getATRepository().rebuildLatestAtStates(maxLatestAtStatesHeight);
 			repository.saveChanges();
 
 			while (!Controller.isStopping()) {
@@ -70,7 +71,8 @@ public class AtStatesTrimmer implements Runnable {
 					if (upperTrimmableHeight > upperBatchHeight) {
 						trimStartHeight = upperBatchHeight;
 						repository.getATRepository().setAtTrimHeight(trimStartHeight);
-						repository.getATRepository().rebuildLatestAtStates();
+						maxLatestAtStatesHeight = PruneManager.getMaxHeightForLatestAtStates(repository);
+						repository.getATRepository().rebuildLatestAtStates(maxLatestAtStatesHeight);
 						repository.saveChanges();
 
 						final int finalTrimStartHeight = trimStartHeight;

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

@@ -0,0 +1,121 @@
+package org.qortal.controller.repository;
+
+import org.apache.commons.io.FileUtils;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.qortal.controller.Controller;
+import org.qortal.controller.Synchronizer;
+import org.qortal.repository.*;
+import org.qortal.settings.Settings;
+import org.qortal.transform.TransformationException;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+
+public class BlockArchiveRebuilder {
+
+    private static final Logger LOGGER = LogManager.getLogger(BlockArchiveRebuilder.class);
+
+    private final int serializationVersion;
+
+    public BlockArchiveRebuilder(int serializationVersion) {
+        this.serializationVersion = serializationVersion;
+    }
+
+    public void start() throws DataException, IOException {
+        if (!Settings.getInstance().isArchiveEnabled() || Settings.getInstance().isLite()) {
+            return;
+        }
+
+        // New archive path is in a different location from original archive path, to avoid conflicts.
+        // It will be moved later, once the process is complete.
+        final Path newArchivePath = Paths.get(Settings.getInstance().getRepositoryPath(), "archive-rebuild");
+        final Path originalArchivePath = Paths.get(Settings.getInstance().getRepositoryPath(), "archive");
+
+        // Delete archive-rebuild if it exists from a previous attempt
+        FileUtils.deleteDirectory(newArchivePath.toFile());
+
+        try (final Repository repository = RepositoryManager.getRepository()) {
+            int startHeight = 1; // We need to rebuild the entire archive
+
+            LOGGER.info("Rebuilding block archive from height {}...", startHeight);
+
+            while (!Controller.isStopping()) {
+                repository.discardChanges();
+
+                Thread.sleep(1000L);
+
+                // Don't even attempt if we're mid-sync as our repository requests will be delayed for ages
+                if (Synchronizer.getInstance().isSynchronizing()) {
+                    continue;
+                }
+
+                // Rebuild archive
+                try {
+                    final int maximumArchiveHeight = BlockArchiveReader.getInstance().getHeightOfLastArchivedBlock();
+                    if (startHeight >= maximumArchiveHeight) {
+                        // We've finished.
+                        // Delete existing archive and move the newly built one into its place
+                        FileUtils.deleteDirectory(originalArchivePath.toFile());
+                        FileUtils.moveDirectory(newArchivePath.toFile(), originalArchivePath.toFile());
+                        BlockArchiveReader.getInstance().invalidateFileListCache();
+                        LOGGER.info("Block archive successfully rebuilt");
+                        return;
+                    }
+
+                    BlockArchiveWriter writer = new BlockArchiveWriter(startHeight, maximumArchiveHeight, serializationVersion, newArchivePath, repository);
+
+                    // Set data source to BLOCK_ARCHIVE as we are rebuilding
+                    writer.setDataSource(BlockArchiveWriter.BlockArchiveDataSource.BLOCK_ARCHIVE);
+
+                    // We can't enforce the 100MB file size target, as the final file needs to contain all blocks
+                    // that exist in the current archive. Otherwise, the final blocks in the archive will be lost.
+                    writer.setShouldEnforceFileSizeTarget(false);
+
+                    // We want to log the rebuild progress
+                    writer.setShouldLogProgress(true);
+
+                    BlockArchiveWriter.BlockArchiveWriteResult result = writer.write();
+                    switch (result) {
+                        case OK:
+                            // Increment block archive height
+                            startHeight += writer.getWrittenCount();
+                            repository.saveChanges();
+                            break;
+
+                        case STOPPING:
+                            return;
+
+                        // We've reached the limit of the blocks we can archive
+                        // Sleep for a while to allow more to become available
+                        case NOT_ENOUGH_BLOCKS:
+                            // This shouldn't happen, as we're not enforcing minimum file sizes
+                            repository.discardChanges();
+                            throw new DataException("Unable to rebuild archive due to unexpected NOT_ENOUGH_BLOCKS response.");
+
+                        case BLOCK_NOT_FOUND:
+                            // We tried to archive a block that didn't exist. This is a major failure and likely means
+                            // that a bootstrap or re-sync is needed. Try again every minute until then.
+                            LOGGER.info("Error: block not found when rebuilding archive. If this error persists, " +
+                                    "a bootstrap or re-sync may be needed.");
+                            repository.discardChanges();
+                            throw new DataException("Unable to rebuild archive because a block is missing.");
+                    }
+
+                } catch (IOException | TransformationException e) {
+                    LOGGER.info("Caught exception when rebuilding block archive", e);
+                    throw new DataException("Unable to rebuild block archive");
+                }
+
+            }
+        } catch (InterruptedException e) {
+            // Do nothing
+        } finally {
+            // Delete archive-rebuild if it still exists, as that means something went wrong
+            FileUtils.deleteDirectory(newArchivePath.toFile());
+        }
+    }
+
+}

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

@@ -157,4 +157,18 @@ public class PruneManager {
         return (height < latestUnprunedHeight);
     }
 
+    /**
+     * When rebuilding the latest AT states, we need to specify a maxHeight, so that we aren't tracking
+     * very recent AT states that could potentially be orphaned. This method ensures that AT states
+     * are given a sufficient number of blocks to confirm before being tracked as a latest AT state.
+     */
+    public static int getMaxHeightForLatestAtStates(Repository repository) throws DataException {
+        // Get current chain height, and subtract a certain number of "confirmation" blocks
+        // This is to ensure we are basing our latest AT states data on confirmed blocks -
+        // ones that won't be orphaned in any normal circumstances
+        final int confirmationBlocks = 250;
+        final int chainHeight = repository.getBlockRepository().getBlockchainHeight();
+        return chainHeight - confirmationBlocks;
+    }
+
 }

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

@@ -49,6 +49,7 @@ public class Bitcoin extends Bitcoiny {
 						//CLOSED new Server("bitcoin.grey.pw", Server.ConnectionType.SSL, 50002),
 						//CLOSED new Server("btc.litepay.ch", Server.ConnectionType.SSL, 50002),
 						//CLOSED new Server("electrum.pabu.io", Server.ConnectionType.SSL, 50002),
+						//CLOSED new Server("electrumx.dev", Server.ConnectionType.SSL, 50002),
 						//CLOSED new Server("electrumx.hodlwallet.com", Server.ConnectionType.SSL, 50002),
 						//CLOSED new Server("gd42.org", Server.ConnectionType.SSL, 50002),
 						//CLOSED new Server("korea.electrum-server.com", Server.ConnectionType.SSL, 50002),
@@ -56,28 +57,75 @@ public class Bitcoin extends Bitcoiny {
 						//1.15.0 new Server("alviss.coinjoined.com", Server.ConnectionType.SSL, 50002),
 						//1.15.0 new Server("electrum.acinq.co", Server.ConnectionType.SSL, 50002),
 						//1.14.0 new Server("electrum.coinext.com.br", Server.ConnectionType.SSL, 50002),
+						//F1.7.0 new Server("btc.lastingcoin.net", Server.ConnectionType.SSL, 50002),
 						new Server("104.248.139.211", Server.ConnectionType.SSL, 50002),
+						new Server("128.0.190.26", Server.ConnectionType.SSL, 50002),
 						new Server("142.93.6.38", Server.ConnectionType.SSL, 50002),
 						new Server("157.245.172.236", Server.ConnectionType.SSL, 50002),
 						new Server("167.172.226.175", Server.ConnectionType.SSL, 50002),
 						new Server("167.172.42.31", Server.ConnectionType.SSL, 50002),
 						new Server("178.62.80.20", Server.ConnectionType.SSL, 50002),
 						new Server("185.64.116.15", Server.ConnectionType.SSL, 50002),
+						new Server("188.165.206.215", Server.ConnectionType.SSL, 50002),
+						new Server("188.165.211.112", Server.ConnectionType.SSL, 50002),
+						new Server("2azzarita.hopto.org", Server.ConnectionType.SSL, 50002),
+						new Server("2electrumx.hopto.me", Server.ConnectionType.SSL, 56022),
+						new Server("2ex.digitaleveryware.com", Server.ConnectionType.SSL, 50002),
+						new Server("65.39.140.37", Server.ConnectionType.SSL, 50002),
 						new Server("68.183.188.105", Server.ConnectionType.SSL, 50002),
+						new Server("71.73.14.254", Server.ConnectionType.SSL, 50002),
+						new Server("94.23.247.135", Server.ConnectionType.SSL, 50002),
+						new Server("assuredly.not.fyi", Server.ConnectionType.SSL, 50002),
+						new Server("ax101.blockeng.ch", Server.ConnectionType.SSL, 50002),
+						new Server("ax102.blockeng.ch", Server.ConnectionType.SSL, 50002),
+						new Server("b.1209k.com", Server.ConnectionType.SSL, 50002),
+						new Server("b6.1209k.com", Server.ConnectionType.SSL, 50002),
+						new Server("bitcoin.dermichi.com", Server.ConnectionType.SSL, 50002),
+						new Server("bitcoin.lu.ke", Server.ConnectionType.SSL, 50002),
 						new Server("bitcoin.lukechilds.co", Server.ConnectionType.SSL, 50002),
 						new Server("blkhub.net", Server.ConnectionType.SSL, 50002),
-						new Server("btc.lastingcoin.net", Server.ConnectionType.SSL, 50002),
+						new Server("btc.electroncash.dk", Server.ConnectionType.SSL, 60002),
+						new Server("btc.ocf.sh", Server.ConnectionType.SSL, 50002),
 						new Server("btce.iiiiiii.biz", Server.ConnectionType.SSL, 50002),
 						new Server("caleb.vegas", Server.ConnectionType.SSL, 50002),
 						new Server("eai.coincited.net", Server.ConnectionType.SSL, 50002),
+						new Server("electrum.bhoovd.com", Server.ConnectionType.SSL, 50002),
 						new Server("electrum.bitaroo.net", Server.ConnectionType.SSL, 50002),
-						new Server("electrumx.dev", Server.ConnectionType.SSL, 50002),
+						new Server("electrum.bitcoinlizard.net", Server.ConnectionType.SSL, 50002),
+						new Server("electrum.blockstream.info", Server.ConnectionType.SSL, 50002),
+						new Server("electrum.emzy.de", Server.ConnectionType.SSL, 50002),
+						new Server("electrum.exan.tech", Server.ConnectionType.SSL, 50002),
+						new Server("electrum.kendigisland.xyz", Server.ConnectionType.SSL, 50002),
+						new Server("electrum.mmitech.info", Server.ConnectionType.SSL, 50002),
+						new Server("electrum.petrkr.net", Server.ConnectionType.SSL, 50002),
+						new Server("electrum.stippy.com", Server.ConnectionType.SSL, 50002),
+						new Server("electrum.thomasfischbach.de", Server.ConnectionType.SSL, 50002),
+						new Server("electrum0.snel.it", Server.ConnectionType.SSL, 50002),
+						new Server("electrum1.cipig.net", Server.ConnectionType.SSL, 50002),
+						new Server("electrum2.cipig.net", Server.ConnectionType.SSL, 50002),
+						new Server("electrum3.cipig.net", Server.ConnectionType.SSL, 50002),
+						new Server("electrumx.alexridevski.net", Server.ConnectionType.SSL, 50002),
+						new Server("electrumx-core.1209k.com", Server.ConnectionType.SSL, 50002),
 						new Server("elx.bitske.com", Server.ConnectionType.SSL, 50002),
+						new Server("ex03.axalgo.com", Server.ConnectionType.SSL, 50002),
+						new Server("ex05.axalgo.com", Server.ConnectionType.SSL, 50002),
+						new Server("ex07.axalgo.com", Server.ConnectionType.SSL, 50002),
 						new Server("fortress.qtornado.com", Server.ConnectionType.SSL, 50002),
+						new Server("fulcrum.grey.pw", Server.ConnectionType.SSL, 50002),
+						new Server("fulcrum.sethforprivacy.com", Server.ConnectionType.SSL, 51002),
 						new Server("guichet.centure.cc", Server.ConnectionType.SSL, 50002),
-						new Server("kareoke.qoppa.org", Server.ConnectionType.SSL, 50002),
 						new Server("hodlers.beer", Server.ConnectionType.SSL, 50002),
+						new Server("kareoke.qoppa.org", Server.ConnectionType.SSL, 50002),
+						new Server("kirsche.emzy.de", Server.ConnectionType.SSL, 50002),
 						new Server("node1.btccuracao.com", Server.ConnectionType.SSL, 50002),
+						new Server("osr1ex1.compumundohipermegared.one", Server.ConnectionType.SSL, 50002),
+						new Server("smmalis37.ddns.net", Server.ConnectionType.SSL, 50002),
+						new Server("ulrichard.ch", Server.ConnectionType.SSL, 50002),
+						new Server("vmd104012.contaboserver.net", Server.ConnectionType.SSL, 50002),
+						new Server("vmd104014.contaboserver.net", Server.ConnectionType.SSL, 50002),
+						new Server("vmd63185.contaboserver.net", Server.ConnectionType.SSL, 50002),
+						new Server("vmd71287.contaboserver.net", Server.ConnectionType.SSL, 50002),
+						new Server("vmd84592.contaboserver.net", Server.ConnectionType.SSL, 50002),
 						new Server("xtrum.com", Server.ConnectionType.SSL, 50002));
 			}
 

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

@@ -167,6 +167,16 @@ public abstract class Bitcoiny implements ForeignBlockchain {
 		return blockTimestamps.get(5);
 	}
 
+	/**
+	 * Returns height from latest block.
+	 * <p>
+	 * @throws ForeignBlockchainException if error occurs
+	 */
+	public int getBlockchainHeight() throws ForeignBlockchainException {
+		int height = this.blockchainProvider.getCurrentHeight();
+		return height;
+	}
+
 	/** Returns fee per transaction KB. To be overridden for testnet/regtest. */
 	public Coin getFeePerKb() {
 		return this.bitcoinjContext.getFeePerKb();

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

@@ -45,6 +45,9 @@ public class Digibyte extends Bitcoiny {
 				return Arrays.asList(
 						// Servers chosen on NO BASIS WHATSOEVER from various sources!
 						// Status verified at https://1209k.com/bitcoin-eye/ele.php?chain=dgb
+						new Server("electrum.qortal.link", Server.ConnectionType.SSL, 55002),
+						new Server("electrum-dgb.qortal.online", ConnectionType.SSL, 50002),
+						new Server("electrum1-dgb.qortal.online", ConnectionType.SSL, 50002),
 						new Server("electrum1.cipig.net", ConnectionType.SSL, 20059),
 						new Server("electrum2.cipig.net", ConnectionType.SSL, 20059),
 						new Server("electrum3.cipig.net", ConnectionType.SSL, 20059));

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

@@ -45,10 +45,13 @@ public class Dogecoin extends Bitcoiny {
 			public Collection<Server> getServers() {
 				return Arrays.asList(
 						// Servers chosen on NO BASIS WHATSOEVER from various sources!
+						// Status verified at https://1209k.com/bitcoin-eye/ele.php?chain=doge
+						new Server("electrum.qortal.link", Server.ConnectionType.SSL, 54002),
+						new Server("electrum-doge.qortal.online", ConnectionType.SSL, 50002),
+						new Server("electrum1-doge.qortal.online", ConnectionType.SSL, 50002),
 						new Server("electrum1.cipig.net", ConnectionType.SSL, 20060),
 						new Server("electrum2.cipig.net", ConnectionType.SSL, 20060),
 						new Server("electrum3.cipig.net", ConnectionType.SSL, 20060));
-						// TODO: add more mainnet servers. It's too centralized.
 			}
 
 			@Override

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

@@ -45,15 +45,19 @@ public class Litecoin extends Bitcoiny {
 				return Arrays.asList(
 						// Servers chosen on NO BASIS WHATSOEVER from various sources!
 						// Status verified at https://1209k.com/bitcoin-eye/ele.php?chain=ltc
-						//CLOSED new Server("electrum-ltc.petrkr.net", Server.ConnectionType.SSL, 60002),
 						//CLOSED new Server("electrum-ltc.someguy123.net", Server.ConnectionType.SSL, 50002),
+						//CLOSED new Server("ltc.litepay.ch", Server.ConnectionType.SSL, 50022),
+						//BEHIND new Server("62.171.169.176", Server.ConnectionType.SSL, 50002),
 						//PHISHY new Server("electrum-ltc.bysh.me", Server.ConnectionType.SSL, 50002),
 						new Server("backup.electrum-ltc.org", Server.ConnectionType.SSL, 443),
+						new Server("electrum.qortal.link", Server.ConnectionType.SSL, 50002),
 						new Server("electrum.ltc.xurious.com", Server.ConnectionType.SSL, 50002),
+						new Server("electrum-ltc.petrkr.net", Server.ConnectionType.SSL, 60002),
+						new Server("electrum-ltc.qortal.online", Server.ConnectionType.SSL, 50002),
+						new Server("electrum1-ltc.qortal.online", Server.ConnectionType.SSL, 50002),
 						new Server("electrum1.cipig.net", Server.ConnectionType.SSL, 20063),
 						new Server("electrum2.cipig.net", Server.ConnectionType.SSL, 20063),
 						new Server("electrum3.cipig.net", Server.ConnectionType.SSL, 20063),
-						new Server("ltc.litepay.ch", Server.ConnectionType.SSL, 50022),
 						new Server("ltc.rentonrisk.com", Server.ConnectionType.SSL, 50002));
 			}
 

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

@@ -57,9 +57,9 @@ public class PirateChain extends Bitcoiny {
 			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("wallet-arrr1.qortal.online", ConnectionType.SSL, 443),
+						new Server("wallet-arrr2.qortal.online", ConnectionType.SSL, 443),
+						new Server("wallet-arrr3.qortal.online", ConnectionType.SSL, 443),
 						new Server("lightd.pirate.black", ConnectionType.SSL, 443));
 			}
 

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

@@ -45,13 +45,17 @@ public class Ravencoin extends Bitcoiny {
 				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),
+						//CLOSED new Server("aethyn.com", ConnectionType.SSL, 50002),
+						//CLOSED new Server("electrum2.rvn.rocks", ConnectionType.SSL, 50002),
+						//BEHIND new Server("electrum3.rvn.rocks", ConnectionType.SSL, 50002),
+						new Server("electrum.qortal.link", Server.ConnectionType.SSL, 56002),
+						new Server("electrum-rvn.qortal.online", ConnectionType.SSL, 50002),
+						new Server("electrum1-rvn.qortal.online", ConnectionType.SSL, 50002),
 						new Server("electrum1.cipig.net", ConnectionType.SSL, 20051),
 						new Server("electrum2.cipig.net", ConnectionType.SSL, 20051),
-						new Server("electrum3.cipig.net", ConnectionType.SSL, 20051));
+						new Server("electrum3.cipig.net", ConnectionType.SSL, 20051),
+						new Server("rvn-dashboard.com", ConnectionType.SSL, 50002),
+						new Server("rvn4lyfe.com", ConnectionType.SSL, 50002));
 			}
 
 			@Override

src/main/java/org/qortal/data/chat/ActiveChats.java

@@ -17,17 +17,21 @@ public class ActiveChats {
 		private Long timestamp;
 		private String sender;
 		private String senderName;
+		private byte[] signature;
+		private byte[] data;
 
 		protected GroupChat() {
 			/* JAXB */
 		}
 
-		public GroupChat(int groupId, String groupName, Long timestamp, String sender, String senderName) {
+		public GroupChat(int groupId, String groupName, Long timestamp, String sender, String senderName, byte[] signature, byte[] data) {
 			this.groupId = groupId;
 			this.groupName = groupName;
 			this.timestamp = timestamp;
 			this.sender = sender;
 			this.senderName = senderName;
+			this.signature = signature;
+			this.data = data;
 		}
 
 		public int getGroupId() {
@@ -49,6 +53,14 @@ public class ActiveChats {
 		public String getSenderName() {
 			return this.senderName;
 		}
+
+		public byte[] getSignature() {
+			return this.signature;
+		}
+
+		public byte[] getData() {
+			return this.data;
+		}
 	}
 
 	@XmlAccessorType(XmlAccessType.FIELD)
@@ -118,4 +130,4 @@ public class ActiveChats {
 		return this.direct;
 	}
 
-}
+}

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

@@ -16,6 +16,8 @@ import org.qortal.repository.Repository;
 import org.qortal.transaction.Transaction.TransactionType;
 import org.qortal.utils.Unicode;
 
+import java.util.Objects;
+
 public class Name {
 
 	// Properties
@@ -116,7 +118,7 @@ public class Name {
 
 		this.repository.getNameRepository().save(this.nameData);
 
-		if (!updateNameTransactionData.getNewName().isEmpty())
+		if (!updateNameTransactionData.getNewName().isEmpty() && !Objects.equals(updateNameTransactionData.getName(), updateNameTransactionData.getNewName()))
 			// Name has changed, delete old entry
 			this.repository.getNameRepository().delete(updateNameTransactionData.getNewName());
 

src/main/java/org/qortal/network/message/CachedBlockV2Message.java

@@ -0,0 +1,43 @@
+package org.qortal.network.message;
+
+import com.google.common.primitives.Ints;
+import org.qortal.block.Block;
+import org.qortal.transform.TransformationException;
+import org.qortal.transform.block.BlockTransformer;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
+// This is an OUTGOING-only Message which more readily lends itself to being cached
+public class CachedBlockV2Message extends Message implements Cloneable {
+
+	public CachedBlockV2Message(Block block) throws TransformationException {
+		super(MessageType.BLOCK_V2);
+
+		ByteArrayOutputStream bytes = new ByteArrayOutputStream();
+
+		try {
+			bytes.write(Ints.toByteArray(block.getBlockData().getHeight()));
+
+			bytes.write(BlockTransformer.toBytes(block));
+		} catch (IOException e) {
+			throw new AssertionError("IOException shouldn't occur with ByteArrayOutputStream");
+		}
+
+		this.dataBytes = bytes.toByteArray();
+		this.checksumBytes = Message.generateChecksum(this.dataBytes);
+	}
+
+	public CachedBlockV2Message(byte[] cachedBytes) {
+		super(MessageType.BLOCK_V2);
+
+		this.dataBytes = cachedBytes;
+		this.checksumBytes = Message.generateChecksum(this.dataBytes);
+	}
+
+	public static Message fromByteBuffer(int id, ByteBuffer byteBuffer) {
+		throw new UnsupportedOperationException("CachedBlockMessageV2 is for outgoing messages only");
+	}
+
+}

src/main/java/org/qortal/repository/ATRepository.java

@@ -119,7 +119,7 @@ public interface ATRepository {
 	 * <p>
 	 * NOTE: performs implicit <tt>repository.saveChanges()</tt>.
 	 */
-	public void rebuildLatestAtStates() throws DataException;
+	public void rebuildLatestAtStates(int maxHeight) throws DataException;
 
 
 	/** Returns height of first trimmable AT state. */

src/main/java/org/qortal/repository/BlockArchiveReader.java

@@ -3,10 +3,7 @@ package org.qortal.repository;
 import com.google.common.primitives.Ints;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
-import org.qortal.data.at.ATStateData;
 import org.qortal.data.block.BlockArchiveData;
-import org.qortal.data.block.BlockData;
-import org.qortal.data.transaction.TransactionData;
 import org.qortal.settings.Settings;
 import org.qortal.transform.TransformationException;
 import org.qortal.transform.block.BlockTransformation;
@@ -67,20 +64,51 @@ public class BlockArchiveReader {
         this.fileListCache = Map.copyOf(map);
     }
 
+    public Integer fetchSerializationVersionForHeight(int height) {
+        if (this.fileListCache == null) {
+            this.fetchFileList();
+        }
+
+        Triple<byte[], Integer, Integer> serializedBlock = this.fetchSerializedBlockBytesForHeight(height);
+        if (serializedBlock == null) {
+            return null;
+        }
+        Integer serializationVersion = serializedBlock.getB();
+        return serializationVersion;
+    }
+
     public BlockTransformation fetchBlockAtHeight(int height) {
         if (this.fileListCache == null) {
             this.fetchFileList();
         }
 
-        byte[] serializedBytes = this.fetchSerializedBlockBytesForHeight(height);
-        if (serializedBytes == null) {
+        Triple<byte[], Integer, Integer> serializedBlock = this.fetchSerializedBlockBytesForHeight(height);
+        if (serializedBlock == null) {
+            return null;
+        }
+        byte[] serializedBytes = serializedBlock.getA();
+        Integer serializationVersion = serializedBlock.getB();
+        if (serializedBytes == null || serializationVersion == null) {
             return null;
         }
 
         ByteBuffer byteBuffer = ByteBuffer.wrap(serializedBytes);
         BlockTransformation blockInfo = null;
         try {
-            blockInfo = BlockTransformer.fromByteBuffer(byteBuffer);
+            switch (serializationVersion) {
+                case 1:
+                    blockInfo = BlockTransformer.fromByteBuffer(byteBuffer);
+                    break;
+
+                case 2:
+                    blockInfo = BlockTransformer.fromByteBufferV2(byteBuffer);
+                    break;
+
+                default:
+                    // Invalid serialization version
+                    return null;
+            }
+
             if (blockInfo != null && blockInfo.getBlockData() != null) {
                 // Block height is stored outside of the main serialized bytes, so it
                 // won't be set automatically.
@@ -168,15 +196,20 @@ public class BlockArchiveReader {
         return null;
     }
 
-    public byte[] fetchSerializedBlockBytesForSignature(byte[] signature, boolean includeHeightPrefix, Repository repository) {
+    public Triple<byte[], Integer, Integer> fetchSerializedBlockBytesForSignature(byte[] signature, boolean includeHeightPrefix, Repository repository) {
         if (this.fileListCache == null) {
             this.fetchFileList();
         }
 
         Integer height = this.fetchHeightForSignature(signature, repository);
         if (height != null) {
-            byte[] blockBytes = this.fetchSerializedBlockBytesForHeight(height);
-            if (blockBytes == null) {
+            Triple<byte[], Integer, Integer> serializedBlock = this.fetchSerializedBlockBytesForHeight(height);
+            if (serializedBlock == null) {
+                return null;
+            }
+            byte[] blockBytes = serializedBlock.getA();
+            Integer version = serializedBlock.getB();
+            if (blockBytes == null || version == null) {
                 return null;
             }
 
@@ -187,18 +220,18 @@ public class BlockArchiveReader {
                 try {
                     bytes.write(Ints.toByteArray(height));
                     bytes.write(blockBytes);
-                    return bytes.toByteArray();
+                    return new Triple<>(bytes.toByteArray(), version, height);
 
                 } catch (IOException e) {
                     return null;
                 }
             }
-            return blockBytes;
+            return new Triple<>(blockBytes, version, height);
         }
         return null;
     }
 
-    public byte[] fetchSerializedBlockBytesForHeight(int height) {
+    public Triple<byte[], Integer, Integer> fetchSerializedBlockBytesForHeight(int height) {
         String filename = this.getFilenameForHeight(height);
         if (filename == null) {
             // We don't have this block in the archive
@@ -221,7 +254,7 @@ public class BlockArchiveReader {
             // End of fixed length header
 
             // Make sure the version is one we recognize
-            if (version != 1) {
+            if (version != 1 && version != 2) {
                 LOGGER.info("Error: unknown version in file {}: {}", filename, version);
                 return null;
             }
@@ -258,7 +291,7 @@ public class BlockArchiveReader {
             byte[] blockBytes = new byte[blockLength];
             file.read(blockBytes);
 
-            return blockBytes;
+            return new Triple<>(blockBytes, version, height);
 
         } catch (FileNotFoundException e) {
             LOGGER.info("File {} not found: {}", filename, e.getMessage());
@@ -279,6 +312,30 @@ public class BlockArchiveReader {
         }
     }
 
+    public int getHeightOfLastArchivedBlock() {
+        if (this.fileListCache == null) {
+            this.fetchFileList();
+        }
+
+        int maxEndHeight = 0;
+
+        Iterator it = this.fileListCache.entrySet().iterator();
+        while (it.hasNext()) {
+            Map.Entry pair = (Map.Entry) it.next();
+            if (pair == null && pair.getKey() == null && pair.getValue() == null) {
+                continue;
+            }
+            Triple<Integer, Integer, Integer> heightInfo = (Triple<Integer, Integer, Integer>) pair.getValue();
+            Integer endHeight = heightInfo.getB();
+
+            if (endHeight != null && endHeight > maxEndHeight) {
+                maxEndHeight = endHeight;
+            }
+        }
+
+        return maxEndHeight;
+    }
+
     public void invalidateFileListCache() {
         this.fileListCache = null;
     }

src/main/java/org/qortal/repository/BlockArchiveWriter.java

@@ -6,10 +6,13 @@ import org.apache.logging.log4j.Logger;
 import org.qortal.block.Block;
 import org.qortal.controller.Controller;
 import org.qortal.controller.Synchronizer;
+import org.qortal.data.at.ATStateData;
 import org.qortal.data.block.BlockArchiveData;
 import org.qortal.data.block.BlockData;
+import org.qortal.data.transaction.TransactionData;
 import org.qortal.settings.Settings;
 import org.qortal.transform.TransformationException;
+import org.qortal.transform.block.BlockTransformation;
 import org.qortal.transform.block.BlockTransformer;
 
 import java.io.ByteArrayOutputStream;
@@ -18,6 +21,7 @@ import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
+import java.util.List;
 
 public class BlockArchiveWriter {
 
@@ -28,25 +32,71 @@ public class BlockArchiveWriter {
         BLOCK_NOT_FOUND
     }
 
+    public enum BlockArchiveDataSource {
+        BLOCK_REPOSITORY, // To build an archive from the Blocks table
+        BLOCK_ARCHIVE // To build a new archive from an existing archive
+    }
+
     private static final Logger LOGGER = LogManager.getLogger(BlockArchiveWriter.class);
 
     public static final long DEFAULT_FILE_SIZE_TARGET = 100 * 1024 * 1024; // 100MiB
 
     private int startHeight;
     private final int endHeight;
+    private final Integer serializationVersion;
+    private final Path archivePath;
     private final Repository repository;
 
     private long fileSizeTarget = DEFAULT_FILE_SIZE_TARGET;
     private boolean shouldEnforceFileSizeTarget = true;
 
+    // Default data source to BLOCK_REPOSITORY; can optionally be overridden
+    private BlockArchiveDataSource dataSource = BlockArchiveDataSource.BLOCK_REPOSITORY;
+
+    private boolean shouldLogProgress = false;
+
     private int writtenCount;
     private int lastWrittenHeight;
     private Path outputPath;
 
-    public BlockArchiveWriter(int startHeight, int endHeight, Repository repository) {
+    /**
+     * Instantiate a BlockArchiveWriter using a custom archive path
+     * @param startHeight
+     * @param endHeight
+     * @param repository
+     */
+    public BlockArchiveWriter(int startHeight, int endHeight, Integer serializationVersion, Path archivePath, Repository repository) {
         this.startHeight = startHeight;
         this.endHeight = endHeight;
+        this.archivePath = archivePath.toAbsolutePath();
         this.repository = repository;
+
+        if (serializationVersion == null) {
+            // When serialization version isn't specified, fetch it from the existing archive
+            serializationVersion = this.findSerializationVersion();
+        }
+        this.serializationVersion = serializationVersion;
+    }
+
+    /**
+     * Instantiate a BlockArchiveWriter using the default archive path and version
+     * @param startHeight
+     * @param endHeight
+     * @param repository
+     */
+    public BlockArchiveWriter(int startHeight, int endHeight, Repository repository) {
+        this(startHeight, endHeight, null, Paths.get(Settings.getInstance().getRepositoryPath(), "archive"), repository);
+    }
+
+    private int findSerializationVersion() {
+        // Attempt to fetch the serialization version from the existing archive
+        Integer block2SerializationVersion = BlockArchiveReader.getInstance().fetchSerializationVersionForHeight(2);
+        if (block2SerializationVersion != null) {
+            return block2SerializationVersion;
+        }
+
+        // Default to version specified in settings
+        return Settings.getInstance().getDefaultArchiveVersion();
     }
 
     public static int getMaxArchiveHeight(Repository repository) throws DataException {
@@ -72,8 +122,7 @@ public class BlockArchiveWriter {
 
     public BlockArchiveWriteResult write() throws DataException, IOException, TransformationException, InterruptedException {
         // Create the archive folder if it doesn't exist
-        // This is a subfolder of the db directory, to make bootstrapping easier
-        Path archivePath = Paths.get(Settings.getInstance().getRepositoryPath(), "archive").toAbsolutePath();
+        // This is generally a subfolder of the db directory, to make bootstrapping easier
         try {
             Files.createDirectories(archivePath);
         } catch (IOException e) {
@@ -95,13 +144,13 @@ public class BlockArchiveWriter {
 
         LOGGER.info(String.format("Fetching blocks from height %d...", startHeight));
         int i = 0;
-        while (headerBytes.size() + bytes.size() < this.fileSizeTarget
-                || this.shouldEnforceFileSizeTarget == false) {
+        while (headerBytes.size() + bytes.size() < this.fileSizeTarget) {
 
             if (Controller.isStopping()) {
                 return BlockArchiveWriteResult.STOPPING;
             }
             if (Synchronizer.getInstance().isSynchronizing()) {
+                Thread.sleep(1000L);
                 continue;
             }
 
@@ -112,7 +161,28 @@ public class BlockArchiveWriter {
 
             //LOGGER.info("Fetching block {}...", currentHeight);
 
-            BlockData blockData = repository.getBlockRepository().fromHeight(currentHeight);
+            BlockData blockData = null;
+            List<TransactionData> transactions = null;
+            List<ATStateData> atStates = null;
+            byte[] atStatesHash = null;
+
+            switch (this.dataSource) {
+                case BLOCK_ARCHIVE:
+                    BlockTransformation archivedBlock = BlockArchiveReader.getInstance().fetchBlockAtHeight(currentHeight);
+                    if (archivedBlock != null) {
+                        blockData = archivedBlock.getBlockData();
+                        transactions = archivedBlock.getTransactions();
+                        atStates = archivedBlock.getAtStates();
+                        atStatesHash = archivedBlock.getAtStatesHash();
+                    }
+                    break;
+
+                case BLOCK_REPOSITORY:
+                default:
+                    blockData = repository.getBlockRepository().fromHeight(currentHeight);
+                    break;
+            }
+
             if (blockData == null) {
                 return BlockArchiveWriteResult.BLOCK_NOT_FOUND;
             }
@@ -122,18 +192,50 @@ public class BlockArchiveWriter {
             repository.getBlockArchiveRepository().save(blockArchiveData);
             repository.saveChanges();
 
+            // Build the block
+            Block block;
+            if (atStatesHash != null) {
+                block = new Block(repository, blockData, transactions, atStatesHash);
+            }
+            else if (atStates != null) {
+                block = new Block(repository, blockData, transactions, atStates);
+            }
+            else {
+                block = new Block(repository, blockData);
+            }
+
             // Write the block data to some byte buffers
-            Block block = new Block(repository, blockData);
             int blockIndex = bytes.size();
             // Write block index to header
             headerBytes.write(Ints.toByteArray(blockIndex));
             // Write block height
             bytes.write(Ints.toByteArray(block.getBlockData().getHeight()));
-            byte[] blockBytes = BlockTransformer.toBytes(block);
+
+            // Get serialized block bytes
+            byte[] blockBytes;
+            switch (serializationVersion) {
+                case 1:
+                    blockBytes = BlockTransformer.toBytes(block);
+                    break;
+
+                case 2:
+                    blockBytes = BlockTransformer.toBytesV2(block);
+                    break;
+
+                default:
+                    throw new DataException("Invalid serialization version");
+            }
+
             // Write block length
             bytes.write(Ints.toByteArray(blockBytes.length));
             // Write block bytes
             bytes.write(blockBytes);
+
+            // Log every 1000 blocks
+            if (this.shouldLogProgress && i % 1000 == 0) {
+                LOGGER.info("Archived up to block height {}. Size of current file: {} bytes", currentHeight, (headerBytes.size() + bytes.size()));
+            }
+
             i++;
 
         }
@@ -147,11 +249,10 @@ public class BlockArchiveWriter {
 
         // We have enough blocks to create a new file
         int endHeight = startHeight + i - 1;
-        int version = 1;
         String filePath = String.format("%s/%d-%d.dat", archivePath.toString(), startHeight, endHeight);
         FileOutputStream fileOutputStream = new FileOutputStream(filePath);
         // Write version number
-        fileOutputStream.write(Ints.toByteArray(version));
+        fileOutputStream.write(Ints.toByteArray(serializationVersion));
         // Write start height
         fileOutputStream.write(Ints.toByteArray(startHeight));
         // Write end height
@@ -199,4 +300,12 @@ public class BlockArchiveWriter {
         this.shouldEnforceFileSizeTarget = shouldEnforceFileSizeTarget;
     }
 
+    public void setDataSource(BlockArchiveDataSource dataSource) {
+        this.dataSource = dataSource;
+    }
+
+    public void setShouldLogProgress(boolean shouldLogProgress) {
+        this.shouldLogProgress = shouldLogProgress;
+    }
+
 }

src/main/java/org/qortal/repository/Bootstrap.java

@@ -279,7 +279,9 @@ public class Bootstrap {
 
             LOGGER.info("Generating checksum file...");
             String checksum = Crypto.digestHexString(compressedOutputPath.toFile(), 1024*1024);
+            LOGGER.info("checksum: {}", checksum);
             Path checksumPath = Paths.get(String.format("%s.sha256", compressedOutputPath.toString()));
+            LOGGER.info("Writing checksum to path: {}", checksumPath);
             Files.writeString(checksumPath, checksum, StandardOpenOption.CREATE);
 
             // Return the path to the compressed bootstrap file

src/main/java/org/qortal/repository/RepositoryManager.java

@@ -2,11 +2,6 @@ package org.qortal.repository;
 
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
-import org.qortal.gui.SplashFrame;
-import org.qortal.repository.hsqldb.HSQLDBDatabaseArchiving;
-import org.qortal.repository.hsqldb.HSQLDBDatabasePruning;
-import org.qortal.repository.hsqldb.HSQLDBRepository;
-import org.qortal.settings.Settings;
 
 import java.sql.SQLException;
 import java.util.concurrent.TimeoutException;
@@ -61,62 +56,6 @@ public abstract class RepositoryManager {
 		}
 	}
 
-	public static boolean archive(Repository repository) {
-		if (Settings.getInstance().isLite()) {
-			// Lite nodes have no blockchain
-			return false;
-		}
-
-		// Bulk archive the database the first time we use archive mode
-		if (Settings.getInstance().isArchiveEnabled()) {
-			if (RepositoryManager.canArchiveOrPrune()) {
-				try {
-					return HSQLDBDatabaseArchiving.buildBlockArchive(repository, BlockArchiveWriter.DEFAULT_FILE_SIZE_TARGET);
-
-				} catch (DataException e) {
-					LOGGER.info("Unable to build block archive. The database may have been left in an inconsistent state.");
-				}
-			}
-			else {
-				LOGGER.info("Unable to build block archive due to missing ATStatesHeightIndex. Bootstrapping is recommended.");
-				LOGGER.info("To bootstrap, stop the core and delete the db folder, then start the core again.");
-				SplashFrame.getInstance().updateStatus("Missing index. Bootstrapping is recommended.");
-			}
-		}
-		return false;
-	}
-
-	public static boolean prune(Repository repository) {
-		if (Settings.getInstance().isLite()) {
-			// Lite nodes have no blockchain
-			return false;
-		}
-
-		// Bulk prune the database the first time we use top-only or block archive mode
-		if (Settings.getInstance().isTopOnly() ||
-			Settings.getInstance().isArchiveEnabled()) {
-			if (RepositoryManager.canArchiveOrPrune()) {
-				try {
-					boolean prunedATStates = HSQLDBDatabasePruning.pruneATStates((HSQLDBRepository) repository);
-					boolean prunedBlocks = HSQLDBDatabasePruning.pruneBlocks((HSQLDBRepository) repository);
-
-					// Perform repository maintenance to shrink the db size down
-					if (prunedATStates && prunedBlocks) {
-						HSQLDBDatabasePruning.performMaintenance(repository);
-						return true;
-					}
-
-				} catch (SQLException | DataException e) {
-					LOGGER.info("Unable to bulk prune AT states. The database may have been left in an inconsistent state.");
-				}
-			}
-			else {
-				LOGGER.info("Unable to prune blocks due to missing ATStatesHeightIndex. Bootstrapping is recommended.");
-			}
-		}
-		return false;
-	}
-
 	public static void setRequestedCheckpoint(Boolean quick) {
 		quickCheckpointRequested = quick;
 	}

src/main/java/org/qortal/repository/hsqldb/HSQLDBATRepository.java

@@ -603,7 +603,7 @@ public class HSQLDBATRepository implements ATRepository {
 
 
 	@Override
-	public void rebuildLatestAtStates() throws DataException {
+	public void rebuildLatestAtStates(int maxHeight) throws DataException {
 		// latestATStatesLock is to prevent concurrent updates on LatestATStates
 		// that could result in one process using a partial or empty dataset
 		// because it was in the process of being rebuilt by another thread
@@ -624,11 +624,12 @@ public class HSQLDBATRepository implements ATRepository {
 					+ "CROSS JOIN LATERAL("
 					+ "SELECT height FROM ATStates "
 					+ "WHERE ATStates.AT_address = ATs.AT_address "
+					+ "AND height <= ?"
 					+ "ORDER BY AT_address DESC, height DESC LIMIT 1"
 					+ ") "
 					+ ")";
 			try {
-				this.repository.executeCheckedUpdate(insertSql);
+				this.repository.executeCheckedUpdate(insertSql, maxHeight);
 			} catch (SQLException e) {
 				repository.examineException(e);
 				throw new DataException("Unable to populate temporary latest AT states cache in repository", e);

src/main/java/org/qortal/repository/hsqldb/HSQLDBChatRepository.java

@@ -177,11 +177,11 @@ public class HSQLDBChatRepository implements ChatRepository {
 
 	private List<GroupChat> getActiveGroupChats(String address) throws DataException {
 		// Find groups where address is a member and potential latest message details
-		String groupsSql = "SELECT group_id, group_name, latest_timestamp, sender, sender_name "
+		String groupsSql = "SELECT group_id, group_name, latest_timestamp, sender, sender_name, signature, data "
 				+ "FROM GroupMembers "
 				+ "JOIN Groups USING (group_id) "
 				+ "LEFT OUTER JOIN LATERAL("
-					+ "SELECT created_when AS latest_timestamp, sender, name AS sender_name "
+					+ "SELECT created_when AS latest_timestamp, sender, name AS sender_name, signature, data "
 					+ "FROM ChatTransactions "
 					+ "JOIN Transactions USING (signature) "
 					+ "LEFT OUTER JOIN Names AS SenderNames ON SenderNames.owner = sender "
@@ -205,8 +205,10 @@ public class HSQLDBChatRepository implements ChatRepository {
 
 					String sender = resultSet.getString(4);
 					String senderName = resultSet.getString(5);
+					byte[] signature = resultSet.getBytes(6);
+					byte[] data = resultSet.getBytes(7);
 
-					GroupChat groupChat = new GroupChat(groupId, groupName, timestamp, sender, senderName);
+					GroupChat groupChat = new GroupChat(groupId, groupName, timestamp, sender, senderName, signature, data);
 					groupChats.add(groupChat);
 				} while (resultSet.next());
 			}
@@ -215,7 +217,7 @@ public class HSQLDBChatRepository implements ChatRepository {
 		}
 
 		// We need different SQL to handle group-less chat
-		String grouplessSql = "SELECT created_when, sender, SenderNames.name "
+		String grouplessSql = "SELECT created_when, sender, SenderNames.name, signature, data "
 				+ "FROM ChatTransactions "
 				+ "JOIN Transactions USING (signature) "
 				+ "LEFT OUTER JOIN Names AS SenderNames ON SenderNames.owner = sender "
@@ -228,15 +230,19 @@ public class HSQLDBChatRepository implements ChatRepository {
 			Long timestamp = null;
 			String sender = null;
 			String senderName = null;
+			byte[] signature = null;
+			byte[] data = null;
 
 			if (resultSet != null) {
 				// We found a recipient-less, group-less CHAT message, so report its details
 				timestamp = resultSet.getLong(1);
 				sender = resultSet.getString(2);
 				senderName = resultSet.getString(3);
+				signature = resultSet.getBytes(4);
+				data = resultSet.getBytes(5);
 			}
 
-			GroupChat groupChat = new GroupChat(0, null, timestamp, sender, senderName);
+			GroupChat groupChat = new GroupChat(0, null, timestamp, sender, senderName, signature, data);
 			groupChats.add(groupChat);
 		} catch (SQLException e) {
 			throw new DataException("Unable to fetch active group chats from repository", e);
@@ -291,4 +297,4 @@ public class HSQLDBChatRepository implements ChatRepository {
 		return directChats;
 	}
 
-}
+}

src/main/java/org/qortal/repository/hsqldb/HSQLDBDatabaseArchiving.java

@@ -1,88 +0,0 @@
-package org.qortal.repository.hsqldb;
-
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import org.qortal.controller.Controller;
-import org.qortal.gui.SplashFrame;
-import org.qortal.repository.BlockArchiveWriter;
-import org.qortal.repository.DataException;
-import org.qortal.repository.Repository;
-import org.qortal.repository.RepositoryManager;
-import org.qortal.transform.TransformationException;
-
-import java.io.IOException;
-
-/**
- *
- * When switching to an archiving node, we need to archive most of the database contents.
- * This involves copying its data into flat files.
- * If we do this entirely as a background process, it is very slow and can interfere with syncing.
- * However, if we take the approach of doing this in bulk, before starting up the rest of the
- * processes, this makes it much faster and less invasive.
- *
- * From that point, the original background archiving process will run, but can be dialled right down
- * so not to interfere with syncing.
- *
- */
-
-
-public class HSQLDBDatabaseArchiving {
-
-    private static final Logger LOGGER = LogManager.getLogger(HSQLDBDatabaseArchiving.class);
-
-
-    public static boolean buildBlockArchive(Repository repository, long fileSizeTarget) throws DataException {
-
-        // Only build the archive if we haven't already got one that is up to date
-        boolean upToDate = BlockArchiveWriter.isArchiverUpToDate(repository);
-        if (upToDate) {
-            // Already archived
-            return false;
-        }
-
-        LOGGER.info("Building block archive - this process could take a while...");
-        SplashFrame.getInstance().updateStatus("Building block archive...");
-
-        final int maximumArchiveHeight = BlockArchiveWriter.getMaxArchiveHeight(repository);
-        int startHeight = 0;
-
-        while (!Controller.isStopping()) {
-            try {
-                BlockArchiveWriter writer = new BlockArchiveWriter(startHeight, maximumArchiveHeight, repository);
-                writer.setFileSizeTarget(fileSizeTarget);
-                BlockArchiveWriter.BlockArchiveWriteResult result = writer.write();
-                switch (result) {
-                    case OK:
-                        // Increment block archive height
-                        startHeight = writer.getLastWrittenHeight() + 1;
-                        repository.getBlockArchiveRepository().setBlockArchiveHeight(startHeight);
-                        repository.saveChanges();
-                        break;
-
-                    case STOPPING:
-                        return false;
-
-                    case NOT_ENOUGH_BLOCKS:
-                        // We've reached the limit of the blocks we can archive
-                        // Return from the whole method
-                        return true;
-
-                    case BLOCK_NOT_FOUND:
-                        // We tried to archive a block that didn't exist. This is a major failure and likely means
-                        // that a bootstrap or re-sync is needed. Return rom the method
-                        LOGGER.info("Error: block not found when building archive. If this error persists, " +
-                                "a bootstrap or re-sync may be needed.");
-                        return false;
-                }
-
-            } catch (IOException | TransformationException | InterruptedException e) {
-                LOGGER.info("Caught exception when creating block cache", e);
-                return false;
-            }
-        }
-
-        // If we got this far then something went wrong (most likely the app is stopping)
-        return false;
-    }
-
-}

src/main/java/org/qortal/repository/hsqldb/HSQLDBDatabasePruning.java

@@ -1,332 +0,0 @@
-package org.qortal.repository.hsqldb;
-
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import org.qortal.controller.Controller;
-import org.qortal.data.block.BlockData;
-import org.qortal.gui.SplashFrame;
-import org.qortal.repository.BlockArchiveWriter;
-import org.qortal.repository.DataException;
-import org.qortal.repository.Repository;
-import org.qortal.settings.Settings;
-
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.util.concurrent.TimeoutException;
-
-/**
- *
- * When switching from a full node to a pruning node, we need to delete most of the database contents.
- * If we do this entirely as a background process, it is very slow and can interfere with syncing.
- * However, if we take the approach of transferring only the necessary rows to a new table and then
- * deleting the original table, this makes the process much faster. It was taking several days to
- * delete the AT states in the background, but only a couple of minutes to copy them to a new table.
- *
- * The trade off is that we have to go through a form of "reshape" when starting the app for the first
- * time after enabling pruning mode. But given that this is an opt-in mode, I don't think it will be
- * a problem.
- *
- * Once the pruning is complete, it automatically performs a CHECKPOINT DEFRAG in order to
- * shrink the database file size down to a fraction of what it was before.
- *
- * From this point, the original background process will run, but can be dialled right down so not
- * to interfere with syncing.
- *
- */
-
-
-public class HSQLDBDatabasePruning {
-
-    private static final Logger LOGGER = LogManager.getLogger(HSQLDBDatabasePruning.class);
-
-
-    public static boolean pruneATStates(HSQLDBRepository repository) throws SQLException, DataException {
-
-        // Only bulk prune AT states if we have never done so before
-        int pruneHeight = repository.getATRepository().getAtPruneHeight();
-        if (pruneHeight > 0) {
-            // Already pruned AT states
-            return false;
-        }
-
-        if (Settings.getInstance().isArchiveEnabled()) {
-            // Only proceed if we can see that the archiver has already finished
-            // This way, if the archiver failed for any reason, we can prune once it has had
-            // some opportunities to try again
-            boolean upToDate = BlockArchiveWriter.isArchiverUpToDate(repository);
-            if (!upToDate) {
-                return false;
-            }
-        }
-
-        LOGGER.info("Starting bulk prune of AT states - this process could take a while... " +
-                "(approx. 2 mins on high spec, or upwards of 30 mins in some cases)");
-        SplashFrame.getInstance().updateStatus("Pruning database (takes up to 30 mins)...");
-
-        // Create new AT-states table to hold smaller dataset
-        repository.executeCheckedUpdate("DROP TABLE IF EXISTS ATStatesNew");
-        repository.executeCheckedUpdate("CREATE TABLE ATStatesNew ("
-                + "AT_address QortalAddress, height INTEGER NOT NULL, state_hash ATStateHash NOT NULL, "
-                + "fees QortalAmount NOT NULL, is_initial BOOLEAN NOT NULL, sleep_until_message_timestamp BIGINT, "
-                + "PRIMARY KEY (AT_address, height), "
-                + "FOREIGN KEY (AT_address) REFERENCES ATs (AT_address) ON DELETE CASCADE)");
-        repository.executeCheckedUpdate("SET TABLE ATStatesNew NEW SPACE");
-        repository.executeCheckedUpdate("CHECKPOINT");
-
-        // Add a height index
-        LOGGER.info("Adding index to AT states table...");
-        repository.executeCheckedUpdate("CREATE INDEX IF NOT EXISTS ATStatesNewHeightIndex ON ATStatesNew (height)");
-        repository.executeCheckedUpdate("CHECKPOINT");
-
-
-        // Find our latest block
-        BlockData latestBlock = repository.getBlockRepository().getLastBlock();
-        if (latestBlock == null) {
-            LOGGER.info("Unable to determine blockchain height, necessary for bulk block pruning");
-            return false;
-        }
-
-        // Calculate some constants for later use
-        final int blockchainHeight = latestBlock.getHeight();
-        int maximumBlockToTrim = blockchainHeight - Settings.getInstance().getPruneBlockLimit();
-        if (Settings.getInstance().isArchiveEnabled()) {
-            // Archive mode - don't prune anything that hasn't been archived yet
-            maximumBlockToTrim = Math.min(maximumBlockToTrim, repository.getBlockArchiveRepository().getBlockArchiveHeight() - 1);
-        }
-        final int endHeight = blockchainHeight;
-        final int blockStep = 10000;
-
-
-        // It's essential that we rebuild the latest AT states here, as we are using this data in the next query.
-        // Failing to do this will result in important AT states being deleted, rendering the database unusable.
-        repository.getATRepository().rebuildLatestAtStates();
-
-
-        // Loop through all the LatestATStates and copy them to the new table
-        LOGGER.info("Copying AT states...");
-        for (int height = 0; height < endHeight; height += blockStep) {
-            final int batchEndHeight = height + blockStep - 1;
-            //LOGGER.info(String.format("Copying AT states between %d and %d...", height, batchEndHeight));
-
-            String sql = "SELECT height, AT_address FROM LatestATStates WHERE height BETWEEN ? AND ?";
-            try (ResultSet latestAtStatesResultSet = repository.checkedExecute(sql, height, batchEndHeight)) {
-                if (latestAtStatesResultSet != null) {
-                    do {
-                        int latestAtHeight = latestAtStatesResultSet.getInt(1);
-                        String latestAtAddress = latestAtStatesResultSet.getString(2);
-
-                        // Copy this latest ATState to the new table
-                        //LOGGER.info(String.format("Copying AT %s at height %d...", latestAtAddress, latestAtHeight));
-                        try {
-                            String updateSql = "INSERT INTO ATStatesNew ("
-                                    + "SELECT AT_address, height, state_hash, fees, is_initial, sleep_until_message_timestamp "
-                                    + "FROM ATStates "
-                                    + "WHERE height = ? AND AT_address = ?)";
-                            repository.executeCheckedUpdate(updateSql, latestAtHeight, latestAtAddress);
-                        } catch (SQLException e) {
-                            repository.examineException(e);
-                            throw new DataException("Unable to copy ATStates", e);
-                        }
-
-                        // If this batch includes blocks after the maximum block to trim, we will need to copy
-                        // each of its AT states above maximumBlockToTrim as they are considered "recent". We
-                        // need to do this for _all_ AT states in these blocks, regardless of their latest state.
-                        if (batchEndHeight >= maximumBlockToTrim) {
-                            // Now copy this AT's states for each recent block they are present in
-                            for (int i = maximumBlockToTrim; i < endHeight; i++) {
-                                if (latestAtHeight < i) {
-                                    // This AT finished before this block so there is nothing to copy
-                                    continue;
-                                }
-
-                                //LOGGER.info(String.format("Copying recent AT %s at height %d...", latestAtAddress, i));
-                                try {
-                                    // Copy each LatestATState to the new table
-                                    String updateSql = "INSERT IGNORE INTO ATStatesNew ("
-                                            + "SELECT AT_address, height, state_hash, fees, is_initial, sleep_until_message_timestamp "
-                                            + "FROM ATStates "
-                                            + "WHERE height = ? AND AT_address = ?)";
-                                    repository.executeCheckedUpdate(updateSql, i, latestAtAddress);
-                                } catch (SQLException e) {
-                                    repository.examineException(e);
-                                    throw new DataException("Unable to copy ATStates", e);
-                                }
-                            }
-                        }
-                        repository.saveChanges();
-
-                    } while (latestAtStatesResultSet.next());
-                }
-            } catch (SQLException e) {
-                throw new DataException("Unable to copy AT states", e);
-            }
-        }
-
-
-        // Finally, drop the original table and rename
-        LOGGER.info("Deleting old AT states...");
-        repository.executeCheckedUpdate("DROP TABLE ATStates");
-        repository.executeCheckedUpdate("ALTER TABLE ATStatesNew RENAME TO ATStates");
-        repository.executeCheckedUpdate("ALTER INDEX ATStatesNewHeightIndex RENAME TO ATStatesHeightIndex");
-        repository.executeCheckedUpdate("CHECKPOINT");
-
-        // Update the prune height
-        int nextPruneHeight = maximumBlockToTrim + 1;
-        repository.getATRepository().setAtPruneHeight(nextPruneHeight);
-        repository.saveChanges();
-
-        repository.executeCheckedUpdate("CHECKPOINT");
-
-        // Now prune/trim the ATStatesData, as this currently goes back over a month
-        return HSQLDBDatabasePruning.pruneATStateData(repository);
-    }
-
-    /*
-     * Bulk prune ATStatesData to catch up with the now pruned ATStates table
-     * This uses the existing AT States trimming code but with a much higher end block
-     */
-    private static boolean pruneATStateData(Repository repository) throws DataException {
-
-        if (Settings.getInstance().isArchiveEnabled()) {
-            // Don't prune ATStatesData in archive mode
-            return true;
-        }
-
-        BlockData latestBlock = repository.getBlockRepository().getLastBlock();
-        if (latestBlock == null) {
-            LOGGER.info("Unable to determine blockchain height, necessary for bulk ATStatesData pruning");
-            return false;
-        }
-        final int blockchainHeight = latestBlock.getHeight();
-        int upperPrunableHeight = blockchainHeight - Settings.getInstance().getPruneBlockLimit();
-        // ATStateData is already trimmed - so carry on from where we left off in the past
-        int pruneStartHeight = repository.getATRepository().getAtTrimHeight();
-
-        LOGGER.info("Starting bulk prune of AT states data - this process could take a while... (approx. 3 mins on high spec)");
-
-        while (pruneStartHeight < upperPrunableHeight) {
-            // Prune all AT state data up until our latest minus pruneBlockLimit (or our archive height)
-
-            if (Controller.isStopping()) {
-                return false;
-            }
-
-            // Override batch size in the settings because this is a one-off process
-            final int batchSize = 1000;
-            final int rowLimitPerBatch = 50000;
-            int upperBatchHeight = pruneStartHeight + batchSize;
-            int upperPruneHeight = Math.min(upperBatchHeight, upperPrunableHeight);
-
-            LOGGER.trace(String.format("Pruning AT states data between %d and %d...", pruneStartHeight, upperPruneHeight));
-
-            int numATStatesPruned = repository.getATRepository().trimAtStates(pruneStartHeight, upperPruneHeight, rowLimitPerBatch);
-            repository.saveChanges();
-
-            if (numATStatesPruned > 0) {
-                LOGGER.trace(String.format("Pruned %d AT states data rows between blocks %d and %d",
-                        numATStatesPruned, pruneStartHeight, upperPruneHeight));
-            } else {
-                repository.getATRepository().setAtTrimHeight(upperBatchHeight);
-                // No need to rebuild the latest AT states as we aren't currently synchronizing
-                repository.saveChanges();
-                LOGGER.debug(String.format("Bumping AT states trim height to %d", upperBatchHeight));
-
-                // Can we move onto next batch?
-                if (upperPrunableHeight > upperBatchHeight) {
-                    pruneStartHeight = upperBatchHeight;
-                }
-                else {
-                    // We've finished pruning
-                    break;
-                }
-            }
-        }
-
-        return true;
-    }
-
-    public static boolean pruneBlocks(Repository repository) throws SQLException, DataException {
-
-        // Only bulk prune AT states if we have never done so before
-        int pruneHeight = repository.getBlockRepository().getBlockPruneHeight();
-        if (pruneHeight > 0) {
-            // Already pruned blocks
-            return false;
-        }
-
-        if (Settings.getInstance().isArchiveEnabled()) {
-            // Only proceed if we can see that the archiver has already finished
-            // This way, if the archiver failed for any reason, we can prune once it has had
-            // some opportunities to try again
-            boolean upToDate = BlockArchiveWriter.isArchiverUpToDate(repository);
-            if (!upToDate) {
-                return false;
-            }
-        }
-
-        BlockData latestBlock = repository.getBlockRepository().getLastBlock();
-        if (latestBlock == null) {
-            LOGGER.info("Unable to determine blockchain height, necessary for bulk block pruning");
-            return false;
-        }
-        final int blockchainHeight = latestBlock.getHeight();
-        int upperPrunableHeight = blockchainHeight - Settings.getInstance().getPruneBlockLimit();
-        int pruneStartHeight = 0;
-
-        if (Settings.getInstance().isArchiveEnabled()) {
-            // Archive mode - don't prune anything that hasn't been archived yet
-            upperPrunableHeight = Math.min(upperPrunableHeight, repository.getBlockArchiveRepository().getBlockArchiveHeight() - 1);
-        }
-
-        LOGGER.info("Starting bulk prune of blocks - this process could take a while... (approx. 5 mins on high spec)");
-
-        while (pruneStartHeight < upperPrunableHeight) {
-            // Prune all blocks up until our latest minus pruneBlockLimit
-
-            int upperBatchHeight = pruneStartHeight + Settings.getInstance().getBlockPruneBatchSize();
-            int upperPruneHeight = Math.min(upperBatchHeight, upperPrunableHeight);
-
-            LOGGER.info(String.format("Pruning blocks between %d and %d...", pruneStartHeight, upperPruneHeight));
-
-            int numBlocksPruned = repository.getBlockRepository().pruneBlocks(pruneStartHeight, upperPruneHeight);
-            repository.saveChanges();
-
-            if (numBlocksPruned > 0) {
-                LOGGER.info(String.format("Pruned %d block%s between %d and %d",
-                        numBlocksPruned, (numBlocksPruned != 1 ? "s" : ""),
-                        pruneStartHeight, upperPruneHeight));
-            } else {
-                final int nextPruneHeight = upperPruneHeight + 1;
-                repository.getBlockRepository().setBlockPruneHeight(nextPruneHeight);
-                repository.saveChanges();
-                LOGGER.debug(String.format("Bumping block base prune height to %d", nextPruneHeight));
-
-                // Can we move onto next batch?
-                if (upperPrunableHeight > nextPruneHeight) {
-                    pruneStartHeight = nextPruneHeight;
-                }
-                else {
-                    // We've finished pruning
-                    break;
-                }
-            }
-        }
-
-        return true;
-    }
-
-    public static void performMaintenance(Repository repository) throws SQLException, DataException {
-        try {
-            SplashFrame.getInstance().updateStatus("Performing maintenance...");
-
-            // Timeout if the database isn't ready for backing up after 5 minutes
-            // Nothing else should be using the db at this point, so a timeout shouldn't happen
-            long timeout = 5 * 60 * 1000L;
-            repository.performPeriodicMaintenance(timeout);
-
-        } catch (TimeoutException e) {
-            LOGGER.info("Attempt to perform maintenance failed due to timeout: {}", e.getMessage());
-        }
-    }
-
-}

src/main/java/org/qortal/repository/hsqldb/HSQLDBMessageRepository.java

@@ -28,7 +28,6 @@ public class HSQLDBMessageRepository implements MessageRepository {
 		StringBuilder sql = new StringBuilder(1024);
 		sql.append("SELECT signature from MessageTransactions "
 				+ "JOIN Transactions USING (signature) "
-				+ "JOIN BlockTransactions ON transaction_signature = signature "
 				+ "WHERE ");
 
 		List<String> whereClauses = new ArrayList<>();

src/main/java/org/qortal/settings/Settings.java

@@ -178,6 +178,8 @@ public class Settings {
 	private boolean archiveEnabled = true;
 	/** How often to attempt archiving (ms). */
 	private long archiveInterval = 7171L; // milliseconds
+	/** Serialization version to use when building an archive */
+	private int defaultArchiveVersion = 1;
 
 
 	/** Whether to automatically bootstrap instead of syncing from genesis */
@@ -215,7 +217,7 @@ public class Settings {
 	public long recoveryModeTimeout = 10 * 60 * 1000L;
 
 	/** Minimum peer version number required in order to sync with them */
-	private String minPeerVersion = "3.8.2";
+	private String minPeerVersion = "3.8.7";
 	/** Whether to allow connections with peers below minPeerVersion
 	 * If true, we won't sync with them but they can still sync with us, and will show in the peers list
 	 * If false, sync will be blocked both ways, and they will not appear in the peers list */
@@ -926,6 +928,10 @@ public class Settings {
 		return this.archiveInterval;
 	}
 
+	public int getDefaultArchiveVersion() {
+		return this.defaultArchiveVersion;
+	}
+
 
 	public boolean getBootstrap() {
 		return this.bootstrap;

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

@@ -5,6 +5,7 @@ import java.util.List;
 
 import org.qortal.account.Account;
 import org.qortal.asset.Asset;
+import org.qortal.controller.repository.NamesDatabaseIntegrityCheck;
 import org.qortal.data.naming.NameData;
 import org.qortal.data.transaction.CancelSellNameTransactionData;
 import org.qortal.data.transaction.TransactionData;
@@ -81,7 +82,13 @@ public class CancelSellNameTransaction extends Transaction {
 
 	@Override
 	public void preProcess() throws DataException {
-		// Nothing to do
+		CancelSellNameTransactionData cancelSellNameTransactionData = (CancelSellNameTransactionData) transactionData;
+
+		// Rebuild this name in the Names table from the transaction history
+		// This is necessary because in some rare cases names can be missing from the Names table after registration
+		// but we have been unable to reproduce the issue and track down the root cause
+		NamesDatabaseIntegrityCheck namesDatabaseIntegrityCheck = new NamesDatabaseIntegrityCheck();
+		namesDatabaseIntegrityCheck.rebuildName(cancelSellNameTransactionData.getName(), this.repository);
 	}
 
 	@Override

src/main/java/org/qortal/transform/block/BlockTransformer.java

@@ -312,16 +312,24 @@ public class BlockTransformer extends Transformer {
 				ByteArrayOutputStream atHashBytes = new ByteArrayOutputStream(atBytesLength);
 				long atFees = 0;
 
-				for (ATStateData atStateData : block.getATStates()) {
-					// Skip initial states generated by DEPLOY_AT transactions in the same block
-					if (atStateData.isInitial())
-						continue;
+				if (block.getAtStatesHash() != null) {
+					// We already have the AT states hash
+					atFees = blockData.getATFees();
+					atHashBytes.write(block.getAtStatesHash());
+				}
+				else {
+					// We need to build the AT states hash
+					for (ATStateData atStateData : block.getATStates()) {
+						// Skip initial states generated by DEPLOY_AT transactions in the same block
+						if (atStateData.isInitial())
+							continue;
 
-					atHashBytes.write(atStateData.getATAddress().getBytes(StandardCharsets.UTF_8));
-					atHashBytes.write(atStateData.getStateHash());
-					atHashBytes.write(Longs.toByteArray(atStateData.getFees()));
+						atHashBytes.write(atStateData.getATAddress().getBytes(StandardCharsets.UTF_8));
+						atHashBytes.write(atStateData.getStateHash());
+						atHashBytes.write(Longs.toByteArray(atStateData.getFees()));
 
-					atFees += atStateData.getFees();
+						atFees += atStateData.getFees();
+					}
 				}
 
 				bytes.write(Ints.toByteArray(blockData.getATCount()));

src/main/java/org/qortal/utils/BlockArchiveUtils.java

@@ -21,6 +21,16 @@ public class BlockArchiveUtils {
      * into the HSQLDB, in order to make it SQL-compatible
      * again.
      * <p>
+     * This is only fully compatible with archives that use
+     * serialization version 1. For version 2 (or above),
+     * we are unable to import individual AT states as we
+     * only have a single combined hash, so the use cases
+     * for this are greatly limited.
+     * <p>
+     * A version 1 archive should ultimately be rebuildable
+     * via a resync or reindex from genesis, allowing
+     * access to this feature once again.
+     * <p>
      * Note: calls discardChanges() and saveChanges(), so
      * make sure that you commit any existing repository
      * changes before calling this method.
@@ -61,9 +71,18 @@ public class BlockArchiveUtils {
                 repository.getBlockRepository().save(blockInfo.getBlockData());
 
                 // Save AT state data hashes
-                for (ATStateData atStateData : blockInfo.getAtStates()) {
-                    atStateData.setHeight(blockInfo.getBlockData().getHeight());
-                    repository.getATRepository().save(atStateData);
+                if (blockInfo.getAtStates() != null) {
+                    for (ATStateData atStateData : blockInfo.getAtStates()) {
+                        atStateData.setHeight(blockInfo.getBlockData().getHeight());
+                        repository.getATRepository().save(atStateData);
+                    }
+                }
+                else {
+                    // We don't have AT state hashes, so we are only importing a partial state.
+                    // This can still be useful to allow orphaning to very old blocks, when we
+                    // need to access other chainstate info (such as balances) at an earlier block.
+                    // In order to do this, the orphan process must be temporarily adjusted to avoid
+                    // orphaning AT states, as it will otherwise fail due to having no previous state.
                 }
 
             } catch (DataException e) {

src/main/resources/i18n/ApiError_pl.properties

@@ -0,0 +1,83 @@
+#Generated by ResourceBundle Editor (http://essiembre.github.io/eclipse-rbe/)
+# Keys are from api.ApiError enum
+
+# "localeLang": "pl",
+
+### Common ###
+JSON = nie udało się przetworzyć wiadomości JSON
+
+INSUFFICIENT_BALANCE = niedostateczne środki
+
+UNAUTHORIZED = nieautoryzowane połączenie API
+
+REPOSITORY_ISSUE = błąd repozytorium
+
+NON_PRODUCTION = to wywołanie API nie jest dozwolone dla systemów produkcyjnych
+
+BLOCKCHAIN_NEEDS_SYNC = blockchain musi się najpierw zsynchronizować
+
+NO_TIME_SYNC = zegar się jeszcze nie zsynchronizował
+
+### Validation ###
+INVALID_SIGNATURE = nieprawidłowa sygnatura
+
+INVALID_ADDRESS = nieprawidłowy adres
+
+INVALID_PUBLIC_KEY = nieprawidłowy klucz publiczny
+
+INVALID_DATA = nieprawidłowe dane
+
+INVALID_NETWORK_ADDRESS = nieprawidłowy adres sieci
+
+ADDRESS_UNKNOWN = nieznany adres konta
+
+INVALID_CRITERIA = nieprawidłowe kryteria wyszukiwania
+
+INVALID_REFERENCE = nieprawidłowe skierowanie
+
+TRANSFORMATION_ERROR = nie udało się przekształcić JSON w transakcję
+
+INVALID_PRIVATE_KEY = klucz prywatny jest niepoprawny
+
+INVALID_HEIGHT = nieprawidłowa wysokość bloku
+
+CANNOT_MINT = konto nie możne bić monet
+
+### Blocks ###
+BLOCK_UNKNOWN = blok nieznany
+
+### Transactions ###
+TRANSACTION_UNKNOWN = nieznana transakcja
+
+PUBLIC_KEY_NOT_FOUND = nie znaleziono klucza publicznego
+
+# this one is special in that caller expected to pass two additional strings, hence the two %s
+TRANSACTION_INVALID = transakcja nieważna: %s (%s)
+
+### Naming ###
+NAME_UNKNOWN = nazwa nieznana
+
+### Asset ###
+INVALID_ASSET_ID = nieprawidłowy identyfikator aktywy
+
+INVALID_ORDER_ID = nieprawidłowy identyfikator zlecenia aktywy
+
+ORDER_UNKNOWN = nieznany identyfikator zlecenia aktywy
+
+### Groups ###
+GROUP_UNKNOWN = nieznana grupa
+
+### Foreign Blockchain ###
+FOREIGN_BLOCKCHAIN_NETWORK_ISSUE = obcy blockchain lub problem z siecią ElectrumX
+
+FOREIGN_BLOCKCHAIN_BALANCE_ISSUE = niewystarczające środki na obcym blockchainie
+
+FOREIGN_BLOCKCHAIN_TOO_SOON = zbyt wczesne nadawanie transakcji na obcym blockchainie (okres karencji/średni czas bloku)
+
+### Trade Portal ###
+ORDER_SIZE_TOO_SMALL = zbyt niska kwota zlecenia
+
+### Data ###
+FILE_NOT_FOUND = plik nie został znaleziony
+
+NO_REPLY = peer nie odpowiedział w wyznaczonym czasie

src/main/resources/i18n/ApiError_ru.properties

@@ -16,7 +16,7 @@ NON_PRODUCTION = этот вызов API не разрешен для произ
 
 BLOCKCHAIN_NEEDS_SYNC = блокчейн должен сначала синхронизироваться
 
-NO_TIME_SYNC = пока нет синхронизации часов
+NO_TIME_SYNC = время не синхронизировано
 
 ### Validation ###
 INVALID_SIGNATURE = недействительная подпись
@@ -72,7 +72,7 @@ FOREIGN_BLOCKCHAIN_NETWORK_ISSUE = проблема с внешним блокч
 
 FOREIGN_BLOCKCHAIN_BALANCE_ISSUE = недостаточный баланс на внешнем блокчейне
 
-FOREIGN_BLOCKCHAIN_TOO_SOON = слишком рано для трансляции транзакции во внений блокчей (время блокировки/среднее время блока)
+FOREIGN_BLOCKCHAIN_TOO_SOON = слишком рано для трансляции транзакции во внешний блокчей (время блокировки/среднее время блока)
 
 ### Trade Portal ###
 ORDER_SIZE_TOO_SMALL = слишком маленькая сумма ордера
@@ -80,4 +80,4 @@ ORDER_SIZE_TOO_SMALL = слишком маленькая сумма ордера
 ### Data ###
 FILE_NOT_FOUND = файл не найден
 
-NO_REPLY = узел не ответил данными
+NO_REPLY = нет ответа

src/main/resources/i18n/SysTray_de.properties

@@ -5,11 +5,11 @@ APPLYING_UPDATE_AND_RESTARTING = Automatisches Update anwenden und neu starten
 
 AUTO_UPDATE = Automatisches Update
 
-BLOCK_HEIGHT = height
+BLOCK_HEIGHT = Blockhöhe
 
 BLOCKS_REMAINING = blocks remaining
 
-BUILD_VERSION = Build-Version
+BUILD_VERSION = Entwicklungs-Version
 
 CHECK_TIME_ACCURACY = Prüfe Zeitgenauigkeit
 
@@ -23,7 +23,7 @@ CREATING_BACKUP_OF_DB_FILES = Erstellen Backup von Datenbank Dateien …
 
 DB_BACKUP = Datenbank Backup
 
-DB_CHECKPOINT = Datenbank Kontrollpunkt
+DB_CHECKPOINT = Datenbank Check
 
 DB_MAINTENANCE = Datenbank Instandhaltung
 
@@ -31,18 +31,18 @@ EXIT = Verlassen
 
 LITE_NODE = Lite node
 
-MINTING_DISABLED = NOT minting
+MINTING_DISABLED = Kein minting
 
-MINTING_ENABLED = \u2714 Minting
+MINTING_ENABLED = \u2714 Minting aktiviert 
 
 OPEN_UI = Öffne UI
 
-PERFORMING_DB_CHECKPOINT = Speichern nicht übergebener Datenbank Änderungen …
+PERFORMING_DB_CHECKPOINT = Speichern von unbestätigten Datenbankänderungen...
 
 PERFORMING_DB_MAINTENANCE = Planmäßige Wartung durchführen...
 
 SYNCHRONIZE_CLOCK = Synchronisiere Uhr
 
-SYNCHRONIZING_BLOCKCHAIN = Synchronisierung
+SYNCHRONIZING_BLOCKCHAIN = Synchronisierung der Blockchain
 
-SYNCHRONIZING_CLOCK = Synchronisierung Uhr
+SYNCHRONIZING_CLOCK = Synchronisierung der Uhr

src/main/resources/i18n/SysTray_pl.properties

@@ -0,0 +1,46 @@
+#Generated by ResourceBundle Editor (http://essiembre.github.io/eclipse-rbe/)
+# SysTray pop-up menu
+
+APPLYING_UPDATE_AND_RESTARTING = Zastosowanie automatycznej aktualizacji i ponowne uruchomienie...
+
+AUTO_UPDATE = Automatyczna aktualizacja
+
+BLOCK_HEIGHT = wysokość
+
+BUILD_VERSION = Wersja kompilacji
+
+CHECK_TIME_ACCURACY = Sprawdz dokładność czasu
+
+CONNECTING = Łączenie
+
+CONNECTION = połączenie
+
+CONNECTIONS = połączenia
+
+CREATING_BACKUP_OF_DB_FILES = Tworzenie kopii zapasowej plików bazy danych...
+
+DB_BACKUP = Kopia zapasowa bazy danych
+
+DB_CHECKPOINT = Punkt kontrolny bazy danych...
+
+DB_MAINTENANCE = Konserwacja bazy danych
+
+EXIT = Zakończ
+
+LITE_NODE = Lite node
+
+MINTING_DISABLED = Mennica zamknięta
+
+MINTING_ENABLED = \u2714 Mennica aktywna
+
+OPEN_UI = Otwórz interfejs użytkownika
+
+PERFORMING_DB_CHECKPOINT = Zapisywanie niezaksięgowanych zmian w bazie danych...
+
+PERFORMING_DB_MAINTENANCE = Performing scheduled maintenance...
+
+SYNCHRONIZE_CLOCK = Synchronizuj zegar
+
+SYNCHRONIZING_BLOCKCHAIN = Synchronizacja
+
+SYNCHRONIZING_CLOCK = Synchronizacja zegara

src/main/resources/i18n/SysTray_ru.properties

@@ -1,7 +1,7 @@
 #Generated by ResourceBundle Editor (http://essiembre.github.io/eclipse-rbe/)
 # SysTray pop-up menu
 
-APPLYING_UPDATE_AND_RESTARTING = Применение автоматического обновления и перезапуска...
+APPLYING_UPDATE_AND_RESTARTING = Применение автоматического обновления и перезапуск...
 
 AUTO_UPDATE = Автоматическое обновление
 

src/main/resources/i18n/TransactionValidity_de.properties

@@ -0,0 +1,195 @@
+#
+
+ACCOUNT_ALREADY_EXISTS = Account existiert bereits
+
+ACCOUNT_CANNOT_REWARD_SHARE = Account kann keine Belohnung teilen
+
+ADDRESS_ABOVE_RATE_LIMIT = address hat das angegebene Geschwindigkeitlimit erreicht 
+
+ADDRESS_BLOCKED =  Addresse ist geblockt
+
+ALREADY_GROUP_ADMIN = bereits Gruppen Admin
+
+ALREADY_GROUP_MEMBER = bereits Gruppen Mitglied
+
+ALREADY_VOTED_FOR_THAT_OPTION = bereits für diese Option gestimmt
+
+ASSET_ALREADY_EXISTS = asset existiert bereits
+
+ASSET_DOES_NOT_EXIST = asset nicht gefunden 
+
+ASSET_DOES_NOT_MATCH_AT = asset passt nicht mit AT's asset
+
+ASSET_NOT_SPENDABLE = asset ist nicht ausgabefähig
+
+AT_ALREADY_EXISTS = AT existiert bereits
+
+AT_IS_FINISHED = AT ist fertig 
+
+AT_UNKNOWN = AT unbekannt 
+
+BAN_EXISTS = ban besteht bereits
+
+BAN_UNKNOWN = ban unbekannt
+
+BANNED_FROM_GROUP = von der gruppe gebannt
+
+BUYER_ALREADY_OWNER = Käufer ist bereits Besitzer 
+
+CLOCK_NOT_SYNCED = Uhr nicht synchronisiert
+
+DUPLICATE_MESSAGE = Adresse sendete doppelte Nachricht
+
+DUPLICATE_OPTION = Duplizierungsmöglichkeit
+
+GROUP_ALREADY_EXISTS = Gruppe besteht bereits
+
+GROUP_APPROVAL_DECIDED = Gruppenfreigabe bereits beschlossen
+
+GROUP_APPROVAL_NOT_REQUIRED = Gruppenfreigabe nicht erforderlich
+
+GROUP_DOES_NOT_EXIST = Gruppe nicht vorhanden
+
+GROUP_ID_MISMATCH = Gruppen-ID stimmt nicht überein
+
+GROUP_OWNER_CANNOT_LEAVE = Gruppenbesitzer kann Gruppe nicht verlassen
+
+HAVE_EQUALS_WANT = das bessesene-asset ist das selbe wie das gesuchte-asset
+
+INCORRECT_NONCE = falsche PoW-Nonce
+
+INSUFFICIENT_FEE = unzureichende Gebühr
+
+INVALID_ADDRESS = ungültige Adresse
+
+INVALID_AMOUNT = ungültiger Betrag
+
+INVALID_ASSET_OWNER = Ungültiger Eigentümer
+
+INVALID_AT_TRANSACTION = ungültige AT-Transaktion
+
+INVALID_AT_TYPE_LENGTH = ungültige AT 'Typ' Länge
+
+INVALID_BUT_OK = ungültig aber OK
+
+INVALID_CREATION_BYTES = ungültige Erstellungs der bytes
+
+INVALID_DATA_LENGTH = ungültige Datenlänge
+
+INVALID_DESCRIPTION_LENGTH = ungültige Länge der Beschreibung
+
+INVALID_GROUP_APPROVAL_THRESHOLD = ungültiger Schwellenwert für die Gruppenzulassung
+
+INVALID_GROUP_BLOCK_DELAY = Ungültige Blockverzögerung der Gruppenfreigabe
+
+INVALID_GROUP_ID = ungültige Gruppen-ID
+
+INVALID_GROUP_OWNER = ungültiger Gruppenbesitzer
+
+INVALID_LIFETIME = unzulässige Lebensdauer
+
+INVALID_NAME_LENGTH = ungültige Namenslänge
+
+INVALID_NAME_OWNER = ungültiger Besitzername 
+
+INVALID_OPTION_LENGTH = ungültige Länge der Optionen
+
+INVALID_OPTIONS_COUNT = Anzahl ungültiger Optionen
+
+INVALID_ORDER_CREATOR = ungültiger Auftragsersteller
+
+INVALID_PAYMENTS_COUNT = Anzahl ungültiger Zahlungen
+
+INVALID_PUBLIC_KEY = ungültiger öffentlicher Schlüssel
+
+INVALID_QUANTITY = unzulässige Menge
+
+INVALID_REFERENCE = ungültige Referenz
+
+INVALID_RETURN = ungültige Rückgabe
+
+INVALID_REWARD_SHARE_PERCENT = ungültig Prozent der Belohnunganteile 
+
+INVALID_SELLER = unzulässiger Verkäufer
+
+INVALID_TAGS_LENGTH = ungültige 'tags'-Länge
+
+INVALID_TIMESTAMP_SIGNATURE = Ungültige Zeitstempel-Signatur
+
+INVALID_TX_GROUP_ID = Ungültige Transaktionsgruppen-ID
+
+INVALID_VALUE_LENGTH = ungültige 'Wert'-Länge
+
+INVITE_UNKNOWN = Gruppeneinladung unbekannt
+
+JOIN_REQUEST_EXISTS = Gruppeneinladung existiert bereits
+
+MAXIMUM_REWARD_SHARES = die maximale Anzahl von Reward-Shares für dieses Konto erreicht
+
+MISSING_CREATOR = fehlender Ersteller
+
+MULTIPLE_NAMES_FORBIDDEN = mehrere registrierte Namen pro Konto sind untersagt
+
+NAME_ALREADY_FOR_SALE = Name bereits zum Verkauf
+
+NAME_ALREADY_REGISTERED = Name bereits registriert
+
+NAME_BLOCKED = Name geblockt
+
+NAME_DOES_NOT_EXIST = Name nicht vorhanden
+
+NAME_NOT_FOR_SALE = Name ist unverkäuflich
+
+NAME_NOT_NORMALIZED = Name nicht in Unicode-'normalisierter' Form
+
+NEGATIVE_AMOUNT = ungültiger/negativer Betrag
+
+NEGATIVE_FEE = ungültige/negative Gebühr
+
+NEGATIVE_PRICE = ungültiger/negativer Preis
+
+NO_BALANCE = unzureichendes Guthaben
+
+NO_BLOCKCHAIN_LOCK = die Blockchain des Knotens ist beschäftigt
+
+NO_FLAG_PERMISSION = Konto hat diese Berechtigung nicht
+
+NOT_GROUP_ADMIN = Account ist kein Gruppenadmin
+
+NOT_GROUP_MEMBER = Account kein Gruppenmitglied 
+
+NOT_MINTING_ACCOUNT = Account kann nicht minten
+
+NOT_YET_RELEASED = Funktion noch nicht freigegeben
+
+OK = OK
+
+ORDER_ALREADY_CLOSED = Asset Trade Order ist bereits geschlossen
+
+ORDER_DOES_NOT_EXIST = asset trade order existiert nicht
+
+POLL_ALREADY_EXISTS = Umfrage bereits vorhanden
+
+POLL_DOES_NOT_EXIST = Umfrage nicht vorhanden
+
+POLL_OPTION_DOES_NOT_EXIST = Umfrageoption existiert nicht
+
+PUBLIC_KEY_UNKNOWN = öffentlicher Schlüssel unbekannt
+
+REWARD_SHARE_UNKNOWN = Geteilte Belohnungen unbekant
+
+SELF_SHARE_EXISTS = Selbstbeteiligung (Geteilte Belohnungen) sind breits vorhanden
+
+TIMESTAMP_TOO_NEW = Zeitstempel zu neu
+
+TIMESTAMP_TOO_OLD = Zeitstempel zu alt
+
+TOO_MANY_UNCONFIRMED = Account hat zu viele unbestätigte Transaktionen am laufen
+
+TRANSACTION_ALREADY_CONFIRMED = Transaktionen sind bereits bestätigt
+
+TRANSACTION_ALREADY_EXISTS = Transaktionen existiert bereits
+
+TRANSACTION_UNKNOWN = Unbekante Transaktion
+
+TX_GROUP_ID_MISMATCH = Transaktion Gruppen ID stimmt nicht überein

src/main/resources/i18n/TransactionValidity_pl.properties

@@ -0,0 +1,196 @@
+#
+
+ACCOUNT_ALREADY_EXISTS = konto już istnieje
+
+ACCOUNT_CANNOT_REWARD_SHARE = konto nie może udostępniać nagród
+
+ADDRESS_ABOVE_RATE_LIMIT = adres osiągnął określony limit stawki
+
+ADDRESS_BLOCKED = ten adres jest zablokowany
+
+ALREADY_GROUP_ADMIN = już adminem grupy
+
+ALREADY_GROUP_MEMBER = już członkiem grupy
+
+ALREADY_VOTED_FOR_THAT_OPTION = już zagłosowano na ta opcje
+
+ASSET_ALREADY_EXISTS = aktywa już istnieje
+
+ASSET_DOES_NOT_EXIST = aktywa nie istnieje
+
+ASSET_DOES_NOT_MATCH_AT = aktywa nie pasuje do aktywy AT
+
+ASSET_NOT_SPENDABLE = aktywa nie jest rozporządzalna
+
+AT_ALREADY_EXISTS = AT już istnieje
+
+AT_IS_FINISHED = AT zakończył
+
+AT_UNKNOWN = AT nieznany
+
+BAN_EXISTS = ban już istnieje
+
+BAN_UNKNOWN = ban nieznany
+
+BANNED_FROM_GROUP = zbanowany z grupy
+
+BUYER_ALREADY_OWNER = kupca jest już właścicielem
+
+CLOCK_NOT_SYNCED = zegar nie zsynchronizowany
+
+DUPLICATE_MESSAGE = adres wysłał duplikat wiadomości
+
+DUPLICATE_OPTION = duplikat opcji
+
+GROUP_ALREADY_EXISTS = grupa już istnieje
+
+GROUP_APPROVAL_DECIDED = zatwierdzenie grupy już zdecydowano
+
+GROUP_APPROVAL_NOT_REQUIRED = zatwierdzenie grupy nie jest wymagane
+
+GROUP_DOES_NOT_EXIST = grupa nie istnieje
+
+GROUP_ID_MISMATCH = niedopasowanie identyfikatora grupy
+
+GROUP_OWNER_CANNOT_LEAVE = właściciel grupy nie może opuścić grupy
+
+HAVE_EQUALS_WANT = posiadana aktywa równa się chcianej aktywie
+
+INCORRECT_NONCE = nieprawidłowy nonce PoW
+
+INSUFFICIENT_FEE = niewystarczająca opłata
+
+INVALID_ADDRESS = nieprawidłowy adres
+
+INVALID_AMOUNT = nieprawidłowa kwota
+
+INVALID_ASSET_OWNER = nieprawidłowy właściciel aktywów
+
+INVALID_AT_TRANSACTION = nieważna transakcja AT
+
+INVALID_AT_TYPE_LENGTH = nieprawidłowa długość typu AT
+
+INVALID_BUT_OK = nieważne, ale OK
+
+INVALID_CREATION_BYTES = nieprawidłowe bajty tworzenia
+
+INVALID_DATA_LENGTH = nieprawidłowa długość danych
+
+INVALID_DESCRIPTION_LENGTH = nieprawidłowa długość opisu
+
+INVALID_GROUP_APPROVAL_THRESHOLD = nieprawidłowy próg zatwierdzenia grupy
+
+INVALID_GROUP_BLOCK_DELAY = nieprawidłowe opóźnienie bloku zatwierdzenia grupy
+
+INVALID_GROUP_ID = nieprawidłowy identyfikator grupy
+
+INVALID_GROUP_OWNER = nieprawidłowy właściciel grupy
+
+INVALID_LIFETIME = nieprawidłowy czas istnienia
+
+INVALID_NAME_LENGTH = nieprawidłowa długość nazwy
+
+INVALID_NAME_OWNER = nieprawidłowy właściciel nazwy
+
+INVALID_OPTION_LENGTH = nieprawidłowa długość opcji
+
+INVALID_OPTIONS_COUNT = nieprawidłowa liczba opcji
+
+INVALID_ORDER_CREATOR = nieprawidłowy twórca zlecenia
+
+INVALID_PAYMENTS_COUNT = nieprawidłowa liczba płatności
+
+INVALID_PUBLIC_KEY = nieprawidłowy klucz publiczny
+
+INVALID_QUANTITY = nieprawidłowa ilość
+
+INVALID_REFERENCE = nieprawidłowe skierowanie
+
+INVALID_RETURN = nieprawidłowy zwrot
+
+INVALID_REWARD_SHARE_PERCENT = nieprawidłowy procent udziału w nagrodzie
+
+INVALID_SELLER = nieprawidłowy sprzedawca
+
+INVALID_TAGS_LENGTH = nieprawidłowa długość tagów
+
+INVALID_TIMESTAMP_SIGNATURE = nieprawidłowa sygnatura znacznika czasu
+
+INVALID_TX_GROUP_ID = nieprawidłowy identyfikator grupy transakcji
+
+INVALID_VALUE_LENGTH = nieprawidłowa długość wartości
+
+INVITE_UNKNOWN = zaproszenie do grupy nieznane
+
+JOIN_REQUEST_EXISTS = wniosek o dołączenie do grupy już istnieje
+
+MAXIMUM_REWARD_SHARES = osiągnięto już maksymalną liczbę udziałów w nagrodzie dla tego konta
+
+MISSING_CREATOR = brak twórcy
+
+MULTIPLE_NAMES_FORBIDDEN = zabronione jest używanie wielu nazw na jednym koncie
+
+NAME_ALREADY_FOR_SALE = nazwa już wystawiona na sprzedaż
+
+NAME_ALREADY_REGISTERED = nazwa już zarejestrowana
+
+NAME_BLOCKED = ta nazwa jest zablokowana
+
+NAME_DOES_NOT_EXIST = nazwa nie istnieje
+
+NAME_NOT_FOR_SALE = nazwa nie jest przeznaczona do sprzedaży
+
+NAME_NOT_NORMALIZED = nazwa nie jest w formie 'znormalizowanej' Unicode
+
+NEGATIVE_AMOUNT = nieprawidłowa/ujemna kwota
+
+NEGATIVE_FEE = nieprawidłowa/ujemna opłata
+
+NEGATIVE_PRICE = nieprawidłowa/ujemna cena
+
+NO_BALANCE = niewystarczające środki
+
+NO_BLOCKCHAIN_LOCK = węzeł blockchain jest obecnie zajęty
+
+NO_FLAG_PERMISSION = konto nie ma tego uprawnienia
+
+NOT_GROUP_ADMIN = konto nie jest adminem grupy
+
+NOT_GROUP_MEMBER = konto nie jest członkiem grupy
+
+NOT_MINTING_ACCOUNT = konto nie może bić monet
+
+NOT_YET_RELEASED = funkcja nie została jeszcze udostępniona
+
+OK = OK
+
+ORDER_ALREADY_CLOSED = zlecenie handlu aktywami jest już zakończone
+
+ORDER_DOES_NOT_EXIST = zlecenie sprzedaży aktywów nie istnieje
+
+POLL_ALREADY_EXISTS = ankieta już istnieje
+
+POLL_DOES_NOT_EXIST = ankieta nie istnieje
+
+POLL_OPTION_DOES_NOT_EXIST = opcja ankiety nie istnieje
+
+PUBLIC_KEY_UNKNOWN = klucz publiczny nieznany
+
+REWARD_SHARE_UNKNOWN = nieznany udział w nagrodzie
+
+SELF_SHARE_EXISTS = samoudział (udział w nagrodzie) już istnieje
+
+TIMESTAMP_TOO_NEW = zbyt nowy znacznik czasu
+
+TIMESTAMP_TOO_OLD = zbyt stary znacznik czasu
+
+TOO_MANY_UNCONFIRMED = rachunek ma zbyt wiele niepotwierdzonych transakcji w toku
+
+TRANSACTION_ALREADY_CONFIRMED = transakcja została już potwierdzona
+
+TRANSACTION_ALREADY_EXISTS = transakcja już istnieje
+
+TRANSACTION_UNKNOWN = transakcja nieznana
+
+TX_GROUP_ID_MISMATCH = niezgodność ID grupy transakcji
+

src/test/java/org/qortal/test/BlockArchiveV1Tests.java

@@ -1,6 +1,7 @@
 package org.qortal.test;
 
 import org.apache.commons.io.FileUtils;
+import org.apache.commons.lang3.reflect.FieldUtils;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
@@ -10,8 +11,6 @@ import org.qortal.data.at.ATStateData;
 import org.qortal.data.block.BlockData;
 import org.qortal.data.transaction.TransactionData;
 import org.qortal.repository.*;
-import org.qortal.repository.hsqldb.HSQLDBDatabaseArchiving;
-import org.qortal.repository.hsqldb.HSQLDBDatabasePruning;
 import org.qortal.repository.hsqldb.HSQLDBRepository;
 import org.qortal.settings.Settings;
 import org.qortal.test.common.AtUtils;
@@ -23,11 +22,9 @@ import org.qortal.transform.TransformationException;
 import org.qortal.transform.block.BlockTransformation;
 import org.qortal.utils.BlockArchiveUtils;
 import org.qortal.utils.NTP;
-import org.qortal.utils.Triple;
 
 import java.io.File;
 import java.io.IOException;
-import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.sql.SQLException;
@@ -35,13 +32,16 @@ import java.util.List;
 
 import static org.junit.Assert.*;
 
-public class BlockArchiveTests extends Common {
+public class BlockArchiveV1Tests extends Common {
 
 	@Before
-	public void beforeTest() throws DataException {
+	public void beforeTest() throws DataException, IllegalAccessException {
 		Common.useSettings("test-settings-v2-block-archive.json");
 		NTP.setFixedOffset(Settings.getInstance().getTestNtpOffset());
 		this.deleteArchiveDirectory();
+
+		// Set default archive version to 1, so that archive builds in these tests use V2
+		FieldUtils.writeField(Settings.getInstance(), "defaultArchiveVersion", 1, true);
 	}
 
 	@After
@@ -314,9 +314,10 @@ public class BlockArchiveTests extends Common {
 			repository.getBlockRepository().setBlockPruneHeight(901);
 
 			// Prune the AT states for the archived blocks
-			repository.getATRepository().rebuildLatestAtStates();
+			repository.getATRepository().rebuildLatestAtStates(900);
+			repository.saveChanges();
 			int numATStatesPruned = repository.getATRepository().pruneAtStates(0, 900);
-			assertEquals(900-1, numATStatesPruned);
+			assertEquals(900-2, numATStatesPruned); // Minus 1 for genesis block, and another for the latest AT state
 			repository.getATRepository().setAtPruneHeight(901);
 
 			// Now ensure the SQL repository is missing blocks 2 and 900...
@@ -333,212 +334,6 @@ public class BlockArchiveTests extends Common {
 		}
 	}
 
-	@Test
-	public void testBulkArchiveAndPrune() throws DataException, SQLException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			HSQLDBRepository hsqldb = (HSQLDBRepository) repository;
-
-			// Deploy an AT so that we have AT state data
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "alice");
-			byte[] creationBytes = AtUtils.buildSimpleAT();
-			long fundingAmount = 1_00000000L;
-			AtUtils.doDeployAT(repository, deployer, creationBytes, fundingAmount);
-
-			// Mint some blocks so that we are able to archive them later
-			for (int i = 0; i < 1000; i++) {
-				BlockMinter.mintTestingBlock(repository, Common.getTestAccount(repository, "alice-reward-share"));
-			}
-
-			// Assume 900 blocks are trimmed (this specifies the first untrimmed height)
-			repository.getBlockRepository().setOnlineAccountsSignaturesTrimHeight(901);
-			repository.getATRepository().setAtTrimHeight(901);
-
-			// Check the max archive height - this should be one less than the first untrimmed height
-			final int maximumArchiveHeight = BlockArchiveWriter.getMaxArchiveHeight(repository);
-			assertEquals(900, maximumArchiveHeight);
-
-			// Check the current archive height
-			assertEquals(0, repository.getBlockArchiveRepository().getBlockArchiveHeight());
-
-			// Write blocks 2-900 to the archive (using bulk method)
-			int fileSizeTarget = 428600; // Pre-calculated size of 900 blocks
-			assertTrue(HSQLDBDatabaseArchiving.buildBlockArchive(repository, fileSizeTarget));
-
-			// Ensure the block archive height has increased
-			assertEquals(901, repository.getBlockArchiveRepository().getBlockArchiveHeight());
-
-			// Ensure the SQL repository contains blocks 2 and 900...
-			assertNotNull(repository.getBlockRepository().fromHeight(2));
-			assertNotNull(repository.getBlockRepository().fromHeight(900));
-
-			// Check the current prune heights
-			assertEquals(0, repository.getBlockRepository().getBlockPruneHeight());
-			assertEquals(0, repository.getATRepository().getAtPruneHeight());
-
-			// Prior to archiving or pruning, ensure blocks 2 to 1002 and their AT states are available in the db
-			for (int i=2; i<=1002; i++) {
-				assertNotNull(repository.getBlockRepository().fromHeight(i));
-				List<ATStateData> atStates = repository.getATRepository().getBlockATStatesAtHeight(i);
-				assertNotNull(atStates);
-				assertEquals(1, atStates.size());
-			}
-
-			// Prune all the archived blocks and AT states (using bulk method)
-			assertTrue(HSQLDBDatabasePruning.pruneBlocks(hsqldb));
-			assertTrue(HSQLDBDatabasePruning.pruneATStates(hsqldb));
-
-			// Ensure the current prune heights have increased
-			assertEquals(901, repository.getBlockRepository().getBlockPruneHeight());
-			assertEquals(901, repository.getATRepository().getAtPruneHeight());
-
-			// Now ensure the SQL repository is missing blocks 2 and 900...
-			assertNull(repository.getBlockRepository().fromHeight(2));
-			assertNull(repository.getBlockRepository().fromHeight(900));
-
-			// ... but it's not missing blocks 1 and 901 (we don't prune the genesis block)
-			assertNotNull(repository.getBlockRepository().fromHeight(1));
-			assertNotNull(repository.getBlockRepository().fromHeight(901));
-
-			// Validate the latest block height in the repository
-			assertEquals(1002, (int) repository.getBlockRepository().getLastBlock().getHeight());
-
-			// Ensure blocks 2-900 are all available in the archive
-			for (int i=2; i<=900; i++) {
-				assertNotNull(repository.getBlockArchiveRepository().fromHeight(i));
-			}
-
-			// Ensure blocks 2-900 are NOT available in the db
-			for (int i=2; i<=900; i++) {
-				assertNull(repository.getBlockRepository().fromHeight(i));
-			}
-
-			// Ensure blocks 901 to 1002 and their AT states are available in the db
-			for (int i=901; i<=1002; i++) {
-				assertNotNull(repository.getBlockRepository().fromHeight(i));
-				List<ATStateData> atStates = repository.getATRepository().getBlockATStatesAtHeight(i);
-				assertNotNull(atStates);
-				assertEquals(1, atStates.size());
-			}
-
-			// Ensure blocks 901 to 1002 are not available in the archive
-			for (int i=901; i<=1002; i++) {
-				assertNull(repository.getBlockArchiveRepository().fromHeight(i));
-			}
-		}
-	}
-
-	@Test
-	public void testBulkArchiveAndPruneMultipleFiles() throws DataException, SQLException {
-		try (final Repository repository = RepositoryManager.getRepository()) {
-			HSQLDBRepository hsqldb = (HSQLDBRepository) repository;
-
-			// Deploy an AT so that we have AT state data
-			PrivateKeyAccount deployer = Common.getTestAccount(repository, "alice");
-			byte[] creationBytes = AtUtils.buildSimpleAT();
-			long fundingAmount = 1_00000000L;
-			AtUtils.doDeployAT(repository, deployer, creationBytes, fundingAmount);
-
-			// Mint some blocks so that we are able to archive them later
-			for (int i = 0; i < 1000; i++) {
-				BlockMinter.mintTestingBlock(repository, Common.getTestAccount(repository, "alice-reward-share"));
-			}
-
-			// Assume 900 blocks are trimmed (this specifies the first untrimmed height)
-			repository.getBlockRepository().setOnlineAccountsSignaturesTrimHeight(901);
-			repository.getATRepository().setAtTrimHeight(901);
-
-			// Check the max archive height - this should be one less than the first untrimmed height
-			final int maximumArchiveHeight = BlockArchiveWriter.getMaxArchiveHeight(repository);
-			assertEquals(900, maximumArchiveHeight);
-
-			// Check the current archive height
-			assertEquals(0, repository.getBlockArchiveRepository().getBlockArchiveHeight());
-
-			// Write blocks 2-900 to the archive (using bulk method)
-			int fileSizeTarget = 42360; // Pre-calculated size of approx 90 blocks
-			assertTrue(HSQLDBDatabaseArchiving.buildBlockArchive(repository, fileSizeTarget));
-
-			// Ensure 10 archive files have been created
-			Path archivePath = Paths.get(Settings.getInstance().getRepositoryPath(), "archive");
-			assertEquals(10, new File(archivePath.toString()).list().length);
-
-			// Check the files exist
-			assertTrue(Files.exists(Paths.get(archivePath.toString(), "2-90.dat")));
-			assertTrue(Files.exists(Paths.get(archivePath.toString(), "91-179.dat")));
-			assertTrue(Files.exists(Paths.get(archivePath.toString(), "180-268.dat")));
-			assertTrue(Files.exists(Paths.get(archivePath.toString(), "269-357.dat")));
-			assertTrue(Files.exists(Paths.get(archivePath.toString(), "358-446.dat")));
-			assertTrue(Files.exists(Paths.get(archivePath.toString(), "447-535.dat")));
-			assertTrue(Files.exists(Paths.get(archivePath.toString(), "536-624.dat")));
-			assertTrue(Files.exists(Paths.get(archivePath.toString(), "625-713.dat")));
-			assertTrue(Files.exists(Paths.get(archivePath.toString(), "714-802.dat")));
-			assertTrue(Files.exists(Paths.get(archivePath.toString(), "803-891.dat")));
-
-			// Ensure the block archive height has increased
-			// It won't be as high as 901, because blocks 892-901 were too small to reach the file size
-			// target of the 11th file
-			assertEquals(892, repository.getBlockArchiveRepository().getBlockArchiveHeight());
-
-			// Ensure the SQL repository contains blocks 2 and 891...
-			assertNotNull(repository.getBlockRepository().fromHeight(2));
-			assertNotNull(repository.getBlockRepository().fromHeight(891));
-
-			// Check the current prune heights
-			assertEquals(0, repository.getBlockRepository().getBlockPruneHeight());
-			assertEquals(0, repository.getATRepository().getAtPruneHeight());
-
-			// Prior to archiving or pruning, ensure blocks 2 to 1002 and their AT states are available in the db
-			for (int i=2; i<=1002; i++) {
-				assertNotNull(repository.getBlockRepository().fromHeight(i));
-				List<ATStateData> atStates = repository.getATRepository().getBlockATStatesAtHeight(i);
-				assertNotNull(atStates);
-				assertEquals(1, atStates.size());
-			}
-
-			// Prune all the archived blocks and AT states (using bulk method)
-			assertTrue(HSQLDBDatabasePruning.pruneBlocks(hsqldb));
-			assertTrue(HSQLDBDatabasePruning.pruneATStates(hsqldb));
-
-			// Ensure the current prune heights have increased
-			assertEquals(892, repository.getBlockRepository().getBlockPruneHeight());
-			assertEquals(892, repository.getATRepository().getAtPruneHeight());
-
-			// Now ensure the SQL repository is missing blocks 2 and 891...
-			assertNull(repository.getBlockRepository().fromHeight(2));
-			assertNull(repository.getBlockRepository().fromHeight(891));
-
-			// ... but it's not missing blocks 1 and 901 (we don't prune the genesis block)
-			assertNotNull(repository.getBlockRepository().fromHeight(1));
-			assertNotNull(repository.getBlockRepository().fromHeight(892));
-
-			// Validate the latest block height in the repository
-			assertEquals(1002, (int) repository.getBlockRepository().getLastBlock().getHeight());
-
-			// Ensure blocks 2-891 are all available in the archive
-			for (int i=2; i<=891; i++) {
-				assertNotNull(repository.getBlockArchiveRepository().fromHeight(i));
-			}
-
-			// Ensure blocks 2-891 are NOT available in the db
-			for (int i=2; i<=891; i++) {
-				assertNull(repository.getBlockRepository().fromHeight(i));
-			}
-
-			// Ensure blocks 892 to 1002 and their AT states are available in the db
-			for (int i=892; i<=1002; i++) {
-				assertNotNull(repository.getBlockRepository().fromHeight(i));
-				List<ATStateData> atStates = repository.getATRepository().getBlockATStatesAtHeight(i);
-				assertNotNull(atStates);
-				assertEquals(1, atStates.size());
-			}
-
-			// Ensure blocks 892 to 1002 are not available in the archive
-			for (int i=892; i<=1002; i++) {
-				assertNull(repository.getBlockArchiveRepository().fromHeight(i));
-			}
-		}
-	}
-
 	@Test
 	public void testTrimArchivePruneAndOrphan() throws DataException, InterruptedException, TransformationException, IOException {
 		try (final Repository repository = RepositoryManager.getRepository()) {
@@ -563,16 +358,23 @@ public class BlockArchiveTests extends Common {
 			// Trim the first 500 blocks
 			repository.getBlockRepository().trimOldOnlineAccountsSignatures(0, 500);
 			repository.getBlockRepository().setOnlineAccountsSignaturesTrimHeight(501);
+			repository.getATRepository().rebuildLatestAtStates(500);
 			repository.getATRepository().trimAtStates(0, 500, 1000);
 			repository.getATRepository().setAtTrimHeight(501);
 
-			// Now block 500 should only have the AT state data hash
-			block500AtStatesData = repository.getATRepository().getBlockATStatesAtHeight(500);
-			atStatesData = repository.getATRepository().getATStateAtHeight(block500AtStatesData.get(0).getATAddress(), 500);
+			// Now block 499 should only have the AT state data hash
+			List<ATStateData> block499AtStatesData = repository.getATRepository().getBlockATStatesAtHeight(499);
+			atStatesData = repository.getATRepository().getATStateAtHeight(block499AtStatesData.get(0).getATAddress(), 499);
 			assertNotNull(atStatesData.getStateHash());
 			assertNull(atStatesData.getStateData());
 
-			// ... but block 501 should have the full data
+			// ... but block 500 should have the full data (due to being retained as the "latest" AT state in the trimmed range
+			block500AtStatesData = repository.getATRepository().getBlockATStatesAtHeight(500);
+			atStatesData = repository.getATRepository().getATStateAtHeight(block500AtStatesData.get(0).getATAddress(), 500);
+			assertNotNull(atStatesData.getStateHash());
+			assertNotNull(atStatesData.getStateData());
+
+			// ... and block 501 should also have the full data
 			List<ATStateData> block501AtStatesData = repository.getATRepository().getBlockATStatesAtHeight(501);
 			atStatesData = repository.getATRepository().getATStateAtHeight(block501AtStatesData.get(0).getATAddress(), 501);
 			assertNotNull(atStatesData.getStateHash());
@@ -612,9 +414,10 @@ public class BlockArchiveTests extends Common {
 			repository.getBlockRepository().setBlockPruneHeight(501);
 
 			// Prune the AT states for the archived blocks
-			repository.getATRepository().rebuildLatestAtStates();
+			repository.getATRepository().rebuildLatestAtStates(500);
+			repository.saveChanges();
 			int numATStatesPruned = repository.getATRepository().pruneAtStates(2, 500);
-			assertEquals(499, numATStatesPruned);
+			assertEquals(498, numATStatesPruned); // Minus 1 for genesis block, and another for the latest AT state
 			repository.getATRepository().setAtPruneHeight(501);
 
 			// Now ensure the SQL repository is missing blocks 2 and 500...

src/test/java/org/qortal/test/BlockArchiveV2Tests.java

@@ -0,0 +1,504 @@
+package org.qortal.test;
+
+import org.apache.commons.io.FileUtils;
+import org.apache.commons.lang3.reflect.FieldUtils;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.qortal.account.PrivateKeyAccount;
+import org.qortal.controller.BlockMinter;
+import org.qortal.data.at.ATStateData;
+import org.qortal.data.block.BlockData;
+import org.qortal.data.transaction.TransactionData;
+import org.qortal.repository.*;
+import org.qortal.repository.hsqldb.HSQLDBRepository;
+import org.qortal.settings.Settings;
+import org.qortal.test.common.AtUtils;
+import org.qortal.test.common.BlockUtils;
+import org.qortal.test.common.Common;
+import org.qortal.transaction.DeployAtTransaction;
+import org.qortal.transaction.Transaction;
+import org.qortal.transform.TransformationException;
+import org.qortal.transform.block.BlockTransformation;
+import org.qortal.utils.BlockArchiveUtils;
+import org.qortal.utils.NTP;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.sql.SQLException;
+import java.util.List;
+
+import static org.junit.Assert.*;
+
+public class BlockArchiveV2Tests extends Common {
+
+	@Before
+	public void beforeTest() throws DataException, IllegalAccessException {
+		Common.useSettings("test-settings-v2-block-archive.json");
+		NTP.setFixedOffset(Settings.getInstance().getTestNtpOffset());
+		this.deleteArchiveDirectory();
+
+		// Set default archive version to 2, so that archive builds in these tests use V2
+		FieldUtils.writeField(Settings.getInstance(), "defaultArchiveVersion", 2, true);
+	}
+
+	@After
+	public void afterTest() throws DataException {
+		this.deleteArchiveDirectory();
+	}
+
+
+	@Test
+	public void testWriter() throws DataException, InterruptedException, TransformationException, IOException {
+		try (final Repository repository = RepositoryManager.getRepository()) {
+
+			// Mint some blocks so that we are able to archive them later
+			for (int i = 0; i < 1000; i++) {
+				BlockMinter.mintTestingBlock(repository, Common.getTestAccount(repository, "alice-reward-share"));
+			}
+
+			// 900 blocks are trimmed (this specifies the first untrimmed height)
+			repository.getBlockRepository().setOnlineAccountsSignaturesTrimHeight(901);
+			repository.getATRepository().setAtTrimHeight(901);
+
+			// Check the max archive height - this should be one less than the first untrimmed height
+			final int maximumArchiveHeight = BlockArchiveWriter.getMaxArchiveHeight(repository);
+			assertEquals(900, maximumArchiveHeight);
+
+			// Write blocks 2-900 to the archive
+			BlockArchiveWriter writer = new BlockArchiveWriter(0, maximumArchiveHeight, repository);
+			writer.setShouldEnforceFileSizeTarget(false); // To avoid the need to pre-calculate file sizes
+			BlockArchiveWriter.BlockArchiveWriteResult result = writer.write();
+			assertEquals(BlockArchiveWriter.BlockArchiveWriteResult.OK, result);
+
+			// Make sure that the archive contains the correct number of blocks
+			assertEquals(900 - 1, writer.getWrittenCount());
+
+			// Increment block archive height
+			repository.getBlockArchiveRepository().setBlockArchiveHeight(writer.getWrittenCount());
+			repository.saveChanges();
+			assertEquals(900 - 1, repository.getBlockArchiveRepository().getBlockArchiveHeight());
+
+			// Ensure the file exists
+			File outputFile = writer.getOutputPath().toFile();
+			assertTrue(outputFile.exists());
+		}
+	}
+
+	@Test
+	public void testWriterAndReader() throws DataException, InterruptedException, TransformationException, IOException {
+		try (final Repository repository = RepositoryManager.getRepository()) {
+
+			// Mint some blocks so that we are able to archive them later
+			for (int i = 0; i < 1000; i++) {
+				BlockMinter.mintTestingBlock(repository, Common.getTestAccount(repository, "alice-reward-share"));
+			}
+
+			// 900 blocks are trimmed (this specifies the first untrimmed height)
+			repository.getBlockRepository().setOnlineAccountsSignaturesTrimHeight(901);
+			repository.getATRepository().setAtTrimHeight(901);
+
+			// Check the max archive height - this should be one less than the first untrimmed height
+			final int maximumArchiveHeight = BlockArchiveWriter.getMaxArchiveHeight(repository);
+			assertEquals(900, maximumArchiveHeight);
+
+			// Write blocks 2-900 to the archive
+			BlockArchiveWriter writer = new BlockArchiveWriter(0, maximumArchiveHeight, repository);
+			writer.setShouldEnforceFileSizeTarget(false); // To avoid the need to pre-calculate file sizes
+			BlockArchiveWriter.BlockArchiveWriteResult result = writer.write();
+			assertEquals(BlockArchiveWriter.BlockArchiveWriteResult.OK, result);
+
+			// Make sure that the archive contains the correct number of blocks
+			assertEquals(900 - 1, writer.getWrittenCount());
+
+			// Increment block archive height
+			repository.getBlockArchiveRepository().setBlockArchiveHeight(writer.getWrittenCount());
+			repository.saveChanges();
+			assertEquals(900 - 1, repository.getBlockArchiveRepository().getBlockArchiveHeight());
+
+			// Ensure the file exists
+			File outputFile = writer.getOutputPath().toFile();
+			assertTrue(outputFile.exists());
+
+			// Read block 2 from the archive
+			BlockArchiveReader reader = BlockArchiveReader.getInstance();
+			BlockTransformation block2Info = reader.fetchBlockAtHeight(2);
+			BlockData block2ArchiveData = block2Info.getBlockData();
+
+			// Read block 2 from the repository
+			BlockData block2RepositoryData = repository.getBlockRepository().fromHeight(2);
+
+			// Ensure the values match
+			assertEquals(block2ArchiveData.getHeight(), block2RepositoryData.getHeight());
+			assertArrayEquals(block2ArchiveData.getSignature(), block2RepositoryData.getSignature());
+
+			// Test some values in the archive
+			assertEquals(1, block2ArchiveData.getOnlineAccountsCount());
+
+			// Read block 900 from the archive
+			BlockTransformation block900Info = reader.fetchBlockAtHeight(900);
+			BlockData block900ArchiveData = block900Info.getBlockData();
+
+			// Read block 900 from the repository
+			BlockData block900RepositoryData = repository.getBlockRepository().fromHeight(900);
+
+			// Ensure the values match
+			assertEquals(block900ArchiveData.getHeight(), block900RepositoryData.getHeight());
+			assertArrayEquals(block900ArchiveData.getSignature(), block900RepositoryData.getSignature());
+
+			// Test some values in the archive
+			assertEquals(1, block900ArchiveData.getOnlineAccountsCount());
+
+		}
+	}
+
+	@Test
+	public void testArchivedAtStates() throws DataException, InterruptedException, TransformationException, IOException {
+		try (final Repository repository = RepositoryManager.getRepository()) {
+
+			// Deploy an AT so that we have AT state data
+			PrivateKeyAccount deployer = Common.getTestAccount(repository, "alice");
+			byte[] creationBytes = AtUtils.buildSimpleAT();
+			long fundingAmount = 1_00000000L;
+			DeployAtTransaction deployAtTransaction =  AtUtils.doDeployAT(repository, deployer, creationBytes, fundingAmount);
+			String atAddress = deployAtTransaction.getATAccount().getAddress();
+
+			// Mint some blocks so that we are able to archive them later
+			for (int i = 0; i < 1000; i++) {
+				BlockMinter.mintTestingBlock(repository, Common.getTestAccount(repository, "alice-reward-share"));
+			}
+
+			// 9 blocks are trimmed (this specifies the first untrimmed height)
+			repository.getBlockRepository().setOnlineAccountsSignaturesTrimHeight(10);
+			repository.getATRepository().setAtTrimHeight(10);
+
+			// Check the max archive height
+			final int maximumArchiveHeight = BlockArchiveWriter.getMaxArchiveHeight(repository);
+			assertEquals(9, maximumArchiveHeight);
+
+			// Write blocks 2-9 to the archive
+			BlockArchiveWriter writer = new BlockArchiveWriter(0, maximumArchiveHeight, repository);
+			writer.setShouldEnforceFileSizeTarget(false); // To avoid the need to pre-calculate file sizes
+			BlockArchiveWriter.BlockArchiveWriteResult result = writer.write();
+			assertEquals(BlockArchiveWriter.BlockArchiveWriteResult.OK, result);
+
+			// Make sure that the archive contains the correct number of blocks
+			assertEquals(9 - 1, writer.getWrittenCount());
+
+			// Increment block archive height
+			repository.getBlockArchiveRepository().setBlockArchiveHeight(writer.getWrittenCount());
+			repository.saveChanges();
+			assertEquals(9 - 1, repository.getBlockArchiveRepository().getBlockArchiveHeight());
+
+			// Ensure the file exists
+			File outputFile = writer.getOutputPath().toFile();
+			assertTrue(outputFile.exists());
+
+			// Check blocks 3-9
+			for (Integer testHeight = 2; testHeight <= 9; testHeight++) {
+
+				// Read a block from the archive
+				BlockArchiveReader reader = BlockArchiveReader.getInstance();
+				BlockTransformation blockInfo = reader.fetchBlockAtHeight(testHeight);
+				BlockData archivedBlockData = blockInfo.getBlockData();
+				byte[] archivedAtStateHash = blockInfo.getAtStatesHash();
+				List<TransactionData> archivedTransactions = blockInfo.getTransactions();
+
+				// Read the same block from the repository
+				BlockData repositoryBlockData = repository.getBlockRepository().fromHeight(testHeight);
+				ATStateData repositoryAtStateData = repository.getATRepository().getATStateAtHeight(atAddress, testHeight);
+
+				// Ensure the repository has full AT state data
+				assertNotNull(repositoryAtStateData.getStateHash());
+				assertNotNull(repositoryAtStateData.getStateData());
+
+				// Check the archived AT state
+				if (testHeight == 2) {
+					assertEquals(1, archivedTransactions.size());
+					assertEquals(Transaction.TransactionType.DEPLOY_AT, archivedTransactions.get(0).getType());
+				}
+				else {
+					// Blocks 3+ shouldn't have any transactions
+					assertTrue(archivedTransactions.isEmpty());
+				}
+
+				// Ensure the archive has the AT states hash
+				assertNotNull(archivedAtStateHash);
+
+				// Also check the online accounts count and height
+				assertEquals(1, archivedBlockData.getOnlineAccountsCount());
+				assertEquals(testHeight, archivedBlockData.getHeight());
+
+				// Ensure the values match
+				assertEquals(archivedBlockData.getHeight(), repositoryBlockData.getHeight());
+				assertArrayEquals(archivedBlockData.getSignature(), repositoryBlockData.getSignature());
+				assertEquals(archivedBlockData.getOnlineAccountsCount(), repositoryBlockData.getOnlineAccountsCount());
+				assertArrayEquals(archivedBlockData.getMinterSignature(), repositoryBlockData.getMinterSignature());
+				assertEquals(archivedBlockData.getATCount(), repositoryBlockData.getATCount());
+				assertEquals(archivedBlockData.getOnlineAccountsCount(), repositoryBlockData.getOnlineAccountsCount());
+				assertArrayEquals(archivedBlockData.getReference(), repositoryBlockData.getReference());
+				assertEquals(archivedBlockData.getTimestamp(), repositoryBlockData.getTimestamp());
+				assertEquals(archivedBlockData.getATFees(), repositoryBlockData.getATFees());
+				assertEquals(archivedBlockData.getTotalFees(), repositoryBlockData.getTotalFees());
+				assertEquals(archivedBlockData.getTransactionCount(), repositoryBlockData.getTransactionCount());
+				assertArrayEquals(archivedBlockData.getTransactionsSignature(), repositoryBlockData.getTransactionsSignature());
+
+				// TODO: build atStatesHash and compare against value in archive
+			}
+
+			// Check block 10 (unarchived)
+			BlockArchiveReader reader = BlockArchiveReader.getInstance();
+			BlockTransformation blockInfo = reader.fetchBlockAtHeight(10);
+			assertNull(blockInfo);
+
+		}
+
+	}
+
+	@Test
+	public void testArchiveAndPrune() throws DataException, InterruptedException, TransformationException, IOException {
+		try (final Repository repository = RepositoryManager.getRepository()) {
+
+			// Deploy an AT so that we have AT state data
+			PrivateKeyAccount deployer = Common.getTestAccount(repository, "alice");
+			byte[] creationBytes = AtUtils.buildSimpleAT();
+			long fundingAmount = 1_00000000L;
+			AtUtils.doDeployAT(repository, deployer, creationBytes, fundingAmount);
+
+			// Mint some blocks so that we are able to archive them later
+			for (int i = 0; i < 1000; i++) {
+				BlockMinter.mintTestingBlock(repository, Common.getTestAccount(repository, "alice-reward-share"));
+			}
+
+			// Assume 900 blocks are trimmed (this specifies the first untrimmed height)
+			repository.getBlockRepository().setOnlineAccountsSignaturesTrimHeight(901);
+			repository.getATRepository().setAtTrimHeight(901);
+
+			// Check the max archive height - this should be one less than the first untrimmed height
+			final int maximumArchiveHeight = BlockArchiveWriter.getMaxArchiveHeight(repository);
+			assertEquals(900, maximumArchiveHeight);
+
+			// Write blocks 2-900 to the archive
+			BlockArchiveWriter writer = new BlockArchiveWriter(0, maximumArchiveHeight, repository);
+			writer.setShouldEnforceFileSizeTarget(false); // To avoid the need to pre-calculate file sizes
+			BlockArchiveWriter.BlockArchiveWriteResult result = writer.write();
+			assertEquals(BlockArchiveWriter.BlockArchiveWriteResult.OK, result);
+
+			// Make sure that the archive contains the correct number of blocks
+			assertEquals(900 - 1, writer.getWrittenCount());
+
+			// Increment block archive height
+			repository.getBlockArchiveRepository().setBlockArchiveHeight(901);
+			repository.saveChanges();
+			assertEquals(901, repository.getBlockArchiveRepository().getBlockArchiveHeight());
+
+			// Ensure the file exists
+			File outputFile = writer.getOutputPath().toFile();
+			assertTrue(outputFile.exists());
+
+			// Ensure the SQL repository contains blocks 2 and 900...
+			assertNotNull(repository.getBlockRepository().fromHeight(2));
+			assertNotNull(repository.getBlockRepository().fromHeight(900));
+
+			// Prune all the archived blocks
+			int numBlocksPruned = repository.getBlockRepository().pruneBlocks(0, 900);
+			assertEquals(900-1, numBlocksPruned);
+			repository.getBlockRepository().setBlockPruneHeight(901);
+
+			// Prune the AT states for the archived blocks
+			repository.getATRepository().rebuildLatestAtStates(900);
+			repository.saveChanges();
+			int numATStatesPruned = repository.getATRepository().pruneAtStates(0, 900);
+			assertEquals(900-2, numATStatesPruned); // Minus 1 for genesis block, and another for the latest AT state
+			repository.getATRepository().setAtPruneHeight(901);
+
+			// Now ensure the SQL repository is missing blocks 2 and 900...
+			assertNull(repository.getBlockRepository().fromHeight(2));
+			assertNull(repository.getBlockRepository().fromHeight(900));
+
+			// ... but it's not missing blocks 1 and 901 (we don't prune the genesis block)
+			assertNotNull(repository.getBlockRepository().fromHeight(1));
+			assertNotNull(repository.getBlockRepository().fromHeight(901));
+
+			// Validate the latest block height in the repository
+			assertEquals(1002, (int) repository.getBlockRepository().getLastBlock().getHeight());
+
+		}
+	}
+
+	@Test
+	public void testTrimArchivePruneAndOrphan() throws DataException, InterruptedException, TransformationException, IOException {
+		try (final Repository repository = RepositoryManager.getRepository()) {
+
+			// Deploy an AT so that we have AT state data
+			PrivateKeyAccount deployer = Common.getTestAccount(repository, "alice");
+			byte[] creationBytes = AtUtils.buildSimpleAT();
+			long fundingAmount = 1_00000000L;
+			AtUtils.doDeployAT(repository, deployer, creationBytes, fundingAmount);
+
+			// Mint some blocks so that we are able to archive them later
+			for (int i = 0; i < 1000; i++) {
+				BlockMinter.mintTestingBlock(repository, Common.getTestAccount(repository, "alice-reward-share"));
+			}
+
+			// Make sure that block 500 has full AT state data and data hash
+			List<ATStateData> block500AtStatesData = repository.getATRepository().getBlockATStatesAtHeight(500);
+			ATStateData atStatesData = repository.getATRepository().getATStateAtHeight(block500AtStatesData.get(0).getATAddress(), 500);
+			assertNotNull(atStatesData.getStateHash());
+			assertNotNull(atStatesData.getStateData());
+
+			// Trim the first 500 blocks
+			repository.getBlockRepository().trimOldOnlineAccountsSignatures(0, 500);
+			repository.getBlockRepository().setOnlineAccountsSignaturesTrimHeight(501);
+			repository.getATRepository().rebuildLatestAtStates(500);
+			repository.getATRepository().trimAtStates(0, 500, 1000);
+			repository.getATRepository().setAtTrimHeight(501);
+
+			// Now block 499 should only have the AT state data hash
+			List<ATStateData> block499AtStatesData = repository.getATRepository().getBlockATStatesAtHeight(499);
+			atStatesData = repository.getATRepository().getATStateAtHeight(block499AtStatesData.get(0).getATAddress(), 499);
+			assertNotNull(atStatesData.getStateHash());
+			assertNull(atStatesData.getStateData());
+
+			// ... but block 500 should have the full data (due to being retained as the "latest" AT state in the trimmed range
+			block500AtStatesData = repository.getATRepository().getBlockATStatesAtHeight(500);
+			atStatesData = repository.getATRepository().getATStateAtHeight(block500AtStatesData.get(0).getATAddress(), 500);
+			assertNotNull(atStatesData.getStateHash());
+			assertNotNull(atStatesData.getStateData());
+
+			// ... and block 501 should also have the full data
+			List<ATStateData> block501AtStatesData = repository.getATRepository().getBlockATStatesAtHeight(501);
+			atStatesData = repository.getATRepository().getATStateAtHeight(block501AtStatesData.get(0).getATAddress(), 501);
+			assertNotNull(atStatesData.getStateHash());
+			assertNotNull(atStatesData.getStateData());
+
+			// Check the max archive height - this should be one less than the first untrimmed height
+			final int maximumArchiveHeight = BlockArchiveWriter.getMaxArchiveHeight(repository);
+			assertEquals(500, maximumArchiveHeight);
+
+			BlockData block3DataPreArchive = repository.getBlockRepository().fromHeight(3);
+
+			// Write blocks 2-500 to the archive
+			BlockArchiveWriter writer = new BlockArchiveWriter(0, maximumArchiveHeight, repository);
+			writer.setShouldEnforceFileSizeTarget(false); // To avoid the need to pre-calculate file sizes
+			BlockArchiveWriter.BlockArchiveWriteResult result = writer.write();
+			assertEquals(BlockArchiveWriter.BlockArchiveWriteResult.OK, result);
+
+			// Make sure that the archive contains the correct number of blocks
+			assertEquals(500 - 1, writer.getWrittenCount()); // -1 for the genesis block
+
+			// Increment block archive height
+			repository.getBlockArchiveRepository().setBlockArchiveHeight(writer.getWrittenCount());
+			repository.saveChanges();
+			assertEquals(500 - 1, repository.getBlockArchiveRepository().getBlockArchiveHeight());
+
+			// Ensure the file exists
+			File outputFile = writer.getOutputPath().toFile();
+			assertTrue(outputFile.exists());
+
+			// Ensure the SQL repository contains blocks 2 and 500...
+			assertNotNull(repository.getBlockRepository().fromHeight(2));
+			assertNotNull(repository.getBlockRepository().fromHeight(500));
+
+			// Prune all the archived blocks
+			int numBlocksPruned = repository.getBlockRepository().pruneBlocks(0, 500);
+			assertEquals(500-1, numBlocksPruned);
+			repository.getBlockRepository().setBlockPruneHeight(501);
+
+			// Prune the AT states for the archived blocks
+			repository.getATRepository().rebuildLatestAtStates(500);
+			repository.saveChanges();
+			int numATStatesPruned = repository.getATRepository().pruneAtStates(2, 500);
+			assertEquals(498, numATStatesPruned); // Minus 1 for genesis block, and another for the latest AT state
+			repository.getATRepository().setAtPruneHeight(501);
+
+			// Now ensure the SQL repository is missing blocks 2 and 500...
+			assertNull(repository.getBlockRepository().fromHeight(2));
+			assertNull(repository.getBlockRepository().fromHeight(500));
+
+			// ... but it's not missing blocks 1 and 501 (we don't prune the genesis block)
+			assertNotNull(repository.getBlockRepository().fromHeight(1));
+			assertNotNull(repository.getBlockRepository().fromHeight(501));
+
+			// Validate the latest block height in the repository
+			assertEquals(1002, (int) repository.getBlockRepository().getLastBlock().getHeight());
+
+			// Now orphan some unarchived blocks.
+			BlockUtils.orphanBlocks(repository, 500);
+			assertEquals(502, (int) repository.getBlockRepository().getLastBlock().getHeight());
+
+			// We're close to the lower limit of the SQL database now, so
+			// we need to import some blocks from the archive
+			BlockArchiveUtils.importFromArchive(401, 500, repository);
+
+			// Ensure the SQL repository now contains block 401 but not 400...
+			assertNotNull(repository.getBlockRepository().fromHeight(401));
+			assertNull(repository.getBlockRepository().fromHeight(400));
+
+			// Import the remaining 399 blocks
+			BlockArchiveUtils.importFromArchive(2, 400, repository);
+
+			// Verify that block 3 matches the original
+			BlockData block3DataPostArchive = repository.getBlockRepository().fromHeight(3);
+			assertArrayEquals(block3DataPreArchive.getSignature(), block3DataPostArchive.getSignature());
+			assertEquals(block3DataPreArchive.getHeight(), block3DataPostArchive.getHeight());
+
+			// Orphan 2 more block, which should be the last one that is possible to be orphaned
+			// TODO: figure out why this is 1 block more than in the equivalent block archive V1 test
+			BlockUtils.orphanBlocks(repository, 2);
+
+			// Orphan another block, which should fail
+			Exception exception = null;
+			try {
+				BlockUtils.orphanBlocks(repository, 1);
+			} catch (DataException e) {
+				exception = e;
+			}
+
+			// Ensure that a DataException is thrown because there is no more AT states data available
+			assertNotNull(exception);
+			assertEquals(DataException.class, exception.getClass());
+
+			// FUTURE: we may be able to retain unique AT states when trimming, to avoid this exception
+			// and allow orphaning back through blocks with trimmed AT states.
+
+		}
+	}
+
+
+	/**
+	 * Many nodes are missing an ATStatesHeightIndex due to an earlier bug
+	 * In these cases we disable archiving and pruning as this index is a
+	 * very essential component in these processes.
+	 */
+	@Test
+	public void testMissingAtStatesHeightIndex() throws DataException, SQLException {
+		try (final HSQLDBRepository repository = (HSQLDBRepository) RepositoryManager.getRepository()) {
+
+			// Firstly check that we're able to prune or archive when the index exists
+			assertTrue(repository.getATRepository().hasAtStatesHeightIndex());
+			assertTrue(RepositoryManager.canArchiveOrPrune());
+
+			// Delete the index
+			repository.prepareStatement("DROP INDEX ATSTATESHEIGHTINDEX").execute();
+
+			// Ensure check that we're unable to prune or archive when the index doesn't exist
+			assertFalse(repository.getATRepository().hasAtStatesHeightIndex());
+			assertFalse(RepositoryManager.canArchiveOrPrune());
+		}
+	}
+
+
+	private void deleteArchiveDirectory() {
+		// Delete archive directory if exists
+		Path archivePath = Paths.get(Settings.getInstance().getRepositoryPath(), "archive").toAbsolutePath();
+		try {
+			FileUtils.deleteDirectory(archivePath.toFile());
+		} catch (IOException e) {
+
+		}
+	}
+
+}

src/test/java/org/qortal/test/BootstrapTests.java

@@ -176,7 +176,8 @@ public class BootstrapTests extends Common {
         repository.getBlockRepository().setBlockPruneHeight(901);
 
         // Prune the AT states for the archived blocks
-        repository.getATRepository().rebuildLatestAtStates();
+        repository.getATRepository().rebuildLatestAtStates(900);
+        repository.saveChanges();
         repository.getATRepository().pruneAtStates(0, 900);
         repository.getATRepository().setAtPruneHeight(901);
 

src/test/java/org/qortal/test/PruneTests.java

@@ -1,16 +1,33 @@
 package org.qortal.test;
 
+import com.google.common.hash.HashCode;
 import org.junit.Before;
 import org.junit.Test;
+import org.qortal.account.Account;
 import org.qortal.account.PrivateKeyAccount;
+import org.qortal.asset.Asset;
+import org.qortal.block.Block;
 import org.qortal.controller.BlockMinter;
+import org.qortal.crosschain.AcctMode;
+import org.qortal.crosschain.LitecoinACCTv3;
+import org.qortal.data.at.ATData;
 import org.qortal.data.at.ATStateData;
 import org.qortal.data.block.BlockData;
+import org.qortal.data.crosschain.CrossChainTradeData;
+import org.qortal.data.transaction.BaseTransactionData;
+import org.qortal.data.transaction.DeployAtTransactionData;
+import org.qortal.data.transaction.MessageTransactionData;
+import org.qortal.data.transaction.TransactionData;
+import org.qortal.group.Group;
 import org.qortal.repository.DataException;
 import org.qortal.repository.Repository;
 import org.qortal.repository.RepositoryManager;
 import org.qortal.test.common.AtUtils;
+import org.qortal.test.common.BlockUtils;
 import org.qortal.test.common.Common;
+import org.qortal.test.common.TransactionUtils;
+import org.qortal.transaction.DeployAtTransaction;
+import org.qortal.transaction.MessageTransaction;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -19,6 +36,13 @@ import static org.junit.Assert.*;
 
 public class PruneTests extends Common {
 
+    // Constants for test AT (an LTC ACCT)
+    public static final byte[] litecoinPublicKeyHash = HashCode.fromString("bb00bb11bb22bb33bb44bb55bb66bb77bb88bb99").asBytes();
+    public static final int tradeTimeout = 20; // blocks
+    public static final long redeemAmount = 80_40200000L;
+    public static final long fundingAmount = 123_45600000L;
+    public static final long litecoinAmount = 864200L; // 0.00864200 LTC
+
     @Before
     public void beforeTest() throws DataException {
         Common.useDefaultSettings();
@@ -62,23 +86,32 @@ public class PruneTests extends Common {
             repository.getBlockRepository().setBlockPruneHeight(6);
 
             // Prune AT states for blocks 2-5
+            repository.getATRepository().rebuildLatestAtStates(5);
+            repository.saveChanges();
             int numATStatesPruned = repository.getATRepository().pruneAtStates(0, 5);
-            assertEquals(4, numATStatesPruned);
+            assertEquals(3, numATStatesPruned);
             repository.getATRepository().setAtPruneHeight(6);
 
-            // Make sure that blocks 2-5 are now missing block data and AT states data
-            for (Integer i=2; i <= 5; i++) {
+            // Make sure that blocks 2-4 are now missing block data and AT states data
+            for (Integer i=2; i <= 4; i++) {
                 BlockData blockData = repository.getBlockRepository().fromHeight(i);
                 assertNull(blockData);
                 List<ATStateData> atStatesDataList = repository.getATRepository().getBlockATStatesAtHeight(i);
                 assertTrue(atStatesDataList.isEmpty());
             }
 
-            // ... but blocks 6-10 have block data and full AT states data
+            // Block 5 should have full AT states data even though it was pruned.
+            // This is because we identified that as the "latest" AT state in that block range
+            BlockData blockData = repository.getBlockRepository().fromHeight(5);
+            assertNull(blockData);
+            List<ATStateData> atStatesDataList = repository.getATRepository().getBlockATStatesAtHeight(5);
+            assertEquals(1, atStatesDataList.size());
+
+            // Blocks 6-10 have block data and full AT states data
             for (Integer i=6; i <= 10; i++) {
-                BlockData blockData = repository.getBlockRepository().fromHeight(i);
+                blockData = repository.getBlockRepository().fromHeight(i);
                 assertNotNull(blockData.getSignature());
-                List<ATStateData> atStatesDataList = repository.getATRepository().getBlockATStatesAtHeight(i);
+                atStatesDataList = repository.getATRepository().getBlockATStatesAtHeight(i);
                 assertNotNull(atStatesDataList);
                 assertFalse(atStatesDataList.isEmpty());
                 ATStateData atStatesData = repository.getATRepository().getATStateAtHeight(atStatesDataList.get(0).getATAddress(), i);
@@ -88,4 +121,102 @@ public class PruneTests extends Common {
         }
     }
 
+    @Test
+    public void testPruneSleepingAt() throws DataException {
+        try (final Repository repository = RepositoryManager.getRepository()) {
+            PrivateKeyAccount deployer = Common.getTestAccount(repository, "chloe");
+            PrivateKeyAccount tradeAccount = Common.getTestAccount(repository, "alice");
+
+            DeployAtTransaction deployAtTransaction = doDeploy(repository, deployer, tradeAccount.getAddress());
+            Account at = deployAtTransaction.getATAccount();
+            String atAddress = at.getAddress();
+
+            // Mint enough blocks to take the original DEPLOY_AT past the prune threshold (in this case 20)
+            Block block = BlockUtils.mintBlocks(repository, 25);
+
+            // Send creator's address to AT, instead of typical partner's address
+            byte[] messageData = LitecoinACCTv3.getInstance().buildCancelMessage(deployer.getAddress());
+            long txTimestamp = block.getBlockData().getTimestamp();
+            MessageTransaction messageTransaction = sendMessage(repository, deployer, messageData, atAddress, txTimestamp);
+
+            // AT should process 'cancel' message in next block
+            BlockUtils.mintBlock(repository);
+
+            // Prune AT states up to block 20
+            repository.getATRepository().rebuildLatestAtStates(20);
+            repository.saveChanges();
+            int numATStatesPruned = repository.getATRepository().pruneAtStates(0, 20);
+            assertEquals(1, numATStatesPruned); // deleted state at heights 2, but state at height 3 remains
+
+            // Check AT is finished
+            ATData atData = repository.getATRepository().fromATAddress(atAddress);
+            assertTrue(atData.getIsFinished());
+
+            // AT should be in CANCELLED mode
+            CrossChainTradeData tradeData = LitecoinACCTv3.getInstance().populateTradeData(repository, atData);
+            assertEquals(AcctMode.CANCELLED, tradeData.mode);
+
+            // Test orphaning - should be possible because the previous AT state at height 3 is still available
+            BlockUtils.orphanLastBlock(repository);
+        }
+    }
+
+
+    // Helper methods for AT testing
+    private DeployAtTransaction doDeploy(Repository repository, PrivateKeyAccount deployer, String tradeAddress) throws DataException {
+        byte[] creationBytes = LitecoinACCTv3.buildQortalAT(tradeAddress, litecoinPublicKeyHash, redeemAmount, litecoinAmount, tradeTimeout);
+
+        long txTimestamp = System.currentTimeMillis();
+        byte[] lastReference = deployer.getLastReference();
+
+        if (lastReference == null) {
+            System.err.println(String.format("Qortal account %s has no last reference", deployer.getAddress()));
+            System.exit(2);
+        }
+
+        Long fee = null;
+        String name = "QORT-LTC cross-chain trade";
+        String description = String.format("Qortal-Litecoin cross-chain trade");
+        String atType = "ACCT";
+        String tags = "QORT-LTC ACCT";
+
+        BaseTransactionData baseTransactionData = new BaseTransactionData(txTimestamp, Group.NO_GROUP, lastReference, deployer.getPublicKey(), fee, null);
+        TransactionData deployAtTransactionData = new DeployAtTransactionData(baseTransactionData, name, description, atType, tags, creationBytes, fundingAmount, Asset.QORT);
+
+        DeployAtTransaction deployAtTransaction = new DeployAtTransaction(repository, deployAtTransactionData);
+
+        fee = deployAtTransaction.calcRecommendedFee();
+        deployAtTransactionData.setFee(fee);
+
+        TransactionUtils.signAndMint(repository, deployAtTransactionData, deployer);
+
+        return deployAtTransaction;
+    }
+
+    private MessageTransaction sendMessage(Repository repository, PrivateKeyAccount sender, byte[] data, String recipient, long txTimestamp) throws DataException {
+        byte[] lastReference = sender.getLastReference();
+
+        if (lastReference == null) {
+            System.err.println(String.format("Qortal account %s has no last reference", sender.getAddress()));
+            System.exit(2);
+        }
+
+        Long fee = null;
+        int version = 4;
+        int nonce = 0;
+        long amount = 0;
+        Long assetId = null; // because amount is zero
+
+        BaseTransactionData baseTransactionData = new BaseTransactionData(txTimestamp, Group.NO_GROUP, lastReference, sender.getPublicKey(), fee, null);
+        TransactionData messageTransactionData = new MessageTransactionData(baseTransactionData, version, nonce, recipient, amount, assetId, data, false, false);
+
+        MessageTransaction messageTransaction = new MessageTransaction(repository, messageTransactionData);
+
+        fee = messageTransaction.calcRecommendedFee();
+        messageTransactionData.setFee(fee);
+
+        TransactionUtils.signAndMint(repository, messageTransactionData, sender);
+
+        return messageTransaction;
+    }
 }

src/test/java/org/qortal/test/at/AtRepositoryTests.java

@@ -2,29 +2,20 @@ package org.qortal.test.at;
 
 import static org.junit.Assert.*;
 
-import java.nio.ByteBuffer;
 import java.util.List;
 
-import org.ciyam.at.CompilationException;
 import org.ciyam.at.MachineState;
-import org.ciyam.at.OpCode;
 import org.junit.Before;
 import org.junit.Test;
 import org.qortal.account.PrivateKeyAccount;
-import org.qortal.asset.Asset;
 import org.qortal.data.at.ATData;
 import org.qortal.data.at.ATStateData;
-import org.qortal.data.transaction.BaseTransactionData;
-import org.qortal.data.transaction.DeployAtTransactionData;
-import org.qortal.data.transaction.TransactionData;
-import org.qortal.group.Group;
 import org.qortal.repository.DataException;
 import org.qortal.repository.Repository;
 import org.qortal.repository.RepositoryManager;
 import org.qortal.test.common.AtUtils;
 import org.qortal.test.common.BlockUtils;
 import org.qortal.test.common.Common;
-import org.qortal.test.common.TransactionUtils;
 import org.qortal.transaction.DeployAtTransaction;
 
 public class AtRepositoryTests extends Common {
@@ -76,7 +67,7 @@ public class AtRepositoryTests extends Common {
 			Integer testHeight = maxHeight - 2;
 
 			// Trim AT state data
-			repository.getATRepository().rebuildLatestAtStates();
+			repository.getATRepository().rebuildLatestAtStates(maxHeight);
 			repository.getATRepository().trimAtStates(2, maxHeight, 1000);
 
 			ATStateData atStateData = repository.getATRepository().getATStateAtHeight(atAddress, testHeight);
@@ -130,7 +121,7 @@ public class AtRepositoryTests extends Common {
 			Integer testHeight = blockchainHeight;
 
 			// Trim AT state data
-			repository.getATRepository().rebuildLatestAtStates();
+			repository.getATRepository().rebuildLatestAtStates(maxHeight);
 			// COMMIT to check latest AT states persist / TEMPORARY table interaction
 			repository.saveChanges();
 
@@ -163,8 +154,8 @@ public class AtRepositoryTests extends Common {
 			int maxTrimHeight = blockchainHeight - 4;
 			Integer testHeight = maxTrimHeight + 1;
 
-			// Trim AT state data
-			repository.getATRepository().rebuildLatestAtStates();
+			// Trim AT state data (using a max height of maxTrimHeight + 1, so it is beyond the trimmed range)
+			repository.getATRepository().rebuildLatestAtStates(maxTrimHeight + 1);
 			repository.saveChanges();
 			repository.getATRepository().trimAtStates(2, maxTrimHeight, 1000);
 
@@ -333,7 +324,7 @@ public class AtRepositoryTests extends Common {
 			Integer testHeight = maxHeight - 2;
 
 			// Trim AT state data
-			repository.getATRepository().rebuildLatestAtStates();
+			repository.getATRepository().rebuildLatestAtStates(maxHeight);
 			repository.getATRepository().trimAtStates(2, maxHeight, 1000);
 
 			List<ATStateData> atStates = repository.getATRepository().getBlockATStatesAtHeight(testHeight);

src/test/java/org/qortal/test/common/BlockUtils.java

@@ -20,6 +20,15 @@ public class BlockUtils {
 		return BlockMinter.mintTestingBlock(repository, mintingAccount);
 	}
 
+	/** Mints multiple blocks using "alice-reward-share" test account, and returns the final block. */
+	public static Block mintBlocks(Repository repository, int count) throws DataException {
+		Block block = null;
+		for (int i=0; i<count; i++) {
+			block = BlockUtils.mintBlock(repository);
+		}
+		return block;
+	}
+
 	public static Long getNextBlockReward(Repository repository) throws DataException {
 		int currentHeight = repository.getBlockRepository().getBlockchainHeight();
 

src/test/java/org/qortal/test/naming/UpdateTests.java

@@ -219,6 +219,65 @@ public class UpdateTests extends Common {
 		}
 	}
 
+	// Test that multiple UPDATE_NAME transactions work as expected, when using a matching name and newName string
+	@Test
+	public void testDoubleUpdateNameWithMatchingNewName() throws DataException {
+		try (final Repository repository = RepositoryManager.getRepository()) {
+			// Register-name
+			PrivateKeyAccount alice = Common.getTestAccount(repository, "alice");
+			String name = "name";
+			String reducedName = "name";
+			String data = "{\"age\":30}";
+
+			TransactionData initialTransactionData = new RegisterNameTransactionData(TestTransaction.generateBase(alice), name, data);
+			initialTransactionData.setFee(new RegisterNameTransaction(null, null).getUnitFee(initialTransactionData.getTimestamp()));
+			TransactionUtils.signAndMint(repository, initialTransactionData, alice);
+
+			// Check name exists
+			assertTrue(repository.getNameRepository().nameExists(name));
+			assertNotNull(repository.getNameRepository().fromReducedName(reducedName));
+
+			// Update name
+			TransactionData middleTransactionData = new UpdateNameTransactionData(TestTransaction.generateBase(alice), name, name, data);
+			TransactionUtils.signAndMint(repository, middleTransactionData, alice);
+
+			// Check name still exists
+			assertTrue(repository.getNameRepository().nameExists(name));
+			assertNotNull(repository.getNameRepository().fromReducedName(reducedName));
+
+			// Update name again
+			TransactionData newestTransactionData = new UpdateNameTransactionData(TestTransaction.generateBase(alice), name, name, data);
+			TransactionUtils.signAndMint(repository, newestTransactionData, alice);
+
+			// Check name still exists
+			assertTrue(repository.getNameRepository().nameExists(name));
+			assertNotNull(repository.getNameRepository().fromReducedName(reducedName));
+
+			// Check updated timestamp is correct
+			assertEquals((Long) newestTransactionData.getTimestamp(), repository.getNameRepository().fromName(name).getUpdated());
+
+			// orphan and recheck
+			BlockUtils.orphanLastBlock(repository);
+
+			// Check name still exists
+			assertTrue(repository.getNameRepository().nameExists(name));
+			assertNotNull(repository.getNameRepository().fromReducedName(reducedName));
+
+			// Check updated timestamp is correct
+			assertEquals((Long) middleTransactionData.getTimestamp(), repository.getNameRepository().fromName(name).getUpdated());
+
+			// orphan and recheck
+			BlockUtils.orphanLastBlock(repository);
+
+			// Check name still exists
+			assertTrue(repository.getNameRepository().nameExists(name));
+			assertNotNull(repository.getNameRepository().fromReducedName(reducedName));
+
+			// Check updated timestamp is empty
+			assertNull(repository.getNameRepository().fromName(name).getUpdated());
+		}
+	}
+
 	// Test that reverting using previous UPDATE_NAME works as expected
 	@Test
 	public void testIntermediateUpdateName() throws DataException {

src/test/resources/test-settings-v2-block-archive.json

@@ -9,5 +9,6 @@
   "testNtpOffset": 0,
   "minPeers": 0,
   "pruneBlockLimit": 100,
-  "repositoryPath": "dbtest"
+  "repositoryPath": "dbtest",
+  "defaultArchiveVersion": 1
 }