public override string ToString()
{
var branch = Branch == Branch.Left ? "left" : "right";
var encodedHash = HexEncoder.Encode(Hash);
return($"{branch}:{encodedHash}");
}
public void Proof()
{
var mt = new MerkleTree();
foreach (var i in Enumerable.Range(0, 10))
{
mt.AddLeaf(sha256($"test{i}"));
}
Assert.Equal(5, mt.Levels);
foreach (var i in Enumerable.Range(0, 10))
{
var proof = mt.GetProof(i);
var receipt = proof.ToReceipt();
receipt.AddAnchor("BTCOpReturn", "ae125");
var jo = (JObject)JsonConvert.DeserializeObject(receipt.ToJson());
Assert.Equal(receipt.Context, jo["@context"]);
Assert.Equal(HexEncoder.Encode(receipt.TargetHash), (string)(jo["targetHash"]));
Assert.Equal(HexEncoder.Encode(receipt.MerkleRoot), (string)(jo["merkleRoot"]));
Assert.Equal(receipt.Type, jo["type"]);
Assert.Equal("ChainpointSHA256v2", receipt.Type);
var rproof = (JArray)jo["proof"];
var j = 0;
foreach (var p in proof)
{
var branch = (p.Branch == Branch.Left) ? "left" : "right";
var rp = rproof[j++];
Assert.Equal(HexEncoder.Encode(p.Hash), (string)(rp[branch]));
}
Assert.True((bool)mt.ValidateProof(proof, sha256($"test{i}")));
}
}
public object ToJson()
{
var branch = Branch == Branch.Left ? "left" : "right";
var encodedHash = HexEncoder.Encode(Hash);
return($"{{ \"{branch}\":\"{encodedHash}\"}}");
}
public void WhenDelimiterSet_ThenReturnEncodedWithDelimiter(char delimiter, string expected)
{
var sut = new HexEncoder(delimiter);
var result = sut.Encode("John");
Assert.That(result, Is.EqualTo(expected));
}
/// <inheritdoc />
public string GetFilePath(IMediaFileSystem fileSystem, Guid itemGuid, Guid propertyGuid, string filename, string previous = null)
{
// assumes that cuid and puid keys can be trusted - and that a single property type
// for a single content cannot store two different files with the same name
var directory = HexEncoder.Encode(GuidUtils.Combine(itemGuid, propertyGuid).ToByteArray() /*'/', 2, 4*/); // could use ext to fragment path eg 12/e4/f2/...
return(Path.Combine(directory, filename).Replace('\\', '/'));
}
public static string ToHex(this byte[] bytes, bool upperCase = false)
{
if (bytes == null)
{
return(string.Empty);
}
return(upperCase ? HEX_UPPERCASE.Encode(bytes) : HEX.Encode(bytes));
}
public void ToHexStringWithSeparatorCreatesCorrectValue()
{
var buffer = new byte[255];
var random = new Random();
random.NextBytes(buffer);
var expected = ToHexString(buffer, '/', 2, 4);
var actual = HexEncoder.Encode(buffer, '/', 2, 4);
Assert.AreEqual(expected, actual);
}
public void HexEncoderOutputIsCorrect()
{
byte[] hash = Hash();
var sb = new StringBuilder(hash.Length * 2);
for (int i = 0; i < hash.Length; i++)
{
sb.Append(hash[i].ToString("x2"));
}
string expected = sb.ToString();
string actual = HexEncoder.Encode(hash);
Assert.Equal(expected, actual);
}
public void ToHexStringCreatesCorrectValue()
{
var buffer = new byte[255];
var random = new Random();
random.NextBytes(buffer);
var sb = new StringBuilder(buffer.Length * 2);
for (var i = 0; i < buffer.Length; i++)
{
sb.Append(buffer[i].ToString("X2"));
}
var expected = sb.ToString();
var actual = HexEncoder.Encode(buffer);
Assert.AreEqual(expected, actual);
}
static bool GetNextValue(string charset, Encoder encoder, HexEncoder hex, char[] chars, ref int index,
ref byte[] bytes, ref byte[] encoded, int maxLength, out string value)
{
int length = chars.Length - index;
if (length < maxLength)
{
switch (GetEncodeMethod(chars, index, length))
{
case EncodeMethod.Quote:
value = MimeUtils.Quote(new string (chars, index, length));
index += length;
return(false);
case EncodeMethod.None:
value = new string (chars, index, length);
index += length;
return(false);
}
}
length = Math.Min(maxLength, length);
int ratio, count, n;
do
{
count = encoder.GetByteCount(chars, index, length, true);
if (count > maxLength && length > 1)
{
ratio = (int)Math.Round((double)count / (double)length);
length -= Math.Max((count - maxLength) / ratio, 1);
continue;
}
if (bytes.Length < count)
{
Array.Resize <byte> (ref bytes, count);
}
count = encoder.GetBytes(chars, index, length, bytes, 0, true);
// Note: the first chunk needs to be encoded in order to declare the charset
if (index > 0 || charset == "us-ascii")
{
var method = GetEncodeMethod(bytes, count);
if (method == EncodeMethod.Quote)
{
value = MimeUtils.Quote(Encoding.ASCII.GetString(bytes, 0, count));
index += length;
return(false);
}
if (method == EncodeMethod.None)
{
value = Encoding.ASCII.GetString(bytes, 0, count);
index += length;
return(false);
}
}
n = hex.EstimateOutputLength(count);
if (encoded.Length < n)
{
Array.Resize <byte> (ref encoded, n);
}
// only the first value gets a charset declaration
int charsetLength = index == 0 ? charset.Length + 2 : 0;
n = hex.Encode(bytes, 0, count, encoded);
if (n > 3 && (charsetLength + n) > maxLength)
{
int x = 0;
for (int i = n - 1; i >= 0 && charsetLength + i >= maxLength; i--)
{
if (encoded[i] == (byte)'%')
{
x--;
}
else
{
x++;
}
}
ratio = (int)Math.Round((double)count / (double)length);
length -= Math.Max(x / ratio, 1);
continue;
}
if (index == 0)
{
value = charset + "''" + Encoding.ASCII.GetString(encoded, 0, n);
}
else
{
value = Encoding.ASCII.GetString(encoded, 0, n);
}
index += length;
return(true);
} while (true);
}
/// <summary>
/// Checks if two NamesTable are equals, if not, prints the values that do not appear in both of them
/// </summary>
/// <param name="tableNumberTwo">a table of entries</param>
/// <returns>true of false if table is identical</returns>
public bool CompareTablesAndPrintResults(NamesTable tableNumberTwo)
{
// Check if tree root identical
if (HexEncoder.Encode(tableHashTree.MerkleRootHash) ==
HexEncoder.Encode(tableNumberTwo.tableHashTree.MerkleRootHash))
{
Console.WriteLine("Tables are identical");
return(true);
}
// If you're here, the tables aren't identical
int currIndex = tableOfEntries.Count / 2;
int lowerLimit = 0;
int upperLimit = tableOfEntries.Count - 1;
string direction;
Proof currProof, myProof;
ArrayList currProofStr, myProofStr;
while (true)
{
try
{
// If GetProof throws exception, value is not in table
currProof = tableNumberTwo.tableHashTree.GetProof(ToBytes(tableOfEntries[currIndex].ToString()));
}
catch
{
Console.WriteLine("The entry \"" +
tableOfEntries[currIndex].ToString() +
"\" is not in the other table");
return(false);
}
// this is a failsafe, should never be true
if (currIndex == 0)
{
break;
}
//Console.WriteLine("Checking index number " + currIndex);
// Getting proof for my table
myProof = tableHashTree.GetProof(ToBytes(tableOfEntries[currIndex].ToString()));
// Parsing proofs from both tables
currProofStr = ParseProof(currProof);
myProofStr = ParseProof(myProof);
// finding different hashes in the Proof and setting the direction to continue
for (int i = 0; i < currProofStr.Count; i++)
{
i++;
if (!(currProofStr[i].Equals(myProofStr[i])))
{
direction = myProofStr[i - 1].ToString().Replace(" ", string.Empty);
if (direction.Equals("right")) // Going right
{
lowerLimit = currIndex;
currIndex = ((lowerLimit + upperLimit) / 2);
if (((lowerLimit + upperLimit) % 2) == 1)
{
currIndex++;
}
}
else // Going left
{
upperLimit = currIndex;
currIndex = (lowerLimit + upperLimit) / 2;
}
break;
}
}
}
return(false);
}
public void TestEncodeLower()
{
IEncoder encoder = new HexEncoder(false);
Assert.AreEqual(testhexStringLowercase, encoder.Encode(testTytes));
}
public void TestEncodeUpper()
{
IEncoder encoder = new HexEncoder(true);
Assert.AreEqual(testhexStringUppercase, encoder.Encode(testTytes));
}
public void ShouldEncodeToUppercase()
{
var encoder = new HexEncoder();
var encoded = encoder.Encode(new byte[] {0x66, 0xff, 0x00, 0x44});
Assert.AreEqual("66FF0044", encoded);
}
public void Example()
{
var tree = new MerkleTree();
tree.AddLeave(new[] {
HexEncoder.Decode("e1566f09e0deea437826514431be6e4bdb4fe10aa54d75aecf0b4cdc1bc4320c"),
HexEncoder.Decode("2f7f9092b2d6c5c17cfe2bcf33fc38a41f2e4d4485b198c2b1074bba067e7168"),
HexEncoder.Decode("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"),
HexEncoder.Decode("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855")
});
var root = HexEncoder.Encode(tree.MerkleRootHash);
Console.WriteLine(root);
// 740c08b74d31bb77fd9806e4f6159d88dfd012acf8984bd41b4b4c9cbd7aa358
var proof = tree.GetProof(1);
Console.WriteLine(proof.ToJson());
/*
* [{
* "left": "e1566f09e0deea437826514431be6e4bdb4fe10aa54d75aecf0b4cdc1bc4320c"
* },{
* "right":"2dba5dbc339e7316aea2683faf839c1b7b1ee2313db792112588118df066aa35"
* }]"
*/
var hash = HexEncoder.Decode("2f7f9092b2d6c5c17cfe2bcf33fc38a41f2e4d4485b198c2b1074bba067e7168");
var isValid = tree.ValidateProof(proof, hash);
Console.WriteLine(isValid); // true
var receipt = proof.ToReceipt();
receipt.AddBitcoinAnchor("780b4cdc16f09e0deebce156a434320c2654fe10aa54d75ae14431be6e4bdbcf");
Console.WriteLine(receipt.ToJson());
/*
* {
* "@context":"https://w3id.org/chainpoint/v2",
* "type":"ChainpointSHA256v2",
* "targetHash":"2f7f9092b2d6c5c17cfe2bcf33fc38a41f2e4d4485b198c2b1074bba067e7168",
* "merkleRoot":"740c08b74d31bb77fd9806e4f6159d88dfd012acf8984bd41b4b4c9cbd7aa358",
* "proof":[
* {
* "left":"e1566f09e0deea437826514431be6e4bdb4fe10aa54d75aecf0b4cdc1bc4320c"
* },
* {
* "right":"2dba5dbc339e7316aea2683faf839c1b7b1ee2313db792112588118df066aa35"
* }
* ],
* "anchors":[
* {
* "type":"BTCOpReturn",
* "sourceId":"780b4cdc16f09e0deebce156a434320c2654fe10aa54d75ae14431be6e4bdbcf"
* }
* ]
* }
*/
}
public string ToHexStringEncoder() => HexEncoder.Encode(_buffer);
public int EncodeToBuffer() => HexEncoder.Encode(bytes, charBuffer);
public string Encode() => HexEncoder.Encode(bytes);
public void TwoItems()
{
var mt = new MerkleTree();
mt.AddLeaf(sha256("test1"));
mt.AddLeaf(sha256("test2"));
Assert.Equal <string>("587b1fe3afa386ce7cf9e99cf6f3b7f6a78a3c1ca6a549bbd467c992e482dc56", HexEncoder.Encode(mt.MerkleRootHash));
}
