public void UInt16List32()
{
// Arrange
var value = new ushort[] { 0xaabb, 0xc0ad, 0xeeff };
var tree = new SszTree(new SszBasicList(value, limit: 32));
// Act
var bytes = tree.Serialize();
var hashTreeRoot = tree.HashTreeRoot();
// Assert
var byteString = BitConverter.ToString(bytes.ToArray()).Replace("-", "").ToLowerInvariant();
var expectedByteString = "bbaaadc0ffee";
byteString.ShouldBe(expectedByteString);
var contentsRoot = Hash(
Chunk(new byte[] { 0xbb, 0xaa, 0xad, 0xc0, 0xff, 0xee }),
Chunk(new byte[0])
);
var expectedHashTreeRoot =
Hash(
contentsRoot,
Chunk(new byte[] { 0x03, 0x00, 0x00, 0x00 })
);
var expectedHashTreeRootString = BitConverter.ToString(expectedHashTreeRoot).Replace("-", "").ToLowerInvariant();
var hashTreeRootString = BitConverter.ToString(hashTreeRoot.ToArray()).Replace("-", "").ToLowerInvariant();
hashTreeRootString.ShouldBe(expectedHashTreeRootString);
}
public void ByteArray16Serialize()
{
// Arrange
var value = new byte[16];
value[0] = 1;
value[15] = 0xff;
var tree = new SszTree(new SszBasicVector(value));
// Act
var bytes = tree.Serialize();
var hashTreeRoot = tree.HashTreeRoot();
// Assert
var byteString = BitConverter.ToString(bytes.ToArray()).Replace("-", "").ToLowerInvariant();
var expectedByteString = "010000000000000000000000000000ff";
byteString.ShouldBe(expectedByteString);
var hashTreeRootString = BitConverter.ToString(hashTreeRoot.ToArray()).Replace("-", "").ToLowerInvariant();
var expectedHashTreeRootString = "010000000000000000000000000000ff"
+ "00000000000000000000000000000000";
hashTreeRootString.ShouldBe(expectedHashTreeRootString);
}
public void FixedContainer()
{
// Arrange
var container = new FixedTestContainer()
{
A = (byte)0xab,
B = (ulong)0xaabbccdd00112233,
C = (uint)0x12345678
};
var tree = new SszTree(container.ToSszContainer());
// Act
var bytes = tree.Serialize();
var hashTreeRoot = tree.HashTreeRoot();
// Assert
var expectedByteString = "ab33221100ddccbbaa78563412";
var byteString = BitConverter.ToString(bytes.ToArray()).Replace("-", "").ToLowerInvariant();
byteString.ShouldBe(expectedByteString);
var expectedHashTreeRoot = Hash(
Hash(Chunk(new byte[] { 0xab }), Chunk(new byte[] { 0x33, 0x22, 0x11, 0x00, 0xdd, 0xcc, 0xbb, 0xaa })),
Hash(Chunk(new byte[] { 0x78, 0x56, 0x34, 0x12 }), Chunk(new byte[] { }))
);
var expectedHashTreeRootString = BitConverter.ToString(expectedHashTreeRoot).Replace("-", "").ToLowerInvariant();
var hashTreeRootString = BitConverter.ToString(hashTreeRoot.ToArray()).Replace("-", "").ToLowerInvariant();
hashTreeRootString.ShouldBe(expectedHashTreeRootString);
}
public void UInt32List128()
{
// Arrange
var value = new uint[] { 0xaabb, 0xc0ad, 0xeeff };
var tree = new SszTree(new SszBasicList(value, limit: 128));
// Act
var bytes = tree.Serialize();
var hashTreeRoot = tree.HashTreeRoot();
// Assert
var byteString = BitConverter.ToString(bytes.ToArray()).Replace("-", "").ToLowerInvariant();
var expectedByteString = "bbaa0000adc00000ffee0000";
byteString.ShouldBe(expectedByteString);
var expectedHashTreeRoot =
Hash(
Merge(
Chunk(new byte[] { 0xbb, 0xaa, 0x00, 0x00,
0xad, 0xc0, 0x00, 0x00,
0xff, 0xee, 0x00, 0x00 }),
ZeroHashes(0, 4)
),
Chunk(new byte[] { 0x03, 0x00, 0x00, 0x00 })
);
var expectedHashTreeRootString = BitConverter.ToString(expectedHashTreeRoot).Replace("-", "").ToLowerInvariant();
var hashTreeRootString = BitConverter.ToString(hashTreeRoot.ToArray()).Replace("-", "").ToLowerInvariant();
// TODO: Need to mix in the length
hashTreeRootString.ShouldBe(expectedHashTreeRootString);
}
public void ByteArray64Serialize()
{
// Arrange
var value = new byte[64];
value[0] = 1;
value[32] = 2;
var tree = new SszTree(new SszBasicVector(value));
// Act
var bytes = tree.Serialize();
var hashTreeRoot = tree.HashTreeRoot();
// Assert
var byteString = BitConverter.ToString(bytes.ToArray()).Replace("-", "").ToLowerInvariant();
var expectedByteString = "0100000000000000000000000000000000000000000000000000000000000000"
+ "0200000000000000000000000000000000000000000000000000000000000000";
byteString.ShouldBe(expectedByteString);
var hashTreeRootString = BitConverter.ToString(hashTreeRoot.ToArray()).Replace("-", "").ToLowerInvariant();
Console.WriteLine(hashTreeRootString);
//var c1 = new byte[32];
//c1[0] = 1;
//var c2 = new byte[32];
//c2[0] = 2;
//var expectedHashTreeRoot = Hash(c1, c2);
var expectedHashTreeRootString = "ff55c97976a840b4ced964ed49e3794594ba3f675238b5fd25d282b60f70a194";
hashTreeRootString.ShouldBe(expectedHashTreeRootString);
}
public void SmallContainer()
{
// Arrange
var container = new SmallTestContainer()
{
A = (ushort)0x4567, B = (ushort)0x0123
};
var tree = new SszTree(container.ToSszContainer());
// Act
var bytes = tree.Serialize();
var hashTreeRoot = tree.HashTreeRoot();
// Assert
var expectedByteString = "67452301";
var byteString = BitConverter.ToString(bytes.ToArray()).Replace("-", "").ToLowerInvariant();
byteString.ShouldBe(expectedByteString);
var expectedHashTreeRoot = Hash(Chunk(new byte[] { 0x67, 0x45 }), Chunk(new byte[] { 0x23, 0x01 }));
var expectedHashTreeRootString = BitConverter.ToString(expectedHashTreeRoot).Replace("-", "").ToLowerInvariant();
var hashTreeRootString = BitConverter.ToString(hashTreeRoot.ToArray()).Replace("-", "").ToLowerInvariant();
hashTreeRootString.ShouldBe(expectedHashTreeRootString);
}
public void ByteArray192Serialize()
{
// Arrange
var value = new byte[192];
value[0] = 1;
value[32] = 2;
value[64] = 3;
value[95] = 0xff;
value[96] = 4;
value[128] = 5;
value[160] = 6;
var tree = new SszTree(new SszBasicVector(value));
// Act
var bytes = tree.Serialize();
var hashTreeRoot = tree.HashTreeRoot();
// Assert
var expectedByteString = "0100000000000000000000000000000000000000000000000000000000000000"
+ "0200000000000000000000000000000000000000000000000000000000000000"
+ "03000000000000000000000000000000000000000000000000000000000000ff"
+ "0400000000000000000000000000000000000000000000000000000000000000"
+ "0500000000000000000000000000000000000000000000000000000000000000"
+ "0600000000000000000000000000000000000000000000000000000000000000";
var byteString = BitConverter.ToString(bytes.ToArray()).Replace("-", "").ToLowerInvariant();
byteString.ShouldBe(expectedByteString);
var c1 = new byte[32];
c1[0] = 1;
var c2 = new byte[32];
c2[0] = 2;
var c3 = new byte[32];
c3[0] = 3;
c3[31] = 0xff;
var c4 = new byte[32];
c4[0] = 4;
var c5 = new byte[32];
c5[0] = 5;
var c6 = new byte[32];
c6[0] = 6;
var cZ = new byte[32];
var expectedHashTreeRoot = Hash(
Hash(Hash(c1, c2), Hash(c3, c4)),
Hash(Hash(c5, c6), Hash(cZ, cZ)));
hashTreeRoot.ToArray().ShouldBe(expectedHashTreeRoot);
}
public void SmallTestContainerList16()
{
// Arrange
var value = new SingleFieldTestContainer[] {
new SingleFieldTestContainer {
A = 0x01
},
new SingleFieldTestContainer {
A = 0x02
},
new SingleFieldTestContainer {
A = 0x03
},
};
var tree = new SszTree(value.ToSszList(16));
// Act
var bytes = tree.Serialize();
var hashTreeRoot = tree.HashTreeRoot();
// Assert
var byteString = BitConverter.ToString(bytes.ToArray()).Replace("-", "").ToLowerInvariant();
var expectedByteString = "010203";
byteString.ShouldBe(expectedByteString);
var contentsRoot = Merge(
Hash(
Hash(
Chunk(new byte[] { 0x01 }),
Chunk(new byte[] { 0x02 })
),
Hash(
Chunk(new byte[] { 0x03 }),
Chunk(new byte[] { 0x00 })
)
),
ZeroHashes(2, 4));
var expectedHashTreeRoot =
Hash(
contentsRoot,
Chunk(new byte[] { 0x03, 0x00, 0x00, 0x00 }) // mix in length
);
var expectedHashTreeRootString = BitConverter.ToString(expectedHashTreeRoot).Replace("-", "").ToLowerInvariant();
var hashTreeRootString = BitConverter.ToString(hashTreeRoot.ToArray()).Replace("-", "").ToLowerInvariant();
hashTreeRootString.ShouldBe(expectedHashTreeRootString);
}
public void BitvectorSerialize(bool[] value, string expectedByteString, byte[] expectedHashTreeRoot)
{
// Arrange
var tree = new SszTree(new SszBitvector(value));
// Act
var bytes = tree.Serialize();
var hashTreeRoot = tree.HashTreeRoot();
// Assert
var byteString = BitConverter.ToString(bytes.ToArray()).Replace("-", "").ToLowerInvariant();
byteString.ShouldBe(expectedByteString);
hashTreeRoot.ToArray().ShouldBe(expectedHashTreeRoot);
}
public void ByteUInt32(uint value, string expectedByteString, string expectedHashTreeRoot)
{
// Arrange
var tree = new SszTree(new SszBasicElement(value));
// Act
var bytes = tree.Serialize();
var hashTreeRoot = tree.HashTreeRoot();
// Assert
var byteString = BitConverter.ToString(bytes.ToArray()).Replace("-", "").ToLowerInvariant();
byteString.ShouldBe(expectedByteString);
var hashTreeRootString = BitConverter.ToString(hashTreeRoot.ToArray()).Replace("-", "").ToLowerInvariant();
hashTreeRootString.ShouldBe(expectedHashTreeRoot);
}
public void VarContainer_Some()
{
// Arrange
var container = new VarTestContainer()
{
A = 0xabcd,
B = new ushort[] { 1, 2, 3 },
C = 0xff
};
var tree = new SszTree(container.ToSszContainer());
// Act
var bytes = tree.Serialize();
var hashTreeRoot = tree.HashTreeRoot();
// Assert
var expectedByteString = "cdab07000000ff010002000300";
var byteString = BitConverter.ToString(bytes.ToArray()).Replace("-", "").ToLowerInvariant();
byteString.ShouldBe(expectedByteString);
var expectedHashTreeRoot =
Hash(
Hash(
Chunk(new byte[] { 0xcd, 0xab }),
Hash(
Merge(
Chunk(new byte[] { 0x01, 0x00, 0x02, 0x00, 0x03, 0x00 }),
ZeroHashes(0, 6)
),
Chunk(new byte[] { 0x03, 0x00, 0x00, 0x00 }) // Length mix in
)
),
Hash(Chunk(new byte[] { 0xff }), Chunk(new byte[] { }))
);
var expectedHashTreeRootString = BitConverter.ToString(expectedHashTreeRoot).Replace("-", "").ToLowerInvariant();
var hashTreeRootString = BitConverter.ToString(hashTreeRoot.ToArray()).Replace("-", "").ToLowerInvariant();
hashTreeRootString.ShouldBe(expectedHashTreeRootString);
}
public void ByteArray96Serialize()
{
// Arrange
var value = new byte[96];
value[0] = 1;
value[32] = 2;
value[64] = 3;
value[95] = 0xff;
var tree = new SszTree(new SszBasicVector(value));
// Act
var bytes = tree.Serialize();
var hashTreeRoot = tree.HashTreeRoot();
// Assert
var expectedByteString = "0100000000000000000000000000000000000000000000000000000000000000"
+ "0200000000000000000000000000000000000000000000000000000000000000"
+ "03000000000000000000000000000000000000000000000000000000000000ff";
var byteString = BitConverter.ToString(bytes.ToArray()).Replace("-", "").ToLowerInvariant();
byteString.ShouldBe(expectedByteString);
var c1 = new byte[32];
c1[0] = 1;
var c2 = new byte[32];
c2[0] = 2;
var c3 = new byte[32];
c3[0] = 3;
c3[31] = 0xff;
var cZ = new byte[32];
var h1 = Hash(c1, c2);
var expectedHashTreeRoot = Hash(h1, Hash(c3, cZ));
hashTreeRoot.ToArray().ShouldBe(expectedHashTreeRoot);
}
public void SingleFieldContainer()
{
// Arrange
var container = new SingleFieldTestContainer()
{
A = (byte)0xab
};
var tree = new SszTree(container.ToSszContainer());
// Act
var bytes = tree.Serialize();
var hashTreeRoot = tree.HashTreeRoot();
// Assert
var expectedByteString = "ab";
var byteString = BitConverter.ToString(bytes.ToArray()).Replace("-", "").ToLowerInvariant();
byteString.ShouldBe(expectedByteString);
var expectedHashTreeRootString = "ab00000000000000000000000000000000000000000000000000000000000000";
var hashTreeRootString = BitConverter.ToString(hashTreeRoot.ToArray()).Replace("-", "").ToLowerInvariant();
hashTreeRootString.ShouldBe(expectedHashTreeRootString);
}
public void UInt16Vector()
{
// Arrange
var value = new ushort[] { 0x4567, 0x0123 };
var tree = new SszTree(new SszBasicVector(value));
// Act
var bytes = tree.Serialize();
var hashTreeRoot = tree.HashTreeRoot();
// Assert
var byteString = BitConverter.ToString(bytes.ToArray()).Replace("-", "").ToLowerInvariant();
var expectedByteString = "67452301";
byteString.ShouldBe(expectedByteString);
var expectedHashTreeRoot = Chunk(new byte[] { 0x67, 0x45, 0x23, 0x01 }).ToArray();
var expectedHashTreeRootString = BitConverter.ToString(expectedHashTreeRoot).Replace("-", "").ToLowerInvariant();
var hashTreeRootString = BitConverter.ToString(hashTreeRoot.ToArray()).Replace("-", "").ToLowerInvariant();
hashTreeRootString.ShouldBe(expectedHashTreeRootString);
}
public static Root HashTreeRoot(this SignedBeaconBlockHeader item)
{
var tree = new SszTree(new SszContainer(GetValues(item)));
return(new Root(tree.HashTreeRoot()));
}
public static Root HashTreeRoot(this BeaconBlockBody item, ulong maximumProposerSlashings, ulong maximumAttesterSlashings, ulong maximumAttestations, ulong maximumDeposits, ulong maximumVoluntaryExits, ulong maximumValidatorsPerCommittee)
{
var tree = new SszTree(item.ToSszContainer(maximumProposerSlashings, maximumAttesterSlashings, maximumAttestations, maximumDeposits, maximumVoluntaryExits, maximumValidatorsPerCommittee));
return(new Root(tree.HashTreeRoot()));
}
public static Hash32 HashTreeRoot(this BeaconBlockBody item, MiscellaneousParameters miscellaneousParameters, MaxOperationsPerBlock maxOperationsPerBlock)
{
var tree = new SszTree(item.ToSszContainer(miscellaneousParameters, maxOperationsPerBlock));
return(new Hash32(tree.HashTreeRoot()));
}
public static Hash32 HashTreeRoot(this Crosslink item)
{
var tree = new SszTree(item.ToSszContainer());
return new Hash32(tree.HashTreeRoot());
}
public static Hash32 HashTreeRoot(this Epoch item)
{
var tree = new SszTree(item.ToSszBasicElement());
return(new Hash32(tree.HashTreeRoot()));
}
public static Hash32 HashTreeRoot(this HistoricalBatch item)
{
var tree = new SszTree(item.ToSszContainer());
return(new Hash32(tree.HashTreeRoot()));
}
public static Hash32 HashTreeRoot(this IEnumerable <DepositData> list, ulong limit)
{
var tree = new SszTree(list.ToSszList(limit));
return(new Hash32(tree.HashTreeRoot()));
}
public static Root HashTreeRoot(this DepositData item)
{
var tree = new SszTree(item.ToSszContainer());
return(new Root(tree.HashTreeRoot()));
}
public static Hash32 HashTreeRoot(this BeaconState item, ulong historicalRootsLimit, ulong slotsPerEth1VotingPeriod, ulong validatorRegistryLimit, ulong maximumAttestationsPerEpoch, ulong maximumValidatorsPerCommittee)
{
var tree = new SszTree(item.ToSszContainer(historicalRootsLimit, slotsPerEth1VotingPeriod, validatorRegistryLimit, maximumAttestationsPerEpoch, maximumValidatorsPerCommittee));
return(new Hash32(tree.HashTreeRoot()));
}
public static Hash32 SigningRoot(this BeaconBlock item, ulong maximumProposerSlashings, ulong maximumAttesterSlashings, ulong maximumAttestations, ulong maximumDeposits, ulong maximumVoluntaryExits, ulong maximumValidatorsPerCommittee)
{
var tree = new SszTree(new SszContainer(GetValues(item, maximumProposerSlashings, maximumAttesterSlashings, maximumAttestations, maximumDeposits, maximumVoluntaryExits, maximumValidatorsPerCommittee, true)));
return(new Hash32(tree.HashTreeRoot()));
}
public static Hash32 SigningRoot(this VoluntaryExit item)
{
var tree = new SszTree(new SszContainer(GetValues(item, true)));
return(new Hash32(tree.HashTreeRoot()));
}
public static Hash32 SigningRoot(this BeaconBlockHeader item)
{
var tree = new SszTree(new SszContainer(GetValues(item, true)));
return(new Hash32(tree.HashTreeRoot()));
}
public static Hash32 HashTreeRoot(this BeaconState item, MiscellaneousParameters miscellaneousParameters, TimeParameters timeParameters, StateListLengths stateListLengths, MaxOperationsPerBlock maxOperationsPerBlock)
{
var tree = new SszTree(item.ToSszContainer(miscellaneousParameters, timeParameters, stateListLengths, maxOperationsPerBlock));
return(new Hash32(tree.HashTreeRoot()));
}
public static Root HashTreeRoot(this SignedVoluntaryExit item)
{
var tree = new SszTree(new SszContainer(GetValues(item)));
return(new Root(tree.HashTreeRoot()));
}
public static Hash32 HashTreeRoot(this AttestationData item)
{
var tree = new SszTree(item.ToSszContainer());
return(new Hash32(tree.HashTreeRoot()));
}
public static Hash32 SigningRoot(this BeaconBlock item, MiscellaneousParameters miscellaneousParameters, MaxOperationsPerBlock maxOperationsPerBlock)
{
var tree = new SszTree(new SszContainer(GetValues(item, miscellaneousParameters, maxOperationsPerBlock, true)));
return(new Hash32(tree.HashTreeRoot()));
}
