public void AddBlockTest()
{
var bc = new Blockchain();
var lsTrx = new List <Transaction>();
//Create first transaction
var trx1 = new Transaction
{
Sender = "Stevano",
Recipient = "Valentino",
Amount = 3.0,
Fee = 0.3
};
lsTrx.Add(trx1);
bc.AddBlock(lsTrx.ToArray());
Assert.Equal(2, bc.Blocks.Count);
//Create 2nd transaction
trx1 = new Transaction
{
Sender = "Budiawan",
Recipient = "Norita",
Amount = 2.5,
Fee = 0.2
};
lsTrx = new List <Transaction>();
lsTrx.Add(trx1);
bc.AddBlock(lsTrx.ToArray());
Assert.Equal(3, bc.Blocks.Count);
}
public void BlockchainTests()
{
Blockchain chain = new Blockchain();
AccountView Person1 = new AccountView();
AccountView Person2 = new AccountView();
Block nullBlock = new Block();
nullBlock.block_number = 0;
nullBlock.calculateNonce(Person1.publicKey, chain);
chain.AddBlock(nullBlock);
Assert.IsTrue(chain.validate(), "The chain is invalid, even though it should be valid, as it only contains the nullblock");
Transaction tx = new Transaction(Person1.publicKey, Person2.publicKey, 30, 0, Person1.privateKey);
Block b = new Block();
b.AddTransaction(tx);
b.block_number = 1;
b.prev_hash = chain.getLastHash();
b.calculateNonce(Person1.publicKey, chain);
chain.AddBlock(b);
Assert.AreEqual(chain.count_funds(Person1.publicKey), 70, "Person one has a wrong number of coins");
Assert.AreEqual(chain.count_funds(Person2.publicKey), 30, "Person two has a wrong number of coins");
}
public static void TestBlockchain()
{
Blockchain BlockCoin = new Blockchain();
BlockCoin.AddBlock(new Block(DateTime.Now, null, "{sender:intay,receiver:alex,amount:10}"));
BlockCoin.AddBlock(new Block(DateTime.Now, null, "{sender:intay,receiver:crunchyroll,amount:5}"));
BlockCoin.AddBlock(new Block(DateTime.Now, null, "{sender:Backer,receiver:StartupCompany,amount:100}"));
Console.WriteLine(JsonConvert.SerializeObject(BlockCoin, Formatting.Indented));
}
private void Client()
{
TcpClient client = new TcpClient();
client.Connect(IPAddress.Parse(IP), int.Parse(Port));
if (client.Connected)
{
NetworkStream stream = client.GetStream();
//Reading blockchain from server
var response = new byte[2042];
//Read bytes to userChain and return readed bytes number.
int bytes = stream.Read(response, 0, response.Length);
var memoryStream = new MemoryStream();
//Write to memory stream from 0 to readed number bytes.
memoryStream.Write(response, 0, bytes);
byte[] BlockChainBytes = new byte[2042];
//Convert to byte array.
BlockChainBytes = memoryStream.ToArray();
blockChain = (Blockchain)ByteArrayToObject(BlockChainBytes);
blockChain.origin = "Client";
//Write data to client network stream
try {
if (kanditatas1.Checked)
{
blockChain.AddBlock(new Block(null, kanditatas1.Text));
}
if (kanditatas2.Checked)
{
blockChain.AddBlock(new Block(null, kanditatas2.Text));
}
if (kanditatas3.Checked)
{
blockChain.AddBlock(new Block(null, kanditatas3.Text));
}
// Sending blockchain to server.
blockChain.origin = "Client";
stream.Write(ObjectToByteArray(blockChain), 0, ObjectToByteArray(blockChain).Length);
//MessageBox.Show("Sekmingai balsuota");
this.BeginInvoke((MethodInvoker) delegate {
this.Close();
});
} catch (Exception ex) {
MessageBox.Show(ex.Message);
}
}
else
{
MessageBox.Show("Not connected to server. Try next time.");
}
}
static void Main(string[] args)
{
Blockchain simonCoin = new Blockchain();
simonCoin.AddBlock(new Block(DateTime.Now, null, "{sender:Tadeusz,receiver:Franek,amount:10}"));
simonCoin.AddBlock(new Block(DateTime.Now, null, "{sender:Łukasz,receiver:Igor,amount:15}"));
simonCoin.AddBlock(new Block(DateTime.Now, null, "{sender:Tomeczek,receiver:Wojtuś,amount:45}"));
Console.WriteLine(JsonConvert.SerializeObject(simonCoin, Formatting.Indented));
}
public void Unsorted_blocks_in_branch()
{
var blockchain = new Blockchain(miner, new BlockBuilder(), 1);
var genesis = new Block(new byte[] { }, 0)
{
Hash = new byte[] { 1, 5, 2 }
};
blockchain.AddBlock(genesis);
Assert.AreEqual(genesis, blockchain.Last);
Assert.AreEqual(0, blockchain.BranchesCount);
var block1A = new Block(genesis.Hash, 1)
{
Hash = new byte[] { 2, 8, 7 }
};
blockchain.AddBlock(block1A);
Assert.AreEqual(block1A, blockchain.Last);
Assert.AreEqual(0, blockchain.BranchesCount);
var block1B = new Block(genesis.Hash, 2)
{
Hash = new byte[] { 2, 8, 4 }
};
var block2B = new Block(block1B.Hash, 3)
{
Hash = new byte[] { 6, 4, 1 }
};
blockchain.AddBlock(block2B);
Assert.AreEqual(block1A, blockchain.Last);
Assert.AreEqual(1, blockchain.BranchesCount);
blockchain.AddBlock(block1B);
Assert.AreEqual(block2B, blockchain.Last);
Assert.AreEqual(3, blockchain.Trunk.Count());
Assert.IsTrue(genesis.Hash.SequenceEqual(blockchain.GetBlock(0).Hash));
Assert.IsTrue(block1B.Hash.SequenceEqual(blockchain.GetBlock(1).Hash));
Assert.IsTrue(block2B.Hash.SequenceEqual(blockchain.GetBlock(2).Hash));
Assert.AreEqual(1, blockchain.BranchesCount);
Assert.AreEqual(block1A, blockchain.GetBlock(0, 0));
}
public void TestValidBlockchain()
{
using (var tmpDir = new TempDirectory())
{
var blockchain = new Blockchain <Mock>(tmpDir.Path);
var data1 = new Mock("New data 1");
var data2 = new Mock("New data 2");
var data3 = new Mock("New data 3");
blockchain.AddBlock(data1);
blockchain.AddBlock(data2);
blockchain.AddBlock(data3);
Assert.IsTrue(blockchain.IsValidChain());
}
}
static void Main(string[] args)
{
Blockchain phillyCoin = new Blockchain();
phillyCoin.AddBlock(new Block(DateTime.Now, null, "{sender:Henry,receiver:MaHesh,amount:10}"));
phillyCoin.AddBlock(new Block(DateTime.Now, null, "{sender:MaHesh,receiver:Henry,amount:5}"));
phillyCoin.AddBlock(new Block(DateTime.Now, null, "{sender:Mahesh,receiver:Henry,amount:5}"));
Console.WriteLine(JsonConvert.SerializeObject(phillyCoin, Formatting.Indented));
Console.WriteLine($"Is Chain Valid: {phillyCoin.IsValid()}");
Console.WriteLine($"Update amount to 1000");
phillyCoin.Chain[1].Data = "{sender:Henry,receiver:MaHesh,amount:1000}";
Console.WriteLine($"Is Chain Valid: {phillyCoin.IsValid()}");
Console.ReadKey();
}
public void TestGetBlockByHash()
{
using (var tmpDir = new TempDirectory())
{
var blockchain = new Blockchain <Mock>(tmpDir.Path);
var data1 = new Mock("New data 1");
var data2 = new Mock("New data 2");
blockchain.AddBlock(data1);
blockchain.AddBlock(data2);
var block = blockchain.GetBlockByHash(data1.GetSha1());
Assert.AreEqual(1, block.Height);
Assert.AreEqual(blockchain.LastBlock.PreviousHash, block.Hash);
Assert.IsTrue(data1.Equals(block.Data));
}
}
public void RejectTamperedChain()
{
Blockchain blockchain = new Blockchain();
blockchain.AddBlock(Encoding.UTF8.GetBytes("x123 sends 0.1 BIKECOINS to y456"));
blockchain.AddBlock(Encoding.UTF8.GetBytes("more transactions"));
blockchain.AddBlock(Encoding.UTF8.GetBytes("smart contract data"));
Assert.True(blockchain.IsValidChain()); // not tampered yet
Blockchain tamperedBlockchain = TamperWithChain(blockchain);
Assert.NotNull(tamperedBlockchain);
Assert.False(tamperedBlockchain.IsValidChain());
}
private static void DoCreateBlock()
{
Console.Clear();
Console.WriteLine("\n\n\nCreate Block");
Console.WriteLine("======================");
var trxPool = Transaction.GetPool();
var transactions = trxPool.FindAll();
var numOfTrxInPool = trxPool.Count();
if (numOfTrxInPool <= 0)
{
Console.WriteLine("No transaction in pool, please create transaction first!");
}
else
{
var lastBlock = Blockchain.GetLastBlock();
// create block from transaction pool
string tempTransactions = JsonConvert.SerializeObject(transactions);
var block = new Block(lastBlock, tempTransactions);
Console.WriteLine("Block created and added to Blockchain");
Blockchain.AddBlock(block);
// move all record in trx pool to transactions table
foreach (Transaction trx in transactions)
{
Transaction.Add(trx);
}
// clear mempool
trxPool.DeleteAll();
}
}
public static Blockchain AskChain()
{
/*
* Protocol reqProtocol = new Protocol(MessageType.AskChain);
* byte[] buffer = Formatter.ToByteArray(reqProtocol);
* DataClient.Client.Client.Send(buffer, SocketFlags.None);
* Protocol receiveMessage = ReceiveMessage();
* if (receiveMessage.Type != MessageType.Response)
* {
* return null;
* }
*
* if (receiveMessage.Chain == null)
* {
* return null;
* }
*
* return receiveMessage.Chain;*/
int lenght = AskChainStats().Lenght;
Blockchain chain = new Blockchain("");
for (int i = 0; i < lenght; i++)
{
Block b = AskBlockNumber(i);
if (b != null)
{
chain.AddBlock(b);
}
}
return(chain);
}
public ActionResult Mine([FromBody] MineRequestModel request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
if (String.IsNullOrEmpty(request.Data))
{
throw new ArgumentNullException("request.Data");
}
try
{
byte[] data = Convert.FromBase64String(request.Data);
var newBlock = blockchain.AddBlock(data);
websocketBlockchainHandler.BroadcastBlockchain().ConfigureAwait(false);
Program.BroadcastBlockchain();
return(RedirectToAction("Blocks"));
}
catch (FormatException)
{
HttpContext.Response.StatusCode = (int)System.Net.HttpStatusCode.BadRequest;
return(Json(new { result = "error", message = "Data is not a valid base64 string" }));
}
}
private static void AddBlock()
{
string execType = string.Empty;
UInt16 txCount = 0;
List <Transaction> transactions = new List <Transaction>();
do
{
Console.Clear();
Console.WriteLine("(1) Add transaction\n(2) Mine block\n");
execType = Console.ReadLine();
if (execType == "1")
{
transactions.Add(AddTransaction(txCount));
}
else
{
break;
}
txCount++;
}while (execType == "1");
Block block = _chain.AddBlock(config, _currHash, transactions, DateTime.UtcNow.Ticks);
Console.WriteLine($"Added Block {block.Header.Index} with Hash: {block.Header.Hash})\n");
_currHash = block.Header.Hash;
}
public void TestPersistantBlockchain()
{
using (var tmpDir = new TempDirectory())
{
var blockchain = new Blockchain <Mock>(tmpDir.Path);
var data1 = new Mock("New data 1");
var data2 = new Mock("New data 2");
var data3 = new Mock("New data 3");
blockchain.AddBlock(data1);
blockchain.AddBlock(data2);
blockchain.AddBlock(data3);
var cpyBlockchain = new Blockchain <Mock>(blockchain.DbPath);
Assert.AreEqual(3, cpyBlockchain.LastBlock.Height);
}
}
public void AcceptBlock(PacketHeader header, Connection connection, Block newBlock)
{
if (newBlock == null)
{
ConnectionHandled(); return;
}
if (!newBlock.isValid((newBlock.block_number / Environment.diffReducer) + Environment.initialDifficulty, _chain))
{
ConnectionHandled(); return;
}
if (!Enumerable.SequenceEqual(newBlock.prev_hash, _chain.getLastHash()))
{
//If the other chain is x blocks longer, request last 10 blocks;
if (chainSize++ >= CoinFramework.Environment.TrustBlocks)
{
chainSize = 0;
connection.SendObject <int>("SendChain", _chain.chain.Count - 10);
ConnectionHandled();
return;
}
else
{
return;
}
}
if (newBlock.block_number != _chain.chain.Count + 1)
{
ConnectionHandled();
return;
}
_chain.AddBlock(newBlock);
connection.SendObject <int>("SendChain", _chain.chain.Count + 1);
}
private void MineBlock()
{
_blockchain.AddBlock(new Block(DateTime.Now, null, null));
Console.WriteLine("Mined Block successfully");
UpdateNetwork();
}
public bool AddToBlockchain(Blockchain blockchain = null)
{
if (_blockchain == null)
{
_blockchain = blockchain;
}
return(_blockchain != null && _blockchain.AddBlock(this));
}
// [TestCase(7)]
// [TestCase(8)]
public void TestZeros(int zeros)
{
var watch = Stopwatch.StartNew();
var blockchain = new Blockchain(zeros);
blockchain.AddBlock("One");
blockchain.AddBlock("Two");
blockchain.AddBlock("Three");
blockchain.AddBlock("Four");
blockchain.AddBlock("Five");
watch.Stop();
var elapsedMs = watch.ElapsedMilliseconds;
Debug.WriteLine($"{zeros} zeros: " + elapsedMs);
Assert.AreEqual(6, blockchain.Blocks.Count);
Assert.IsTrue(blockchain.IsCorrectChain());
}
public void DontReplaceWithShortChain()
{
Blockchain blockchain = new Blockchain();
blockchain.AddBlock(Encoding.UTF8.GetBytes("x123 sends 0.1 BIKECOINS to y456"));
blockchain.AddBlock(Encoding.UTF8.GetBytes("more transactions"));
blockchain.AddBlock(Encoding.UTF8.GetBytes("smart contract data"));
Blockchain newBlockchain = new Blockchain();
newBlockchain.AddBlock(Encoding.UTF8.GetBytes("x123 sends 0.1 BIKECOINS to y456"));
newBlockchain.AddBlock(Encoding.UTF8.GetBytes("more transactions"));
(bool result, bool?tooShort, bool?invalid) = blockchain.ReplaceBlocks(newBlockchain);
Assert.False(result);
Assert.True(tooShort.HasValue && tooShort.Value);
Assert.False(invalid.HasValue);
}
public void Branch()
{
var blockchain = new Blockchain(miner, new BlockBuilder(), 1);
var genesis = new Block(new byte[] { }, 0)
{
Hash = new byte[] { 1, 5, 2 }
};
blockchain.AddBlock(genesis);
Assert.AreEqual(1, blockchain.Trunk.Count());
Assert.AreEqual(0, blockchain.BranchesCount);
var block1A = new Block(genesis.Hash, 1)
{
Hash = new byte[] { 2, 8, 7 }
};
blockchain.AddBlock(block1A);
Assert.AreEqual(2, blockchain.Trunk.Count());
Assert.AreEqual(0, blockchain.BranchesCount);
var block1B = new Block(genesis.Hash, 1)
{
Hash = new byte[] { 2, 1, 7 }
};
blockchain.AddBlock(block1B);
Assert.AreEqual(2, blockchain.Trunk.Count());
Assert.AreEqual(1, blockchain.BranchesCount);
var block1C = new Block(genesis.Hash, 1)
{
Hash = new byte[] { 2, 1, 2 }
};
blockchain.AddBlock(block1C);
Assert.AreEqual(2, blockchain.Trunk.Count());
Assert.AreEqual(2, blockchain.BranchesCount);
}
public void ValidateValidChain()
{
Blockchain blockchain = new Blockchain();
Assert.True(blockchain.IsValidChain());
blockchain.AddBlock(Encoding.UTF8.GetBytes("x123 sends 0.1 BIKECOINS to y456"));
Assert.True(blockchain.IsValidChain());
}
public void Trunk()
{
var blockchain = new Blockchain(miner, new BlockBuilder(), 1);
var genesis = new Block(new byte[] { }, 0)
{
Hash = new byte[] { 1, 5, 2 }
};
blockchain.AddBlock(genesis);
var block1 = new Block(genesis.Hash, 1)
{
Hash = new byte[] { 2, 8, 7 }
};
blockchain.AddBlock(block1);
Assert.AreEqual(2, blockchain.Trunk.Count());
}
static void Main(string[] args)
{
var blockchain = new Blockchain <MyData>(@"C:\temp\blockchain");
for (var i = 1; i < 21; i++)
{
blockchain.AddBlock($"New block {i}");
}
var valid = blockchain.IsValidChain();
var block = blockchain.GetBlockByHash(blockchain.GetBlock(10).Hash);
}
public void TestInsertBlock()
{
using (var tmpDir = new TempDirectory())
{
var blockchain = new Blockchain <Mock>(tmpDir.Path);
var data = new Mock("New data 1");
blockchain.AddBlock(data);
Assert.AreEqual(1, blockchain.LastBlock.Height);
Assert.IsNotNull(blockchain.LastBlock.PreviousHash);
Assert.IsTrue(data.Equals(blockchain.LastBlock.Data));
}
}
static void Main(string[] args)
{
var sw = new Stopwatch();
sw.Start();
var lolicoin = new Blockchain();
lolicoin.AddBlock(new Block(1, DateTime.Today.TimeOfDay, new BlockData {
Amount = 4, Description = "My first 4 lolicoins"
}));
int firstBlockTime = sw.Elapsed.Milliseconds;
lolicoin.AddBlock(new Block(2, DateTime.Today.AddDays(1).TimeOfDay, new BlockData {
Amount = 10, Description = "Another 10 lolicoins"
}));
int secondBlockTime = sw.Elapsed.Milliseconds;
sw.Stop();
Debug.WriteLine($"First Block added after {firstBlockTime} ms");
Debug.WriteLine($"Second Block added after {secondBlockTime} ms");
Console.WriteLine(JsonConvert.SerializeObject(lolicoin, Formatting.Indented));
Debug.WriteLine($"Is Blockchain valid? {lolicoin.IsChainValid()}");
Debug.WriteLine("Tampering block data...");
lolicoin.Chain[1].Data = new BlockData {
Amount = 100
};
Debug.WriteLine($"Is Blockchain valid? {lolicoin.IsChainValid()}");
Debug.WriteLine("Tampering block hash...");
lolicoin.Chain[1].Hash = lolicoin.Chain[1].CalculateHash();
Debug.WriteLine($"Is Blockchain valid? {lolicoin.IsChainValid()}");
Console.ReadLine();
}
static void Main(string[] args)
{
Console.WriteLine("------Initializing blockchain------");
Blockchain bc = new Blockchain();
do
{
Console.WriteLine($"Index of last block: {bc.GetLastBlock().Index}");
Console.WriteLine($"Mining attempts: {bc.GetLastBlock().Nonce}");
Console.WriteLine($"-----Verifying validiy------");
Console.WriteLine($"Blockchain is valid: {bc.IsValid()}");
Console.WriteLine("------Input next block data------");
var input = Console.ReadLine();
bc.AddBlock(input);
} while (true);
}
public Block Post([FromBody] Block value)
{
if (value != null)
{
Blockchain Chain = Program.Chain;
foreach (var I in Chain.Chain)
{
if (I.Username == value.Username)
{
return(new Block(DateTime.Now, null, null, null, null, 1));
}
}
Block Updated = new Block(DateTime.Now, null, value.Username, value.Password, value.Packeages, value.Pickle);
Chain.AddBlock(Updated);
new SaveBlockChain();
return(Updated);
}
return(new Block(DateTime.Now, null, null, null, null, 1));
}
private static bool ImportBlocks(Blockchain blockchain, Stream stream)
{
var levelDBBlockchain = blockchain as LevelDBBlockchain;
if (levelDBBlockchain != null)
{
levelDBBlockchain.VerifyBlocks = false;
}
using (var reader = new BinaryReader(stream))
{
var count = reader.ReadUInt32();
for (int height = 0; height < count; height++)
{
var array = reader.ReadBytes(reader.ReadInt32());
if (height <= blockchain.Height)
{
continue;
}
var block = array.AsSerializable <Block>();
try
{
blockchain.AddBlock(block);
}
catch (ObjectDisposedException)
{
// Blockchain instance has been disposed. This is most likely due to the application exiting
return(false);
}
}
}
if (levelDBBlockchain != null)
{
levelDBBlockchain.VerifyBlocks = true;
}
return(true);
}
/// <summary>
/// 1. Get valid transactions from transaction pool
/// 2. Include a reward for the miner
/// 3. Create a block consisting of the valid transactions
/// </summary>
public void Mine()
{
// 1. Get valid transactions
var response = TransactionPool.Instance.ValidTransactions();
ValidTransactions = response.Item2;
if (!response.Item1)
{
InvalidTransactions = JsonConvert.DeserializeObject <List <Transaction> >(response.Item3);
}
// 2. Create reward transaction for miner
if (ValidTransactions.Count > 0)
{
Transaction rewardTransaction = new Transaction();
rewardTransaction.CreateRewardTransaction(MinerWallet);
ValidTransactions.Add(rewardTransaction);
}
//3. Create block consisiting of valid transactions
Blockchain.AddBlock(JsonConvert.SerializeObject(ValidTransactions));
}