public override void WriteValue(CodedOutputStream stream)
{
var bytes = MultiHash.ToArray();
stream.WriteLength(bytes.Length);
stream.WriteSomeBytes(bytes);
}
public void Encode_V0()
{
var hash = "QmXg9Pp2ytZ14xgmQjYEiHjVjMFXzCVVEcRTWJBmLgR39V";
Cid cid = new MultiHash(hash);
Assert.AreEqual(hash, cid.Encode());
}
public void Compute_Not_Implemented_Hash_Array()
{
MultiHash.HashingAlgorithm.Register("not-implemented", 0x0F, 32);
var hello = Encoding.UTF8.GetBytes("Hello, world.");
ExceptionAssert.Throws <NotImplementedException>(() => MultiHash.ComputeHash(hello, "not-implemented"));
}
public void To_String_Is_Base58_Representation()
{
var hash = "QmaozNR7DZHQK1ZcU9p7QdrshMvXqWK6gpu5rmrkPdT3L4";
var mh = new MultiHash(hash);
Assert.AreEqual(hash, mh.ToString());
}
void Read(CodedInputStream stream)
{
while (!stream.IsAtEnd)
{
var tag = stream.ReadTag();
switch (WireFormat.GetTagFieldNumber(tag))
{
case 1:
using (var ms = new MemoryStream(stream.ReadSomeBytes(stream.ReadLength())))
{
Hash = new MultiHash(ms).ToBase58();
}
break;
case 2:
Name = stream.ReadString();
break;
case 3:
Size = stream.ReadInt64();
break;
default:
throw new InvalidDataException("Unknown field number");
}
}
}
public void Parsing_Unknown_Hash_Number()
{
MultiHash.HashingAlgorithm unknown = null;
EventHandler <UnknownHashingAlgorithmEventArgs> unknownHandler = (s, e) => { unknown = e.Algorithm; };
var ms = new MemoryStream(new byte[] { 0x01, 0x02, 0x0a, 0x0b });
MultiHash.UnknownHashingAlgorithm += unknownHandler;
try
{
var mh = new MultiHash(ms);
Assert.AreEqual("ipfs-1", mh.Algorithm.Name);
Assert.AreEqual("ipfs-1", mh.Algorithm.ToString());
Assert.AreEqual(1, mh.Algorithm.Code);
Assert.AreEqual(2, mh.Algorithm.DigestSize);
Assert.AreEqual(0xa, mh.Digest[0]);
Assert.AreEqual(0xb, mh.Digest[1]);
Assert.IsNotNull(unknown, "unknown handler not called");
Assert.AreEqual("ipfs-1", unknown.Name);
Assert.AreEqual(1, unknown.Code);
Assert.AreEqual(2, unknown.DigestSize);
}
finally
{
MultiHash.UnknownHashingAlgorithm -= unknownHandler;
}
}
public void Compute_Hash_Array()
{
var hello = Encoding.UTF8.GetBytes("Hello, world.");
var mh = MultiHash.ComputeHash(hello);
Assert.AreEqual(MultiHash.DefaultAlgorithmName, mh.Algorithm.Name);
Assert.IsNotNull(mh.Digest);
}
public void HashNames()
{
var mh = new MultiHash("sha1", new byte[20]);
mh = new MultiHash("sha2-256", new byte[32]);
mh = new MultiHash("sha2-512", new byte[64]);
mh = new MultiHash("sha3-512", new byte[64]);
}
public void Base32_Encode()
{
var mh = new MultiHash("QmPZ9gcCEpqKTo6aq61g2nXGUhM4iCL3ewB6LDXZCtioEB");
Assert.AreEqual("sha2-256", mh.Algorithm.Name);
Assert.AreEqual(32, mh.Digest.Length);
Assert.AreEqual("ciqbed3k6ya5i3qqwljochwxdrk5exzqilbckapedujenz5b5hj5r3a", mh.ToBase32());
}
public void Base58_Encode_Decode()
{
var mh = new MultiHash("QmPZ9gcCEpqKTo6aq61g2nXGUhM4iCL3ewB6LDXZCtioEB");
Assert.AreEqual("sha2-256", mh.Algorithm.Name);
Assert.AreEqual(32, mh.Digest.Length);
Assert.AreEqual("QmPZ9gcCEpqKTo6aq61g2nXGUhM4iCL3ewB6LDXZCtioEB", mh.ToBase58());
}
public void Implicit_Conversion_From_String()
{
var hash = "QmaozNR7DZHQK1ZcU9p7QdrshMvXqWK6gpu5rmrkPdT3L4";
MultiHash mh = hash;
Assert.IsNotNull(mh);
Assert.IsInstanceOfType(mh, typeof(MultiHash));
Assert.AreEqual(hash, mh.ToString());
}
public void GetAlgorithmByName()
{
Assert.IsNotNull(MultiHash.GetHashAlgorithm());
Assert.IsNotNull(MultiHash.GetHashAlgorithm("sha2-512"));
var e = ExceptionAssert.Throws <KeyNotFoundException>(() =>
{
var _ = MultiHash.GetHashAlgorithm("unknown");
});
}
void ComputeHash()
{
using (var ms = new MemoryStream())
{
Write(ms);
size = ms.Position;
ms.Position = 0;
id = MultiHash.ComputeHash(ms, hashAlgorithm);
}
}
public void Compute_Hash_Stream()
{
var hello = new MemoryStream(Encoding.UTF8.GetBytes("Hello, world."));
hello.Position = 0;
var mh = MultiHash.ComputeHash(hello);
Assert.AreEqual(MultiHash.DefaultAlgorithmName, mh.Algorithm.Name);
Assert.IsNotNull(mh.Digest);
}
public void MultiHash_is_Cid_V0()
{
var mh = new MultiHash("QmXg9Pp2ytZ14xgmQjYEiHjVjMFXzCVVEcRTWJBmLgR39V");
Cid cid = mh;
Assert.AreEqual(0, cid.Version);
Assert.AreEqual("dag-pb", cid.ContentType);
Assert.AreEqual("base58btc", cid.Encoding);
Assert.AreSame(mh, cid.Hash);
}
public void MultiHash_is_Cid_V1()
{
var hello = Encoding.UTF8.GetBytes("Hello, world.");
var mh = MultiHash.ComputeHash(hello, "sha2-512");
Cid cid = mh;
Assert.AreEqual(1, cid.Version);
Assert.AreEqual("dag-pb", cid.ContentType);
Assert.AreEqual("base32", cid.Encoding);
Assert.AreSame(mh, cid.Hash);
}
public void Encode_Upgrade_to_V1_Hash()
{
var hello = Encoding.UTF8.GetBytes("Hello, world.");
var mh = MultiHash.ComputeHash(hello, "sha2-512");
var cid = new Cid
{
Hash = mh
};
Assert.AreEqual(1, cid.Version);
Assert.AreEqual("zBunRFxZVcKeu8wAbUg92z2JK6UukiL7EnPR1D6TZaQCsPpRe7KzcmioKFyi2oEZd9ffwpbKTib1pucMQrDyRnAdaqwbB", cid.Encode());
}
public void Example()
{
var hello = Encoding.UTF8.GetBytes("Hello world");
var mh = MultiHash.ComputeHash(hello, "sha2-256");
Console.WriteLine($"| hash code | 0x{mh.Algorithm.Code.ToString("x")} |");
Console.WriteLine($"| digest length | 0x{mh.Digest.Length.ToString("x")} |");
Console.WriteLine($"| digest value | {mh.Digest.ToHexString()} |");
Console.WriteLine($"| binary | {mh.ToArray().ToHexString()} |");
Console.WriteLine($"| base 58 | {mh.ToBase58()} |");
Console.WriteLine($"| base 32 | {mh.ToBase32()} |");
}
public void CheckMultiHash()
{
foreach (var v in TestVectors)
{
if (v.Ignore)
{
continue;
}
var bytes = Encoding.UTF8.GetBytes(v.Input);
var mh = MultiHash.ComputeHash(bytes, v.Algorithm);
Assert.AreEqual(v.Output, mh.ToArray().ToHexString(), v.Algorithm);
}
}
public void Murmur3_Decode()
{
var hash = "2304243ddb9e".ToHexBuffer().ToBase58();
var mh = new MultiHash(hash);
Assert.AreEqual("murmur3-32", mh.Algorithm.Name);
Assert.AreEqual("243ddb9e", mh.Digest.ToHexString());
hash = "2210acfe9c5bbf88f075c0c4df0464430ead".ToHexBuffer().ToBase58();
mh = new MultiHash(hash);
Assert.AreEqual("murmur3-128", mh.Algorithm.Name);
Assert.AreEqual("acfe9c5bbf88f075c0c4df0464430ead", mh.Digest.ToHexString());
}
public void Encode_Upgrade_to_V1_Hash()
{
var hello = Encoding.UTF8.GetBytes("Hello, world.");
var mh = MultiHash.ComputeHash(hello, "sha2-512");
var cid = new Cid
{
Hash = mh
};
Assert.AreEqual(1, cid.Version);
Assert.AreEqual("base32", cid.Encoding);
Assert.AreEqual("bafybgqfnbq34ghljwmk7hka7cpem3zybbffnsfzfxinq3qyztsuxcntbxaua23xx42hrgptcchrolkndcucelv3pc4eoarjbwdxagtylboxsm", cid.Encode());
}
public void Binary()
{
var mh = new MultiHash("QmPZ9gcCEpqKTo6aq61g2nXGUhM4iCL3ewB6LDXZCtioEB");
Assert.AreEqual("sha2-256", mh.Algorithm.Name);
Assert.AreEqual(32, mh.Digest.Length);
var binary = mh.ToArray();
var mh1 = new MultiHash(binary);
Assert.AreEqual(mh.Algorithm.Name, mh1.Algorithm.Name);
CollectionAssert.AreEqual(mh.Digest, mh1.Digest);
}
/// <summary>
/// Gets a multiaddress that ends with the peer ID.
/// </summary>
/// <param name="peerId">
/// The peer ID to end the multiaddress with.
/// </param>
/// <returns>
/// Either the <c>this</c> multiadddress when it contains the
/// <paramref name="peerId"/> or a new <see cref="MultiAddress"/>
/// ending the <paramref name="peerId"/>.
/// </returns>
/// <exception cref="Exception">
/// When the mulltiaddress has the wrong peer ID.
/// </exception>
public MultiAddress WithPeerId(MultiHash peerId)
{
if (HasPeerId)
{
var id = PeerId;
if (id != peerId)
{
throw new Exception($"Expected a multiaddress with peer ID of '{peerId}', not '{id}'.");
}
return(this);
}
return(new MultiAddress(this.ToString() + $"/p2p/{peerId}"));
}
public void Matches_Stream()
{
var hello = new MemoryStream(Encoding.UTF8.GetBytes("Hello, world."));
var hello1 = new MemoryStream(Encoding.UTF8.GetBytes("Hello, world"));
hello.Position = 0;
var mh = MultiHash.ComputeHash(hello);
hello.Position = 0;
Assert.IsTrue(mh.Matches(hello));
hello1.Position = 0;
Assert.IsFalse(mh.Matches(hello1));
}
public void JsonSerialization()
{
var a = new MultiHash("QmPZ9gcCEpqKTo6aq61g2nXGUhM4iCL3ewB6LDXZCtioEB");
string json = JsonConvert.SerializeObject(a);
Assert.AreEqual($"\"{a.ToString()}\"", json);
var b = JsonConvert.DeserializeObject <MultiHash>(json);
Assert.AreEqual(a, b);
a = null;
json = JsonConvert.SerializeObject(a);
b = JsonConvert.DeserializeObject <MultiHash>(json);
Assert.IsNull(b);
}
public void Wire_Formats()
{
var hashes = new[]
{
"5drNu81uhrFLRiS4bxWgAkpydaLUPW", // sha1
"QmaozNR7DZHQK1ZcU9p7QdrshMvXqWK6gpu5rmrkPdT3L4", // sha2_256
"8Vtkv2tdQ43bNGdWN9vNx9GVS9wrbXHk4ZW8kmucPmaYJwwedXir52kti9wJhcik4HehyqgLrQ1hBuirviLhxgRBNv", // sha2_512
};
var helloWorld = Encoding.UTF8.GetBytes("hello world");
foreach (var hash in hashes)
{
var mh = new MultiHash(hash);
Assert.IsTrue(mh.Matches(helloWorld), hash);
}
}
public void Encode_V0()
{
var hash = "QmXg9Pp2ytZ14xgmQjYEiHjVjMFXzCVVEcRTWJBmLgR39V";
Cid cid = new MultiHash(hash);
Assert.AreEqual(hash, cid.Encode());
Assert.AreEqual(0, cid.Version);
cid = new Cid
{
ContentType = "dag-pb",
Encoding = "base58btc",
Hash = hash
};
Assert.AreEqual(hash, cid.Encode());
Assert.AreEqual(0, cid.Version);
}
public void Varint_Hash_Code_and_Length()
{
var concise = "1220f8c3bf62a9aa3e6fc1619c250e48abe7519373d3edf41be62eb5dc45199af2ef"
.ToHexBuffer();
var mh = new MultiHash(new MemoryStream(concise, false));
Assert.AreEqual("sha2-256", mh.Algorithm.Name);
Assert.AreEqual(0x12, mh.Algorithm.Code);
Assert.AreEqual(0x20, mh.Algorithm.DigestSize);
var longer = "9200a000f8c3bf62a9aa3e6fc1619c250e48abe7519373d3edf41be62eb5dc45199af2ef"
.ToHexBuffer();
mh = new MultiHash(new MemoryStream(longer, false));
Assert.AreEqual("sha2-256", mh.Algorithm.Name);
Assert.AreEqual(0x12, mh.Algorithm.Code);
Assert.AreEqual(0x20, mh.Algorithm.DigestSize);
}
public void Compute_Hash_All_Algorithms()
{
foreach (var alg in HashingAlgorithm.All)
{
try
{
var mh = MultiHash.ComputeHash(new byte[0], alg.Name);
Assert.IsNotNull(mh, alg.Name);
Assert.AreEqual(alg.Code, mh.Algorithm.Code, alg.Name);
Assert.AreEqual(alg.Name, mh.Algorithm.Name, alg.Name);
Assert.AreEqual(alg.DigestSize, mh.Algorithm.DigestSize, alg.Name);
Assert.AreEqual(alg.DigestSize, mh.Digest.Length, alg.Name);
}
catch (NotImplementedException)
{
// If NYI then can't test it.
}
}
}
public void Value_Equality()
{
var a0 = new MultiHash("QmaozNR7DZHQK1ZcU9p7QdrshMvXqWK6gpu5rmrkPdT3L4");
var a1 = new MultiHash("QmaozNR7DZHQK1ZcU9p7QdrshMvXqWK6gpu5rmrkPdT3L4");
var b = new MultiHash("QmaozNR7DZHQK1ZcU9p7QdrshMvXqWK6gpu5rmrkPdT3L5");
MultiHash c = null;
MultiHash d = null;
Assert.IsTrue(c == d);
Assert.IsFalse(c == b);
Assert.IsFalse(b == c);
Assert.IsFalse(c != d);
Assert.IsTrue(c != b);
Assert.IsTrue(b != c);
#pragma warning disable 1718
Assert.IsTrue(a0 == a0);
Assert.IsTrue(a0 == a1);
Assert.IsFalse(a0 == b);
#pragma warning disable 1718
Assert.IsFalse(a0 != a0);
Assert.IsFalse(a0 != a1);
Assert.IsTrue(a0 != b);
Assert.IsTrue(a0.Equals(a0));
Assert.IsTrue(a0.Equals(a1));
Assert.IsFalse(a0.Equals(b));
Assert.AreEqual(a0, a0);
Assert.AreEqual(a0, a1);
Assert.AreNotEqual(a0, b);
Assert.AreEqual <MultiHash>(a0, a0);
Assert.AreEqual <MultiHash>(a0, a1);
Assert.AreNotEqual <MultiHash>(a0, b);
Assert.AreEqual(a0.GetHashCode(), a0.GetHashCode());
Assert.AreEqual(a0.GetHashCode(), a1.GetHashCode());
Assert.AreNotEqual(a0.GetHashCode(), b.GetHashCode());
}
