public override async Task HandleMessage(NetworkNode node, Message msg)
{
if (node.HandshakeIsCompleted)
{
return;
}
var blockchain = _blockchainRepo.GetChainByNetId(_netId);
try
{
if (node.ConnectionType == ConnectionType.Inbound)
{
await HandleInboundHandshakeMessage(node, msg, blockchain);
}
else
{
await HandleOutboundHandshakeMessage(node, msg, blockchain);
}
}
catch (Exception)
{
node?.Disconnect();
}
}
public MessageHandler(INetworkManager manager, ConcurrentTransactionPool txPool, NetworkNodesPool nodePool, IDifficultyCalculator difficultyCalculator, IBlockValidator blockValidator, ILoggerFactory loggerFactory, IBlockchainRepository blockchainRepo, string netId)
: base(manager, nodePool, loggerFactory)
{
_difficultyCalculator = difficultyCalculator;
_blockValidator = blockValidator;
_blockchainRepo = blockchainRepo;
_netId = netId;
_txPool = txPool;
_blockchain = _blockchainRepo.GetChainByNetId(_netId);
_difficulty = _difficultyCalculator.CalculateCurrentDifficulty(_blockchain);
}
private IEnumerable <StateTransaction> GetAllByPredicate(Func <StateTransaction, bool> predicate, string netId)
{
var blockchain = _blockchainRepo.GetChainByNetId(netId);
lock (blockchain)
{
foreach (Block b in blockchain.Blocks)
{
if (b.Header.Version > BlockchainConstants.ProtocolVersion)
{
// todo log unsupporting block version found, but continue
}
var stateTransactions = b.Transactions.OfType <StateTransaction>();
var transactionsByPubKey = stateTransactions.Where(predicate);
foreach (StateTransaction tx in transactionsByPubKey)
{
yield return(tx);
}
}
}
}
private IEnumerable <Block> GetBlocksFromHash(string beginHash, string stopHash, bool includeBeginBlock)
{
var blocks = new List <Block>();
bool stopSearching = false;
var bLockchain = _blockchainRepo.GetChainByNetId(_netId); // We fetch the blockchain to put a threadlock on it.
lock (bLockchain)
{
var previousBlock = _blockchainRepo.GetBlockByHash(beginHash, _netId);
var i = 0;
if (includeBeginBlock)
{
blocks.Add(previousBlock);
}
while (i < NetworkConstants.MaxHeadersInMessage && !stopSearching)
{
// Stale blocks / side chains are not supported here
try
{
previousBlock = _blockchainRepo.GetBlockByPreviousHash(previousBlock.Header.Hash, _netId);
blocks.Add(previousBlock);
if (previousBlock.Header.Hash == stopHash)
{
stopSearching = true;
}
}
catch (KeyNotFoundException)
{
stopSearching = true; // No more blocks found
}
i++;
}
}
return(blocks);
}
public Miner(string netId, string minerWalletPubKey, string minerWalletPrivKey,
IBlockchainRepository blockchainRepo, ITransactionRepository transactionRepo,
ITransactionCreator transactionCreator, ITransactionValidator transactionValidator,
IDifficultyCalculator difficultyCalculator, IPowBlockCreator blockCreator,
IBlockValidator blockValidator, ConcurrentTransactionPool txPool, ILoggerFactory loggerFactory)
{
_logger = loggerFactory.CreateLogger <Miner>();
_walletPubKey = minerWalletPubKey;
_walletPrivKey = minerWalletPrivKey;
_blockchainRepo = blockchainRepo;
_networkIdentifier = netId;
_blockchain = _blockchainRepo.GetChainByNetId(_networkIdentifier);
_transactionRepo = transactionRepo;
_transactionCreator = transactionCreator;
_transactionValidator = transactionValidator;
_difficultyCalculator = difficultyCalculator;
_blockCreator = blockCreator;
_blockValidator = blockValidator;
_txPool = txPool;
EventPublisher.GetInstance().OnUnvalidatedTransactionReceived += OnUnvalidatedTransactionReceived;
EventPublisher.GetInstance().OnUnvalidatedBlockCreated += OnUnvalidatedBlockCreated;
difficulty = _difficultyCalculator.CalculateCurrentDifficulty(_blockchain);
}
public static void Main(string[] args)
{
CryptographyCommandhandler cryptographyCmdHandler = new CryptographyCommandhandler(new KeyGenerator());
cryptographyCmdHandler.HandleGenerateKeysCommand(out string walletPubKey, out string walletPrivKey);
PushKeyPair(walletPubKey, walletPrivKey);
Console.WriteLine("Your new public key: " + walletPubKey);
Console.WriteLine("Your new private key: " + walletPrivKey);
Console.WriteLine("Loading blockchain..");
var networkIdentifier = "testnet";
var services = SetupDI(networkIdentifier, walletPubKey, walletPrivKey);
ushort listeningPort = NetworkConstants.DefaultListeningPort;
IPAddress publicIP = IPAddress.Parse("127.0.0.1"); // Our public IP so other nodes can find us, todo
if (args.Length > 1 && args[0] == "-port")
{
listeningPort = ushort.Parse(args[1]);
}
IBlockchainRepository blockchainRepo = services.GetService <IBlockchainRepository>();
ITransactionRepository transactionRepo = services.GetService <ITransactionRepository>();
ITransactionCreator transactionCreator = services.GetService <ITransactionCreator>();
ITimestamper timestamper = services.GetService <ITimestamper>();
ISkuRepository skuRepository = services.GetService <ISkuRepository>();
INetworkManager networkManager = services.GetService <INetworkManager>();
ILoggerFactory loggerFactory = services.GetService <ILoggerFactory>();
ISkuRepository skuRepo = services.GetService <ISkuRepository>();
Miner miner = services.GetService <Miner>();
_logger = loggerFactory.CreateLogger <Program>();
Blockchain blockchain = blockchainRepo.GetChainByNetId(networkIdentifier);
// Command handlers, only large commands are handles by these separate handlers.
AccountsCommandHandler accountsCmdHandler = new AccountsCommandHandler(transactionRepo, networkIdentifier);
SkusCommandHandler skusCmdHandler = new SkusCommandHandler(blockchainRepo, timestamper, skuRepository, networkIdentifier);
TransactionsCommandHandler transactionsCmdHandler = new TransactionsCommandHandler(transactionRepo, networkIdentifier);
TransactionPoolCommandHandler txpoolCmdHandler = new TransactionPoolCommandHandler();
TransferTokensCommandHandler transferTokensCmdHandler = new TransferTokensCommandHandler(transactionRepo, transactionCreator);
CreateSkuCommandHandler createSkuCmdHandler = new CreateSkuCommandHandler(transactionRepo, transactionCreator);
TransferSupplyCommandHandler transferSupplyCmdHandler = new TransferSupplyCommandHandler(skuRepository, transactionRepo, transactionCreator, networkIdentifier);
NetworkingCommandHandler networkingCmdHandler = new NetworkingCommandHandler();
TransactionGeneratorCommandHandler txGeneratorCmdHandler = new TransactionGeneratorCommandHandler(miner, transactionCreator, skuRepo, blockchainRepo);
CreateSupplyCommandHandler createSupplyCmdHandler = new CreateSupplyCommandHandler(skuRepository, transactionRepo, transactionCreator, networkIdentifier);
DestroySupplyCommandHandler destroySupplyCmdHandler = new DestroySupplyCommandHandler(skuRepository, transactionRepo, transactionCreator, networkIdentifier);
_logger.LogInformation("Loaded blockchain. Current height: {Height}", blockchain.CurrentHeight == -1 ? "GENESIS" : blockchain.CurrentHeight.ToString());
networkManager.AcceptConnections(publicIP, listeningPort, new CancellationTokenSource());
networkManager.ConnectToPeer(new NetworkNode(ConnectionType.Outbound, new IPEndPoint(IPAddress.Parse("127.0.0.1"), 12345)));
PrintConsoleCommands();
var skuTransactions = 0;
var txpool = ConcurrentTransactionPool.GetInstance();
EventPublisher.GetInstance().OnValidTransactionReceived += (object sender, TransactionReceivedEventArgs txargs) =>
{
if (txargs.Transaction.Action == TransactionAction.CreateSku.ToString())
{
skuTransactions++;
}
if (skuTransactions > 200000 && txpool.Count() < 1)
{
miner.StopMining(true);
txGeneratorCmdHandler.HandleStopCommand();
}
};
var input = "";
while (input != "exit")
{
input = Console.ReadLine().ToLower();
switch (input)
{
case "help":
PrintConsoleCommands();
break;
case "transactiongenerator startandmine":
txGeneratorCmdHandler.HandleStartCommand(true);
break;
case "transactiongenerator start":
txGeneratorCmdHandler.HandleStartCommand(false);
break;
case "transactiongenerator stop":
txGeneratorCmdHandler.HandleStopCommand();
break;
case "generatekeys":
cryptographyCmdHandler.HandleGenerateKeysCommand(out walletPubKey, out walletPrivKey);
PushKeyPair(walletPubKey, walletPrivKey);
Console.WriteLine("Your new public key: " + walletPubKey);
Console.WriteLine("Your new private key: " + walletPrivKey);
Console.Write("> ");
break;
case "accounts":
case "users":
case "balances":
accountsCmdHandler.HandleCommand();
break;
case "skus":
skusCmdHandler.HandleCommand();
break;
case "txpool":
case "transactionpool":
case "pendingtransactions":
txpoolCmdHandler.HandleCommand(miner.TransactionPool);
break;
case "transactions":
transactionsCmdHandler.HandleCommand();
break;
case "startmining":
miner.StartMining();
Console.Write("> ");
break;
case "stopmining":
miner.StopMining(true);
PrintConsoleCommands();
break;
case "resetblockchain":
networkManager.Dispose();
_logger.LogWarning("All network connections shut down.");
miner.StopMining(false);
blockchainRepo.Delete(networkIdentifier);
_logger.LogInformation("Local blockchain file deleted as requested by user");
Console.WriteLine("Please restart the logistichain executable now to reload a fresh blockchain instance!");
break;
case "transfertokens":
transferTokensCmdHandler.HandleCommand(networkIdentifier);
break;
case "createsku":
createSkuCmdHandler.HandleCommand(networkIdentifier);
break;
case "transfersupply":
transferSupplyCmdHandler.HandleCommand();
break;
case "createsupply":
createSupplyCmdHandler.HandleCommand();
break;
case "destroysupply":
destroySupplyCmdHandler.HandleCommand();
break;
case "networking setport":
listeningPort = networkingCmdHandler.HandleSetPortCommand(listeningPort);
break;
case "networking setaddress":
publicIP = networkingCmdHandler.HandleSetAddressCommand(publicIP);
break;
case "networking connect":
networkingCmdHandler.HandleConnectCommand(networkManager);
break;
case "networking disconnect":
networkingCmdHandler.HandleDisconnectCommand(networkManager);
break;
case "networking pool":
networkingCmdHandler.HandleListPoolCommand(NetworkNodesPool.GetInstance(loggerFactory));
break;
case "networking stop":
networkManager.Dispose();
break;
case "networking start":
if (networkManager.IsDisposed)
{
networkManager = GetService <INetworkManager>(services);
}
networkManager.AcceptConnections(publicIP, listeningPort, new CancellationTokenSource());
break;
case "networking restart":
networkManager.Dispose();
Thread.Sleep(1000);
networkManager = GetService <INetworkManager>(services);
networkManager.AcceptConnections(publicIP, listeningPort, new CancellationTokenSource());
break;
default:
Console.WriteLine("I don't recognize that command.");
Console.Write("> ");
break;
}
}
}
internal void HandleCommand()
{
var currentBlockchain = _blockchainRepo.GetChainByNetId(_netId);
var historyLists = _skuRepository.GetAllWithHistory(_netId);
if (historyLists.Count() == 0)
{
Console.WriteLine("No transactions found.");
}
else
{
Console.WriteLine("SKU's:");
}
// Now loop though all the SKU's historylists
foreach (List <Sku> historyList in historyLists)
{
Console.WriteLine("------- SKU -------");
var createSkuTransaction = (StateTransaction)historyList.First().Transaction;
var currentSupply = createSkuTransaction.Amount;
var owner = createSkuTransaction.FromPubKey;
var versionNumber = 0;
foreach (var skuversion in historyList)
{
var blockHeight = _blockchainRepo.GetHeightForBlock(skuversion.Block.Header.Hash, _netId);
var confirmations = (currentBlockchain.CurrentHeight - blockHeight) + 1; // The block itself is a confirmation aswell.
var blockTime = _timestamper.GetUtcDateTimeFromTimestamp(skuversion.Block.Header.Timestamp);
var transaction = (StateTransaction)skuversion.Transaction;
var isCreateOrChange = transaction.Action == TransactionAction.CreateSku.ToString() || transaction.Action == TransactionAction.ChangeSku.ToString();
if (isCreateOrChange)
{
versionNumber++;
}
Console.WriteLine("Action: " + transaction.Action);
Console.WriteLine("SKU Version: " + versionNumber);
Console.WriteLine("Time: " + blockTime.ToString("dd-MM-yyy HH:mm:ss") + " UTC time");
Console.WriteLine("Block hash: " + skuversion.Block.Header.Hash);
Console.WriteLine("Block height: " + blockHeight);
Console.WriteLine("Confirmations: " + confirmations.ToString());
Console.WriteLine("Transaction hash: " + transaction.Hash);
if (isCreateOrChange)
{
Console.WriteLine(" Owner pubkey: " + owner);
Console.WriteLine(" SKU ID: " + skuversion.Data.SkuId);
Console.WriteLine(" EAN code: " + skuversion.Data.EanCode);
Console.WriteLine(" Description: " + skuversion.Data.Description);
}
else if (transaction.Action == TransactionAction.DestroySupply.ToString())
{
currentSupply -= transaction.Amount;
}
else if (transaction.Action == TransactionAction.CreateSupply.ToString())
{
currentSupply += transaction.Amount;
}
else if (transaction.Action == TransactionAction.TransferSupply.ToString())
{
Console.WriteLine(" From: " + transaction.FromPubKey);
Console.WriteLine(" To: " + transaction.ToPubKey);
Console.WriteLine(" Amount: " + transaction.Amount);
}
Console.WriteLine("Total global supply after transaction: " + currentSupply);
if (versionNumber != historyList.Count)
{
Console.WriteLine("-------");
}
}
Console.WriteLine("-------=====-------");
}
Console.Write("> ");
}