public static Block CreateWithAddedTransactions(this Block block, params EncodedTx[] transactions)
{
// update transactions
var updatedTxes = block.BlockTxes.AddRange(transactions.Select((tx, txIndex) =>
new BlockTx(block.BlockTxes.Length + txIndex, tx)));
// update merkle root
var updatedHeader = block.Header.With(MerkleRoot: MerkleTree.CalculateMerkleRoot(updatedTxes));
return(new Block(updatedHeader, updatedTxes));
}
private void BuildMerkleTree()
{
merkleTree = new MerkleTree();
foreach (ITransaction txn in Transaction)
{
merkleTree.AppendLeaf(MerkleHash.Create(txn.CalculateTransactionHash()));
}
merkleTree.BuildTree();
}
public void BuildMerkleTree()
{
merkleTreeObj = new MerkleTree();
foreach (ITransaction transaction in Transaction)
{
merkleTreeObj.AppendLeaf(MerkleHash.Create(transaction.CalculateTransactionHash()));
}
merkleTreeObj.BuildTree();
}
public void Tree_to_Array()
{
// Arrange
var tree = MerkleTree.ComputeTree(_hashes);
// Act
var hasharray = tree.ToHashArray();
// Assert
CollectionAssert.AreEqual(_hashes, hasharray);
}
public void CreateTree(MerkleTree tree, int numLeaves)
{
List <DemoMerkleNode> leaves = new List <DemoMerkleNode>();
for (int i = 0; i < numLeaves; i++)
{
tree.AppendLeaf(DemoMerkleNode.Create(i.ToString()).SetText(i.ToString("X")));
}
tree.BuildTree();
}
public void Search_Node()
{
// Act
var tree = MerkleTree.ComputeTree(_hashes);
var node = tree.Search(UInt256.Parse("d7578928d3ffde14619ce1ceaecbf0300b303a4f09916c0c62006625ba9d251a"));
var nodeNone = tree.Search(UInt256.Parse("f6049de2a1ce95dc4fbff3c66af5900ff2733d78c0eaab7c723c92f0a1e62f23"));
// Assert
Assert.AreEqual("0xd7578928d3ffde14619ce1ceaecbf0300b303a4f09916c0c62006625ba9d251a", node.Hash.ToString());
Assert.IsNull(nodeNone);
}
public string GetPayloadHash()
{
var hashsBytes = this.Transactions.Select(tx => Base16.Decode(tx.Hash)).ToList();
var bytes = MerkleTree.Hash(hashsBytes);
return(Base16.Encode(
HashHelper.Hash(
bytes.ToArray()
)));
}
public Archive CreateArchive(MerkleTree merkleTree, ArchiveFlags flags)
{
var archive = FindArchive(merkleTree.Root);
if (archive != null)
{
return(archive);
}
throw new NotImplementedException();
}
public void Can_calculate_sibling_index(uint level, uint indexAtLevel, uint?expectedSiblingIndex)
{
if (expectedSiblingIndex == null)
{
Assert.Throws <IndexOutOfRangeException>(() => MerkleTree.GetSiblingIndex(level, indexAtLevel));
}
else
{
MerkleTree.GetSiblingIndex(level, indexAtLevel).Should().Be(expectedSiblingIndex.Value);
MerkleTree.GetSiblingIndex(level, expectedSiblingIndex.Value).Should().Be(indexAtLevel);
}
}
public Block EnsureHeader()
{
if (TransactionHashes == null)
{
return(null);
}
if (Block.MerkleRoot is null)
{
Block.MerkleRoot = MerkleTree.ComputeRoot(TransactionHashes);
}
return(Block);
}
public string HashBlockTransactions(List <Transaction> transactions)
{
if (transactions == null || transactions.Count == 0)
{
return(string.Empty);
}
List <string> hashes = transactions.Select(x => x.TransactionId).ToList();
MerkleTree tree = new MerkleTree(hashes);
return(tree.Root.Hash);
}
public void Get_Leafs()
{
// Arrange
var tree = MerkleTree.ComputeTree(_hashes);
// Act
var leafs = tree.Root.GetLeafs().Select(u => u.Hash).ToArray();
// Assert
Assert.IsTrue(_hashes.SequenceEqual(leafs));
Assert.AreEqual((tree.Depth - 1) * 2, leafs.Length);
}
public MerkleTreeTests()
{
_subject = new MerkleTree();
_hashes = new[]
{
HashUtil.Blake256(new byte[] { 0x01 }),
HashUtil.Blake256(new byte[] { 0x02 }),
HashUtil.Blake256(new byte[] { 0x03 }),
HashUtil.Blake256(new byte[] { 0x04 }),
HashUtil.Blake256(new byte[] { 0x05 }),
};
}
public void Can_calculate_sibling_index(uint row, uint indexAtRow, uint?expectedSiblingIndex)
{
if (expectedSiblingIndex == null)
{
Assert.Throws <ArgumentOutOfRangeException>(() => MerkleTree.GetSiblingIndex(row, indexAtRow));
}
else
{
MerkleTree.GetSiblingIndex(row, indexAtRow).Should().Be(expectedSiblingIndex.Value);
MerkleTree.GetSiblingIndex(row, expectedSiblingIndex.Value).Should().Be(indexAtRow);
}
}
public void Trim()
{
// Arrange
var tree = MerkleTree.ComputeTree(_hashes);
var bitarray = new BitArray(new byte[] { });
// Act
tree.Trim(bitarray);
// Assert
Assert.AreEqual("0x04948a9f4b7d5d1c7ed2cbd7f7034cfa095ce08d0b7a25959a083dc446aa8743", tree.Root.Hash.ToString());
}
public void ProofListTest()
{
MerkleTree tree = new MerkleTree();
tree.AddLeaves(CreateLeaves(new string[] { "a", "e", "l", "f", "2", "0", "1", "8" }));
tree.GenerateMerkleTree();
MerkleHash target = new MerkleHash("e");
var prooflist = tree.GetProofList(target);
Assert.True(prooflist[0].Hash.ToString() == new MerkleHash("a").ToString());
Assert.True(prooflist[prooflist.Count - 1].Hash.ToString() == tree.MerkleRoot.Hash.ToString());
}
public BlockWithTransactions Build()
{
if (_genesisBlock != null)
{
return(_genesisBlock);
}
var genesisConfig = _configManager.GetConfig <GenesisConfig>("genesis") ??
throw new InvalidOperationException("No genesis config found");
var fromAddress = UInt160Utils.Zero; // mint initial tokens from zero address
var balances = genesisConfig !.Balances
.OrderBy(x => x.Key)
.ToArray();
var genesisTransactions = balances.Select((t, i) => new Transaction
{
From = fromAddress,
Nonce = (ulong)i,
Value = Money.Parse(t.Value).ToUInt256(),
To = t.Key.HexToUInt160(),
GasPrice = 0,
})
.Select(tx => new TransactionReceipt
{
Transaction = tx,
Hash = HardforkHeights.IsHardfork_9Active(0) ? tx.FullHash(SignatureUtils.ZeroNew, true) : tx.FullHash(SignatureUtils.ZeroOld, false),
Signature = HardforkHeights.IsHardfork_9Active(0) ? SignatureUtils.ZeroNew : SignatureUtils.ZeroOld,
})
.ToList();
var txHashes = genesisTransactions.Select(tx => tx.Hash).ToArray();
var header = new BlockHeader
{
PrevBlockHash = UInt256Utils.Zero,
MerkleRoot = MerkleTree.ComputeRoot(txHashes) ?? UInt256Utils.Zero,
Index = 0,
StateHash = UInt256Utils.Zero,
Nonce = GenesisConsensusData
};
var result = new Block
{
Hash = header.Keccak(),
TransactionHashes = { txHashes },
Header = header
};
_genesisBlock = new BlockWithTransactions(result, genesisTransactions.ToArray());
return(_genesisBlock);
}
public void Can_get_leaf(uint nodesCount)
{
MerkleTree baselineTree = BuildATree();
for (int i = 0; i < nodesCount; i++)
{
baselineTree.Insert(_testLeaves[0]);
}
for (int i = 0; i < nodesCount; i++)
{
baselineTree.GetLeaf((uint)i).Hash.Should().NotBe(Keccak.Zero);
}
}
protected virtual void BuildMerkleBranches()
{
var transactionHashes = BlockTemplate.Transactions
.Select(tx => (tx.TxId ?? tx.Hash)
.HexToByteArray()
.ReverseArray())
.ToArray();
mt = new MerkleTree(transactionHashes);
merkleBranchesHex = mt.Steps
.Select(x => x.ToHexString())
.ToArray();
}
public Block CreateEmptyBlock(UInt256 previousBlockHash, UInt256?target = null)
{
var coinbaseTx = new Transaction
(
version: 0,
inputs: ImmutableArray.Create
(
new TxInput
(
previousTxOutputKey: new TxOutputKey
(
txHash: 0,
txOutputIndex: 0
),
scriptSignature: ImmutableArray.Create(random.NextBytes(100)),
sequence: 0
)
),
outputs: ImmutableArray.Create
(
new TxOutput
(
value: 50 * SATOSHI_PER_BTC,
scriptPublicKey: ImmutableArray.Create(this.txManager.CreatePublicKeyScript(coinbasePublicKey))
)
),
lockTime: 0
);
//Debug.WriteLine("Coinbase Tx Created: {0}".Format2(coinbaseTx.Hash.ToHexNumberString()));
var transactions = ImmutableArray.Create(coinbaseTx);
var merkleRoot = MerkleTree.CalculateMerkleRoot(transactions);
var block = new Block
(
header: new BlockHeader
(
version: 0,
previousBlock: previousBlockHash,
merkleRoot: merkleRoot,
time: 0,
bits: DataCalculator.TargetToBits(target ?? UnitTestRules.Target0),
nonce: 0
),
transactions: transactions
);
return(block);
}
public void Can_restore_count_from_the_database(uint leafCount)
{
MemMerkleTreeStore memDb = new MemMerkleTreeStore();
MerkleTree baselineTree = BuildATree(memDb);
for (int i = 0; i < leafCount; i++)
{
baselineTree.Insert(_testLeaves[0]);
}
MerkleTree baselineTreeRestored = BuildATree(memDb);
baselineTreeRestored.Count.Should().Be(leafCount);
}
public void Test_Tree()
{
// Act
var root = MerkleTree.ComputeRoot(_hashes);
var tree = MerkleTree.ComputeTree(_hashes);
// Assert
Assert.AreEqual("0x04948a9f4b7d5d1c7ed2cbd7f7034cfa095ce08d0b7a25959a083dc446aa8743", root.ToString());
Assert.AreEqual(root, tree.Root.Hash);
Assert.AreEqual(tree.Depth, 3);
Assert.IsTrue(tree.Root.IsRoot);
Assert.AreEqual("0xe2a1ce95dc4fbff3c66af5900ff2733d78c0eaab7c723c92f0a1e62f23f6049d", tree.Root.LeftChild.Hash.ToString());
Assert.AreEqual("0x6f143cb819dc8934ad357cb9b8185c084c7b82bbb173ef4d06b2acb09f70ad76", tree.Root.RightChild.Hash.ToString());
}
private CreateBlockModel Mining()
{
if (Block.Transactions.Count == 0)
{
return(null);
}
var transactionHash = MerkleTree <TransactionModel> .Compute(Block.Transactions.OrderBy(x => x.Id).ToList());
var obj = new MiningBlock
{
Hash = transactionHash.TrimEnd('=') + Block.PreviousHash.TrimEnd('='),
PreviousBlockHash = Block.PreviousHash.TrimEnd('='),
Nonce = -1,
Miner = User
};
string blockResultHash;
using (SHA256Managed sha = new SHA256Managed())
{
using (MemoryStream ms = new MemoryStream())
{
do
{
if (_miningTokenSource.IsCancellationRequested)
{
return(null);
}
obj.Nonce++;
_hashCurr = obj.Nonce;
ms.Position = 0;
BinaryFormatter bf = new BinaryFormatter();
bf.Serialize(ms, obj);
blockResultHash = Convert.ToBase64String(sha.ComputeHash(ms.ToArray()));
ThreadHelperClass.SetText(this, Output, blockResultHash);
}while (!blockResultHash.Substring(0, 2).All(x => x == '0'));
return(new CreateBlockModel
{
Date = DateTimeOffset.Now,
Hash = blockResultHash,
Miner = User,
Nonce = obj.Nonce,
PrevBlockHash = Block.PreviousHash,
Transactions = Block.Transactions.Select(x => x.Id).ToList()
});
}
}
}
public void FixingOddNumberOfLeavesByAddingTreeTest()
{
MerkleTree tree = new MerkleTree();
MerkleHash l1 = MerkleHash.Create("abc");
MerkleHash l2 = MerkleHash.Create("def");
MerkleHash l3 = MerkleHash.Create("123");
tree.AppendLeaves(new MerkleHash[] { l1, l2, l3 });
MerkleHash rootHash = tree.BuildTree();
tree.AddTree(new MerkleTree());
MerkleHash rootHashAfterFix = tree.BuildTree();
Assert.IsTrue(rootHash == rootHashAfterFix);
}
public void WriteArchiveBlock(Archive archive, byte[] content, int blockIndex)
{
Throw.IfNull(archive, nameof(archive));
Throw.IfNull(content, nameof(content));
Throw.If(blockIndex < 0 || blockIndex >= archive.BlockCount, "invalid block index");
var hash = MerkleTree.CalculateBlockHash(content);
if (!archive.MerkleTree.VerifyContent(hash, blockIndex))
{
throw new ArchiveException("Block content mismatch");
}
_archiveContents.Set(hash, content);
}
public void FixingOddNumberOfLeavesManuallyTest()
{
MerkleTree tree = new MerkleTree();
MerkleHash l1 = MerkleHash.Create("abc");
MerkleHash l2 = MerkleHash.Create("def");
MerkleHash l3 = MerkleHash.Create("123");
tree.AppendLeaves(new MerkleHash[] { l1, l2, l3 });
MerkleHash rootHash = tree.BuildTree();
tree.FixOddNumberLeaves();
MerkleHash rootHashAfterFix = tree.BuildTree();
Assert.True(rootHash != rootHashAfterFix);
}
public static MerkleBlockPayload Create(Block block, BitArray flags)
{
MerkleTree tree = new MerkleTree(block.Transactions.Select(p => p.Hash).ToArray());
tree.Trim(flags);
byte[] buffer = new byte[(flags.Length + 7) / 8];
flags.CopyTo(buffer, 0);
return(new MerkleBlockPayload
{
Header = block.Header,
TxCount = block.Transactions.Length,
Hashes = tree.ToHashArray(),
Flags = buffer
});
}
public void FixingOddNumberOfLeavesManuallyTest()
{
MerkleTree tree = new MerkleTree();
MerkleHash l1 = new MerkleHash("abc");
MerkleHash l2 = new MerkleHash("def");
MerkleHash l3 = new MerkleHash("123");
tree.Append(new MerkleHash[] { l1, l2, l3 });
MerkleHash rootHash = tree.BuildTree();
tree.FixOddNumberLeaves();
MerkleHash rootHashAfterFix = tree.BuildTree();
(rootHash != rootHashAfterFix).Should().BeTrue();
}
public string GetUnConsolidatedHash(List <string> unCons)
{
if (unCons.Count() == 0)
{
return(null);
}
var mt = new MerkleTree();
foreach (var hash in unCons)
{
mt.AppendLeaf(MerkleHash.Create(hash));
}
return(mt.BuildTree().ToString());
}
public Archive CreateArchive(MerkleTree merkleTree, BigInteger size, ArchiveFlags flags, byte[] key)
{
var archive = FindArchive(merkleTree.Root);
if (archive != null)
{
return(archive);
}
archive = new Archive(merkleTree, size, flags, key);
var archiveHash = merkleTree.Root;
_archiveEntries.Set(archiveHash, archive);
return(archive);
}
