Add burningman accounting

common/src/main/java/bisq/common/config/Config.java

@@ -129,6 +129,9 @@ public class Config {
     public static final String BYPASS_MEMPOOL_VALIDATION = "bypassMempoolValidation";
     public static final String DAO_NODE_API_URL = "daoNodeApiUrl";
     public static final String DAO_NODE_API_PORT = "daoNodeApiPort";
+    public static final String IS_BM_FULL_NODE = "isBmFullNode";
+    public static final String BM_ORACLE_NODE_PUB_KEY = "bmOracleNodePubKey";
+    public static final String BM_ORACLE_NODE_PRIV_KEY = "bmOracleNodePrivKey";
     public static final String SEED_NODE_REPORTING_SERVER_URL = "seedNodeReportingServerUrl";
 
     // Default values for certain options
@@ -221,6 +224,9 @@ public class Config {
     public final boolean bypassMempoolValidation;
     public final String daoNodeApiUrl;
     public final int daoNodeApiPort;
+    public final boolean isBmFullNode;
+    public final String bmOracleNodePubKey;
+    public final String bmOracleNodePrivKey;
     public final String seedNodeReportingServerUrl;
 
     // Properties derived from options but not exposed as options themselves
@@ -681,6 +687,23 @@ public Config(String defaultAppName, File defaultUserDataDir, String... args) {
                         .withRequiredArg()
                         .ofType(Integer.class)
                         .defaultsTo(8082);
+
+        ArgumentAcceptingOptionSpec<Boolean> isBmFullNode =
+                parser.accepts(IS_BM_FULL_NODE, "Run as Burningman full node")
+                        .withRequiredArg()
+                        .ofType(boolean.class)
+                        .defaultsTo(false);
+
+        ArgumentAcceptingOptionSpec<String> bmOracleNodePubKey =
+                parser.accepts(BM_ORACLE_NODE_PUB_KEY, "Burningman oracle node public key")
+                        .withRequiredArg()
+                        .defaultsTo("");
+
+        ArgumentAcceptingOptionSpec<String> bmOracleNodePrivKey =
+                parser.accepts(BM_ORACLE_NODE_PRIV_KEY, "Burningman oracle node private key")
+                        .withRequiredArg()
+                        .defaultsTo("");
+
         ArgumentAcceptingOptionSpec<String> seedNodeReportingServerUrlOpt =
                 parser.accepts(SEED_NODE_REPORTING_SERVER_URL, "URL of seed node reporting server")
                         .withRequiredArg()
@@ -806,6 +829,9 @@ public Config(String defaultAppName, File defaultUserDataDir, String... args) {
             this.bypassMempoolValidation = options.valueOf(bypassMempoolValidationOpt);
             this.daoNodeApiUrl = options.valueOf(daoNodeApiUrlOpt);
             this.daoNodeApiPort = options.valueOf(daoNodeApiPortOpt);
+            this.isBmFullNode = options.valueOf(isBmFullNode);
+            this.bmOracleNodePubKey = options.valueOf(bmOracleNodePubKey);
+            this.bmOracleNodePrivKey = options.valueOf(bmOracleNodePrivKey);
             this.seedNodeReportingServerUrl = options.valueOf(seedNodeReportingServerUrlOpt);
         } catch (OptionException ex) {
             throw new ConfigException("problem parsing option '%s': %s",

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

@@ -0,0 +1,60 @@
+/*
+ * This file is part of Bisq.
+ *
+ * Bisq is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or (at
+ * your option) any later version.
+ *
+ * Bisq is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with Bisq. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package bisq.common.util;
+
+import java.util.Calendar;
+import java.util.Date;
+import java.util.GregorianCalendar;
+
+public class DateUtil {
+    /**
+     *
+     * @param date      The date which should be reset to first day of month
+     * @return First day in given date with time set to zero.
+     */
+    public static Date getStartOfMonth(Date date) {
+        Calendar calendar = new GregorianCalendar();
+        calendar.setTime(date);
+        calendar.set(Calendar.DAY_OF_MONTH, 1);
+        calendar.set(Calendar.HOUR_OF_DAY, 0);
+        calendar.set(Calendar.MINUTE, 0);
+        calendar.set(Calendar.SECOND, 0);
+        calendar.set(Calendar.MILLISECOND, 0);
+        return calendar.getTime();
+    }
+
+    /**
+     *
+     * @param year      The year
+     * @param month     The month starts with 0 for January
+     * @return First day in given month with time set to zero.
+     */
+    public static Date getStartOfMonth(int year, int month) {
+        Calendar calendar = new GregorianCalendar();
+        calendar.setTime(new Date());
+        calendar.set(Calendar.YEAR, year);
+        calendar.set(Calendar.MONTH, month);
+        calendar.set(Calendar.DAY_OF_MONTH, 1);
+        calendar.set(Calendar.HOUR_OF_DAY, 0);
+        calendar.set(Calendar.MINUTE, 0);
+        calendar.set(Calendar.SECOND, 0);
+        calendar.set(Calendar.MILLISECOND, 0);
+        Date time = calendar.getTime();
+        return time;
+    }
+}

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

@@ -28,4 +28,8 @@ public static byte[] decode(String hex) {
     public static String encode(byte[] bytes) {
         return BaseEncoding.base16().lowerCase().encode(bytes);
     }
+
+    public static byte[] decodeLast4Bytes(String hex) {
+        return decode(hex.substring(hex.length() - 8));
+    }
 }

core/src/main/java/bisq/core/btc/wallet/BsqWalletService.java

@@ -591,7 +591,7 @@ private Transaction getPreparedSendTx(String receiverAddress,
             coinSelector.setUtxoCandidates(null);   // We reuse the selectors. Reset the transactionOutputCandidates field
             return tx;
         } catch (InsufficientMoneyException e) {
-            log.error("getPreparedSendTx: tx={}", tx.toString());
+            log.error("getPreparedSendTx: tx={}", tx);
             log.error(e.toString());
             throw new InsufficientBsqException(e.missing);
         }

core/src/main/java/bisq/core/btc/wallet/TradeWalletService.java

@@ -76,7 +76,7 @@
 
 public class TradeWalletService {
     private static final Logger log = LoggerFactory.getLogger(TradeWalletService.class);
-    private static final Coin MIN_DELAYED_PAYOUT_TX_FEE = Coin.valueOf(1000);
+    public static final Coin MIN_DELAYED_PAYOUT_TX_FEE = Coin.valueOf(1000);
 
     private final WalletsSetup walletsSetup;
     private final Preferences preferences;
@@ -696,16 +696,31 @@ public void sellerAddsBuyerWitnessesToDepositTx(Transaction myDepositTx,
     // Delayed payout tx
     ///////////////////////////////////////////////////////////////////////////////////////////
 
+    public Transaction createDelayedUnsignedPayoutTx(Transaction depositTx,
+                                                     List<Tuple2<Long, String>> receivers,
+                                                     long lockTime)
+            throws AddressFormatException, TransactionVerificationException {
+        TransactionOutput depositTxOutput = depositTx.getOutput(0);
+        Transaction delayedPayoutTx = new Transaction(params);
+        delayedPayoutTx.addInput(depositTxOutput);
+        applyLockTime(lockTime, delayedPayoutTx);
+        checkArgument(!receivers.isEmpty(), "receivers must not be empty");
+        receivers.forEach(receiver -> delayedPayoutTx.addOutput(Coin.valueOf(receiver.first), Address.fromString(params, receiver.second)));
+        WalletService.printTx("Unsigned delayedPayoutTx ToDonationAddress", delayedPayoutTx);
+        WalletService.verifyTransaction(delayedPayoutTx);
+        return delayedPayoutTx;
+    }
+
     public Transaction createDelayedUnsignedPayoutTx(Transaction depositTx,
                                                      String donationAddressString,
                                                      Coin minerFee,
                                                      long lockTime)
             throws AddressFormatException, TransactionVerificationException {
-        TransactionOutput hashedMultiSigOutput = depositTx.getOutput(0);
+        TransactionOutput depositTxOutput = depositTx.getOutput(0);
         Transaction delayedPayoutTx = new Transaction(params);
-        delayedPayoutTx.addInput(hashedMultiSigOutput);
+        delayedPayoutTx.addInput(depositTxOutput);
         applyLockTime(lockTime, delayedPayoutTx);
-        Coin outputAmount = hashedMultiSigOutput.getValue().subtract(minerFee);
+        Coin outputAmount = depositTxOutput.getValue().subtract(minerFee);
         delayedPayoutTx.addOutput(outputAmount, Address.fromString(params, donationAddressString));
         WalletService.printTx("Unsigned delayedPayoutTx ToDonationAddress", delayedPayoutTx);
         WalletService.verifyTransaction(delayedPayoutTx);

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

@@ -0,0 +1,127 @@
+/*
+ * This file is part of Bisq.
+ *
+ * Bisq is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or (at
+ * your option) any later version.
+ *
+ * Bisq is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with Bisq. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package bisq.core.dao;
+
+import bisq.core.dao.governance.period.CycleService;
+import bisq.core.dao.state.DaoStateService;
+import bisq.core.dao.state.model.governance.Cycle;
+import bisq.core.dao.state.model.governance.DaoPhase;
+
+import javax.inject.Inject;
+import javax.inject.Singleton;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+
+import lombok.extern.slf4j.Slf4j;
+
+/**
+ * Utility methods for Cycle related methods.
+ * As they might be called often we use caching.
+ */
+@Slf4j
+@Singleton
+public class CyclesInDaoStateService {
+    private final DaoStateService daoStateService;
+    private final CycleService cycleService;
+
+    // Cached results
+    private final Map<Integer, Cycle> cyclesByHeight = new HashMap<>();
+    private final Map<Cycle, Integer> indexByCycle = new HashMap<>();
+    private final Map<Integer, Cycle> cyclesByIndex = new HashMap<>();
+
+    @Inject
+    public CyclesInDaoStateService(DaoStateService daoStateService, CycleService cycleService) {
+        this.daoStateService = daoStateService;
+        this.cycleService = cycleService;
+    }
+
+    public int getCycleIndexAtChainHeight(int chainHeight) {
+        return findCycleAtHeight(chainHeight)
+                .map(cycleService::getCycleIndex)
+                .orElse(-1);
+    }
+
+    public int getHeightOfFirstBlockOfResultPhaseOfPastCycle(int chainHeight, int numPastCycles) {
+        return findCycleAtHeight(chainHeight)
+                .map(cycle -> {
+                    int cycleIndex = getIndexForCycle(cycle);
+                    int targetIndex = Math.max(0, (cycleIndex - numPastCycles));
+                    return getCycleAtIndex(targetIndex);
+                })
+                .map(cycle -> cycle.getFirstBlockOfPhase(DaoPhase.Phase.RESULT))
+                .orElse(daoStateService.getGenesisBlockHeight());
+    }
+
+    /**
+     *
+     * @param chainHeight       Chain height from where we start
+     * @param numPastCycles     Number of past cycles
+     * @return The height at the same offset from the first block of the cycle as in the current cycle minus the past cycles.
+     */
+    public int getChainHeightOfPastCycle(int chainHeight, int numPastCycles) {
+        int firstBlockOfPastCycle = getHeightOfFirstBlockOfPastCycle(chainHeight, numPastCycles);
+        if (firstBlockOfPastCycle == daoStateService.getGenesisBlockHeight()) {
+            return firstBlockOfPastCycle;
+        }
+        return firstBlockOfPastCycle + getOffsetFromFirstBlockInCycle(chainHeight);
+    }
+
+    public Integer getOffsetFromFirstBlockInCycle(int chainHeight) {
+        return daoStateService.getCycle(chainHeight)
+                .map(c -> chainHeight - c.getHeightOfFirstBlock())
+                .orElse(0);
+    }
+
+    public int getHeightOfFirstBlockOfPastCycle(int chainHeight, int numPastCycles) {
+        return findCycleAtHeight(chainHeight)
+                .map(cycle -> getIndexForCycle(cycle) - numPastCycles)
+                .filter(targetIndex -> targetIndex > 0)
+                .map(targetIndex -> getCycleAtIndex(targetIndex).getHeightOfFirstBlock())
+                .orElse(daoStateService.getGenesisBlockHeight());
+    }
+
+    public Cycle getCycleAtIndex(int index) {
+        int cycleIndex = Math.max(0, index);
+        return Optional.ofNullable(cyclesByIndex.get(cycleIndex))
+                .orElseGet(() -> {
+                    Cycle cycle = daoStateService.getCycleAtIndex(cycleIndex);
+                    cyclesByIndex.put(cycleIndex, cycle);
+                    return cycle;
+                });
+    }
+
+    public int getIndexForCycle(Cycle cycle) {
+        return Optional.ofNullable(indexByCycle.get(cycle))
+                .orElseGet(() -> {
+                    int index = cycleService.getCycleIndex(cycle);
+                    indexByCycle.put(cycle, index);
+                    return index;
+                });
+    }
+
+    public Optional<Cycle> findCycleAtHeight(int chainHeight) {
+        return Optional.ofNullable(cyclesByHeight.get(chainHeight))
+                .or(() -> {
+                    Optional<Cycle> optionalCycle = daoStateService.getCycle(chainHeight);
+                    optionalCycle.ifPresent(cycle -> cyclesByHeight.put(chainHeight, cycle));
+                    return optionalCycle;
+                });
+    }
+}

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

@@ -252,11 +252,13 @@ public ObservableList<Proposal> getActiveOrMyUnconfirmedProposals() {
     // Creation of Proposal and proposalTransaction
     public ProposalWithTransaction getCompensationProposalWithTransaction(String name,
                                                                           String link,
-                                                                          Coin requestedBsq)
+                                                                          Coin requestedBsq,
+                                                                          Optional<String> burningManReceiverAddress)
             throws ProposalValidationException, InsufficientMoneyException, TxException {
         return compensationProposalFactory.createProposalWithTransaction(name,
                 link,
-                requestedBsq);
+                requestedBsq,
+                burningManReceiverAddress);
     }
 
     public ProposalWithTransaction getReimbursementProposalWithTransaction(String name,

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

@@ -222,6 +222,9 @@ protected void configure() {
         bindConstant().annotatedWith(named(Config.RPC_BLOCK_NOTIFICATION_HOST)).to(config.rpcBlockNotificationHost);
         bindConstant().annotatedWith(named(Config.DUMP_BLOCKCHAIN_DATA)).to(config.dumpBlockchainData);
         bindConstant().annotatedWith(named(Config.FULL_DAO_NODE)).to(config.fullDaoNode);
+        bindConstant().annotatedWith(named(Config.IS_BM_FULL_NODE)).to(config.isBmFullNode);
+        bindConstant().annotatedWith(named(Config.BM_ORACLE_NODE_PUB_KEY)).to(config.bmOracleNodePubKey);
+        bindConstant().annotatedWith(named(Config.BM_ORACLE_NODE_PRIV_KEY)).to(config.bmOracleNodePrivKey);
     }
 }
 

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

@@ -17,6 +17,9 @@
 
 package bisq.core.dao;
 
+import bisq.core.dao.burningman.accounting.BurningManAccountingService;
+import bisq.core.dao.burningman.accounting.node.AccountingNode;
+import bisq.core.dao.burningman.accounting.node.AccountingNodeProvider;
 import bisq.core.dao.governance.asset.AssetService;
 import bisq.core.dao.governance.ballot.BallotListService;
 import bisq.core.dao.governance.blindvote.BlindVoteListService;
@@ -54,9 +57,11 @@
 public class DaoSetup {
     private final BsqNode bsqNode;
     private final List<DaoSetupService> daoSetupServices = new ArrayList<>();
+    private final AccountingNode accountingNode;
 
     @Inject
     public DaoSetup(BsqNodeProvider bsqNodeProvider,
+                    AccountingNodeProvider accountingNodeProvider,
                     DaoStateService daoStateService,
                     CycleService cycleService,
                     BallotListService ballotListService,
@@ -79,9 +84,11 @@ public DaoSetup(BsqNodeProvider bsqNodeProvider,
                     DaoStateMonitoringService daoStateMonitoringService,
                     ProposalStateMonitoringService proposalStateMonitoringService,
                     BlindVoteStateMonitoringService blindVoteStateMonitoringService,
-                    DaoStateSnapshotService daoStateSnapshotService) {
+                    DaoStateSnapshotService daoStateSnapshotService,
+                    BurningManAccountingService burningManAccountingService) {
 
         bsqNode = bsqNodeProvider.getBsqNode();
+        accountingNode = accountingNodeProvider.getAccountingNode();
 
         // We need to take care of order of execution.
         daoSetupServices.add(daoStateService);
@@ -107,15 +114,20 @@ public DaoSetup(BsqNodeProvider bsqNodeProvider,
         daoSetupServices.add(proposalStateMonitoringService);
         daoSetupServices.add(blindVoteStateMonitoringService);
         daoSetupServices.add(daoStateSnapshotService);
+        daoSetupServices.add(burningManAccountingService);
 
-        daoSetupServices.add(bsqNodeProvider.getBsqNode());
+        daoSetupServices.add(bsqNode);
+        daoSetupServices.add(accountingNode);
     }
 
     public void onAllServicesInitialized(Consumer<String> errorMessageHandler,
                                          Consumer<String> warnMessageHandler) {
         bsqNode.setErrorMessageHandler(errorMessageHandler);
         bsqNode.setWarnMessageHandler(warnMessageHandler);
 
+        accountingNode.setErrorMessageHandler(errorMessageHandler);
+        accountingNode.setWarnMessageHandler(warnMessageHandler);
+
         // We add first all listeners at all services and then call the start methods.
         // Some services are listening on others so we need to make sure that the
         // listeners are set before we call start as that might trigger state change
@@ -126,5 +138,6 @@ public void onAllServicesInitialized(Consumer<String> errorMessageHandler,
 
     public void shutDown() {
         bsqNode.shutDown();
+        accountingNode.shutDown();
     }
 }