public void Can_merkleize_int() { Span <byte> root = stackalloc byte[32]; Merkle.Ize(root, 34 + byte.MaxValue + ushort.MaxValue); Assert.AreEqual("0x2001010000000000000000000000000000000000000000000000000000000000", root.ToHexString(true)); }
public void Can_merkleize_bitvector() { Span <byte> root = stackalloc byte[32]; Merkle.Ize(root, new byte[] { 123 }); Assert.AreEqual("0x7b00000000000000000000000000000000000000000000000000000000000000", root.ToHexString(true)); }
public void Can_merkleize_byte() { Span <byte> root = stackalloc byte[32]; Merkle.Ize(root, (byte)34); Assert.AreEqual("0x2200000000000000000000000000000000000000000000000000000000000000", root.ToHexString(true)); }
public void Can_merkleize_uint256_vector_longer() { Span <byte> root = stackalloc byte[32]; Merkle.Ize(root, new UInt256[] { 1, 2, 3, 4 }); Assert.AreEqual("0xbfe3c665d2e561f13b30606c580cb703b2041287e212ade110f0bfd8563e21bb", root.ToHexString(true)); }
public void Can_merkleize_uint128_vector_full() { Span <byte> root = stackalloc byte[32]; Merkle.Ize(root, new UInt128[] { 1, 3 }); Assert.AreEqual("0x0100000000000000000000000000000003000000000000000000000000000000", root.ToHexString(true)); }
public void Can_merkleize_uint128_vector() { Span <byte> root = stackalloc byte[32]; Merkle.Ize(root, new UInt128[] { 1, 3, 5 }); Assert.AreEqual("0xf189891181de961f99a35c1aa21c0d909bf30bb8bebb760050f3d06dc56e488a", root.ToHexString(true)); }
public void Can_merkleize_ulong_vector() { Span <byte> root = stackalloc byte[32]; Merkle.Ize(root, new [] { 1UL, 3UL }); Assert.AreEqual("0x0100000000000000030000000000000000000000000000000000000000000000", root.ToHexString(true)); }
public void Can_merkleize_bool_vector() { Span <byte> root = stackalloc byte[32]; Merkle.Ize(root, new [] { true, false }); Assert.AreEqual("0x0100000000000000000000000000000000000000000000000000000000000000", root.ToHexString(true)); }
public void Can_merkleize_uint256() { UInt256 input = UInt256.Zero; input += 34; input += byte.MaxValue; input += ushort.MaxValue; input += uint.MaxValue; input += ulong.MaxValue; Span <byte> root = stackalloc byte[32]; Merkle.Ize(root, input); Assert.AreEqual("0x1e01010001000000010000000000000000000000000000000000000000000000", root.ToHexString(true)); }
private static bool RunGenericSszTests(string category) { bool success = true; string[] valid = Directory.GetDirectories(Path.Combine("generic", category, "valid")); string[] invalid = Directory.GetDirectories(Path.Combine("generic", category, "invalid")); foreach (string validDir in valid) { TestContext.Out.WriteLine(validDir); string[] files = Directory.GetFiles(validDir); (YamlNode valueNode, YamlNodeType valueType) = LoadValue(Path.Combine(validDir, "value.yaml")); (YamlNode merkleRootYaml, _) = LoadValue(Path.Combine(validDir, "meta.yaml")); UInt256.CreateFromLittleEndian(out UInt256 expectedMerkleRoot, Bytes.FromHexString(((YamlScalarNode)merkleRootYaml["root"]).Value)); Span <byte> output = null; Span <byte> ssz = File.ReadAllBytes(Path.Combine(validDir, "serialized.ssz")); if (valueType == YamlNodeType.Sequence) { YamlSequenceNode sequenceNode = (YamlSequenceNode)valueNode; if (validDir.Contains("bool")) { bool[] value = sequenceNode.Children.Cast <YamlScalarNode>().Select(sn => bool.Parse(sn?.Value ?? "false")).ToArray(); bool[] valueFromSsz = Nethermind.Ssz.Ssz.DecodeBools(ssz).ToArray(); output = new byte[value.Length]; Nethermind.Ssz.Ssz.Encode(output, value); byte[] clone = output.ToArray(); Nethermind.Ssz.Ssz.Encode(output, valueFromSsz); Assert.AreEqual(clone.ToHexString(), output.ToHexString(), "ssz"); Merkle.Ize(out UInt256 root, valueFromSsz); Assert.AreEqual(expectedMerkleRoot, root); } else if (validDir.Contains("uint256")) { UInt256[] value = sequenceNode.Children.Cast <YamlScalarNode>().Select(sn => UInt256.Parse(sn.Value)).ToArray(); UInt256[] valueFromSsz = Nethermind.Ssz.Ssz.DecodeUInts256(ssz); output = new byte[value.Length * 32]; Nethermind.Ssz.Ssz.Encode(output, value); byte[] clone = output.ToArray(); Nethermind.Ssz.Ssz.Encode(output, valueFromSsz); Assert.AreEqual(clone.ToHexString(), output.ToHexString(), "ssz"); Merkle.Ize(out UInt256 root, valueFromSsz); Assert.AreEqual(expectedMerkleRoot, root); } else if (validDir.Contains("uint128")) { UInt128[] value = sequenceNode.Children.Cast <YamlScalarNode>().Select(sn => UInt128.Parse(sn.Value)).ToArray(); UInt128[] valueFromSsz = Nethermind.Ssz.Ssz.DecodeUInts128(ssz); output = new byte[value.Length * 16]; Nethermind.Ssz.Ssz.Encode(output, value); byte[] clone = output.ToArray(); Nethermind.Ssz.Ssz.Encode(output, valueFromSsz); Assert.AreEqual(clone.ToHexString(), output.ToHexString(), "ssz"); Merkle.Ize(out UInt256 root, valueFromSsz); Assert.AreEqual(expectedMerkleRoot, root); } else if (validDir.Contains("uint64")) { ulong[] value = sequenceNode.Children.Cast <YamlScalarNode>().Select(sn => ulong.Parse(sn.Value ?? ulong.MinValue.ToString())).ToArray(); ulong[] valueFromSsz = Nethermind.Ssz.Ssz.DecodeULongs(ssz).ToArray(); output = new byte[value.Length * 8]; Nethermind.Ssz.Ssz.Encode(output, value); byte[] clone = output.ToArray(); Nethermind.Ssz.Ssz.Encode(output, valueFromSsz); Assert.AreEqual(clone.ToHexString(), output.ToHexString(), "ssz"); Merkle.Ize(out UInt256 root, valueFromSsz); Assert.AreEqual(expectedMerkleRoot, root); } else if (validDir.Contains("uint32")) { uint[] value = sequenceNode.Children.Cast <YamlScalarNode>().Select(sn => uint.Parse(sn.Value ?? uint.MinValue.ToString())).ToArray(); uint[] valueFromSsz = Nethermind.Ssz.Ssz.DecodeUInts(ssz).ToArray(); output = new byte[value.Length * 4]; Nethermind.Ssz.Ssz.Encode(output, value); byte[] clone = output.ToArray(); Nethermind.Ssz.Ssz.Encode(output, valueFromSsz); Assert.AreEqual(clone.ToHexString(), output.ToHexString(), "ssz"); Merkle.Ize(out UInt256 root, valueFromSsz); Assert.AreEqual(expectedMerkleRoot, root); } else if (validDir.Contains("uint16")) { ushort[] value = sequenceNode.Children.Cast <YamlScalarNode>().Select(sn => ushort.Parse(sn.Value ?? ushort.MinValue.ToString())).ToArray(); ushort[] valueFromSsz = Nethermind.Ssz.Ssz.DecodeUShorts(ssz).ToArray(); output = new byte[value.Length * 2]; Nethermind.Ssz.Ssz.Encode(output, value); byte[] clone = output.ToArray(); Nethermind.Ssz.Ssz.Encode(output, valueFromSsz); Assert.AreEqual(clone.ToHexString(), output.ToHexString(), "ssz"); Merkle.Ize(out UInt256 root, valueFromSsz); Assert.AreEqual(expectedMerkleRoot, root); } else if (validDir.Contains("uint8")) { byte[] value = sequenceNode.Children.Cast <YamlScalarNode>().Select(sn => byte.Parse(sn.Value ?? byte.MinValue.ToString())).ToArray(); byte[] valueFromSsz = Nethermind.Ssz.Ssz.DecodeBytes(ssz).ToArray(); output = new byte[value.Length]; Nethermind.Ssz.Ssz.Encode(output, value); byte[] clone = output.ToArray(); Nethermind.Ssz.Ssz.Encode(output, valueFromSsz); Assert.AreEqual(clone.ToHexString(), output.ToHexString(), "ssz"); Merkle.Ize(out UInt256 root, valueFromSsz); Assert.AreEqual(expectedMerkleRoot, root); } } else if (valueType == YamlNodeType.Scalar) { if (validDir.Contains("bitvec") || validDir.Contains("bitlist")) { uint limit = 0; Match match = Regex.Match(validDir, "bitlist_(\\d+)", RegexOptions.IgnoreCase); if (match.Success) { limit = (uint.Parse(match.Groups[1].Value) + 255) / 256; } byte[] value = Bytes.FromHexString(((YamlScalarNode)valueNode).Value); byte[] valueFromSsz = Nethermind.Ssz.Ssz.DecodeBytes(ssz).ToArray(); output = new byte[value.Length]; Nethermind.Ssz.Ssz.Encode(output, value); byte[] clone = output.ToArray(); Nethermind.Ssz.Ssz.Encode(output, valueFromSsz); Assert.AreEqual(clone.ToHexString(), output.ToHexString(), "ssz"); UInt256 root; if (validDir.Contains("bitvec")) { Merkle.Ize(out root, valueFromSsz); } else { Merkle.IzeBits(out root, valueFromSsz, limit); } Assert.AreEqual(expectedMerkleRoot, root); } else if (validDir.Contains("boolean")) { string yamlValue = ((YamlScalarNode)valueNode)?.Value; bool? value = yamlValue is null ? null : (bool?)bool.Parse(yamlValue); bool? valueFromSsz = Nethermind.Ssz.Ssz.DecodeBool(ssz); Assert.AreEqual(value, valueFromSsz); output = new byte[1]; output[0] = Nethermind.Ssz.Ssz.Encode(value ?? false); Merkle.Ize(out UInt256 root, valueFromSsz ?? false); Assert.AreEqual(expectedMerkleRoot, root); } else if (validDir.Contains("uint_256")) { UInt256 value = UInt256.Parse(((YamlScalarNode)valueNode).Value); UInt256 valueFromSsz = Nethermind.Ssz.Ssz.DecodeUInt256(ssz); Assert.AreEqual(value, valueFromSsz); output = new byte[32]; Nethermind.Ssz.Ssz.Encode(output, value); Merkle.Ize(out UInt256 root, valueFromSsz); Assert.AreEqual(expectedMerkleRoot, root); } else if (validDir.Contains("uint_128")) { UInt128 value = UInt128.Parse(((YamlScalarNode)valueNode).Value); UInt128 valueFromSsz = Nethermind.Ssz.Ssz.DecodeUInt128(ssz); Assert.AreEqual(value, valueFromSsz); output = new byte[16]; Nethermind.Ssz.Ssz.Encode(output, value); Merkle.Ize(out UInt256 root, valueFromSsz); Assert.AreEqual(expectedMerkleRoot, root); } else if (validDir.Contains("uint_64")) { ulong value = ulong.Parse(((YamlScalarNode)valueNode).Value); ulong valueFromSsz = Nethermind.Ssz.Ssz.DecodeULong(ssz); Assert.AreEqual(value, valueFromSsz); output = new byte[8]; Nethermind.Ssz.Ssz.Encode(output, value); Merkle.Ize(out UInt256 root, valueFromSsz); Assert.AreEqual(expectedMerkleRoot, root); } else if (validDir.Contains("uint_32")) { uint value = uint.Parse(((YamlScalarNode)valueNode).Value); uint valueFromSsz = Nethermind.Ssz.Ssz.DecodeUInt(ssz); Assert.AreEqual(value, valueFromSsz); output = new byte[4]; Nethermind.Ssz.Ssz.Encode(output, value); Merkle.Ize(out UInt256 root, valueFromSsz); Assert.AreEqual(expectedMerkleRoot, root); } else if (validDir.Contains("uint_16")) { ushort value = ushort.Parse(((YamlScalarNode)valueNode).Value); ushort valueFromSsz = Nethermind.Ssz.Ssz.DecodeUShort(ssz); Assert.AreEqual(value, valueFromSsz); output = new byte[2]; Nethermind.Ssz.Ssz.Encode(output, value); Merkle.Ize(out UInt256 root, valueFromSsz); Assert.AreEqual(expectedMerkleRoot, root); } else if (validDir.Contains("uint_8")) { byte value = byte.Parse(((YamlScalarNode)valueNode).Value); byte valueFromSsz = Nethermind.Ssz.Ssz.DecodeByte(ssz); Assert.AreEqual(value, valueFromSsz); output = new byte[1]; Nethermind.Ssz.Ssz.Encode(output, value); Merkle.Ize(out UInt256 root, valueFromSsz); Assert.AreEqual(expectedMerkleRoot, root); } } else if (valueType == YamlNodeType.Mapping) { var mappingNode = (YamlMappingNode)valueNode; if (validDir.Contains("BitsStruct")) { BitsStruct testStruct = ParseBitsStruct(mappingNode); BitsStruct testStructFromSsz = DecodeBitsStruct(ssz); output = new byte[13]; Encode(output, testStruct); byte[] clone = output.ToArray(); Encode(output, testStructFromSsz); Assert.AreEqual(clone.ToHexString(), output.ToHexString(), "ssz"); } else if (validDir.Contains("SmallTestStruct")) { SmallTestStruct testStruct = ParseSmallTestStruct(mappingNode); SmallTestStruct testStructFromSsz = DecodeSmallTestStruct(ssz); output = new byte[4]; Encode(output, testStruct); byte[] clone = output.ToArray(); Encode(output, testStructFromSsz); Assert.AreEqual(clone.ToHexString(), output.ToHexString(), "ssz"); } else if (validDir.Contains("SingleFieldTestStruct")) { SingleFieldTestStruct testStruct = new SingleFieldTestStruct(); SingleFieldTestStruct testStructFromSsz = DecodeSingleFieldTestStruct(ssz); testStruct.A = byte.Parse(((YamlScalarNode)mappingNode.Children["A"]).Value); output = new byte[1]; Encode(output, testStruct); byte[] clone = output.ToArray(); Encode(output, testStructFromSsz); Assert.AreEqual(clone.ToHexString(), output.ToHexString(), "ssz"); } else if (validDir.Contains("VarTestStruct")) { VarTestStruct testStruct = ParseVarTestStruct(mappingNode); VarTestStruct testStructFromSsz = DecodeVarTestStruct(ssz); output = new byte[7 + testStruct.B.Length * 2]; Encode(output, testStruct); byte[] clone = output.ToArray(); Encode(output, testStructFromSsz); Assert.AreEqual(clone.ToHexString(), output.ToHexString(), "ssz"); } else if (validDir.Contains("FixedTestStruct")) { FixedTestStruct testStruct = ParseFixedTestStruct(mappingNode); FixedTestStruct testStructFromSsz = DecodeFixTestStruct(ssz); output = new byte[13]; Encode(output, testStruct); byte[] clone = output.ToArray(); Encode(output, testStructFromSsz); Assert.AreEqual(clone.ToHexString(), output.ToHexString(), "ssz"); } else if (validDir.Contains("ComplexTestStruct")) { ComplexTestStruct testStruct = ParseComplexTestStruct(mappingNode); output = new byte[8236]; Encode(ref output, testStruct); } } if (ssz.ToHexString() != output.ToHexString()) { TestContext.Out.WriteLine($" expected {ssz.ToHexString()}"); TestContext.Out.WriteLine($" actual {output.ToHexString()}"); success = false; } } return(success); }