private static IList <TransactionItem> DeserializeTransactionItems(BlockDeserializeContext context)
{
var list = new List <TransactionItem>();
if (context.br.ReadBoolean())
{
var count = context.br.ReadInt32();
for (var i = 0; i < count; i++)
{
var item = new TransactionItem
{
Index = context.br.ReadInt64(),
TransactionId = context.br.ReadString(),
Type = (TransactionDataType)context.br.ReadByte(),
Address = context.br.ReadBuffer(),
Amount = context.br.ReadInt64(),
Signature = context.br.ReadBuffer()
};
list.Add(item);
}
}
return(list);
}
private void DeserializeObjects(Block block, byte[] data)
{
using (var ms = new MemoryStream(data))
{
using (var br = new BinaryReader(ms))
{
// Version:
var context = new BlockDeserializeContext(br, _typeProvider);
// Nonce:
var nonce = context.br.ReadBuffer();
if (nonce != null)
{
// Data:
using (var dms = new MemoryStream(StreamEncryption.EncryptChaCha20(context.br.ReadBuffer(), nonce, _typeProvider.SecretKey)))
{
using (var dbr = new BinaryReader(dms))
{
var dc = new BlockDeserializeContext(dbr, _typeProvider);
block.DeserializeObjects(dc);
}
}
}
else
{
// Data:
block.DeserializeObjects(context);
}
}
}
}
public void DeserializeHeader(BlockDeserializeContext context)
{
Version = context.br.ReadInt32(); // Version
PreviousHash = context.br.ReadBuffer(); // PreviousHash
Timestamp = context.br.ReadInt64(); // Timestamp
Difficulty = context.br.ReadDouble(); // Difficulty
Nonce = context.br.ReadInt64(); // Nonce
}
public static void Deserialize(IBlockDescriptor descriptor, BlockDeserializeContext context)
{
descriptor.Version = context.br.ReadInt32(); // Version
descriptor.PreviousHash = context.br.ReadBuffer(); // PreviousHash
descriptor.MerkleRootHash = context.br.ReadBuffer(); // MerkleRootHash
descriptor.Timestamp = context.br.ReadUInt32(); // Timestamp
descriptor.Difficulty = context.br.ReadUInt32(); // Difficulty
descriptor.Nonce = context.br.ReadInt64(); // Nonce
}
public void DeserializeObjects(BlockDeserializeContext context)
{
var count = context.br.ReadInt32();
Objects = new List <BlockObject>(count);
for (var i = 0; i < count; i++)
{
Objects.Add(new BlockObject(context));
}
}
public IBlockSerialized Deserialize(Type type, BlockDeserializeContext context)
{
if (!Serializers.TryGetValue(type, out var serializer))
{
return(null);
}
var deserialized = serializer.Invoke(new object[] { context });
return((IBlockSerialized)deserialized);
}
private void DeserializeObjects(Block block, byte[] data)
{
using (var ms = new MemoryStream(data))
{
using (var br = new BinaryReader(ms))
{
var context = new BlockDeserializeContext(br, _typeProvider);
block.DeserializeObjects(context);
block.Hash = block.ToHashBytes(_hashProvider);
}
}
}
public Transaction(BlockDeserializeContext context)
{
Id = context.br.ReadString();
Hash = context.br.ReadBuffer();
Type = (TransactionType)context.br.ReadByte();
if (context.br.ReadBoolean())
{
Data = new TransactionData
{
Inputs = DeserializeTransactionItems(context),
Outputs = DeserializeTransactionItems(context)
};
}
}
public BlockObject(BlockDeserializeContext context)
{
Type = context.br.ReadNullableLong(); // Type
Version = context.br.ReadInt64(); // Version
Timestamp = context.br.ReadInt64(); // Timestamp
Hash = context.br.ReadBuffer(); // Hash
if (context.br.ReadBoolean() && Type.HasValue)
{
var type = context.typeProvider.Get(Type.Value);
if (type != null)
{
Data = context.typeProvider.Deserialize(type, context);
}
}
}
public Transaction(BlockDeserializeContext context)
{
Id = context.br.ReadNullableString();
Type = (TransactionType)context.br.ReadByte();
if (context.br.ReadBoolean())
{
var inputs = DeserializeTransactionItems(context);
var outputs = DeserializeTransactionItems(context);
Data = new TransactionData
{
Inputs = inputs,
Outputs = outputs
};
}
}
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);
}
public void DeserializeHeader(BlockDeserializeContext context)
{
BlockHeader.Deserialize(this, context);
}
public Message(BlockDeserializeContext context)
{
Text = context.br.ReadString();
}
public object Deserialize(BlockDeserializeContext context)
{
return(new BlockObject(context));
}
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);
}
}
}
}
private Block(BlockDeserializeContext context, IHashProvider hashProvider)
{
DeserializeHeader(context);
DeserializeObjects(context);
Hash = this.ToHashBytes(hashProvider);
}
private Block(BlockDeserializeContext context)
{
DeserializeHeader(context);
Hash = context.br.ReadBuffer();
DeserializeObjects(context);
}
