private void CreateAndDistributeCombinedBlock(RegistryFullBlock transactionsFullBlockMostConfident)
{
lock (_synchronizationContext)
{
SynchronizationRegistryCombinedBlock lastCombinedBlock = (SynchronizationRegistryCombinedBlock)_synchronizationChainDataService.GetAllLastBlocksByType(BlockTypes.Synchronization_RegistryCombinationBlock).Single();
byte[] prevHash = lastCombinedBlock != null?_defaultTransactionHashCalculation.CalculateHash(lastCombinedBlock.RawData) : new byte[Globals.DEFAULT_HASH_SIZE];
byte[] fullBlockHash = _defaultTransactionHashCalculation.CalculateHash(transactionsFullBlockMostConfident?.RawData ?? new byte[Globals.DEFAULT_HASH_SIZE]);
//TODO: For initial POC there will be only one participant at Synchronization Layer, thus combination of FullBlocks won't be implemented fully
SynchronizationRegistryCombinedBlock synchronizationRegistryCombinedBlock = new SynchronizationRegistryCombinedBlock
{
SyncBlockHeight = _synchronizationContext.LastBlockDescriptor?.BlockHeight ?? 0,
PowHash = _powCalculation.CalculateHash(_synchronizationContext.LastBlockDescriptor?.Hash ?? new byte[Globals.DEFAULT_HASH_SIZE]),
BlockHeight = ++_synchronizationContext.LastRegistrationCombinedBlockHeight,
HashPrev = prevHash,
ReportedTime = DateTime.Now,
BlockHashes = new byte[][] { fullBlockHash }
};
ISerializer combinedBlockSerializer = _signatureSupportSerializersFactory.Create(synchronizationRegistryCombinedBlock);
combinedBlockSerializer.FillBodyAndRowBytes();
IEnumerable <IKey> storageLayerKeys = _nodesResolutionService.GetStorageNodeKeys(combinedBlockSerializer);
_communicationService.PostMessage(storageLayerKeys, combinedBlockSerializer);
_synchronizationChainDataService.Add(synchronizationRegistryCombinedBlock);
}
}
public bool SendTransaction(BlockBase block, BlockBase registerBlock)
{
ISerializer transactionSerializer = _signatureSupportSerializersFactory.Create(block);
ISerializer registerSerializer = _signatureSupportSerializersFactory.Create(registerBlock);
_networkSynchronizer.SendData(transactionSerializer, registerSerializer);
return(true);
}
private void SendTransactionsBlocks(Tuple <RegistryFullBlock, RegistryShortBlock> tuple)
{
RegistryFullBlock transactionsFullBlock = tuple.Item1;
RegistryShortBlock transactionsShortBlock = tuple.Item2;
ISerializer fullBlockSerializer = _signatureSupportSerializersFactory.Create(transactionsFullBlock);
ISerializer shortBlockSerializer = _signatureSupportSerializersFactory.Create(transactionsShortBlock);
shortBlockSerializer.FillBodyAndRowBytes();
transactionsFullBlock.ShortBlockHash = _hashCalculation.CalculateHash(transactionsShortBlock.RawData);
_logger.Debug($"Sending FullBlock with {transactionsFullBlock.TransactionHeaders.Count} transactions and ShortBlock with {transactionsShortBlock.TransactionHeaderHashes.Count} hashes at round {transactionsFullBlock.BlockHeight}");
_tcpCommunicationService.PostMessage(_registryGroupState.SyncLayerNode, fullBlockSerializer);
_tcpCommunicationService.PostMessage(_registryGroupState.GetAllNeighbors(), shortBlockSerializer);
}
private void SendTransactionsBlocks(RegistryFullBlock transactionsFullBlock, RegistryShortBlock transactionsShortBlock)
{
ISerializer fullBlockSerializer = _serializersFactory.Create(transactionsFullBlock);
ISerializer shortBlockSerializer = _serializersFactory.Create(transactionsShortBlock);
shortBlockSerializer.SerializeBody();
_nodeContext.SigningService.Sign(transactionsShortBlock);
shortBlockSerializer.SerializeFully();
transactionsFullBlock.ShortBlockHash = _hashCalculation.CalculateHash(transactionsShortBlock.RawData);
fullBlockSerializer.SerializeBody();
_nodeContext.SigningService.Sign(transactionsFullBlock);
_logger.Debug($"Sending FullBlock with {transactionsFullBlock.StateWitnesses.Length + transactionsFullBlock.UtxoWitnesses.Length} transactions and ShortBlock with {transactionsShortBlock.WitnessStateKeys.Length + transactionsShortBlock.WitnessUtxoKeys.Length} keys at round {transactionsFullBlock.BlockHeight}");
_tcpCommunicationService.PostMessage(_registryGroupState.SyncLayerNode, fullBlockSerializer);
_tcpCommunicationService.PostMessage(_registryGroupState.GetAllNeighbors(), shortBlockSerializer);
}
public void DeferredBroadcast(ushort round, Action onBroadcasted)
{
if (_synchronizationContext == null)
{
return;
}
//if (_synchronizationContext.LastBlockDescriptor != null && _synchronizationContext.LastBlockDescriptor.BlockHeight - 1 > _lastLaunchedSyncBlockOrder)
//{
// _syncProducingCancellation?.Cancel();
// _syncProducingCancellation = null;
//}
int delay = 1;
if (_syncProducingCancellation != null)
{
delay = Math.Max((int)(60000 * round - (DateTime.Now - (_synchronizationContext.LastBlockDescriptor?.UpdateTime ?? DateTime.Now)).TotalMilliseconds), 0);
}
_syncProducingCancellation = new CancellationTokenSource();
//if (delay > 0)
{
Task.Delay(delay, _syncProducingCancellation.Token)
.ContinueWith(t =>
{
try
{
SynchronizationDescriptor synchronizationDescriptor = _synchronizationContext.LastBlockDescriptor;
SynchronizationProducingBlock synchronizationBlock = new SynchronizationProducingBlock
{
SyncBlockHeight = synchronizationDescriptor?.BlockHeight ?? 0,
BlockHeight = (synchronizationDescriptor?.BlockHeight ?? 0) + 1,
ReportedTime = synchronizationDescriptor?.MedianTime.AddMinutes(1) ?? DateTime.Now,
Round = round,
HashPrev = synchronizationDescriptor?.Hash ?? new byte[Globals.DEFAULT_HASH_SIZE],
PowHash = _proofOfWorkCalculation.CalculateHash(synchronizationDescriptor?.Hash ?? new byte[Globals.DEFAULT_HASH_SIZE])
};
using (ISerializer serializer = _serializersFactory.Create(synchronizationBlock))
{
serializer.SerializeBody();
_nodeContext.SigningService.Sign(synchronizationBlock);
_communicationService.PostMessage(_synchronizationGroupState.GetAllNeighbors(), serializer);
_lastLaunchedSyncBlockOrder = synchronizationBlock.BlockHeight;
}
}
finally
{
onBroadcasted.Invoke();
}
}, _syncProducingCancellation.Token, TaskContinuationOptions.NotOnCanceled, TaskScheduler.Current);
}
}
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);
}
private void SendConfidence(RegistryConfidenceBlock transactionsRegistryConfidenceBlock)
{
ISerializer confidenceBlockSerializer = _signatureSupportSerializersFactory.Create(transactionsRegistryConfidenceBlock);
_tcpCommunicationService.PostMessage(_registryGroupState.SyncLayerNode, confidenceBlockSerializer);
}
public void GetMostConfidentFullBlockTest()
{
List <RegistryFullBlock> registryFullBlocks = new List <RegistryFullBlock>();
List <RegistryShortBlock> registryShortBlocks = new List <RegistryShortBlock>();
Dictionary <IKey, int> votesPerShortBlockKey = new Dictionary <IKey, int>();
int fullBlockCount = 10;
int votersCount = 100;
ulong syncBlockHeight = 1;
ulong blockHeight = 12;
uint nonce = 0;
byte[] powHash = BinaryHelper.GetPowHash(1234);
IHashCalculation hashCalculationTransactionKey = new MurMurHashCalculation();
IHashCalculation hashCalculationDefault = new Keccak256HashCalculation();
IHashCalculation hashCalculationMurMur = new MurMurHashCalculation();
ISerializersFactory serializersFactory = Substitute.For <ISerializersFactory>();
IHashCalculationsRepository hashCalculationsRepository = Substitute.For <IHashCalculationsRepository>();
IIdentityKeyProvider identityKeyProviderTransactionKey = Substitute.For <IIdentityKeyProvider>();
IIdentityKeyProvidersRegistry identityKeyProvidersRegistry = Substitute.For <IIdentityKeyProvidersRegistry>();
ISigningService signingService = GetRandomCryptoService();
ILoggerService loggerService = Substitute.For <ILoggerService>();
IStatesRepository statesRepository = Substitute.For <IStatesRepository>();
ISynchronizationContext synchronizationContext = new Wist.Core.Synchronization.SynchronizationContext(loggerService);
statesRepository.GetInstance <ISynchronizationContext>().ReturnsForAnyArgs(synchronizationContext);
identityKeyProviderTransactionKey.GetKey(null).ReturnsForAnyArgs(c => new Key16(c.ArgAt <Memory <byte> >(0)));
identityKeyProvidersRegistry.GetInstance("DefaultHash").Returns(new DefaultHashKeyProvider());
identityKeyProvidersRegistry.GetTransactionsIdenityKeyProvider().Returns(identityKeyProviderTransactionKey);
hashCalculationsRepository.Create(HashType.Keccak256).Returns(hashCalculationDefault);
hashCalculationsRepository.Create(HashType.MurMur).Returns(hashCalculationMurMur);
serializersFactory.Create(null).ReturnsForAnyArgs(c =>
{
RegistryShortBlockSerializer registryShortBlockSerializer = new RegistryShortBlockSerializer();
registryShortBlockSerializer.Initialize(c.Arg <SignedPacketBase>());
return(registryShortBlockSerializer);
});
SyncRegistryMemPool syncRegistryMemPool = new SyncRegistryMemPool(loggerService, hashCalculationsRepository);
for (int i = 0; i < fullBlockCount; i++)
{
ISigningService signingService1 = GetRandomCryptoService();
ushort expectedCount = 1000;
SortedList <ushort, RegistryRegisterBlock> transactionHeaders = GetTransactionHeaders(syncBlockHeight, blockHeight, nonce, expectedCount);
WitnessStateKey[] transactionHeaderKeys = GetTransactionHeaderKeys(transactionHeaders);
RegistryShortBlock registryShortBlock = new RegistryShortBlock
{
SyncBlockHeight = syncBlockHeight,
BlockHeight = blockHeight,
Nonce = nonce,
PowHash = powHash,
WitnessStateKeys = transactionHeaderKeys
};
RegistryShortBlockSerializer registryShortBlockSerializer = new RegistryShortBlockSerializer();
registryShortBlockSerializer.Initialize(registryShortBlock);
registryShortBlockSerializer.SerializeBody();
signingService1.Sign(registryShortBlock);
registryShortBlockSerializer.SerializeFully();
RegistryFullBlock registryFullBlock = new RegistryFullBlock
{
SyncBlockHeight = syncBlockHeight,
BlockHeight = blockHeight,
Nonce = nonce,
PowHash = powHash,
StateWitnesses = transactionHeaders.Values.ToArray(),
ShortBlockHash = hashCalculationDefault.CalculateHash(registryShortBlock.RawData)
};
RegistryFullBlockSerializer serializer = new RegistryFullBlockSerializer();
serializer.Initialize(registryFullBlock);
serializer.SerializeBody();
signingService.Sign(registryFullBlock);
serializer.SerializeFully();
registryFullBlocks.Add(registryFullBlock);
registryShortBlocks.Add(registryShortBlock);
}
foreach (RegistryFullBlock fullBlock in registryFullBlocks)
{
syncRegistryMemPool.AddCandidateBlock(fullBlock);
}
IKey expectedMostConfidentKey = votesPerShortBlockKey.OrderByDescending(kv => kv.Value).Select(kv => kv.Key).First();
IEnumerable <RegistryFullBlock> actualFullBlocks = syncRegistryMemPool.GetRegistryBlocks();
}
private void FillRawData(BlockBase blockBase)
{
ISerializer serializer = _signatureSupportSerializersFactory.Create(blockBase);
serializer.FillBodyAndRowBytes();
}
public void GetMostConfidentFullBlockTest()
{
List <RegistryFullBlock> registryFullBlocks = new List <RegistryFullBlock>();
List <RegistryShortBlock> registryShortBlocks = new List <RegistryShortBlock>();
Dictionary <IKey, int> votesPerShortBlockKey = new Dictionary <IKey, int>();
int fullBlockCount = 10;
int votersCount = 100;
ulong syncBlockHeight = 1;
ulong blockHeight = 12;
uint nonce = 0;
byte[] powHash = BinaryBuilder.GetPowHash(1234);
IHashCalculation hashCalculationTransactionKey = new MurMurHashCalculation();
IHashCalculation hashCalculationDefault = new Keccak256HashCalculation();
IHashCalculation hashCalculationMurMur = new MurMurHashCalculation();
ISerializersFactory signatureSupportSerializersFactory = Substitute.For <ISerializersFactory>();
IHashCalculationsRepository hashCalculationsRepository = Substitute.For <IHashCalculationsRepository>();
IIdentityKeyProvider identityKeyProviderTransactionKey = Substitute.For <IIdentityKeyProvider>();
IIdentityKeyProvidersRegistry identityKeyProvidersRegistry = Substitute.For <IIdentityKeyProvidersRegistry>();
ICryptoService cryptoService = GetRandomCryptoService();
ILoggerService loggerService = Substitute.For <ILoggerService>();
IStatesRepository statesRepository = Substitute.For <IStatesRepository>();
ISynchronizationContext synchronizationContext = new Wist.Core.Synchronization.SynchronizationContext(loggerService);
statesRepository.GetInstance <ISynchronizationContext>().ReturnsForAnyArgs(synchronizationContext);
identityKeyProviderTransactionKey.GetKey(null).ReturnsForAnyArgs(c => new Key16(c.ArgAt <Memory <byte> >(0)));
identityKeyProvidersRegistry.GetInstance("DefaultHash").Returns(new DefaultHashKeyProvider());
identityKeyProvidersRegistry.GetTransactionsIdenityKeyProvider().Returns(identityKeyProviderTransactionKey);
hashCalculationsRepository.Create(HashType.Keccak256).Returns(hashCalculationDefault);
hashCalculationsRepository.Create(HashType.MurMur).Returns(hashCalculationMurMur);
signatureSupportSerializersFactory.Create(null).ReturnsForAnyArgs(c =>
{
RegistryShortBlockSerializer registryShortBlockSerializer = new RegistryShortBlockSerializer(cryptoService, identityKeyProvidersRegistry, hashCalculationsRepository);
registryShortBlockSerializer.Initialize(c.Arg <SignedBlockBase>());
return(registryShortBlockSerializer);
});
SyncRegistryMemPool syncRegistryMemPool = new SyncRegistryMemPool(signatureSupportSerializersFactory, hashCalculationsRepository, identityKeyProvidersRegistry, cryptoService, statesRepository, loggerService);
for (int i = 0; i < fullBlockCount; i++)
{
ICryptoService cryptoService1 = GetRandomCryptoService();
ushort expectedCount = 1000;
SortedList <ushort, ITransactionRegistryBlock> transactionHeaders = GetTransactionHeaders(syncBlockHeight, blockHeight, nonce, expectedCount);
SortedList <ushort, IKey> transactionHeaderKeys = GetTransactionHeaderKeys(hashCalculationTransactionKey, transactionHeaders);
RegistryShortBlock registryShortBlock = new RegistryShortBlock
{
SyncBlockHeight = syncBlockHeight,
BlockHeight = blockHeight,
Nonce = nonce,
PowHash = powHash,
TransactionHeaderHashes = transactionHeaderKeys
};
RegistryShortBlockSerializer registryShortBlockSerializer = new RegistryShortBlockSerializer(cryptoService1, identityKeyProvidersRegistry, hashCalculationsRepository);
registryShortBlockSerializer.Initialize(registryShortBlock);
registryShortBlockSerializer.FillBodyAndRowBytes();
RegistryFullBlock registryFullBlock = new RegistryFullBlock
{
SyncBlockHeight = syncBlockHeight,
BlockHeight = blockHeight,
Nonce = nonce,
PowHash = powHash,
TransactionHeaders = transactionHeaders,
ShortBlockHash = hashCalculationDefault.CalculateHash(registryShortBlock.RawData)
};
RegistryFullBlockSerializer serializer = new RegistryFullBlockSerializer(cryptoService1, identityKeyProvidersRegistry, hashCalculationsRepository);
serializer.Initialize(registryFullBlock);
serializer.FillBodyAndRowBytes();
registryFullBlocks.Add(registryFullBlock);
registryShortBlocks.Add(registryShortBlock);
}
foreach (RegistryFullBlock fullBlock in registryFullBlocks)
{
syncRegistryMemPool.AddCandidateBlock(fullBlock);
}
Random random = new Random();
for (int i = 0; i < votersCount; i++)
{
ICryptoService cryptoService2 = GetRandomCryptoService();
foreach (var registryShortBlock in registryShortBlocks)
{
byte[] hashBytes = hashCalculationDefault.CalculateHash(registryShortBlock.RawData);
Random randNum = new Random();
byte[] bitMask = Enumerable.Repeat(0, registryShortBlock.TransactionHeaderHashes.Count).Select(j => (byte)randNum.Next(0, 255)).ToArray();
byte[] expectedProof = Enumerable.Repeat(0, 16).Select(j => (byte)randNum.Next(0, 255)).ToArray();
IKey shortBlockKey = new Key32(hashBytes);
long vote = GetConfidence(bitMask);
if (!votesPerShortBlockKey.ContainsKey(shortBlockKey))
{
votesPerShortBlockKey.Add(shortBlockKey, (ushort)vote);
}
else
{
votesPerShortBlockKey[shortBlockKey] += (ushort)vote;
}
RegistryConfidenceBlock registryConfidenceBlock = new RegistryConfidenceBlock
{
SyncBlockHeight = syncBlockHeight,
BlockHeight = blockHeight,
Nonce = nonce,
PowHash = powHash,
ReferencedBlockHash = hashBytes,
BitMask = bitMask,
ConfidenceProof = expectedProof
};
RegistryConfidenceBlockSerializer registryConfidenceBlockSerializer = new RegistryConfidenceBlockSerializer(cryptoService2, identityKeyProvidersRegistry, hashCalculationsRepository);
registryConfidenceBlockSerializer.Initialize(registryConfidenceBlock);
registryConfidenceBlockSerializer.FillBodyAndRowBytes();
syncRegistryMemPool.AddVotingBlock(registryConfidenceBlock);
}
}
IKey expectedMostConfidentKey = votesPerShortBlockKey.OrderByDescending(kv => kv.Value).Select(kv => kv.Key).First();
RegistryFullBlock actualFullBlock = syncRegistryMemPool.GetMostConfidentFullBlock(blockHeight);
IKey actualMostConfidentKey = new Key32(actualFullBlock.ShortBlockHash);
Assert.Equal(expectedMostConfidentKey, actualMostConfidentKey);
}