Add irregular txType, add check for total balance, prevent proposal withhold attack

core/src/main/java/bisq/core/dao/governance/ballot/BallotListPresentation.java

@@ -45,7 +45,6 @@
 public class BallotListPresentation implements BallotListService.BallotListChangeListener, DaoStateListener {
     private final BallotListService ballotListService;
     private final PeriodService periodService;
-    private final DaoStateService daoStateService;
     private final ProposalValidatorProvider proposalValidatorProvider;
 
     @Getter
@@ -65,31 +64,20 @@ public BallotListPresentation(BallotListService ballotListService,
                                   ProposalValidatorProvider proposalValidatorProvider) {
         this.ballotListService = ballotListService;
         this.periodService = periodService;
-        this.daoStateService = daoStateService;
         this.proposalValidatorProvider = proposalValidatorProvider;
 
         daoStateService.addDaoStateListener(this);
         ballotListService.addListener(this);
     }
 
+
     ///////////////////////////////////////////////////////////////////////////////////////////
     // DaoStateListener
     ///////////////////////////////////////////////////////////////////////////////////////////
 
-    @Override
-    public void onNewBlockHeight(int blockHeight) {
-        if (daoStateService.isParseBlockChainComplete()) {
-            ballotsOfCycle.setPredicate(ballot -> periodService.isTxInCorrectCycle(ballot.getTxId(), blockHeight));
-        }
-    }
-
-    @Override
-    public void onParseBlockChainComplete() {
-        ballotsOfCycle.setPredicate(ballot -> periodService.isTxInCorrectCycle(ballot.getTxId(), daoStateService.getChainHeight()));
-    }
-
     @Override
     public void onParseBlockCompleteAfterBatchProcessing(Block block) {
+        ballotsOfCycle.setPredicate(ballot -> periodService.isTxInCorrectCycle(ballot.getTxId(), block.getHeight()));
         onListChanged(ballotListService.getValidatedBallotList());
     }
 

core/src/main/java/bisq/core/dao/governance/blindvote/BlindVoteListService.java

@@ -136,20 +136,20 @@ private void fillListFromAppendOnlyDataStore() {
         p2PService.getP2PDataStorage().getAppendOnlyDataStoreMap().values().forEach(e -> onAppendOnlyDataAdded(e, false));
     }
 
-    private void onAppendOnlyDataAdded(PersistableNetworkPayload persistableNetworkPayload, boolean doLog) {
+    private void onAppendOnlyDataAdded(PersistableNetworkPayload persistableNetworkPayload, boolean fromBroadcastMessage) {
         if (persistableNetworkPayload instanceof BlindVotePayload) {
             BlindVotePayload blindVotePayload = (BlindVotePayload) persistableNetworkPayload;
             if (!blindVotePayloads.contains(blindVotePayload)) {
                 BlindVote blindVote = blindVotePayload.getBlindVote();
                 String txId = blindVote.getTxId();
-                // We don't check the phase and the cycle as we want to add all object independently when we receive it
-                // (or when we start the app to fill our list from the data we gor from the seed node).
+                // We don't validate as we might receive blindVotes from other cycles or phases at startup.
+                // Beside that we might receive payloads we requested at the vote result phase in case we missed some
+                // payloads. We prefer here resilience over protection against late publishing attacks.
                 if (blindVoteValidator.areDataFieldsValid(blindVote)) {
-                    // We don't validate as we might receive blindVotes from other cycles or phases at startup.
-                    blindVotePayloads.add(blindVotePayload);
-                    if (doLog) {
+                    if (fromBroadcastMessage) {
                         log.info("We received a blindVotePayload. blindVoteTxId={}", txId);
                     }
+                    blindVotePayloads.add(blindVotePayload);
                 } else {
                     log.warn("We received an invalid blindVotePayload. blindVoteTxId={}", txId);
                 }

core/src/main/java/bisq/core/dao/governance/blindvote/MyBlindVoteListService.java

@@ -135,7 +135,7 @@ public MyBlindVoteListService(P2PService p2PService,
         this.myVoteListService = myVoteListService;
         this.myProposalListService = myProposalListService;
 
-        numConnectedPeersListener = (observable, oldValue, newValue) -> rePublishOnceWellConnected();
+        numConnectedPeersListener = (observable, oldValue, newValue) -> rePublishMyBlindVoteOnceWellConnected();
     }
 
 
@@ -176,7 +176,7 @@ public void readPersisted() {
 
     @Override
     public void onParseBlockChainComplete() {
-        rePublishOnceWellConnected();
+        rePublishMyBlindVoteOnceWellConnected();
     }
 
 
@@ -351,15 +351,16 @@ private Transaction getBlindVoteTx(Coin stake, Coin fee, byte[] opReturnData)
         return bsqWalletService.signTx(txWithBtcFee);
     }
 
-    private void rePublishOnceWellConnected() {
+    private void rePublishMyBlindVoteOnceWellConnected() {
+        // We republish at each startup at any block during the cycle. We filter anyway for valid blind votes
+        // of that cycle so it is 1 blind vote getting rebroadcast at each startup to my neighbors.
         int minPeers = BisqEnvironment.getBaseCurrencyNetwork().isMainnet() ? 4 : 1;
         if ((p2PService.getNumConnectedPeers().get() >= minPeers && p2PService.isBootstrapped()) ||
                 BisqEnvironment.getBaseCurrencyNetwork().isRegtest()) {
-            int chainHeight = periodService.getChainHeight();
             myBlindVoteList.stream()
                     .filter(blindVote -> periodService.isTxInPhaseAndCycle(blindVote.getTxId(),
                             DaoPhase.Phase.BLIND_VOTE,
-                            chainHeight))
+                            periodService.getChainHeight()))
                     .forEach(blindVote -> addToP2PNetwork(blindVote, null));
 
             // We delay removal of listener as we call that inside listener itself.
@@ -369,13 +370,15 @@ private void rePublishOnceWellConnected() {
 
     private void addToP2PNetwork(BlindVote blindVote, @Nullable ErrorMessageHandler errorMessageHandler) {
         BlindVotePayload blindVotePayload = new BlindVotePayload(blindVote);
+        // We use reBroadcast flag here as we only broadcast our own blindVote and want to be sure it gets distributed
+        // well.
         boolean success = p2PService.addPersistableNetworkPayload(blindVotePayload, true);
 
         if (success) {
             log.info("We added a blindVotePayload to the P2P network as append only data. blindVoteTxId={}",
                     blindVote.getTxId());
         } else {
-            final String msg = "Adding of blindVotePayload to P2P network failed. blindVoteTxId=" + blindVote.getTxId();
+            String msg = "Adding of blindVotePayload to P2P network failed. blindVoteTxId=" + blindVote.getTxId();
             log.error(msg);
             if (errorMessageHandler != null)
                 errorMessageHandler.handleErrorMessage(msg);

core/src/main/java/bisq/core/dao/governance/merit/MeritConsensus.java

@@ -54,28 +54,27 @@ public static MeritList decryptMeritList(byte[] encryptedMeritList, SecretKey se
     }
 
     public static long getMeritStake(String blindVoteTxId, MeritList meritList, DaoStateService daoStateService) {
-        int txChainHeight = daoStateService.getTx(blindVoteTxId).map(Tx::getBlockHeight).orElse(0);
-        return getMeritStake(blindVoteTxId, meritList, txChainHeight);
-    }
-
-    private static long getMeritStake(String blindVoteTxId, MeritList meritList, int txChainHeight) {
         // We need to take the chain height when the blindVoteTx got published so we get the same merit for the vote even at
         // later blocks (merit decreases with each block).
-        if (txChainHeight == 0) {
+        int blindVoteTxHeight = daoStateService.getTx(blindVoteTxId).map(Tx::getBlockHeight).orElse(0);
+        if (blindVoteTxHeight == 0) {
             log.error("Error at getMeritStake: blindVoteTx not found in daoStateService. blindVoteTxId=" + blindVoteTxId);
             return 0;
         }
 
+        // We only use past issuance. In case we would calculate the merit after the vote result phase we have the
+        // issuance from the same cycle but we must not add that to the merit.
         return meritList.getList().stream()
                 .filter(merit -> isSignatureValid(merit.getSignature(), merit.getIssuance().getPubKey(), blindVoteTxId))
+                .filter(merit -> merit.getIssuance().getChainHeight() <= blindVoteTxHeight)
                 .mapToLong(merit -> {
                     try {
                         Issuance issuance = merit.getIssuance();
                         checkArgument(issuance.getIssuanceType() == IssuanceType.COMPENSATION,
                                 "issuance must be of type COMPENSATION");
                         return getWeightedMeritAmount(issuance.getAmount(),
                                 issuance.getChainHeight(),
-                                txChainHeight,
+                                blindVoteTxHeight,
                                 BLOCKS_PER_YEAR);
                     } catch (Throwable t) {
                         log.error("Error at getMeritStake: error={}, merit={}", t.toString(), merit);
@@ -145,17 +144,20 @@ public static long getWeightedMeritAmount(long amount, int issuanceHeight, int b
     public static long getCurrentlyAvailableMerit(MeritList meritList, int currentChainHeight) {
         // We need to take the chain height when the blindVoteTx got published so we get the same merit for the vote even at
         // later blocks (merit decreases with each block).
+        // We add 1 block to currentChainHeight so that the displayed merit would match the merit in case we get the
+        // blind vote tx into the next block.
+        int height = currentChainHeight + 1;
         return meritList.getList().stream()
                 .mapToLong(merit -> {
                     try {
                         Issuance issuance = merit.getIssuance();
                         checkArgument(issuance.getIssuanceType() == IssuanceType.COMPENSATION, "issuance must be of type COMPENSATION");
                         int issuanceHeight = issuance.getChainHeight();
-                        checkArgument(issuanceHeight <= currentChainHeight,
+                        checkArgument(issuanceHeight <= height,
                                 "issuanceHeight must not be larger as currentChainHeight");
                         return getWeightedMeritAmount(issuance.getAmount(),
                                 issuanceHeight,
-                                currentChainHeight,
+                                height,
                                 BLOCKS_PER_YEAR);
                     } catch (Throwable t) {
                         log.error("Error at getCurrentlyAvailableMerit: " + t.toString());

core/src/main/java/bisq/core/dao/governance/myvote/MyVote.java

@@ -126,7 +126,7 @@ public static MyVote fromProto(PB.MyVote proto) {
     // API
     ///////////////////////////////////////////////////////////////////////////////////////////
 
-    public String getTxId() {
+    public String getBlindVoteTxId() {
         return blindVote.getTxId();
     }
 

core/src/main/java/bisq/core/dao/governance/myvote/MyVoteList.java

@@ -64,7 +64,7 @@ public static PersistableEnvelope fromProto(PB.MyVoteList proto) {
     @Override
     public String toString() {
         return "List of TxId's in MyVoteList: " + getList().stream()
-                .map(MyVote::getTxId)
+                .map(MyVote::getBlindVoteTxId)
                 .collect(Collectors.toList());
     }
 }

core/src/main/java/bisq/core/dao/governance/proposal/MyProposalListService.java

@@ -30,6 +30,7 @@
 
 import bisq.network.p2p.P2PService;
 
+import bisq.common.UserThread;
 import bisq.common.app.DevEnv;
 import bisq.common.crypto.KeyRing;
 import bisq.common.handlers.ErrorMessageHandler;
@@ -93,7 +94,7 @@ public MyProposalListService(P2PService p2PService,
 
         signaturePubKey = keyRing.getPubKeyRing().getSignaturePubKey();
 
-        numConnectedPeersListener = (observable, oldValue, newValue) -> rePublishOnceWellConnected();
+        numConnectedPeersListener = (observable, oldValue, newValue) -> rePublishMyProposalsOnceWellConnected();
         daoStateService.addDaoStateListener(this);
         p2PService.getNumConnectedPeers().addListener(numConnectedPeersListener);
     }
@@ -122,7 +123,7 @@ public void readPersisted() {
 
     @Override
     public void onParseBlockChainComplete() {
-        rePublishOnceWellConnected();
+        rePublishMyProposalsOnceWellConnected();
     }
 
 
@@ -216,26 +217,23 @@ private boolean addToP2PNetworkAsProtectedData(Proposal proposal) {
         return p2PService.addProtectedStorageEntry(new TempProposalPayload(proposal, signaturePubKey), true);
     }
 
-    private void rePublishOnceWellConnected() {
+    private void rePublishMyProposalsOnceWellConnected() {
+        // We republish at each startup at any block during the cycle. We filter anyway for valid blind votes
+        // of that cycle so it is 1 blind vote getting rebroadcast at each startup to my neighbors.
         int minPeers = BisqEnvironment.getBaseCurrencyNetwork().isMainnet() ? 4 : 1;
         if ((p2PService.getNumConnectedPeers().get() >= minPeers && p2PService.isBootstrapped()) ||
                 BisqEnvironment.getBaseCurrencyNetwork().isRegtest()) {
-            p2PService.getNumConnectedPeers().removeListener(numConnectedPeersListener);
-            rePublish();
+            myProposalList.stream()
+                    .filter(proposal -> periodService.isTxInPhaseAndCycle(proposal.getTxId(),
+                            DaoPhase.Phase.PROPOSAL,
+                            periodService.getChainHeight()))
+                    .forEach(this::addToP2PNetworkAsProtectedData);
+
+            // We delay removal of listener as we call that inside listener itself.
+            UserThread.execute(() -> p2PService.getNumConnectedPeers().removeListener(numConnectedPeersListener));
         }
     }
 
-    private void rePublish() {
-        myProposalList.forEach(proposal -> {
-            final String txId = proposal.getTxId();
-            if (periodService.isTxInPhaseAndCycle(txId, DaoPhase.Phase.PROPOSAL, periodService.getChainHeight())) {
-                boolean result = addToP2PNetworkAsProtectedData(proposal);
-                if (!result)
-                    log.warn("Adding of proposal to P2P network failed.\nproposal=" + proposal);
-            }
-        });
-    }
-
     private void persist() {
         storage.queueUpForSave();
     }