public byte[] CalculateMerkleRootInternal(MerkleProofElement currentElement, MerkleHashCalculator calculator)
{
if (currentElement is ProofHashedLeaf)
{
var leafElement = (ProofHashedLeaf)currentElement;
return(leafElement.MerkleHash);
}
else if (currentElement is ProofValueLeaf)
{
var valueElement = (ProofValueLeaf)currentElement;
var value = valueElement.Content;
if (calculator.IsContainerProofValueLeaf(value))
{
var merkleProofTree = this.BuildProofTree(value, calculator);
return(this.CalculateMerkleRootInternal(merkleProofTree.Root, calculator));
}
else
{
return(calculator.CalculateLeafHash(value));
}
}
else if (currentElement is ProofNode)
{
var proofElement = (ProofNode)currentElement;
var left = this.CalculateMerkleRootInternal(proofElement.Left, calculator);
var right = this.CalculateMerkleRootInternal(proofElement.Right, calculator);
return(calculator.CalculateNodeHash(proofElement.Prefix, left, right));
}
else
{
throw new System.Exception("Should have handled this type? " + currentElement.GetType());
}
}
public MerkleHashSummary CalculateMerkleRoot(object value, MerkleHashCalculator calculator)
{
var binaryTree = this.TreeFactory.Build(value);
var proofTree = this.ProofFactory.BuildFromBinaryTree(binaryTree, calculator);
return(this.CalculateMerkleRootOfTree(proofTree, calculator));
}
public static byte[] MerkleHash(object value, MerkleHashCalculator calculator)
{
return(MerkleHashSummary(value, calculator).MerkleHash);
}
public static MerkleProofTree GenerateProof(object value, PathSet pathSet, MerkleHashCalculator calculator)
{
var binaryTree = treeFactory.BuildWithPath(value, pathSet);
return(proofFactory.BuildFromBinaryTree(binaryTree, calculator));
}
private static MerkleHashSummary MerkleProofHashSummary(MerkleProofTree tree, MerkleHashCalculator calculator)
{
var summaryFactory = new MerkleHashSummaryFactory(treeFactory, proofFactory);
return(summaryFactory.CalculateMerkleTreeRoot(tree, calculator));
}
public static MerkleHashSummary MerkleHashSummary(object value, MerkleHashCalculator calculator)
{
var summaryFactory = new MerkleHashSummaryFactory(treeFactory, proofFactory);
return(summaryFactory.CalculateMerkleRoot(value, calculator));
}
public static byte[] MerkleTreeHash(MerkleProofTree tree, MerkleHashCalculator calculator)
{
return(MerkleProofHashSummary(tree, calculator).MerkleHash);
}
public MerkleProofTree BuildProofTree(object value, MerkleHashCalculator calculator)
{
var root = this.TreeFactory.Build(value);
return(this.ProofFactory.BuildFromBinaryTree(root, calculator));
}
public MerkleHashSummary CalculateMerkleRootOfTree(MerkleProofTree proofTree, MerkleHashCalculator calculator)
{
var calculatedSummary = this.CalculateMerkleRootInternal(proofTree.Root, calculator);
return(new MerkleHashSummary(calculatedSummary));
}
public MerkleHashSummary CalculateMerkleTreeRoot(MerkleProofTree tree, MerkleHashCalculator calculator)
{
return(this.CalculateMerkleRootOfTree(tree, calculator));
}
public MerkleProofElement BuildFromBinaryTreeInternal(BinaryTreeElement currentElement, MerkleHashCalculator calculator)
{
if (currentElement is EmptyLeaf)
{
return(new ProofHashedLeaf(new byte[32]));
}
else if (currentElement is Leaf)
{
var leafElement = (Leaf)currentElement;
var pathElem = currentElement.PathElem;
if (!(pathElem is null))
{
if (pathElem is PathLeafElement)
{
return(new ProofValueLeaf(leafElement.Content, pathElem.Previous));
}
else
{
throw new System.Exception("The path and structure don't match. We are at a leaf, but path elem is not a leaf: " + pathElem);
}
}
else
{
var hash = calculator.CalculateLeafHash(leafElement.Content);
return(new ProofHashedLeaf(hash));
}
}
public MerkleProofTree BuildFromBinaryTree(BinaryTree originalTree, MerkleHashCalculator calculator)
{
var rootElem = this.BuildFromBinaryTreeInternal(originalTree.Root, calculator);
return(new MerkleProofTree(rootElem));
}
