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); }