[FEAT] Add some features and fix few bugs:

- Now multiple loggers can be used for a single scenario run
- Some refactoring for names
- Added new compact block for bitcoin according to BIP158
- Newer bitcoin nodes support compact blocks
- Lowered the number of default nodes in Bitcoin network to a number close to 8000 (reported by https://www.dsn.kastel.kit.edu/bitcoin/) which is seems to be closer to reality than 16000 reported by https://bitnodes.io/
- Added new logging event: BlockchainReorgEvent
- Added new logger for block propagation delay

Author: hyajam

README.md

@@ -105,7 +105,7 @@ Currently, the following consensus algorithms are implemented in JABS:
 ## Roadmap ##
 
 - [x] Add new block mining process that can support adjustable difficulty.
-- [ ] Add multiple loggers and scenarios in main class.
+- [x] Add multiple loggers and scenarios in main class.
 - [ ] Add detailed comparison with other simulators in README.md.
 - [ ] Add new network latency stats that has countries instead of continents.
 - [ ] Add events for network churn.

src/main/java/jabs/Main.java

@@ -1,12 +1,13 @@
 package jabs;
 
-import jabs.log.AbstractLogger;
-import jabs.log.BlockConfirmationLogger;
-import jabs.log.BlockGenerationLogger;
+import jabs.log.*;
+import jabs.network.stats.sixglobalregions.GlobalNetworkStats6Region;
+import jabs.network.stats.sixglobalregions.SixRegions;
 import jabs.scenario.AbstractScenario;
 import jabs.scenario.BitcoinGlobalNetworkScenario;
 import jabs.scenario.NormalEthereumNetworkScenario;
 import jabs.scenario.PBFTLANScenario;
+import jabs.simulator.randengine.RandomnessEngine;
 
 import java.io.IOException;
 import java.nio.file.Paths;
@@ -21,28 +22,33 @@ public class Main {
      */
     public static void main(String[] args) throws IOException {
         AbstractScenario scenario;
-        AbstractLogger logger;
 
         // Simulate one day in the life of Bitcoin network
         // Nakamoto protocol with block every 600 seconds
-        // Around 16000 nodes with 30 miners
-        logger = new BlockConfirmationLogger(Paths.get("_output/bitcoin-simulation-log.csv"));
-        scenario = new BitcoinGlobalNetworkScenario("One day in the life of Bitcoin", 1, logger,
+        // Around 8000 nodes with 30 miners
+        scenario = new BitcoinGlobalNetworkScenario("One day in the life of Bitcoin", 1,
                 86400, 600, 6);
+        scenario.AddNewLogger(new BlockchainReorgLogger(Paths.get("_output/bitcoin-reorgs-log.csv")));
+        scenario.AddNewLogger(new BlockConfirmationLogger(Paths.get("_output/bitcoin-confirmations-log.csv")));
+        scenario.AddNewLogger(new BlockDeliveryLogger(Paths.get("_output/bitcoin-block-delivery-log.csv")));
+        scenario.AddNewLogger(new BlockPropagationDelayLogger(
+                Paths.get("_output/bitcoin-50-propagation-delay-log.csv"),0.5));
+        scenario.AddNewLogger(new BlockPropagationDelayLogger(
+                Paths.get("_output/bitcoin-90-propagation-delay-log.csv"),0.9));
         scenario.run();
 
         // Simulate 1 hour in the life of Ethereum network
         // Ghost protocol with blocks every 14 seconds on average
         // Around 6000 nodes with 37 miners
-        logger = new BlockGenerationLogger(Paths.get("_output/ethereum-simulation-log.csv"));
-        scenario = new NormalEthereumNetworkScenario("One day in the life of Ethereum", 1, logger,
+        scenario = new NormalEthereumNetworkScenario("One hour in the life of Ethereum", 1,
                 3600, 14);
+        scenario.AddNewLogger(new BlockGenerationLogger(Paths.get("_output/ethereum-simulation-log.csv")));
         scenario.run();
 
         // Simulate PBFT Lan network of 40 nodes for 1 hour
-        logger = new BlockGenerationLogger(Paths.get("_output/pbft-simulation-log.csv"));
-        scenario = new PBFTLANScenario("24 hours of a PBFT lan Network", 1, logger,
+        scenario = new PBFTLANScenario("One hour of a PBFT lan Network", 1,
                 40, 3600);
+        scenario.AddNewLogger(new BlockGenerationLogger(Paths.get("_output/pbft-simulation-log.csv")));
         scenario.run();
     }
 }

src/main/java/jabs/consensus/algorithm/NakamotoConsensus.java

@@ -6,23 +6,34 @@
 import jabs.consensus.blockchain.LocalBlockTree;
 import jabs.simulator.Simulator;
 import jabs.simulator.event.BlockConfirmationEvent;
+import jabs.simulator.event.BlockchainReorgEvent;
 
 public class NakamotoConsensus<B extends SingleParentBlock<B>, T extends Tx<T>>
         extends AbstractChainBasedConsensus<B, T> {
-    private int longestChainLen = -1;
+    private int longestChainLen = 0;
     private final double averageBlockMiningInterval;
     private final int confirmationDepth;
 
     public NakamotoConsensus(LocalBlockTree<B> localBlockTree, NakamotoConsensusConfig nakamotoConsensusConfig) {
         super(localBlockTree);
         this.averageBlockMiningInterval = nakamotoConsensusConfig.averageBlockMiningInterval();
         this.confirmationDepth = nakamotoConsensusConfig.getConfirmationDepth();
-        this.newIncomingBlock(localBlockTree.getGenesisBlock());
+        this.currentMainChainHead = localBlockTree.getGenesisBlock();
     }
 
     @Override
     public void newIncomingBlock(B block) {
         if (block.getHeight() > longestChainLen) {
+            if (!(localBlockTree.getAncestorOfHeight(block, this.longestChainLen)
+                    .equals(this.currentMainChainHead))) {
+                Simulator simulator = this.peerDLTNode.getSimulator();
+                double currentTime = simulator.getCurrentTime();
+                simulator.putEvent(
+                        new BlockchainReorgEvent(currentTime, this.peerDLTNode, block,
+                                block.getHeight() - this.longestChainLen),
+                        0
+                );
+            }
             this.longestChainLen = block.getHeight();
             this.currentMainChainHead = block;
             this.updateChain();
@@ -39,7 +50,7 @@ protected void updateChain() {
             double currentTime = simulator.getCurrentTime();
             simulator.putEvent(
                     new BlockConfirmationEvent(currentTime, this.peerDLTNode, highestConfirmedBlock),
-                    currentTime);
+                    0);
         }
     }
 

src/main/java/jabs/ledgerdata/BlockFactory.java

@@ -1,6 +1,6 @@
 package jabs.ledgerdata;
 
-import jabs.ledgerdata.bitcoin.BitcoinBlock;
+import jabs.ledgerdata.bitcoin.BitcoinBlockWithoutTx;
 import jabs.ledgerdata.ethereum.EthereumBlock;
 import jabs.ledgerdata.pbft.PBFTBlock;
 import jabs.network.node.nodes.bitcoin.BitcoinMinerNode;
@@ -22,6 +22,11 @@ public final class BlockFactory {
     public static final int INV_MESSAGE_OVERHEAD = 1;
     public static final int ETHEREUM_HELLO_MESSAGE_SIZE = 16;
 
+    private static final long[] BITCOIN_COMPACT_BLOCK_SIZE_2020_BINS = {
+            30, 3624, 7668, 11910, 16644, 21828, 27558, 30672, 31662, 32544, 33420, 34878, 35544, 36198, 36840, 37476,
+            38130, 38838, 39630, 40674, 42732, 72714
+    };
+
     private static final long[] BITCOIN_BLOCK_SIZE_2020_BINS = {
             196, 119880, 254789, 396047, 553826, 726752, 917631, 1021479, 1054560, 1084003, 1113136, 1138722, 1161695,
             1183942, 1205734, 1227090, 1248408, 1270070, 1293647, 1320186, 1354939, 1423459, 2422858
@@ -36,9 +41,13 @@ public static int sampleBitcoinBlockSize(RandomnessEngine randomnessEngine) {
         return (int) randomnessEngine.sampleDistributionWithBins(BITCOIN_BLOCK_SIZE_2020, BITCOIN_BLOCK_SIZE_2020_BINS);
     }
 
-    public static BitcoinBlock sampleBitcoinBlock(Simulator simulator, RandomnessEngine randomnessEngine,
-                                                  BitcoinMinerNode creator, BitcoinBlock parent, double difficulty) {
-        return new BitcoinBlock(sampleBitcoinBlockSize(randomnessEngine), parent.getHeight() + 1,
+    public static int sampleBitcoinCompactBlockSize(RandomnessEngine randomnessEngine) {
+        return (int) randomnessEngine.sampleDistributionWithBins(BITCOIN_BLOCK_SIZE_2020, BITCOIN_BLOCK_SIZE_2020_BINS);
+    }
+
+    public static BitcoinBlockWithoutTx sampleBitcoinBlock(Simulator simulator, RandomnessEngine randomnessEngine,
+                                                           BitcoinMinerNode creator, BitcoinBlockWithoutTx parent, double difficulty) {
+        return new BitcoinBlockWithoutTx(sampleBitcoinBlockSize(randomnessEngine), parent.getHeight() + 1,
                 simulator.getCurrentTime(), creator, parent, difficulty);
     }
 

src/main/java/jabs/ledgerdata/TxCompactID.java

@@ -0,0 +1,9 @@
+package jabs.ledgerdata;
+
+public class TxCompactID extends BasicData {
+
+    protected TxCompactID(int size) {
+        super(size);
+    }
+
+}

src/main/java/jabs/ledgerdata/bitcoin/BitcoinBlockWithTx.java

@@ -7,13 +7,13 @@
 
 import static jabs.ledgerdata.BlockFactory.BITCOIN_BLOCK_HEADER_SIZE;
 
-public class BitcoinBlockWithTx extends BitcoinBlock {
+public class BitcoinBlockWithTx extends BitcoinBlockWithoutTx {
     private final Set<BitcoinTx> Txs;
 
-    public BitcoinBlockWithTx(int height, double creationTime, BitcoinBlock parent, BitcoinMinerNode creator,
+    public BitcoinBlockWithTx(int height, double creationTime, BitcoinBlockWithoutTx parent, BitcoinMinerNode creator,
                               Set<BitcoinTx> txs, double difficulty) {
         super(0, height, creationTime, creator, parent, difficulty);
-        Txs = txs;
+        this.Txs = txs;
 
         int totalSize = BITCOIN_BLOCK_HEADER_SIZE;
         for (BitcoinTx tx:txs) {

src/main/java/jabs/ledgerdata/bitcoin/BitcoinBlock.java renamed to src/main/java/jabs/ledgerdata/bitcoin/BitcoinBlockWithoutTx.java

@@ -5,9 +5,9 @@
 
 import static jabs.ledgerdata.BlockFactory.BITCOIN_INV_SIZE;
 
-public class BitcoinBlock extends SingleParentBlock<BitcoinBlock> {
+public class BitcoinBlockWithoutTx extends SingleParentBlock<BitcoinBlockWithoutTx> {
     protected final double difficulty;
-    public BitcoinBlock(int size, int height, double creationTime, Node creator, BitcoinBlock parent, double difficulty) {
+    public BitcoinBlockWithoutTx(int size, int height, double creationTime, Node creator, BitcoinBlockWithoutTx parent, double difficulty) {
         super(size, height, creationTime, creator, parent, BITCOIN_INV_SIZE);
         this.difficulty = difficulty;
     }

src/main/java/jabs/ledgerdata/bitcoin/BitcoinCompactBlock.java

@@ -0,0 +1,43 @@
+package jabs.ledgerdata.bitcoin;
+
+import jabs.network.node.nodes.Node;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import static jabs.ledgerdata.BlockFactory.BITCOIN_BLOCK_HEADER_SIZE;
+
+public class BitcoinCompactBlock extends BitcoinBlockWithoutTx {
+    private final Set<BitcoinTxCompactID> TxCompactIDs = new HashSet<>();
+
+    public BitcoinCompactBlock(int height, double creationTime, Node creator, BitcoinBlockWithoutTx parent,
+                               Set<BitcoinTx> txs, double difficulty) {
+        super(0, height, creationTime, creator, parent, difficulty);
+
+        int totalSize = BITCOIN_BLOCK_HEADER_SIZE;
+        for (BitcoinTx tx:txs) {
+            TxCompactIDs.add(tx.getCompactID());
+            totalSize += tx.getSize();
+        }
+
+        this.size = totalSize;
+    }
+
+    public BitcoinCompactBlock(BitcoinBlockWithTx block) {
+        super(0, block.getHeight(), block.getCreationTime(), block.getCreator(), block.getParent(),
+                block.difficulty);
+
+        int totalSize = BITCOIN_BLOCK_HEADER_SIZE;
+
+        for (BitcoinTx tx: block.getTxs()) {
+            TxCompactIDs.add(tx.getCompactID());
+            totalSize += tx.getSize();
+        }
+
+        this.size = totalSize;
+    }
+
+    public Set<BitcoinTxCompactID> getTxCompactIDs() {
+        return TxCompactIDs;
+    }
+}

src/main/java/jabs/ledgerdata/bitcoin/BitcoinCompactBlockWithoutTx.java

@@ -0,0 +1,29 @@
+package jabs.ledgerdata.bitcoin;
+
+import jabs.network.node.nodes.Node;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import static jabs.ledgerdata.BlockFactory.BITCOIN_BLOCK_HEADER_SIZE;
+
+public class BitcoinCompactBlockWithoutTx extends BitcoinBlockWithoutTx {
+    private final Set<BitcoinTxCompactID> TxCompactIDs = new HashSet<>();
+
+    public BitcoinCompactBlockWithoutTx(int size, int height, double creationTime, Node creator, BitcoinBlockWithoutTx parent,
+                                        Set<BitcoinTx> txs, double difficulty) {
+        super(size, height, creationTime, creator, parent, difficulty);
+    }
+
+    // This is a very rough estimation of the size of a compact block in bitcoin
+    public BitcoinCompactBlockWithoutTx(BitcoinBlockWithoutTx block) {
+        super(0, block.getHeight(), block.getCreationTime(), block.getCreator(), block.getParent(),
+                block.difficulty);
+
+        this.size = (int)((((double)block.getSize() - BITCOIN_BLOCK_HEADER_SIZE) / 200) * 6) + BITCOIN_BLOCK_HEADER_SIZE;
+    }
+
+    public Set<BitcoinTxCompactID> getTxCompactIDs() {
+        return TxCompactIDs;
+    }
+}

src/main/java/jabs/ledgerdata/bitcoin/BitcoinTx.java

@@ -5,7 +5,12 @@
 import static jabs.ledgerdata.BlockFactory.BITCOIN_INV_SIZE;
 
 public class BitcoinTx extends Tx<BitcoinTx> {
+    private final BitcoinTxCompactID compactID = new BitcoinTxCompactID();
     public BitcoinTx(int size) {
         super(size, BITCOIN_INV_SIZE);
     }
+
+    public BitcoinTxCompactID getCompactID() {
+        return this.compactID;
+    }
 }