Add hash of dao state

common/src/main/java/bisq/common/app/Capability.java

@@ -31,5 +31,6 @@ public enum Capability {
     PROPOSAL,
     BLIND_VOTE,
     ACK_MSG,
-    BSQ_BLOCK
+    BSQ_BLOCK,
+    DAO_STATE
 }

common/src/main/java/bisq/common/util/Utilities.java

@@ -161,7 +161,7 @@ public static ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor(String
     public static boolean isMacMenuBarDarkMode() {
         try {
             // check for exit status only. Once there are more modes than "dark" and "default", we might need to analyze string contents..
-            final Process process = Runtime.getRuntime().exec(new String[] {"defaults", "read", "-g", "AppleInterfaceStyle"});
+            Process process = Runtime.getRuntime().exec(new String[]{"defaults", "read", "-g", "AppleInterfaceStyle"});
             process.waitFor(100, TimeUnit.MILLISECONDS);
             return process.exitValue() == 0;
         } catch (IOException | InterruptedException | IllegalThreadStateException ex) {
@@ -512,15 +512,29 @@ public static void checkCryptoPolicySetup() throws NoSuchAlgorithmException, Lim
             throw new LimitedKeyStrengthException();
     }
 
+    public static String toTruncatedString(Object message) {
+        return toTruncatedString(message, 200, true);
+    }
+
     public static String toTruncatedString(Object message, int maxLength) {
-        if (message != null) {
-            return StringUtils.abbreviate(message.toString(), maxLength).replace("\n", "");
-        }
-        return "null";
+        return toTruncatedString(message, maxLength, true);
     }
 
-    public static String toTruncatedString(Object message) {
-        return toTruncatedString(message, 200);
+    public static String toTruncatedString(Object message, boolean removeLinebreaks) {
+        return toTruncatedString(message, 200, removeLinebreaks);
+    }
+
+    public static String toTruncatedString(Object message, int maxLength, boolean removeLinebreaks) {
+        if (message == null)
+            return "null";
+
+
+        String result = StringUtils.abbreviate(message.toString(), maxLength);
+        if (removeLinebreaks)
+            return result.replace("\n", "");
+
+        return result;
+
     }
 
     public static String getRandomPrefix(int minLength, int maxLength) {

common/src/main/proto/pb.proto

@@ -57,6 +57,9 @@ message NetworkEnvelope {
         AddPersistableNetworkPayloadMessage add_persistable_network_payload_message = 31;
         AckMessage ack_message = 32;
         RepublishGovernanceDataRequest republish_governance_data_request = 33;
+        NewDaoStateHashMessage new_dao_state_hash_message = 34;
+        GetDaoStateHashRequest get_dao_state_hash_request = 35;
+        GetDaoStateHashResponse get_dao_state_hash_response = 36;
     }
 }
 
@@ -324,6 +327,16 @@ message NewBlockBroadcastMessage {
 message RepublishGovernanceDataRequest {
 }
 
+message GetDaoStateHashRequest {
+    int32 from_block_height = 1;
+    int32 nonce = 2;
+}
+
+message GetDaoStateHashResponse {
+    repeated DaoStateHash dao_state_hashes = 1;
+    int32 request_nonce = 2;
+}
+
 ///////////////////////////////////////////////////////////////////////////////////////////
 // Payload
 ///////////////////////////////////////////////////////////////////////////////////////////
@@ -1713,6 +1726,17 @@ message DecryptedBallotsWithMerits {
 
 message DaoStateStore {
     BsqState bsq_state = 1;
+    repeated DaoStateHash dao_state_hash = 2;
+}
+
+message DaoStateHash {
+    int32 blockHeight = 1;
+    bytes hash = 2;
+    bytes prev_hash = 3;
+}
+
+message NewDaoStateHashMessage {
+    DaoStateHash dao_state_hash = 1;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////

core/src/main/java/bisq/core/btc/BitcoinModule.java

@@ -56,9 +56,12 @@ public BitcoinModule(Environment environment) {
     protected void configure() {
         // We we have selected BTC_DAO_TESTNET we use our master regtest node, otherwise the specified host or default
         // (localhost)
-        String regTestHost = BisqEnvironment.getBaseCurrencyNetwork().isDaoTestNet() ?
-                "104.248.31.39" :
-                environment.getProperty(BtcOptionKeys.REG_TEST_HOST, String.class, RegTestHost.DEFAULT_HOST);
+        String regTestHost = environment.getProperty(BtcOptionKeys.REG_TEST_HOST, String.class, "");
+        if (regTestHost.isEmpty()) {
+            regTestHost = BisqEnvironment.getBaseCurrencyNetwork().isDaoTestNet() ?
+                    "104.248.31.39" :
+                    RegTestHost.DEFAULT_HOST;
+        }
 
         RegTestHost.HOST = regTestHost;
         if (Arrays.asList("localhost", "127.0.0.1").contains(regTestHost)) {

core/src/main/java/bisq/core/dao/DaoModule.java

@@ -73,11 +73,14 @@
 import bisq.core.dao.node.lite.network.LiteNodeNetworkService;
 import bisq.core.dao.node.parser.BlockParser;
 import bisq.core.dao.node.parser.TxParser;
+import bisq.core.dao.state.DaoEventCoordinator;
 import bisq.core.dao.state.DaoStateService;
 import bisq.core.dao.state.DaoStateSnapshotService;
 import bisq.core.dao.state.DaoStateStorageService;
 import bisq.core.dao.state.GenesisTxInfo;
 import bisq.core.dao.state.model.DaoState;
+import bisq.core.dao.state.monitoring.DaoStateMonitoringService;
+import bisq.core.dao.state.monitoring.network.DaoStateNetworkService;
 import bisq.core.dao.state.unconfirmed.UnconfirmedBsqChangeOutputListService;
 
 import bisq.common.app.AppModule;
@@ -99,6 +102,7 @@ public DaoModule(Environment environment) {
     protected void configure() {
         bind(DaoSetup.class).in(Singleton.class);
         bind(DaoFacade.class).in(Singleton.class);
+        bind(DaoEventCoordinator.class).in(Singleton.class);
         bind(DaoKillSwitch.class).in(Singleton.class);
 
         // Node, parser
@@ -116,6 +120,8 @@ protected void configure() {
         bind(DaoStateService.class).in(Singleton.class);
         bind(DaoStateSnapshotService.class).in(Singleton.class);
         bind(DaoStateStorageService.class).in(Singleton.class);
+        bind(DaoStateMonitoringService.class).in(Singleton.class);
+        bind(DaoStateNetworkService.class).in(Singleton.class);
         bind(UnconfirmedBsqChangeOutputListService.class).in(Singleton.class);
 
         bind(ExportJsonFilesService.class).in(Singleton.class);

core/src/main/java/bisq/core/dao/DaoSetup.java

@@ -34,7 +34,9 @@
 import bisq.core.dao.node.BsqNode;
 import bisq.core.dao.node.BsqNodeProvider;
 import bisq.core.dao.node.explorer.ExportJsonFilesService;
+import bisq.core.dao.state.DaoEventCoordinator;
 import bisq.core.dao.state.DaoStateService;
+import bisq.core.dao.state.monitoring.DaoStateMonitoringService;
 
 import com.google.inject.Inject;
 
@@ -69,11 +71,18 @@ public DaoSetup(BsqNodeProvider bsqNodeProvider,
                     ProofOfBurnService proofOfBurnService,
                     DaoFacade daoFacade,
                     ExportJsonFilesService exportJsonFilesService,
-                    DaoKillSwitch daoKillSwitch) {
+                    DaoKillSwitch daoKillSwitch,
+                    DaoStateMonitoringService daoStateMonitoringService,
+                    DaoEventCoordinator daoEventCoordinator) {
 
         bsqNode = bsqNodeProvider.getBsqNode();
 
         // We need to take care of order of execution.
+
+        // For order critical event flow we use the daoEventCoordinator to delegate the calls from anonymous listeners
+        // to concrete clients.
+        daoSetupServices.add(daoEventCoordinator);
+
         daoSetupServices.add(daoStateService);
         daoSetupServices.add(cycleService);
         daoSetupServices.add(ballotListService);
@@ -92,6 +101,8 @@ public DaoSetup(BsqNodeProvider bsqNodeProvider,
         daoSetupServices.add(daoFacade);
         daoSetupServices.add(exportJsonFilesService);
         daoSetupServices.add(daoKillSwitch);
+        daoSetupServices.add(daoStateMonitoringService);
+
         daoSetupServices.add(bsqNodeProvider.getBsqNode());
     }
 

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

@@ -105,7 +105,7 @@ public void onParseBlockChainComplete() {
 
     @Override
     public void onAdded(PersistableNetworkPayload payload) {
-        onAppendOnlyDataAdded(payload);
+        onAppendOnlyDataAdded(payload, true);
     }
 
 
@@ -126,10 +126,10 @@ public List<BlindVote> getBlindVotesInPhaseAndCycle() {
     ///////////////////////////////////////////////////////////////////////////////////////////
 
     private void fillListFromAppendOnlyDataStore() {
-        p2PService.getP2PDataStorage().getAppendOnlyDataStoreMap().values().forEach(this::onAppendOnlyDataAdded);
+        p2PService.getP2PDataStorage().getAppendOnlyDataStoreMap().values().forEach(e -> onAppendOnlyDataAdded(e, false));
     }
 
-    private void onAppendOnlyDataAdded(PersistableNetworkPayload persistableNetworkPayload) {
+    private void onAppendOnlyDataAdded(PersistableNetworkPayload persistableNetworkPayload, boolean doLog) {
         if (persistableNetworkPayload instanceof BlindVotePayload) {
             BlindVotePayload blindVotePayload = (BlindVotePayload) persistableNetworkPayload;
             if (!blindVotePayloads.contains(blindVotePayload)) {
@@ -140,7 +140,9 @@ private void onAppendOnlyDataAdded(PersistableNetworkPayload persistableNetworkP
                 if (blindVoteValidator.areDataFieldsValid(blindVote)) {
                     // We don't validate as we might receive blindVotes from other cycles or phases at startup.
                     blindVotePayloads.add(blindVotePayload);
-                    log.info("We received a blindVotePayload. blindVoteTxId={}", txId);
+                    if (doLog) {
+                        log.info("We received a blindVotePayload. blindVoteTxId={}", txId);
+                    }
                 } else {
                     log.warn("We received an invalid blindVotePayload. blindVoteTxId={}", txId);
                 }

core/src/main/java/bisq/core/dao/governance/period/CycleService.java

@@ -79,7 +79,7 @@ public void start() {
     public void onNewBlockHeight(int blockHeight) {
         if (blockHeight != genesisBlockHeight)
             maybeCreateNewCycle(blockHeight, daoStateService.getCycles())
-                    .ifPresent(daoStateService.getCycles()::add);
+                    .ifPresent(daoStateService::addCycle);
     }
 
 
@@ -88,7 +88,7 @@ public void onNewBlockHeight(int blockHeight) {
     ///////////////////////////////////////////////////////////////////////////////////////////
 
     public void addFirstCycle() {
-        daoStateService.getCycles().add(getFirstCycle());
+        daoStateService.addCycle(getFirstCycle());
     }
 
     public int getCycleIndex(Cycle cycle) {

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

@@ -131,7 +131,7 @@ public void start() {
 
     @Override
     public void onAdded(ProtectedStorageEntry entry) {
-        onProtectedDataAdded(entry);
+        onProtectedDataAdded(entry, true);
     }
 
     @Override
@@ -146,7 +146,7 @@ public void onRemoved(ProtectedStorageEntry entry) {
 
     @Override
     public void onAdded(PersistableNetworkPayload payload) {
-        onAppendOnlyDataAdded(payload);
+        onAppendOnlyDataAdded(payload, true);
     }
 
 
@@ -190,11 +190,11 @@ public List<Proposal> getValidatedProposals() {
     ///////////////////////////////////////////////////////////////////////////////////////////
 
     private void fillListFromProtectedStore() {
-        p2PService.getDataMap().values().forEach(this::onProtectedDataAdded);
+        p2PService.getDataMap().values().forEach(e -> onProtectedDataAdded(e, false));
     }
 
     private void fillListFromAppendOnlyDataStore() {
-        p2PService.getP2PDataStorage().getAppendOnlyDataStoreMap().values().forEach(this::onAppendOnlyDataAdded);
+        p2PService.getP2PDataStorage().getAppendOnlyDataStoreMap().values().forEach(e -> onAppendOnlyDataAdded(e, false));
     }
 
     private void publishToAppendOnlyDataStore() {
@@ -211,16 +211,18 @@ private void publishToAppendOnlyDataStore() {
                 });
     }
 
-    private void onProtectedDataAdded(ProtectedStorageEntry entry) {
+    private void onProtectedDataAdded(ProtectedStorageEntry entry, boolean doLog) {
         ProtectedStoragePayload protectedStoragePayload = entry.getProtectedStoragePayload();
         if (protectedStoragePayload instanceof TempProposalPayload) {
             Proposal proposal = ((TempProposalPayload) protectedStoragePayload).getProposal();
             // We do not validate if we are in current cycle and if tx is confirmed yet as the tx might be not
             // available/confirmed. But we check if we are in the proposal phase.
             if (!tempProposals.contains(proposal)) {
                 if (proposalValidator.isValidOrUnconfirmed(proposal)) {
-                    log.info("We received a TempProposalPayload and store it to our protectedStoreList. proposalTxId={}",
-                            proposal.getTxId());
+                    if (doLog) {
+                        log.info("We received a TempProposalPayload and store it to our protectedStoreList. proposalTxId={}",
+                                proposal.getTxId());
+                    }
                     tempProposals.add(proposal);
                 } else {
                     log.debug("We received an invalid proposal from the P2P network. Proposal.txId={}, blockHeight={}",
@@ -256,14 +258,16 @@ private void onProtectedDataRemoved(ProtectedStorageEntry entry) {
         }
     }
 
-    private void onAppendOnlyDataAdded(PersistableNetworkPayload persistableNetworkPayload) {
+    private void onAppendOnlyDataAdded(PersistableNetworkPayload persistableNetworkPayload, boolean doLog) {
         if (persistableNetworkPayload instanceof ProposalPayload) {
             ProposalPayload proposalPayload = (ProposalPayload) persistableNetworkPayload;
             if (!proposalPayloads.contains(proposalPayload)) {
                 Proposal proposal = proposalPayload.getProposal();
                 if (proposalValidator.areDataFieldsValid(proposal)) {
-                    log.info("We received a ProposalPayload and store it to our appendOnlyStoreList. proposalTxId={}",
-                            proposal.getTxId());
+                    if (doLog) {
+                        log.info("We received a ProposalPayload and store it to our appendOnlyStoreList. proposalTxId={}",
+                                proposal.getTxId());
+                    }
                     proposalPayloads.add(proposalPayload);
                 } else {
                     log.warn("We received a invalid append-only proposal from the P2P network. " +

core/src/main/java/bisq/core/dao/governance/voteresult/VoteResultService.java

@@ -235,6 +235,7 @@ private void maybeCalculateVoteResult(int chainHeight) {
             }
 
             // Those which did not get accepted will be added to the nonBsq map
+            // FIXME add check for cycle as now we call addNonBsqTxOutput for past rejected comp requests as well
             daoStateService.getIssuanceCandidateTxOutputs().stream()
                     .filter(txOutput -> !daoStateService.isIssuanceTx(txOutput.getTxId()))
                     .forEach(daoStateService::addNonBsqTxOutput);
@@ -304,6 +305,8 @@ private Function<TxOutput, DecryptedBallotsWithMerits> txOutputToDecryptedBallot
                     return getDecryptedBallotsWithMerits(voteRevealTxId, currentCycle, voteRevealOpReturnData,
                             blindVoteTxId, hashOfBlindVoteList, blindVoteStake, optionalBlindVote.get());
                 }
+
+                // We are missing P2P network data
                 return getEmptyDecryptedBallotsWithMerits(voteRevealTxId, blindVoteTxId, hashOfBlindVoteList,
                         blindVoteStake);
             } catch (Throwable e) {

core/src/main/java/bisq/core/dao/node/full/FullNode.java

@@ -185,7 +185,9 @@ private void parseBlocksIfNewBlockAvailable(int chainHeight) {
                     } else {
                         log.info("parseBlocksIfNewBlockAvailable did not result in a new block, so we complete.");
                         log.info("parse {} blocks took {} seconds", blocksToParseInBatch, (System.currentTimeMillis() - parseInBatchStartTime) / 1000d);
-                        onParseBlockChainComplete();
+                        if (!parseBlockchainComplete) {
+                            onParseBlockChainComplete();
+                        }
                     }
                 },
                 this::handleError);

core/src/main/java/bisq/core/dao/node/full/RpcService.java

@@ -74,7 +74,6 @@ public class RpcService {
     private final String rpcPassword;
     private final String rpcPort;
     private final String rpcBlockPort;
-    private final boolean dumpBlockchainData;
 
     private BtcdClient client;
     private BtcdDaemon daemon;
@@ -92,8 +91,7 @@ public class RpcService {
     @Inject
     public RpcService(Preferences preferences,
                       @Named(DaoOptionKeys.RPC_PORT) String rpcPort,
-                      @Named(DaoOptionKeys.RPC_BLOCK_NOTIFICATION_PORT) String rpcBlockPort,
-                      @Named(DaoOptionKeys.DUMP_BLOCKCHAIN_DATA) boolean dumpBlockchainData) {
+                      @Named(DaoOptionKeys.RPC_BLOCK_NOTIFICATION_PORT) String rpcBlockPort) {
         this.rpcUser = preferences.getRpcUser();
         this.rpcPassword = preferences.getRpcPw();
 
@@ -109,8 +107,6 @@ public RpcService(Preferences preferences,
                                         "18443"; // regtest
         this.rpcBlockPort = rpcBlockPort != null && !rpcBlockPort.isEmpty() ? rpcBlockPort : "5125";
 
-        this.dumpBlockchainData = dumpBlockchainData;
-
         log.info("Version of btcd-cli4j library: {}", BtcdCli4jVersion.VERSION);
     }
 
@@ -305,7 +301,7 @@ private RawTx getTxFromRawTransaction(RawTransaction rawBtcTx, com.neemre.btcdcl
                             // We don't support raw MS which are the only case where scriptPubKey.getAddresses()>1
                             String address = scriptPubKey.getAddresses() != null &&
                                     scriptPubKey.getAddresses().size() == 1 ? scriptPubKey.getAddresses().get(0) : null;
-                    PubKeyScript pubKeyScript = dumpBlockchainData ? new PubKeyScript(scriptPubKey) : null;
+                    PubKeyScript pubKeyScript = new PubKeyScript(scriptPubKey);
                     return new RawTxOutput(rawBtcTxOutput.getN(),
                             rawBtcTxOutput.getValue().movePointRight(8).longValue(),
                             rawBtcTx.getTxId(),