public void SerializeHeader(BlockSerializeContext context)
{
context.bw.Write(context.Version); // Version
context.bw.WriteBuffer(PreviousHash); // PreviousHash
context.bw.Write(Timestamp); // Timestamp
context.bw.Write(Difficulty); // Difficulty
context.bw.Write(Nonce); // Nonce
}
public static void Serialize(IBlockDescriptor descriptor, BlockSerializeContext context)
{
context.bw.Write(context.Version); // Version
context.bw.WriteBuffer(descriptor.PreviousHash); // PreviousHash
context.bw.WriteBuffer(descriptor.MerkleRootHash); // MerkleRootHash
context.bw.Write(descriptor.Timestamp); // Timestamp
context.bw.Write(descriptor.Difficulty); // Difficulty
context.bw.Write(descriptor.Nonce); // Nonce
}
public void Serialize(BlockSerializeContext context)
{
context.bw.WriteNullableString(Id);
context.bw.Write((byte)Type);
if (context.bw.WriteBoolean(Data != null))
{
Debug.Assert(Data != null);
SerializeTransactionItems(context, Data.Inputs);
SerializeTransactionItems(context, Data.Outputs);
}
}
public void SerializeObjects(BlockSerializeContext context)
{
var count = Objects?.Count ?? 0;
context.bw.Write(count);
if (Objects != null)
{
foreach (var @object in Objects)
{
@object.Serialize(context);
}
}
}
public void Serialize(BlockSerializeContext context)
{
Type = context.typeProvider.Get(Data?.GetType());
context.bw.WriteNullableLong(Type); // Type
context.bw.Write(Version); // Version
context.bw.Write(Timestamp); // Timestamp
context.bw.WriteBuffer(Hash); // Hash
if (context.bw.WriteBoolean(Data != null) && Type.HasValue)
{
Data?.Serialize(context);
}
}
private byte[] SerializeObjects(Block block)
{
byte[] data;
using (var ms = new MemoryStream())
{
using (var bw = new BinaryWriter(ms, Encoding.UTF8))
{
var context = new BlockSerializeContext(bw, _typeProvider);
block.SerializeObjects(context);
}
data = ms.ToArray();
}
return(data);
}
private static void SerializeTransactionItems(BlockSerializeContext context, ICollection <TransactionItem> items)
{
if (context.bw.WriteBoolean(items != null))
{
Debug.Assert(items != null);
context.bw.Write(items.Count);
foreach (var input in items)
{
context.bw.Write(input.Index);
context.bw.Write(input.TransactionId);
context.bw.Write((byte)input.Type);
context.bw.WriteBuffer(input.Address);
context.bw.Write(input.Amount);
context.bw.WriteBuffer(input.Signature);
}
}
}
public void RoundTripCheck(IHashProvider hashProvider, IBlockObjectTypeProvider typeProvider)
{
// Serialize a first time
var firstMemoryStream = new MemoryStream();
var firstSerializeContext = new BlockSerializeContext(new BinaryWriter(firstMemoryStream), typeProvider);
Serialize(firstSerializeContext);
var originalData = firstMemoryStream.ToArray();
// Then deserialize that data
var br = new BinaryReader(new MemoryStream(originalData));
var deserializeContext = new BlockDeserializeContext(br, typeProvider);
var deserialized = new Block(deserializeContext, hashProvider);
// Then serialize that deserialized data and see if it matches
var secondMemoryStream = new MemoryCompareStream(originalData);
var secondSerializeContext = new BlockSerializeContext(new BinaryWriter(secondMemoryStream), typeProvider);
deserialized.Serialize(secondSerializeContext);
}
private byte[] SerializeObjects(Block block)
{
byte[] data;
using (var ms = new MemoryStream())
{
using (var bw = new BinaryWriter(ms, Encoding.UTF8))
{
// Version:
var context = new BlockSerializeContext(bw, _typeProvider);
if (context.typeProvider.SecretKey != null)
{
// Nonce:
var nonce = StreamEncryption.GenerateNonceChaCha20();
context.bw.WriteBuffer(nonce);
// Data:
using (var ems = new MemoryStream())
{
using (var ebw = new BinaryWriter(ems, Encoding.UTF8))
{
var ec = new BlockSerializeContext(ebw, _typeProvider, context.Version);
block.SerializeObjects(ec);
context.bw.WriteBuffer(StreamEncryption.EncryptChaCha20(ems.ToArray(), nonce, ec.typeProvider.SecretKey));
}
}
}
else
{
// Data:
context.bw.Write(false);
block.SerializeObjects(context);
}
data = ms.ToArray();
}
}
return(data);
}
public void Serialize(BlockSerializeContext context)
{
context.bw.Write(Text);
}
public void RoundTripCheck(IHashProvider hashProvider, IBlockObjectTypeProvider typeProvider)
{
// Serialize a first time
var firstMemoryStream = new MemoryStream();
var firstSerializeContext = new BlockSerializeContext(new BinaryWriter(firstMemoryStream), typeProvider);
byte[] nonce;
if (typeProvider.SecretKey != null)
{
nonce = StreamEncryption.GenerateNonceChaCha20();
firstSerializeContext.bw.WriteBuffer(nonce);
using (var ems = new MemoryStream())
{
using (var ebw = new BinaryWriter(ems))
{
var ec = new BlockSerializeContext(ebw, typeProvider, firstSerializeContext.Version);
Serialize(ec);
firstSerializeContext.bw.WriteBuffer(StreamEncryption.EncryptChaCha20(ems.ToArray(), nonce, ec.typeProvider.SecretKey));
}
}
}
else
{
firstSerializeContext.bw.Write(false);
Serialize(firstSerializeContext);
}
byte[] originalData = firstMemoryStream.ToArray();
// Then deserialize that data
{
var br = new BinaryReader(new MemoryStream(originalData));
var deserializeContext = new BlockDeserializeContext(br, typeProvider);
nonce = deserializeContext.br.ReadBuffer();
Block deserialized;
if (nonce != null)
{
using (var dms = new MemoryStream(StreamEncryption.DecryptChaCha20(deserializeContext.br.ReadBuffer(), nonce, typeProvider.SecretKey)))
{
using (var dbr = new BinaryReader(dms))
{
var dc = new BlockDeserializeContext(dbr, typeProvider);
deserialized = new Block(dc);
}
}
}
else
{
deserialized = new Block(deserializeContext);
}
// Then serialize that deserialized data and see if it matches
{
var secondMemoryStream = new MemoryCompareStream(originalData);
var secondSerializeContext = new BlockSerializeContext(new BinaryWriter(secondMemoryStream), typeProvider);
if (typeProvider.SecretKey != null)
{
secondSerializeContext.bw.WriteBuffer(nonce);
using (var ems = new MemoryStream())
{
using (var ebw = new BinaryWriter(ems))
{
var ec = new BlockSerializeContext(ebw, typeProvider, secondSerializeContext.Version);
deserialized.Serialize(ec);
secondSerializeContext.bw.WriteBuffer(StreamEncryption.EncryptChaCha20(ems.ToArray(), nonce, ec.typeProvider.SecretKey));
}
}
}
else
{
secondSerializeContext.bw.Write(false);
deserialized.Serialize(secondSerializeContext);
}
}
}
}
public void SerializeHeader(BlockSerializeContext context)
{
BlockHeader.Serialize(this, context);
}
public void Serialize(BlockSerializeContext context)
{
SerializeHeader(context);
context.bw.WriteBuffer(Hash);
SerializeObjects(context);
}
public void Serialize(BlockSerializeContext context)
{
SerializeHeader(context);
SerializeObjects(context);
}
public void Serialize(BlockSerializeContext context)
{
Serialize(this, context);
}
