More refactoring, using BitcoinFactory on more classes and tests.

Author: Alessandro Polverini

core/api/src/main/java/hu/netmind/bitcoin/Constants.java

@@ -0,0 +1,12 @@
+package hu.netmind.bitcoin;
+
+/**
+ *
+ * @author Alessandro Polverini <[email protected]>
+ */
+public class Constants {
+
+  public final static long PRODNET_MESSAGE_MAGIC = 0xf9beb4d9L;
+  public final static long TESTNET2_MESSAGE_MAGIC = 0xfabfb5daL;
+  public final static long TESTNET3_MESSAGE_MAGIC = 0x0b110907;
+}

core/block/src/main/java/hu/netmind/bitcoin/block/BitcoinFactory.java

@@ -19,11 +19,8 @@
 
 import hu.netmind.bitcoin.Block;
 import hu.netmind.bitcoin.ScriptFactory;
-import hu.netmind.bitcoin.net.InventoryItem;
-import hu.netmind.bitcoin.net.Message;
 import hu.netmind.bitcoin.net.NetworkMessageFactory;
 import java.math.BigDecimal;
-import java.util.List;
 
 /**
  *

core/block/src/main/java/hu/netmind/bitcoin/block/StandardBitcoinFactory.java core/block/src/main/java/hu/netmind/bitcoin/block/ProdnetBitcoinFactory.java

@@ -19,6 +19,7 @@
 
 import hu.netmind.bitcoin.BitcoinException;
 import hu.netmind.bitcoin.Block;
+import hu.netmind.bitcoin.Constants;
 import hu.netmind.bitcoin.ScriptFactory;
 import hu.netmind.bitcoin.ScriptFragment;
 import hu.netmind.bitcoin.net.NetworkMessageFactory;
@@ -35,26 +36,26 @@
  *
  * @author Alessandro Polverini
  */
