/// <inheritdoc/>
public override void SetBlockPerceivedTime(
HashDigest <SHA256> blockHash,
DateTimeOffset perceivedTime
)
{
byte[] key = BlockKey(blockHash);
_blockPerceptionDb.Put(
key,
NetworkOrderBitsConverter.GetBytes(perceivedTime.ToUnixTimeMilliseconds())
);
}
private static byte[] GetMessage(int version, IValue extra)
{
byte[] msg = NetworkOrderBitsConverter.GetBytes(version);
if (!(extra is null))
{
byte[] extraBytes = _codec.Encode(extra);
int versionLength = msg.Length;
Array.Resize(ref msg, versionLength + extraBytes.Length);
extraBytes.CopyTo(msg, versionLength);
}
return(msg);
}
private static void RoundTripInt16(short num, params byte[] bytes)
{
byte[] buffer = NetworkOrderBitsConverter.GetBytes(num);
Assert.Equal(2, buffer.Length);
Assert.Equal(bytes, buffer);
Assert.Equal(num, NetworkOrderBitsConverter.ToInt16(buffer));
NetworkOrderBitsConverter.PutInt16(num, buffer);
Assert.Equal(bytes, buffer);
Assert.Equal(num, NetworkOrderBitsConverter.ToInt16(buffer));
}
private static void RoundTripInt32(int num, params byte[] bytes)
{
byte[] buffer = NetworkOrderBitsConverter.GetBytes(num);
Assert.AreEqual(4, buffer.Length);
CollectionAssert.AreEqual(bytes, buffer);
Assert.AreEqual(num, NetworkOrderBitsConverter.ToInt32(buffer));
NetworkOrderBitsConverter.PutInt32(num, buffer);
CollectionAssert.AreEqual(bytes, buffer);
Assert.AreEqual(num, NetworkOrderBitsConverter.ToInt32(buffer));
}
/// <inheritdoc cref="BaseStore.SetBlockPerceivedTime(BlockHash, DateTimeOffset)"/>
public override void SetBlockPerceivedTime(
BlockHash blockHash,
DateTimeOffset perceivedTime
)
{
try
{
byte[] key = BlockKey(blockHash);
_blockPerceptionDb.Put(
key,
NetworkOrderBitsConverter.GetBytes(perceivedTime.ToUnixTimeMilliseconds())
);
}
catch (Exception e)
{
LogUnexpectedException(nameof(SetBlockPerceivedTime), e);
}
}
public void TestInt64()
{
byte[] buffer = NetworkOrderBitsConverter.GetBytes(1);
Assert.AreEqual(1, buffer[3]);
Assert.AreEqual(0, buffer[0]);
long num = NetworkOrderBitsConverter.ToInt32(buffer);
Assert.AreEqual(1, num);
NetworkOrderBitsConverter.PutInt32(16777216, buffer, 0);
Assert.AreEqual(1, buffer[0]);
Assert.AreEqual(0, buffer[3]);
num = NetworkOrderBitsConverter.ToInt32(buffer);
Assert.AreEqual(16777216, num);
}
public void TestInt32()
{
byte[] buffer = NetworkOrderBitsConverter.GetBytes((long)1);
Assert.AreEqual(buffer[7], 1);
Assert.AreEqual(0, buffer[0]);
long num = NetworkOrderBitsConverter.ToInt64(buffer);
Assert.AreEqual(1, num);
NetworkOrderBitsConverter.PutInt64(72057594037927936, buffer, 0);
Assert.AreEqual(1, buffer[0]);
Assert.AreEqual(0, buffer[7]);
num = NetworkOrderBitsConverter.ToInt64(buffer);
Assert.AreEqual(72057594037927936, num);
}
public void Constructor()
{
// Generate fixture block hashes looks like 0x000...1, 0x000...2, 0x000...3, and so on,
// for the sake of easier debugging.
ImmutableArray <HashDigest <SHA256> > blocks = Enumerable.Range(0, 0x10).Select(i =>
{
byte[] bytes = NetworkOrderBitsConverter.GetBytes(i);
var buffer = new byte[HashDigest <SHA256> .Size];
bytes.CopyTo(buffer, buffer.Length - bytes.Length);
return(new HashDigest <SHA256>(buffer));
}).ToImmutableArray();
var locator = new BlockLocator(
indexBlockHash: idx => blocks[(int)(idx < 0 ? blocks.Length + idx : idx)],
indexByBlockHash: hash => blocks.IndexOf(hash),
sampleAfter: 5
);
foreach (HashDigest <SHA256> hash in locator)
{
_output.WriteLine(hash.ToString());
}
Assert.Equal(
new[]
{
blocks[0xf],
blocks[0xe],
blocks[0xd],
blocks[0xc],
blocks[0xb],
blocks[0xa],
blocks[0x8],
blocks[0x4],
blocks[0x0],
},
locator
);
}
