Bump version to 4.3.0

consolidated shared functionality into ACCTTests.java

pom.xml

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

src/main/resources/blockchain.json

@@ -29,7 +29,7 @@
 	"onlineAccountSignaturesMaxLifetime": 86400000,
 	"onlineAccountsModulusV2Timestamp": 1659801600000,
 	"selfSponsorshipAlgoV1SnapshotTimestamp": 1670230000000,
-	"mempowTransactionUpdatesTimestamp": 9999999999999,
+	"mempowTransactionUpdatesTimestamp": 1693558800000,
 	"rewardsByHeight": [
 		{ "height": 1, "reward": 5.00 },
 		{ "height": 259201, "reward": 4.75 },

src/test/java/org/qortal/test/crosschain/ACCTTests.java

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

src/test/java/org/qortal/test/crosschain/bitcoinv1/BitcoinACCTv1Tests.java

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

src/test/java/org/qortal/test/crosschain/bitcoinv3/BitcoinACCTv3Tests.java

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

src/test/java/org/qortal/test/crosschain/digibytev3/DigibyteACCTv3Tests.java

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

src/test/java/org/qortal/test/crosschain/dogecoinv3/DogecoinACCTv3Tests.java

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

src/test/java/org/qortal/test/crosschain/litecoinv1/LitecoinACCTv1Tests.java

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

src/test/java/org/qortal/test/crosschain/litecoinv3/LitecoinACCTv3Tests.java

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

src/test/java/org/qortal/test/crosschain/piratechainv3/PirateChainACCTv3Tests.java

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

src/test/java/org/qortal/test/crosschain/ravencoinv3/RavencoinACCTv3Tests.java

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

testnet/testchain.json

@@ -26,6 +26,7 @@
 	"onlineAccountSignaturesMaxLifetime": 86400000,
 	"onlineAccountsModulusV2Timestamp": 0,
 	"selfSponsorshipAlgoV1SnapshotTimestamp": 9999999999999,
+	"mempowTransactionUpdatesTimestamp": 1692554400000,
 	"rewardsByHeight": [
 		{ "height": 1, "reward": 5.00 },
 		{ "height": 259201, "reward": 4.75 },

tools/approve-auto-update.sh

@@ -50,7 +50,7 @@ tx_json=$( cat <<TX_END
 {
   "timestamp": ${timestamp},
   "reference": "${lastref}",
-  "fee": 0.001,
+  "fee": 0.01,
   "txGroupId": 0,
   "adminPublicKey": "${pubkey}",
   "pendingSignature": "${sig}",

tools/approve-dev-transaction.sh

@@ -50,7 +50,7 @@ tx_json=$( cat <<TX_END
 {
   "timestamp": ${timestamp},
   "reference": "${lastref}",
-  "fee": 0.001,
+  "fee": 0.01,
   "txGroupId": 0,
   "adminPublicKey": "${pubkey}",
   "pendingSignature": "${sig}",

tools/publish-auto-update-v5.pl

@@ -1,163 +0,0 @@
-#!/usr/bin/env perl
-
-use strict;
-use warnings;
-use POSIX;
-use Getopt::Std;
-use File::Slurp;
-
-sub usage() {
-	die("usage: $0 [-p api-port] dev-private-key [short-commit-hash]\n");
-}
-
-my %opt;
-getopts('p:', \%opt);
-
-usage() if @ARGV < 1 || @ARGV > 2;
-
-my $port = $opt{p} || 12391;
-my $privkey = shift @ARGV;
-my $commit_hash = shift @ARGV;
-
-my $git_dir = `git rev-parse --show-toplevel`;
-die("Cannot determine git top level dir\n") unless $git_dir;
-
-chomp $git_dir;
-chdir($git_dir) || die("Can't change directory to $git_dir: $!\n");
-
-open(POM, '<', 'pom.xml') || die ("Can't open 'pom.xml': $!\n");
-my $project;
-while (<POM>) {
-	if (m/<artifactId>(\w+)<.artifactId>/o) {
-		$project = $1;
-		last;
-	}
-}
-close(POM);
-
-my $apikey = read_file('apikey.txt');
-
-# Do we need to determine commit hash?
-unless ($commit_hash) {
-	# determine git branch
-	my $branch_name = ` git symbolic-ref -q HEAD `;
-	chomp $branch_name;
-	$branch_name =~ s|^refs/heads/||; # ${branch_name##refs/heads/}
-
-	# short-form commit hash on base branch (non-auto-update)
-	$commit_hash ||= `git show --no-patch --format=%h`;
-	die("Can't find commit hash\n") if ! defined $commit_hash;
-	chomp $commit_hash;
-	printf "Commit hash on '%s' branch: %s\n", $branch_name, $commit_hash;
-} else {
-	printf "Using given commit hash: %s\n", $commit_hash;
-}
-
-# build timestamp / commit timestamp on base branch
-my $timestamp = `git show --no-patch --format=%ct ${commit_hash}`;
-die("Can't determine commit timestamp\n") if ! defined $timestamp;
-$timestamp *= 1000; # Convert to milliseconds
-
-# locate sha256 utility
-my $SHA256 = `which sha256sum || which sha256`;
-chomp $SHA256;
-die("Can't find sha256sum or sha256\n") unless length($SHA256) > 0;
-
-# SHA256 of actual update file
-my $sha256 = `git show auto-update-${commit_hash}:${project}.update | ${SHA256} | head -c 64`;
-die("Can't calculate SHA256 of ${project}.update\n") unless $sha256 =~ m/(\S{64})/;
-chomp $sha256;
-
-# long-form commit hash of HEAD on auto-update branch
-my $update_hash = `git rev-parse refs/heads/auto-update-${commit_hash}`;
-die("Can't find commit hash for HEAD on auto-update-${commit_hash} branch\n") if ! defined $update_hash;
-chomp $update_hash;
-
-printf "Build timestamp (ms): %d / 0x%016x\n", $timestamp, $timestamp;
-printf "Auto-update commit hash: %s\n", $update_hash;
-printf "SHA256 of ${project}.update: %s\n", $sha256;
-
-my $tx_type = 10;
-my $tx_timestamp = time() * 1000;
-my $tx_group_id = 1;
-my $service = 1;
-printf "\nARBITRARY(%d) transaction with timestamp %d, txGroupID %d and service %d\n", $tx_type, $tx_timestamp, $tx_group_id, $service;
-
-my $data_hex = sprintf "%016x%s%s", $timestamp, $update_hash, $sha256;
-printf "\nARBITRARY transaction data payload: %s\n", $data_hex;
-
-my $n_payments = 0;
-my $data_type = 1; # RAW_DATA
-my $data_length = length($data_hex) / 2; # two hex chars per byte
-my $fee = 0;
-my $nonce = 0;
-my $name_length = 0;
-my $identifier_length = 0;
-my $method = 0; # PUT
-my $secret_length = 0;
-my $compression = 0; # None
-my $metadata_hash_length = 0;
-
-die("Something's wrong: data length is not 60 bytes!\n") if $data_length != 60;
-
-my $pubkey = `curl --silent --url http://localhost:${port}/utils/publickey --data ${privkey}`;
-die("Can't convert private key to public key:\n$pubkey\n") unless $pubkey =~ m/^\w{44}$/;
-printf "\nPublic key: %s\n", $pubkey;
-
-my $pubkey_hex = `curl --silent --url http://localhost:${port}/utils/frombase58 --data ${pubkey}`;
-die("Can't convert base58 public key to hex:\n$pubkey_hex\n") unless $pubkey_hex =~ m/^[A-Za-z0-9]{64}$/;
-printf "Public key hex: %s\n", $pubkey_hex;
-
-my $address = `curl --silent --url http://localhost:${port}/addresses/convert/${pubkey}`;
-die("Can't convert base58 public key to address:\n$address\n") unless $address =~ m/^\w{33,34}$/;
-printf "Address: %s\n", $address;
-
-my $reference = `curl --silent --url http://localhost:${port}/addresses/lastreference/${address}`;
-die("Can't fetch last reference for $address:\n$reference\n") unless $reference =~ m/^\w{87,88}$/;
-printf "Last reference: %s\n", $reference;
-
-my $reference_hex = `curl --silent --url http://localhost:${port}/utils/frombase58 --data ${reference}`;
-die("Can't convert base58 reference to hex:\n$reference_hex\n") unless $reference_hex =~ m/^[A-Za-z0-9]{128}$/;
-printf "Last reference hex: %s\n", $reference_hex;
-
-my $raw_tx_hex = sprintf("%08x%016x%08x%s%s%08x%08x%08x%08x%08x%08x%08x%08x%02x%08x%s%08x%08x%016x", $tx_type, $tx_timestamp, $tx_group_id, $reference_hex, $pubkey_hex, $nonce, $name_length, $identifier_length, $method, $secret_length, $compression, $n_payments, $service, $data_type, $data_length, $data_hex, $data_length, $metadata_hash_length, $fee);
-printf "\nRaw transaction hex:\n%s\n", $raw_tx_hex;
-
-my $raw_tx = `curl --silent --url http://localhost:${port}/utils/tobase58/${raw_tx_hex}`;
-die("Can't convert raw transaction hex to base58:\n$raw_tx\n") unless $raw_tx =~ m/^\w{300,320}$/; # Roughly 305 to 320 base58 chars
-printf "\nRaw transaction (base58):\n%s\n", $raw_tx;
-
-my $computed_tx = `curl --silent -X POST --url http://localhost:${port}/arbitrary/compute -H "X-API-KEY: ${apikey}" -d "${raw_tx}"`;
-die("Can't compute nonce for transaction:\n$computed_tx\n") unless $computed_tx =~ m/^\w{300,320}$/; # Roughly 300 to 320 base58 chars
-printf "\nRaw computed transaction (base58):\n%s\n", $computed_tx;
-
-my $sign_data = qq|' { "privateKey": "${privkey}", "transactionBytes": "${computed_tx}" } '|;
-my $signed_tx = `curl --silent -H "accept: text/plain" -H "Content-Type: application/json" --url http://localhost:${port}/transactions/sign --data ${sign_data}`;
-die("Can't sign raw transaction:\n$signed_tx\n") unless $signed_tx =~ m/^\w{390,410}$/; # +90ish longer than $raw_tx
-printf "\nSigned transaction:\n%s\n", $signed_tx;
-
-# Check we can actually fetch update
-my $origin = `git remote get-url origin`;
-die("Unable to get github url for 'origin'?\n") unless $origin && $origin =~ m/:(.*)\.git$/;
-my $repo = $1;
-my $update_url = "https://github.com/${repo}/raw/${update_hash}/${project}.update";
-
-my $fetch_result = `curl --silent -o /dev/null --location --range 0-1 --head --write-out '%{http_code}' --url ${update_url}`;
-die("\nUnable to fetch update from ${update_url}\n") if $fetch_result ne '200';
-printf "\nUpdate fetchable from ${update_url}\n";
-
-# Flush STDOUT after every output
-$| = 1;
-print "\n";
-for (my $delay = 5; $delay > 0; --$delay) {
-	printf "\rSubmitting transaction in %d second%s... CTRL-C to abort ", $delay, ($delay != 1 ? 's' : '');
-	sleep 1;
-}
-
-printf "\rSubmitting transaction NOW...                                    \n";
-my $result = `curl --silent --url http://localhost:${port}/transactions/process --data ${signed_tx}`;
-chomp $result;
-die("Transaction wasn't accepted:\n$result\n") unless $result eq 'true';
-
-my $decoded_tx = `curl --silent -H "Content-Type: application/json" --url http://localhost:${port}/transactions/decode --data ${signed_tx}`;
-printf "\nTransaction accepted:\n$decoded_tx\n";

tools/publish-auto-update.pl

@@ -4,6 +4,7 @@ use strict;
 use warnings;
 use POSIX;
 use Getopt::Std;
+use File::Slurp;
 
 sub usage() {
 	die("usage: $0 [-p api-port] dev-private-key [short-commit-hash]\n");
@@ -34,6 +35,8 @@ while (<POM>) {
 }
 close(POM);
 
+my $apikey = read_file('apikey.txt');
+
 # Do we need to determine commit hash?
 unless ($commit_hash) {
 	# determine git branch
@@ -84,9 +87,16 @@ my $data_hex = sprintf "%016x%s%s", $timestamp, $update_hash, $sha256;
 printf "\nARBITRARY transaction data payload: %s\n", $data_hex;
 
 my $n_payments = 0;
-my $is_raw = 1; # RAW_DATA
+my $data_type = 1; # RAW_DATA
 my $data_length = length($data_hex) / 2; # two hex chars per byte
-my $fee = 0.001 * 1e8;
+my $fee = 0.01 * 1e8;
+my $nonce = 0;
+my $name_length = 0;
+my $identifier_length = 0;
+my $method = 0; # PUT
+my $secret_length = 0;
+my $compression = 0; # None
+my $metadata_hash_length = 0;
 
 die("Something's wrong: data length is not 60 bytes!\n") if $data_length != 60;
 
@@ -110,16 +120,16 @@ my $reference_hex = `curl --silent --url http://localhost:${port}/utils/frombase
 die("Can't convert base58 reference to hex:\n$reference_hex\n") unless $reference_hex =~ m/^[A-Za-z0-9]{128}$/;
 printf "Last reference hex: %s\n", $reference_hex;
 
-my $raw_tx_hex = sprintf("%08x%016x%08x%s%s%08x%08x%02x%08x%s%016x", $tx_type, $tx_timestamp, $tx_group_id, $reference_hex, $pubkey_hex, $n_payments, $service, $is_raw, $data_length, $data_hex, $fee);
+my $raw_tx_hex = sprintf("%08x%016x%08x%s%s%08x%08x%08x%08x%08x%08x%08x%08x%02x%08x%s%08x%08x%016x", $tx_type, $tx_timestamp, $tx_group_id, $reference_hex, $pubkey_hex, $nonce, $name_length, $identifier_length, $method, $secret_length, $compression, $n_payments, $service, $data_type, $data_length, $data_hex, $data_length, $metadata_hash_length, $fee);
 printf "\nRaw transaction hex:\n%s\n", $raw_tx_hex;
 
 my $raw_tx = `curl --silent --url http://localhost:${port}/utils/tobase58/${raw_tx_hex}`;
-die("Can't convert raw transaction hex to base58:\n$raw_tx\n") unless $raw_tx =~ m/^\w{255,265}$/; # Roughly 255 to 265 base58 chars
+die("Can't convert raw transaction hex to base58:\n$raw_tx\n") unless $raw_tx =~ m/^\w{300,320}$/; # Roughly 305 to 320 base58 chars
 printf "\nRaw transaction (base58):\n%s\n", $raw_tx;
 
 my $sign_data = qq|' { "privateKey": "${privkey}", "transactionBytes": "${raw_tx}" } '|;
 my $signed_tx = `curl --silent -H "accept: text/plain" -H "Content-Type: application/json" --url http://localhost:${port}/transactions/sign --data ${sign_data}`;
-die("Can't sign raw transaction:\n$signed_tx\n") unless $signed_tx =~ m/^\w{345,355}$/; # +90ish longer than $raw_tx
+die("Can't sign raw transaction:\n$signed_tx\n") unless $signed_tx =~ m/^\w{390,410}$/; # +90ish longer than $raw_tx
 printf "\nSigned transaction:\n%s\n", $signed_tx;
 
 # Check we can actually fetch update

tools/tx.pl

@@ -40,7 +40,7 @@ our %b58 = map { $b58[$_] => $_ } 0 .. 57;
 our %reverseb58 = reverse %b58;
 
 our $BASE_URL = $ENV{BASE_URL} || ($opt{t} ? 'http://localhost:62391' : 'http://localhost:12391');
-our $DEFAULT_FEE = 0.001;
+our $DEFAULT_FEE = 0.01;
 
 our %TRANSACTION_TYPES = (
 	payment => {
@@ -92,7 +92,7 @@ our %TRANSACTION_TYPES = (
 	},
 	remove_group_admin => {
 		url => 'groups/removeadmin',
-		required => [qw(groupId txGroupId member)],
+		required => [qw(groupId txGroupId admin)],
 		key_name => 'ownerPublicKey',
 	},
 	group_approval => {