true
@@ -11,7 +11,7 @@
0.15.10
1.69
${maven.build.timestamp}
- 1.3.8
+ 1.4.0
3.6
1.8
2.6
diff --git a/src/main/java/org/qortal/account/Account.java b/src/main/java/org/qortal/account/Account.java
index c3a25fb6..2c75dbc0 100644
--- a/src/main/java/org/qortal/account/Account.java
+++ b/src/main/java/org/qortal/account/Account.java
@@ -211,7 +211,8 @@ public class Account {
if (level != null && level >= BlockChain.getInstance().getMinAccountLevelToMint())
return true;
- if (Account.isFounder(accountData.getFlags()))
+ // Founders can always mint, unless they have a penalty
+ if (Account.isFounder(accountData.getFlags()) && accountData.getBlocksMintedPenalty() == 0)
return true;
return false;
@@ -222,6 +223,11 @@ public class Account {
return this.repository.getAccountRepository().getMintedBlockCount(this.address);
}
+ /** Returns account's blockMintedPenalty or null if account not found in repository. */
+ public Integer getBlocksMintedPenalty() throws DataException {
+ return this.repository.getAccountRepository().getBlocksMintedPenaltyCount(this.address);
+ }
+
/** Returns whether account can build reward-shares.
*
@@ -243,7 +249,7 @@ public class Account {
if (level != null && level >= BlockChain.getInstance().getMinAccountLevelToRewardShare())
return true;
- if (Account.isFounder(accountData.getFlags()))
+ if (Account.isFounder(accountData.getFlags()) && accountData.getBlocksMintedPenalty() == 0)
return true;
return false;
@@ -271,7 +277,7 @@ public class Account {
/**
* Returns 'effective' minting level, or zero if account does not exist/cannot mint.
*
- * For founder accounts, this returns "founderEffectiveMintingLevel" from blockchain config.
+ * For founder accounts with no penalty, this returns "founderEffectiveMintingLevel" from blockchain config.
*
* @return 0+
* @throws DataException
@@ -281,7 +287,8 @@ public class Account {
if (accountData == null)
return 0;
- if (Account.isFounder(accountData.getFlags()))
+ // Founders are assigned a different effective minting level, as long as they have no penalty
+ if (Account.isFounder(accountData.getFlags()) && accountData.getBlocksMintedPenalty() == 0)
return BlockChain.getInstance().getFounderEffectiveMintingLevel();
return accountData.getLevel();
@@ -289,8 +296,6 @@ public class Account {
/**
* Returns 'effective' minting level, or zero if reward-share does not exist.
- *
- * this is being used on src/main/java/org/qortal/api/resource/AddressesResource.java to fulfil the online accounts api call
*
* @param repository
* @param rewardSharePublicKey
@@ -309,7 +314,7 @@ public class Account {
/**
* Returns 'effective' minting level, with a fix for the zero level.
*
- * For founder accounts, this returns "founderEffectiveMintingLevel" from blockchain config.
+ * For founder accounts with no penalty, this returns "founderEffectiveMintingLevel" from blockchain config.
*
* @param repository
* @param rewardSharePublicKey
@@ -322,7 +327,7 @@ public class Account {
if (rewardShareData == null)
return 0;
- else if(!rewardShareData.getMinter().equals(rewardShareData.getRecipient()))//the minter is different than the recipient this means sponsorship
+ else if (!rewardShareData.getMinter().equals(rewardShareData.getRecipient())) // Sponsorship reward share
return 0;
Account rewardShareMinter = new Account(repository, rewardShareData.getMinter());
diff --git a/src/main/java/org/qortal/account/SelfSponsorshipAlgoV1.java b/src/main/java/org/qortal/account/SelfSponsorshipAlgoV1.java
new file mode 100644
index 00000000..725e53f5
--- /dev/null
+++ b/src/main/java/org/qortal/account/SelfSponsorshipAlgoV1.java
@@ -0,0 +1,367 @@
+package org.qortal.account;
+
+import org.qortal.api.resource.TransactionsResource;
+import org.qortal.asset.Asset;
+import org.qortal.data.account.AccountData;
+import org.qortal.data.naming.NameData;
+import org.qortal.data.transaction.*;
+import org.qortal.repository.DataException;
+import org.qortal.repository.Repository;
+import org.qortal.transaction.Transaction.TransactionType;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class SelfSponsorshipAlgoV1 {
+
+ private final Repository repository;
+ private final String address;
+ private final AccountData accountData;
+ private final long snapshotTimestamp;
+ private final boolean override;
+
+ private int registeredNameCount = 0;
+ private int suspiciousCount = 0;
+ private int suspiciousPercent = 0;
+ private int consolidationCount = 0;
+ private int bulkIssuanceCount = 0;
+ private int recentSponsorshipCount = 0;
+
+ private List sponsorshipRewardShares = new ArrayList<>();
+ private final Map> paymentsByAddress = new HashMap<>();
+ private final Set sponsees = new LinkedHashSet<>();
+ private Set consolidatedAddresses = new LinkedHashSet<>();
+ private final Set zeroTransactionAddreses = new LinkedHashSet<>();
+ private final Set penaltyAddresses = new LinkedHashSet<>();
+
+ public SelfSponsorshipAlgoV1(Repository repository, String address, long snapshotTimestamp, boolean override) throws DataException {
+ this.repository = repository;
+ this.address = address;
+ this.accountData = this.repository.getAccountRepository().getAccount(this.address);
+ this.snapshotTimestamp = snapshotTimestamp;
+ this.override = override;
+ }
+
+ public String getAddress() {
+ return this.address;
+ }
+
+ public Set getPenaltyAddresses() {
+ return this.penaltyAddresses;
+ }
+
+
+ public void run() throws DataException {
+ if (this.accountData == null) {
+ // Nothing to do
+ return;
+ }
+
+ this.fetchSponsorshipRewardShares();
+ if (this.sponsorshipRewardShares.isEmpty()) {
+ // Nothing to do
+ return;
+ }
+
+ this.findConsolidatedRewards();
+ this.findBulkIssuance();
+ this.findRegisteredNameCount();
+ this.findRecentSponsorshipCount();
+
+ int score = this.calculateScore();
+ if (score <= 0 && !override) {
+ return;
+ }
+
+ String newAddress = this.getDestinationAccount(this.address);
+ while (newAddress != null) {
+ // Found destination account
+ this.penaltyAddresses.add(newAddress);
+
+ // Run algo for this address, but in "override" mode because it has already been flagged
+ SelfSponsorshipAlgoV1 algoV1 = new SelfSponsorshipAlgoV1(this.repository, newAddress, this.snapshotTimestamp, true);
+ algoV1.run();
+ this.penaltyAddresses.addAll(algoV1.getPenaltyAddresses());
+
+ newAddress = this.getDestinationAccount(newAddress);
+ }
+
+ this.penaltyAddresses.add(this.address);
+
+ if (this.override || this.recentSponsorshipCount < 20) {
+ this.penaltyAddresses.addAll(this.consolidatedAddresses);
+ this.penaltyAddresses.addAll(this.zeroTransactionAddreses);
+ }
+ else {
+ this.penaltyAddresses.addAll(this.sponsees);
+ }
+ }
+
+ private String getDestinationAccount(String address) throws DataException {
+ List transferPrivsTransactions = fetchTransferPrivsForAddress(address);
+ if (transferPrivsTransactions.isEmpty()) {
+ // No TRANSFER_PRIVS transactions for this address
+ return null;
+ }
+
+ AccountData accountData = this.repository.getAccountRepository().getAccount(address);
+ if (accountData == null) {
+ return null;
+ }
+
+ for (TransactionData transactionData : transferPrivsTransactions) {
+ TransferPrivsTransactionData transferPrivsTransactionData = (TransferPrivsTransactionData) transactionData;
+ if (Arrays.equals(transferPrivsTransactionData.getSenderPublicKey(), accountData.getPublicKey())) {
+ return transferPrivsTransactionData.getRecipient();
+ }
+ }
+
+ return null;
+ }
+
+ private void findConsolidatedRewards() throws DataException {
+ List sponseesThatSentRewards = new ArrayList<>();
+ Map paymentRecipients = new HashMap<>();
+
+ // Collect outgoing payments of each sponsee
+ for (String sponseeAddress : this.sponsees) {
+
+ // Firstly fetch all payments for address, since the functions below depend on this data
+ this.fetchPaymentsForAddress(sponseeAddress);
+
+ // Check if the address has zero relevant transactions
+ if (this.hasZeroTransactions(sponseeAddress)) {
+ this.zeroTransactionAddreses.add(sponseeAddress);
+ }
+
+ // Get payment recipients
+ List allPaymentRecipients = this.fetchOutgoingPaymentRecipientsForAddress(sponseeAddress);
+ if (allPaymentRecipients.isEmpty()) {
+ continue;
+ }
+ sponseesThatSentRewards.add(sponseeAddress);
+
+ List addressesPaidByThisSponsee = new ArrayList<>();
+ for (String paymentRecipient : allPaymentRecipients) {
+ if (addressesPaidByThisSponsee.contains(paymentRecipient)) {
+ // We already tracked this association - don't allow multiple to stack up
+ continue;
+ }
+ addressesPaidByThisSponsee.add(paymentRecipient);
+
+ // Increment count for this recipient, or initialize to 1 if not present
+ if (paymentRecipients.computeIfPresent(paymentRecipient, (k, v) -> v + 1) == null) {
+ paymentRecipients.put(paymentRecipient, 1);
+ }
+ }
+
+ }
+
+ // Exclude addresses with a low number of payments
+ Map filteredPaymentRecipients = paymentRecipients.entrySet().stream()
+ .filter(p -> p.getValue() != null && p.getValue() >= 10)
+ .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+
+ // Now check how many sponsees have sent to this subset of addresses
+ Map sponseesThatConsolidatedRewards = new HashMap<>();
+ for (String sponseeAddress : sponseesThatSentRewards) {
+ List allPaymentRecipients = this.fetchOutgoingPaymentRecipientsForAddress(sponseeAddress);
+ // Remove any that aren't to one of the flagged recipients (i.e. consolidation)
+ allPaymentRecipients.removeIf(r -> !filteredPaymentRecipients.containsKey(r));
+
+ int count = allPaymentRecipients.size();
+ if (count == 0) {
+ continue;
+ }
+ if (sponseesThatConsolidatedRewards.computeIfPresent(sponseeAddress, (k, v) -> v + count) == null) {
+ sponseesThatConsolidatedRewards.put(sponseeAddress, count);
+ }
+ }
+
+ // Remove sponsees that have only sent a low number of payments to the filtered addresses
+ Map filteredSponseesThatConsolidatedRewards = sponseesThatConsolidatedRewards.entrySet().stream()
+ .filter(p -> p.getValue() != null && p.getValue() >= 2)
+ .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+
+ this.consolidationCount = sponseesThatConsolidatedRewards.size();
+ this.consolidatedAddresses = new LinkedHashSet<>(filteredSponseesThatConsolidatedRewards.keySet());
+ this.suspiciousCount = this.consolidationCount + this.zeroTransactionAddreses.size();
+ this.suspiciousPercent = (int)(this.suspiciousCount / (float) this.sponsees.size() * 100);
+ }
+
+ private void findBulkIssuance() {
+ Long lastTimestamp = null;
+ for (RewardShareTransactionData rewardShareTransactionData : sponsorshipRewardShares) {
+ long timestamp = rewardShareTransactionData.getTimestamp();
+ if (timestamp >= this.snapshotTimestamp) {
+ continue;
+ }
+
+ if (lastTimestamp != null) {
+ if (timestamp - lastTimestamp < 3*60*1000L) {
+ this.bulkIssuanceCount++;
+ }
+ }
+ lastTimestamp = timestamp;
+ }
+ }
+
+ private void findRegisteredNameCount() throws DataException {
+ int registeredNameCount = 0;
+ for (String sponseeAddress : sponsees) {
+ List names = repository.getNameRepository().getNamesByOwner(sponseeAddress);
+ for (NameData name : names) {
+ if (name.getRegistered() < this.snapshotTimestamp) {
+ registeredNameCount++;
+ break;
+ }
+ }
+ }
+ this.registeredNameCount = registeredNameCount;
+ }
+
+ private void findRecentSponsorshipCount() {
+ final long referenceTimestamp = this.snapshotTimestamp - (365 * 24 * 60 * 60 * 1000L);
+ int recentSponsorshipCount = 0;
+ for (RewardShareTransactionData rewardShare : sponsorshipRewardShares) {
+ if (rewardShare.getTimestamp() >= referenceTimestamp) {
+ recentSponsorshipCount++;
+ }
+ }
+ this.recentSponsorshipCount = recentSponsorshipCount;
+ }
+
+ private int calculateScore() {
+ final int suspiciousMultiplier = (this.suspiciousCount >= 100) ? this.suspiciousPercent : 1;
+ final int nameMultiplier = (this.sponsees.size() >= 50 && this.registeredNameCount == 0) ? 2 : 1;
+ final int consolidationMultiplier = Math.max(this.consolidationCount, 1);
+ final int bulkIssuanceMultiplier = Math.max(this.bulkIssuanceCount / 2, 1);
+ final int offset = 9;
+ return suspiciousMultiplier * nameMultiplier * consolidationMultiplier * bulkIssuanceMultiplier - offset;
+ }
+
+ private void fetchSponsorshipRewardShares() throws DataException {
+ List sponsorshipRewardShares = new ArrayList<>();
+
+ // Define relevant transactions
+ List txTypes = List.of(TransactionType.REWARD_SHARE);
+ List transactionDataList = fetchTransactions(repository, txTypes, this.address, false);
+
+ for (TransactionData transactionData : transactionDataList) {
+ if (transactionData.getType() != TransactionType.REWARD_SHARE) {
+ continue;
+ }
+
+ RewardShareTransactionData rewardShareTransactionData = (RewardShareTransactionData) transactionData;
+
+ // Skip removals
+ if (rewardShareTransactionData.getSharePercent() < 0) {
+ continue;
+ }
+
+ // Skip if not sponsored by this account
+ if (!Arrays.equals(rewardShareTransactionData.getCreatorPublicKey(), accountData.getPublicKey())) {
+ continue;
+ }
+
+ // Skip self shares
+ if (Objects.equals(rewardShareTransactionData.getRecipient(), this.address)) {
+ continue;
+ }
+
+ boolean duplicateFound = false;
+ for (RewardShareTransactionData existingRewardShare : sponsorshipRewardShares) {
+ if (Objects.equals(existingRewardShare.getRecipient(), rewardShareTransactionData.getRecipient())) {
+ // Duplicate
+ duplicateFound = true;
+ break;
+ }
+ }
+ if (!duplicateFound) {
+ sponsorshipRewardShares.add(rewardShareTransactionData);
+ this.sponsees.add(rewardShareTransactionData.getRecipient());
+ }
+ }
+
+ this.sponsorshipRewardShares = sponsorshipRewardShares;
+ }
+
+ private List fetchTransferPrivsForAddress(String address) throws DataException {
+ return fetchTransactions(repository,
+ List.of(TransactionType.TRANSFER_PRIVS),
+ address, true);
+ }
+
+ private void fetchPaymentsForAddress(String address) throws DataException {
+ List payments = fetchTransactions(repository,
+ Arrays.asList(TransactionType.PAYMENT, TransactionType.TRANSFER_ASSET),
+ address, false);
+ this.paymentsByAddress.put(address, payments);
+ }
+
+ private List fetchOutgoingPaymentRecipientsForAddress(String address) {
+ List outgoingPaymentRecipients = new ArrayList<>();
+
+ List transactionDataList = this.paymentsByAddress.get(address);
+ if (transactionDataList == null) transactionDataList = new ArrayList<>();
+ transactionDataList.removeIf(t -> t.getTimestamp() >= this.snapshotTimestamp);
+ for (TransactionData transactionData : transactionDataList) {
+ switch (transactionData.getType()) {
+
+ case PAYMENT:
+ PaymentTransactionData paymentTransactionData = (PaymentTransactionData) transactionData;
+ if (!Objects.equals(paymentTransactionData.getRecipient(), address)) {
+ // Outgoing payment from this account
+ outgoingPaymentRecipients.add(paymentTransactionData.getRecipient());
+ }
+ break;
+
+ case TRANSFER_ASSET:
+ TransferAssetTransactionData transferAssetTransactionData = (TransferAssetTransactionData) transactionData;
+ if (transferAssetTransactionData.getAssetId() == Asset.QORT) {
+ if (!Objects.equals(transferAssetTransactionData.getRecipient(), address)) {
+ // Outgoing payment from this account
+ outgoingPaymentRecipients.add(transferAssetTransactionData.getRecipient());
+ }
+ }
+ break;
+
+ default:
+ break;
+ }
+ }
+
+ return outgoingPaymentRecipients;
+ }
+
+ private boolean hasZeroTransactions(String address) {
+ List transactionDataList = this.paymentsByAddress.get(address);
+ if (transactionDataList == null) {
+ return true;
+ }
+ transactionDataList.removeIf(t -> t.getTimestamp() >= this.snapshotTimestamp);
+ return transactionDataList.size() == 0;
+ }
+
+ private static List fetchTransactions(Repository repository, List txTypes, String address, boolean reverse) throws DataException {
+ // Fetch all relevant transactions for this account
+ List signatures = repository.getTransactionRepository()
+ .getSignaturesMatchingCriteria(null, null, null, txTypes,
+ null, null, address, TransactionsResource.ConfirmationStatus.CONFIRMED,
+ null, null, reverse);
+
+ List transactionDataList = new ArrayList<>();
+
+ for (byte[] signature : signatures) {
+ // Fetch transaction data
+ TransactionData transactionData = repository.getTransactionRepository().fromSignature(signature);
+ if (transactionData == null) {
+ continue;
+ }
+ transactionDataList.add(transactionData);
+ }
+
+ return transactionDataList;
+ }
+
+}
diff --git a/src/main/java/org/qortal/api/model/AccountPenaltyStats.java b/src/main/java/org/qortal/api/model/AccountPenaltyStats.java
new file mode 100644
index 00000000..aafe25fc
--- /dev/null
+++ b/src/main/java/org/qortal/api/model/AccountPenaltyStats.java
@@ -0,0 +1,56 @@
+package org.qortal.api.model;
+
+import org.qortal.block.SelfSponsorshipAlgoV1Block;
+import org.qortal.data.account.AccountData;
+import org.qortal.data.naming.NameData;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlElement;
+import java.util.ArrayList;
+import java.util.List;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+public class AccountPenaltyStats {
+
+ public Integer totalPenalties;
+ public Integer maxPenalty;
+ public Integer minPenalty;
+ public String penaltyHash;
+
+ protected AccountPenaltyStats() {
+ }
+
+ public AccountPenaltyStats(Integer totalPenalties, Integer maxPenalty, Integer minPenalty, String penaltyHash) {
+ this.totalPenalties = totalPenalties;
+ this.maxPenalty = maxPenalty;
+ this.minPenalty = minPenalty;
+ this.penaltyHash = penaltyHash;
+ }
+
+ public static AccountPenaltyStats fromAccounts(List accounts) {
+ int totalPenalties = 0;
+ Integer maxPenalty = null;
+ Integer minPenalty = null;
+
+ List addresses = new ArrayList<>();
+ for (AccountData accountData : accounts) {
+ int penalty = accountData.getBlocksMintedPenalty();
+ addresses.add(accountData.getAddress());
+ totalPenalties++;
+
+ // Penalties are expressed as a negative number, so the min and the max are reversed here
+ if (maxPenalty == null || penalty < maxPenalty) maxPenalty = penalty;
+ if (minPenalty == null || penalty > minPenalty) minPenalty = penalty;
+ }
+
+ String penaltyHash = SelfSponsorshipAlgoV1Block.getHash(addresses);
+ return new AccountPenaltyStats(totalPenalties, maxPenalty, minPenalty, penaltyHash);
+ }
+
+
+ @Override
+ public String toString() {
+ return String.format("totalPenalties: %d, maxPenalty: %d, minPenalty: %d, penaltyHash: %s", totalPenalties, maxPenalty, minPenalty, penaltyHash == null ? "null" : penaltyHash);
+ }
+}
diff --git a/src/main/java/org/qortal/api/model/ConnectedPeer.java b/src/main/java/org/qortal/api/model/ConnectedPeer.java
index 3d383321..c4198654 100644
--- a/src/main/java/org/qortal/api/model/ConnectedPeer.java
+++ b/src/main/java/org/qortal/api/model/ConnectedPeer.java
@@ -1,6 +1,7 @@
package org.qortal.api.model;
import io.swagger.v3.oas.annotations.media.Schema;
+import org.qortal.controller.Controller;
import org.qortal.data.block.BlockSummaryData;
import org.qortal.data.network.PeerData;
import org.qortal.network.Handshake;
@@ -36,6 +37,7 @@ public class ConnectedPeer {
public Long lastBlockTimestamp;
public UUID connectionId;
public String age;
+ public Boolean isTooDivergent;
protected ConnectedPeer() {
}
@@ -69,6 +71,11 @@ public class ConnectedPeer {
this.lastBlockSignature = peerChainTipData.getSignature();
this.lastBlockTimestamp = peerChainTipData.getTimestamp();
}
+
+ // Only include isTooDivergent decision if we've had the opportunity to request block summaries this peer
+ if (peer.getLastTooDivergentTime() != null) {
+ this.isTooDivergent = Controller.wasRecentlyTooDivergent.test(peer);
+ }
}
}
diff --git a/src/main/java/org/qortal/api/resource/AddressesResource.java b/src/main/java/org/qortal/api/resource/AddressesResource.java
index 468b90a8..79cb6e05 100644
--- a/src/main/java/org/qortal/api/resource/AddressesResource.java
+++ b/src/main/java/org/qortal/api/resource/AddressesResource.java
@@ -14,6 +14,7 @@ import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
+import java.util.stream.Collectors;
import javax.servlet.http.HttpServletRequest;
import javax.ws.rs.*;
@@ -27,6 +28,7 @@ import org.qortal.api.ApiErrors;
import org.qortal.api.ApiException;
import org.qortal.api.ApiExceptionFactory;
import org.qortal.api.Security;
+import org.qortal.api.model.AccountPenaltyStats;
import org.qortal.api.model.ApiOnlineAccount;
import org.qortal.api.model.RewardShareKeyRequest;
import org.qortal.asset.Asset;
@@ -34,6 +36,7 @@ import org.qortal.controller.LiteNode;
import org.qortal.controller.OnlineAccountsManager;
import org.qortal.crypto.Crypto;
import org.qortal.data.account.AccountData;
+import org.qortal.data.account.AccountPenaltyData;
import org.qortal.data.account.RewardShareData;
import org.qortal.data.network.OnlineAccountData;
import org.qortal.data.network.OnlineAccountLevel;
@@ -471,6 +474,54 @@ public class AddressesResource {
}
}
+ @GET
+ @Path("/penalties")
+ @Operation(
+ summary = "Get addresses with penalties",
+ description = "Returns a list of accounts with a blocksMintedPenalty",
+ responses = {
+ @ApiResponse(
+ description = "accounts with penalties",
+ content = @Content(mediaType = MediaType.APPLICATION_JSON, array = @ArraySchema(schema = @Schema(implementation = AccountPenaltyData.class)))
+ )
+ }
+ )
+ @ApiErrors({ApiError.INVALID_ADDRESS, ApiError.REPOSITORY_ISSUE})
+ public List getAccountsWithPenalties() {
+ try (final Repository repository = RepositoryManager.getRepository()) {
+
+ List accounts = repository.getAccountRepository().getPenaltyAccounts();
+ List penalties = accounts.stream().map(a -> new AccountPenaltyData(a.getAddress(), a.getBlocksMintedPenalty())).collect(Collectors.toList());
+
+ return penalties;
+ } catch (DataException e) {
+ throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.REPOSITORY_ISSUE, e);
+ }
+ }
+
+ @GET
+ @Path("/penalties/stats")
+ @Operation(
+ summary = "Get stats about current penalties",
+ responses = {
+ @ApiResponse(
+ description = "aggregated stats about accounts with penalties",
+ content = @Content(mediaType = MediaType.APPLICATION_JSON, array = @ArraySchema(schema = @Schema(implementation = AccountPenaltyStats.class)))
+ )
+ }
+ )
+ @ApiErrors({ApiError.INVALID_ADDRESS, ApiError.REPOSITORY_ISSUE})
+ public AccountPenaltyStats getPenaltyStats() {
+ try (final Repository repository = RepositoryManager.getRepository()) {
+
+ List accounts = repository.getAccountRepository().getPenaltyAccounts();
+ return AccountPenaltyStats.fromAccounts(accounts);
+
+ } catch (DataException e) {
+ throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.REPOSITORY_ISSUE, e);
+ }
+ }
+
@POST
@Path("/publicize")
@Operation(
diff --git a/src/main/java/org/qortal/api/resource/ArbitraryResource.java b/src/main/java/org/qortal/api/resource/ArbitraryResource.java
index 978183c0..25b968f1 100644
--- a/src/main/java/org/qortal/api/resource/ArbitraryResource.java
+++ b/src/main/java/org/qortal/api/resource/ArbitraryResource.java
@@ -1128,7 +1128,7 @@ public class ArbitraryResource {
if (path == null) {
// See if we have a string instead
if (string != null) {
- File tempFile = File.createTempFile("qortal-", ".tmp");
+ File tempFile = File.createTempFile("qortal-", "");
tempFile.deleteOnExit();
BufferedWriter writer = new BufferedWriter(new FileWriter(tempFile.toPath().toString()));
writer.write(string);
@@ -1138,7 +1138,7 @@ public class ArbitraryResource {
}
// ... or base64 encoded raw data
else if (base64 != null) {
- File tempFile = File.createTempFile("qortal-", ".tmp");
+ File tempFile = File.createTempFile("qortal-", "");
tempFile.deleteOnExit();
Files.write(tempFile.toPath(), Base64.decode(base64));
path = tempFile.toPath().toString();
diff --git a/src/main/java/org/qortal/api/resource/BlocksResource.java b/src/main/java/org/qortal/api/resource/BlocksResource.java
index 195b2ca4..15541802 100644
--- a/src/main/java/org/qortal/api/resource/BlocksResource.java
+++ b/src/main/java/org/qortal/api/resource/BlocksResource.java
@@ -634,13 +634,16 @@ public class BlocksResource {
@ApiErrors({
ApiError.REPOSITORY_ISSUE
})
- public List getBlockRange(@PathParam("height") int height, @Parameter(
- ref = "count"
- ) @QueryParam("count") int count) {
+ public List getBlockRange(@PathParam("height") int height,
+ @Parameter(ref = "count") @QueryParam("count") int count,
+ @Parameter(ref = "reverse") @QueryParam("reverse") Boolean reverse,
+ @QueryParam("includeOnlineSignatures") Boolean includeOnlineSignatures) {
try (final Repository repository = RepositoryManager.getRepository()) {
List blocks = new ArrayList<>();
+ boolean shouldReverse = (reverse != null && reverse == true);
- for (/* count already set */; count > 0; --count, ++height) {
+ int i = 0;
+ while (i < count) {
BlockData blockData = repository.getBlockRepository().fromHeight(height);
if (blockData == null) {
// Not found - try the archive
@@ -650,8 +653,14 @@ public class BlocksResource {
break;
}
}
+ if (includeOnlineSignatures == null || includeOnlineSignatures == false) {
+ blockData.setOnlineAccountsSignatures(null);
+ }
blocks.add(blockData);
+
+ height = shouldReverse ? height - 1 : height + 1;
+ i++;
}
return blocks;
diff --git a/src/main/java/org/qortal/api/resource/ChatResource.java b/src/main/java/org/qortal/api/resource/ChatResource.java
index ee2a8599..2601e938 100644
--- a/src/main/java/org/qortal/api/resource/ChatResource.java
+++ b/src/main/java/org/qortal/api/resource/ChatResource.java
@@ -70,6 +70,8 @@ public class ChatResource {
@QueryParam("txGroupId") Integer txGroupId,
@QueryParam("involving") List involvingAddresses,
@QueryParam("reference") String reference,
+ @QueryParam("chatreference") String chatReference,
+ @QueryParam("haschatreference") Boolean hasChatReference,
@Parameter(ref = "limit") @QueryParam("limit") Integer limit,
@Parameter(ref = "offset") @QueryParam("offset") Integer offset,
@Parameter(ref = "reverse") @QueryParam("reverse") Boolean reverse) {
@@ -92,12 +94,18 @@ public class ChatResource {
if (reference != null)
referenceBytes = Base58.decode(reference);
+ byte[] chatReferenceBytes = null;
+ if (chatReference != null)
+ chatReferenceBytes = Base58.decode(chatReference);
+
try (final Repository repository = RepositoryManager.getRepository()) {
return repository.getChatRepository().getMessagesMatchingCriteria(
before,
after,
txGroupId,
referenceBytes,
+ chatReferenceBytes,
+ hasChatReference,
involvingAddresses,
limit, offset, reverse);
} catch (DataException e) {
diff --git a/src/main/java/org/qortal/api/resource/CrossChainBitcoinResource.java b/src/main/java/org/qortal/api/resource/CrossChainBitcoinResource.java
index 80d19804..dd967451 100644
--- a/src/main/java/org/qortal/api/resource/CrossChainBitcoinResource.java
+++ b/src/main/java/org/qortal/api/resource/CrossChainBitcoinResource.java
@@ -68,7 +68,7 @@ public class CrossChainBitcoinResource {
throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_PRIVATE_KEY);
try {
- Long balance = bitcoin.getWalletBalanceFromTransactions(key58);
+ Long balance = bitcoin.getWalletBalance(key58);
if (balance == null)
throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE);
diff --git a/src/main/java/org/qortal/api/resource/CrossChainDigibyteResource.java b/src/main/java/org/qortal/api/resource/CrossChainDigibyteResource.java
index 57049639..31d51c73 100644
--- a/src/main/java/org/qortal/api/resource/CrossChainDigibyteResource.java
+++ b/src/main/java/org/qortal/api/resource/CrossChainDigibyteResource.java
@@ -68,7 +68,7 @@ public class CrossChainDigibyteResource {
throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_PRIVATE_KEY);
try {
- Long balance = digibyte.getWalletBalanceFromTransactions(key58);
+ Long balance = digibyte.getWalletBalance(key58);
if (balance == null)
throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE);
diff --git a/src/main/java/org/qortal/api/resource/CrossChainDogecoinResource.java b/src/main/java/org/qortal/api/resource/CrossChainDogecoinResource.java
index 189a53d3..28bebfb8 100644
--- a/src/main/java/org/qortal/api/resource/CrossChainDogecoinResource.java
+++ b/src/main/java/org/qortal/api/resource/CrossChainDogecoinResource.java
@@ -66,7 +66,7 @@ public class CrossChainDogecoinResource {
throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_PRIVATE_KEY);
try {
- Long balance = dogecoin.getWalletBalanceFromTransactions(key58);
+ Long balance = dogecoin.getWalletBalance(key58);
if (balance == null)
throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE);
diff --git a/src/main/java/org/qortal/api/resource/CrossChainHtlcResource.java b/src/main/java/org/qortal/api/resource/CrossChainHtlcResource.java
index 664b013a..45b92c7c 100644
--- a/src/main/java/org/qortal/api/resource/CrossChainHtlcResource.java
+++ b/src/main/java/org/qortal/api/resource/CrossChainHtlcResource.java
@@ -8,11 +8,10 @@ import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.security.SecurityRequirement;
import io.swagger.v3.oas.annotations.tags.Tag;
-import java.io.IOException;
import java.math.BigDecimal;
import java.util.List;
import java.util.Objects;
-import java.util.concurrent.locks.ReentrantLock;
+import java.util.stream.Collectors;
import javax.servlet.http.HttpServletRequest;
import javax.ws.rs.*;
@@ -25,7 +24,6 @@ import org.bitcoinj.core.*;
import org.bitcoinj.script.Script;
import org.qortal.api.*;
import org.qortal.api.model.CrossChainBitcoinyHTLCStatus;
-import org.qortal.controller.Controller;
import org.qortal.crosschain.*;
import org.qortal.crypto.Crypto;
import org.qortal.data.at.ATData;
@@ -586,98 +584,103 @@ public class CrossChainHtlcResource {
}
List allTradeBotData = repository.getCrossChainRepository().getAllTradeBotData();
- TradeBotData tradeBotData = allTradeBotData.stream().filter(tradeBotDataItem -> tradeBotDataItem.getAtAddress().equals(atAddress)).findFirst().orElse(null);
- if (tradeBotData == null)
+ List tradeBotDataList = allTradeBotData.stream().filter(tradeBotDataItem -> tradeBotDataItem.getAtAddress().equals(atAddress)).collect(Collectors.toList());
+ if (tradeBotDataList == null || tradeBotDataList.isEmpty())
throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_CRITERIA);
- Bitcoiny bitcoiny = (Bitcoiny) acct.getBlockchain();
- int lockTime = tradeBotData.getLockTimeA();
+ // Loop through all matching entries for this AT address, as there might be more than one
+ for (TradeBotData tradeBotData : tradeBotDataList) {
- // We can't refund P2SH-A until lockTime-A has passed
- if (NTP.getTime() <= lockTime * 1000L)
- throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_TOO_SOON);
+ if (tradeBotData == null)
+ throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_CRITERIA);
- // We can't refund P2SH-A until median block time has passed lockTime-A (see BIP113)
- int medianBlockTime = bitcoiny.getMedianBlockTime();
- if (medianBlockTime <= lockTime)
- throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_TOO_SOON);
+ Bitcoiny bitcoiny = (Bitcoiny) acct.getBlockchain();
+ int lockTime = tradeBotData.getLockTimeA();
- // Fee for redeem/refund is subtracted from P2SH-A balance.
- long feeTimestamp = calcFeeTimestamp(lockTime, crossChainTradeData.tradeTimeout);
- long p2shFee = bitcoiny.getP2shFee(feeTimestamp);
- long minimumAmountA = crossChainTradeData.expectedForeignAmount + p2shFee;
+ // We can't refund P2SH-A until lockTime-A has passed
+ if (NTP.getTime() <= lockTime * 1000L)
+ continue;
- // Create redeem script based on destination chain
- byte[] redeemScriptA;
- String p2shAddressA;
- BitcoinyHTLC.Status htlcStatusA;
- if (Objects.equals(bitcoiny.getCurrencyCode(), "ARRR")) {
- redeemScriptA = PirateChainHTLC.buildScript(tradeBotData.getTradeForeignPublicKey(), lockTime, crossChainTradeData.creatorForeignPKH, tradeBotData.getHashOfSecret());
- p2shAddressA = PirateChain.getInstance().deriveP2shAddressBPrefix(redeemScriptA);
- htlcStatusA = PirateChainHTLC.determineHtlcStatus(bitcoiny.getBlockchainProvider(), p2shAddressA, minimumAmountA);
- }
- else {
- redeemScriptA = BitcoinyHTLC.buildScript(tradeBotData.getTradeForeignPublicKeyHash(), lockTime, crossChainTradeData.creatorForeignPKH, tradeBotData.getHashOfSecret());
- p2shAddressA = bitcoiny.deriveP2shAddress(redeemScriptA);
- htlcStatusA = BitcoinyHTLC.determineHtlcStatus(bitcoiny.getBlockchainProvider(), p2shAddressA, minimumAmountA);
- }
- LOGGER.info(String.format("Refunding P2SH address: %s", p2shAddressA));
+ // We can't refund P2SH-A until median block time has passed lockTime-A (see BIP113)
+ int medianBlockTime = bitcoiny.getMedianBlockTime();
+ if (medianBlockTime <= lockTime)
+ continue;
- switch (htlcStatusA) {
- case UNFUNDED:
- case FUNDING_IN_PROGRESS:
- // Still waiting for P2SH-A to be funded...
- throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_TOO_SOON);
+ // Fee for redeem/refund is subtracted from P2SH-A balance.
+ long feeTimestamp = calcFeeTimestamp(lockTime, crossChainTradeData.tradeTimeout);
+ long p2shFee = bitcoiny.getP2shFee(feeTimestamp);
+ long minimumAmountA = crossChainTradeData.expectedForeignAmount + p2shFee;
- case REDEEM_IN_PROGRESS:
- case REDEEMED:
- case REFUND_IN_PROGRESS:
- case REFUNDED:
- // Too late!
- return false;
+ // Create redeem script based on destination chain
+ byte[] redeemScriptA;
+ String p2shAddressA;
+ BitcoinyHTLC.Status htlcStatusA;
+ if (Objects.equals(bitcoiny.getCurrencyCode(), "ARRR")) {
+ redeemScriptA = PirateChainHTLC.buildScript(tradeBotData.getTradeForeignPublicKey(), lockTime, crossChainTradeData.creatorForeignPKH, tradeBotData.getHashOfSecret());
+ p2shAddressA = PirateChain.getInstance().deriveP2shAddressBPrefix(redeemScriptA);
+ htlcStatusA = PirateChainHTLC.determineHtlcStatus(bitcoiny.getBlockchainProvider(), p2shAddressA, minimumAmountA);
+ } else {
+ redeemScriptA = BitcoinyHTLC.buildScript(tradeBotData.getTradeForeignPublicKeyHash(), lockTime, crossChainTradeData.creatorForeignPKH, tradeBotData.getHashOfSecret());
+ p2shAddressA = bitcoiny.deriveP2shAddress(redeemScriptA);
+ htlcStatusA = BitcoinyHTLC.determineHtlcStatus(bitcoiny.getBlockchainProvider(), p2shAddressA, minimumAmountA);
+ }
+ LOGGER.info(String.format("Refunding P2SH address: %s", p2shAddressA));
- case FUNDED:{
- Coin refundAmount = Coin.valueOf(crossChainTradeData.expectedForeignAmount);
+ switch (htlcStatusA) {
+ case UNFUNDED:
+ case FUNDING_IN_PROGRESS:
+ // Still waiting for P2SH-A to be funded...
+ continue;
- if (Objects.equals(bitcoiny.getCurrencyCode(), "ARRR")) {
- // Pirate Chain custom integration
+ case REDEEM_IN_PROGRESS:
+ case REDEEMED:
+ case REFUND_IN_PROGRESS:
+ case REFUNDED:
+ // Too late!
+ continue;
- PirateChain pirateChain = PirateChain.getInstance();
- String p2shAddressT3 = pirateChain.deriveP2shAddress(redeemScriptA);
+ case FUNDED: {
+ Coin refundAmount = Coin.valueOf(crossChainTradeData.expectedForeignAmount);
- // Get funding txid
- String fundingTxidHex = PirateChainHTLC.getUnspentFundingTxid(pirateChain.getBlockchainProvider(), p2shAddressA, minimumAmountA);
- if (fundingTxidHex == null) {
- throw new ForeignBlockchainException("Missing funding txid when refunding P2SH");
+ if (Objects.equals(bitcoiny.getCurrencyCode(), "ARRR")) {
+ // Pirate Chain custom integration
+
+ PirateChain pirateChain = PirateChain.getInstance();
+ String p2shAddressT3 = pirateChain.deriveP2shAddress(redeemScriptA);
+
+ // Get funding txid
+ String fundingTxidHex = PirateChainHTLC.getUnspentFundingTxid(pirateChain.getBlockchainProvider(), p2shAddressA, minimumAmountA);
+ if (fundingTxidHex == null) {
+ throw new ForeignBlockchainException("Missing funding txid when refunding P2SH");
+ }
+ String fundingTxid58 = Base58.encode(HashCode.fromString(fundingTxidHex).asBytes());
+
+ byte[] privateKey = tradeBotData.getTradePrivateKey();
+ String privateKey58 = Base58.encode(privateKey);
+ String redeemScript58 = Base58.encode(redeemScriptA);
+
+ String txid = PirateChain.getInstance().refundP2sh(p2shAddressT3,
+ receiveAddress, refundAmount.value, redeemScript58, fundingTxid58, lockTime, privateKey58);
+ LOGGER.info("Refund txid: {}", txid);
+ } else {
+ // ElectrumX coins
+
+ ECKey refundKey = ECKey.fromPrivate(tradeBotData.getTradePrivateKey());
+ List fundingOutputs = bitcoiny.getUnspentOutputs(p2shAddressA);
+
+ // Validate the destination foreign blockchain address
+ Address receiving = Address.fromString(bitcoiny.getNetworkParameters(), receiveAddress);
+ if (receiving.getOutputScriptType() != Script.ScriptType.P2PKH)
+ throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_CRITERIA);
+
+ Transaction p2shRefundTransaction = BitcoinyHTLC.buildRefundTransaction(bitcoiny.getNetworkParameters(), refundAmount, refundKey,
+ fundingOutputs, redeemScriptA, lockTime, receiving.getHash());
+
+ bitcoiny.broadcastTransaction(p2shRefundTransaction);
}
- String fundingTxid58 = Base58.encode(HashCode.fromString(fundingTxidHex).asBytes());
- byte[] privateKey = tradeBotData.getTradePrivateKey();
- String privateKey58 = Base58.encode(privateKey);
- String redeemScript58 = Base58.encode(redeemScriptA);
-
- String txid = PirateChain.getInstance().refundP2sh(p2shAddressT3,
- receiveAddress, refundAmount.value, redeemScript58, fundingTxid58, lockTime, privateKey58);
- LOGGER.info("Refund txid: {}", txid);
+ return true;
}
- else {
- // ElectrumX coins
-
- ECKey refundKey = ECKey.fromPrivate(tradeBotData.getTradePrivateKey());
- List fundingOutputs = bitcoiny.getUnspentOutputs(p2shAddressA);
-
- // Validate the destination foreign blockchain address
- Address receiving = Address.fromString(bitcoiny.getNetworkParameters(), receiveAddress);
- if (receiving.getOutputScriptType() != Script.ScriptType.P2PKH)
- throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_CRITERIA);
-
- Transaction p2shRefundTransaction = BitcoinyHTLC.buildRefundTransaction(bitcoiny.getNetworkParameters(), refundAmount, refundKey,
- fundingOutputs, redeemScriptA, lockTime, receiving.getHash());
-
- bitcoiny.broadcastTransaction(p2shRefundTransaction);
- }
-
- return true;
}
}
diff --git a/src/main/java/org/qortal/api/resource/CrossChainLitecoinResource.java b/src/main/java/org/qortal/api/resource/CrossChainLitecoinResource.java
index 8ac0f9a0..d12dd94c 100644
--- a/src/main/java/org/qortal/api/resource/CrossChainLitecoinResource.java
+++ b/src/main/java/org/qortal/api/resource/CrossChainLitecoinResource.java
@@ -68,7 +68,7 @@ public class CrossChainLitecoinResource {
throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_PRIVATE_KEY);
try {
- Long balance = litecoin.getWalletBalanceFromTransactions(key58);
+ Long balance = litecoin.getWalletBalance(key58);
if (balance == null)
throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE);
diff --git a/src/main/java/org/qortal/api/resource/CrossChainRavencoinResource.java b/src/main/java/org/qortal/api/resource/CrossChainRavencoinResource.java
index 756b0bb5..97550392 100644
--- a/src/main/java/org/qortal/api/resource/CrossChainRavencoinResource.java
+++ b/src/main/java/org/qortal/api/resource/CrossChainRavencoinResource.java
@@ -68,7 +68,7 @@ public class CrossChainRavencoinResource {
throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.INVALID_PRIVATE_KEY);
try {
- Long balance = ravencoin.getWalletBalanceFromTransactions(key58);
+ Long balance = ravencoin.getWalletBalance(key58);
if (balance == null)
throw ApiExceptionFactory.INSTANCE.createException(request, ApiError.FOREIGN_BLOCKCHAIN_NETWORK_ISSUE);
diff --git a/src/main/java/org/qortal/api/websocket/ChatMessagesWebSocket.java b/src/main/java/org/qortal/api/websocket/ChatMessagesWebSocket.java
index 9760b7f0..76ed936c 100644
--- a/src/main/java/org/qortal/api/websocket/ChatMessagesWebSocket.java
+++ b/src/main/java/org/qortal/api/websocket/ChatMessagesWebSocket.java
@@ -47,6 +47,8 @@ public class ChatMessagesWebSocket extends ApiWebSocket {
txGroupId,
null,
null,
+ null,
+ null,
null, null, null);
sendMessages(session, chatMessages);
@@ -74,6 +76,8 @@ public class ChatMessagesWebSocket extends ApiWebSocket {
null,
null,
null,
+ null,
+ null,
involvingAddresses,
null, null, null);
diff --git a/src/main/java/org/qortal/arbitrary/ArbitraryDataBuilder.java b/src/main/java/org/qortal/arbitrary/ArbitraryDataBuilder.java
index 4f0e3835..b6b17ea5 100644
--- a/src/main/java/org/qortal/arbitrary/ArbitraryDataBuilder.java
+++ b/src/main/java/org/qortal/arbitrary/ArbitraryDataBuilder.java
@@ -2,6 +2,7 @@ package org.qortal.arbitrary;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
+import org.qortal.arbitrary.exception.DataNotPublishedException;
import org.qortal.arbitrary.exception.MissingDataException;
import org.qortal.arbitrary.metadata.ArbitraryDataMetadataCache;
import org.qortal.arbitrary.misc.Service;
@@ -88,7 +89,7 @@ public class ArbitraryDataBuilder {
if (latestPut == null) {
String message = String.format("Couldn't find PUT transaction for name %s, service %s and identifier %s",
this.name, this.service, this.identifierString());
- throw new DataException(message);
+ throw new DataNotPublishedException(message);
}
this.latestPutTransaction = latestPut;
diff --git a/src/main/java/org/qortal/arbitrary/ArbitraryDataReader.java b/src/main/java/org/qortal/arbitrary/ArbitraryDataReader.java
index 5d4b015c..d1a8b4f5 100644
--- a/src/main/java/org/qortal/arbitrary/ArbitraryDataReader.java
+++ b/src/main/java/org/qortal/arbitrary/ArbitraryDataReader.java
@@ -4,6 +4,7 @@ import org.apache.commons.io.FileUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
+import org.qortal.arbitrary.exception.DataNotPublishedException;
import org.qortal.arbitrary.exception.MissingDataException;
import org.qortal.arbitrary.misc.Service;
import org.qortal.controller.arbitrary.ArbitraryDataBuildManager;
@@ -169,10 +170,18 @@ public class ArbitraryDataReader {
this.uncompress();
this.validate();
+ } catch (DataNotPublishedException e) {
+ if (e.getMessage() != null) {
+ // Log the message only, to avoid spamming the logs with a full stack trace
+ LOGGER.debug("DataNotPublishedException when trying to load QDN resource: {}", e.getMessage());
+ }
+ this.deleteWorkingDirectory();
+ throw e;
+
} catch (DataException e) {
LOGGER.info("DataException when trying to load QDN resource", e);
this.deleteWorkingDirectory();
- throw new DataException(e.getMessage());
+ throw e;
} finally {
this.postExecute();
diff --git a/src/main/java/org/qortal/arbitrary/ArbitraryDataResource.java b/src/main/java/org/qortal/arbitrary/ArbitraryDataResource.java
index 616c9b03..2720e4b2 100644
--- a/src/main/java/org/qortal/arbitrary/ArbitraryDataResource.java
+++ b/src/main/java/org/qortal/arbitrary/ArbitraryDataResource.java
@@ -3,6 +3,7 @@ package org.qortal.arbitrary;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.qortal.arbitrary.ArbitraryDataFile.ResourceIdType;
+import org.qortal.arbitrary.exception.DataNotPublishedException;
import org.qortal.arbitrary.metadata.ArbitraryDataTransactionMetadata;
import org.qortal.arbitrary.misc.Service;
import org.qortal.controller.arbitrary.ArbitraryDataBuildManager;
@@ -325,7 +326,7 @@ public class ArbitraryDataResource {
if (latestPut == null) {
String message = String.format("Couldn't find PUT transaction for name %s, service %s and identifier %s",
this.resourceId, this.service, this.identifierString());
- throw new DataException(message);
+ throw new DataNotPublishedException(message);
}
this.latestPutTransaction = latestPut;
diff --git a/src/main/java/org/qortal/arbitrary/exception/DataNotPublishedException.java b/src/main/java/org/qortal/arbitrary/exception/DataNotPublishedException.java
new file mode 100644
index 00000000..4782826b
--- /dev/null
+++ b/src/main/java/org/qortal/arbitrary/exception/DataNotPublishedException.java
@@ -0,0 +1,22 @@
+package org.qortal.arbitrary.exception;
+
+import org.qortal.repository.DataException;
+
+public class DataNotPublishedException extends DataException {
+
+ public DataNotPublishedException() {
+ }
+
+ public DataNotPublishedException(String message) {
+ super(message);
+ }
+
+ public DataNotPublishedException(String message, Throwable cause) {
+ super(message, cause);
+ }
+
+ public DataNotPublishedException(Throwable cause) {
+ super(cause);
+ }
+
+}
diff --git a/src/main/java/org/qortal/arbitrary/misc/Service.java b/src/main/java/org/qortal/arbitrary/misc/Service.java
index 5dd8d94e..01419d2f 100644
--- a/src/main/java/org/qortal/arbitrary/misc/Service.java
+++ b/src/main/java/org/qortal/arbitrary/misc/Service.java
@@ -10,9 +10,7 @@ import java.io.File;
import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
+import java.util.*;
import static java.util.Arrays.stream;
import static java.util.stream.Collectors.toMap;
@@ -20,9 +18,52 @@ import static java.util.stream.Collectors.toMap;
public enum Service {
AUTO_UPDATE(1, false, null, null),
ARBITRARY_DATA(100, false, null, null),
+ QCHAT_ATTACHMENT(120, true, 1024*1024L, null) {
+ @Override
+ public ValidationResult validate(Path path) throws IOException {
+ ValidationResult superclassResult = super.validate(path);
+ if (superclassResult != ValidationResult.OK) {
+ return superclassResult;
+ }
+
+ // Custom validation function to require a single file, with a whitelisted extension
+ int fileCount = 0;
+ File[] files = path.toFile().listFiles();
+ // If already a single file, replace the list with one that contains that file only
+ if (files == null && path.toFile().isFile()) {
+ files = new File[] { path.toFile() };
+ }
+ if (files != null) {
+ for (File file : files) {
+ if (file.getName().equals(".qortal")) {
+ continue;
+ }
+ if (file.isDirectory()) {
+ return ValidationResult.DIRECTORIES_NOT_ALLOWED;
+ }
+ final String extension = FilenameUtils.getExtension(file.getName()).toLowerCase();
+ // We must allow blank file extensions because these are used by data published from a plaintext or base64-encoded string
+ final List allowedExtensions = Arrays.asList("zip", "pdf", "txt", "odt", "ods", "doc", "docx", "xls", "xlsx", "ppt", "pptx", "");
+ if (extension == null || !allowedExtensions.contains(extension)) {
+ return ValidationResult.INVALID_FILE_EXTENSION;
+ }
+ fileCount++;
+ }
+ }
+ if (fileCount != 1) {
+ return ValidationResult.INVALID_FILE_COUNT;
+ }
+ return ValidationResult.OK;
+ }
+ },
WEBSITE(200, true, null, null) {
@Override
- public ValidationResult validate(Path path) {
+ public ValidationResult validate(Path path) throws IOException {
+ ValidationResult superclassResult = super.validate(path);
+ if (superclassResult != ValidationResult.OK) {
+ return superclassResult;
+ }
+
// Custom validation function to require an index HTML file in the root directory
List fileNames = ArbitraryDataRenderer.indexFiles();
String[] files = path.toFile().list();
@@ -53,12 +94,24 @@ public enum Service {
METADATA(1100, false, null, null),
GIF_REPOSITORY(1200, true, 25*1024*1024L, null) {
@Override
- public ValidationResult validate(Path path) {
+ public ValidationResult validate(Path path) throws IOException {
+ ValidationResult superclassResult = super.validate(path);
+ if (superclassResult != ValidationResult.OK) {
+ return superclassResult;
+ }
+
// Custom validation function to require .gif files only, and at least 1
int gifCount = 0;
File[] files = path.toFile().listFiles();
+ // If already a single file, replace the list with one that contains that file only
+ if (files == null && path.toFile().isFile()) {
+ files = new File[] { path.toFile() };
+ }
if (files != null) {
for (File file : files) {
+ if (file.getName().equals(".qortal")) {
+ continue;
+ }
if (file.isDirectory()) {
return ValidationResult.DIRECTORIES_NOT_ALLOWED;
}
@@ -143,7 +196,8 @@ public enum Service {
MISSING_INDEX_FILE(4),
DIRECTORIES_NOT_ALLOWED(5),
INVALID_FILE_EXTENSION(6),
- MISSING_DATA(7);
+ MISSING_DATA(7),
+ INVALID_FILE_COUNT(8);
public final int value;
diff --git a/src/main/java/org/qortal/block/Block.java b/src/main/java/org/qortal/block/Block.java
index 5e838458..3f306b93 100644
--- a/src/main/java/org/qortal/block/Block.java
+++ b/src/main/java/org/qortal/block/Block.java
@@ -136,7 +136,7 @@ public class Block {
}
/** Lazy-instantiated expanded info on block's online accounts. */
- private static class ExpandedAccount {
+ public static class ExpandedAccount {
private final RewardShareData rewardShareData;
private final int sharePercent;
private final boolean isRecipientAlsoMinter;
@@ -169,6 +169,13 @@ public class Block {
}
}
+ public Account getMintingAccount() {
+ return this.mintingAccount;
+ }
+ public Account getRecipientAccount() {
+ return this.recipientAccount;
+ }
+
/**
* Returns share bin for expanded account.
*
@@ -363,12 +370,26 @@ public class Block {
return null;
}
+ int height = parentBlockData.getHeight() + 1;
long timestamp = calcTimestamp(parentBlockData, minter.getPublicKey(), minterLevel);
long onlineAccountsTimestamp = OnlineAccountsManager.getCurrentOnlineAccountTimestamp();
// Fetch our list of online accounts, removing any that are missing a nonce
List onlineAccounts = OnlineAccountsManager.getInstance().getOnlineAccounts(onlineAccountsTimestamp);
onlineAccounts.removeIf(a -> a.getNonce() == null || a.getNonce() < 0);
+
+ // After feature trigger, remove any online accounts that are level 0
+ if (height >= BlockChain.getInstance().getOnlineAccountMinterLevelValidationHeight()) {
+ onlineAccounts.removeIf(a -> {
+ try {
+ return Account.getRewardShareEffectiveMintingLevel(repository, a.getPublicKey()) == 0;
+ } catch (DataException e) {
+ // Something went wrong, so remove the account
+ return true;
+ }
+ });
+ }
+
if (onlineAccounts.isEmpty()) {
LOGGER.debug("No online accounts - not even our own?");
return null;
@@ -435,7 +456,6 @@ public class Block {
int transactionCount = 0;
byte[] transactionsSignature = null;
- int height = parentBlockData.getHeight() + 1;
int atCount = 0;
long atFees = 0;
@@ -1029,6 +1049,15 @@ public class Block {
if (onlineRewardShares == null)
return ValidationResult.ONLINE_ACCOUNT_UNKNOWN;
+ // After feature trigger, require all online account minters to be greater than level 0
+ if (this.getBlockData().getHeight() >= BlockChain.getInstance().getOnlineAccountMinterLevelValidationHeight()) {
+ List expandedAccounts = this.getExpandedAccounts();
+ for (ExpandedAccount account : expandedAccounts) {
+ if (account.getMintingAccount().getEffectiveMintingLevel() == 0)
+ return ValidationResult.ONLINE_ACCOUNTS_INVALID;
+ }
+ }
+
// If block is past a certain age then we simply assume the signatures were correct
long signatureRequirementThreshold = NTP.getTime() - BlockChain.getInstance().getOnlineAccountSignaturesMinLifetime();
if (this.blockData.getTimestamp() < signatureRequirementThreshold)
@@ -1434,6 +1463,9 @@ public class Block {
if (this.blockData.getHeight() == 212937)
// Apply fix for block 212937
Block212937.processFix(this);
+
+ else if (this.blockData.getHeight() == BlockChain.getInstance().getSelfSponsorshipAlgoV1Height())
+ SelfSponsorshipAlgoV1Block.processAccountPenalties(this);
}
// We're about to (test-)process a batch of transactions,
@@ -1490,19 +1522,23 @@ public class Block {
// Batch update in repository
repository.getAccountRepository().modifyMintedBlockCounts(allUniqueExpandedAccounts.stream().map(AccountData::getAddress).collect(Collectors.toList()), +1);
+ // Keep track of level bumps in case we need to apply to other entries
+ Map bumpedAccounts = new HashMap<>();
+
// Local changes and also checks for level bump
for (AccountData accountData : allUniqueExpandedAccounts) {
// Adjust count locally (in Java)
accountData.setBlocksMinted(accountData.getBlocksMinted() + 1);
LOGGER.trace(() -> String.format("Block minter %s up to %d minted block%s", accountData.getAddress(), accountData.getBlocksMinted(), (accountData.getBlocksMinted() != 1 ? "s" : "")));
- final int effectiveBlocksMinted = accountData.getBlocksMinted() + accountData.getBlocksMintedAdjustment();
+ final int effectiveBlocksMinted = accountData.getBlocksMinted() + accountData.getBlocksMintedAdjustment() + accountData.getBlocksMintedPenalty();
for (int newLevel = maximumLevel; newLevel >= 0; --newLevel)
if (effectiveBlocksMinted >= cumulativeBlocksByLevel.get(newLevel)) {
if (newLevel > accountData.getLevel()) {
// Account has increased in level!
accountData.setLevel(newLevel);
+ bumpedAccounts.put(accountData.getAddress(), newLevel);
repository.getAccountRepository().setLevel(accountData);
LOGGER.trace(() -> String.format("Block minter %s bumped to level %d", accountData.getAddress(), accountData.getLevel()));
}
@@ -1510,6 +1546,25 @@ public class Block {
break;
}
}
+
+ // Also bump other entries if need be
+ if (!bumpedAccounts.isEmpty()) {
+ for (ExpandedAccount expandedAccount : expandedAccounts) {
+ Integer newLevel = bumpedAccounts.get(expandedAccount.mintingAccountData.getAddress());
+ if (newLevel != null && expandedAccount.mintingAccountData.getLevel() != newLevel) {
+ expandedAccount.mintingAccountData.setLevel(newLevel);
+ LOGGER.trace("Also bumped {} to level {}", expandedAccount.mintingAccountData.getAddress(), newLevel);
+ }
+
+ if (!expandedAccount.isRecipientAlsoMinter) {
+ newLevel = bumpedAccounts.get(expandedAccount.recipientAccountData.getAddress());
+ if (newLevel != null && expandedAccount.recipientAccountData.getLevel() != newLevel) {
+ expandedAccount.recipientAccountData.setLevel(newLevel);
+ LOGGER.trace("Also bumped {} to level {}", expandedAccount.recipientAccountData.getAddress(), newLevel);
+ }
+ }
+ }
+ }
}
protected void processBlockRewards() throws DataException {
@@ -1669,6 +1724,9 @@ public class Block {
// Revert fix for block 212937
Block212937.orphanFix(this);
+ else if (this.blockData.getHeight() == BlockChain.getInstance().getSelfSponsorshipAlgoV1Height())
+ SelfSponsorshipAlgoV1Block.orphanAccountPenalties(this);
+
// Block rewards, including transaction fees, removed after transactions undone
orphanBlockRewards();
@@ -1797,7 +1855,7 @@ public class Block {
accountData.setBlocksMinted(accountData.getBlocksMinted() - 1);
LOGGER.trace(() -> String.format("Block minter %s down to %d minted block%s", accountData.getAddress(), accountData.getBlocksMinted(), (accountData.getBlocksMinted() != 1 ? "s" : "")));
- final int effectiveBlocksMinted = accountData.getBlocksMinted() + accountData.getBlocksMintedAdjustment();
+ final int effectiveBlocksMinted = accountData.getBlocksMinted() + accountData.getBlocksMintedAdjustment() + accountData.getBlocksMintedPenalty();
for (int newLevel = maximumLevel; newLevel >= 0; --newLevel)
if (effectiveBlocksMinted >= cumulativeBlocksByLevel.get(newLevel)) {
diff --git a/src/main/java/org/qortal/block/BlockChain.java b/src/main/java/org/qortal/block/BlockChain.java
index 5e1f44f3..b96350e6 100644
--- a/src/main/java/org/qortal/block/BlockChain.java
+++ b/src/main/java/org/qortal/block/BlockChain.java
@@ -74,7 +74,11 @@ public class BlockChain {
transactionV5Timestamp,
transactionV6Timestamp,
disableReferenceTimestamp,
- increaseOnlineAccountsDifficultyTimestamp;
+ increaseOnlineAccountsDifficultyTimestamp,
+ onlineAccountMinterLevelValidationHeight,
+ selfSponsorshipAlgoV1Height,
+ feeValidationFixTimestamp,
+ chatReferenceTimestamp;
}
// Custom transaction fees
@@ -96,6 +100,13 @@ public class BlockChain {
/** Whether only one registered name is allowed per account. */
private boolean oneNamePerAccount = false;
+ /** Checkpoints */
+ public static class Checkpoint {
+ public int height;
+ public String signature;
+ }
+ private List checkpoints;
+
/** Block rewards by block height */
public static class RewardByHeight {
public int height;
@@ -196,6 +207,9 @@ public class BlockChain {
* featureTriggers because unit tests need to set this value via Reflection. */
private long onlineAccountsModulusV2Timestamp;
+ /** Snapshot timestamp for self sponsorship algo V1 */
+ private long selfSponsorshipAlgoV1SnapshotTimestamp;
+
/** Max reward shares by block height */
public static class MaxRewardSharesByTimestamp {
public long timestamp;
@@ -356,6 +370,11 @@ public class BlockChain {
return this.onlineAccountsModulusV2Timestamp;
}
+ // Self sponsorship algo
+ public long getSelfSponsorshipAlgoV1SnapshotTimestamp() {
+ return this.selfSponsorshipAlgoV1SnapshotTimestamp;
+ }
+
/** Returns true if approval-needing transaction types require a txGroupId other than NO_GROUP. */
public boolean getRequireGroupForApproval() {
return this.requireGroupForApproval;
@@ -369,6 +388,10 @@ public class BlockChain {
return this.oneNamePerAccount;
}
+ public List getCheckpoints() {
+ return this.checkpoints;
+ }
+
public List getBlockRewardsByHeight() {
return this.rewardsByHeight;
}
@@ -483,6 +506,22 @@ public class BlockChain {
return this.featureTriggers.get(FeatureTrigger.increaseOnlineAccountsDifficultyTimestamp.name()).longValue();
}
+ public int getSelfSponsorshipAlgoV1Height() {
+ return this.featureTriggers.get(FeatureTrigger.selfSponsorshipAlgoV1Height.name()).intValue();
+ }
+
+ public long getOnlineAccountMinterLevelValidationHeight() {
+ return this.featureTriggers.get(FeatureTrigger.onlineAccountMinterLevelValidationHeight.name()).intValue();
+ }
+
+ public long getFeeValidationFixTimestamp() {
+ return this.featureTriggers.get(FeatureTrigger.feeValidationFixTimestamp.name()).longValue();
+ }
+
+ public long getChatReferenceTimestamp() {
+ return this.featureTriggers.get(FeatureTrigger.chatReferenceTimestamp.name()).longValue();
+ }
+
// More complex getters for aspects that change by height or timestamp
@@ -651,6 +690,7 @@ public class BlockChain {
boolean isTopOnly = Settings.getInstance().isTopOnly();
boolean archiveEnabled = Settings.getInstance().isArchiveEnabled();
+ boolean isLite = Settings.getInstance().isLite();
boolean canBootstrap = Settings.getInstance().getBootstrap();
boolean needsArchiveRebuild = false;
BlockData chainTip;
@@ -671,22 +711,44 @@ public class BlockChain {
}
}
}
+
+ // Validate checkpoints
+ // Limited to topOnly nodes for now, in order to reduce risk, and to solve a real-world problem with divergent topOnly nodes
+ // TODO: remove the isTopOnly conditional below once this feature has had more testing time
+ if (isTopOnly && !isLite) {
+ List checkpoints = BlockChain.getInstance().getCheckpoints();
+ for (Checkpoint checkpoint : checkpoints) {
+ BlockData blockData = repository.getBlockRepository().fromHeight(checkpoint.height);
+ if (blockData == null) {
+ // Try the archive
+ blockData = repository.getBlockArchiveRepository().fromHeight(checkpoint.height);
+ }
+ if (blockData == null) {
+ LOGGER.trace("Couldn't find block for height {}", checkpoint.height);
+ // This is likely due to the block being pruned, so is safe to ignore.
+ // Continue, as there might be other blocks we can check more definitively.
+ continue;
+ }
+
+ byte[] signature = Base58.decode(checkpoint.signature);
+ if (!Arrays.equals(signature, blockData.getSignature())) {
+ LOGGER.info("Error: block at height {} with signature {} doesn't match checkpoint sig: {}. Bootstrapping...", checkpoint.height, Base58.encode(blockData.getSignature()), checkpoint.signature);
+ needsArchiveRebuild = true;
+ break;
+ }
+ LOGGER.info("Block at height {} matches checkpoint signature", blockData.getHeight());
+ }
+ }
+
}
- boolean hasBlocks = (chainTip != null && chainTip.getHeight() > 1);
+ // Check first block is Genesis Block
+ if (!isGenesisBlockValid() || needsArchiveRebuild) {
+ try {
+ rebuildBlockchain();
- if (isTopOnly && hasBlocks) {
- // Top-only mode is enabled and we have blocks, so it's possible that the genesis block has been pruned
- // It's best not to validate it, and there's no real need to
- } else {
- // Check first block is Genesis Block
- if (!isGenesisBlockValid() || needsArchiveRebuild) {
- try {
- rebuildBlockchain();
-
- } catch (InterruptedException e) {
- throw new DataException(String.format("Interrupted when trying to rebuild blockchain: %s", e.getMessage()));
- }
+ } catch (InterruptedException e) {
+ throw new DataException(String.format("Interrupted when trying to rebuild blockchain: %s", e.getMessage()));
}
}
@@ -695,9 +757,7 @@ public class BlockChain {
try (final Repository repository = RepositoryManager.getRepository()) {
repository.checkConsistency();
- // Set the number of blocks to validate based on the pruned state of the chain
- // If pruned, subtract an extra 10 to allow room for error
- int blocksToValidate = (isTopOnly || archiveEnabled) ? Settings.getInstance().getPruneBlockLimit() - 10 : 1440;
+ int blocksToValidate = Math.min(Settings.getInstance().getPruneBlockLimit() - 10, 1440);
int startHeight = Math.max(repository.getBlockRepository().getBlockchainHeight() - blocksToValidate, 1);
BlockData detachedBlockData = repository.getBlockRepository().getDetachedBlockSignature(startHeight);
diff --git a/src/main/java/org/qortal/block/SelfSponsorshipAlgoV1Block.java b/src/main/java/org/qortal/block/SelfSponsorshipAlgoV1Block.java
new file mode 100644
index 00000000..a9a016b6
--- /dev/null
+++ b/src/main/java/org/qortal/block/SelfSponsorshipAlgoV1Block.java
@@ -0,0 +1,133 @@
+package org.qortal.block;
+
+import org.apache.commons.lang3.StringUtils;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.qortal.account.SelfSponsorshipAlgoV1;
+import org.qortal.api.model.AccountPenaltyStats;
+import org.qortal.crypto.Crypto;
+import org.qortal.data.account.AccountData;
+import org.qortal.data.account.AccountPenaltyData;
+import org.qortal.repository.DataException;
+import org.qortal.repository.Repository;
+import org.qortal.utils.Base58;
+
+import java.nio.charset.StandardCharsets;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * Self Sponsorship AlgoV1 Block
+ *
+ * Selected block for the initial run on the "self sponsorship detection algorithm"
+ */
+public final class SelfSponsorshipAlgoV1Block {
+
+ private static final Logger LOGGER = LogManager.getLogger(SelfSponsorshipAlgoV1Block.class);
+
+
+ private SelfSponsorshipAlgoV1Block() {
+ /* Do not instantiate */
+ }
+
+ public static void processAccountPenalties(Block block) throws DataException {
+ LOGGER.info("Running algo for block processing - this will take a while...");
+ logPenaltyStats(block.repository);
+ long startTime = System.currentTimeMillis();
+ Set penalties = getAccountPenalties(block.repository, -5000000);
+ block.repository.getAccountRepository().updateBlocksMintedPenalties(penalties);
+ long totalTime = System.currentTimeMillis() - startTime;
+ String hash = getHash(penalties.stream().map(p -> p.getAddress()).collect(Collectors.toList()));
+ LOGGER.info("{} penalty addresses processed (hash: {}). Total time taken: {} seconds", penalties.size(), hash, (int)(totalTime / 1000.0f));
+ logPenaltyStats(block.repository);
+
+ int updatedCount = updateAccountLevels(block.repository, penalties);
+ LOGGER.info("Account levels updated for {} penalty addresses", updatedCount);
+ }
+
+ public static void orphanAccountPenalties(Block block) throws DataException {
+ LOGGER.info("Running algo for block orphaning - this will take a while...");
+ logPenaltyStats(block.repository);
+ long startTime = System.currentTimeMillis();
+ Set penalties = getAccountPenalties(block.repository, 5000000);
+ block.repository.getAccountRepository().updateBlocksMintedPenalties(penalties);
+ long totalTime = System.currentTimeMillis() - startTime;
+ String hash = getHash(penalties.stream().map(p -> p.getAddress()).collect(Collectors.toList()));
+ LOGGER.info("{} penalty addresses orphaned (hash: {}). Total time taken: {} seconds", penalties.size(), hash, (int)(totalTime / 1000.0f));
+ logPenaltyStats(block.repository);
+
+ int updatedCount = updateAccountLevels(block.repository, penalties);
+ LOGGER.info("Account levels updated for {} penalty addresses", updatedCount);
+ }
+
+ public static Set getAccountPenalties(Repository repository, int penalty) throws DataException {
+ final long snapshotTimestamp = BlockChain.getInstance().getSelfSponsorshipAlgoV1SnapshotTimestamp();
+ Set penalties = new LinkedHashSet<>();
+ List addresses = repository.getTransactionRepository().getConfirmedRewardShareCreatorsExcludingSelfShares();
+ for (String address : addresses) {
+ //System.out.println(String.format("address: %s", address));
+ SelfSponsorshipAlgoV1 selfSponsorshipAlgoV1 = new SelfSponsorshipAlgoV1(repository, address, snapshotTimestamp, false);
+ selfSponsorshipAlgoV1.run();
+ //System.out.println(String.format("Penalty addresses: %d", selfSponsorshipAlgoV1.getPenaltyAddresses().size()));
+
+ for (String penaltyAddress : selfSponsorshipAlgoV1.getPenaltyAddresses()) {
+ penalties.add(new AccountPenaltyData(penaltyAddress, penalty));
+ }
+ }
+ return penalties;
+ }
+
+ private static int updateAccountLevels(Repository repository, Set accountPenalties) throws DataException {
+ final List cumulativeBlocksByLevel = BlockChain.getInstance().getCumulativeBlocksByLevel();
+ final int maximumLevel = cumulativeBlocksByLevel.size() - 1;
+
+ int updatedCount = 0;
+
+ for (AccountPenaltyData penaltyData : accountPenalties) {
+ AccountData accountData = repository.getAccountRepository().getAccount(penaltyData.getAddress());
+ final int effectiveBlocksMinted = accountData.getBlocksMinted() + accountData.getBlocksMintedAdjustment() + accountData.getBlocksMintedPenalty();
+
+ // Shortcut for penalties
+ if (effectiveBlocksMinted < 0) {
+ accountData.setLevel(0);
+ repository.getAccountRepository().setLevel(accountData);
+ updatedCount++;
+ LOGGER.trace(() -> String.format("Block minter %s dropped to level %d", accountData.getAddress(), accountData.getLevel()));
+ continue;
+ }
+
+ for (int newLevel = maximumLevel; newLevel >= 0; --newLevel) {
+ if (effectiveBlocksMinted >= cumulativeBlocksByLevel.get(newLevel)) {
+ accountData.setLevel(newLevel);
+ repository.getAccountRepository().setLevel(accountData);
+ updatedCount++;
+ LOGGER.trace(() -> String.format("Block minter %s increased to level %d", accountData.getAddress(), accountData.getLevel()));
+ break;
+ }
+ }
+ }
+
+ return updatedCount;
+ }
+
+ private static void logPenaltyStats(Repository repository) {
+ try {
+ LOGGER.info(getPenaltyStats(repository));
+
+ } catch (DataException e) {}
+ }
+
+ private static AccountPenaltyStats getPenaltyStats(Repository repository) throws DataException {
+ List accounts = repository.getAccountRepository().getPenaltyAccounts();
+ return AccountPenaltyStats.fromAccounts(accounts);
+ }
+
+ public static String getHash(List penaltyAddresses) {
+ if (penaltyAddresses == null || penaltyAddresses.isEmpty()) {
+ return null;
+ }
+ Collections.sort(penaltyAddresses);
+ return Base58.encode(Crypto.digest(StringUtils.join(penaltyAddresses).getBytes(StandardCharsets.UTF_8)));
+ }
+
+}
diff --git a/src/main/java/org/qortal/controller/BlockMinter.java b/src/main/java/org/qortal/controller/BlockMinter.java
index 7e3b4b9e..185dd7cd 100644
--- a/src/main/java/org/qortal/controller/BlockMinter.java
+++ b/src/main/java/org/qortal/controller/BlockMinter.java
@@ -26,9 +26,6 @@ import org.qortal.data.block.CommonBlockData;
import org.qortal.data.transaction.TransactionData;
import org.qortal.network.Network;
import org.qortal.network.Peer;
-import org.qortal.network.message.BlockSummariesV2Message;
-import org.qortal.network.message.HeightV2Message;
-import org.qortal.network.message.Message;
import org.qortal.repository.BlockRepository;
import org.qortal.repository.DataException;
import org.qortal.repository.Repository;
@@ -38,6 +35,8 @@ import org.qortal.transaction.Transaction;
import org.qortal.utils.Base58;
import org.qortal.utils.NTP;
+import static org.junit.Assert.assertNotNull;
+
// Minting new blocks
public class BlockMinter extends Thread {
@@ -64,8 +63,8 @@ public class BlockMinter extends Thread {
public void run() {
Thread.currentThread().setName("BlockMinter");
- if (Settings.getInstance().isLite()) {
- // Lite nodes do not mint
+ if (Settings.getInstance().isTopOnly() || Settings.getInstance().isLite()) {
+ // Top only and lite nodes do not sign blocks
return;
}
if (Settings.getInstance().getWipeUnconfirmedOnStart()) {
@@ -511,6 +510,21 @@ public class BlockMinter extends Thread {
PrivateKeyAccount mintingAccount = mintingAndOnlineAccounts[0];
+ Block block = mintTestingBlockRetainingTimestamps(repository, mintingAccount);
+ assertNotNull("Minted block must not be null", block);
+
+ return block;
+ }
+
+ public static Block mintTestingBlockUnvalidated(Repository repository, PrivateKeyAccount... mintingAndOnlineAccounts) throws DataException {
+ if (!BlockChain.getInstance().isTestChain())
+ throw new DataException("Ignoring attempt to mint testing block for non-test chain!");
+
+ // Ensure mintingAccount is 'online' so blocks can be minted
+ OnlineAccountsManager.getInstance().ensureTestingAccountsOnline(mintingAndOnlineAccounts);
+
+ PrivateKeyAccount mintingAccount = mintingAndOnlineAccounts[0];
+
return mintTestingBlockRetainingTimestamps(repository, mintingAccount);
}
@@ -518,6 +532,8 @@ public class BlockMinter extends Thread {
BlockData previousBlockData = repository.getBlockRepository().getLastBlock();
Block newBlock = Block.mint(repository, previousBlockData, mintingAccount);
+ if (newBlock == null)
+ return null;
// Make sure we're the only thread modifying the blockchain
ReentrantLock blockchainLock = Controller.getInstance().getBlockchainLock();
diff --git a/src/main/java/org/qortal/controller/Controller.java b/src/main/java/org/qortal/controller/Controller.java
index bcd010e8..e9e1fcc2 100644
--- a/src/main/java/org/qortal/controller/Controller.java
+++ b/src/main/java/org/qortal/controller/Controller.java
@@ -29,6 +29,7 @@ import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.jsse.provider.BouncyCastleJsseProvider;
+import org.qortal.account.Account;
import org.qortal.api.ApiService;
import org.qortal.api.DomainMapService;
import org.qortal.api.GatewayService;
@@ -756,6 +757,28 @@ public class Controller extends Thread {
return peer.isAtLeastVersion(minPeerVersion) == false;
};
+ public static final Predicate hasInvalidSigner = peer -> {
+ final BlockSummaryData peerChainTipData = peer.getChainTipData();
+ if (peerChainTipData == null)
+ return true;
+
+ try (Repository repository = RepositoryManager.getRepository()) {
+ return Account.getRewardShareEffectiveMintingLevel(repository, peerChainTipData.getMinterPublicKey()) == 0;
+ } catch (DataException e) {
+ return true;
+ }
+ };
+
+ public static final Predicate wasRecentlyTooDivergent = peer -> {
+ Long now = NTP.getTime();
+ Long peerLastTooDivergentTime = peer.getLastTooDivergentTime();
+ if (now == null || peerLastTooDivergentTime == null)
+ return false;
+
+ // Exclude any peers that were TOO_DIVERGENT in the last 5 mins
+ return (now - peerLastTooDivergentTime < 5 * 60 * 1000L);
+ };
+
private long getRandomRepositoryMaintenanceInterval() {
final long minInterval = Settings.getInstance().getRepositoryMaintenanceMinInterval();
final long maxInterval = Settings.getInstance().getRepositoryMaintenanceMaxInterval();
diff --git a/src/main/java/org/qortal/controller/Synchronizer.java b/src/main/java/org/qortal/controller/Synchronizer.java
index cd9483e9..2dad62e7 100644
--- a/src/main/java/org/qortal/controller/Synchronizer.java
+++ b/src/main/java/org/qortal/controller/Synchronizer.java
@@ -247,6 +247,9 @@ public class Synchronizer extends Thread {
// Disregard peers that are on the same block as last sync attempt and we didn't like their chain
peers.removeIf(Controller.hasInferiorChainTip);
+ // Disregard peers that have a block with an invalid signer
+ peers.removeIf(Controller.hasInvalidSigner);
+
final int peersBeforeComparison = peers.size();
// Request recent block summaries from the remaining peers, and locate our common block with each
@@ -1118,6 +1121,7 @@ public class Synchronizer extends Thread {
// If common block is too far behind us then we're on massively different forks so give up.
if (!force && testHeight < ourHeight - MAXIMUM_COMMON_DELTA) {
LOGGER.info(String.format("Blockchain too divergent with peer %s", peer));
+ peer.setLastTooDivergentTime(NTP.getTime());
return SynchronizationResult.TOO_DIVERGENT;
}
@@ -1127,6 +1131,9 @@ public class Synchronizer extends Thread {
testHeight = Math.max(testHeight - step, 1);
}
+ // Peer not considered too divergent
+ peer.setLastTooDivergentTime(0L);
+
// Prepend test block's summary as first block summary, as summaries returned are *after* test block
BlockSummaryData testBlockSummary = new BlockSummaryData(testBlockData);
blockSummariesFromCommon.add(0, testBlockSummary);
diff --git a/src/main/java/org/qortal/controller/arbitrary/ArbitraryDataFileManager.java b/src/main/java/org/qortal/controller/arbitrary/ArbitraryDataFileManager.java
index 30b0fcca..e2de1ae0 100644
--- a/src/main/java/org/qortal/controller/arbitrary/ArbitraryDataFileManager.java
+++ b/src/main/java/org/qortal/controller/arbitrary/ArbitraryDataFileManager.java
@@ -82,7 +82,7 @@ public class ArbitraryDataFileManager extends Thread {
try {
// Use a fixed thread pool to execute the arbitrary data file requests
- int threadCount = 10;
+ int threadCount = 5;
ExecutorService arbitraryDataFileRequestExecutor = Executors.newFixedThreadPool(threadCount);
for (int i = 0; i < threadCount; i++) {
arbitraryDataFileRequestExecutor.execute(new ArbitraryDataFileRequestThread());
@@ -288,7 +288,7 @@ public class ArbitraryDataFileManager extends Thread {
// The ID needs to match that of the original request
message.setId(originalMessage.getId());
- if (!requestingPeer.sendMessage(message)) {
+ if (!requestingPeer.sendMessageWithTimeout(message, (int) ArbitraryDataManager.ARBITRARY_REQUEST_TIMEOUT)) {
LOGGER.debug("Failed to forward arbitrary data file to peer {}", requestingPeer);
requestingPeer.disconnect("failed to forward arbitrary data file");
}
@@ -564,13 +564,16 @@ public class ArbitraryDataFileManager extends Thread {
LOGGER.trace("Hash {} exists", hash58);
// We can serve the file directly as we already have it
+ LOGGER.debug("Sending file {}...", arbitraryDataFile);
ArbitraryDataFileMessage arbitraryDataFileMessage = new ArbitraryDataFileMessage(signature, arbitraryDataFile);
arbitraryDataFileMessage.setId(message.getId());
- if (!peer.sendMessage(arbitraryDataFileMessage)) {
- LOGGER.debug("Couldn't sent file");
+ if (!peer.sendMessageWithTimeout(arbitraryDataFileMessage, (int) ArbitraryDataManager.ARBITRARY_REQUEST_TIMEOUT)) {
+ LOGGER.debug("Couldn't send file {}", arbitraryDataFile);
peer.disconnect("failed to send file");
}
- LOGGER.debug("Sent file {}", arbitraryDataFile);
+ else {
+ LOGGER.debug("Sent file {}", arbitraryDataFile);
+ }
}
else if (relayInfo != null) {
LOGGER.debug("We have relay info for hash {}", Base58.encode(hash));
diff --git a/src/main/java/org/qortal/controller/repository/AtStatesPruner.java b/src/main/java/org/qortal/controller/repository/AtStatesPruner.java
index bd12f784..064fe0ea 100644
--- a/src/main/java/org/qortal/controller/repository/AtStatesPruner.java
+++ b/src/main/java/org/qortal/controller/repository/AtStatesPruner.java
@@ -42,6 +42,7 @@ public class AtStatesPruner implements Runnable {
repository.discardChanges();
repository.getATRepository().rebuildLatestAtStates();
+ repository.saveChanges();
while (!Controller.isStopping()) {
repository.discardChanges();
diff --git a/src/main/java/org/qortal/controller/repository/AtStatesTrimmer.java b/src/main/java/org/qortal/controller/repository/AtStatesTrimmer.java
index 69fa347c..6c026385 100644
--- a/src/main/java/org/qortal/controller/repository/AtStatesTrimmer.java
+++ b/src/main/java/org/qortal/controller/repository/AtStatesTrimmer.java
@@ -29,6 +29,7 @@ public class AtStatesTrimmer implements Runnable {
repository.discardChanges();
repository.getATRepository().rebuildLatestAtStates();
+ repository.saveChanges();
while (!Controller.isStopping()) {
repository.discardChanges();
diff --git a/src/main/java/org/qortal/controller/tradebot/LitecoinACCTv3TradeBot.java b/src/main/java/org/qortal/controller/tradebot/LitecoinACCTv3TradeBot.java
index a31a1a28..a4ae921e 100644
--- a/src/main/java/org/qortal/controller/tradebot/LitecoinACCTv3TradeBot.java
+++ b/src/main/java/org/qortal/controller/tradebot/LitecoinACCTv3TradeBot.java
@@ -19,6 +19,7 @@ import org.qortal.data.transaction.MessageTransactionData;
import org.qortal.group.Group;
import org.qortal.repository.DataException;
import org.qortal.repository.Repository;
+import org.qortal.repository.RepositoryManager;
import org.qortal.transaction.DeployAtTransaction;
import org.qortal.transaction.MessageTransaction;
import org.qortal.transaction.Transaction.ValidationResult;
@@ -317,20 +318,27 @@ public class LitecoinACCTv3TradeBot implements AcctTradeBot {
boolean isMessageAlreadySent = repository.getMessageRepository().exists(tradeBotData.getTradeNativePublicKey(), messageRecipient, messageData);
if (!isMessageAlreadySent) {
- PrivateKeyAccount sender = new PrivateKeyAccount(repository, tradeBotData.getTradePrivateKey());
- MessageTransaction messageTransaction = MessageTransaction.build(repository, sender, Group.NO_GROUP, messageRecipient, messageData, false, false);
+ // Do this in a new thread so caller doesn't have to wait for computeNonce()
+ // In the unlikely event that the transaction doesn't validate then the buy won't happen and eventually Alice's AT will be refunded
+ new Thread(() -> {
+ try (final Repository threadsRepository = RepositoryManager.getRepository()) {
+ PrivateKeyAccount sender = new PrivateKeyAccount(threadsRepository, tradeBotData.getTradePrivateKey());
+ MessageTransaction messageTransaction = MessageTransaction.build(threadsRepository, sender, Group.NO_GROUP, messageRecipient, messageData, false, false);
- messageTransaction.computeNonce();
- messageTransaction.sign(sender);
+ messageTransaction.computeNonce();
+ messageTransaction.sign(sender);
- // reset repository state to prevent deadlock
- repository.discardChanges();
- ValidationResult result = messageTransaction.importAsUnconfirmed();
+ // reset repository state to prevent deadlock
+ threadsRepository.discardChanges();
+ ValidationResult result = messageTransaction.importAsUnconfirmed();
- if (result != ValidationResult.OK) {
- LOGGER.warn(() -> String.format("Unable to send MESSAGE to Bob's trade-bot %s: %s", messageRecipient, result.name()));
- return ResponseResult.NETWORK_ISSUE;
- }
+ if (result != ValidationResult.OK) {
+ LOGGER.warn(() -> String.format("Unable to send MESSAGE to Bob's trade-bot %s: %s", messageRecipient, result.name()));
+ }
+ } catch (DataException e) {
+ LOGGER.warn(() -> String.format("Unable to send MESSAGE to Bob's trade-bot %s: %s", messageRecipient, e.getMessage()));
+ }
+ }, "TradeBot response").start();
}
TradeBot.updateTradeBotState(repository, tradeBotData, () -> String.format("Funding P2SH-A %s. Messaged Bob. Waiting for AT-lock", p2shAddress));
diff --git a/src/main/java/org/qortal/crosschain/Bitcoiny.java b/src/main/java/org/qortal/crosschain/Bitcoiny.java
index 350779bc..c08bd91e 100644
--- a/src/main/java/org/qortal/crosschain/Bitcoiny.java
+++ b/src/main/java/org/qortal/crosschain/Bitcoiny.java
@@ -357,19 +357,33 @@ public abstract class Bitcoiny implements ForeignBlockchain {
* @return unspent BTC balance, or null if unable to determine balance
*/
public Long getWalletBalance(String key58) throws ForeignBlockchainException {
- // It's more accurate to calculate the balance from the transactions, rather than asking Bitcoinj
- return this.getWalletBalanceFromTransactions(key58);
+ Long balance = 0L;
-// Context.propagate(bitcoinjContext);
-//
-// Wallet wallet = walletFromDeterministicKey58(key58);
-// wallet.setUTXOProvider(new WalletAwareUTXOProvider(this, wallet));
-//
-// Coin balance = wallet.getBalance();
-// if (balance == null)
-// return null;
-//
-// return balance.value;
+ List allUnspentOutputs = new ArrayList<>();
+ Set walletAddresses = this.getWalletAddresses(key58);
+ for (String address : walletAddresses) {
+ allUnspentOutputs.addAll(this.getUnspentOutputs(address));
+ }
+ for (TransactionOutput output : allUnspentOutputs) {
+ if (!output.isAvailableForSpending()) {
+ continue;
+ }
+ balance += output.getValue().value;
+ }
+ return balance;
+ }
+
+ public Long getWalletBalanceFromBitcoinj(String key58) {
+ Context.propagate(bitcoinjContext);
+
+ Wallet wallet = walletFromDeterministicKey58(key58);
+ wallet.setUTXOProvider(new WalletAwareUTXOProvider(this, wallet));
+
+ Coin balance = wallet.getBalance();
+ if (balance == null)
+ return null;
+
+ return balance.value;
}
public Long getWalletBalanceFromTransactions(String key58) throws ForeignBlockchainException {
@@ -464,6 +478,64 @@ public abstract class Bitcoiny implements ForeignBlockchain {
}
}
+ public Set getWalletAddresses(String key58) throws ForeignBlockchainException {
+ synchronized (this) {
+ Context.propagate(bitcoinjContext);
+
+ Wallet wallet = walletFromDeterministicKey58(key58);
+ DeterministicKeyChain keyChain = wallet.getActiveKeyChain();
+
+ keyChain.setLookaheadSize(Bitcoiny.WALLET_KEY_LOOKAHEAD_INCREMENT);
+ keyChain.maybeLookAhead();
+
+ List keys = new ArrayList<>(keyChain.getLeafKeys());
+
+ Set keySet = new HashSet<>();
+
+ int unusedCounter = 0;
+ int ki = 0;
+ do {
+ boolean areAllKeysUnused = true;
+
+ for (; ki < keys.size(); ++ki) {
+ DeterministicKey dKey = keys.get(ki);
+
+ // Check for transactions
+ Address address = Address.fromKey(this.params, dKey, ScriptType.P2PKH);
+ keySet.add(address.toString());
+ byte[] script = ScriptBuilder.createOutputScript(address).getProgram();
+
+ // Ask for transaction history - if it's empty then key has never been used
+ List historicTransactionHashes = this.getAddressTransactions(script, false);
+
+ if (!historicTransactionHashes.isEmpty()) {
+ areAllKeysUnused = false;
+ }
+ }
+
+ if (areAllKeysUnused) {
+ // No transactions
+ if (unusedCounter >= Settings.getInstance().getGapLimit()) {
+ // ... and we've hit our search limit
+ break;
+ }
+ // We haven't hit our search limit yet so increment the counter and keep looking
+ unusedCounter += WALLET_KEY_LOOKAHEAD_INCREMENT;
+ } else {
+ // Some keys in this batch were used, so reset the counter
+ unusedCounter = 0;
+ }
+
+ // Generate some more keys
+ keys.addAll(generateMoreKeys(keyChain));
+
+ // Process new keys
+ } while (true);
+
+ return keySet;
+ }
+ }
+
protected SimpleTransaction convertToSimpleTransaction(BitcoinyTransaction t, Set keySet) {
long amount = 0;
long total = 0L;
diff --git a/src/main/java/org/qortal/crosschain/Digibyte.java b/src/main/java/org/qortal/crosschain/Digibyte.java
index 3ab5e78e..4358b3b3 100644
--- a/src/main/java/org/qortal/crosschain/Digibyte.java
+++ b/src/main/java/org/qortal/crosschain/Digibyte.java
@@ -134,6 +134,8 @@ public class Digibyte extends Bitcoiny {
Context bitcoinjContext = new Context(digibyteNet.getParams());
instance = new Digibyte(digibyteNet, electrumX, bitcoinjContext, CURRENCY_CODE);
+
+ electrumX.setBlockchain(instance);
}
return instance;
diff --git a/src/main/java/org/qortal/crosschain/ElectrumX.java b/src/main/java/org/qortal/crosschain/ElectrumX.java
index a2a42089..e1eb1963 100644
--- a/src/main/java/org/qortal/crosschain/ElectrumX.java
+++ b/src/main/java/org/qortal/crosschain/ElectrumX.java
@@ -40,7 +40,7 @@ public class ElectrumX extends BitcoinyBlockchainProvider {
private static final String VERBOSE_TRANSACTIONS_UNSUPPORTED_MESSAGE = "verbose transactions are currently unsupported";
private static final int RESPONSE_TIME_READINGS = 5;
- private static final long MAX_AVG_RESPONSE_TIME = 500L; // ms
+ private static final long MAX_AVG_RESPONSE_TIME = 1000L; // ms
public static class Server {
String hostname;
diff --git a/src/main/java/org/qortal/crosschain/PirateWallet.java b/src/main/java/org/qortal/crosschain/PirateWallet.java
index 6c6ed2a9..4b95d3cc 100644
--- a/src/main/java/org/qortal/crosschain/PirateWallet.java
+++ b/src/main/java/org/qortal/crosschain/PirateWallet.java
@@ -117,7 +117,7 @@ public class PirateWallet {
// Restore existing wallet
String response = LiteWalletJni.initfromb64(serverUri, params, wallet, saplingOutput64, saplingSpend64);
if (response != null && !response.contains("\"initalized\":true")) {
- LOGGER.info("Unable to initialize Pirate Chain wallet: {}", response);
+ LOGGER.info("Unable to initialize Pirate Chain wallet at {}: {}", serverUri, response);
return false;
}
this.seedPhrase = inputSeedPhrase;
diff --git a/src/main/java/org/qortal/crosschain/Ravencoin.java b/src/main/java/org/qortal/crosschain/Ravencoin.java
index d65c0a13..7bf5b20f 100644
--- a/src/main/java/org/qortal/crosschain/Ravencoin.java
+++ b/src/main/java/org/qortal/crosschain/Ravencoin.java
@@ -138,6 +138,8 @@ public class Ravencoin extends Bitcoiny {
Context bitcoinjContext = new Context(ravencoinNet.getParams());
instance = new Ravencoin(ravencoinNet, electrumX, bitcoinjContext, CURRENCY_CODE);
+
+ electrumX.setBlockchain(instance);
}
return instance;
diff --git a/src/main/java/org/qortal/data/account/AccountData.java b/src/main/java/org/qortal/data/account/AccountData.java
index 4d662f04..868d1bc1 100644
--- a/src/main/java/org/qortal/data/account/AccountData.java
+++ b/src/main/java/org/qortal/data/account/AccountData.java
@@ -18,6 +18,7 @@ public class AccountData {
protected int level;
protected int blocksMinted;
protected int blocksMintedAdjustment;
+ protected int blocksMintedPenalty;
// Constructors
@@ -25,7 +26,7 @@ public class AccountData {
protected AccountData() {
}
- public AccountData(String address, byte[] reference, byte[] publicKey, int defaultGroupId, int flags, int level, int blocksMinted, int blocksMintedAdjustment) {
+ public AccountData(String address, byte[] reference, byte[] publicKey, int defaultGroupId, int flags, int level, int blocksMinted, int blocksMintedAdjustment, int blocksMintedPenalty) {
this.address = address;
this.reference = reference;
this.publicKey = publicKey;
@@ -34,10 +35,11 @@ public class AccountData {
this.level = level;
this.blocksMinted = blocksMinted;
this.blocksMintedAdjustment = blocksMintedAdjustment;
+ this.blocksMintedPenalty = blocksMintedPenalty;
}
public AccountData(String address) {
- this(address, null, null, Group.NO_GROUP, 0, 0, 0, 0);
+ this(address, null, null, Group.NO_GROUP, 0, 0, 0, 0, 0);
}
// Getters/Setters
@@ -102,6 +104,14 @@ public class AccountData {
this.blocksMintedAdjustment = blocksMintedAdjustment;
}
+ public int getBlocksMintedPenalty() {
+ return this.blocksMintedPenalty;
+ }
+
+ public void setBlocksMintedPenalty(int blocksMintedPenalty) {
+ this.blocksMintedPenalty = blocksMintedPenalty;
+ }
+
// Comparison
@Override
diff --git a/src/main/java/org/qortal/data/account/AccountPenaltyData.java b/src/main/java/org/qortal/data/account/AccountPenaltyData.java
new file mode 100644
index 00000000..61947a5f
--- /dev/null
+++ b/src/main/java/org/qortal/data/account/AccountPenaltyData.java
@@ -0,0 +1,52 @@
+package org.qortal.data.account;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+
+// All properties to be converted to JSON via JAXB
+@XmlAccessorType(XmlAccessType.FIELD)
+public class AccountPenaltyData {
+
+ // Properties
+ private String address;
+ private int blocksMintedPenalty;
+
+ // Constructors
+
+ // necessary for JAXB
+ protected AccountPenaltyData() {
+ }
+
+ public AccountPenaltyData(String address, int blocksMintedPenalty) {
+ this.address = address;
+ this.blocksMintedPenalty = blocksMintedPenalty;
+ }
+
+ // Getters/Setters
+
+ public String getAddress() {
+ return this.address;
+ }
+
+ public int getBlocksMintedPenalty() {
+ return this.blocksMintedPenalty;
+ }
+
+ public String toString() {
+ return String.format("%s has penalty %d", this.address, this.blocksMintedPenalty);
+ }
+
+ @Override
+ public boolean equals(Object b) {
+ if (!(b instanceof AccountPenaltyData))
+ return false;
+
+ return this.getAddress().equals(((AccountPenaltyData) b).getAddress());
+ }
+
+ @Override
+ public int hashCode() {
+ return address.hashCode();
+ }
+
+}
diff --git a/src/main/java/org/qortal/data/chat/ChatMessage.java b/src/main/java/org/qortal/data/chat/ChatMessage.java
index 26df1da4..5d16bb7c 100644
--- a/src/main/java/org/qortal/data/chat/ChatMessage.java
+++ b/src/main/java/org/qortal/data/chat/ChatMessage.java
@@ -27,6 +27,8 @@ public class ChatMessage {
private String recipientName;
+ private byte[] chatReference;
+
private byte[] data;
private boolean isText;
@@ -42,8 +44,8 @@ public class ChatMessage {
// For repository use
public ChatMessage(long timestamp, int txGroupId, byte[] reference, byte[] senderPublicKey, String sender,
- String senderName, String recipient, String recipientName, byte[] data, boolean isText,
- boolean isEncrypted, byte[] signature) {
+ String senderName, String recipient, String recipientName, byte[] chatReference, byte[] data,
+ boolean isText, boolean isEncrypted, byte[] signature) {
this.timestamp = timestamp;
this.txGroupId = txGroupId;
this.reference = reference;
@@ -52,6 +54,7 @@ public class ChatMessage {
this.senderName = senderName;
this.recipient = recipient;
this.recipientName = recipientName;
+ this.chatReference = chatReference;
this.data = data;
this.isText = isText;
this.isEncrypted = isEncrypted;
@@ -90,6 +93,10 @@ public class ChatMessage {
return this.recipientName;
}
+ public byte[] getChatReference() {
+ return this.chatReference;
+ }
+
public byte[] getData() {
return this.data;
}
diff --git a/src/main/java/org/qortal/data/transaction/ChatTransactionData.java b/src/main/java/org/qortal/data/transaction/ChatTransactionData.java
index 36ce6124..5a6adf7f 100644
--- a/src/main/java/org/qortal/data/transaction/ChatTransactionData.java
+++ b/src/main/java/org/qortal/data/transaction/ChatTransactionData.java
@@ -26,6 +26,8 @@ public class ChatTransactionData extends TransactionData {
private String recipient; // can be null
+ private byte[] chatReference; // can be null
+
@Schema(description = "raw message data, possibly UTF8 text", example = "2yGEbwRFyhPZZckKA")
private byte[] data;
@@ -44,13 +46,14 @@ public class ChatTransactionData extends TransactionData {
}
public ChatTransactionData(BaseTransactionData baseTransactionData,
- String sender, int nonce, String recipient, byte[] data, boolean isText, boolean isEncrypted) {
+ String sender, int nonce, String recipient, byte[] chatReference, byte[] data, boolean isText, boolean isEncrypted) {
super(TransactionType.CHAT, baseTransactionData);
this.senderPublicKey = baseTransactionData.creatorPublicKey;
this.sender = sender;
this.nonce = nonce;
this.recipient = recipient;
+ this.chatReference = chatReference;
this.data = data;
this.isText = isText;
this.isEncrypted = isEncrypted;
@@ -78,6 +81,14 @@ public class ChatTransactionData extends TransactionData {
return this.recipient;
}
+ public byte[] getChatReference() {
+ return this.chatReference;
+ }
+
+ public void setChatReference(byte[] chatReference) {
+ this.chatReference = chatReference;
+ }
+
public byte[] getData() {
return this.data;
}
diff --git a/src/main/java/org/qortal/data/transaction/DeployAtTransactionData.java b/src/main/java/org/qortal/data/transaction/DeployAtTransactionData.java
index 7a2ebdab..fed69cd5 100644
--- a/src/main/java/org/qortal/data/transaction/DeployAtTransactionData.java
+++ b/src/main/java/org/qortal/data/transaction/DeployAtTransactionData.java
@@ -2,6 +2,7 @@ package org.qortal.data.transaction;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
import org.qortal.transaction.Transaction.TransactionType;
@@ -90,4 +91,17 @@ public class DeployAtTransactionData extends TransactionData {
this.aTAddress = AtAddress;
}
+ // Re-expose creatorPublicKey for this transaction type for JAXB
+ @XmlElement(name = "creatorPublicKey")
+ @Schema(name = "creatorPublicKey", description = "AT creator's public key", example = "2tiMr5LTpaWCgbRvkPK8TFd7k63DyHJMMFFsz9uBf1ZP")
+ public byte[] getAtCreatorPublicKey() {
+ return this.creatorPublicKey;
+ }
+
+ @XmlElement(name = "creatorPublicKey")
+ @Schema(name = "creatorPublicKey", description = "AT creator's public key", example = "2tiMr5LTpaWCgbRvkPK8TFd7k63DyHJMMFFsz9uBf1ZP")
+ public void setAtCreatorPublicKey(byte[] creatorPublicKey) {
+ this.creatorPublicKey = creatorPublicKey;
+ }
+
}
diff --git a/src/main/java/org/qortal/data/transaction/TransactionData.java b/src/main/java/org/qortal/data/transaction/TransactionData.java
index 060901f2..ec1139f4 100644
--- a/src/main/java/org/qortal/data/transaction/TransactionData.java
+++ b/src/main/java/org/qortal/data/transaction/TransactionData.java
@@ -128,6 +128,10 @@ public abstract class TransactionData {
return this.txGroupId;
}
+ public void setTxGroupId(int txGroupId) {
+ this.txGroupId = txGroupId;
+ }
+
public byte[] getReference() {
return this.reference;
}
diff --git a/src/main/java/org/qortal/group/Group.java b/src/main/java/org/qortal/group/Group.java
index 1dbb18b0..465743a9 100644
--- a/src/main/java/org/qortal/group/Group.java
+++ b/src/main/java/org/qortal/group/Group.java
@@ -80,6 +80,9 @@ public class Group {
// Useful constants
public static final int NO_GROUP = 0;
+ // Null owner address corresponds with public key "11111111111111111111111111111111"
+ public static String NULL_OWNER_ADDRESS = "QdSnUy6sUiEnaN87dWmE92g1uQjrvPgrWG";
+
public static final int MIN_NAME_SIZE = 3;
public static final int MAX_NAME_SIZE = 32;
public static final int MAX_DESCRIPTION_SIZE = 128;
diff --git a/src/main/java/org/qortal/network/Handshake.java b/src/main/java/org/qortal/network/Handshake.java
index 22354cc4..47752767 100644
--- a/src/main/java/org/qortal/network/Handshake.java
+++ b/src/main/java/org/qortal/network/Handshake.java
@@ -265,7 +265,7 @@ public enum Handshake {
private static final long PEER_VERSION_131 = 0x0100030001L;
/** Minimum peer version that we are allowed to communicate with */
- private static final String MIN_PEER_VERSION = "3.1.0";
+ private static final String MIN_PEER_VERSION = "3.8.2";
private static final int POW_BUFFER_SIZE_PRE_131 = 8 * 1024 * 1024; // bytes
private static final int POW_DIFFICULTY_PRE_131 = 8; // leading zero bits
diff --git a/src/main/java/org/qortal/network/Peer.java b/src/main/java/org/qortal/network/Peer.java
index a187d29b..4c05d5b9 100644
--- a/src/main/java/org/qortal/network/Peer.java
+++ b/src/main/java/org/qortal/network/Peer.java
@@ -155,6 +155,11 @@ public class Peer {
*/
private CommonBlockData commonBlockData;
+ /**
+ * Last time we detected this peer as TOO_DIVERGENT
+ */
+ private Long lastTooDivergentTime;
+
// Message stats
private static class MessageStats {
@@ -383,6 +388,14 @@ public class Peer {
this.commonBlockData = commonBlockData;
}
+ public Long getLastTooDivergentTime() {
+ return this.lastTooDivergentTime;
+ }
+
+ public void setLastTooDivergentTime(Long lastTooDivergentTime) {
+ this.lastTooDivergentTime = lastTooDivergentTime;
+ }
+
public boolean isSyncInProgress() {
return this.syncInProgress;
}
diff --git a/src/main/java/org/qortal/network/message/AccountMessage.java b/src/main/java/org/qortal/network/message/AccountMessage.java
index d22ef879..453862b0 100644
--- a/src/main/java/org/qortal/network/message/AccountMessage.java
+++ b/src/main/java/org/qortal/network/message/AccountMessage.java
@@ -41,6 +41,8 @@ public class AccountMessage extends Message {
bytes.write(Ints.toByteArray(accountData.getBlocksMintedAdjustment()));
+ bytes.write(Ints.toByteArray(accountData.getBlocksMintedPenalty()));
+
} catch (IOException e) {
throw new AssertionError("IOException shouldn't occur with ByteArrayOutputStream");
}
@@ -80,7 +82,9 @@ public class AccountMessage extends Message {
int blocksMintedAdjustment = byteBuffer.getInt();
- AccountData accountData = new AccountData(address, reference, publicKey, defaultGroupId, flags, level, blocksMinted, blocksMintedAdjustment);
+ int blocksMintedPenalty = byteBuffer.getInt();
+
+ AccountData accountData = new AccountData(address, reference, publicKey, defaultGroupId, flags, level, blocksMinted, blocksMintedAdjustment, blocksMintedPenalty);
return new AccountMessage(id, accountData);
}
diff --git a/src/main/java/org/qortal/repository/AccountRepository.java b/src/main/java/org/qortal/repository/AccountRepository.java
index 281f34f1..1175337c 100644
--- a/src/main/java/org/qortal/repository/AccountRepository.java
+++ b/src/main/java/org/qortal/repository/AccountRepository.java
@@ -1,13 +1,9 @@
package org.qortal.repository;
import java.util.List;
+import java.util.Set;
-import org.qortal.data.account.AccountBalanceData;
-import org.qortal.data.account.AccountData;
-import org.qortal.data.account.EligibleQoraHolderData;
-import org.qortal.data.account.MintingAccountData;
-import org.qortal.data.account.QortFromQoraData;
-import org.qortal.data.account.RewardShareData;
+import org.qortal.data.account.*;
public interface AccountRepository {
@@ -19,6 +15,9 @@ public interface AccountRepository {
/** Returns accounts with any bit set in given mask. */
public List getFlaggedAccounts(int mask) throws DataException;
+ /** Returns accounts with a blockedMintedPenalty */
+ public List getPenaltyAccounts() throws DataException;
+
/** Returns account's last reference or null if not set or account not found. */
public byte[] getLastReference(String address) throws DataException;
@@ -100,6 +99,18 @@ public interface AccountRepository {
*/
public void modifyMintedBlockCounts(List addresses, int delta) throws DataException;
+ /** Returns account's block minted penalty count or null if account not found. */
+ public Integer getBlocksMintedPenaltyCount(String address) throws DataException;
+
+ /**
+ * Sets blocks minted penalties for given list of accounts.
+ * This replaces the existing values rather than modifying them by a delta.
+ *
+ * @param accountPenalties
+ * @throws DataException
+ */
+ public void updateBlocksMintedPenalties(Set accountPenalties) throws DataException;
+
/** Delete account from repository. */
public void delete(String address) throws DataException;
diff --git a/src/main/java/org/qortal/repository/ChatRepository.java b/src/main/java/org/qortal/repository/ChatRepository.java
index 2ecd8a34..c4541907 100644
--- a/src/main/java/org/qortal/repository/ChatRepository.java
+++ b/src/main/java/org/qortal/repository/ChatRepository.java
@@ -14,8 +14,8 @@ public interface ChatRepository {
* Expects EITHER non-null txGroupID OR non-null sender and recipient addresses.
*/
public List getMessagesMatchingCriteria(Long before, Long after,
- Integer txGroupId, byte[] reference, List involving,
- Integer limit, Integer offset, Boolean reverse) throws DataException;
+ Integer txGroupId, byte[] reference, byte[] chatReferenceBytes, Boolean hasChatReference,
+ List involving, Integer limit, Integer offset, Boolean reverse) throws DataException;
public ChatMessage toChatMessage(ChatTransactionData chatTransactionData) throws DataException;
diff --git a/src/main/java/org/qortal/repository/GroupRepository.java b/src/main/java/org/qortal/repository/GroupRepository.java
index bcee7d25..94c97992 100644
--- a/src/main/java/org/qortal/repository/GroupRepository.java
+++ b/src/main/java/org/qortal/repository/GroupRepository.java
@@ -131,7 +131,14 @@ public interface GroupRepository {
public GroupBanData getBan(int groupId, String member) throws DataException;
- public boolean banExists(int groupId, String offender) throws DataException;
+ /**
+ * IMPORTANT: when using banExists() as part of validation, the timestamp must be that of the transaction that
+ * is calling banExists() as part of its validation. It must NOT be the current time, unless this is being
+ * called outside of validation, as part of an on demand check for a ban existing (such as via an API call).
+ * This is because we need to evaluate a ban's status based on the time of the subsequent transaction, as
+ * validation will not occur at a fixed time for every node. For some, it could be months into the future.
+ */
+ public boolean banExists(int groupId, String offender, long timestamp) throws DataException;
public List getGroupBans(int groupId, Integer limit, Integer offset, Boolean reverse) throws DataException;
diff --git a/src/main/java/org/qortal/repository/TransactionRepository.java b/src/main/java/org/qortal/repository/TransactionRepository.java
index 4fb9bb12..105a317d 100644
--- a/src/main/java/org/qortal/repository/TransactionRepository.java
+++ b/src/main/java/org/qortal/repository/TransactionRepository.java
@@ -179,6 +179,15 @@ public interface TransactionRepository {
public List getAssetTransfers(long assetId, String address, Integer limit, Integer offset, Boolean reverse)
throws DataException;
+ /**
+ * Returns list of reward share transaction creators, excluding self shares.
+ * This uses confirmed transactions only.
+ *
+ * @return
+ * @throws DataException
+ */
+ public List getConfirmedRewardShareCreatorsExcludingSelfShares() throws DataException;
+
/**
* Returns list of transactions pending approval, with optional txGgroupId filtering.
*
diff --git a/src/main/java/org/qortal/repository/hsqldb/HSQLDBAccountRepository.java b/src/main/java/org/qortal/repository/hsqldb/HSQLDBAccountRepository.java
index 9fdb0a3f..cb188502 100644
--- a/src/main/java/org/qortal/repository/hsqldb/HSQLDBAccountRepository.java
+++ b/src/main/java/org/qortal/repository/hsqldb/HSQLDBAccountRepository.java
@@ -6,15 +6,11 @@ import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
+import java.util.Set;
import java.util.stream.Collectors;
import org.qortal.asset.Asset;
-import org.qortal.data.account.AccountBalanceData;
-import org.qortal.data.account.AccountData;
-import org.qortal.data.account.EligibleQoraHolderData;
-import org.qortal.data.account.MintingAccountData;
-import org.qortal.data.account.QortFromQoraData;
-import org.qortal.data.account.RewardShareData;
+import org.qortal.data.account.*;
import org.qortal.repository.AccountRepository;
import org.qortal.repository.DataException;
@@ -30,7 +26,7 @@ public class HSQLDBAccountRepository implements AccountRepository {
@Override
public AccountData getAccount(String address) throws DataException {
- String sql = "SELECT reference, public_key, default_group_id, flags, level, blocks_minted, blocks_minted_adjustment FROM Accounts WHERE account = ?";
+ String sql = "SELECT reference, public_key, default_group_id, flags, level, blocks_minted, blocks_minted_adjustment, blocks_minted_penalty FROM Accounts WHERE account = ?";
try (ResultSet resultSet = this.repository.checkedExecute(sql, address)) {
if (resultSet == null)
@@ -43,8 +39,9 @@ public class HSQLDBAccountRepository implements AccountRepository {
int level = resultSet.getInt(5);
int blocksMinted = resultSet.getInt(6);
int blocksMintedAdjustment = resultSet.getInt(7);
+ int blocksMintedPenalty = resultSet.getInt(8);
- return new AccountData(address, reference, publicKey, defaultGroupId, flags, level, blocksMinted, blocksMintedAdjustment);
+ return new AccountData(address, reference, publicKey, defaultGroupId, flags, level, blocksMinted, blocksMintedAdjustment, blocksMintedPenalty);
} catch (SQLException e) {
throw new DataException("Unable to fetch account info from repository", e);
}
@@ -52,7 +49,7 @@ public class HSQLDBAccountRepository implements AccountRepository {
@Override
public List getFlaggedAccounts(int mask) throws DataException {
- String sql = "SELECT reference, public_key, default_group_id, flags, level, blocks_minted, blocks_minted_adjustment, account FROM Accounts WHERE BITAND(flags, ?) != 0";
+ String sql = "SELECT reference, public_key, default_group_id, flags, level, blocks_minted, blocks_minted_adjustment, blocks_minted_penalty, account FROM Accounts WHERE BITAND(flags, ?) != 0";
List accounts = new ArrayList<>();
@@ -68,9 +65,10 @@ public class HSQLDBAccountRepository implements AccountRepository {
int level = resultSet.getInt(5);
int blocksMinted = resultSet.getInt(6);
int blocksMintedAdjustment = resultSet.getInt(7);
- String address = resultSet.getString(8);
+ int blocksMintedPenalty = resultSet.getInt(8);
+ String address = resultSet.getString(9);
- accounts.add(new AccountData(address, reference, publicKey, defaultGroupId, flags, level, blocksMinted, blocksMintedAdjustment));
+ accounts.add(new AccountData(address, reference, publicKey, defaultGroupId, flags, level, blocksMinted, blocksMintedAdjustment, blocksMintedPenalty));
} while (resultSet.next());
return accounts;
@@ -79,6 +77,36 @@ public class HSQLDBAccountRepository implements AccountRepository {
}
}
+ @Override
+ public List getPenaltyAccounts() throws DataException {
+ String sql = "SELECT reference, public_key, default_group_id, flags, level, blocks_minted, blocks_minted_adjustment, blocks_minted_penalty, account FROM Accounts WHERE blocks_minted_penalty != 0";
+
+ List accounts = new ArrayList<>();
+
+ try (ResultSet resultSet = this.repository.checkedExecute(sql)) {
+ if (resultSet == null)
+ return accounts;
+
+ do {
+ byte[] reference = resultSet.getBytes(1);
+ byte[] publicKey = resultSet.getBytes(2);
+ int defaultGroupId = resultSet.getInt(3);
+ int flags = resultSet.getInt(4);
+ int level = resultSet.getInt(5);
+ int blocksMinted = resultSet.getInt(6);
+ int blocksMintedAdjustment = resultSet.getInt(7);
+ int blocksMintedPenalty = resultSet.getInt(8);
+ String address = resultSet.getString(9);
+
+ accounts.add(new AccountData(address, reference, publicKey, defaultGroupId, flags, level, blocksMinted, blocksMintedAdjustment, blocksMintedPenalty));
+ } while (resultSet.next());
+
+ return accounts;
+ } catch (SQLException e) {
+ throw new DataException("Unable to fetch penalty accounts from repository", e);
+ }
+ }
+
@Override
public byte[] getLastReference(String address) throws DataException {
String sql = "SELECT reference FROM Accounts WHERE account = ?";
@@ -298,6 +326,39 @@ public class HSQLDBAccountRepository implements AccountRepository {
}
}
+ @Override
+ public Integer getBlocksMintedPenaltyCount(String address) throws DataException {
+ String sql = "SELECT blocks_minted_penalty FROM Accounts WHERE account = ?";
+
+ try (ResultSet resultSet = this.repository.checkedExecute(sql, address)) {
+ if (resultSet == null)
+ return null;
+
+ return resultSet.getInt(1);
+ } catch (SQLException e) {
+ throw new DataException("Unable to fetch account's block minted penalty count from repository", e);
+ }
+ }
+ public void updateBlocksMintedPenalties(Set accountPenalties) throws DataException {
+ // Nothing to do?
+ if (accountPenalties == null || accountPenalties.isEmpty())
+ return;
+
+ // Map balance changes into SQL bind params, filtering out no-op changes
+ List updateBlocksMintedPenaltyParams = accountPenalties.stream()
+ .map(accountPenalty -> new Object[] { accountPenalty.getAddress(), accountPenalty.getBlocksMintedPenalty(), accountPenalty.getBlocksMintedPenalty() })
+ .collect(Collectors.toList());
+
+ // Perform actual balance changes
+ String sql = "INSERT INTO Accounts (account, blocks_minted_penalty) VALUES (?, ?) " +
+ "ON DUPLICATE KEY UPDATE blocks_minted_penalty = blocks_minted_penalty + ?";
+ try {
+ this.repository.executeCheckedBatchUpdate(sql, updateBlocksMintedPenaltyParams);
+ } catch (SQLException e) {
+ throw new DataException("Unable to set blocks minted penalties in repository", e);
+ }
+ }
+
@Override
public void delete(String address) throws DataException {
// NOTE: Account balances are deleted automatically by the database thanks to "ON DELETE CASCADE" in AccountBalances' FOREIGN KEY
diff --git a/src/main/java/org/qortal/repository/hsqldb/HSQLDBChatRepository.java b/src/main/java/org/qortal/repository/hsqldb/HSQLDBChatRepository.java
index 2f570686..08226d53 100644
--- a/src/main/java/org/qortal/repository/hsqldb/HSQLDBChatRepository.java
+++ b/src/main/java/org/qortal/repository/hsqldb/HSQLDBChatRepository.java
@@ -24,8 +24,8 @@ public class HSQLDBChatRepository implements ChatRepository {
@Override
public List getMessagesMatchingCriteria(Long before, Long after, Integer txGroupId, byte[] referenceBytes,
- List involving, Integer limit, Integer offset, Boolean reverse)
- throws DataException {
+ byte[] chatReferenceBytes, Boolean hasChatReference, List involving,
+ Integer limit, Integer offset, Boolean reverse) throws DataException {
// Check args meet expectations
if ((txGroupId != null && involving != null && !involving.isEmpty())
|| (txGroupId == null && (involving == null || involving.size() != 2)))
@@ -35,7 +35,7 @@ public class HSQLDBChatRepository implements ChatRepository {
sql.append("SELECT created_when, tx_group_id, Transactions.reference, creator, "
+ "sender, SenderNames.name, recipient, RecipientNames.name, "
- + "data, is_text, is_encrypted, signature "
+ + "chat_reference, data, is_text, is_encrypted, signature "
+ "FROM ChatTransactions "
+ "JOIN Transactions USING (signature) "
+ "LEFT OUTER JOIN Names AS SenderNames ON SenderNames.owner = sender "
@@ -62,6 +62,18 @@ public class HSQLDBChatRepository implements ChatRepository {
bindParams.add(referenceBytes);
}
+ if (chatReferenceBytes != null) {
+ whereClauses.add("chat_reference = ?");
+ bindParams.add(chatReferenceBytes);
+ }
+
+ if (hasChatReference != null && hasChatReference == true) {
+ whereClauses.add("chat_reference IS NOT NULL");
+ }
+ else if (hasChatReference != null && hasChatReference == false) {
+ whereClauses.add("chat_reference IS NULL");
+ }
+
if (txGroupId != null) {
whereClauses.add("tx_group_id = " + txGroupId); // int safe to use literally
whereClauses.add("recipient IS NULL");
@@ -103,13 +115,14 @@ public class HSQLDBChatRepository implements ChatRepository {
String senderName = resultSet.getString(6);
String recipient = resultSet.getString(7);
String recipientName = resultSet.getString(8);
- byte[] data = resultSet.getBytes(9);
- boolean isText = resultSet.getBoolean(10);
- boolean isEncrypted = resultSet.getBoolean(11);
- byte[] signature = resultSet.getBytes(12);
+ byte[] chatReference = resultSet.getBytes(9);
+ byte[] data = resultSet.getBytes(10);
+ boolean isText = resultSet.getBoolean(11);
+ boolean isEncrypted = resultSet.getBoolean(12);
+ byte[] signature = resultSet.getBytes(13);
ChatMessage chatMessage = new ChatMessage(timestamp, groupId, reference, senderPublicKey, sender,
- senderName, recipient, recipientName, data, isText, isEncrypted, signature);
+ senderName, recipient, recipientName, chatReference, data, isText, isEncrypted, signature);
chatMessages.add(chatMessage);
} while (resultSet.next());
@@ -141,13 +154,14 @@ public class HSQLDBChatRepository implements ChatRepository {
byte[] senderPublicKey = chatTransactionData.getSenderPublicKey();
String sender = chatTransactionData.getSender();
String recipient = chatTransactionData.getRecipient();
+ byte[] chatReference = chatTransactionData.getChatReference();
byte[] data = chatTransactionData.getData();
boolean isText = chatTransactionData.getIsText();
boolean isEncrypted = chatTransactionData.getIsEncrypted();
byte[] signature = chatTransactionData.getSignature();
return new ChatMessage(timestamp, groupId, reference, senderPublicKey, sender,
- senderName, recipient, recipientName, data, isText, isEncrypted, signature);
+ senderName, recipient, recipientName, chatReference, data, isText, isEncrypted, signature);
} catch (SQLException e) {
throw new DataException("Unable to fetch convert chat transaction from repository", e);
}
diff --git a/src/main/java/org/qortal/repository/hsqldb/HSQLDBDatabaseUpdates.java b/src/main/java/org/qortal/repository/hsqldb/HSQLDBDatabaseUpdates.java
index 1174f5c8..e72e5fab 100644
--- a/src/main/java/org/qortal/repository/hsqldb/HSQLDBDatabaseUpdates.java
+++ b/src/main/java/org/qortal/repository/hsqldb/HSQLDBDatabaseUpdates.java
@@ -975,6 +975,19 @@ public class HSQLDBDatabaseUpdates {
stmt.execute("ALTER TABLE TradeBotStates ALTER COLUMN receiving_account_info SET DATA TYPE VARBINARY(128)");
break;
+ case 44:
+ // Add blocks minted penalty
+ stmt.execute("ALTER TABLE Accounts ADD blocks_minted_penalty INTEGER NOT NULL DEFAULT 0");
+ break;
+
+ case 45:
+ // Add a chat reference, to allow one message to reference another, and for this to be easily
+ // searchable. Null values are allowed as most transactions won't have a reference.
+ stmt.execute("ALTER TABLE ChatTransactions ADD chat_reference Signature");
+ // For finding chat messages by reference
+ stmt.execute("CREATE INDEX ChatTransactionsChatReferenceIndex ON ChatTransactions (chat_reference)");
+ break;
+
default:
// nothing to do
return false;
diff --git a/src/main/java/org/qortal/repository/hsqldb/HSQLDBGroupRepository.java b/src/main/java/org/qortal/repository/hsqldb/HSQLDBGroupRepository.java
index 91db22f1..b1cd40a0 100644
--- a/src/main/java/org/qortal/repository/hsqldb/HSQLDBGroupRepository.java
+++ b/src/main/java/org/qortal/repository/hsqldb/HSQLDBGroupRepository.java
@@ -777,9 +777,9 @@ public class HSQLDBGroupRepository implements GroupRepository {
}
@Override
- public boolean banExists(int groupId, String offender) throws DataException {
+ public boolean banExists(int groupId, String offender, long timestamp) throws DataException {
try {
- return this.repository.exists("GroupBans", "group_id = ? AND offender = ?", groupId, offender);
+ return this.repository.exists("GroupBans", "group_id = ? AND offender = ? AND (expires_when IS NULL OR expires_when > ?)", groupId, offender, timestamp);
} catch (SQLException e) {
throw new DataException("Unable to check for group ban in repository", e);
}
diff --git a/src/main/java/org/qortal/repository/hsqldb/transaction/HSQLDBChatTransactionRepository.java b/src/main/java/org/qortal/repository/hsqldb/transaction/HSQLDBChatTransactionRepository.java
index 449922f4..79e798a9 100644
--- a/src/main/java/org/qortal/repository/hsqldb/transaction/HSQLDBChatTransactionRepository.java
+++ b/src/main/java/org/qortal/repository/hsqldb/transaction/HSQLDBChatTransactionRepository.java
@@ -17,7 +17,7 @@ public class HSQLDBChatTransactionRepository extends HSQLDBTransactionRepository
}
TransactionData fromBase(BaseTransactionData baseTransactionData) throws DataException {
- String sql = "SELECT sender, nonce, recipient, is_text, is_encrypted, data FROM ChatTransactions WHERE signature = ?";
+ String sql = "SELECT sender, nonce, recipient, is_text, is_encrypted, data, chat_reference FROM ChatTransactions WHERE signature = ?";
try (ResultSet resultSet = this.repository.checkedExecute(sql, baseTransactionData.getSignature())) {
if (resultSet == null)
@@ -29,8 +29,9 @@ public class HSQLDBChatTransactionRepository extends HSQLDBTransactionRepository
boolean isText = resultSet.getBoolean(4);
boolean isEncrypted = resultSet.getBoolean(5);
byte[] data = resultSet.getBytes(6);
+ byte[] chatReference = resultSet.getBytes(7);
- return new ChatTransactionData(baseTransactionData, sender, nonce, recipient, data, isText, isEncrypted);
+ return new ChatTransactionData(baseTransactionData, sender, nonce, recipient, chatReference, data, isText, isEncrypted);
} catch (SQLException e) {
throw new DataException("Unable to fetch chat transaction from repository", e);
}
@@ -45,7 +46,7 @@ public class HSQLDBChatTransactionRepository extends HSQLDBTransactionRepository
saveHelper.bind("signature", chatTransactionData.getSignature()).bind("nonce", chatTransactionData.getNonce())
.bind("sender", chatTransactionData.getSender()).bind("recipient", chatTransactionData.getRecipient())
.bind("is_text", chatTransactionData.getIsText()).bind("is_encrypted", chatTransactionData.getIsEncrypted())
- .bind("data", chatTransactionData.getData());
+ .bind("data", chatTransactionData.getData()).bind("chat_reference", chatTransactionData.getChatReference());
try {
saveHelper.execute(this.repository);
diff --git a/src/main/java/org/qortal/repository/hsqldb/transaction/HSQLDBTransactionRepository.java b/src/main/java/org/qortal/repository/hsqldb/transaction/HSQLDBTransactionRepository.java
index e3ef13be..a8df1ab5 100644
--- a/src/main/java/org/qortal/repository/hsqldb/transaction/HSQLDBTransactionRepository.java
+++ b/src/main/java/org/qortal/repository/hsqldb/transaction/HSQLDBTransactionRepository.java
@@ -7,11 +7,7 @@ import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.ResultSet;
import java.sql.SQLException;
-import java.util.ArrayList;
-import java.util.EnumMap;
-import java.util.EnumSet;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
@@ -969,6 +965,33 @@ public class HSQLDBTransactionRepository implements TransactionRepository {
}
}
+ public List getConfirmedRewardShareCreatorsExcludingSelfShares() throws DataException {
+ List rewardShareCreators = new ArrayList<>();
+
+ String sql = "SELECT account "
+ + "FROM RewardShareTransactions "
+ + "JOIN Accounts ON Accounts.public_key = RewardShareTransactions.minter_public_key "
+ + "JOIN Transactions ON Transactions.signature = RewardShareTransactions.signature "
+ + "WHERE block_height IS NOT NULL AND RewardShareTransactions.recipient != Accounts.account "
+ + "GROUP BY account "
+ + "ORDER BY account";
+
+ try (ResultSet resultSet = this.repository.checkedExecute(sql)) {
+ if (resultSet == null)
+ return rewardShareCreators;
+
+ do {
+ String address = resultSet.getString(1);
+
+ rewardShareCreators.add(address);
+ } while (resultSet.next());
+
+ return rewardShareCreators;
+ } catch (SQLException e) {
+ throw new DataException("Unable to fetch reward share creators from repository", e);
+ }
+ }
+
@Override
public List getApprovalPendingTransactions(Integer txGroupId, Integer limit, Integer offset, Boolean reverse) throws DataException {
StringBuilder sql = new StringBuilder(512);
diff --git a/src/main/java/org/qortal/settings/Settings.java b/src/main/java/org/qortal/settings/Settings.java
index acfd0e78..5799bd26 100644
--- a/src/main/java/org/qortal/settings/Settings.java
+++ b/src/main/java/org/qortal/settings/Settings.java
@@ -110,7 +110,13 @@ public class Settings {
/** Maximum number of unconfirmed transactions allowed per account */
private int maxUnconfirmedPerAccount = 25;
/** Max milliseconds into future for accepting new, unconfirmed transactions */
- private int maxTransactionTimestampFuture = 24 * 60 * 60 * 1000; // milliseconds
+ private int maxTransactionTimestampFuture = 30 * 60 * 1000; // milliseconds
+
+ /** Maximum number of CHAT transactions allowed per account in recent timeframe */
+ private int maxRecentChatMessagesPerAccount = 250;
+ /** Maximum age of a CHAT transaction to be considered 'recent' */
+ private long recentChatMessagesMaxAge = 60 * 60 * 1000L; // milliseconds
+
/** Whether we check, fetch and install auto-updates */
private boolean autoUpdateEnabled = true;
/** How long between repository backups (ms), or 0 if disabled. */
@@ -153,7 +159,7 @@ public class Settings {
* This prevents the node from being able to serve older blocks */
private boolean topOnly = false;
/** The amount of recent blocks we should keep when pruning */
- private int pruneBlockLimit = 1450;
+ private int pruneBlockLimit = 6000;
/** How often to attempt AT state pruning (ms). */
private long atStatesPruneInterval = 3219L; // milliseconds
@@ -209,7 +215,7 @@ public class Settings {
public long recoveryModeTimeout = 10 * 60 * 1000L;
/** Minimum peer version number required in order to sync with them */
- private String minPeerVersion = "3.6.3";
+ private String minPeerVersion = "3.8.2";
/** Whether to allow connections with peers below minPeerVersion
* If true, we won't sync with them but they can still sync with us, and will show in the peers list
* If false, sync will be blocked both ways, and they will not appear in the peers list */
@@ -267,7 +273,7 @@ public class Settings {
private String[] bootstrapHosts = new String[] {
"http://bootstrap.qortal.org",
"http://bootstrap2.qortal.org",
- "http://62.171.190.193"
+ "http://bootstrap.qortal.online"
};
// Auto-update sources
@@ -640,6 +646,14 @@ public class Settings {
return this.maxTransactionTimestampFuture;
}
+ public int getMaxRecentChatMessagesPerAccount() {
+ return this.maxRecentChatMessagesPerAccount;
+ }
+
+ public long getRecentChatMessagesMaxAge() {
+ return recentChatMessagesMaxAge;
+ }
+
public int getBlockCacheSize() {
return this.blockCacheSize;
}
diff --git a/src/main/java/org/qortal/transaction/AddGroupAdminTransaction.java b/src/main/java/org/qortal/transaction/AddGroupAdminTransaction.java
index 15dc51bf..f38638c5 100644
--- a/src/main/java/org/qortal/transaction/AddGroupAdminTransaction.java
+++ b/src/main/java/org/qortal/transaction/AddGroupAdminTransaction.java
@@ -2,6 +2,7 @@ package org.qortal.transaction;
import java.util.Collections;
import java.util.List;
+import java.util.Objects;
import org.qortal.account.Account;
import org.qortal.asset.Asset;
@@ -64,15 +65,24 @@ public class AddGroupAdminTransaction extends Transaction {
Account owner = getOwner();
String groupOwner = this.repository.getGroupRepository().getOwner(groupId);
+ boolean groupOwnedByNullAccount = Objects.equals(groupOwner, Group.NULL_OWNER_ADDRESS);
- // Check transaction's public key matches group's current owner
- if (!owner.getAddress().equals(groupOwner))
+ // Require approval if transaction relates to a group owned by the null account
+ if (groupOwnedByNullAccount && !this.needsGroupApproval())
+ return ValidationResult.GROUP_APPROVAL_REQUIRED;
+
+ // Check transaction's public key matches group's current owner (except for groups owned by the null account)
+ if (!groupOwnedByNullAccount && !owner.getAddress().equals(groupOwner))
return ValidationResult.INVALID_GROUP_OWNER;
// Check address is a group member
if (!this.repository.getGroupRepository().memberExists(groupId, memberAddress))
return ValidationResult.NOT_GROUP_MEMBER;
+ // Check transaction creator is a group member
+ if (!this.repository.getGroupRepository().memberExists(groupId, this.getCreator().getAddress()))
+ return ValidationResult.NOT_GROUP_MEMBER;
+
// Check group member is not already an admin
if (this.repository.getGroupRepository().adminExists(groupId, memberAddress))
return ValidationResult.ALREADY_GROUP_ADMIN;
diff --git a/src/main/java/org/qortal/transaction/ArbitraryTransaction.java b/src/main/java/org/qortal/transaction/ArbitraryTransaction.java
index ca5ce517..50d8ccad 100644
--- a/src/main/java/org/qortal/transaction/ArbitraryTransaction.java
+++ b/src/main/java/org/qortal/transaction/ArbitraryTransaction.java
@@ -24,6 +24,7 @@ import org.qortal.transform.Transformer;
import org.qortal.transform.transaction.ArbitraryTransactionTransformer;
import org.qortal.transform.transaction.TransactionTransformer;
import org.qortal.utils.ArbitraryTransactionUtils;
+import org.qortal.utils.NTP;
public class ArbitraryTransaction extends Transaction {
@@ -34,9 +35,13 @@ public class ArbitraryTransaction extends Transaction {
public static final int MAX_DATA_SIZE = 4000;
public static final int MAX_METADATA_LENGTH = 32;
public static final int HASH_LENGTH = TransactionTransformer.SHA256_LENGTH;
- public static final int POW_BUFFER_SIZE = 8 * 1024 * 1024; // bytes
public static final int MAX_IDENTIFIER_LENGTH = 64;
+ /** If time difference between transaction and now is greater than this then we don't verify proof-of-work. */
+ public static final long HISTORIC_THRESHOLD = 2 * 7 * 24 * 60 * 60 * 1000L;
+ public static final int POW_BUFFER_SIZE = 8 * 1024 * 1024; // bytes
+
+
// Constructors
public ArbitraryTransaction(Repository repository, TransactionData transactionData) {
@@ -202,9 +207,11 @@ public class ArbitraryTransaction extends Transaction {
// Clear nonce from transactionBytes
ArbitraryTransactionTransformer.clearNonce(transactionBytes);
- // Check nonce
- int difficulty = ArbitraryDataManager.getInstance().getPowDifficulty();
- return MemoryPoW.verify2(transactionBytes, POW_BUFFER_SIZE, difficulty, nonce);
+ // We only need to check nonce for recent transactions due to PoW verification overhead
+ if (NTP.getTime() - this.arbitraryTransactionData.getTimestamp() < HISTORIC_THRESHOLD) {
+ int difficulty = ArbitraryDataManager.getInstance().getPowDifficulty();
+ return MemoryPoW.verify2(transactionBytes, POW_BUFFER_SIZE, difficulty, nonce);
+ }
}
return true;
diff --git a/src/main/java/org/qortal/transaction/CancelGroupBanTransaction.java b/src/main/java/org/qortal/transaction/CancelGroupBanTransaction.java
index 483dfc6f..08d9cb3e 100644
--- a/src/main/java/org/qortal/transaction/CancelGroupBanTransaction.java
+++ b/src/main/java/org/qortal/transaction/CancelGroupBanTransaction.java
@@ -73,7 +73,7 @@ public class CancelGroupBanTransaction extends Transaction {
Account member = getMember();
// Check ban actually exists
- if (!this.repository.getGroupRepository().banExists(groupId, member.getAddress()))
+ if (!this.repository.getGroupRepository().banExists(groupId, member.getAddress(), this.groupUnbanTransactionData.getTimestamp()))
return ValidationResult.BAN_UNKNOWN;
// Check admin has enough funds
diff --git a/src/main/java/org/qortal/transaction/ChatTransaction.java b/src/main/java/org/qortal/transaction/ChatTransaction.java
index 9cccd42a..5ed96494 100644
--- a/src/main/java/org/qortal/transaction/ChatTransaction.java
+++ b/src/main/java/org/qortal/transaction/ChatTransaction.java
@@ -1,7 +1,9 @@
package org.qortal.transaction;
+import java.util.Arrays;
import java.util.Collections;
import java.util.List;
+import java.util.function.Predicate;
import org.qortal.account.Account;
import org.qortal.account.PublicKeyAccount;
@@ -16,9 +18,11 @@ import org.qortal.list.ResourceListManager;
import org.qortal.repository.DataException;
import org.qortal.repository.GroupRepository;
import org.qortal.repository.Repository;
+import org.qortal.settings.Settings;
import org.qortal.transform.TransformationException;
import org.qortal.transform.transaction.ChatTransactionTransformer;
import org.qortal.transform.transaction.TransactionTransformer;
+import org.qortal.utils.NTP;
public class ChatTransaction extends Transaction {
@@ -26,10 +30,11 @@ public class ChatTransaction extends Transaction {
private ChatTransactionData chatTransactionData;
// Other useful constants
- public static final int MAX_DATA_SIZE = 1024;
+ public static final int MAX_DATA_SIZE = 4000;
public static final int POW_BUFFER_SIZE = 8 * 1024 * 1024; // bytes
- public static final int POW_DIFFICULTY_WITH_QORT = 8; // leading zero bits
- public static final int POW_DIFFICULTY_NO_QORT = 12; // leading zero bits
+ public static final int POW_DIFFICULTY_ABOVE_QORT_THRESHOLD = 8; // leading zero bits
+ public static final int POW_DIFFICULTY_BELOW_QORT_THRESHOLD = 18; // leading zero bits
+ public static final long POW_QORT_THRESHOLD = 400000000L;
// Constructors
@@ -78,7 +83,7 @@ public class ChatTransaction extends Transaction {
// Clear nonce from transactionBytes
ChatTransactionTransformer.clearNonce(transactionBytes);
- int difficulty = this.getSender().getConfirmedBalance(Asset.QORT) > 0 ? POW_DIFFICULTY_WITH_QORT : POW_DIFFICULTY_NO_QORT;
+ int difficulty = this.getSender().getConfirmedBalance(Asset.QORT) >= POW_QORT_THRESHOLD ? POW_DIFFICULTY_ABOVE_QORT_THRESHOLD : POW_DIFFICULTY_BELOW_QORT_THRESHOLD;
// Calculate nonce
this.chatTransactionData.setNonce(MemoryPoW.compute2(transactionBytes, POW_BUFFER_SIZE, difficulty));
@@ -145,6 +150,11 @@ public class ChatTransaction extends Transaction {
public ValidationResult isValid() throws DataException {
// Nonce checking is done via isSignatureValid() as that method is only called once per import
+ // Disregard messages with timestamp too far in the future (we have stricter limits for CHAT transactions)
+ if (this.chatTransactionData.getTimestamp() > NTP.getTime() + (5 * 60 * 1000L)) {
+ return ValidationResult.TIMESTAMP_TOO_NEW;
+ }
+
// Check for blocked author by address
ResourceListManager listManager = ResourceListManager.getInstance();
if (listManager.listContains("blockedAddresses", this.chatTransactionData.getSender(), true)) {
@@ -163,6 +173,14 @@ public class ChatTransaction extends Transaction {
}
}
+ PublicKeyAccount creator = this.getCreator();
+ if (creator == null)
+ return ValidationResult.MISSING_CREATOR;
+
+ // Reject if unconfirmed pile already has X recent CHAT transactions from same creator
+ if (countRecentChatTransactionsByCreator(creator) >= Settings.getInstance().getMaxRecentChatMessagesPerAccount())
+ return ValidationResult.TOO_MANY_UNCONFIRMED;
+
// If we exist in the repository then we've been imported as unconfirmed,
// but we don't want to make it into a block, so return fake non-OK result.
if (this.repository.getTransactionRepository().exists(this.chatTransactionData.getSignature()))
@@ -204,7 +222,7 @@ public class ChatTransaction extends Transaction {
int difficulty;
try {
- difficulty = this.getSender().getConfirmedBalance(Asset.QORT) > 0 ? POW_DIFFICULTY_WITH_QORT : POW_DIFFICULTY_NO_QORT;
+ difficulty = this.getSender().getConfirmedBalance(Asset.QORT) >= POW_QORT_THRESHOLD ? POW_DIFFICULTY_ABOVE_QORT_THRESHOLD : POW_DIFFICULTY_BELOW_QORT_THRESHOLD;
} catch (DataException e) {
return false;
}
@@ -213,6 +231,26 @@ public class ChatTransaction extends Transaction {
return MemoryPoW.verify2(transactionBytes, POW_BUFFER_SIZE, difficulty, nonce);
}
+ private int countRecentChatTransactionsByCreator(PublicKeyAccount creator) throws DataException {
+ List unconfirmedTransactions = repository.getTransactionRepository().getUnconfirmedTransactions();
+ final Long now = NTP.getTime();
+ long recentThreshold = Settings.getInstance().getRecentChatMessagesMaxAge();
+
+ // We only care about chat transactions, and only those that are considered 'recent'
+ Predicate hasSameCreatorAndIsRecentChat = transactionData -> {
+ if (transactionData.getType() != TransactionType.CHAT)
+ return false;
+
+ if (transactionData.getTimestamp() < now - recentThreshold)
+ return false;
+
+ return Arrays.equals(creator.getPublicKey(), transactionData.getCreatorPublicKey());
+ };
+
+ return (int) unconfirmedTransactions.stream().filter(hasSameCreatorAndIsRecentChat).count();
+ }
+
+
/**
* Ensure there's at least a skeleton account so people
* can retrieve sender's public key using address, even if all their messages
diff --git a/src/main/java/org/qortal/transaction/GroupInviteTransaction.java b/src/main/java/org/qortal/transaction/GroupInviteTransaction.java
index f3b08f59..fa5e7b85 100644
--- a/src/main/java/org/qortal/transaction/GroupInviteTransaction.java
+++ b/src/main/java/org/qortal/transaction/GroupInviteTransaction.java
@@ -78,7 +78,7 @@ public class GroupInviteTransaction extends Transaction {
return ValidationResult.ALREADY_GROUP_MEMBER;
// Check invitee is not banned
- if (this.repository.getGroupRepository().banExists(groupId, invitee.getAddress()))
+ if (this.repository.getGroupRepository().banExists(groupId, invitee.getAddress(), this.groupInviteTransactionData.getTimestamp()))
return ValidationResult.BANNED_FROM_GROUP;
// Check creator has enough funds
diff --git a/src/main/java/org/qortal/transaction/JoinGroupTransaction.java b/src/main/java/org/qortal/transaction/JoinGroupTransaction.java
index bc62c629..3061a3fb 100644
--- a/src/main/java/org/qortal/transaction/JoinGroupTransaction.java
+++ b/src/main/java/org/qortal/transaction/JoinGroupTransaction.java
@@ -53,7 +53,7 @@ public class JoinGroupTransaction extends Transaction {
return ValidationResult.ALREADY_GROUP_MEMBER;
// Check member is not banned
- if (this.repository.getGroupRepository().banExists(groupId, joiner.getAddress()))
+ if (this.repository.getGroupRepository().banExists(groupId, joiner.getAddress(), this.joinGroupTransactionData.getTimestamp()))
return ValidationResult.BANNED_FROM_GROUP;
// Check join request doesn't already exist
diff --git a/src/main/java/org/qortal/transaction/PublicizeTransaction.java b/src/main/java/org/qortal/transaction/PublicizeTransaction.java
index c03c8283..76fef00b 100644
--- a/src/main/java/org/qortal/transaction/PublicizeTransaction.java
+++ b/src/main/java/org/qortal/transaction/PublicizeTransaction.java
@@ -4,7 +4,9 @@ import java.util.Collections;
import java.util.List;
import org.qortal.account.Account;
+import org.qortal.account.PublicKeyAccount;
import org.qortal.api.resource.TransactionsResource.ConfirmationStatus;
+import org.qortal.asset.Asset;
import org.qortal.crypto.MemoryPoW;
import org.qortal.data.transaction.PublicizeTransactionData;
import org.qortal.data.transaction.TransactionData;
@@ -26,7 +28,7 @@ public class PublicizeTransaction extends Transaction {
/** If time difference between transaction and now is greater than this then we don't verify proof-of-work. */
public static final long HISTORIC_THRESHOLD = 2 * 7 * 24 * 60 * 60 * 1000L;
public static final int POW_BUFFER_SIZE = 8 * 1024 * 1024; // bytes
- public static final int POW_DIFFICULTY = 15; // leading zero bits
+ public static final int POW_DIFFICULTY = 14; // leading zero bits
// Constructors
@@ -102,6 +104,12 @@ public class PublicizeTransaction extends Transaction {
if (!verifyNonce())
return ValidationResult.INCORRECT_NONCE;
+ // Validate fee if one has been included
+ PublicKeyAccount creator = this.getCreator();
+ if (this.transactionData.getFee() > 0)
+ if (creator.getConfirmedBalance(Asset.QORT) < this.transactionData.getFee())
+ return ValidationResult.NO_BALANCE;
+
return ValidationResult.OK;
}
diff --git a/src/main/java/org/qortal/transaction/RemoveGroupAdminTransaction.java b/src/main/java/org/qortal/transaction/RemoveGroupAdminTransaction.java
index 3e5f1e6d..043b5423 100644
--- a/src/main/java/org/qortal/transaction/RemoveGroupAdminTransaction.java
+++ b/src/main/java/org/qortal/transaction/RemoveGroupAdminTransaction.java
@@ -2,6 +2,7 @@ package org.qortal.transaction;
import java.util.Collections;
import java.util.List;
+import java.util.Objects;
import org.qortal.account.Account;
import org.qortal.asset.Asset;
@@ -65,11 +66,21 @@ public class RemoveGroupAdminTransaction extends Transaction {
return ValidationResult.GROUP_DOES_NOT_EXIST;
Account owner = getOwner();
+ String groupOwner = this.repository.getGroupRepository().getOwner(groupId);
+ boolean groupOwnedByNullAccount = Objects.equals(groupOwner, Group.NULL_OWNER_ADDRESS);
- // Check transaction's public key matches group's current owner
- if (!owner.getAddress().equals(groupData.getOwner()))
+ // Require approval if transaction relates to a group owned by the null account
+ if (groupOwnedByNullAccount && !this.needsGroupApproval())
+ return ValidationResult.GROUP_APPROVAL_REQUIRED;
+
+ // Check transaction's public key matches group's current owner (except for groups owned by the null account)
+ if (!groupOwnedByNullAccount && !owner.getAddress().equals(groupOwner))
return ValidationResult.INVALID_GROUP_OWNER;
+ // Check transaction creator is a group member
+ if (!this.repository.getGroupRepository().memberExists(groupId, this.getCreator().getAddress()))
+ return ValidationResult.NOT_GROUP_MEMBER;
+
Account admin = getAdmin();
// Check member is an admin
diff --git a/src/main/java/org/qortal/transaction/RewardShareTransaction.java b/src/main/java/org/qortal/transaction/RewardShareTransaction.java
index ed5029b2..d4d2434c 100644
--- a/src/main/java/org/qortal/transaction/RewardShareTransaction.java
+++ b/src/main/java/org/qortal/transaction/RewardShareTransaction.java
@@ -163,9 +163,12 @@ public class RewardShareTransaction extends Transaction {
return ValidationResult.SELF_SHARE_EXISTS;
}
- // Fee checking needed if not setting up new self-share
- if (!(isRecipientAlsoMinter && existingRewardShareData == null))
- // Check creator has enough funds
+ // Check creator has enough funds
+ if (this.rewardShareTransactionData.getTimestamp() >= BlockChain.getInstance().getFeeValidationFixTimestamp())
+ if (creator.getConfirmedBalance(Asset.QORT) < this.rewardShareTransactionData.getFee())
+ return ValidationResult.NO_BALANCE;
+
+ else if (!(isRecipientAlsoMinter && existingRewardShareData == null))
if (creator.getConfirmedBalance(Asset.QORT) < this.rewardShareTransactionData.getFee())
return ValidationResult.NO_BALANCE;
diff --git a/src/main/java/org/qortal/transaction/Transaction.java b/src/main/java/org/qortal/transaction/Transaction.java
index b56d48cf..f0e9b3f6 100644
--- a/src/main/java/org/qortal/transaction/Transaction.java
+++ b/src/main/java/org/qortal/transaction/Transaction.java
@@ -1,13 +1,7 @@
package org.qortal.transaction;
import java.math.BigInteger;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Comparator;
-import java.util.EnumSet;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
import java.util.concurrent.locks.ReentrantLock;
import java.util.function.Predicate;
@@ -69,8 +63,8 @@ public abstract class Transaction {
AT(21, false),
CREATE_GROUP(22, true),
UPDATE_GROUP(23, true),
- ADD_GROUP_ADMIN(24, false),
- REMOVE_GROUP_ADMIN(25, false),
+ ADD_GROUP_ADMIN(24, true),
+ REMOVE_GROUP_ADMIN(25, true),
GROUP_BAN(26, false),
CANCEL_GROUP_BAN(27, false),
GROUP_KICK(28, false),
@@ -250,6 +244,8 @@ public abstract class Transaction {
INVALID_TIMESTAMP_SIGNATURE(95),
ADDRESS_BLOCKED(96),
NAME_BLOCKED(97),
+ GROUP_APPROVAL_REQUIRED(98),
+ ACCOUNT_NOT_TRANSFERABLE(99),
INVALID_BUT_OK(999),
NOT_YET_RELEASED(1000);
@@ -760,9 +756,13 @@ public abstract class Transaction {
// Group no longer exists? Possibly due to blockchain orphaning undoing group creation?
return true; // stops tx being included in block but it will eventually expire
+ String groupOwner = this.repository.getGroupRepository().getOwner(txGroupId);
+ boolean groupOwnedByNullAccount = Objects.equals(groupOwner, Group.NULL_OWNER_ADDRESS);
+
// If transaction's creator is group admin (of group with ID txGroupId) then auto-approve
+ // This is disabled for null-owned groups, since these require approval from other admins
PublicKeyAccount creator = this.getCreator();
- if (groupRepository.adminExists(txGroupId, creator.getAddress()))
+ if (!groupOwnedByNullAccount && groupRepository.adminExists(txGroupId, creator.getAddress()))
return false;
return true;
diff --git a/src/main/java/org/qortal/transaction/TransferPrivsTransaction.java b/src/main/java/org/qortal/transaction/TransferPrivsTransaction.java
index f6a9de68..97e67160 100644
--- a/src/main/java/org/qortal/transaction/TransferPrivsTransaction.java
+++ b/src/main/java/org/qortal/transaction/TransferPrivsTransaction.java
@@ -67,6 +67,11 @@ public class TransferPrivsTransaction extends Transaction {
if (getSender().getConfirmedBalance(Asset.QORT) < this.transferPrivsTransactionData.getFee())
return ValidationResult.NO_BALANCE;
+ // Check sender doesn't have a blocksMintedPenalty, as these accounts cannot be transferred
+ AccountData senderAccountData = this.repository.getAccountRepository().getAccount(getSender().getAddress());
+ if (senderAccountData == null || senderAccountData.getBlocksMintedPenalty() != 0)
+ return ValidationResult.ACCOUNT_NOT_TRANSFERABLE;
+
return ValidationResult.OK;
}
diff --git a/src/main/java/org/qortal/transaction/UpdateGroupTransaction.java b/src/main/java/org/qortal/transaction/UpdateGroupTransaction.java
index 9664ccbf..27580430 100644
--- a/src/main/java/org/qortal/transaction/UpdateGroupTransaction.java
+++ b/src/main/java/org/qortal/transaction/UpdateGroupTransaction.java
@@ -103,7 +103,7 @@ public class UpdateGroupTransaction extends Transaction {
Account newOwner = getNewOwner();
// Check new owner is not banned
- if (this.repository.getGroupRepository().banExists(this.updateGroupTransactionData.getGroupId(), newOwner.getAddress()))
+ if (this.repository.getGroupRepository().banExists(this.updateGroupTransactionData.getGroupId(), newOwner.getAddress(), this.updateGroupTransactionData.getTimestamp()))
return ValidationResult.BANNED_FROM_GROUP;
return ValidationResult.OK;
diff --git a/src/main/java/org/qortal/transform/transaction/ChatTransactionTransformer.java b/src/main/java/org/qortal/transform/transaction/ChatTransactionTransformer.java
index 69a9ef5b..b966ed2b 100644
--- a/src/main/java/org/qortal/transform/transaction/ChatTransactionTransformer.java
+++ b/src/main/java/org/qortal/transform/transaction/ChatTransactionTransformer.java
@@ -4,6 +4,7 @@ import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
+import org.qortal.block.BlockChain;
import org.qortal.crypto.Crypto;
import org.qortal.data.transaction.BaseTransactionData;
import org.qortal.data.transaction.ChatTransactionData;
@@ -22,11 +23,13 @@ public class ChatTransactionTransformer extends TransactionTransformer {
private static final int NONCE_LENGTH = INT_LENGTH;
private static final int HAS_RECIPIENT_LENGTH = BOOLEAN_LENGTH;
private static final int RECIPIENT_LENGTH = ADDRESS_LENGTH;
+ private static final int HAS_CHAT_REFERENCE_LENGTH = BOOLEAN_LENGTH;
+ private static final int CHAT_REFERENCE_LENGTH = SIGNATURE_LENGTH;
private static final int DATA_SIZE_LENGTH = INT_LENGTH;
private static final int IS_TEXT_LENGTH = BOOLEAN_LENGTH;
private static final int IS_ENCRYPTED_LENGTH = BOOLEAN_LENGTH;
- private static final int EXTRAS_LENGTH = NONCE_LENGTH + HAS_RECIPIENT_LENGTH + DATA_SIZE_LENGTH + IS_ENCRYPTED_LENGTH + IS_TEXT_LENGTH;
+ private static final int EXTRAS_LENGTH = NONCE_LENGTH + HAS_RECIPIENT_LENGTH + DATA_SIZE_LENGTH + IS_ENCRYPTED_LENGTH + IS_TEXT_LENGTH + HAS_CHAT_REFERENCE_LENGTH;
protected static final TransactionLayout layout;
@@ -77,13 +80,24 @@ public class ChatTransactionTransformer extends TransactionTransformer {
long fee = byteBuffer.getLong();
+ byte[] chatReference = null;
+
+ if (timestamp >= BlockChain.getInstance().getChatReferenceTimestamp()) {
+ boolean hasChatReference = byteBuffer.get() != 0;
+
+ if (hasChatReference) {
+ chatReference = new byte[CHAT_REFERENCE_LENGTH];
+ byteBuffer.get(chatReference);
+ }
+ }
+
byte[] signature = new byte[SIGNATURE_LENGTH];
byteBuffer.get(signature);
BaseTransactionData baseTransactionData = new BaseTransactionData(timestamp, txGroupId, reference, senderPublicKey, fee, signature);
String sender = Crypto.toAddress(senderPublicKey);
- return new ChatTransactionData(baseTransactionData, sender, nonce, recipient, data, isText, isEncrypted);
+ return new ChatTransactionData(baseTransactionData, sender, nonce, recipient, chatReference, data, isText, isEncrypted);
}
public static int getDataLength(TransactionData transactionData) {
@@ -94,6 +108,9 @@ public class ChatTransactionTransformer extends TransactionTransformer {
if (chatTransactionData.getRecipient() != null)
dataLength += RECIPIENT_LENGTH;
+ if (chatTransactionData.getChatReference() != null)
+ dataLength += CHAT_REFERENCE_LENGTH;
+
return dataLength;
}
@@ -124,6 +141,16 @@ public class ChatTransactionTransformer extends TransactionTransformer {
bytes.write(Longs.toByteArray(chatTransactionData.getFee()));
+ if (transactionData.getTimestamp() >= BlockChain.getInstance().getChatReferenceTimestamp()) {
+ // Include chat reference if it's not null
+ if (chatTransactionData.getChatReference() != null) {
+ bytes.write((byte) 1);
+ bytes.write(chatTransactionData.getChatReference());
+ } else {
+ bytes.write((byte) 0);
+ }
+ }
+
if (chatTransactionData.getSignature() != null)
bytes.write(chatTransactionData.getSignature());
diff --git a/src/main/resources/blockchain.json b/src/main/resources/blockchain.json
index 34671c76..46b4b4f9 100644
--- a/src/main/resources/blockchain.json
+++ b/src/main/resources/blockchain.json
@@ -24,6 +24,7 @@
"onlineAccountSignaturesMinLifetime": 43200000,
"onlineAccountSignaturesMaxLifetime": 86400000,
"onlineAccountsModulusV2Timestamp": 1659801600000,
+ "selfSponsorshipAlgoV1SnapshotTimestamp": 1670230000000,
"rewardsByHeight": [
{ "height": 1, "reward": 5.00 },
{ "height": 259201, "reward": 4.75 },
@@ -80,8 +81,15 @@
"transactionV5Timestamp": 1642176000000,
"transactionV6Timestamp": 9999999999999,
"disableReferenceTimestamp": 1655222400000,
- "increaseOnlineAccountsDifficultyTimestamp": 9999999999999
+ "increaseOnlineAccountsDifficultyTimestamp": 9999999999999,
+ "onlineAccountMinterLevelValidationHeight": 1092000,
+ "selfSponsorshipAlgoV1Height": 1092400,
+ "feeValidationFixTimestamp": 1671918000000,
+ "chatReferenceTimestamp": 1674316800000
},
+ "checkpoints": [
+ { "height": 1136300, "signature": "3BbwawEF2uN8Ni5ofpJXkukoU8ctAPxYoFB7whq9pKfBnjfZcpfEJT4R95NvBDoTP8WDyWvsUvbfHbcr9qSZuYpSKZjUQTvdFf6eqznHGEwhZApWfvXu6zjGCxYCp65F4jsVYYJjkzbjmkCg5WAwN5voudngA23kMK6PpTNygapCzXt" }
+ ],
"genesisInfo": {
"version": 4,
"timestamp": "1593450000000",
diff --git a/src/test/java/org/qortal/test/SelfSponsorshipAlgoV1Tests.java b/src/test/java/org/qortal/test/SelfSponsorshipAlgoV1Tests.java
new file mode 100644
index 00000000..397a1bbe
--- /dev/null
+++ b/src/test/java/org/qortal/test/SelfSponsorshipAlgoV1Tests.java
@@ -0,0 +1,1572 @@
+package org.qortal.test;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.qortal.account.Account;
+import org.qortal.account.PrivateKeyAccount;
+import org.qortal.asset.Asset;
+import org.qortal.block.Block;
+import org.qortal.controller.BlockMinter;
+import org.qortal.data.transaction.BaseTransactionData;
+import org.qortal.data.transaction.PaymentTransactionData;
+import org.qortal.data.transaction.TransactionData;
+import org.qortal.data.transaction.TransferPrivsTransactionData;
+import org.qortal.repository.DataException;
+import org.qortal.repository.Repository;
+import org.qortal.repository.RepositoryManager;
+import org.qortal.settings.Settings;
+import org.qortal.test.common.*;
+import org.qortal.test.common.transaction.TestTransaction;
+import org.qortal.transaction.Transaction;
+import org.qortal.transaction.TransferPrivsTransaction;
+import org.qortal.utils.NTP;
+
+import java.util.*;
+
+import static org.junit.Assert.*;
+import static org.qortal.test.common.AccountUtils.fee;
+import static org.qortal.transaction.Transaction.ValidationResult.*;
+
+public class SelfSponsorshipAlgoV1Tests extends Common {
+
+
+ @Before
+ public void beforeTest() throws DataException {
+ Common.useSettings("test-settings-v2-self-sponsorship-algo.json");
+ NTP.setFixedOffset(Settings.getInstance().getTestNtpOffset());
+ }
+
+
+ @Test
+ public void testSingleSponsor() throws DataException {
+ try (final Repository repository = RepositoryManager.getRepository()) {
+ final int initialRewardShareCount = repository.getAccountRepository().getRewardShares().size();
+
+ // Alice self share online, and will be used to mint the blocks
+ PrivateKeyAccount aliceSelfShare = Common.getTestAccount(repository, "alice-reward-share");
+ List onlineAccounts = new ArrayList<>();
+ onlineAccounts.add(aliceSelfShare);
+
+ PrivateKeyAccount bobAccount = Common.getTestAccount(repository, "bob");
+
+ // Bob self sponsors 10 accounts
+ List bobSponsees = AccountUtils.generateSponsorshipRewardShares(repository, bobAccount, 10);
+ List bobSponseesOnlineAccounts = AccountUtils.toRewardShares(repository, bobAccount, bobSponsees);
+ onlineAccounts.addAll(bobSponseesOnlineAccounts);
+
+ // Mint blocks
+ Block block = null;
+ for (int i = 0; i <= 1; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ assertEquals(11, block.getBlockData().getOnlineAccountsCount());
+ assertEquals(10, repository.getAccountRepository().getRewardShares().size() - initialRewardShareCount);
+
+ for (PrivateKeyAccount bobSponsee : bobSponsees)
+ assertTrue(new Account(repository, bobSponsee.getAddress()).getLevel() == 0);
+
+ // Mint some blocks, until accounts have leveled up
+ for (int i = 0; i <= 5; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ for (PrivateKeyAccount bobSponsee : bobSponsees)
+ assertTrue(new Account(repository, bobSponsee.getAddress()).getLevel() > 0);
+
+ // Generate self shares so the sponsees can start minting
+ List bobSponseeSelfShares = AccountUtils.generateSelfShares(repository, bobSponsees);
+ onlineAccounts.addAll(bobSponseeSelfShares);
+
+ // Mint blocks
+ for (int i = 0; i <= 1; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ for (PrivateKeyAccount bobSponsee : bobSponsees)
+ assertTrue(new Account(repository, bobSponsee.getAddress()).getConfirmedBalance(Asset.QORT) > 10); // 5 for transaction, 5 for fee
+
+ // Bob then consolidates funds
+ consolidateFunds(repository, bobSponsees, bobAccount);
+
+ // Mint until block 19 (the algo runs at block 20)
+ while (block.getBlockData().getHeight() < 19)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+ assertEquals(19, (int) block.getBlockData().getHeight());
+
+ // Ensure that bob and his sponsees have no penalties
+ List bobAndSponsees = new ArrayList<>(bobSponsees);
+ bobAndSponsees.add(bobAccount);
+ for (PrivateKeyAccount bobSponsee : bobAndSponsees)
+ assertEquals(0, (int) new Account(repository, bobSponsee.getAddress()).getBlocksMintedPenalty());
+
+ // Mint a block, so the algo runs
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ // Ensure that bob and his sponsees now have penalties
+ for (PrivateKeyAccount bobSponsee : bobAndSponsees)
+ assertEquals(-5000000, (int) new Account(repository, bobSponsee.getAddress()).getBlocksMintedPenalty());
+
+ // Ensure that bob and his sponsees are now level 0
+ for (PrivateKeyAccount bobSponsee : bobAndSponsees)
+ assertEquals(0, (int) new Account(repository, bobSponsee.getAddress()).getLevel());
+
+ // Orphan last block
+ BlockUtils.orphanLastBlock(repository);
+
+ // Ensure that bob and his sponsees are now greater than level 0
+ for (PrivateKeyAccount bobSponsee : bobAndSponsees)
+ assertTrue(new Account(repository, bobSponsee.getAddress()).getLevel() > 0);
+
+ // Ensure that bob and his sponsees have no penalties again
+ for (PrivateKeyAccount bobSponsee : bobAndSponsees)
+ assertEquals(0, (int) new Account(repository, bobSponsee.getAddress()).getBlocksMintedPenalty());
+
+ // Run orphan check - this can't be in afterTest() because some tests access the live db
+ Common.orphanCheck();
+ }
+ }
+
+ @Test
+ public void testMultipleSponsors() throws DataException {
+ try (final Repository repository = RepositoryManager.getRepository()) {
+ final int initialRewardShareCount = repository.getAccountRepository().getRewardShares().size();
+
+ // Alice self share online, and will be used to mint the blocks
+ PrivateKeyAccount aliceSelfShare = Common.getTestAccount(repository, "alice-reward-share");
+ List onlineAccounts = new ArrayList<>();
+ onlineAccounts.add(aliceSelfShare);
+
+ PrivateKeyAccount bobAccount = Common.getTestAccount(repository, "bob");
+ PrivateKeyAccount chloeAccount = Common.getTestAccount(repository, "chloe");
+ PrivateKeyAccount dilbertAccount = Common.getTestAccount(repository, "dilbert");
+
+ // Bob sponsors 10 accounts
+ List bobSponsees = AccountUtils.generateSponsorshipRewardShares(repository, bobAccount, 10);
+ List bobSponseesOnlineAccounts = AccountUtils.toRewardShares(repository, bobAccount, bobSponsees);
+ onlineAccounts.addAll(bobSponseesOnlineAccounts);
+
+ // Chloe sponsors 10 accounts
+ List chloeSponsees = AccountUtils.generateSponsorshipRewardShares(repository, chloeAccount, 10);
+ List chloeSponseesOnlineAccounts = AccountUtils.toRewardShares(repository, chloeAccount, chloeSponsees);
+ onlineAccounts.addAll(chloeSponseesOnlineAccounts);
+
+ // Dilbert sponsors 5 accounts
+ List dilbertSponsees = AccountUtils.generateSponsorshipRewardShares(repository, dilbertAccount, 5);
+ List dilbertSponseesOnlineAccounts = AccountUtils.toRewardShares(repository, dilbertAccount, dilbertSponsees);
+ onlineAccounts.addAll(dilbertSponseesOnlineAccounts);
+
+ // Mint blocks
+ Block block = null;
+ for (int i = 0; i <= 1; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ assertEquals(26, block.getBlockData().getOnlineAccountsCount());
+ assertEquals(25, repository.getAccountRepository().getRewardShares().size() - initialRewardShareCount);
+
+ for (PrivateKeyAccount bobSponsee : bobSponsees)
+ assertTrue(new Account(repository, bobSponsee.getAddress()).getLevel() == 0);
+
+ // Mint some blocks, until accounts have leveled up
+ for (int i = 0; i <= 5; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ for (PrivateKeyAccount bobSponsee : bobSponsees)
+ assertTrue(new Account(repository, bobSponsee.getAddress()).getLevel() > 0);
+
+ // Generate self shares so the sponsees can start minting
+ List bobSponseeSelfShares = AccountUtils.generateSelfShares(repository, bobSponsees);
+ onlineAccounts.addAll(bobSponseeSelfShares);
+
+ // Mint blocks
+ for (int i = 0; i <= 1; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ for (PrivateKeyAccount bobSponsee : bobSponsees)
+ assertTrue(new Account(repository, bobSponsee.getAddress()).getConfirmedBalance(Asset.QORT) > 10); // 5 for transaction, 5 for fee
+
+ // Bob then consolidates funds
+ consolidateFunds(repository, bobSponsees, bobAccount);
+
+ // Mint until block 19 (the algo runs at block 20)
+ while (block.getBlockData().getHeight() < 19)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+ assertEquals(19, (int) block.getBlockData().getHeight());
+
+ // Ensure that bob and his sponsees have no penalties
+ List bobAndSponsees = new ArrayList<>(bobSponsees);
+ bobAndSponsees.add(bobAccount);
+ for (PrivateKeyAccount bobSponsee : bobAndSponsees)
+ assertEquals(0, (int) new Account(repository, bobSponsee.getAddress()).getBlocksMintedPenalty());
+
+ assertEquals(6, (int)dilbertAccount.getLevel());
+
+ // Mint a block, so the algo runs
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ // Ensure that bob and his sponsees now have penalties
+ for (PrivateKeyAccount bobSponsee : bobAndSponsees)
+ assertEquals(-5000000, (int) new Account(repository, bobSponsee.getAddress()).getBlocksMintedPenalty());
+
+ // Ensure that chloe and her sponsees have no penalties
+ List chloeAndSponsees = new ArrayList<>(chloeSponsees);
+ chloeAndSponsees.add(chloeAccount);
+ for (PrivateKeyAccount chloeSponsee : chloeAndSponsees)
+ assertEquals(0, (int) new Account(repository, chloeSponsee.getAddress()).getBlocksMintedPenalty());
+
+ // Ensure that dilbert and his sponsees have no penalties
+ List dilbertAndSponsees = new ArrayList<>(dilbertSponsees);
+ dilbertAndSponsees.add(dilbertAccount);
+ for (PrivateKeyAccount dilbertSponsee : dilbertAndSponsees)
+ assertEquals(0, (int) new Account(repository, dilbertSponsee.getAddress()).getBlocksMintedPenalty());
+
+ // Ensure that bob and his sponsees are now level 0
+ for (PrivateKeyAccount bobSponsee : bobAndSponsees)
+ assertEquals(0, (int) new Account(repository, bobSponsee.getAddress()).getLevel());
+
+ // Orphan last block
+ BlockUtils.orphanLastBlock(repository);
+
+ // Ensure that bob and his sponsees are now greater than level 0
+ for (PrivateKeyAccount bobSponsee : bobAndSponsees)
+ assertTrue(new Account(repository, bobSponsee.getAddress()).getLevel() > 0);
+
+ // Ensure that bob and his sponsees have no penalties again
+ for (PrivateKeyAccount bobSponsee : bobAndSponsees)
+ assertEquals(0, (int) new Account(repository, bobSponsee.getAddress()).getBlocksMintedPenalty());
+
+ // Ensure that chloe and her sponsees still have no penalties
+ for (PrivateKeyAccount chloeSponsee : chloeAndSponsees)
+ assertEquals(0, (int) new Account(repository, chloeSponsee.getAddress()).getBlocksMintedPenalty());
+
+ // Ensure that dilbert and his sponsees still have no penalties
+ for (PrivateKeyAccount dilbertSponsee : dilbertAndSponsees)
+ assertEquals(0, (int) new Account(repository, dilbertSponsee.getAddress()).getBlocksMintedPenalty());
+
+ // Run orphan check - this can't be in afterTest() because some tests access the live db
+ Common.orphanCheck();
+ }
+ }
+
+ @Test
+ public void testMintBlockWithSignerPenalty() throws DataException {
+ try (final Repository repository = RepositoryManager.getRepository()) {
+ final int initialRewardShareCount = repository.getAccountRepository().getRewardShares().size();
+
+ List onlineAccountsAliceSigner = new ArrayList<>();
+ List onlineAccountsBobSigner = new ArrayList<>();
+
+ // Alice self share online, and will be used to mint (some of) the blocks
+ PrivateKeyAccount aliceSelfShare = Common.getTestAccount(repository, "alice-reward-share");
+ onlineAccountsAliceSigner.add(aliceSelfShare);
+
+ // Bob self share online, and will be used to mint (some of) the blocks
+ PrivateKeyAccount bobSelfShare = Common.getTestAccount(repository, "bob-reward-share");
+ onlineAccountsBobSigner.add(bobSelfShare);
+
+ // Include Alice and Bob's online accounts in each other's arrays
+ onlineAccountsAliceSigner.add(bobSelfShare);
+ onlineAccountsBobSigner.add(aliceSelfShare);
+
+ PrivateKeyAccount bobAccount = Common.getTestAccount(repository, "bob");
+ PrivateKeyAccount chloeAccount = Common.getTestAccount(repository, "chloe");
+ PrivateKeyAccount dilbertAccount = Common.getTestAccount(repository, "dilbert");
+
+ // Bob sponsors 10 accounts
+ List bobSponsees = AccountUtils.generateSponsorshipRewardShares(repository, bobAccount, 10);
+ List bobSponseesOnlineAccounts = AccountUtils.toRewardShares(repository, bobAccount, bobSponsees);
+ onlineAccountsAliceSigner.addAll(bobSponseesOnlineAccounts);
+ onlineAccountsBobSigner.addAll(bobSponseesOnlineAccounts);
+
+ // Chloe sponsors 10 accounts
+ List chloeSponsees = AccountUtils.generateSponsorshipRewardShares(repository, chloeAccount, 10);
+ List chloeSponseesOnlineAccounts = AccountUtils.toRewardShares(repository, chloeAccount, chloeSponsees);
+ onlineAccountsAliceSigner.addAll(chloeSponseesOnlineAccounts);
+ onlineAccountsBobSigner.addAll(chloeSponseesOnlineAccounts);
+
+ // Dilbert sponsors 5 accounts
+ List dilbertSponsees = AccountUtils.generateSponsorshipRewardShares(repository, dilbertAccount, 5);
+ List dilbertSponseesOnlineAccounts = AccountUtils.toRewardShares(repository, dilbertAccount, dilbertSponsees);
+ onlineAccountsAliceSigner.addAll(dilbertSponseesOnlineAccounts);
+ onlineAccountsBobSigner.addAll(dilbertSponseesOnlineAccounts);
+
+ // Mint blocks (Bob is the signer)
+ Block block = null;
+ for (int i = 0; i <= 1; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccountsBobSigner.toArray(new PrivateKeyAccount[0]));
+
+ // Get reward share transaction count
+ assertEquals(25, repository.getAccountRepository().getRewardShares().size() - initialRewardShareCount);
+
+ for (PrivateKeyAccount bobSponsee : bobSponsees)
+ assertTrue(new Account(repository, bobSponsee.getAddress()).getLevel() == 0);
+
+ // Mint some blocks, until accounts have leveled up (Bob is the signer)
+ for (int i = 0; i <= 5; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccountsBobSigner.toArray(new PrivateKeyAccount[0]));
+
+ for (PrivateKeyAccount bobSponsee : bobSponsees)
+ assertTrue(new Account(repository, bobSponsee.getAddress()).getLevel() > 0);
+
+ // Generate self shares so the sponsees can start minting
+ List bobSponseeSelfShares = AccountUtils.generateSelfShares(repository, bobSponsees);
+ onlineAccountsAliceSigner.addAll(bobSponseeSelfShares);
+ onlineAccountsBobSigner.addAll(bobSponseeSelfShares);
+
+ // Mint blocks (Bob is the signer)
+ for (int i = 0; i <= 1; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccountsBobSigner.toArray(new PrivateKeyAccount[0]));
+
+ for (PrivateKeyAccount bobSponsee : bobSponsees)
+ assertTrue(new Account(repository, bobSponsee.getAddress()).getConfirmedBalance(Asset.QORT) > 10); // 5 for transaction, 5 for fee
+
+ // Bob then consolidates funds
+ consolidateFunds(repository, bobSponsees, bobAccount);
+
+ // Mint until block 19 (the algo runs at block 20) (Bob is the signer)
+ while (block.getBlockData().getHeight() < 19)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccountsBobSigner.toArray(new PrivateKeyAccount[0]));
+ assertEquals(19, (int) block.getBlockData().getHeight());
+
+ // Ensure that bob and his sponsees have no penalties
+ List bobAndSponsees = new ArrayList<>(bobSponsees);
+ bobAndSponsees.add(bobAccount);
+ for (PrivateKeyAccount bobSponsee : bobAndSponsees)
+ assertEquals(0, (int) new Account(repository, bobSponsee.getAddress()).getBlocksMintedPenalty());
+
+ // Mint a block, so the algo runs (Bob is the signer)
+ // Block should be valid, because new account levels don't take effect until next block's validation
+ block = BlockMinter.mintTestingBlock(repository, onlineAccountsBobSigner.toArray(new PrivateKeyAccount[0]));
+
+ // Ensure that bob and his sponsees now have penalties
+ for (PrivateKeyAccount bobSponsee : bobAndSponsees)
+ assertEquals(-5000000, (int) new Account(repository, bobSponsee.getAddress()).getBlocksMintedPenalty());
+
+ // Ensure that bob and his sponsees are now level 0
+ for (PrivateKeyAccount bobSponsee : bobAndSponsees)
+ assertEquals(0, (int) new Account(repository, bobSponsee.getAddress()).getLevel());
+
+ // Mint a block, but Bob is now an invalid signer because he is level 0
+ block = BlockMinter.mintTestingBlockUnvalidated(repository, onlineAccountsBobSigner.toArray(new PrivateKeyAccount[0]));
+ // Block should be null as it's unable to be minted
+ assertNull(block);
+
+ // Mint the same block with Alice as the signer, and this time it should be valid
+ block = BlockMinter.mintTestingBlock(repository, onlineAccountsAliceSigner.toArray(new PrivateKeyAccount[0]));
+ // Block should NOT be null
+ assertNotNull(block);
+
+ // Run orphan check - this can't be in afterTest() because some tests access the live db
+ Common.orphanCheck();
+ }
+ }
+
+ @Test
+ public void testMintBlockWithFounderSignerPenalty() throws DataException {
+ try (final Repository repository = RepositoryManager.getRepository()) {
+ final int initialRewardShareCount = repository.getAccountRepository().getRewardShares().size();
+
+ List onlineAccountsAliceSigner = new ArrayList<>();
+ List onlineAccountsBobSigner = new ArrayList<>();
+
+ // Alice self share online, and will be used to mint (some of) the blocks
+ PrivateKeyAccount aliceSelfShare = Common.getTestAccount(repository, "alice-reward-share");
+ onlineAccountsAliceSigner.add(aliceSelfShare);
+
+ // Bob self share online, and will be used to mint (some of) the blocks
+ PrivateKeyAccount bobSelfShare = Common.getTestAccount(repository, "bob-reward-share");
+ onlineAccountsBobSigner.add(bobSelfShare);
+
+ // Include Alice and Bob's online accounts in each other's arrays
+ onlineAccountsAliceSigner.add(bobSelfShare);
+ onlineAccountsBobSigner.add(aliceSelfShare);
+
+ PrivateKeyAccount aliceAccount = Common.getTestAccount(repository, "alice");
+ PrivateKeyAccount bobAccount = Common.getTestAccount(repository, "bob");
+
+ // Alice sponsors 10 accounts
+ List aliceSponsees = AccountUtils.generateSponsorshipRewardShares(repository, aliceAccount, 10);
+ List aliceSponseesOnlineAccounts = AccountUtils.toRewardShares(repository, aliceAccount, aliceSponsees);
+ onlineAccountsAliceSigner.addAll(aliceSponseesOnlineAccounts);
+ onlineAccountsBobSigner.addAll(aliceSponseesOnlineAccounts);
+
+ // Bob sponsors 9 accounts
+ List bobSponsees = AccountUtils.generateSponsorshipRewardShares(repository, bobAccount, 9);
+ List bobSponseesOnlineAccounts = AccountUtils.toRewardShares(repository, bobAccount, bobSponsees);
+ onlineAccountsAliceSigner.addAll(bobSponseesOnlineAccounts);
+ onlineAccountsBobSigner.addAll(bobSponseesOnlineAccounts);
+
+ // Mint blocks (Bob is the signer)
+ Block block = null;
+ for (int i = 0; i <= 1; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccountsAliceSigner.toArray(new PrivateKeyAccount[0]));
+
+ // Get reward share transaction count
+ assertEquals(19, repository.getAccountRepository().getRewardShares().size() - initialRewardShareCount);
+
+ for (PrivateKeyAccount aliceSponsee : aliceSponsees)
+ assertTrue(new Account(repository, aliceSponsee.getAddress()).getLevel() == 0);
+
+ // Mint some blocks, until accounts have leveled up (Alice is the signer)
+ for (int i = 0; i <= 5; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccountsAliceSigner.toArray(new PrivateKeyAccount[0]));
+
+ for (PrivateKeyAccount aliceSponsee : aliceSponsees)
+ assertTrue(new Account(repository, aliceSponsee.getAddress()).getLevel() > 0);
+
+ // Generate self shares so the sponsees can start minting
+ List aliceSponseeSelfShares = AccountUtils.generateSelfShares(repository, aliceSponsees);
+ onlineAccountsAliceSigner.addAll(aliceSponseeSelfShares);
+ onlineAccountsBobSigner.addAll(aliceSponseeSelfShares);
+
+ // Mint blocks (Bob is the signer)
+ for (int i = 0; i <= 1; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccountsAliceSigner.toArray(new PrivateKeyAccount[0]));
+
+ for (PrivateKeyAccount aliceSponsee : aliceSponsees)
+ assertTrue(new Account(repository, aliceSponsee.getAddress()).getConfirmedBalance(Asset.QORT) > 10); // 5 for transaction, 5 for fee
+
+ // Alice then consolidates funds
+ consolidateFunds(repository, aliceSponsees, aliceAccount);
+
+ // Mint until block 19 (the algo runs at block 20) (Bob is the signer)
+ while (block.getBlockData().getHeight() < 19)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccountsAliceSigner.toArray(new PrivateKeyAccount[0]));
+ assertEquals(19, (int) block.getBlockData().getHeight());
+
+ // Ensure that alice and her sponsees have no penalties
+ List aliceAndSponsees = new ArrayList<>(aliceSponsees);
+ aliceAndSponsees.add(aliceAccount);
+ for (PrivateKeyAccount aliceSponsee : aliceAndSponsees)
+ assertEquals(0, (int) new Account(repository, aliceSponsee.getAddress()).getBlocksMintedPenalty());
+
+ // Mint a block, so the algo runs (Alice is the signer)
+ // Block should be valid, because new account levels don't take effect until next block's validation
+ block = BlockMinter.mintTestingBlock(repository, onlineAccountsAliceSigner.toArray(new PrivateKeyAccount[0]));
+
+ // Ensure that alice and her sponsees now have penalties
+ for (PrivateKeyAccount aliceSponsee : aliceAndSponsees)
+ assertEquals(-5000000, (int) new Account(repository, aliceSponsee.getAddress()).getBlocksMintedPenalty());
+
+ // Ensure that alice and her sponsees are now level 0
+ for (PrivateKeyAccount aliceSponsee : aliceAndSponsees)
+ assertEquals(0, (int) new Account(repository, aliceSponsee.getAddress()).getLevel());
+
+ // Mint a block, but Alice is now an invalid signer because she has lost founder minting abilities
+ block = BlockMinter.mintTestingBlockUnvalidated(repository, onlineAccountsAliceSigner.toArray(new PrivateKeyAccount[0]));
+ // Block should be null as it's unable to be minted
+ assertNull(block);
+
+ // Mint the same block with Bob as the signer, and this time it should be valid
+ block = BlockMinter.mintTestingBlock(repository, onlineAccountsBobSigner.toArray(new PrivateKeyAccount[0]));
+ // Block should NOT be null
+ assertNotNull(block);
+
+ // Run orphan check - this can't be in afterTest() because some tests access the live db
+ Common.orphanCheck();
+ }
+ }
+
+ @Test
+ public void testOnlineAccountsWithPenalties() throws DataException {
+ try (final Repository repository = RepositoryManager.getRepository()) {
+ final int initialRewardShareCount = repository.getAccountRepository().getRewardShares().size();
+
+ // Alice self share online, and will be used to mint the blocks
+ PrivateKeyAccount aliceSelfShare = Common.getTestAccount(repository, "alice-reward-share");
+ List onlineAccounts = new ArrayList<>();
+ onlineAccounts.add(aliceSelfShare);
+
+ // Bob self share online
+ PrivateKeyAccount bobSelfShare = Common.getTestAccount(repository, "bob-reward-share");
+ onlineAccounts.add(bobSelfShare);
+
+ PrivateKeyAccount bobAccount = Common.getTestAccount(repository, "bob");
+ PrivateKeyAccount chloeAccount = Common.getTestAccount(repository, "chloe");
+ PrivateKeyAccount dilbertAccount = Common.getTestAccount(repository, "dilbert");
+
+ // Bob sponsors 10 accounts
+ List bobSponsees = AccountUtils.generateSponsorshipRewardShares(repository, bobAccount, 10);
+ List bobSponseesOnlineAccounts = AccountUtils.toRewardShares(repository, bobAccount, bobSponsees);
+ onlineAccounts.addAll(bobSponseesOnlineAccounts);
+
+ // Chloe sponsors 10 accounts
+ List chloeSponsees = AccountUtils.generateSponsorshipRewardShares(repository, chloeAccount, 10);
+ List chloeSponseesOnlineAccounts = AccountUtils.toRewardShares(repository, chloeAccount, chloeSponsees);
+ onlineAccounts.addAll(chloeSponseesOnlineAccounts);
+
+ // Dilbert sponsors 5 accounts
+ List dilbertSponsees = AccountUtils.generateSponsorshipRewardShares(repository, dilbertAccount, 5);
+ List dilbertSponseesOnlineAccounts = AccountUtils.toRewardShares(repository, dilbertAccount, dilbertSponsees);
+ onlineAccounts.addAll(dilbertSponseesOnlineAccounts);
+
+ // Mint blocks
+ Block block = null;
+ for (int i = 0; i <= 1; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ assertEquals(27, block.getBlockData().getOnlineAccountsCount());
+ assertEquals(25, repository.getAccountRepository().getRewardShares().size() - initialRewardShareCount);
+
+ for (PrivateKeyAccount bobSponsee : bobSponsees)
+ assertTrue(new Account(repository, bobSponsee.getAddress()).getLevel() == 0);
+
+ // Mint some blocks, until accounts have leveled up
+ for (int i = 0; i <= 5; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ for (PrivateKeyAccount bobSponsee : bobSponsees)
+ assertTrue(new Account(repository, bobSponsee.getAddress()).getLevel() > 0);
+
+ // Generate self shares so the sponsees can start minting
+ List bobSponseeSelfShares = AccountUtils.generateSelfShares(repository, bobSponsees);
+ onlineAccounts.addAll(bobSponseeSelfShares);
+
+ // Mint blocks
+ for (int i = 0; i <= 1; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ for (PrivateKeyAccount bobSponsee : bobSponsees)
+ assertTrue(new Account(repository, bobSponsee.getAddress()).getConfirmedBalance(Asset.QORT) > 10); // 5 for transaction, 5 for fee
+
+ // Bob then consolidates funds
+ consolidateFunds(repository, bobSponsees, bobAccount);
+
+ // Mint until block 19 (the algo runs at block 20)
+ while (block.getBlockData().getHeight() < 19)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+ assertEquals(19, (int) block.getBlockData().getHeight());
+
+ // Ensure that bob and his sponsees have no penalties
+ List bobAndSponsees = new ArrayList<>(bobSponsees);
+ bobAndSponsees.add(bobAccount);
+ for (PrivateKeyAccount bobSponsee : bobAndSponsees)
+ assertEquals(0, (int) new Account(repository, bobSponsee.getAddress()).getBlocksMintedPenalty());
+
+ // Ensure that bob and his sponsees are present in block's online accounts
+ assertTrue(areAllAccountsPresentInBlock(bobAndSponsees, block));
+
+ // Ensure that chloe's sponsees are present in block's online accounts
+ assertTrue(areAllAccountsPresentInBlock(chloeSponsees, block));
+
+ // Ensure that dilbert's sponsees are present in block's online accounts
+ assertTrue(areAllAccountsPresentInBlock(dilbertSponsees, block));
+
+ // Mint a block, so the algo runs
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ // Ensure that bob and his sponsees now have penalties
+ for (PrivateKeyAccount bobSponsee : bobAndSponsees)
+ assertEquals(-5000000, (int) new Account(repository, bobSponsee.getAddress()).getBlocksMintedPenalty());
+
+ // Ensure that bob and his sponsees are still present in block's online accounts
+ assertTrue(areAllAccountsPresentInBlock(bobAndSponsees, block));
+
+ // Mint another few blocks
+ while (block.getBlockData().getHeight() < 24)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ assertEquals(24, (int)block.getBlockData().getHeight());
+
+ // Ensure that bob and his sponsees are NOT present in block's online accounts (due to penalties)
+ assertFalse(areAllAccountsPresentInBlock(bobAndSponsees, block));
+
+ // Ensure that chloe's sponsees are still present in block's online accounts
+ assertTrue(areAllAccountsPresentInBlock(chloeSponsees, block));
+
+ // Ensure that dilbert's sponsees are still present in block's online accounts
+ assertTrue(areAllAccountsPresentInBlock(dilbertSponsees, block));
+
+ // Run orphan check - this can't be in afterTest() because some tests access the live db
+ Common.orphanCheck();
+ }
+ }
+
+ @Test
+ public void testFounderOnlineAccountsWithPenalties() throws DataException {
+ try (final Repository repository = RepositoryManager.getRepository()) {
+ final int initialRewardShareCount = repository.getAccountRepository().getRewardShares().size();
+
+ // Bob self share online, and will be used to mint the blocks
+ PrivateKeyAccount bobSelfShare = Common.getTestAccount(repository, "bob-reward-share");
+ List onlineAccounts = new ArrayList<>();
+ onlineAccounts.add(bobSelfShare);
+
+ // Alice self share online
+ PrivateKeyAccount aliceSelfShare = Common.getTestAccount(repository, "alice-reward-share");
+ onlineAccounts.add(aliceSelfShare);
+
+ PrivateKeyAccount aliceAccount = Common.getTestAccount(repository, "alice");
+ PrivateKeyAccount bobAccount = Common.getTestAccount(repository, "bob");
+
+ // Alice sponsors 10 accounts
+ List aliceSponsees = AccountUtils.generateSponsorshipRewardShares(repository, aliceAccount, 10);
+ List aliceSponseesOnlineAccounts = AccountUtils.toRewardShares(repository, aliceAccount, aliceSponsees);
+ onlineAccounts.addAll(aliceSponseesOnlineAccounts);
+ onlineAccounts.addAll(aliceSponseesOnlineAccounts);
+
+ // Bob sponsors 9 accounts
+ List bobSponsees = AccountUtils.generateSponsorshipRewardShares(repository, bobAccount, 9);
+ List bobSponseesOnlineAccounts = AccountUtils.toRewardShares(repository, bobAccount, bobSponsees);
+ onlineAccounts.addAll(bobSponseesOnlineAccounts);
+ onlineAccounts.addAll(bobSponseesOnlineAccounts);
+
+ // Mint blocks (Bob is the signer)
+ Block block = null;
+ for (int i = 0; i <= 1; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ // Get reward share transaction count
+ assertEquals(19, repository.getAccountRepository().getRewardShares().size() - initialRewardShareCount);
+
+ for (PrivateKeyAccount aliceSponsee : aliceSponsees)
+ assertTrue(new Account(repository, aliceSponsee.getAddress()).getLevel() == 0);
+
+ // Mint some blocks, until accounts have leveled up (Alice is the signer)
+ for (int i = 0; i <= 5; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ for (PrivateKeyAccount aliceSponsee : aliceSponsees)
+ assertTrue(new Account(repository, aliceSponsee.getAddress()).getLevel() > 0);
+
+ // Generate self shares so the sponsees can start minting
+ List aliceSponseeSelfShares = AccountUtils.generateSelfShares(repository, aliceSponsees);
+ onlineAccounts.addAll(aliceSponseeSelfShares);
+
+ // Mint blocks (Bob is the signer)
+ for (int i = 0; i <= 1; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ for (PrivateKeyAccount aliceSponsee : aliceSponsees)
+ assertTrue(new Account(repository, aliceSponsee.getAddress()).getConfirmedBalance(Asset.QORT) > 10); // 5 for transaction, 5 for fee
+
+ // Alice then consolidates funds
+ consolidateFunds(repository, aliceSponsees, aliceAccount);
+
+ // Mint until block 19 (the algo runs at block 20) (Bob is the signer)
+ while (block.getBlockData().getHeight() < 19)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+ assertEquals(19, (int) block.getBlockData().getHeight());
+
+ // Ensure that alice and her sponsees have no penalties
+ List aliceAndSponsees = new ArrayList<>(aliceSponsees);
+ aliceAndSponsees.add(aliceAccount);
+ for (PrivateKeyAccount aliceSponsee : aliceAndSponsees)
+ assertEquals(0, (int) new Account(repository, aliceSponsee.getAddress()).getBlocksMintedPenalty());
+
+ // Mint a block, so the algo runs (Alice is the signer)
+ // Block should be valid, because new account levels don't take effect until next block's validation
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ // Ensure that alice and her sponsees now have penalties
+ for (PrivateKeyAccount aliceSponsee : aliceAndSponsees)
+ assertEquals(-5000000, (int) new Account(repository, aliceSponsee.getAddress()).getBlocksMintedPenalty());
+
+ // Ensure that alice and her sponsees are now level 0
+ for (PrivateKeyAccount aliceSponsee : aliceAndSponsees)
+ assertEquals(0, (int) new Account(repository, aliceSponsee.getAddress()).getLevel());
+
+ // Ensure that alice and her sponsees don't have penalties
+ List bobAndSponsees = new ArrayList<>(bobSponsees);
+ bobAndSponsees.add(bobAccount);
+ for (PrivateKeyAccount bobSponsee : bobAndSponsees)
+ assertEquals(0, (int) new Account(repository, bobSponsee.getAddress()).getBlocksMintedPenalty());
+
+ // Ensure that bob and his sponsees are still present in block's online accounts
+ assertTrue(areAllAccountsPresentInBlock(bobAndSponsees, block));
+
+ // Ensure that alice and her sponsees are still present in block's online accounts
+ assertTrue(areAllAccountsPresentInBlock(aliceAndSponsees, block));
+
+ // Mint another few blocks
+ while (block.getBlockData().getHeight() < 24)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ assertEquals(24, (int)block.getBlockData().getHeight());
+
+ // Ensure that alice and her sponsees are NOT present in block's online accounts (due to penalties)
+ assertFalse(areAllAccountsPresentInBlock(aliceAndSponsees, block));
+
+ // Ensure that bob and his sponsees are still present in block's online accounts
+ assertTrue(areAllAccountsPresentInBlock(bobAndSponsees, block));
+
+ // Run orphan check - this can't be in afterTest() because some tests access the live db
+ Common.orphanCheck();
+ }
+ }
+
+ @Test
+ public void testPenaltyAccountCreateRewardShare() throws DataException {
+ try (final Repository repository = RepositoryManager.getRepository()) {
+ final int initialRewardShareCount = repository.getAccountRepository().getRewardShares().size();
+
+ // Alice self share online, and will be used to mint the blocks
+ PrivateKeyAccount aliceSelfShare = Common.getTestAccount(repository, "alice-reward-share");
+ List onlineAccounts = new ArrayList<>();
+ onlineAccounts.add(aliceSelfShare);
+
+ PrivateKeyAccount bobAccount = Common.getTestAccount(repository, "bob");
+ PrivateKeyAccount chloeAccount = Common.getTestAccount(repository, "chloe");
+
+ // Bob sponsors 10 accounts
+ List bobSponsees = AccountUtils.generateSponsorshipRewardShares(repository, bobAccount, 10);
+ List bobSponseesOnlineAccounts = AccountUtils.toRewardShares(repository, bobAccount, bobSponsees);
+ onlineAccounts.addAll(bobSponseesOnlineAccounts);
+
+ // Chloe sponsors 10 accounts
+ List chloeSponsees = AccountUtils.generateSponsorshipRewardShares(repository, chloeAccount, 10);
+ List chloeSponseesOnlineAccounts = AccountUtils.toRewardShares(repository, chloeAccount, chloeSponsees);
+ onlineAccounts.addAll(chloeSponseesOnlineAccounts);
+
+ // Mint blocks
+ Block block = null;
+ for (int i = 0; i <= 1; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ assertEquals(21, block.getBlockData().getOnlineAccountsCount());
+ assertEquals(20, repository.getAccountRepository().getRewardShares().size() - initialRewardShareCount);
+
+ // Mint some blocks, until accounts have leveled up
+ for (int i = 0; i <= 5; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ // Generate self shares so the sponsees can start minting
+ List bobSponseeSelfShares = AccountUtils.generateSelfShares(repository, bobSponsees);
+ onlineAccounts.addAll(bobSponseeSelfShares);
+
+ // Mint blocks
+ for (int i = 0; i <= 1; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ // Bob then consolidates funds
+ consolidateFunds(repository, bobSponsees, bobAccount);
+
+ // Mint until block 19 (the algo runs at block 20)
+ while (block.getBlockData().getHeight() < 19)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+ assertEquals(19, (int) block.getBlockData().getHeight());
+
+ // Bob creates a valid reward share transaction
+ assertEquals(Transaction.ValidationResult.OK, AccountUtils.createRandomRewardShare(repository, bobAccount));
+
+ // Mint a block, so the algo runs
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ // Bob can no longer create a reward share transaction
+ assertEquals(Transaction.ValidationResult.ACCOUNT_CANNOT_REWARD_SHARE, AccountUtils.createRandomRewardShare(repository, bobAccount));
+
+ // ... but Chloe still can
+ assertEquals(Transaction.ValidationResult.OK, AccountUtils.createRandomRewardShare(repository, chloeAccount));
+
+ // Orphan last block
+ BlockUtils.orphanLastBlock(repository);
+
+ // Bob creates another valid reward share transaction
+ assertEquals(Transaction.ValidationResult.OK, AccountUtils.createRandomRewardShare(repository, bobAccount));
+
+ // Run orphan check - this can't be in afterTest() because some tests access the live db
+ Common.orphanCheck();
+ }
+ }
+
+ @Test
+ public void testPenaltyFounderCreateRewardShare() throws DataException {
+ try (final Repository repository = RepositoryManager.getRepository()) {
+ final int initialRewardShareCount = repository.getAccountRepository().getRewardShares().size();
+
+ // Bob self share online, and will be used to mint the blocks
+ PrivateKeyAccount bobSelfShare = Common.getTestAccount(repository, "bob-reward-share");
+ List onlineAccounts = new ArrayList<>();
+ onlineAccounts.add(bobSelfShare);
+
+ PrivateKeyAccount aliceAccount = Common.getTestAccount(repository, "alice");
+ PrivateKeyAccount bobAccount = Common.getTestAccount(repository, "bob");
+
+ // Alice sponsors 10 accounts
+ List aliceSponsees = AccountUtils.generateSponsorshipRewardShares(repository, aliceAccount, 10);
+ List aliceSponseesOnlineAccounts = AccountUtils.toRewardShares(repository, aliceAccount, aliceSponsees);
+ onlineAccounts.addAll(aliceSponseesOnlineAccounts);
+
+ // Bob sponsors 10 accounts
+ List bobSponsees = AccountUtils.generateSponsorshipRewardShares(repository, bobAccount, 10);
+ List bobSponseesOnlineAccounts = AccountUtils.toRewardShares(repository, bobAccount, bobSponsees);
+ onlineAccounts.addAll(bobSponseesOnlineAccounts);
+
+ // Mint blocks
+ Block block = null;
+ for (int i = 0; i <= 1; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ assertEquals(21, block.getBlockData().getOnlineAccountsCount());
+ assertEquals(20, repository.getAccountRepository().getRewardShares().size() - initialRewardShareCount);
+
+ // Mint some blocks, until accounts have leveled up
+ for (int i = 0; i <= 5; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ // Generate self shares so the sponsees can start minting
+ List aliceSponseeSelfShares = AccountUtils.generateSelfShares(repository, aliceSponsees);
+ onlineAccounts.addAll(aliceSponseeSelfShares);
+
+ // Mint blocks
+ for (int i = 0; i <= 1; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ // Alice then consolidates funds
+ consolidateFunds(repository, aliceSponsees, aliceAccount);
+
+ // Mint until block 19 (the algo runs at block 20)
+ while (block.getBlockData().getHeight() < 19)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+ assertEquals(19, (int) block.getBlockData().getHeight());
+
+ // Alice creates a valid reward share transaction
+ assertEquals(Transaction.ValidationResult.OK, AccountUtils.createRandomRewardShare(repository, aliceAccount));
+
+ // Mint a block, so the algo runs
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ // Ensure that alice now has a penalty
+ assertEquals(-5000000, (int) new Account(repository, aliceAccount.getAddress()).getBlocksMintedPenalty());
+
+ // Ensure that alice and her sponsees are now level 0
+ assertEquals(0, (int) new Account(repository, aliceAccount.getAddress()).getLevel());
+
+ // Alice can no longer create a reward share transaction
+ assertEquals(Transaction.ValidationResult.ACCOUNT_CANNOT_REWARD_SHARE, AccountUtils.createRandomRewardShare(repository, aliceAccount));
+
+ // ... but Bob still can
+ assertEquals(Transaction.ValidationResult.OK, AccountUtils.createRandomRewardShare(repository, bobAccount));
+
+ // Orphan last block
+ BlockUtils.orphanLastBlock(repository);
+
+ // Alice creates another valid reward share transaction
+ assertEquals(Transaction.ValidationResult.OK, AccountUtils.createRandomRewardShare(repository, aliceAccount));
+
+ // Run orphan check - this can't be in afterTest() because some tests access the live db
+ Common.orphanCheck();
+ }
+ }
+
+ /**
+ * This is a test to prove that Dilbert levels up from 6 to 7 in the same block that the self
+ * sponsorship algo runs. It is here to give some confidence in the following testPenaltyAccountLevelUp()
+ * test, in which we will test what happens if a penalty is applied or removed in the same block
+ * that an account would otherwise have leveled up. It also gives some confidence that the algo
+ * doesn't affect the levels of unflagged accounts.
+ *
+ * @throws DataException
+ */
+ @Test
+ public void testNonPenaltyAccountLevelUp() throws DataException {
+ try (final Repository repository = RepositoryManager.getRepository()) {
+
+ // Alice self share online, and will be used to mint the blocks
+ PrivateKeyAccount aliceSelfShare = Common.getTestAccount(repository, "alice-reward-share");
+ List onlineAccounts = new ArrayList<>();
+ onlineAccounts.add(aliceSelfShare);
+
+ PrivateKeyAccount dilbertAccount = Common.getTestAccount(repository, "dilbert");
+
+ // Dilbert sponsors 10 accounts
+ List dilbertSponsees = AccountUtils.generateSponsorshipRewardShares(repository, dilbertAccount, 10);
+ List dilbertSponseesOnlineAccounts = AccountUtils.toRewardShares(repository, dilbertAccount, dilbertSponsees);
+ onlineAccounts.addAll(dilbertSponseesOnlineAccounts);
+
+ // Mint blocks
+ Block block = null;
+ for (int i = 0; i <= 1; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ // Mint some blocks, until accounts have leveled up
+ for (int i = 0; i <= 5; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ // Mint blocks
+ for (int i = 0; i <= 1; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ // Mint until block 19 (the algo runs at block 20)
+ while (block.getBlockData().getHeight() < 19)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+ assertEquals(19, (int) block.getBlockData().getHeight());
+
+ // Make sure Dilbert hasn't leveled up yet
+ assertEquals(6, (int)dilbertAccount.getLevel());
+
+ // Mint a block, so the algo runs
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ // Make sure Dilbert has leveled up
+ assertEquals(7, (int)dilbertAccount.getLevel());
+
+ // Orphan last block
+ BlockUtils.orphanLastBlock(repository);
+
+ // Make sure Dilbert has returned to level 6
+ assertEquals(6, (int)dilbertAccount.getLevel());
+
+ // Run orphan check - this can't be in afterTest() because some tests access the live db
+ Common.orphanCheck();
+ }
+ }
+
+ @Test
+ public void testPenaltyAccountLevelUp() throws DataException {
+ try (final Repository repository = RepositoryManager.getRepository()) {
+
+ // Alice self share online, and will be used to mint the blocks
+ PrivateKeyAccount aliceSelfShare = Common.getTestAccount(repository, "alice-reward-share");
+ List onlineAccounts = new ArrayList<>();
+ onlineAccounts.add(aliceSelfShare);
+
+ PrivateKeyAccount dilbertAccount = Common.getTestAccount(repository, "dilbert");
+
+ // Dilbert sponsors 10 accounts
+ List dilbertSponsees = AccountUtils.generateSponsorshipRewardShares(repository, dilbertAccount, 10);
+ List dilbertSponseesOnlineAccounts = AccountUtils.toRewardShares(repository, dilbertAccount, dilbertSponsees);
+ onlineAccounts.addAll(dilbertSponseesOnlineAccounts);
+
+ // Mint blocks
+ Block block = null;
+ for (int i = 0; i <= 1; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ // Mint some blocks, until accounts have leveled up
+ for (int i = 0; i <= 5; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ // Generate self shares so the sponsees can start minting
+ List dilbertSponseeSelfShares = AccountUtils.generateSelfShares(repository, dilbertSponsees);
+ onlineAccounts.addAll(dilbertSponseeSelfShares);
+
+ // Mint blocks
+ for (int i = 0; i <= 1; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ // Dilbert then consolidates funds
+ consolidateFunds(repository, dilbertSponsees, dilbertAccount);
+
+ // Mint until block 19 (the algo runs at block 20)
+ while (block.getBlockData().getHeight() < 19)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+ assertEquals(19, (int) block.getBlockData().getHeight());
+
+ // Make sure Dilbert hasn't leveled up yet
+ assertEquals(6, (int)dilbertAccount.getLevel());
+
+ // Mint a block, so the algo runs
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ // Make sure Dilbert is now level 0 instead of 7 (due to penalty)
+ assertEquals(0, (int)dilbertAccount.getLevel());
+
+ // Orphan last block
+ BlockUtils.orphanLastBlock(repository);
+
+ // Make sure Dilbert has returned to level 6
+ assertEquals(6, (int)dilbertAccount.getLevel());
+
+ // Run orphan check - this can't be in afterTest() because some tests access the live db
+ Common.orphanCheck();
+ }
+ }
+
+ @Test
+ public void testDuplicateSponsors() throws DataException {
+ try (final Repository repository = RepositoryManager.getRepository()) {
+ final int initialRewardShareCount = repository.getAccountRepository().getRewardShares().size();
+
+ // Alice self share online, and will be used to mint the blocks
+ PrivateKeyAccount aliceSelfShare = Common.getTestAccount(repository, "alice-reward-share");
+ List onlineAccounts = new ArrayList<>();
+ onlineAccounts.add(aliceSelfShare);
+
+ PrivateKeyAccount bobAccount = Common.getTestAccount(repository, "bob");
+ PrivateKeyAccount chloeAccount = Common.getTestAccount(repository, "chloe");
+ PrivateKeyAccount dilbertAccount = Common.getTestAccount(repository, "dilbert");
+
+ // Bob sponsors 10 accounts
+ List bobSponsees = AccountUtils.generateSponsorshipRewardShares(repository, bobAccount, 10);
+ List bobSponseesOnlineAccounts = AccountUtils.toRewardShares(repository, bobAccount, bobSponsees);
+ onlineAccounts.addAll(bobSponseesOnlineAccounts);
+
+ // Chloe sponsors THE SAME 10 accounts
+ for (PrivateKeyAccount bobSponsee : bobSponsees) {
+ // Create reward-share
+ TransactionData transactionData = AccountUtils.createRewardShare(repository, chloeAccount, bobSponsee, 0, fee);
+ TransactionUtils.signAndImportValid(repository, transactionData, chloeAccount);
+ }
+ List chloeSponsees = new ArrayList<>(bobSponsees);
+ List chloeSponseesOnlineAccounts = AccountUtils.toRewardShares(repository, chloeAccount, chloeSponsees);
+ onlineAccounts.addAll(chloeSponseesOnlineAccounts);
+
+ // Dilbert sponsors 5 accounts
+ List dilbertSponsees = AccountUtils.generateSponsorshipRewardShares(repository, dilbertAccount, 5);
+ List dilbertSponseesOnlineAccounts = AccountUtils.toRewardShares(repository, dilbertAccount, dilbertSponsees);
+ onlineAccounts.addAll(dilbertSponseesOnlineAccounts);
+
+ // Mint blocks
+ Block block = null;
+ for (int i = 0; i <= 1; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ assertEquals(26, block.getBlockData().getOnlineAccountsCount());
+ assertEquals(25, repository.getAccountRepository().getRewardShares().size() - initialRewardShareCount);
+
+ for (PrivateKeyAccount bobSponsee : bobSponsees)
+ assertTrue(new Account(repository, bobSponsee.getAddress()).getLevel() == 0);
+
+ // Mint some blocks, until accounts have leveled up
+ for (int i = 0; i <= 5; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ for (PrivateKeyAccount bobSponsee : bobSponsees)
+ assertTrue(new Account(repository, bobSponsee.getAddress()).getLevel() > 0);
+
+ // Generate self shares so the sponsees can start minting
+ List bobSponseeSelfShares = AccountUtils.generateSelfShares(repository, bobSponsees);
+ onlineAccounts.addAll(bobSponseeSelfShares);
+
+ // Mint blocks
+ for (int i = 0; i <= 1; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ for (PrivateKeyAccount bobSponsee : bobSponsees)
+ assertTrue(new Account(repository, bobSponsee.getAddress()).getConfirmedBalance(Asset.QORT) > 10); // 5 for transaction, 5 for fee
+
+ // Bob then consolidates funds
+ consolidateFunds(repository, bobSponsees, bobAccount);
+
+ // Mint until block 19 (the algo runs at block 20)
+ while (block.getBlockData().getHeight() < 19)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+ assertEquals(19, (int) block.getBlockData().getHeight());
+
+ // Ensure that bob and his sponsees have no penalties
+ List bobAndSponsees = new ArrayList<>(bobSponsees);
+ bobAndSponsees.add(bobAccount);
+ for (PrivateKeyAccount bobSponsee : bobAndSponsees)
+ assertEquals(0, (int) new Account(repository, bobSponsee.getAddress()).getBlocksMintedPenalty());
+
+ assertEquals(6, (int)dilbertAccount.getLevel());
+
+ // Mint a block, so the algo runs
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ // Ensure that bob and his sponsees now have penalties
+ for (PrivateKeyAccount bobSponsee : bobAndSponsees)
+ assertEquals(-5000000, (int) new Account(repository, bobSponsee.getAddress()).getBlocksMintedPenalty());
+
+ // Ensure that chloe and her sponsees also have penalties, as they relate to the same network of accounts
+ List chloeAndSponsees = new ArrayList<>(chloeSponsees);
+ chloeAndSponsees.add(chloeAccount);
+ for (PrivateKeyAccount chloeSponsee : chloeAndSponsees)
+ assertEquals(-5000000, (int) new Account(repository, chloeSponsee.getAddress()).getBlocksMintedPenalty());
+
+ // Ensure that dilbert and his sponsees have no penalties
+ List dilbertAndSponsees = new ArrayList<>(dilbertSponsees);
+ dilbertAndSponsees.add(dilbertAccount);
+ for (PrivateKeyAccount dilbertSponsee : dilbertAndSponsees)
+ assertEquals(0, (int) new Account(repository, dilbertSponsee.getAddress()).getBlocksMintedPenalty());
+
+ // Ensure that bob and his sponsees are now level 0
+ for (PrivateKeyAccount bobSponsee : bobAndSponsees)
+ assertEquals(0, (int) new Account(repository, bobSponsee.getAddress()).getLevel());
+
+ // Orphan last block
+ BlockUtils.orphanLastBlock(repository);
+
+ // Ensure that bob and his sponsees are now greater than level 0
+ for (PrivateKeyAccount bobSponsee : bobAndSponsees)
+ assertTrue(new Account(repository, bobSponsee.getAddress()).getLevel() > 0);
+
+ // Ensure that bob and his sponsees have no penalties again
+ for (PrivateKeyAccount bobSponsee : bobAndSponsees)
+ assertEquals(0, (int) new Account(repository, bobSponsee.getAddress()).getBlocksMintedPenalty());
+
+ // Ensure that chloe and her sponsees still have no penalties again
+ for (PrivateKeyAccount chloeSponsee : chloeAndSponsees)
+ assertEquals(0, (int) new Account(repository, chloeSponsee.getAddress()).getBlocksMintedPenalty());
+
+ // Ensure that dilbert and his sponsees still have no penalties
+ for (PrivateKeyAccount dilbertSponsee : dilbertAndSponsees)
+ assertEquals(0, (int) new Account(repository, dilbertSponsee.getAddress()).getBlocksMintedPenalty());
+
+ // Run orphan check - this can't be in afterTest() because some tests access the live db
+ Common.orphanCheck();
+ }
+ }
+
+ @Test
+ public void testTransferPrivsBeforeAlgoBlock() throws DataException {
+ try (final Repository repository = RepositoryManager.getRepository()) {
+
+ // Alice self share online, and will be used to mint the blocks
+ PrivateKeyAccount aliceSelfShare = Common.getTestAccount(repository, "alice-reward-share");
+ List onlineAccounts = new ArrayList<>();
+ onlineAccounts.add(aliceSelfShare);
+
+ PrivateKeyAccount bobAccount = Common.getTestAccount(repository, "bob");
+
+ // Bob sponsors 10 accounts
+ List bobSponsees = AccountUtils.generateSponsorshipRewardShares(repository, bobAccount, 10);
+ List bobSponseesOnlineAccounts = AccountUtils.toRewardShares(repository, bobAccount, bobSponsees);
+ onlineAccounts.addAll(bobSponseesOnlineAccounts);
+
+ // Mint blocks
+ Block block = null;
+ for (int i = 0; i <= 1; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ for (PrivateKeyAccount bobSponsee : bobSponsees)
+ assertTrue(new Account(repository, bobSponsee.getAddress()).getLevel() == 0);
+
+ // Mint some blocks, until accounts have leveled up
+ for (int i = 0; i <= 5; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ for (PrivateKeyAccount bobSponsee : bobSponsees)
+ assertTrue(new Account(repository, bobSponsee.getAddress()).getLevel() > 0);
+
+ // Generate self shares so the sponsees can start minting
+ List bobSponseeSelfShares = AccountUtils.generateSelfShares(repository, bobSponsees);
+ onlineAccounts.addAll(bobSponseeSelfShares);
+
+ // Mint blocks
+ for (int i = 0; i <= 1; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ for (PrivateKeyAccount bobSponsee : bobSponsees)
+ assertTrue(new Account(repository, bobSponsee.getAddress()).getConfirmedBalance(Asset.QORT) > 10); // 5 for transaction, 5 for fee
+
+ // Bob then consolidates funds
+ consolidateFunds(repository, bobSponsees, bobAccount);
+
+ // Mint until block 18 (the algo runs at block 20)
+ while (block.getBlockData().getHeight() < 18)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+ assertEquals(18, (int) block.getBlockData().getHeight());
+
+ // Bob then issues a TRANSFER_PRIVS
+ PrivateKeyAccount recipientAccount = randomTransferPrivs(repository, bobAccount);
+
+ // Ensure recipient has no level (actually, no account record) at this point (pre-confirmation)
+ assertNull(recipientAccount.getLevel());
+
+ // Mint another block, so that the TRANSFER_PRIVS confirms
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ // Now ensure that the TRANSFER_PRIVS recipient has inherited Bob's level, and Bob is at level 0
+ assertTrue(recipientAccount.getLevel() > 0);
+ assertEquals(0, (int)bobAccount.getLevel());
+ assertEquals(0, (int) new Account(repository, recipientAccount.getAddress()).getBlocksMintedPenalty());
+
+ // Ensure that bob and his sponsees have no penalties
+ List bobAndSponsees = new ArrayList<>(bobSponsees);
+ bobAndSponsees.add(bobAccount);
+ for (PrivateKeyAccount bobSponsee : bobAndSponsees)
+ assertEquals(0, (int) new Account(repository, bobSponsee.getAddress()).getBlocksMintedPenalty());
+
+ // Ensure that bob's sponsees are greater than level 0
+ // Bob's account won't be, as he has transferred privs
+ for (PrivateKeyAccount bobSponsee : bobSponsees)
+ assertTrue(new Account(repository, bobSponsee.getAddress()).getLevel() > 0);
+
+ // Mint a block, so the algo runs
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ // Ensure that bob and his sponsees now have penalties
+ for (PrivateKeyAccount bobSponsee : bobAndSponsees)
+ assertEquals(-5000000, (int) new Account(repository, bobSponsee.getAddress()).getBlocksMintedPenalty());
+
+ // Ensure that bob and his sponsees are now level 0
+ for (PrivateKeyAccount bobSponsee : bobAndSponsees)
+ assertEquals(0, (int) new Account(repository, bobSponsee.getAddress()).getLevel());
+
+ // Ensure recipient account has penalty too
+ assertEquals(-5000000, (int) new Account(repository, recipientAccount.getAddress()).getBlocksMintedPenalty());
+ assertEquals(0, (int) new Account(repository, recipientAccount.getAddress()).getLevel());
+
+ // TODO: check both recipients' sponsees
+
+ // Orphan last block
+ BlockUtils.orphanLastBlock(repository);
+
+ // Ensure that Bob's sponsees are now greater than level 0
+ for (PrivateKeyAccount bobSponsee : bobSponsees)
+ assertTrue(new Account(repository, bobSponsee.getAddress()).getLevel() > 0);
+
+ // Ensure that bob and his sponsees have no penalties again
+ for (PrivateKeyAccount bobSponsee : bobAndSponsees)
+ assertEquals(0, (int) new Account(repository, bobSponsee.getAddress()).getBlocksMintedPenalty());
+
+ // Ensure recipient account has no penalty again and has a level greater than 0
+ assertEquals(0, (int) new Account(repository, recipientAccount.getAddress()).getBlocksMintedPenalty());
+ assertTrue(new Account(repository, recipientAccount.getAddress()).getLevel() > 0);
+
+ // Run orphan check - this can't be in afterTest() because some tests access the live db
+ Common.orphanCheck();
+ }
+ }
+
+ @Test
+ public void testTransferPrivsInAlgoBlock() throws DataException {
+ try (final Repository repository = RepositoryManager.getRepository()) {
+
+ // Alice self share online, and will be used to mint the blocks
+ PrivateKeyAccount aliceSelfShare = Common.getTestAccount(repository, "alice-reward-share");
+ List onlineAccounts = new ArrayList<>();
+ onlineAccounts.add(aliceSelfShare);
+
+ PrivateKeyAccount bobAccount = Common.getTestAccount(repository, "bob");
+
+ // Bob sponsors 10 accounts
+ List bobSponsees = AccountUtils.generateSponsorshipRewardShares(repository, bobAccount, 10);
+ List bobSponseesOnlineAccounts = AccountUtils.toRewardShares(repository, bobAccount, bobSponsees);
+ onlineAccounts.addAll(bobSponseesOnlineAccounts);
+
+ // Mint blocks
+ Block block = null;
+ for (int i = 0; i <= 1; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ for (PrivateKeyAccount bobSponsee : bobSponsees)
+ assertTrue(new Account(repository, bobSponsee.getAddress()).getLevel() == 0);
+
+ // Mint some blocks, until accounts have leveled up
+ for (int i = 0; i <= 5; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ for (PrivateKeyAccount bobSponsee : bobSponsees)
+ assertTrue(new Account(repository, bobSponsee.getAddress()).getLevel() > 0);
+
+ // Generate self shares so the sponsees can start minting
+ List bobSponseeSelfShares = AccountUtils.generateSelfShares(repository, bobSponsees);
+ onlineAccounts.addAll(bobSponseeSelfShares);
+
+ // Mint blocks
+ for (int i = 0; i <= 1; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ for (PrivateKeyAccount bobSponsee : bobSponsees)
+ assertTrue(new Account(repository, bobSponsee.getAddress()).getConfirmedBalance(Asset.QORT) > 10); // 5 for transaction, 5 for fee
+
+ // Bob then consolidates funds
+ consolidateFunds(repository, bobSponsees, bobAccount);
+
+ // Mint until block 19 (the algo runs at block 20)
+ while (block.getBlockData().getHeight() < 19)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+ assertEquals(19, (int) block.getBlockData().getHeight());
+
+ // Ensure that bob and his sponsees have no penalties
+ List bobAndSponsees = new ArrayList<>(bobSponsees);
+ bobAndSponsees.add(bobAccount);
+ for (PrivateKeyAccount bobSponsee : bobAndSponsees)
+ assertEquals(0, (int) new Account(repository, bobSponsee.getAddress()).getBlocksMintedPenalty());
+
+ // Bob then issues a TRANSFER_PRIVS
+ PrivateKeyAccount recipientAccount = randomTransferPrivs(repository, bobAccount);
+
+ // Ensure recipient has no level (actually, no account record) at this point (pre-confirmation)
+ assertNull(recipientAccount.getLevel());
+
+ // Mint a block, so the algo runs
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ // Now ensure that the TRANSFER_PRIVS recipient has inherited Bob's level, and Bob is at level 0
+ assertTrue(recipientAccount.getLevel() > 0);
+ assertEquals(0, (int)bobAccount.getLevel());
+
+ // Ensure that bob and his sponsees now have penalties
+ for (PrivateKeyAccount bobSponsee : bobAndSponsees)
+ assertEquals(-5000000, (int) new Account(repository, bobSponsee.getAddress()).getBlocksMintedPenalty());
+
+ // Ensure that bob and his sponsees are now level 0
+ for (PrivateKeyAccount bobSponsee : bobAndSponsees)
+ assertEquals(0, (int) new Account(repository, bobSponsee.getAddress()).getLevel());
+
+ // Orphan last block
+ BlockUtils.orphanLastBlock(repository);
+
+ // Ensure recipient has no level again
+ assertNull(recipientAccount.getLevel());
+
+ // Ensure that bob and his sponsees are now greater than level 0
+ for (PrivateKeyAccount bobSponsee : bobAndSponsees)
+ assertTrue(new Account(repository, bobSponsee.getAddress()).getLevel() > 0);
+
+ // Ensure that bob and his sponsees have no penalties again
+ for (PrivateKeyAccount bobSponsee : bobAndSponsees)
+ assertEquals(0, (int) new Account(repository, bobSponsee.getAddress()).getBlocksMintedPenalty());
+
+ // Run orphan check - this can't be in afterTest() because some tests access the live db
+ Common.orphanCheck();
+ }
+ }
+
+ @Test
+ public void testTransferPrivsAfterAlgoBlock() throws DataException {
+ try (final Repository repository = RepositoryManager.getRepository()) {
+
+ // Alice self share online, and will be used to mint the blocks
+ PrivateKeyAccount aliceSelfShare = Common.getTestAccount(repository, "alice-reward-share");
+ List onlineAccounts = new ArrayList<>();
+ onlineAccounts.add(aliceSelfShare);
+
+ PrivateKeyAccount bobAccount = Common.getTestAccount(repository, "bob");
+
+ // Bob sponsors 10 accounts
+ List bobSponsees = AccountUtils.generateSponsorshipRewardShares(repository, bobAccount, 10);
+ List bobSponseesOnlineAccounts = AccountUtils.toRewardShares(repository, bobAccount, bobSponsees);
+ onlineAccounts.addAll(bobSponseesOnlineAccounts);
+
+ // Mint blocks
+ Block block = null;
+ for (int i = 0; i <= 1; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ for (PrivateKeyAccount bobSponsee : bobSponsees)
+ assertTrue(new Account(repository, bobSponsee.getAddress()).getLevel() == 0);
+
+ // Mint some blocks, until accounts have leveled up
+ for (int i = 0; i <= 5; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ for (PrivateKeyAccount bobSponsee : bobSponsees)
+ assertTrue(new Account(repository, bobSponsee.getAddress()).getLevel() > 0);
+
+ // Generate self shares so the sponsees can start minting
+ List bobSponseeSelfShares = AccountUtils.generateSelfShares(repository, bobSponsees);
+ onlineAccounts.addAll(bobSponseeSelfShares);
+
+ // Mint blocks
+ for (int i = 0; i <= 1; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ for (PrivateKeyAccount bobSponsee : bobSponsees)
+ assertTrue(new Account(repository, bobSponsee.getAddress()).getConfirmedBalance(Asset.QORT) > 10); // 5 for transaction, 5 for fee
+
+ // Bob then consolidates funds
+ consolidateFunds(repository, bobSponsees, bobAccount);
+
+ // Mint until block 19 (the algo runs at block 20)
+ while (block.getBlockData().getHeight() < 19)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+ assertEquals(19, (int) block.getBlockData().getHeight());
+
+ // Ensure that bob and his sponsees have no penalties
+ List bobAndSponsees = new ArrayList<>(bobSponsees);
+ bobAndSponsees.add(bobAccount);
+ for (PrivateKeyAccount bobSponsee : bobAndSponsees)
+ assertEquals(0, (int) new Account(repository, bobSponsee.getAddress()).getBlocksMintedPenalty());
+
+ // Mint a block, so the algo runs
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ // Bob then issues a TRANSFER_PRIVS, which should be invalid
+ Transaction transferPrivsTransaction = randomTransferPrivsTransaction(repository, bobAccount);
+ assertEquals(ACCOUNT_NOT_TRANSFERABLE, transferPrivsTransaction.isValid());
+
+ // Orphan last 2 blocks
+ BlockUtils.orphanLastBlock(repository);
+ BlockUtils.orphanLastBlock(repository);
+
+ // TRANSFER_PRIVS should now be valid
+ transferPrivsTransaction = randomTransferPrivsTransaction(repository, bobAccount);
+ assertEquals(OK, transferPrivsTransaction.isValid());
+
+ // Run orphan check - this can't be in afterTest() because some tests access the live db
+ Common.orphanCheck();
+ }
+ }
+
+ @Test
+ public void testDoubleTransferPrivs() throws DataException {
+ try (final Repository repository = RepositoryManager.getRepository()) {
+
+ // Alice self share online, and will be used to mint the blocks
+ PrivateKeyAccount aliceSelfShare = Common.getTestAccount(repository, "alice-reward-share");
+ List onlineAccounts = new ArrayList<>();
+ onlineAccounts.add(aliceSelfShare);
+
+ PrivateKeyAccount bobAccount = Common.getTestAccount(repository, "bob");
+
+ // Bob sponsors 10 accounts
+ List bobSponsees = AccountUtils.generateSponsorshipRewardShares(repository, bobAccount, 10);
+ List bobSponseesOnlineAccounts = AccountUtils.toRewardShares(repository, bobAccount, bobSponsees);
+ onlineAccounts.addAll(bobSponseesOnlineAccounts);
+
+ // Mint blocks
+ Block block = null;
+ for (int i = 0; i <= 1; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ for (PrivateKeyAccount bobSponsee : bobSponsees)
+ assertTrue(new Account(repository, bobSponsee.getAddress()).getLevel() == 0);
+
+ // Mint some blocks, until accounts have leveled up
+ for (int i = 0; i <= 5; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ for (PrivateKeyAccount bobSponsee : bobSponsees)
+ assertTrue(new Account(repository, bobSponsee.getAddress()).getLevel() > 0);
+
+ // Generate self shares so the sponsees can start minting
+ List bobSponseeSelfShares = AccountUtils.generateSelfShares(repository, bobSponsees);
+ onlineAccounts.addAll(bobSponseeSelfShares);
+
+ // Mint blocks
+ for (int i = 0; i <= 1; i++)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ for (PrivateKeyAccount bobSponsee : bobSponsees)
+ assertTrue(new Account(repository, bobSponsee.getAddress()).getConfirmedBalance(Asset.QORT) > 10); // 5 for transaction, 5 for fee
+
+ // Bob then consolidates funds
+ consolidateFunds(repository, bobSponsees, bobAccount);
+
+ // Mint until block 17 (the algo runs at block 20)
+ while (block.getBlockData().getHeight() < 17)
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+ assertEquals(17, (int) block.getBlockData().getHeight());
+
+ // Bob then issues a TRANSFER_PRIVS
+ PrivateKeyAccount recipientAccount1 = randomTransferPrivs(repository, bobAccount);
+
+ // Ensure recipient has no level (actually, no account record) at this point (pre-confirmation)
+ assertNull(recipientAccount1.getLevel());
+
+ // Bob and also sends some QORT to cover future transaction fees
+ // This mints another block, and the TRANSFER_PRIVS confirms
+ AccountUtils.pay(repository, bobAccount, recipientAccount1.getAddress(), 123456789L);
+
+ // Now ensure that the TRANSFER_PRIVS recipient has inherited Bob's level, and Bob is at level 0
+ assertTrue(recipientAccount1.getLevel() > 0);
+ assertEquals(0, (int)bobAccount.getLevel());
+ assertEquals(0, (int) new Account(repository, recipientAccount1.getAddress()).getBlocksMintedPenalty());
+
+ // The recipient account then issues a TRANSFER_PRIVS of their own
+ PrivateKeyAccount recipientAccount2 = randomTransferPrivs(repository, recipientAccount1);
+
+ // Ensure recipientAccount2 has no level at this point (pre-confirmation)
+ assertNull(recipientAccount2.getLevel());
+
+ // Mint another block, so that the TRANSFER_PRIVS confirms
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ // Now ensure that the TRANSFER_PRIVS recipient2 has inherited Bob's level, and recipient1 is at level 0
+ assertTrue(recipientAccount2.getLevel() > 0);
+ assertEquals(0, (int)recipientAccount1.getLevel());
+ assertEquals(0, (int) new Account(repository, recipientAccount2.getAddress()).getBlocksMintedPenalty());
+
+ // Ensure that bob and his sponsees have no penalties
+ List bobAndSponsees = new ArrayList<>(bobSponsees);
+ bobAndSponsees.add(bobAccount);
+ for (PrivateKeyAccount bobSponsee : bobAndSponsees)
+ assertEquals(0, (int) new Account(repository, bobSponsee.getAddress()).getBlocksMintedPenalty());
+
+ // Ensure that bob's sponsees are greater than level 0
+ // Bob's account won't be, as he has transferred privs
+ for (PrivateKeyAccount bobSponsee : bobSponsees)
+ assertTrue(new Account(repository, bobSponsee.getAddress()).getLevel() > 0);
+
+ // Mint a block, so the algo runs
+ block = BlockMinter.mintTestingBlock(repository, onlineAccounts.toArray(new PrivateKeyAccount[0]));
+
+ // Ensure that bob and his sponsees now have penalties
+ for (PrivateKeyAccount bobSponsee : bobAndSponsees)
+ assertEquals(-5000000, (int) new Account(repository, bobSponsee.getAddress()).getBlocksMintedPenalty());
+
+ // Ensure that bob and his sponsees are now level 0
+ for (PrivateKeyAccount bobSponsee : bobAndSponsees)
+ assertEquals(0, (int) new Account(repository, bobSponsee.getAddress()).getLevel());
+
+ // Ensure recipientAccount2 has penalty too
+ assertEquals(-5000000, (int) new Account(repository, recipientAccount2.getAddress()).getBlocksMintedPenalty());
+ assertEquals(0, (int) new Account(repository, recipientAccount2.getAddress()).getLevel());
+
+ // Ensure recipientAccount1 has penalty too
+ assertEquals(-5000000, (int) new Account(repository, recipientAccount1.getAddress()).getBlocksMintedPenalty());
+ assertEquals(0, (int) new Account(repository, recipientAccount1.getAddress()).getLevel());
+
+ // TODO: check recipient's sponsees
+
+ // Orphan last block
+ BlockUtils.orphanLastBlock(repository);
+
+ // Ensure that Bob's sponsees are now greater than level 0
+ for (PrivateKeyAccount bobSponsee : bobSponsees)
+ assertTrue(new Account(repository, bobSponsee.getAddress()).getLevel() > 0);
+
+ // Ensure that bob and his sponsees have no penalties again
+ for (PrivateKeyAccount bobSponsee : bobAndSponsees)
+ assertEquals(0, (int) new Account(repository, bobSponsee.getAddress()).getBlocksMintedPenalty());
+
+ // Ensure recipientAccount1 has no penalty again and is level 0
+ assertEquals(0, (int) new Account(repository, recipientAccount1.getAddress()).getBlocksMintedPenalty());
+ assertEquals(0, (int) new Account(repository, recipientAccount1.getAddress()).getLevel());
+
+ // Ensure recipientAccount2 has no penalty again and has a level greater than 0
+ assertEquals(0, (int) new Account(repository, recipientAccount2.getAddress()).getBlocksMintedPenalty());
+ assertTrue(new Account(repository, recipientAccount2.getAddress()).getLevel() > 0);
+
+ // Run orphan check - this can't be in afterTest() because some tests access the live db
+ Common.orphanCheck();
+ }
+ }
+
+
+
+ private static PrivateKeyAccount randomTransferPrivs(Repository repository, PrivateKeyAccount senderAccount) throws DataException {
+ // Generate random recipient account
+ byte[] randomPrivateKey = new byte[32];
+ new Random().nextBytes(randomPrivateKey);
+ PrivateKeyAccount recipientAccount = new PrivateKeyAccount(repository, randomPrivateKey);
+
+ BaseTransactionData baseTransactionData = new BaseTransactionData(NTP.getTime(), 0, senderAccount.getLastReference(), senderAccount.getPublicKey(), fee, null);
+ TransactionData transactionData = new TransferPrivsTransactionData(baseTransactionData, recipientAccount.getAddress());
+
+ TransactionUtils.signAndImportValid(repository, transactionData, senderAccount);
+
+ return recipientAccount;
+ }
+
+ private static TransferPrivsTransaction randomTransferPrivsTransaction(Repository repository, PrivateKeyAccount senderAccount) throws DataException {
+ // Generate random recipient account
+ byte[] randomPrivateKey = new byte[32];
+ new Random().nextBytes(randomPrivateKey);
+ PrivateKeyAccount recipientAccount = new PrivateKeyAccount(repository, randomPrivateKey);
+
+ BaseTransactionData baseTransactionData = new BaseTransactionData(NTP.getTime(), 0, senderAccount.getLastReference(), senderAccount.getPublicKey(), fee, null);
+ TransactionData transactionData = new TransferPrivsTransactionData(baseTransactionData, recipientAccount.getAddress());
+
+ return new TransferPrivsTransaction(repository, transactionData);
+ }
+
+ private boolean areAllAccountsPresentInBlock(List accounts, Block block) throws DataException {
+ for (PrivateKeyAccount bobSponsee : accounts) {
+ boolean foundOnlineAccountInBlock = false;
+ for (Block.ExpandedAccount expandedAccount : block.getExpandedAccounts()) {
+ if (expandedAccount.getRecipientAccount().getAddress().equals(bobSponsee.getAddress())) {
+ foundOnlineAccountInBlock = true;
+ break;
+ }
+ }
+ if (!foundOnlineAccountInBlock) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ private static void consolidateFunds(Repository repository, List sponsees, PrivateKeyAccount sponsor) throws DataException {
+ for (PrivateKeyAccount sponsee : sponsees) {
+ for (int i = 0; i < 5; i++) {
+ // Generate new payments from sponsee to sponsor
+ TransactionData paymentData = new PaymentTransactionData(TestTransaction.generateBase(sponsee), sponsor.getAddress(), 1);
+ TransactionUtils.signAndImportValid(repository, paymentData, sponsee); // updates paymentData's signature
+ }
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/src/test/java/org/qortal/test/api/BlockApiTests.java b/src/test/java/org/qortal/test/api/BlockApiTests.java
index 47d5318a..23e7b007 100644
--- a/src/test/java/org/qortal/test/api/BlockApiTests.java
+++ b/src/test/java/org/qortal/test/api/BlockApiTests.java
@@ -84,7 +84,7 @@ public class BlockApiTests extends ApiCommon {
@Test
public void testGetBlockRange() {
- assertNotNull(this.blocksResource.getBlockRange(1, 1));
+ assertNotNull(this.blocksResource.getBlockRange(1, 1, false, false));
List testValues = Arrays.asList(null, Integer.valueOf(1));
diff --git a/src/test/java/org/qortal/test/arbitrary/ArbitraryServiceTests.java b/src/test/java/org/qortal/test/arbitrary/ArbitraryServiceTests.java
index e6a51776..96843876 100644
--- a/src/test/java/org/qortal/test/arbitrary/ArbitraryServiceTests.java
+++ b/src/test/java/org/qortal/test/arbitrary/ArbitraryServiceTests.java
@@ -1,11 +1,26 @@
package org.qortal.test.arbitrary;
+import org.apache.commons.lang3.reflect.FieldUtils;
import org.junit.Before;
import org.junit.Test;
+import org.qortal.account.PrivateKeyAccount;
+import org.qortal.arbitrary.ArbitraryDataFile;
+import org.qortal.arbitrary.ArbitraryDataReader;
+import org.qortal.arbitrary.exception.MissingDataException;
import org.qortal.arbitrary.misc.Service;
import org.qortal.arbitrary.misc.Service.ValidationResult;
+import org.qortal.controller.arbitrary.ArbitraryDataManager;
+import org.qortal.data.transaction.ArbitraryTransactionData;
+import org.qortal.data.transaction.RegisterNameTransactionData;
import org.qortal.repository.DataException;
+import org.qortal.repository.Repository;
+import org.qortal.repository.RepositoryManager;
+import org.qortal.test.common.ArbitraryUtils;
import org.qortal.test.common.Common;
+import org.qortal.test.common.TransactionUtils;
+import org.qortal.test.common.transaction.TestTransaction;
+import org.qortal.transaction.RegisterNameTransaction;
+import org.qortal.utils.Base58;
import java.io.IOException;
import java.nio.file.Files;
@@ -117,10 +132,27 @@ public class ArbitraryServiceTests extends Common {
Service service = Service.GIF_REPOSITORY;
assertTrue(service.isValidationRequired());
- // There is an index file in the root
assertEquals(ValidationResult.OK, service.validate(path));
}
+ @Test
+ public void testValidateSingleFileGifRepository() throws IOException {
+ // Generate some random data
+ byte[] data = new byte[1024];
+ new Random().nextBytes(data);
+
+ // Write the data to a single file in a temp path
+ Path path = Files.createTempDirectory("testValidateSingleFileGifRepository");
+ path.toFile().deleteOnExit();
+ Path imagePath = Paths.get(path.toString(), "image1.gif");
+ Files.write(imagePath, data, StandardOpenOption.CREATE);
+
+ Service service = Service.GIF_REPOSITORY;
+ assertTrue(service.isValidationRequired());
+
+ assertEquals(ValidationResult.OK, service.validate(imagePath));
+ }
+
@Test
public void testValidateMultiLayerGifRepository() throws IOException {
// Generate some random data
@@ -140,7 +172,6 @@ public class ArbitraryServiceTests extends Common {
Service service = Service.GIF_REPOSITORY;
assertTrue(service.isValidationRequired());
- // There is an index file in the root
assertEquals(ValidationResult.DIRECTORIES_NOT_ALLOWED, service.validate(path));
}
@@ -151,7 +182,6 @@ public class ArbitraryServiceTests extends Common {
Service service = Service.GIF_REPOSITORY;
assertTrue(service.isValidationRequired());
- // There is an index file in the root
assertEquals(ValidationResult.MISSING_DATA, service.validate(path));
}
@@ -171,8 +201,192 @@ public class ArbitraryServiceTests extends Common {
Service service = Service.GIF_REPOSITORY;
assertTrue(service.isValidationRequired());
- // There is an index file in the root
assertEquals(ValidationResult.INVALID_FILE_EXTENSION, service.validate(path));
}
-}
+ @Test
+ public void testValidatePublishedGifRepository() throws IOException, DataException, MissingDataException, IllegalAccessException {
+ try (final Repository repository = RepositoryManager.getRepository()) {
+
+ // Generate some random data
+ byte[] data = new byte[1024];
+ new Random().nextBytes(data);
+
+ // Write the data to several files in a temp path
+ Path path = Files.createTempDirectory("testValidateGifRepository");
+ path.toFile().deleteOnExit();
+ Files.write(Paths.get(path.toString(), "image1.gif"), data, StandardOpenOption.CREATE);
+ Files.write(Paths.get(path.toString(), "image2.gif"), data, StandardOpenOption.CREATE);
+ Files.write(Paths.get(path.toString(), "image3.gif"), data, StandardOpenOption.CREATE);
+
+ Service service = Service.GIF_REPOSITORY;
+ assertTrue(service.isValidationRequired());
+
+ assertEquals(ValidationResult.OK, service.validate(path));
+
+ PrivateKeyAccount alice = Common.getTestAccount(repository, "alice");
+ String publicKey58 = Base58.encode(alice.getPublicKey());
+ String name = "TEST"; // Can be anything for this test
+ String identifier = "test_identifier";
+
+ // Register the name to Alice
+ RegisterNameTransactionData transactionData = new RegisterNameTransactionData(TestTransaction.generateBase(alice), name, "");
+ transactionData.setFee(new RegisterNameTransaction(null, null).getUnitFee(transactionData.getTimestamp()));
+ TransactionUtils.signAndMint(repository, transactionData, alice);
+
+ // Set difficulty to 1
+ FieldUtils.writeField(ArbitraryDataManager.getInstance(), "powDifficulty", 1, true);
+
+ // Create PUT transaction
+ ArbitraryUtils.createAndMintTxn(repository, publicKey58, path, name, identifier, ArbitraryTransactionData.Method.PUT, service, alice);
+
+ // Build the latest data state for this name, and no exceptions should be thrown because validation passes
+ ArbitraryDataReader arbitraryDataReader1a = new ArbitraryDataReader(name, ArbitraryDataFile.ResourceIdType.NAME, service, identifier);
+ arbitraryDataReader1a.loadSynchronously(true);
+ }
+ }
+
+ @Test
+ public void testValidateQChatAttachment() throws IOException {
+ // Generate some random data
+ byte[] data = new byte[1024];
+ new Random().nextBytes(data);
+
+ // Write the data a single file in a temp path
+ Path path = Files.createTempDirectory("testValidateQChatAttachment");
+ path.toFile().deleteOnExit();
+ Files.write(Paths.get(path.toString(), "document.pdf"), data, StandardOpenOption.CREATE);
+
+ Service service = Service.QCHAT_ATTACHMENT;
+ assertTrue(service.isValidationRequired());
+
+ assertEquals(ValidationResult.OK, service.validate(path));
+ }
+
+ @Test
+ public void testValidateSingleFileQChatAttachment() throws IOException {
+ // Generate some random data
+ byte[] data = new byte[1024];
+ new Random().nextBytes(data);
+
+ // Write the data a single file in a temp path
+ Path path = Files.createTempDirectory("testValidateSingleFileQChatAttachment");
+ path.toFile().deleteOnExit();
+ Path filePath = Paths.get(path.toString(), "document.pdf");
+ Files.write(filePath, data, StandardOpenOption.CREATE);
+
+ Service service = Service.QCHAT_ATTACHMENT;
+ assertTrue(service.isValidationRequired());
+
+ assertEquals(ValidationResult.OK, service.validate(filePath));
+ }
+
+ @Test
+ public void testValidateInvalidQChatAttachmentFileExtension() throws IOException {
+ // Generate some random data
+ byte[] data = new byte[1024];
+ new Random().nextBytes(data);
+
+ // Write the data a single file in a temp path
+ Path path = Files.createTempDirectory("testValidateInvalidQChatAttachmentFileExtension");
+ path.toFile().deleteOnExit();
+ Files.write(Paths.get(path.toString(), "application.exe"), data, StandardOpenOption.CREATE);
+
+ Service service = Service.QCHAT_ATTACHMENT;
+ assertTrue(service.isValidationRequired());
+
+ assertEquals(ValidationResult.INVALID_FILE_EXTENSION, service.validate(path));
+ }
+
+ @Test
+ public void testValidateEmptyQChatAttachment() throws IOException {
+ Path path = Files.createTempDirectory("testValidateEmptyQChatAttachment");
+
+ Service service = Service.QCHAT_ATTACHMENT;
+ assertTrue(service.isValidationRequired());
+
+ assertEquals(ValidationResult.INVALID_FILE_COUNT, service.validate(path));
+ }
+
+ @Test
+ public void testValidateMultiLayerQChatAttachment() throws IOException {
+ // Generate some random data
+ byte[] data = new byte[1024];
+ new Random().nextBytes(data);
+
+ // Write the data to several files in a temp path
+ Path path = Files.createTempDirectory("testValidateMultiLayerQChatAttachment");
+ path.toFile().deleteOnExit();
+ Files.write(Paths.get(path.toString(), "file1.txt"), data, StandardOpenOption.CREATE);
+
+ Path subdirectory = Paths.get(path.toString(), "subdirectory");
+ Files.createDirectories(subdirectory);
+ Files.write(Paths.get(subdirectory.toString(), "file2.txt"), data, StandardOpenOption.CREATE);
+ Files.write(Paths.get(subdirectory.toString(), "file3.txt"), data, StandardOpenOption.CREATE);
+
+ Service service = Service.QCHAT_ATTACHMENT;
+ assertTrue(service.isValidationRequired());
+
+ assertEquals(ValidationResult.DIRECTORIES_NOT_ALLOWED, service.validate(path));
+ }
+
+ @Test
+ public void testValidateMultiFileQChatAttachment() throws IOException {
+ // Generate some random data
+ byte[] data = new byte[1024];
+ new Random().nextBytes(data);
+
+ // Write the data to several files in a temp path
+ Path path = Files.createTempDirectory("testValidateMultiFileQChatAttachment");
+ path.toFile().deleteOnExit();
+ Files.write(Paths.get(path.toString(), "file1.txt"), data, StandardOpenOption.CREATE);
+ Files.write(Paths.get(path.toString(), "file2.txt"), data, StandardOpenOption.CREATE);
+
+ Service service = Service.QCHAT_ATTACHMENT;
+ assertTrue(service.isValidationRequired());
+
+ assertEquals(ValidationResult.INVALID_FILE_COUNT, service.validate(path));
+ }
+
+ @Test
+ public void testValidatePublishedQChatAttachment() throws IOException, DataException, MissingDataException, IllegalAccessException {
+ try (final Repository repository = RepositoryManager.getRepository()) {
+
+ // Generate some random data
+ byte[] data = new byte[1024];
+ new Random().nextBytes(data);
+
+ // Write the data a single file in a temp path
+ Path path = Files.createTempDirectory("testValidateSingleFileQChatAttachment");
+ path.toFile().deleteOnExit();
+ Path filePath = Paths.get(path.toString(), "document.pdf");
+ Files.write(filePath, data, StandardOpenOption.CREATE);
+
+ Service service = Service.QCHAT_ATTACHMENT;
+ assertTrue(service.isValidationRequired());
+
+ assertEquals(ValidationResult.OK, service.validate(filePath));
+
+ PrivateKeyAccount alice = Common.getTestAccount(repository, "alice");
+ String publicKey58 = Base58.encode(alice.getPublicKey());
+ String name = "TEST"; // Can be anything for this test
+ String identifier = "test_identifier";
+
+ // Register the name to Alice
+ RegisterNameTransactionData transactionData = new RegisterNameTransactionData(TestTransaction.generateBase(alice), name, "");
+ transactionData.setFee(new RegisterNameTransaction(null, null).getUnitFee(transactionData.getTimestamp()));
+ TransactionUtils.signAndMint(repository, transactionData, alice);
+
+ // Set difficulty to 1
+ FieldUtils.writeField(ArbitraryDataManager.getInstance(), "powDifficulty", 1, true);
+
+ // Create PUT transaction
+ ArbitraryUtils.createAndMintTxn(repository, publicKey58, filePath, name, identifier, ArbitraryTransactionData.Method.PUT, service, alice);
+
+ // Build the latest data state for this name, and no exceptions should be thrown because validation passes
+ ArbitraryDataReader arbitraryDataReader1a = new ArbitraryDataReader(name, ArbitraryDataFile.ResourceIdType.NAME, service, identifier);
+ arbitraryDataReader1a.loadSynchronously(true);
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/src/test/java/org/qortal/test/common/AccountUtils.java b/src/test/java/org/qortal/test/common/AccountUtils.java
index 0d8baae2..bdfd124b 100644
--- a/src/test/java/org/qortal/test/common/AccountUtils.java
+++ b/src/test/java/org/qortal/test/common/AccountUtils.java
@@ -8,7 +8,6 @@ import java.util.*;
import com.google.common.primitives.Longs;
import org.qortal.account.PrivateKeyAccount;
-import org.qortal.block.BlockChain;
import org.qortal.crypto.Crypto;
import org.qortal.crypto.Qortal25519Extras;
import org.qortal.data.network.OnlineAccountData;
@@ -19,6 +18,7 @@ import org.qortal.data.transaction.TransactionData;
import org.qortal.group.Group;
import org.qortal.repository.DataException;
import org.qortal.repository.Repository;
+import org.qortal.transaction.Transaction;
import org.qortal.transform.Transformer;
import org.qortal.utils.Amounts;
@@ -49,10 +49,10 @@ public class AccountUtils {
public static TransactionData createRewardShare(Repository repository, String minter, String recipient, int sharePercent) throws DataException {
PrivateKeyAccount mintingAccount = Common.getTestAccount(repository, minter);
PrivateKeyAccount recipientAccount = Common.getTestAccount(repository, recipient);
- return createRewardShare(repository, mintingAccount, recipientAccount, sharePercent);
+ return createRewardShare(repository, mintingAccount, recipientAccount, sharePercent, fee);
}
- public static TransactionData createRewardShare(Repository repository, PrivateKeyAccount mintingAccount, PrivateKeyAccount recipientAccount, int sharePercent) throws DataException {
+ public static TransactionData createRewardShare(Repository repository, PrivateKeyAccount mintingAccount, PrivateKeyAccount recipientAccount, int sharePercent, long fee) throws DataException {
byte[] reference = mintingAccount.getLastReference();
long timestamp = repository.getTransactionRepository().fromSignature(reference).getTimestamp() + 1;
@@ -78,7 +78,7 @@ public class AccountUtils {
}
public static byte[] rewardShare(Repository repository, PrivateKeyAccount minterAccount, PrivateKeyAccount recipientAccount, int sharePercent) throws DataException {
- TransactionData transactionData = createRewardShare(repository, minterAccount, recipientAccount, sharePercent);
+ TransactionData transactionData = createRewardShare(repository, minterAccount, recipientAccount, sharePercent, fee);
TransactionUtils.signAndMint(repository, transactionData, minterAccount);
byte[] rewardSharePrivateKey = minterAccount.getRewardSharePrivateKey(recipientAccount.getPublicKey());
@@ -86,6 +86,61 @@ public class AccountUtils {
return rewardSharePrivateKey;
}
+ public static List generateSponsorshipRewardShares(Repository repository, PrivateKeyAccount sponsorAccount, int accountsCount) throws DataException {
+ final int sharePercent = 0;
+ Random random = new Random();
+
+ List sponsees = new ArrayList<>();
+ for (int i = 0; i < accountsCount; i++) {
+
+ // Generate random sponsee account
+ byte[] randomPrivateKey = new byte[32];
+ random.nextBytes(randomPrivateKey);
+ PrivateKeyAccount sponseeAccount = new PrivateKeyAccount(repository, randomPrivateKey);
+ sponsees.add(sponseeAccount);
+
+ // Create reward-share
+ TransactionData transactionData = AccountUtils.createRewardShare(repository, sponsorAccount, sponseeAccount, sharePercent, fee);
+ TransactionUtils.signAndImportValid(repository, transactionData, sponsorAccount);
+ }
+
+ return sponsees;
+ }
+
+ public static Transaction.ValidationResult createRandomRewardShare(Repository repository, PrivateKeyAccount account) throws DataException {
+ // Bob attempts to create a reward share transaction
+ byte[] randomPrivateKey = new byte[32];
+ new Random().nextBytes(randomPrivateKey);
+ PrivateKeyAccount sponseeAccount = new PrivateKeyAccount(repository, randomPrivateKey);
+ TransactionData transactionData = createRewardShare(repository, account, sponseeAccount, 0, fee);
+ return TransactionUtils.signAndImport(repository, transactionData, account);
+ }
+
+ public static List generateSelfShares(Repository repository, List accounts) throws DataException {
+ final int sharePercent = 0;
+
+ for (PrivateKeyAccount account : accounts) {
+ // Create reward-share
+ TransactionData transactionData = createRewardShare(repository, account, account, sharePercent, 0L);
+ TransactionUtils.signAndImportValid(repository, transactionData, account);
+ }
+
+ return toRewardShares(repository, null, accounts);
+ }
+
+ public static List toRewardShares(Repository repository, PrivateKeyAccount parentAccount, List accounts) {
+ List rewardShares = new ArrayList<>();
+
+ for (PrivateKeyAccount account : accounts) {
+ PrivateKeyAccount sponsor = (parentAccount != null) ? parentAccount : account;
+ byte[] rewardSharePrivateKey = sponsor.getRewardSharePrivateKey(account.getPublicKey());
+ PrivateKeyAccount rewardShareAccount = new PrivateKeyAccount(repository, rewardSharePrivateKey);
+ rewardShares.add(rewardShareAccount);
+ }
+
+ return rewardShares;
+ }
+
public static Map> getBalances(Repository repository, long... assetIds) throws DataException {
Map> balances = new HashMap<>();
diff --git a/src/test/java/org/qortal/test/common/Common.java b/src/test/java/org/qortal/test/common/Common.java
index 3270a795..bb6cc1cb 100644
--- a/src/test/java/org/qortal/test/common/Common.java
+++ b/src/test/java/org/qortal/test/common/Common.java
@@ -120,7 +120,9 @@ public class Common {
}
public static void useSettingsAndDb(String settingsFilename, boolean dbInMemory) throws DataException {
- closeRepository();
+ if (RepositoryManager.getRepositoryFactory() != null) {
+ closeRepository();
+ }
// Load/check settings, which potentially sets up blockchain config, etc.
LOGGER.debug(String.format("Using setting file: %s", settingsFilename));
diff --git a/src/test/java/org/qortal/test/common/transaction/ChatTestTransaction.java b/src/test/java/org/qortal/test/common/transaction/ChatTestTransaction.java
new file mode 100644
index 00000000..bab1f1a0
--- /dev/null
+++ b/src/test/java/org/qortal/test/common/transaction/ChatTestTransaction.java
@@ -0,0 +1,40 @@
+package org.qortal.test.common.transaction;
+
+import org.qortal.account.PrivateKeyAccount;
+import org.qortal.crypto.Crypto;
+import org.qortal.data.transaction.ChatTransactionData;
+import org.qortal.data.transaction.TransactionData;
+import org.qortal.repository.DataException;
+import org.qortal.repository.Repository;
+
+import java.util.Random;
+
+public class ChatTestTransaction extends TestTransaction {
+
+ public static TransactionData randomTransaction(Repository repository, PrivateKeyAccount account, boolean wantValid) throws DataException {
+ Random random = new Random();
+ byte[] orderId = new byte[64];
+ random.nextBytes(orderId);
+
+ String sender = Crypto.toAddress(account.getPublicKey());
+ int nonce = 1234567;
+
+ // Generate random recipient
+ byte[] randomPrivateKey = new byte[32];
+ random.nextBytes(randomPrivateKey);
+ PrivateKeyAccount recipientAccount = new PrivateKeyAccount(repository, randomPrivateKey);
+ String recipient = Crypto.toAddress(recipientAccount.getPublicKey());
+
+ byte[] chatReference = new byte[64];
+ random.nextBytes(chatReference);
+
+ byte[] data = new byte[4000];
+ random.nextBytes(data);
+
+ boolean isText = true;
+ boolean isEncrypted = true;
+
+ return new ChatTransactionData(generateBase(account), sender, nonce, recipient, chatReference, data, isText, isEncrypted);
+ }
+
+}
diff --git a/src/test/java/org/qortal/test/group/AdminTests.java b/src/test/java/org/qortal/test/group/AdminTests.java
index a39b23d7..8cf83c29 100644
--- a/src/test/java/org/qortal/test/group/AdminTests.java
+++ b/src/test/java/org/qortal/test/group/AdminTests.java
@@ -135,7 +135,8 @@ public class AdminTests extends Common {
assertNotSame(ValidationResult.OK, result);
// Attempt to ban Bob
- result = groupBan(repository, alice, groupId, bob.getAddress());
+ int timeToLive = 0;
+ result = groupBan(repository, alice, groupId, bob.getAddress(), timeToLive);
// Should be OK
assertEquals(ValidationResult.OK, result);
@@ -158,7 +159,7 @@ public class AdminTests extends Common {
assertTrue(isMember(repository, bob.getAddress(), groupId));
// Attempt to ban Bob
- result = groupBan(repository, alice, groupId, bob.getAddress());
+ result = groupBan(repository, alice, groupId, bob.getAddress(), timeToLive);
// Should be OK
assertEquals(ValidationResult.OK, result);
@@ -205,6 +206,144 @@ public class AdminTests extends Common {
}
}
+ @Test
+ public void testGroupBanMemberWithExpiry() throws DataException, InterruptedException {
+ try (final Repository repository = RepositoryManager.getRepository()) {
+ PrivateKeyAccount alice = Common.getTestAccount(repository, "alice");
+ PrivateKeyAccount bob = Common.getTestAccount(repository, "bob");
+
+ // Create group
+ int groupId = createGroup(repository, alice, "open-group", true);
+
+ // Confirm Bob is not a member
+ assertFalse(isMember(repository, bob.getAddress(), groupId));
+
+ // Attempt to cancel non-existent Bob ban
+ ValidationResult result = cancelGroupBan(repository, alice, groupId, bob.getAddress());
+ // Should NOT be OK
+ assertNotSame(ValidationResult.OK, result);
+
+ // Attempt to ban Bob for 2 seconds
+ int timeToLive = 2;
+ result = groupBan(repository, alice, groupId, bob.getAddress(), timeToLive);
+ // Should be OK
+ assertEquals(ValidationResult.OK, result);
+
+ // Confirm Bob no longer a member
+ assertFalse(isMember(repository, bob.getAddress(), groupId));
+
+ // Bob attempts to rejoin
+ result = joinGroup(repository, bob, groupId);
+ // Should NOT be OK
+ assertNotSame(ValidationResult.OK, result);
+
+ // Wait for 2 seconds to pass
+ Thread.sleep(2000L);
+
+ // Bob attempts to rejoin again
+ result = joinGroup(repository, bob, groupId);
+ // Should be OK, as the ban has expired
+ assertSame(ValidationResult.OK, result);
+
+ // Confirm Bob is now a member
+ assertTrue(isMember(repository, bob.getAddress(), groupId));
+
+ // Orphan last block (Bob join)
+ BlockUtils.orphanLastBlock(repository);
+
+ // Confirm Bob is not a member
+ assertFalse(isMember(repository, bob.getAddress(), groupId));
+
+ // Orphan last block (Bob ban)
+ BlockUtils.orphanLastBlock(repository);
+ // Delete unconfirmed group-ban transaction
+ TransactionUtils.deleteUnconfirmedTransactions(repository);
+
+ // Bob to join
+ result = joinGroup(repository, bob, groupId);
+ // Should be OK
+ assertEquals(ValidationResult.OK, result);
+
+ // Confirm Bob now a member
+ assertTrue(isMember(repository, bob.getAddress(), groupId));
+
+
+ // Attempt to ban Bob for 2 seconds
+ result = groupBan(repository, alice, groupId, bob.getAddress(), 2);
+ // Should be OK
+ assertEquals(ValidationResult.OK, result);
+
+ // Confirm Bob no longer a member
+ assertFalse(isMember(repository, bob.getAddress(), groupId));
+
+ // Wait for 2 seconds to pass
+ Thread.sleep(2000L);
+
+ // Cancel Bob's ban
+ result = cancelGroupBan(repository, alice, groupId, bob.getAddress());
+ // Should NOT be OK, as ban has already expired
+ assertNotSame(ValidationResult.OK, result);
+
+ // Confirm Bob still not a member
+ assertFalse(isMember(repository, bob.getAddress(), groupId));
+
+ // Bob attempts to rejoin
+ result = joinGroup(repository, bob, groupId);
+ // Should be OK, as no longer banned
+ assertSame(ValidationResult.OK, result);
+
+ // Confirm Bob is now a member
+ assertTrue(isMember(repository, bob.getAddress(), groupId));
+
+
+ // Attempt to ban Bob for 10 seconds
+ result = groupBan(repository, alice, groupId, bob.getAddress(), 10);
+ // Should be OK
+ assertEquals(ValidationResult.OK, result);
+
+ // Confirm Bob no longer a member
+ assertFalse(isMember(repository, bob.getAddress(), groupId));
+
+ // Bob attempts to rejoin
+ result = joinGroup(repository, bob, groupId);
+ // Should NOT be OK, as ban still exists
+ assertNotSame(ValidationResult.OK, result);
+
+ // Cancel Bob's ban
+ result = cancelGroupBan(repository, alice, groupId, bob.getAddress());
+ // Should be OK, as ban still exists
+ assertEquals(ValidationResult.OK, result);
+
+ // Bob attempts to rejoin
+ result = joinGroup(repository, bob, groupId);
+ // Should be OK, as no longer banned
+ assertEquals(ValidationResult.OK, result);
+
+ // Orphan last block (Bob join)
+ BlockUtils.orphanLastBlock(repository);
+ // Delete unconfirmed join-group transaction
+ TransactionUtils.deleteUnconfirmedTransactions(repository);
+
+ // Orphan last block (Cancel Bob ban)
+ BlockUtils.orphanLastBlock(repository);
+ // Delete unconfirmed cancel-ban transaction
+ TransactionUtils.deleteUnconfirmedTransactions(repository);
+
+ // Bob attempts to rejoin
+ result = joinGroup(repository, bob, groupId);
+ // Should NOT be OK
+ assertNotSame(ValidationResult.OK, result);
+
+ // Orphan last block (Bob ban)
+ BlockUtils.orphanLastBlock(repository);
+ // Delete unconfirmed group-ban transaction
+ TransactionUtils.deleteUnconfirmedTransactions(repository);
+
+ // Confirm Bob now a member
+ assertTrue(isMember(repository, bob.getAddress(), groupId));
+ }
+ }
+
@Test
public void testGroupBanAdmin() throws DataException {
try (final Repository repository = RepositoryManager.getRepository()) {
@@ -226,7 +365,8 @@ public class AdminTests extends Common {
assertTrue(isAdmin(repository, bob.getAddress(), groupId));
// Attempt to ban Bob
- result = groupBan(repository, alice, groupId, bob.getAddress());
+ int timeToLive = 0;
+ result = groupBan(repository, alice, groupId, bob.getAddress(), timeToLive);
// Should be OK
assertEquals(ValidationResult.OK, result);
@@ -272,12 +412,12 @@ public class AdminTests extends Common {
assertTrue(isAdmin(repository, bob.getAddress(), groupId));
// Have Alice (owner) try to ban herself!
- result = groupBan(repository, alice, groupId, alice.getAddress());
+ result = groupBan(repository, alice, groupId, alice.getAddress(), timeToLive);
// Should NOT be OK
assertNotSame(ValidationResult.OK, result);
// Have Bob try to ban Alice (owner)
- result = groupBan(repository, bob, groupId, alice.getAddress());
+ result = groupBan(repository, bob, groupId, alice.getAddress(), timeToLive);
// Should NOT be OK
assertNotSame(ValidationResult.OK, result);
}
@@ -316,8 +456,8 @@ public class AdminTests extends Common {
return result;
}
- private ValidationResult groupBan(Repository repository, PrivateKeyAccount admin, int groupId, String member) throws DataException {
- GroupBanTransactionData transactionData = new GroupBanTransactionData(TestTransaction.generateBase(admin), groupId, member, "testing", 0);
+ private ValidationResult groupBan(Repository repository, PrivateKeyAccount admin, int groupId, String member, int timeToLive) throws DataException {
+ GroupBanTransactionData transactionData = new GroupBanTransactionData(TestTransaction.generateBase(admin), groupId, member, "testing", timeToLive);
ValidationResult result = TransactionUtils.signAndImport(repository, transactionData, admin);
if (result == ValidationResult.OK)
diff --git a/src/test/java/org/qortal/test/group/DevGroupAdminTests.java b/src/test/java/org/qortal/test/group/DevGroupAdminTests.java
new file mode 100644
index 00000000..131359c6
--- /dev/null
+++ b/src/test/java/org/qortal/test/group/DevGroupAdminTests.java
@@ -0,0 +1,388 @@
+package org.qortal.test.group;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.qortal.account.PrivateKeyAccount;
+import org.qortal.data.transaction.*;
+import org.qortal.group.Group;
+import org.qortal.group.Group.ApprovalThreshold;
+import org.qortal.repository.DataException;
+import org.qortal.repository.Repository;
+import org.qortal.repository.RepositoryManager;
+import org.qortal.test.common.BlockUtils;
+import org.qortal.test.common.Common;
+import org.qortal.test.common.GroupUtils;
+import org.qortal.test.common.TransactionUtils;
+import org.qortal.test.common.transaction.TestTransaction;
+import org.qortal.transaction.Transaction;
+import org.qortal.transaction.Transaction.ValidationResult;
+import org.qortal.utils.Base58;
+
+import static org.junit.Assert.*;
+
+/**
+ * Dev group admin tests
+ *
+ * The dev group (ID 1) is owned by the null account with public key 11111111111111111111111111111111
+ * To regain access to otherwise blocked owner-based rules, it has different validation logic
+ * which applies to groups with this same null owner.
+ *
+ * The main difference is that approval is required for certain transaction types relating to
+ * null-owned groups. This allows existing admins to approve updates to the group (using group's
+ * approval threshold) instead of these actions being performed by the owner.
+ *
+ * Since these apply to all null-owned groups, this allows anyone to update their group to
+ * the null owner if they want to take advantage of this decentralized approval system.
+ *
+ * Currently, the affected transaction types are:
+ * - AddGroupAdminTransaction
+ * - RemoveGroupAdminTransaction
+ *
+ * This same approach could ultimately be applied to other group transactions too.
+ */
+public class DevGroupAdminTests extends Common {
+
+ private static final int DEV_GROUP_ID = 1;
+
+ @Before
+ public void beforeTest() throws DataException {
+ Common.useDefaultSettings();
+ }
+
+ @After
+ public void afterTest() throws DataException {
+ Common.orphanCheck();
+ }
+
+ @Test
+ public void testGroupKickMember() throws DataException {
+ try (final Repository repository = RepositoryManager.getRepository()) {
+ PrivateKeyAccount alice = Common.getTestAccount(repository, "alice");
+ PrivateKeyAccount bob = Common.getTestAccount(repository, "bob");
+
+ // Dev group
+ int groupId = DEV_GROUP_ID;
+
+ // Confirm Bob is not a member
+ assertFalse(isMember(repository, bob.getAddress(), groupId));
+
+ // Attempt to kick Bob
+ ValidationResult result = groupKick(repository, alice, groupId, bob.getAddress());
+ // Should NOT be OK
+ assertNotSame(ValidationResult.OK, result);
+
+ // Alice to invite Bob, as it's a closed group
+ groupInvite(repository, alice, groupId, bob.getAddress(), 3600);
+
+ // Bob to join
+ joinGroup(repository, bob, groupId);
+
+ // Confirm Bob now a member
+ assertTrue(isMember(repository, bob.getAddress(), groupId));
+
+ // Attempt to kick Bob
+ result = groupKick(repository, alice, groupId, bob.getAddress());
+ // Should be OK
+ assertEquals(ValidationResult.OK, result);
+
+ // Confirm Bob no longer a member
+ assertFalse(isMember(repository, bob.getAddress(), groupId));
+
+ // Orphan last block
+ BlockUtils.orphanLastBlock(repository);
+
+ // Confirm Bob now a member
+ assertTrue(isMember(repository, bob.getAddress(), groupId));
+ }
+ }
+
+ @Test
+ public void testGroupKickAdmin() throws DataException {
+ try (final Repository repository = RepositoryManager.getRepository()) {
+ PrivateKeyAccount alice = Common.getTestAccount(repository, "alice");
+ PrivateKeyAccount bob = Common.getTestAccount(repository, "bob");
+
+ // Dev group
+ int groupId = DEV_GROUP_ID;
+
+ // Confirm Bob is not a member
+ assertFalse(isMember(repository, bob.getAddress(), groupId));
+
+ // Alice to invite Bob, as it's a closed group
+ groupInvite(repository, alice, groupId, bob.getAddress(), 3600);
+
+ // Bob to join
+ joinGroup(repository, bob, groupId);
+
+ // Confirm Bob now a member
+ assertTrue(isMember(repository, bob.getAddress(), groupId));
+
+ // Promote Bob to admin
+ TransactionData addGroupAdminTransactionData = addGroupAdmin(repository, alice, groupId, bob.getAddress());
+
+ // Confirm transaction needs approval, and hasn't been approved
+ Transaction.ApprovalStatus approvalStatus = GroupUtils.getApprovalStatus(repository, addGroupAdminTransactionData.getSignature());
+ assertEquals("incorrect transaction approval status", Transaction.ApprovalStatus.PENDING, approvalStatus);
+
+ // Have Alice approve Bob's approval-needed transaction
+ GroupUtils.approveTransaction(repository, "alice", addGroupAdminTransactionData.getSignature(), true);
+
+ // Mint a block so that the transaction becomes approved
+ BlockUtils.mintBlock(repository);
+
+ // Confirm transaction is approved
+ approvalStatus = GroupUtils.getApprovalStatus(repository, addGroupAdminTransactionData.getSignature());
+ assertEquals("incorrect transaction approval status", Transaction.ApprovalStatus.APPROVED, approvalStatus);
+
+ // Confirm Bob is now admin
+ assertTrue(isAdmin(repository, bob.getAddress(), groupId));
+
+ // Attempt to kick Bob
+ ValidationResult result = groupKick(repository, alice, groupId, bob.getAddress());
+ // Shouldn't be allowed
+ assertEquals(ValidationResult.INVALID_GROUP_OWNER, result);
+
+ // Confirm Bob is still a member
+ assertTrue(isMember(repository, bob.getAddress(), groupId));
+
+ // Confirm Bob still an admin
+ assertTrue(isAdmin(repository, bob.getAddress(), groupId));
+
+ // Orphan last block
+ BlockUtils.orphanLastBlock(repository);
+
+ // Confirm Bob no longer an admin (ADD_GROUP_ADMIN no longer approved)
+ assertFalse(isAdmin(repository, bob.getAddress(), groupId));
+
+ // Have Alice try to kick herself!
+ result = groupKick(repository, alice, groupId, alice.getAddress());
+ // Should NOT be OK
+ assertNotSame(ValidationResult.OK, result);
+
+ // Have Bob try to kick Alice
+ result = groupKick(repository, bob, groupId, alice.getAddress());
+ // Should NOT be OK
+ assertNotSame(ValidationResult.OK, result);
+ }
+ }
+
+ @Test
+ public void testGroupBanMember() throws DataException {
+ try (final Repository repository = RepositoryManager.getRepository()) {
+ PrivateKeyAccount alice = Common.getTestAccount(repository, "alice");
+ PrivateKeyAccount bob = Common.getTestAccount(repository, "bob");
+
+ // Dev group
+ int groupId = DEV_GROUP_ID;
+
+ // Confirm Bob is not a member
+ assertFalse(isMember(repository, bob.getAddress(), groupId));
+
+ // Attempt to cancel non-existent Bob ban
+ ValidationResult result = cancelGroupBan(repository, alice, groupId, bob.getAddress());
+ // Should NOT be OK
+ assertNotSame(ValidationResult.OK, result);
+
+ // Attempt to ban Bob
+ result = groupBan(repository, alice, groupId, bob.getAddress());
+ // Should be OK
+ assertEquals(ValidationResult.OK, result);
+
+ // Bob attempts to rejoin
+ result = joinGroup(repository, bob, groupId);
+ // Should NOT be OK
+ assertNotSame(ValidationResult.OK, result);
+
+ // Orphan last block (Bob ban)
+ BlockUtils.orphanLastBlock(repository);
+ // Delete unconfirmed group-ban transaction
+ TransactionUtils.deleteUnconfirmedTransactions(repository);
+
+ // Confirm Bob is not a member
+ assertFalse(isMember(repository, bob.getAddress(), groupId));
+
+ // Alice to invite Bob, as it's a closed group
+ groupInvite(repository, alice, groupId, bob.getAddress(), 3600);
+
+ // Bob to join
+ result = joinGroup(repository, bob, groupId);
+ // Should be OK
+ assertEquals(ValidationResult.OK, result);
+
+ // Confirm Bob now a member
+ assertTrue(isMember(repository, bob.getAddress(), groupId));
+
+ // Attempt to ban Bob
+ result = groupBan(repository, alice, groupId, bob.getAddress());
+ // Should be OK
+ assertEquals(ValidationResult.OK, result);
+
+ // Confirm Bob no longer a member
+ assertFalse(isMember(repository, bob.getAddress(), groupId));
+
+ // Bob attempts to rejoin
+ result = joinGroup(repository, bob, groupId);
+ // Should NOT be OK
+ assertNotSame(ValidationResult.OK, result);
+
+ // Cancel Bob's ban
+ result = cancelGroupBan(repository, alice, groupId, bob.getAddress());
+ // Should be OK
+ assertEquals(ValidationResult.OK, result);
+
+ // Bob attempts to rejoin
+ result = joinGroup(repository, bob, groupId);
+ // Should be OK
+ assertEquals(ValidationResult.OK, result);
+
+ // Orphan last block (Bob join)
+ BlockUtils.orphanLastBlock(repository);
+ // Delete unconfirmed join-group transaction
+ TransactionUtils.deleteUnconfirmedTransactions(repository);
+
+ // Orphan last block (Cancel Bob ban)
+ BlockUtils.orphanLastBlock(repository);
+ // Delete unconfirmed cancel-ban transaction
+ TransactionUtils.deleteUnconfirmedTransactions(repository);
+
+ // Bob attempts to rejoin
+ result = joinGroup(repository, bob, groupId);
+ // Should NOT be OK
+ assertNotSame(ValidationResult.OK, result);
+
+ // Orphan last block (Bob ban)
+ BlockUtils.orphanLastBlock(repository);
+ // Delete unconfirmed group-ban transaction
+ TransactionUtils.deleteUnconfirmedTransactions(repository);
+
+ // Confirm Bob now a member
+ assertTrue(isMember(repository, bob.getAddress(), groupId));
+ }
+ }
+
+ @Test
+ public void testGroupBanAdmin() throws DataException {
+ try (final Repository repository = RepositoryManager.getRepository()) {
+ PrivateKeyAccount alice = Common.getTestAccount(repository, "alice");
+ PrivateKeyAccount bob = Common.getTestAccount(repository, "bob");
+
+ // Dev group
+ int groupId = DEV_GROUP_ID;
+
+ // Confirm Bob is not a member
+ assertFalse(isMember(repository, bob.getAddress(), groupId));
+
+ // Alice to invite Bob, as it's a closed group
+ groupInvite(repository, alice, groupId, bob.getAddress(), 3600);
+
+ // Bob to join
+ ValidationResult result = joinGroup(repository, bob, groupId);
+ // Should be OK
+ assertEquals(ValidationResult.OK, result);
+
+ // Promote Bob to admin
+ TransactionData addGroupAdminTransactionData = addGroupAdmin(repository, alice, groupId, bob.getAddress());
+
+ // Confirm transaction needs approval, and hasn't been approved
+ Transaction.ApprovalStatus approvalStatus = GroupUtils.getApprovalStatus(repository, addGroupAdminTransactionData.getSignature());
+ assertEquals("incorrect transaction approval status", Transaction.ApprovalStatus.PENDING, approvalStatus);
+
+ // Have Alice approve Bob's approval-needed transaction
+ GroupUtils.approveTransaction(repository, "alice", addGroupAdminTransactionData.getSignature(), true);
+
+ // Mint a block so that the transaction becomes approved
+ BlockUtils.mintBlock(repository);
+
+ // Confirm transaction is approved
+ approvalStatus = GroupUtils.getApprovalStatus(repository, addGroupAdminTransactionData.getSignature());
+ assertEquals("incorrect transaction approval status", Transaction.ApprovalStatus.APPROVED, approvalStatus);
+
+ // Confirm Bob is now admin
+ assertTrue(isAdmin(repository, bob.getAddress(), groupId));
+
+ // Attempt to ban Bob
+ result = groupBan(repository, alice, groupId, bob.getAddress());
+ // .. but we can't, because Bob is an admin and the group has no owner
+ assertEquals(ValidationResult.INVALID_GROUP_OWNER, result);
+
+ // Confirm Bob still a member
+ assertTrue(isMember(repository, bob.getAddress(), groupId));
+
+ // ... and still an admin
+ assertTrue(isAdmin(repository, bob.getAddress(), groupId));
+
+ // Have Alice try to ban herself!
+ result = groupBan(repository, alice, groupId, alice.getAddress());
+ // Should NOT be OK
+ assertNotSame(ValidationResult.OK, result);
+
+ // Have Bob try to ban Alice
+ result = groupBan(repository, bob, groupId, alice.getAddress());
+ // Should NOT be OK
+ assertNotSame(ValidationResult.OK, result);
+ }
+ }
+
+
+ private ValidationResult joinGroup(Repository repository, PrivateKeyAccount joiner, int groupId) throws DataException {
+ JoinGroupTransactionData transactionData = new JoinGroupTransactionData(TestTransaction.generateBase(joiner), groupId);
+ ValidationResult result = TransactionUtils.signAndImport(repository, transactionData, joiner);
+
+ if (result == ValidationResult.OK)
+ BlockUtils.mintBlock(repository);
+
+ return result;
+ }
+
+ private void groupInvite(Repository repository, PrivateKeyAccount admin, int groupId, String invitee, int timeToLive) throws DataException {
+ GroupInviteTransactionData transactionData = new GroupInviteTransactionData(TestTransaction.generateBase(admin), groupId, invitee, timeToLive);
+ TransactionUtils.signAndMint(repository, transactionData, admin);
+ }
+
+ private ValidationResult groupKick(Repository repository, PrivateKeyAccount admin, int groupId, String member) throws DataException {
+ GroupKickTransactionData transactionData = new GroupKickTransactionData(TestTransaction.generateBase(admin), groupId, member, "testing");
+ ValidationResult result = TransactionUtils.signAndImport(repository, transactionData, admin);
+
+ if (result == ValidationResult.OK)
+ BlockUtils.mintBlock(repository);
+
+ return result;
+ }
+
+ private ValidationResult groupBan(Repository repository, PrivateKeyAccount admin, int groupId, String member) throws DataException {
+ GroupBanTransactionData transactionData = new GroupBanTransactionData(TestTransaction.generateBase(admin), groupId, member, "testing", 0);
+ ValidationResult result = TransactionUtils.signAndImport(repository, transactionData, admin);
+
+ if (result == ValidationResult.OK)
+ BlockUtils.mintBlock(repository);
+
+ return result;
+ }
+
+ private ValidationResult cancelGroupBan(Repository repository, PrivateKeyAccount admin, int groupId, String member) throws DataException {
+ CancelGroupBanTransactionData transactionData = new CancelGroupBanTransactionData(TestTransaction.generateBase(admin), groupId, member);
+ ValidationResult result = TransactionUtils.signAndImport(repository, transactionData, admin);
+
+ if (result == ValidationResult.OK)
+ BlockUtils.mintBlock(repository);
+
+ return result;
+ }
+
+ private TransactionData addGroupAdmin(Repository repository, PrivateKeyAccount owner, int groupId, String member) throws DataException {
+ AddGroupAdminTransactionData transactionData = new AddGroupAdminTransactionData(TestTransaction.generateBase(owner), groupId, member);
+ transactionData.setTxGroupId(groupId);
+ TransactionUtils.signAndMint(repository, transactionData, owner);
+ return transactionData;
+ }
+
+ private boolean isMember(Repository repository, String address, int groupId) throws DataException {
+ return repository.getGroupRepository().memberExists(groupId, address);
+ }
+
+ private boolean isAdmin(Repository repository, String address, int groupId) throws DataException {
+ return repository.getGroupRepository().adminExists(groupId, address);
+ }
+
+}
diff --git a/src/test/java/org/qortal/test/at/AtSerializationTests.java b/src/test/java/org/qortal/test/serialization/AtSerializationTests.java
similarity index 99%
rename from src/test/java/org/qortal/test/at/AtSerializationTests.java
rename to src/test/java/org/qortal/test/serialization/AtSerializationTests.java
index 3953bcdf..ea8d6bcd 100644
--- a/src/test/java/org/qortal/test/at/AtSerializationTests.java
+++ b/src/test/java/org/qortal/test/serialization/AtSerializationTests.java
@@ -1,4 +1,4 @@
-package org.qortal.test.at;
+package org.qortal.test.serialization;
import com.google.common.hash.HashCode;
import org.junit.After;
diff --git a/src/test/java/org/qortal/test/serialization/ChatSerializationTests.java b/src/test/java/org/qortal/test/serialization/ChatSerializationTests.java
new file mode 100644
index 00000000..983896db
--- /dev/null
+++ b/src/test/java/org/qortal/test/serialization/ChatSerializationTests.java
@@ -0,0 +1,102 @@
+package org.qortal.test.serialization;
+
+import com.google.common.hash.HashCode;
+import org.junit.Before;
+import org.junit.Test;
+import org.qortal.account.PrivateKeyAccount;
+import org.qortal.data.transaction.ChatTransactionData;
+import org.qortal.data.transaction.TransactionData;
+import org.qortal.repository.DataException;
+import org.qortal.repository.Repository;
+import org.qortal.repository.RepositoryManager;
+import org.qortal.test.common.Common;
+import org.qortal.test.common.transaction.ChatTestTransaction;
+import org.qortal.transaction.Transaction;
+import org.qortal.transform.TransformationException;
+import org.qortal.transform.transaction.TransactionTransformer;
+import org.qortal.utils.Base58;
+
+import static org.junit.Assert.*;
+
+public class ChatSerializationTests {
+
+ @Before
+ public void beforeTest() throws DataException {
+ Common.useDefaultSettings();
+ }
+
+
+ @Test
+ public void testChatSerializationWithChatReference() throws DataException, TransformationException {
+ try (final Repository repository = RepositoryManager.getRepository()) {
+
+ // Build MESSAGE-type AT transaction with chatReference
+ PrivateKeyAccount signingAccount = Common.getTestAccount(repository, "alice");
+ ChatTransactionData transactionData = (ChatTransactionData) ChatTestTransaction.randomTransaction(repository, signingAccount, true);
+ Transaction transaction = Transaction.fromData(repository, transactionData);
+ transaction.sign(signingAccount);
+
+ assertNotNull(transactionData.getChatReference());
+
+ final int claimedLength = TransactionTransformer.getDataLength(transactionData);
+ byte[] serializedTransaction = TransactionTransformer.toBytes(transactionData);
+ assertEquals("Serialized CHAT transaction length differs from declared length", claimedLength, serializedTransaction.length);
+
+ TransactionData deserializedTransactionData = TransactionTransformer.fromBytes(serializedTransaction);
+ // Re-sign
+ Transaction deserializedTransaction = Transaction.fromData(repository, deserializedTransactionData);
+ deserializedTransaction.sign(signingAccount);
+ assertEquals("Deserialized CHAT transaction signature differs", Base58.encode(transactionData.getSignature()), Base58.encode(deserializedTransactionData.getSignature()));
+
+ // Re-serialize to check new length and bytes
+ final int reclaimedLength = TransactionTransformer.getDataLength(deserializedTransactionData);
+ assertEquals("Reserialized CHAT transaction declared length differs", claimedLength, reclaimedLength);
+
+ byte[] reserializedTransaction = TransactionTransformer.toBytes(deserializedTransactionData);
+ assertEquals("Reserialized CHAT transaction bytes differ", HashCode.fromBytes(serializedTransaction).toString(), HashCode.fromBytes(reserializedTransaction).toString());
+
+ // Deserialized chat reference must match initial chat reference
+ ChatTransactionData deserializedChatTransactionData = (ChatTransactionData) deserializedTransactionData;
+ assertNotNull(deserializedChatTransactionData.getChatReference());
+ assertArrayEquals(deserializedChatTransactionData.getChatReference(), transactionData.getChatReference());
+ }
+ }
+
+ @Test
+ public void testChatSerializationWithoutChatReference() throws DataException, TransformationException {
+ try (final Repository repository = RepositoryManager.getRepository()) {
+
+ // Build MESSAGE-type AT transaction without chatReference
+ PrivateKeyAccount signingAccount = Common.getTestAccount(repository, "alice");
+ ChatTransactionData transactionData = (ChatTransactionData) ChatTestTransaction.randomTransaction(repository, signingAccount, true);
+ transactionData.setChatReference(null);
+ Transaction transaction = Transaction.fromData(repository, transactionData);
+ transaction.sign(signingAccount);
+
+ assertNull(transactionData.getChatReference());
+
+ final int claimedLength = TransactionTransformer.getDataLength(transactionData);
+ byte[] serializedTransaction = TransactionTransformer.toBytes(transactionData);
+ assertEquals("Serialized CHAT transaction length differs from declared length", claimedLength, serializedTransaction.length);
+
+ TransactionData deserializedTransactionData = TransactionTransformer.fromBytes(serializedTransaction);
+ // Re-sign
+ Transaction deserializedTransaction = Transaction.fromData(repository, deserializedTransactionData);
+ deserializedTransaction.sign(signingAccount);
+ assertEquals("Deserialized CHAT transaction signature differs", Base58.encode(transactionData.getSignature()), Base58.encode(deserializedTransactionData.getSignature()));
+
+ // Re-serialize to check new length and bytes
+ final int reclaimedLength = TransactionTransformer.getDataLength(deserializedTransactionData);
+ assertEquals("Reserialized CHAT transaction declared length differs", claimedLength, reclaimedLength);
+
+ byte[] reserializedTransaction = TransactionTransformer.toBytes(deserializedTransactionData);
+ assertEquals("Reserialized CHAT transaction bytes differ", HashCode.fromBytes(serializedTransaction).toString(), HashCode.fromBytes(reserializedTransaction).toString());
+
+ // Deserialized chat reference must match initial chat reference
+ ChatTransactionData deserializedChatTransactionData = (ChatTransactionData) deserializedTransactionData;
+ assertNull(deserializedChatTransactionData.getChatReference());
+ assertArrayEquals(deserializedChatTransactionData.getChatReference(), transactionData.getChatReference());
+ }
+ }
+
+}
diff --git a/src/test/java/org/qortal/test/SerializationTests.java b/src/test/java/org/qortal/test/serialization/SerializationTests.java
similarity index 98%
rename from src/test/java/org/qortal/test/SerializationTests.java
rename to src/test/java/org/qortal/test/serialization/SerializationTests.java
index d9fe978c..e9767909 100644
--- a/src/test/java/org/qortal/test/SerializationTests.java
+++ b/src/test/java/org/qortal/test/serialization/SerializationTests.java
@@ -1,4 +1,4 @@
-package org.qortal.test;
+package org.qortal.test.serialization;
import org.junit.Ignore;
import org.junit.Test;
@@ -47,7 +47,6 @@ public class SerializationTests extends Common {
switch (txType) {
case GENESIS:
case ACCOUNT_FLAGS:
- case CHAT:
case PUBLICIZE:
case AIRDROP:
case ENABLE_FORGING:
@@ -60,6 +59,7 @@ public class SerializationTests extends Common {
TransactionData transactionData = TransactionUtils.randomTransaction(repository, signingAccount, txType, true);
Transaction transaction = Transaction.fromData(repository, transactionData);
transaction.sign(signingAccount);
+ transaction.importAsUnconfirmed();
final int claimedLength = TransactionTransformer.getDataLength(transactionData);
byte[] serializedTransaction = TransactionTransformer.toBytes(transactionData);
diff --git a/src/test/resources/test-chain-v2-block-timestamps.json b/src/test/resources/test-chain-v2-block-timestamps.json
index 4a883bd9..8c2e0503 100644
--- a/src/test/resources/test-chain-v2-block-timestamps.json
+++ b/src/test/resources/test-chain-v2-block-timestamps.json
@@ -14,6 +14,7 @@
"founderEffectiveMintingLevel": 10,
"onlineAccountSignaturesMinLifetime": 3600000,
"onlineAccountSignaturesMaxLifetime": 86400000,
+ "selfSponsorshipAlgoV1SnapshotTimestamp": 9999999999999,
"rewardsByHeight": [
{ "height": 1, "reward": 100 },
{ "height": 11, "reward": 10 },
@@ -70,7 +71,11 @@
"transactionV5Timestamp": 0,
"transactionV6Timestamp": 9999999999999,
"disableReferenceTimestamp": 9999999999999,
- "increaseOnlineAccountsDifficultyTimestamp": 9999999999999
+ "increaseOnlineAccountsDifficultyTimestamp": 9999999999999,
+ "onlineAccountMinterLevelValidationHeight": 0,
+ "selfSponsorshipAlgoV1Height": 999999999,
+ "feeValidationFixTimestamp": 0,
+ "chatReferenceTimestamp": 0
},
"genesisInfo": {
"version": 4,
diff --git a/src/test/resources/test-chain-v2-disable-reference.json b/src/test/resources/test-chain-v2-disable-reference.json
index e8fee5e0..f7f8e7d8 100644
--- a/src/test/resources/test-chain-v2-disable-reference.json
+++ b/src/test/resources/test-chain-v2-disable-reference.json
@@ -18,6 +18,7 @@
"founderEffectiveMintingLevel": 10,
"onlineAccountSignaturesMinLifetime": 3600000,
"onlineAccountSignaturesMaxLifetime": 86400000,
+ "selfSponsorshipAlgoV1SnapshotTimestamp": 9999999999999,
"rewardsByHeight": [
{ "height": 1, "reward": 100 },
{ "height": 11, "reward": 10 },
@@ -73,7 +74,11 @@
"transactionV5Timestamp": 0,
"transactionV6Timestamp": 0,
"disableReferenceTimestamp": 0,
- "increaseOnlineAccountsDifficultyTimestamp": 9999999999999
+ "increaseOnlineAccountsDifficultyTimestamp": 9999999999999,
+ "onlineAccountMinterLevelValidationHeight": 0,
+ "selfSponsorshipAlgoV1Height": 999999999,
+ "feeValidationFixTimestamp": 0,
+ "chatReferenceTimestamp": 0
},
"genesisInfo": {
"version": 4,
diff --git a/src/test/resources/test-chain-v2-founder-rewards.json b/src/test/resources/test-chain-v2-founder-rewards.json
index 17a713a0..20d10233 100644
--- a/src/test/resources/test-chain-v2-founder-rewards.json
+++ b/src/test/resources/test-chain-v2-founder-rewards.json
@@ -19,6 +19,7 @@
"onlineAccountSignaturesMinLifetime": 3600000,
"onlineAccountSignaturesMaxLifetime": 86400000,
"onlineAccountsModulusV2Timestamp": 9999999999999,
+ "selfSponsorshipAlgoV1SnapshotTimestamp": 9999999999999,
"rewardsByHeight": [
{ "height": 1, "reward": 100 },
{ "height": 11, "reward": 10 },
@@ -74,7 +75,11 @@
"transactionV5Timestamp": 0,
"transactionV6Timestamp": 0,
"disableReferenceTimestamp": 9999999999999,
- "increaseOnlineAccountsDifficultyTimestamp": 9999999999999
+ "increaseOnlineAccountsDifficultyTimestamp": 9999999999999,
+ "onlineAccountMinterLevelValidationHeight": 0,
+ "selfSponsorshipAlgoV1Height": 999999999,
+ "feeValidationFixTimestamp": 0,
+ "chatReferenceTimestamp": 0
},
"genesisInfo": {
"version": 4,
diff --git a/src/test/resources/test-chain-v2-leftover-reward.json b/src/test/resources/test-chain-v2-leftover-reward.json
index b57c3195..e71ebab6 100644
--- a/src/test/resources/test-chain-v2-leftover-reward.json
+++ b/src/test/resources/test-chain-v2-leftover-reward.json
@@ -19,6 +19,7 @@
"onlineAccountSignaturesMinLifetime": 3600000,
"onlineAccountSignaturesMaxLifetime": 86400000,
"onlineAccountsModulusV2Timestamp": 9999999999999,
+ "selfSponsorshipAlgoV1SnapshotTimestamp": 9999999999999,
"rewardsByHeight": [
{ "height": 1, "reward": 100 },
{ "height": 11, "reward": 10 },
@@ -74,7 +75,11 @@
"transactionV5Timestamp": 0,
"transactionV6Timestamp": 0,
"disableReferenceTimestamp": 9999999999999,
- "increaseOnlineAccountsDifficultyTimestamp": 9999999999999
+ "increaseOnlineAccountsDifficultyTimestamp": 9999999999999,
+ "onlineAccountMinterLevelValidationHeight": 0,
+ "selfSponsorshipAlgoV1Height": 999999999,
+ "feeValidationFixTimestamp": 0,
+ "chatReferenceTimestamp": 0
},
"genesisInfo": {
"version": 4,
diff --git a/src/test/resources/test-chain-v2-minting.json b/src/test/resources/test-chain-v2-minting.json
index 60b3cd76..2a388e1f 100644
--- a/src/test/resources/test-chain-v2-minting.json
+++ b/src/test/resources/test-chain-v2-minting.json
@@ -19,6 +19,7 @@
"onlineAccountSignaturesMinLifetime": 3600000,
"onlineAccountSignaturesMaxLifetime": 86400000,
"onlineAccountsModulusV2Timestamp": 9999999999999,
+ "selfSponsorshipAlgoV1SnapshotTimestamp": 9999999999999,
"rewardsByHeight": [
{ "height": 1, "reward": 100 },
{ "height": 11, "reward": 10 },
@@ -74,7 +75,11 @@
"transactionV5Timestamp": 0,
"transactionV6Timestamp": 0,
"disableReferenceTimestamp": 9999999999999,
- "increaseOnlineAccountsDifficultyTimestamp": 9999999999999
+ "increaseOnlineAccountsDifficultyTimestamp": 9999999999999,
+ "onlineAccountMinterLevelValidationHeight": 0,
+ "selfSponsorshipAlgoV1Height": 999999999,
+ "feeValidationFixTimestamp": 0,
+ "chatReferenceTimestamp": 0
},
"genesisInfo": {
"version": 4,
diff --git a/src/test/resources/test-chain-v2-qora-holder-extremes.json b/src/test/resources/test-chain-v2-qora-holder-extremes.json
index 2d044687..cface0e7 100644
--- a/src/test/resources/test-chain-v2-qora-holder-extremes.json
+++ b/src/test/resources/test-chain-v2-qora-holder-extremes.json
@@ -19,6 +19,7 @@
"onlineAccountSignaturesMinLifetime": 3600000,
"onlineAccountSignaturesMaxLifetime": 86400000,
"onlineAccountsModulusV2Timestamp": 9999999999999,
+ "selfSponsorshipAlgoV1SnapshotTimestamp": 9999999999999,
"rewardsByHeight": [
{ "height": 1, "reward": 100 },
{ "height": 11, "reward": 10 },
@@ -74,7 +75,11 @@
"transactionV5Timestamp": 0,
"transactionV6Timestamp": 0,
"disableReferenceTimestamp": 9999999999999,
- "increaseOnlineAccountsDifficultyTimestamp": 9999999999999
+ "increaseOnlineAccountsDifficultyTimestamp": 9999999999999,
+ "onlineAccountMinterLevelValidationHeight": 0,
+ "selfSponsorshipAlgoV1Height": 999999999,
+ "feeValidationFixTimestamp": 0,
+ "chatReferenceTimestamp": 0
},
"genesisInfo": {
"version": 4,
diff --git a/src/test/resources/test-chain-v2-qora-holder-reduction.json b/src/test/resources/test-chain-v2-qora-holder-reduction.json
index 3cf8848e..f233680b 100644
--- a/src/test/resources/test-chain-v2-qora-holder-reduction.json
+++ b/src/test/resources/test-chain-v2-qora-holder-reduction.json
@@ -19,6 +19,7 @@
"onlineAccountSignaturesMinLifetime": 3600000,
"onlineAccountSignaturesMaxLifetime": 86400000,
"onlineAccountsModulusV2Timestamp": 9999999999999,
+ "selfSponsorshipAlgoV1SnapshotTimestamp": 9999999999999,
"rewardsByHeight": [
{ "height": 1, "reward": 100 },
{ "height": 11, "reward": 10 },
@@ -75,7 +76,11 @@
"transactionV6Timestamp": 0,
"disableReferenceTimestamp": 9999999999999,
"aggregateSignatureTimestamp": 0,
- "increaseOnlineAccountsDifficultyTimestamp": 9999999999999
+ "increaseOnlineAccountsDifficultyTimestamp": 9999999999999,
+ "onlineAccountMinterLevelValidationHeight": 0,
+ "selfSponsorshipAlgoV1Height": 999999999,
+ "feeValidationFixTimestamp": 0,
+ "chatReferenceTimestamp": 0
},
"genesisInfo": {
"version": 4,
diff --git a/src/test/resources/test-chain-v2-qora-holder.json b/src/test/resources/test-chain-v2-qora-holder.json
index 93965b76..4ea82290 100644
--- a/src/test/resources/test-chain-v2-qora-holder.json
+++ b/src/test/resources/test-chain-v2-qora-holder.json
@@ -19,6 +19,7 @@
"onlineAccountSignaturesMinLifetime": 3600000,
"onlineAccountSignaturesMaxLifetime": 86400000,
"onlineAccountsModulusV2Timestamp": 9999999999999,
+ "selfSponsorshipAlgoV1SnapshotTimestamp": 9999999999999,
"rewardsByHeight": [
{ "height": 1, "reward": 100 },
{ "height": 11, "reward": 10 },
@@ -74,7 +75,11 @@
"transactionV5Timestamp": 0,
"transactionV6Timestamp": 0,
"disableReferenceTimestamp": 9999999999999,
- "increaseOnlineAccountsDifficultyTimestamp": 9999999999999
+ "increaseOnlineAccountsDifficultyTimestamp": 9999999999999,
+ "onlineAccountMinterLevelValidationHeight": 0,
+ "selfSponsorshipAlgoV1Height": 999999999,
+ "feeValidationFixTimestamp": 0,
+ "chatReferenceTimestamp": 0
},
"genesisInfo": {
"version": 4,
diff --git a/src/test/resources/test-chain-v2-reward-levels.json b/src/test/resources/test-chain-v2-reward-levels.json
index 06422e71..5de8d9ff 100644
--- a/src/test/resources/test-chain-v2-reward-levels.json
+++ b/src/test/resources/test-chain-v2-reward-levels.json
@@ -19,6 +19,7 @@
"onlineAccountSignaturesMinLifetime": 3600000,
"onlineAccountSignaturesMaxLifetime": 86400000,
"onlineAccountsModulusV2Timestamp": 9999999999999,
+ "selfSponsorshipAlgoV1SnapshotTimestamp": 9999999999999,
"rewardsByHeight": [
{ "height": 1, "reward": 100 },
{ "height": 11, "reward": 10 },
@@ -74,7 +75,11 @@
"transactionV5Timestamp": 0,
"transactionV6Timestamp": 0,
"disableReferenceTimestamp": 9999999999999,
- "increaseOnlineAccountsDifficultyTimestamp": 9999999999999
+ "increaseOnlineAccountsDifficultyTimestamp": 9999999999999,
+ "onlineAccountMinterLevelValidationHeight": 0,
+ "selfSponsorshipAlgoV1Height": 999999999,
+ "feeValidationFixTimestamp": 0,
+ "chatReferenceTimestamp": 0
},
"genesisInfo": {
"version": 4,
diff --git a/src/test/resources/test-chain-v2-reward-scaling.json b/src/test/resources/test-chain-v2-reward-scaling.json
index 6adcd0ac..c008ed42 100644
--- a/src/test/resources/test-chain-v2-reward-scaling.json
+++ b/src/test/resources/test-chain-v2-reward-scaling.json
@@ -19,6 +19,7 @@
"onlineAccountSignaturesMinLifetime": 3600000,
"onlineAccountSignaturesMaxLifetime": 86400000,
"onlineAccountsModulusV2Timestamp": 9999999999999,
+ "selfSponsorshipAlgoV1SnapshotTimestamp": 9999999999999,
"rewardsByHeight": [
{ "height": 1, "reward": 100 },
{ "height": 11, "reward": 10 },
@@ -74,7 +75,11 @@
"transactionV5Timestamp": 0,
"transactionV6Timestamp": 0,
"disableReferenceTimestamp": 9999999999999,
- "increaseOnlineAccountsDifficultyTimestamp": 9999999999999
+ "increaseOnlineAccountsDifficultyTimestamp": 9999999999999,
+ "onlineAccountMinterLevelValidationHeight": 0,
+ "selfSponsorshipAlgoV1Height": 999999999,
+ "feeValidationFixTimestamp": 0,
+ "chatReferenceTimestamp": 0
},
"genesisInfo": {
"version": 4,
diff --git a/src/test/resources/test-chain-v2-reward-shares.json b/src/test/resources/test-chain-v2-reward-shares.json
index 95324b56..2fc0151f 100644
--- a/src/test/resources/test-chain-v2-reward-shares.json
+++ b/src/test/resources/test-chain-v2-reward-shares.json
@@ -18,6 +18,7 @@
"founderEffectiveMintingLevel": 10,
"onlineAccountSignaturesMinLifetime": 3600000,
"onlineAccountSignaturesMaxLifetime": 86400000,
+ "selfSponsorshipAlgoV1SnapshotTimestamp": 9999999999999,
"rewardsByHeight": [
{ "height": 1, "reward": 100 },
{ "height": 11, "reward": 10 },
@@ -74,7 +75,11 @@
"transactionV5Timestamp": 0,
"transactionV6Timestamp": 0,
"disableReferenceTimestamp": 9999999999999,
- "increaseOnlineAccountsDifficultyTimestamp": 9999999999999
+ "increaseOnlineAccountsDifficultyTimestamp": 9999999999999,
+ "onlineAccountMinterLevelValidationHeight": 0,
+ "selfSponsorshipAlgoV1Height": 999999999,
+ "feeValidationFixTimestamp": 0,
+ "chatReferenceTimestamp": 0
},
"genesisInfo": {
"version": 4,
diff --git a/src/test/resources/test-chain-v2-self-sponsorship-algo.json b/src/test/resources/test-chain-v2-self-sponsorship-algo.json
new file mode 100644
index 00000000..68b33cc3
--- /dev/null
+++ b/src/test/resources/test-chain-v2-self-sponsorship-algo.json
@@ -0,0 +1,116 @@
+{
+ "isTestChain": true,
+ "blockTimestampMargin": 500,
+ "transactionExpiryPeriod": 86400000,
+ "maxBlockSize": 2097152,
+ "maxBytesPerUnitFee": 0,
+ "unitFee": "0.00000001",
+ "nameRegistrationUnitFees": [
+ { "timestamp": 1645372800000, "fee": "5" }
+ ],
+ "requireGroupForApproval": false,
+ "minAccountLevelToRewardShare": 5,
+ "maxRewardSharesPerFounderMintingAccount": 20,
+ "maxRewardSharesByTimestamp": [
+ { "timestamp": 0, "maxShares": 20 },
+ { "timestamp": 9999999999999, "maxShares": 3 }
+ ],
+ "founderEffectiveMintingLevel": 10,
+ "onlineAccountSignaturesMinLifetime": 3600000,
+ "onlineAccountSignaturesMaxLifetime": 86400000,
+ "onlineAccountsModulusV2Timestamp": 9999999999999,
+ "selfSponsorshipAlgoV1SnapshotTimestamp": 9999999999999,
+ "rewardsByHeight": [
+ { "height": 1, "reward": 100 },
+ { "height": 11, "reward": 10 },
+ { "height": 21, "reward": 1 }
+ ],
+ "sharesByLevelV1": [
+ { "id": 1, "levels": [ 1, 2 ], "share": 0.05 },
+ { "id": 2, "levels": [ 3, 4 ], "share": 0.10 },
+ { "id": 3, "levels": [ 5, 6 ], "share": 0.15 },
+ { "id": 4, "levels": [ 7, 8 ], "share": 0.20 },
+ { "id": 5, "levels": [ 9, 10 ], "share": 0.25 }
+ ],
+ "sharesByLevelV2": [
+ { "id": 1, "levels": [ 1, 2 ], "share": 0.06 },
+ { "id": 2, "levels": [ 3, 4 ], "share": 0.13 },
+ { "id": 3, "levels": [ 5, 6 ], "share": 0.19 },
+ { "id": 4, "levels": [ 7, 8 ], "share": 0.26 },
+ { "id": 5, "levels": [ 9, 10 ], "share": 0.32 }
+ ],
+ "qoraHoldersShareByHeight": [
+ { "height": 1, "share": 0.20 },
+ { "height": 1000000, "share": 0.01 }
+ ],
+ "qoraPerQortReward": 250,
+ "minAccountsToActivateShareBin": 0,
+ "shareBinActivationMinLevel": 7,
+ "blocksNeededByLevel": [ 5, 20, 30, 40, 50, 60, 18, 80, 90, 100 ],
+ "blockTimingsByHeight": [
+ { "height": 1, "target": 60000, "deviation": 30000, "power": 0.2 }
+ ],
+ "ciyamAtSettings": {
+ "feePerStep": "0.0001",
+ "maxStepsPerRound": 500,
+ "stepsPerFunctionCall": 10,
+ "minutesPerBlock": 1
+ },
+ "featureTriggers": {
+ "messageHeight": 0,
+ "atHeight": 0,
+ "assetsTimestamp": 0,
+ "votingTimestamp": 0,
+ "arbitraryTimestamp": 0,
+ "powfixTimestamp": 0,
+ "qortalTimestamp": 0,
+ "newAssetPricingTimestamp": 0,
+ "groupApprovalTimestamp": 0,
+ "atFindNextTransactionFix": 0,
+ "newBlockSigHeight": 999999,
+ "shareBinFix": 999999,
+ "sharesByLevelV2Height": 999999,
+ "rewardShareLimitTimestamp": 9999999999999,
+ "calcChainWeightTimestamp": 0,
+ "transactionV5Timestamp": 0,
+ "transactionV6Timestamp": 0,
+ "disableReferenceTimestamp": 9999999999999,
+ "increaseOnlineAccountsDifficultyTimestamp": 9999999999999,
+ "onlineAccountMinterLevelValidationHeight": 0,
+ "selfSponsorshipAlgoV1Height": 20,
+ "feeValidationFixTimestamp": 0,
+ "chatReferenceTimestamp": 0
+ },
+ "genesisInfo": {
+ "version": 4,
+ "timestamp": 0,
+ "transactions": [
+ { "type": "ISSUE_ASSET", "assetName": "QORT", "description": "QORT native coin", "data": "", "quantity": 0, "isDivisible": true, "fee": 0 },
+ { "type": "ISSUE_ASSET", "assetName": "Legacy-QORA", "description": "Representative legacy QORA", "quantity": 0, "isDivisible": true, "data": "{}", "isUnspendable": true },
+ { "type": "ISSUE_ASSET", "assetName": "QORT-from-QORA", "description": "QORT gained from holding legacy QORA", "quantity": 0, "isDivisible": true, "data": "{}", "isUnspendable": true },
+
+ { "type": "GENESIS", "recipient": "QgV4s3xnzLhVBEJxcYui4u4q11yhUHsd9v", "amount": "1000000000" },
+ { "type": "GENESIS", "recipient": "QixPbJUwsaHsVEofJdozU9zgVqkK6aYhrK", "amount": "1000000" },
+ { "type": "GENESIS", "recipient": "QaUpHNhT3Ygx6avRiKobuLdusppR5biXjL", "amount": "1000000" },
+ { "type": "GENESIS", "recipient": "Qci5m9k4rcwe4ruKrZZQKka4FzUUMut3er", "amount": "1000000" },
+
+ { "type": "CREATE_GROUP", "creatorPublicKey": "2tiMr5LTpaWCgbRvkPK8TFd7k63DyHJMMFFsz9uBf1ZP", "groupName": "dev-group", "description": "developer group", "isOpen": false, "approvalThreshold": "PCT100", "minimumBlockDelay": 0, "maximumBlockDelay": 1440 },
+
+ { "type": "UPDATE_GROUP", "ownerPublicKey": "2tiMr5LTpaWCgbRvkPK8TFd7k63DyHJMMFFsz9uBf1ZP", "groupId": 1, "newOwner": "QdSnUy6sUiEnaN87dWmE92g1uQjrvPgrWG", "newDescription": "developer group", "newIsOpen": false, "newApprovalThreshold": "PCT40", "minimumBlockDelay": 10, "maximumBlockDelay": 1440 },
+
+ { "type": "ISSUE_ASSET", "issuerPublicKey": "2tiMr5LTpaWCgbRvkPK8TFd7k63DyHJMMFFsz9uBf1ZP", "assetName": "TEST", "description": "test asset", "data": "", "quantity": "1000000", "isDivisible": true, "fee": 0 },
+ { "type": "ISSUE_ASSET", "issuerPublicKey": "C6wuddsBV3HzRrXUtezE7P5MoRXp5m3mEDokRDGZB6ry", "assetName": "OTHER", "description": "other test asset", "data": "", "quantity": "1000000", "isDivisible": true, "fee": 0 },
+ { "type": "ISSUE_ASSET", "issuerPublicKey": "2tiMr5LTpaWCgbRvkPK8TFd7k63DyHJMMFFsz9uBf1ZP", "assetName": "GOLD", "description": "gold test asset", "data": "", "quantity": "1000000", "isDivisible": true, "fee": 0 },
+
+ { "type": "ACCOUNT_FLAGS", "target": "QgV4s3xnzLhVBEJxcYui4u4q11yhUHsd9v", "andMask": -1, "orMask": 1, "xorMask": 0 },
+ { "type": "REWARD_SHARE", "minterPublicKey": "2tiMr5LTpaWCgbRvkPK8TFd7k63DyHJMMFFsz9uBf1ZP", "recipient": "QgV4s3xnzLhVBEJxcYui4u4q11yhUHsd9v", "rewardSharePublicKey": "7PpfnvLSG7y4HPh8hE7KoqAjLCkv7Ui6xw4mKAkbZtox", "sharePercent": "100" },
+
+ { "type": "ACCOUNT_LEVEL", "target": "QixPbJUwsaHsVEofJdozU9zgVqkK6aYhrK", "level": 5 },
+ { "type": "REWARD_SHARE", "minterPublicKey": "C6wuddsBV3HzRrXUtezE7P5MoRXp5m3mEDokRDGZB6ry", "recipient": "QixPbJUwsaHsVEofJdozU9zgVqkK6aYhrK", "rewardSharePublicKey": "CcABzvk26TFEHG7Yok84jxyd4oBtLkx8RJdGFVz2csvp", "sharePercent": 100 },
+
+ { "type": "ACCOUNT_LEVEL", "target": "Qci5m9k4rcwe4ruKrZZQKka4FzUUMut3er", "level": 5 },
+ { "type": "ACCOUNT_LEVEL", "target": "QaUpHNhT3Ygx6avRiKobuLdusppR5biXjL", "level": 5 },
+ { "type": "ACCOUNT_LEVEL", "target": "Qci5m9k4rcwe4ruKrZZQKka4FzUUMut3er", "level": 6 }
+ ]
+ }
+}
diff --git a/src/test/resources/test-chain-v2.json b/src/test/resources/test-chain-v2.json
index c0fb9861..63abc695 100644
--- a/src/test/resources/test-chain-v2.json
+++ b/src/test/resources/test-chain-v2.json
@@ -19,6 +19,7 @@
"onlineAccountSignaturesMinLifetime": 3600000,
"onlineAccountSignaturesMaxLifetime": 86400000,
"onlineAccountsModulusV2Timestamp": 9999999999999,
+ "selfSponsorshipAlgoV1SnapshotTimestamp": 9999999999999,
"rewardsByHeight": [
{ "height": 1, "reward": 100 },
{ "height": 11, "reward": 10 },
@@ -74,7 +75,11 @@
"transactionV5Timestamp": 0,
"transactionV6Timestamp": 0,
"disableReferenceTimestamp": 9999999999999,
- "increaseOnlineAccountsDifficultyTimestamp": 9999999999999
+ "increaseOnlineAccountsDifficultyTimestamp": 9999999999999,
+ "onlineAccountMinterLevelValidationHeight": 0,
+ "selfSponsorshipAlgoV1Height": 999999999,
+ "feeValidationFixTimestamp": 0,
+ "chatReferenceTimestamp": 0
},
"genesisInfo": {
"version": 4,
@@ -91,6 +96,8 @@
{ "type": "CREATE_GROUP", "creatorPublicKey": "2tiMr5LTpaWCgbRvkPK8TFd7k63DyHJMMFFsz9uBf1ZP", "groupName": "dev-group", "description": "developer group", "isOpen": false, "approvalThreshold": "PCT100", "minimumBlockDelay": 0, "maximumBlockDelay": 1440 },
+ { "type": "UPDATE_GROUP", "ownerPublicKey": "2tiMr5LTpaWCgbRvkPK8TFd7k63DyHJMMFFsz9uBf1ZP", "groupId": 1, "newOwner": "QdSnUy6sUiEnaN87dWmE92g1uQjrvPgrWG", "newDescription": "developer group", "newIsOpen": false, "newApprovalThreshold": "PCT40", "minimumBlockDelay": 10, "maximumBlockDelay": 1440 },
+
{ "type": "ISSUE_ASSET", "issuerPublicKey": "2tiMr5LTpaWCgbRvkPK8TFd7k63DyHJMMFFsz9uBf1ZP", "assetName": "TEST", "description": "test asset", "data": "", "quantity": "1000000", "isDivisible": true, "fee": 0 },
{ "type": "ISSUE_ASSET", "issuerPublicKey": "C6wuddsBV3HzRrXUtezE7P5MoRXp5m3mEDokRDGZB6ry", "assetName": "OTHER", "description": "other test asset", "data": "", "quantity": "1000000", "isDivisible": true, "fee": 0 },
{ "type": "ISSUE_ASSET", "issuerPublicKey": "2tiMr5LTpaWCgbRvkPK8TFd7k63DyHJMMFFsz9uBf1ZP", "assetName": "GOLD", "description": "gold test asset", "data": "", "quantity": "1000000", "isDivisible": true, "fee": 0 },
diff --git a/src/test/resources/test-settings-v2-self-sponsorship-algo.json b/src/test/resources/test-settings-v2-self-sponsorship-algo.json
new file mode 100644
index 00000000..5ea42e66
--- /dev/null
+++ b/src/test/resources/test-settings-v2-self-sponsorship-algo.json
@@ -0,0 +1,20 @@
+{
+ "repositoryPath": "testdb",
+ "bitcoinNet": "TEST3",
+ "litecoinNet": "TEST3",
+ "restrictedApi": false,
+ "blockchainConfig": "src/test/resources/test-chain-v2-self-sponsorship-algo.json",
+ "exportPath": "qortal-backup-test",
+ "bootstrap": false,
+ "wipeUnconfirmedOnStart": false,
+ "testNtpOffset": 0,
+ "minPeers": 0,
+ "pruneBlockLimit": 100,
+ "bootstrapFilenamePrefix": "test-",
+ "dataPath": "data-test",
+ "tempDataPath": "data-test/_temp",
+ "listsPath": "lists-test",
+ "storagePolicy": "FOLLOWED_OR_VIEWED",
+ "maxStorageCapacity": 104857600,
+ "arrrDefaultBirthday": 1900000
+}
diff --git a/tools/approve-dev-transaction.sh b/tools/approve-dev-transaction.sh
new file mode 100755
index 00000000..6b611b59
--- /dev/null
+++ b/tools/approve-dev-transaction.sh
@@ -0,0 +1,97 @@
+#!/usr/bin/env bash
+
+port=12391
+if [ $# -gt 0 -a "$1" = "-t" ]; then
+ port=62391
+fi
+
+printf "Searching for auto-update transactions to approve...\n";
+
+tx=$( curl --silent --url "http://localhost:${port}/transactions/search?txGroupId=1&txType=ADD_GROUP_ADMIN&txType=REMOVE_GROUP_ADMIN&confirmationStatus=CONFIRMED&limit=1&reverse=true" );
+if fgrep --silent '"approvalStatus":"PENDING"' <<< "${tx}"; then
+ true
+else
+ echo "Can't find any pending transactions"
+ exit
+fi
+
+sig=$( perl -n -e 'print $1 if m/"signature":"(\w+)"/' <<< "${tx}" )
+if [ -z "${sig}" ]; then
+ printf "Can't find transaction signature in JSON:\n%s\n" "${tx}"
+ exit
+fi
+
+printf "Found transaction %s\n" $sig;
+
+printf "\nPaste your dev account private key:\n";
+IFS=
+read -s privkey
+printf "\n"
+
+# Convert to public key
+pubkey=$( curl --silent --url "http://localhost:${port}/utils/publickey" --data @- <<< "${privkey}" );
+if egrep -v --silent '^\w{44,46}$' <<< "${pubkey}"; then
+ printf "Invalid response from API - was your private key correct?\n%s\n" "${pubkey}"
+ exit
+fi
+printf "Your public key: %s\n" ${pubkey}
+
+# Convert to address
+address=$( curl --silent --url "http://localhost:${port}/addresses/convert/${pubkey}" );
+printf "Your address: %s\n" ${address}
+
+# Grab last reference
+lastref=$( curl --silent --url "http://localhost:${port}/addresses/lastreference/{$address}" );
+printf "Your last reference: %s\n" ${lastref}
+
+# Build GROUP_APPROVAL transaction
+timestamp=$( date +%s )000
+tx_json=$( cat < 0; seconds--)); do
+ if [ "${seconds}" = "1" ]; then
+ plural=""
+ fi
+ printf "\rBroadcasting in %d second%s...(CTRL-C) to abort " $seconds $plural
+ sleep 1
+done
+
+printf "\rBroadcasting signed GROUP_APPROVAL transaction... \n"
+result=$( curl --silent --url "http://localhost:${port}/transactions/process" --data @- <<< "${signed_tx}" )
+printf "API response:\n%s\n" "${result}"
diff --git a/tools/publish-auto-update-v5.pl b/tools/publish-auto-update-v5.pl
index aad49d4e..f97fe115 100755
--- a/tools/publish-auto-update-v5.pl
+++ b/tools/publish-auto-update-v5.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 () {
}
close(POM);
+my $apikey = read_file('apikey.txt');
+
# Do we need to determine commit hash?
unless ($commit_hash) {
# determine git branch
@@ -124,7 +127,7 @@ my $raw_tx = `curl --silent --url http://localhost:${port}/utils/tobase58/${raw_
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 -d "${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;
diff --git a/tools/tx.pl b/tools/tx.pl
index db6958e2..fe3cd872 100755
--- a/tools/tx.pl
+++ b/tools/tx.pl
@@ -71,9 +71,14 @@ our %TRANSACTION_TYPES = (
},
add_group_admin => {
url => 'groups/addadmin',
- required => [qw(groupId member)],
+ required => [qw(groupId txGroupId member)],
key_name => 'ownerPublicKey',
},
+ remove_group_admin => {
+ url => 'groups/removeadmin',
+ required => [qw(groupId txGroupId admin)],
+ key_name => 'ownerPublicKey',
+ },
group_approval => {
url => 'groups/approval',
required => [qw(pendingSignature approval)],