-public class StandardBitcoinFactory implements BitcoinFactory
+public class ProdnetBitcoinFactory implements BitcoinFactory
 {
 
    protected Logger logger = LoggerFactory.getLogger(this.getClass());
-   protected static final DifficultyTarget MAX_PRODNET_TARGET =
+   protected static final DifficultyTarget MAX_TARGET =
       new DifficultyTarget(new BigInteger("FFFF0000000000000000000000000000000000000000000000000000", 16));
    private Block GENESIS_BLOCK;
    protected ScriptFactory scriptFactory;
    protected NetworkMessageFactory messageFactory;
    protected long compressedTarget;
-   protected long messageMagic;
+   private long protocolMessageMagic;
 
-   protected StandardBitcoinFactory()
+   protected ProdnetBitcoinFactory()
    {
    }
 
-   public StandardBitcoinFactory(ScriptFactory scriptFactory) throws BitcoinException
+   public ProdnetBitcoinFactory(ScriptFactory scriptFactory) throws BitcoinException
    {
       this.scriptFactory = scriptFactory;
-      setNetworkParams(0xf9beb4d9L, 1231006505000l, 2083236893l, 0x1d00ffffL, BtcUtil.hexIn("000000000019D6689C085AE165831E934FF763AE46A2A6C172B3F1B60A8CE26F"));
+      setNetworkParams(Constants.PRODNET_MESSAGE_MAGIC, 1231006505000l, 2083236893l, 0x1d00ffffL, BtcUtil.hexIn("000000000019D6689C085AE165831E934FF763AE46A2A6C172B3F1B60A8CE26F"));
    }
 
    @Override
@@ -66,7 +67,7 @@ public ScriptFactory getScriptFactory()
    @Override
    public long getMessageMagic()
    {
-      return messageMagic;
+      return protocolMessageMagic;
    }
 
    @Override
@@ -96,7 +97,7 @@ public Difficulty newDifficulty(DifficultyTarget target)
    @Override
    public DifficultyTarget maxDifficultyTarget()
    {
-      return MAX_PRODNET_TARGET;
+      return MAX_TARGET;
    }
 
    @Override
@@ -136,7 +137,7 @@ protected final void setNetworkParams(
       long genesisCompressedTarget,
       byte[] genesisHash) throws BitcoinException
    {
-      this.messageMagic = messageMagic;
+      this.protocolMessageMagic = messageMagic;
       this.compressedTarget = genesisCompressedTarget;
       this.messageFactory = new NetworkMessageFactory(messageMagic);
       GENESIS_BLOCK = new BlockImpl(getGenesisTransactions(), genesisCreationTime, genesisNonce, genesisCompressedTarget,

core/block/src/main/java/hu/netmind/bitcoin/block/Testnet2BitcoinFactory.java

@@ -18,6 +18,7 @@
 package hu.netmind.bitcoin.block;
 
 import hu.netmind.bitcoin.BitcoinException;
+import hu.netmind.bitcoin.Constants;
 import hu.netmind.bitcoin.ScriptFactory;
 import it.nibbles.bitcoin.utils.BtcUtil;
 import java.math.BigInteger;
@@ -26,15 +27,16 @@
  *
  * @author Alessandro Polverini
  */
-public class Testnet2BitcoinFactory extends StandardBitcoinFactory
+public class Testnet2BitcoinFactory extends ProdnetBitcoinFactory
 {
-   public static final DifficultyTarget MAX_TESTNET_TARGET =
+
+   public static final DifficultyTarget MAX_TARGET =
       new DifficultyTarget(new BigInteger("FFFFF0000000000000000000000000000000000000000000000000000", 16));
 
    public Testnet2BitcoinFactory(ScriptFactory scriptFactory) throws BitcoinException
    {
       this.scriptFactory = scriptFactory;
-      setNetworkParams(0xfabfb5daL, 1296688602000l, 384568319l, 0x1d07fff8L, BtcUtil.hexIn("00000007199508e34a9ff81e6ec0c477a4cccff2a4767a8eee39c11db367b008"));
+      setNetworkParams(Constants.TESTNET2_MESSAGE_MAGIC, 1296688602000l, 384568319l, 0x1d07fff8L, BtcUtil.hexIn("00000007199508e34a9ff81e6ec0c477a4cccff2a4767a8eee39c11db367b008"));
    }
 
    @Override
@@ -46,6 +48,6 @@ public boolean isTestnet2()
    @Override
    public DifficultyTarget maxDifficultyTarget()
    {
-      return MAX_TESTNET_TARGET;
+      return MAX_TARGET;
    }
 }

core/block/src/main/java/hu/netmind/bitcoin/block/Testnet3BitcoinFactory.java

@@ -18,20 +18,21 @@
 package hu.netmind.bitcoin.block;
 
 import hu.netmind.bitcoin.BitcoinException;
+import hu.netmind.bitcoin.Constants;
 import hu.netmind.bitcoin.ScriptFactory;
 import it.nibbles.bitcoin.utils.BtcUtil;
 
 /**
  *
  * @author Alessandro Polverini
  */
-public class Testnet3BitcoinFactory extends StandardBitcoinFactory
+public class Testnet3BitcoinFactory extends ProdnetBitcoinFactory
 {
 
    public Testnet3BitcoinFactory(ScriptFactory scriptFactory) throws BitcoinException
    {
       this.scriptFactory = scriptFactory;
-      setNetworkParams(0x0b110907, 1296688602000L, 414098458L, 0x1d00ffffL, BtcUtil.hexIn("000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943"));
+      setNetworkParams(Constants.TESTNET3_MESSAGE_MAGIC, 1296688602000L, 414098458L, 0x1d00ffffL, BtcUtil.hexIn("000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943"));
    }
 
    @Override

core/block/src/test/java/hu/netmind/bitcoin/block/DifficultyTests.java

@@ -36,7 +36,7 @@ public class DifficultyTests
    static {
       try
       {
-         prodnetFactory = new StandardBitcoinFactory(null);
+         prodnetFactory = new ProdnetBitcoinFactory(null);
          testnet2Factory = new Testnet2BitcoinFactory(null);
       } catch (BitcoinException ex)
       {

core/block/src/test/java/hu/netmind/bitcoin/block/TesterBitcoinFactory.java

@@ -8,7 +8,7 @@
  *
  * @author Alessandro Polverini
  */
-public class TesterBitcoinFactory extends StandardBitcoinFactory
+public class TesterBitcoinFactory extends ProdnetBitcoinFactory
 {
    private Block genesisBlock;
 

core/net-p2p/src/main/java/hu/netmind/bitcoin/net/p2p/Node.java

@@ -70,24 +70,28 @@ public class Node
    private List<MessageHandler> handlers = new ArrayList<>();
    private final List<NodeWorker> workers = new ArrayList<>();
    private NodeListener nodeListener;
+   protected long messageMagic;
 
+   // TODO: We need to pass the
    /**
     * Create this node which will then listen for incoming connections from
     * other nodes. Note that node will not work until it's started.
     *
     * @param port The port to listen on instead of the default port.
     */
-   public Node(int port)
+   public Node(long messageMagic, int port)
    {
+      this.messageMagic = messageMagic;
       this.port = port;
    }
 
    /**
     * Create this node which will then listen for incoming connections from
     * other nodes. Note that node will not work until it's started.
     */
-   public Node()
+   public Node(long messageMagic)
    {
+      this.messageMagic = messageMagic;
    }
 
    /**
@@ -373,7 +377,7 @@ private class NodeWorker implements Runnable
       private BitCoinOutputStream output;
       private boolean running;
       private Thread workerThread;
-      private MessageMarshaller marshaller = new MessageMarshaller();
+      private MessageMarshaller marshaller = new MessageMarshaller(messageMagic);
       private Connection connection;
       private long lastIncomingTime = 0;
       private long creationTime = 0;

core/net-p2p/src/test/java/hu/netmind/bitcoin/net/p2p/NodeTests.java

@@ -18,11 +18,15 @@
 
 package hu.netmind.bitcoin.net.p2p;
 
+import hu.netmind.bitcoin.BitcoinException;
+import hu.netmind.bitcoin.block.BitcoinFactory;
+import hu.netmind.bitcoin.block.Testnet3BitcoinFactory;
 import hu.netmind.bitcoin.net.AlertMessage;
 import hu.netmind.bitcoin.net.BitCoinInputStream;
 import hu.netmind.bitcoin.net.BitCoinOutputStream;
 import hu.netmind.bitcoin.net.Message;
 import hu.netmind.bitcoin.net.MessageMarshaller;
+import hu.netmind.bitcoin.net.NetworkMessageFactory;
 import hu.netmind.bitcoin.net.NodeAddress;
 import hu.netmind.bitcoin.net.PingMessage;
 import hu.netmind.bitcoin.net.VerackMessage;
@@ -38,6 +42,7 @@
 import java.util.Map;
 import java.util.concurrent.Semaphore;
 import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
 import org.easymock.EasyMock;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -57,13 +62,20 @@ public class NodeTests
 
    private List<DummyNode> dummyNodes = new ArrayList<>();
    private Node savedNode = null;
+   private BitcoinFactory bitcoinFactory;
+   private NetworkMessageFactory messageFactory;
 
+   public NodeTests() throws BitcoinException
+   {
+      bitcoinFactory = new Testnet3BitcoinFactory(null);
+      messageFactory = bitcoinFactory.getMessageFactory();
+   }
    /**
     * Create a node which will be destroyed at the end of test.
     */
    public Node createNode()
    {
-      savedNode = new Node();
+      savedNode = new Node(bitcoinFactory.getMessageMagic());
       return savedNode;
    }
 
@@ -137,7 +149,7 @@ public void testStartStop()
       throws IOException
    {
       // Create node with defaults
-      Node node = new Node();
+      Node node = new Node(bitcoinFactory.getMessageMagic());
       // Check that there are no node threads running before start
       Assert.assertFalse(isNodeThreadActive(),"there is a node thread before starting");
       // Start
@@ -181,9 +193,9 @@ public void testDetectConnectioToSelf()
       EasyMock.replay(source);
 
       final NodeAddress dummyNodeAddress = new NodeAddress(1, new InetSocketAddress(51234));
-      final VersionMessage verMsg1 = new VersionMessage(Message.MAGIC_TEST, BC_PROTOCOL_VERSION, 0, System.currentTimeMillis() / 1000,
+      final VersionMessage verMsg1 = messageFactory.newVersionMessage(BC_PROTOCOL_VERSION, 0, System.currentTimeMillis() / 1000,
          dummyNodeAddress, dummyNodeAddress, 123, "test", 1);
-      final VersionMessage verMsg2 = new VersionMessage(Message.MAGIC_TEST, BC_PROTOCOL_VERSION, 0, System.currentTimeMillis() / 1000,
+      final VersionMessage verMsg2 = messageFactory.newVersionMessage(BC_PROTOCOL_VERSION, 0, System.currentTimeMillis() / 1000,
          dummyNodeAddress, dummyNodeAddress, 124, "test", 1);
 
       // Create node
@@ -238,7 +250,7 @@ public void testCommunicationConcept()
       dummyNode.accept();
 
       // Send a message to node
-      dummyNode.send(new AlertMessage(Message.MAGIC_TEST,"Message"));
+      dummyNode.send(messageFactory.newAlertMessage("Message"));
       // Get the repeated message right back
       AlertMessage answer = (AlertMessage) dummyNode.read();
       // Check
@@ -267,7 +279,7 @@ public void testBroadcast()
       for ( int i=0; i<dummyNodes.length; i++ )
          dummyNodes[i].accept();
       // Broadcast a message to all connected nodes
-      node.broadcast(new AlertMessage(Message.MAGIC_TEST,"Message"));
+      node.broadcast(messageFactory.newAlertMessage("Message"));
       // Get the messages from all nodes
       for ( int i=0; i<dummyNodes.length; i++ )
       {
@@ -296,8 +308,8 @@ public void testSameAddressTwice()
       // Accept the connection from node
       dummyNode.accept();
       // Broadcast 2 messages
-      node.broadcast(new AlertMessage(Message.MAGIC_TEST,"Message1"));
-      node.broadcast(new AlertMessage(Message.MAGIC_TEST,"Message2"));
+      node.broadcast(messageFactory.newAlertMessage("Message1"));
+      node.broadcast(messageFactory.newAlertMessage("Message2"));
       // Now check that the 1st message arrives only once
       AlertMessage message = (AlertMessage) dummyNode.read();
       Assert.assertEquals(message.getMessage(),"Message1");
@@ -318,7 +330,7 @@ public void testAcceptExternalConnection()
       // Wait unilt the node really connected to the node
       waiter.waitForJoin();
       // Check connection
-      node.broadcast(new AlertMessage(Message.MAGIC_TEST,"Message"));
+      node.broadcast(messageFactory.newAlertMessage("Message"));
       AlertMessage message = (AlertMessage) dummyNode.read();
       Assert.assertEquals(message.getMessage(),"Message");
    }
@@ -388,7 +400,7 @@ public void onLeave(Connection conn)
          Assert.fail("didn't receive the 'leave' event of closed node in time");
       // Now try to connect new node and communicate
       DummyNode dummyNode2 = createDummyNode(new InetSocketAddress(node.getPort()));
-      dummyNode2.send(new PingMessage(Message.MAGIC_TEST));
+      dummyNode2.send(messageFactory.newPingMessage());
       Message message = dummyNode2.read();
    }
 
@@ -423,8 +435,8 @@ public void testMultiHandlerReply()
       // Accept the connection from node
       dummyNode.accept();
       // Send two messages to node
-      dummyNode.send(new AlertMessage(Message.MAGIC_TEST,"Message1"));
-      dummyNode.send(new AlertMessage(Message.MAGIC_TEST,"Message2"));
+      dummyNode.send(bitcoinFactory.getMessageFactory().newAlertMessage("Message1"));
+      dummyNode.send(bitcoinFactory.getMessageFactory().newAlertMessage("Message2"));
       // Check that easy is only replied once by the node, meaning that only one repeater handler
       // is allowed to answer.
       AlertMessage incoming = (AlertMessage) dummyNode.read();
@@ -462,7 +474,7 @@ public void onJoin(Connection conn)
          {
             try
             {
-               conn.send(new VerackMessage(Message.MAGIC_TEST));
+               conn.send(messageFactory.newVerackMessage());
             } catch (IOException ex)
             {
             }
@@ -530,7 +542,7 @@ public DummyNode(InetSocketAddress address)
          socket.connect(address,1000); // 0.5 seconds to connect
          input = new BitCoinInputStream(new BufferedInputStream(socket.getInputStream()));
          output = new BitCoinOutputStream(socket.getOutputStream());
-         marshaller = new MessageMarshaller();
+         marshaller = new MessageMarshaller(bitcoinFactory.getMessageMagic());
       }
 
       /**
@@ -542,7 +554,7 @@ public DummyNode()
          serverSocket = new ServerSocket(0);
          address = (InetSocketAddress) serverSocket.getLocalSocketAddress();
          serverSocket.setSoTimeout(1000); // Wait for incoming for 0.5 sec
-         marshaller = new MessageMarshaller();
+         marshaller = new MessageMarshaller(bitcoinFactory.getMessageMagic());
       }
 
       public InetSocketAddress getAddress()