protected override Memory <byte> ParseSynchronization(ushort version, Memory <byte> spanBody, out SynchronizationBlockBase synchronizationBlockBase)
{
if (version == 1)
{
ushort round = BinaryPrimitives.ReadUInt16LittleEndian(spanBody.Span);
byte numberOfSigners = spanBody.Span[2];
byte[][] signers = new byte[numberOfSigners][];
byte[][] signatures = new byte[numberOfSigners][];
for (int i = 0; i < numberOfSigners; i++)
{
signers[i] = spanBody.Slice(3 + (Globals.NODE_PUBLIC_KEY_SIZE + Globals.SIGNATURE_SIZE) * i, Globals.NODE_PUBLIC_KEY_SIZE).ToArray();
signatures[i] = spanBody.Slice(3 + (Globals.NODE_PUBLIC_KEY_SIZE + Globals.SIGNATURE_SIZE) * i + Globals.NODE_PUBLIC_KEY_SIZE, Globals.SIGNATURE_SIZE).ToArray();
}
SynchronizationBlockBase synchronizationConfirmedBlock = new SynchronizationConfirmedBlock()
{
Round = round,
PublicKeys = signers,
Signatures = signatures
};
synchronizationBlockBase = synchronizationConfirmedBlock;
return(spanBody.Slice(3 + (Globals.NODE_PUBLIC_KEY_SIZE + Globals.SIGNATURE_SIZE) * numberOfSigners));
}
throw new BlockVersionNotSupportedException(version, BlockType);
}
public override void Start()
{
ulong index = _synchronizationContext.LastBlockDescriptor?.BlockHeight ?? 0;
byte[] prevHash = _synchronizationContext.LastBlockDescriptor?.Hash;
do
{
unchecked
{
SynchronizationConfirmedBlock synchronizationConfirmedBlock = new SynchronizationConfirmedBlock()
{
SyncBlockHeight = index,
BlockHeight = (ulong)++index,
Signer = _key,
ReportedTime = DateTime.Now,
Round = 1,
HashPrev = prevHash ?? new byte[Globals.DEFAULT_HASH_SIZE],
PowHash = prevHash ?? new byte[Globals.DEFAULT_HASH_SIZE]
};
ISerializer signatureSupportSerializer = _serializersFactory.Create(synchronizationConfirmedBlock);
signatureSupportSerializer.SerializeFully();
prevHash = _hashCalculation.CalculateHash(synchronizationConfirmedBlock.RawData);
_communicationService.PostMessage(_keyTarget, signatureSupportSerializer);
_loadCountersService.SentMessages.Increment();
}
} while (!_cancellationToken.IsCancellationRequested);
}
public void ProcessBlock(PacketBase blockBase)
{
SynchronizationConfirmedBlock synchronizationBlock = blockBase as SynchronizationConfirmedBlock;
if (synchronizationBlock != null)
{
_synchronizationBlocks.Add(synchronizationBlock);
}
}
public override BlockBase Translate(SynchronizationBlock synchronizationBlock)
{
if (synchronizationBlock == null)
{
return(null);
}
SynchronizationConfirmedBlock synchronizationConfirmedBlock = null;
IBlockParser blockParser = _blockParsersRepository.GetInstance(BlockTypes.Synchronization_ConfirmedBlock);
synchronizationConfirmedBlock = blockParser.Parse(synchronizationBlock.BlockContent) as SynchronizationConfirmedBlock;
return(synchronizationConfirmedBlock);
}
private void BroadcastConfirmation(ulong height, ushort round, byte[] prevHash, ulong syncBlockHeight, byte[] powValue)
{
//List<SynchronizationBlockRetransmissionV1> retransmittedSyncBlocks = _synchronizationBlocksByHeight[height].Where(r => _nodeContext.SyncGroupParticipants.Any(p => p.Key == r.Key)).Select(kv => kv.Value.First()).OrderBy(s => s.ConfirmationPublicKey.ToHexString()).ToList();
SynchronizationConfirmedBlock synchronizationConfirmedBlock = new SynchronizationConfirmedBlock
{
BlockHeight = height,
HashPrev = prevHash, //TODO: does not seems too secure
SyncBlockHeight = syncBlockHeight, //TODO: does not seems too secure
PowHash = powValue, //TODO: does not seems too secure
Round = round,
PublicKeys = new byte[0][], // retransmittedSyncBlocks.Select(b => b.ConfirmationPublicKey).ToArray(),
Signatures = new byte[0][] //retransmittedSyncBlocks.Select(b => b.ConfirmationSignature).ToArray()
};
ISerializer confirmationBlockSerializer = _signatureSupportSerializersFactory.Create(synchronizationConfirmedBlock);
_communicationService.PostMessage(_neighborhoodState.GetAllNeighbors(), confirmationBlockSerializer);
}
public override void Start()
{
ulong index = _synchronizationContext.LastBlockDescriptor?.BlockHeight ?? 0;
string cmd = null;
byte[] prevHash = _synchronizationContext.LastBlockDescriptor?.Hash;
byte[] prevPowHash = _proofOfWorkCalculation.CalculateHash(prevHash ?? new byte[Globals.DEFAULT_HASH_SIZE]);
do
{
unchecked
{
SynchronizationConfirmedBlock synchronizationConfirmedBlock = new SynchronizationConfirmedBlock()
{
SyncBlockHeight = index,
BlockHeight = ++index,
Signer = _key,
ReportedTime = DateTime.Now,
Round = 1,
HashPrev = prevHash ?? new byte[Globals.DEFAULT_HASH_SIZE],
PowHash = prevPowHash
};
ISerializer signatureSupportSerializer = _signatureSupportSerializersFactory.Create(synchronizationConfirmedBlock);
signatureSupportSerializer.FillBodyAndRowBytes();
prevHash = _hashCalculation.CalculateHash(synchronizationConfirmedBlock.RawData);
prevPowHash = _proofOfWorkCalculation.CalculateHash(prevHash);
_communicationService.PostMessage(_keyTarget, signatureSupportSerializer);
_loadCountersService.SentMessages.Increment();
}
if (_cancellationToken.IsCancellationRequested)
{
break;
}
Console.WriteLine("Block sent. Press <Enter> for next or type 'exit' and press <Enter> for exit...");
cmd = Console.ReadLine();
} while (!_cancellationToken.IsCancellationRequested && cmd != "exit");
}
protected override void InitializeInner()
{
_logger.Info("Starting Synchronization Initializer");
try
{
SynchronizationConfirmedBlock synchronizationConfirmedBlock = (SynchronizationConfirmedBlock)_chainDataService.GetAllLastBlocksByType(BlockTypes.Synchronization_ConfirmedBlock).Single();
if (synchronizationConfirmedBlock != null)
{
_synchronizationContext.UpdateLastSyncBlockDescriptor(new SynchronizationDescriptor(synchronizationConfirmedBlock.BlockHeight, _hashCalculation.CalculateHash(synchronizationConfirmedBlock.RawData), synchronizationConfirmedBlock.ReportedTime, DateTime.Now, synchronizationConfirmedBlock.Round));
}
SynchronizationRegistryCombinedBlock combinedBlock = (SynchronizationRegistryCombinedBlock)_chainDataService.GetAllLastBlocksByType(BlockTypes.Synchronization_RegistryCombinationBlock).Single();
if (combinedBlock != null)
{
_synchronizationContext.LastRegistrationCombinedBlockHeight = combinedBlock.BlockHeight;
}
}
finally
{
_logger.Info("Synchronization Initializer completed");
}
}
public void SynchronizationConfirmedBlockParserTest()
{
byte signersCount = 10;
byte[] body;
ushort round = 1;
ulong syncBlockHeight = 1;
uint nonce = 4;
ushort version = 1;
ulong blockHeight = 9;
byte[][] expectedSignerPKs = new byte[signersCount][];
byte[][] expectedSignerSignatures = new byte[signersCount][];
DateTime expectedDateTime = DateTime.Now;
byte[] powHash = BinaryHelper.GetPowHash(1234);
byte[] prevHash = BinaryHelper.GetDefaultHash(1234);
for (int i = 0; i < signersCount; i++)
{
byte[] privateSignerKey = ConfidentialAssetsHelper.GetRandomSeed();
Ed25519.KeyPairFromSeed(out byte[] publicSignerKey, out byte[] expandedSignerKey, privateSignerKey);
expectedSignerPKs[i] = publicSignerKey;
byte[] roundBytes = BitConverter.GetBytes(round);
byte[] signerSignature = Ed25519.Sign(roundBytes, expandedSignerKey);
expectedSignerSignatures[i] = signerSignature;
}
using (MemoryStream ms = new MemoryStream())
{
using (BinaryWriter bw = new BinaryWriter(ms))
{
bw.Write(expectedDateTime.ToBinary());
bw.Write(round);
bw.Write(signersCount);
for (int i = 0; i < signersCount; i++)
{
bw.Write(expectedSignerPKs[i]);
bw.Write(expectedSignerSignatures[i]);
}
}
body = ms.ToArray();
}
byte[] packet = BinaryHelper.GetSignedPacket(
PacketType.Synchronization,
syncBlockHeight,
nonce, powHash, version,
BlockTypes.Synchronization_ConfirmedBlock, blockHeight, prevHash, body, _privateKey, out byte[] expectedSignature);
string packetExpectedString = packet.ToHexString();
SynchronizationConfirmedBlockParser synchronizationConfirmedBlockParser = new SynchronizationConfirmedBlockParser(_identityKeyProvidersRegistry);
SynchronizationConfirmedBlock block = (SynchronizationConfirmedBlock)synchronizationConfirmedBlockParser.Parse(packet);
string packetActualString = block.RawData.ToHexString();
Assert.Equal(syncBlockHeight, block.SyncBlockHeight);
Assert.Equal(nonce, block.Nonce);
Assert.Equal(powHash, block.PowHash);
Assert.Equal(version, block.Version);
Assert.Equal(blockHeight, block.BlockHeight);
Assert.Equal(prevHash, block.HashPrev);
Assert.Equal(expectedDateTime, block.ReportedTime);
Assert.Equal(round, block.Round);
for (int i = 0; i < signersCount; i++)
{
Assert.Equal(expectedSignerPKs[i], block.PublicKeys[i]);
Assert.Equal(expectedSignerSignatures[i], block.Signatures[i]);
}
Assert.Equal(_publicKey, block.Signer.Value.ToArray());
Assert.Equal(expectedSignature, block.Signature.ToArray());
}
public void SynchronizationConfirmedBlockSerializerTest()
{
ulong syncBlockHeight = 1;
uint nonce = 4;
byte[] powHash = BinaryBuilder.GetPowHash(1234);
ushort version = 1;
ulong blockHeight = 9;
byte[] prevHash = BinaryBuilder.GetDefaultHash(1234);
ushort round = 1;
byte signersCount = 10;
byte[] body = new byte[11 + Globals.NODE_PUBLIC_KEY_SIZE * signersCount + Globals.SIGNATURE_SIZE * signersCount];
byte[][] expectedSignerPKs = new byte[signersCount][];
byte[][] expectedSignerSignatures = new byte[signersCount][];
DateTime expectedDateTime = DateTime.Now;
for (int i = 0; i < signersCount; i++)
{
byte[] privateSignerKey = CryptoHelper.GetRandomSeed();
Ed25519.KeyPairFromSeed(out byte[] publicSignerKey, out byte[] expandedSignerKey, privateSignerKey);
expectedSignerPKs[i] = publicSignerKey;
byte[] roundBytes = BitConverter.GetBytes(round);
byte[] signerSignature = Ed25519.Sign(roundBytes, expandedSignerKey);
expectedSignerSignatures[i] = signerSignature;
}
using (MemoryStream ms = new MemoryStream(body))
{
using (BinaryWriter bw = new BinaryWriter(ms))
{
bw.Write(expectedDateTime.ToBinary());
bw.Write(round);
bw.Write(signersCount);
for (int i = 0; i < signersCount; i++)
{
bw.Write(expectedSignerPKs[i]);
bw.Write(expectedSignerSignatures[i]);
}
}
}
byte[] expectedPacket = BinaryBuilder.GetSignedPacket(
PacketType.Synchronization,
syncBlockHeight,
nonce, powHash, version,
BlockTypes.Synchronization_ConfirmedBlock, blockHeight, prevHash, body, _privateKey, out byte[] expectedSignature);
SynchronizationConfirmedBlock block = new SynchronizationConfirmedBlock()
{
SyncBlockHeight = syncBlockHeight,
BlockHeight = blockHeight,
Nonce = nonce,
PowHash = powHash,
HashPrev = prevHash,
ReportedTime = expectedDateTime,
Round = round,
PublicKeys = new byte[signersCount][],
Signatures = new byte[signersCount][]
};
for (int i = 0; i < signersCount; i++)
{
block.PublicKeys[i] = expectedSignerPKs[i];
block.Signatures[i] = expectedSignerSignatures[i];
}
SynchronizationConfirmedBlockSerializer serializer = new SynchronizationConfirmedBlockSerializer(_cryptoService, _identityKeyProvidersRegistry, _hashCalculationRepository);
serializer.Initialize(block);
byte[] actualPacket = serializer.GetBytes();
Assert.Equal(expectedPacket, actualPacket);
}
