public TransactionsRegistryHandler(IStatesRepository statesRepository, IServerCommunicationServicesRegistry communicationServicesRegistry, IRawPacketProvidersFactory rawPacketProvidersFactory, IRegistryMemPool registryMemPool, IConfigurationService configurationService, IHashCalculationsRepository hashCalculationRepository, ISerializersFactory signatureSupportSerializersFactory, ILoggerService loggerService) { _registrationBlocks = new BlockingCollection <ITransactionRegistryBlock>(); _registryGroupState = statesRepository.GetInstance <IRegistryGroupState>(); _synchronizationContext = statesRepository.GetInstance <ISynchronizationContext>(); _nodeContext = statesRepository.GetInstance <INodeContext>(); _communicationServicesRegistry = communicationServicesRegistry; _rawPacketProvidersFactory = rawPacketProvidersFactory; _registryMemPool = registryMemPool; _configurationService = configurationService; _signatureSupportSerializersFactory = signatureSupportSerializersFactory; _defaulHashCalculation = hashCalculationRepository.Create(Globals.DEFAULT_HASH); _powCalculation = hashCalculationRepository.Create(Globals.POW_TYPE); _logger = loggerService.GetLogger(nameof(TransactionsRegistryHandler)); TransformBlock <RegistryShortBlock, RegistryConfidenceBlock> produceConfidenceBlock = new TransformBlock <RegistryShortBlock, RegistryConfidenceBlock>((Func <RegistryShortBlock, RegistryConfidenceBlock>)GetConfidence); ActionBlock <RegistryConfidenceBlock> sendConfidenceBlock = new ActionBlock <RegistryConfidenceBlock>((Action <RegistryConfidenceBlock>)SendConfidence); produceConfidenceBlock.LinkTo(sendConfidenceBlock); _transactionsRegistryConfidenceFlow = produceConfidenceBlock; ActionBlock <RegistryConfirmationBlock> confirmationProcessingBlock = new ActionBlock <RegistryConfirmationBlock>((Action <RegistryConfirmationBlock>)ProcessConfirmationBlock); _confirmationBlockFlow = confirmationProcessingBlock; }
public TransactionsRegistryService(IStatesRepository statesRepository, IPredicatesRepository predicatesRepository, IRegistryMemPool registryMemPool, IIdentityKeyProvidersRegistry identityKeyProvidersRegistry, ICryptoService cryptoService, IConfigurationService configurationService, IServerCommunicationServicesRegistry serverCommunicationServicesRegistry, IPerformanceCountersRepository performanceCountersRepository, ISerializersFactory signatureSupportSerializersFactory, ITransactionsRegistryHelper transactionsRegistryHelper, IHashCalculationsRepository hashCalculationsRepository, ILoggerService loggerService) { _synchronizationContext = statesRepository.GetInstance <ISynchronizationContext>(); _registryGroupState = statesRepository.GetInstance <IRegistryGroupState>(); _isBlockProducerPredicate = predicatesRepository.GetInstance("IsBlockProducer"); _transactionHashKey = identityKeyProvidersRegistry.GetTransactionsIdenityKeyProvider(); _cryptoService = cryptoService; _configurationService = configurationService; _serverCommunicationServicesRegistry = serverCommunicationServicesRegistry; _signatureSupportSerializersFactory = signatureSupportSerializersFactory; _transactionsRegistryHelper = transactionsRegistryHelper; _powCalculation = hashCalculationsRepository.Create(Globals.POW_TYPE); _hashCalculation = hashCalculationsRepository.Create(Globals.DEFAULT_HASH); _logger = loggerService.GetLogger(nameof(TransactionsRegistryService)); TransformBlock <IRegistryMemPool, SortedList <ushort, ITransactionRegistryBlock> > deduplicateAndOrderTransactionRegisterBlocksBlock = new TransformBlock <IRegistryMemPool, SortedList <ushort, ITransactionRegistryBlock> >((Func <IRegistryMemPool, SortedList <ushort, ITransactionRegistryBlock> >)DeduplicateAndOrderTransactionRegisterBlocks); TransformBlock <SortedList <ushort, ITransactionRegistryBlock>, RegistryFullBlock> produceTransactionsFullBlock = new TransformBlock <SortedList <ushort, ITransactionRegistryBlock>, RegistryFullBlock>((Func <SortedList <ushort, ITransactionRegistryBlock>, RegistryFullBlock>)ProduceTransactionsFullBlock); ActionBlock <Tuple <RegistryFullBlock, RegistryShortBlock> > sendTransactionsBlocks = new ActionBlock <Tuple <RegistryFullBlock, RegistryShortBlock> >((Action <Tuple <RegistryFullBlock, RegistryShortBlock> >)SendTransactionsBlocks); TransformBlock <RegistryFullBlock, Tuple <RegistryFullBlock, RegistryShortBlock> > produceTransactionsShortBlock = new TransformBlock <RegistryFullBlock, Tuple <RegistryFullBlock, RegistryShortBlock> >((Func <RegistryFullBlock, Tuple <RegistryFullBlock, RegistryShortBlock> >)ProduceTransactionsShortBlock); deduplicateAndOrderTransactionRegisterBlocksBlock.LinkTo(produceTransactionsFullBlock); produceTransactionsFullBlock.LinkTo(produceTransactionsShortBlock); produceTransactionsShortBlock.LinkTo(sendTransactionsBlocks); _transactionsRegistryProducingFlow = deduplicateAndOrderTransactionRegisterBlocksBlock; _registryMemPool = registryMemPool; _nodeCountersService = performanceCountersRepository.GetInstance <NodeCountersService>(); }
public SynchronizationTopologyInitializer(IStatesRepository statesRepository, INodesDataService nodesDataService, ILoggerService loggerService) { _synchronizationGroupState = statesRepository.GetInstance <ISynchronizationGroupState>(); _syncRegistryNeighborhoodState = statesRepository.GetInstance <ISyncRegistryNeighborhoodState>(); _nodesDataService = nodesDataService; _logger = loggerService.GetLogger(nameof(SynchronizationTopologyInitializer)); }
public SynchronizationReceivingHandler(IStatesRepository statesRepository, IServerCommunicationServicesRegistry communicationServicesRegistry, IRawPacketProvidersFactory rawPacketProvidersFactory, IChainDataServicesManager chainDataServicesManager, IHashCalculationsRepository hashCalculationsRepository) { _synchronizationContext = statesRepository.GetInstance <ISynchronizationContext>(); _neighborhoodState = statesRepository.GetInstance <INeighborhoodState>(); _synchronizationBlocks = new BlockingCollection <SynchronizationConfirmedBlock>(); _communicationServicesRegistry = communicationServicesRegistry; _rawPacketProvidersFactory = rawPacketProvidersFactory; _chainDataService = chainDataServicesManager.GetChainDataService(PacketType.Synchronization); _hashCalculation = hashCalculationsRepository.Create(Globals.DEFAULT_HASH); }
public SynchronizationProducer(ISerializersFactory signatureSupportSerializersFactory, IStatesRepository statesRepository, IServerCommunicationServicesRegistry communicationServicesRegistry, IConfigurationService configurationService, IHashCalculationsRepository hashCalculationsRepository) { _signatureSupportSerializersFactory = signatureSupportSerializersFactory; _nodeContext = statesRepository.GetInstance <INodeContext>(); _synchronizationContext = statesRepository.GetInstance <ISynchronizationContext>(); _synchronizationGroupState = statesRepository.GetInstance <ISynchronizationGroupState>(); _communicationServicesRegistry = communicationServicesRegistry; _configurationService = configurationService; _proofOfWorkCalculation = hashCalculationsRepository.Create(Globals.POW_TYPE); }
//private read-only IBlocksProcessor _blocksProcessor public NodeMain(IServerCommunicationServicesRepository communicationServicesFactory, IServerCommunicationServicesRegistry communicationServicesRegistry, IConfigurationService configurationService, IModulesRepository modulesRepository, IPacketsHandler packetsHandler, IBlocksHandlersRegistry blocksProcessorFactory, ILoggerService loggerService, ICryptoService cryptoService, IStatesRepository statesRepository) { _log = loggerService.GetLogger(GetType().Name); _communicationServicesFactory = communicationServicesFactory; _communicationServicesRegistry = communicationServicesRegistry; _configurationService = configurationService; _modulesRepository = modulesRepository; _packetsHandler = packetsHandler; _cryptoService = cryptoService; _nodeContext = statesRepository.GetInstance <INodeContext>(); _accountState = statesRepository.GetInstance <IAccountState>(); _cancellationTokenSource = new CancellationTokenSource(); }
public TransactionRegistryMemPool(ILoggerService loggerService, IIdentityKeyProvidersRegistry identityKeyProvidersRegistry, ICryptoService cryptoService, IStatesRepository statesRepository, ITransactionsRegistryHelper transactionsRegistryHelper, IHashCalculationsRepository hashCalculationsRepository) { _oldValue = 0; //_timer = new Timer(1000); //_timer.Elapsed += (s, e) => //{ // if (_synchronizationContext.LastBlockDescriptor != null && _transactionRegisterBlocksOrdered.ContainsKey(_synchronizationContext.LastBlockDescriptor.BlockHeight)) // { // _logger.Info($"MemPoolCount total = {_transactionRegisterBlocksOrdered[_synchronizationContext.LastBlockDescriptor.BlockHeight].Count}; delta = {_transactionRegisterBlocksOrdered[_synchronizationContext.LastBlockDescriptor.BlockHeight].Count - _oldValue}"); // _oldValue = _transactionRegisterBlocksOrdered[_synchronizationContext.LastBlockDescriptor.BlockHeight].Count; // } //}; //_timer.Start(); _transactionHashKey = identityKeyProvidersRegistry.GetTransactionsIdenityKeyProvider(); _logger = loggerService.GetLogger(nameof(TransactionRegistryMemPool)); _transactionsIndicies = new Dictionary <ulong, int>(); _transactionRegisterBlocksOrdered = new Dictionary <ulong, SortedDictionary <int, ITransactionRegistryBlock> >(); _transactionKeyBySourceKeys = new Dictionary <ulong, Dictionary <ITransactionSourceKey, List <IKey> > >(); _transactionsShortBlocks = new Dictionary <ulong, Dictionary <ulong, HashSet <RegistryShortBlock> > >(); _transactionOrderByTransactionKey = new Dictionary <ulong, Dictionary <IKey, int> >(); _transactionSourceKeyByTransactionKey = new Dictionary <ulong, Dictionary <IKey, ITransactionSourceKey> >(); _cryptoService = cryptoService; _transactionsRegistryHelper = transactionsRegistryHelper; _synchronizationContext = statesRepository.GetInstance <ISynchronizationContext>(); _hashCalculation = hashCalculationsRepository.Create(Globals.DEFAULT_HASH); }
public override void Run(IDictionary <string, string> args = null) { base.Run(args); _log.Info("Starting Modules"); ObtainConfiguredModules(); IStatesRepository statesRepository = ServiceLocator.Current.GetInstance <IStatesRepository>(); IClientState clientState = statesRepository.GetInstance <IClientState>(); ICryptoService cryptoService = ServiceLocator.Current.GetInstance <ICryptoService>(); if (args.ContainsKey("secretKey")) { byte[] secretKey = args["secretKey"].HexStringToByteArray(); clientState.InitializeAccountBased(secretKey); cryptoService.Initialize(secretKey); } try { IModulesRepository modulesRepository = ServiceLocator.Current.GetInstance <IModulesRepository>(); foreach (IModule module in modulesRepository.GetBulkInstances()) { module.Start(); } } finally { _log.Info("Modules started"); } }
public SynchronizationBlocksHandler(IStatesRepository statesRepository, ISynchronizationProducer synchronizationProducer, ISerializersFactory serializersFactory, IIdentityKeyProvidersRegistry identityKeyProvidersRegistry, INodesRatingProviderFactory nodesRatingProvidersFactory, IServerCommunicationServicesRegistry communicationServicesRegistry, ISyncRegistryMemPool syncRegistryMemPool) { _synchronizationContext = statesRepository.GetInstance <ISynchronizationContext>(); _synchronizationProducer = synchronizationProducer; _nodeContext = statesRepository.GetInstance <INodeContext>(); _neighborhoodState = statesRepository.GetInstance <INeighborhoodState>(); _serializersFactory = serializersFactory; _communicationServicesRegistry = communicationServicesRegistry; _syncRegistryMemPool = syncRegistryMemPool; _identityKeyProvider = identityKeyProvidersRegistry.GetInstance(); _synchronizationBlocks = new BlockingCollection <SynchronizationBlockBase>(); _retransmittedBlocks = new BlockingCollection <SynchronizationBlockRetransmissionV1>(); _synchronizationBlocksByHeight = new Dictionary <ulong, Dictionary <IKey, List <SynchronizationBlockRetransmissionV1> > >(); _nodesRatingProvider = nodesRatingProvidersFactory.GetInstance(PacketType.Transactional); }
public SynchronizationInitializer(IStatesRepository statesRepository, IChainDataServicesManager chainDataServicesManager, ILoggerService loggerService, IHashCalculationsRepository hashCalculationsRepository) { _synchronizationContext = statesRepository.GetInstance <ISynchronizationContext>(); _chainDataService = chainDataServicesManager.GetChainDataService(PacketType.Synchronization); _logger = loggerService.GetLogger(typeof(SynchronizationInitializer).Name); _hashCalculation = hashCalculationsRepository.Create(Globals.DEFAULT_HASH); }
public SynchronizationGroupParticipationService(ISynchronizationProducer synchronizationProducer, IStatesRepository statesRepository, INodesRatingProviderFactory nodesRatingProvidersFactory, ILoggerService loggerService) { _synchronizationProducer = synchronizationProducer; _nodesRatingProvider = nodesRatingProvidersFactory.GetInstance(PacketType.Transactional); _synchronizationContext = statesRepository.GetInstance <ISynchronizationContext>(); _accountState = statesRepository.GetInstance <IAccountState>(); _synchronizationGroupState = statesRepository.GetInstance <ISynchronizationGroupState>(); _synchronizationGroupParticipationCheckAction = new TransformBlock <string, string>((Func <string, string>)SynchronizationGroupParticipationCheckAction, new ExecutionDataflowBlockOptions { MaxDegreeOfParallelism = 1 }); _synchronizationGroupLeaderCheckAction = new ActionBlock <string>((Action <string>)SynchronizationGroupLeaderCheckAction, new ExecutionDataflowBlockOptions { MaxDegreeOfParallelism = 1 }); _logger = loggerService.GetLogger(nameof(SynchronizationGroupParticipationService)); }
public void MemPool_AddedXUniqueTransactions_AllContained() { SynchronizationDescriptor synchronizationDescriptor = new SynchronizationDescriptor(1, new byte[Globals.DEFAULT_HASH_SIZE], DateTime.Now, DateTime.Now, 1); IHash transactionKeyHash = HashFactory.Hash128.CreateMurmur3_128(); ILogger logger = Substitute.For <ILogger>(); ILoggerService loggerService = Substitute.For <ILoggerService>(); IIdentityKeyProvider identityKeyProvider = new TransactionRegistryKeyProvider(); IIdentityKeyProvidersRegistry identityKeyProvidersRegistry = Substitute.For <IIdentityKeyProvidersRegistry>(); IHashCalculationsRepository hashCalculationsRepository = Substitute.For <IHashCalculationsRepository>(); ICryptoService cryptoService = Substitute.For <ICryptoService>(); SynchronizationContext synchronizationContext = new SynchronizationContext(loggerService); synchronizationContext.UpdateLastSyncBlockDescriptor(synchronizationDescriptor); IStatesRepository statesRepository = Substitute.For <IStatesRepository>(); hashCalculationsRepository.Create(HashType.MurMur).Returns(new MurMurHashCalculation()); logger.WhenForAnyArgs(l => l.Error(null)).DoNotCallBase(); logger.WhenForAnyArgs(l => l.Warning(null)).DoNotCallBase(); logger.WhenForAnyArgs(l => l.Info(null)).DoNotCallBase(); loggerService.GetLogger(null).Returns(logger); identityKeyProvidersRegistry.GetInstance(null).ReturnsForAnyArgs(identityKeyProvider); statesRepository.GetInstance <ISynchronizationContext>().Returns(synchronizationContext); byte[] privateKey = CryptoHelper.GetRandomSeed(); Ed25519.KeyPairFromSeed(out byte[] publicKey, out byte[] expandedPrivateKey, privateKey); cryptoService.ComputeTransactionKey(new Memory <byte>()).ReturnsForAnyArgs(c => transactionKeyHash.ComputeBytes(c.Arg <Memory <byte> >().ToArray()).GetBytes()); cryptoService.ComputeTransactionKey(new byte[0]).ReturnsForAnyArgs(c => transactionKeyHash.ComputeBytes(c.Arg <byte[]>()).GetBytes()); cryptoService.Sign(null).ReturnsForAnyArgs(c => Ed25519.Sign(c.Arg <byte[]>(), expandedPrivateKey)); cryptoService.PublicKey.ReturnsForAnyArgs(new Key32(publicKey)); TransactionRegistryMemPool transactionRegistryMemPool = new TransactionRegistryMemPool(loggerService, identityKeyProvidersRegistry, cryptoService, statesRepository, new TransactionsRegistryHelper(cryptoService, identityKeyProvidersRegistry), hashCalculationsRepository); ulong expectedCount = 10; SortedList <ushort, RegistryRegisterBlock> expectedBlocks = new SortedList <ushort, RegistryRegisterBlock>(); for (ulong i = 0; i < expectedCount; i++) { RegistryRegisterBlock transactionRegisterBlock = PacketsBuilder.GetTransactionRegisterBlock(synchronizationContext.LastBlockDescriptor.BlockHeight, 1, null, i, PacketType.Transactional, BlockTypes.Transaction_TransferFunds, new byte[Globals.POW_HASH_SIZE], new byte[Globals.DEFAULT_HASH_SIZE], privateKey); RegistryRegisterBlockSerializer serializer = new RegistryRegisterBlockSerializer(cryptoService, identityKeyProvidersRegistry, hashCalculationsRepository); serializer.Initialize(transactionRegisterBlock); serializer.FillBodyAndRowBytes(); expectedBlocks.Add((ushort)i, transactionRegisterBlock); transactionRegistryMemPool.EnqueueTransactionRegisterBlock(transactionRegisterBlock); } SortedList <ushort, ITransactionRegistryBlock> actualBlocks = transactionRegistryMemPool.DequeueBulk(-1); Assert.Equal(expectedCount, (ushort)actualBlocks.Count); for (ushort i = 0; i < (ushort)expectedCount; i++) { Assert.Equal(expectedBlocks[i].BlockHeight, ((RegistryRegisterBlock)actualBlocks[i]).BlockHeight); } }
public VoteViewModel(IDataAccessService dataAccessService, IStatesRepository statesRepository, IBlockParsersRepositoriesRepository blockParsersRepositoriesRepository, IWalletManager walletManager) { _dataAccessService = dataAccessService; _blockParsersRepositoriesRepository = blockParsersRepositoriesRepository; _walletManager = walletManager; _clientState = statesRepository.GetInstance <IClientState>(); }
public ResultsViewModel(IDataAccessService dataAccessService, IWalletManager walletManager, IBlockParsersRepositoriesRepository blockParsersRepositoriesRepository, IStatesRepository statesRepository) { _dataAccessService = dataAccessService; _walletManager = walletManager; _blockParsersRepositoriesRepository = blockParsersRepositoriesRepository; _clientState = statesRepository.GetInstance <IClientState>(); Utxos = new ObservableCollection <UtxoIncomingBlockDesc>(); }
public PollViewModel(IWalletManager walletManager, IStatesRepository statesRepository, IDataAccessService dataAccessService, IBlockParsersRepositoriesRepository blockParsersRepositoriesRepository) { InitPoll(); Polls = new ObservableCollection <IPoll>(); _walletManager = walletManager; _dataAccessService = dataAccessService; _blockParsersRepositoriesRepository = blockParsersRepositoriesRepository; _clientState = statesRepository.GetInstance <IClientState>(); ResultsViewModel = new ResultsViewModel(dataAccessService, walletManager, blockParsersRepositoriesRepository, statesRepository); }
public TransactionsRegistryHandler(IStatesRepository statesRepository, IServerCommunicationServicesRegistry communicationServicesRegistry, IRawPacketProvidersFactory rawPacketProvidersFactory, IRegistryMemPool registryMemPool, IConfigurationService configurationService, IHashCalculationsRepository hashCalculationRepository, ILoggerService loggerService) { _registryStateBlocks = new BlockingCollection <RegistryRegisterBlock>(); _registryUtxoBlocks = new BlockingCollection <RegistryRegisterUtxoConfidential>(); _registryGroupState = statesRepository.GetInstance <IRegistryGroupState>(); _synchronizationContext = statesRepository.GetInstance <ISynchronizationContext>(); _nodeContext = statesRepository.GetInstance <INodeContext>(); _communicationServicesRegistry = communicationServicesRegistry; _rawPacketProvidersFactory = rawPacketProvidersFactory; _registryMemPool = registryMemPool; _configurationService = configurationService; _defaulHashCalculation = hashCalculationRepository.Create(Globals.DEFAULT_HASH); _powCalculation = hashCalculationRepository.Create(Globals.POW_TYPE); _logger = loggerService.GetLogger(nameof(TransactionsRegistryHandler)); _processWitnessedFlow = new ActionBlock <RegistryShortBlock>((Action <RegistryShortBlock>)ProcessWitnessed); }
public RegistrationViewModel(IDataAccessService dataAccessService, IWalletManager walletManager, IStatesRepository statesRepository) { User = new User(); _clientState = statesRepository.GetInstance <IClientState>(); RegisteredUsers = new ObservableCollection <User>(); _dataAccessService = dataAccessService; _walletManager = walletManager; InitData(); }
public SyncRegistryMemPool(ISerializersFactory signatureSupportSerializersFactory, IHashCalculationsRepository hashCalculationsRepository, IIdentityKeyProvidersRegistry identityKeyProvidersRegistry, ICryptoService cryptoService, IStatesRepository statesRepository, ILoggerService loggerService) { _synchronizationContext = statesRepository.GetInstance <ISynchronizationContext>(); _roundDescriptors = new Dictionary <ulong, RoundDescriptor>(); _signatureSupportSerializersFactory = signatureSupportSerializersFactory; _cryptoService = cryptoService; _defaultTransactionHashCalculation = hashCalculationsRepository.Create(Globals.DEFAULT_HASH); _transactionHashKey = identityKeyProvidersRegistry.GetInstance("DefaultHash"); _logger = loggerService.GetLogger(nameof(SyncRegistryMemPool)); }
public InteractionModule(ILoggerService loggerService, IConfigurationService configurationService, IStatesRepository statesRepository, IChainDataServicesManager chainDataServicesManager, IIdentityKeyProvidersRegistry identityKeyProvidersRegistry, IHashCalculationsRepository hashCalculationsRepository) : base(loggerService) { _synchronizationContext = statesRepository.GetInstance <ISynchronizationContext>(); _configurationService = configurationService; _chainDataServicesManager = chainDataServicesManager; _identityKeyProvidersRegistry = identityKeyProvidersRegistry; _hashCalculationsRepository = hashCalculationsRepository; }
public TransactionsRegistryService(IStatesRepository statesRepository, IPredicatesRepository predicatesRepository, IRegistryMemPool registryMemPool, IIdentityKeyProvidersRegistry identityKeyProvidersRegistry, IConfigurationService configurationService, IServerCommunicationServicesRegistry serverCommunicationServicesRegistry, IPerformanceCountersRepository performanceCountersRepository, ISerializersFactory serializersFactory, IHashCalculationsRepository hashCalculationsRepository, ILoggerService loggerService) { _configurationService = configurationService; _synchronizationContext = statesRepository.GetInstance <ISynchronizationContext>(); _registryGroupState = statesRepository.GetInstance <IRegistryGroupState>(); _nodeContext = statesRepository.GetInstance <INodeContext>(); _isBlockProducerPredicate = predicatesRepository.GetInstance("IsBlockProducer"); _transactionHashKey = identityKeyProvidersRegistry.GetTransactionsIdenityKeyProvider(); _serverCommunicationServicesRegistry = serverCommunicationServicesRegistry; _serializersFactory = serializersFactory; _powCalculation = hashCalculationsRepository.Create(Globals.POW_TYPE); _hashCalculation = hashCalculationsRepository.Create(Globals.DEFAULT_HASH); _logger = loggerService.GetLogger(nameof(TransactionsRegistryService)); _registryMemPool = registryMemPool; _nodeCountersService = performanceCountersRepository.GetInstance <NodeCountersService>(); }
public TransactionsRegistrySyncHandler(IStatesRepository statesRepository, ISyncShardsManager syncShardsManager, IIdentityKeyProvidersRegistry identityKeyProvidersRegistry, ICryptoService cryptoService, ISerializersFactory signatureSupportSerializersFactory, IHashCalculationsRepository hashCalculationsRepository, IServerCommunicationServicesRegistry communicationServicesRegistry, ISyncRegistryMemPool syncRegistryMemPool, INodesResolutionService nodesResolutionService, IChainDataServicesManager chainDataServicesManager, IRawPacketProvidersFactory rawPacketProvidersFactory, ILoggerService loggerService) { _registryBlocks = new BlockingCollection <RegistryBlockBase>(); _synchronizationContext = statesRepository.GetInstance <ISynchronizationContext>(); _syncRegistryNeighborhoodState = statesRepository.GetInstance <ISyncRegistryNeighborhoodState>(); _syncContextChangedUnsibsciber = _synchronizationContext.SubscribeOnStateChange(new ActionBlock <string>((Action <string>)SynchronizationStateChanged)); _syncShardsManager = syncShardsManager; _transactionHashKey = identityKeyProvidersRegistry.GetTransactionsIdenityKeyProvider(); _cryptoService = cryptoService; _signatureSupportSerializersFactory = signatureSupportSerializersFactory; _defaultTransactionHashCalculation = hashCalculationsRepository.Create(Globals.DEFAULT_HASH); _powCalculation = hashCalculationsRepository.Create(Globals.POW_TYPE); _communicationServicesRegistry = communicationServicesRegistry; _syncRegistryMemPool = syncRegistryMemPool; _nodesResolutionService = nodesResolutionService; _rawPacketProvidersFactory = rawPacketProvidersFactory; _synchronizationChainDataService = chainDataServicesManager.GetChainDataService(PacketType.Synchronization); _registryChainDataService = chainDataServicesManager.GetChainDataService(PacketType.Registry); _logger = loggerService.GetLogger(nameof(TransactionsRegistrySyncHandler)); }
public WalletManager(INetworkAdapter networkAdapter, IBlockCreator blockCreator, IDataAccessService dataAccessService, IHashCalculationsRepository hashCalculationsRepository, IIdentityKeyProvidersRegistry identityKeyProvidersRegistry, IStatesRepository statesRepository, ISerializersFactory signatureSupportSerializersFactory, IBlockParsersRepositoriesRepository blockParsersRepositoriesRepository) { _networkAdapter = networkAdapter; _blockCreator = blockCreator; _dataAccessService = dataAccessService; _signatureSupportSerializersFactory = signatureSupportSerializersFactory; _blockParsersRepositoriesRepository = blockParsersRepositoriesRepository; _heightsDictionary = new Dictionary <byte[], ulong>(); _hashCalculation = hashCalculationsRepository.Create(Globals.DEFAULT_HASH); _proofOfWorkCalculation = hashCalculationsRepository.Create(Globals.POW_TYPE); _identityKeyProvider = identityKeyProvidersRegistry.GetInstance(); _clientState = statesRepository.GetInstance <IClientState>(); }
public TransactionRegistryMemPool(ILoggerService loggerService, IIdentityKeyProvidersRegistry identityKeyProvidersRegistry, IStatesRepository statesRepository, IHashCalculationsRepository hashCalculationsRepository) { _oldValue = 0; _transactionHashKey = identityKeyProvidersRegistry.GetTransactionsIdenityKeyProvider(); _logger = loggerService.GetLogger(nameof(TransactionRegistryMemPool)); _transactionStateWitnesses = new List <RegistryRegisterBlock>(); _transactionUtxoWitnesses = new List <RegistryRegisterUtxoConfidential>(); _transactionStateWitnessesBySender = new Dictionary <IKey, List <RegistryRegisterBlock> >(); _transactionUtxoWitnessesByKeyImage = new Dictionary <IKey, RegistryRegisterUtxoConfidential>(); _transactionsShortBlocks = new Dictionary <ulong, Dictionary <ulong, HashSet <RegistryShortBlock> > >(); _synchronizationContext = statesRepository.GetInstance <ISynchronizationContext>(); _hashCalculation = hashCalculationsRepository.Create(Globals.DEFAULT_HASH); }
public NetworkSynchronizer(IBlockCreator blockCreator, IClientCommunicationServiceRepository clientCommunicationServiceRepository, ICryptoService cryptoService, IDataAccessService dataAccessService, IHashCalculationsRepository hashCalculationsRepository, IConfigurationService configurationService, IBlockParsersRepositoriesRepository blockParsersRepositoriesRepository, IIdentityKeyProvidersRegistry identityKeyProvidersRegistry, INodesResolutionService nodesResolutionService, IStatesRepository statesRepository, ILoggerService loggerService) { _cryptoService = cryptoService; _dataAccessService = dataAccessService; _blockCreator = blockCreator; _communicationService = clientCommunicationServiceRepository.GetInstance("TcpClientCommunicationService"); _defaultHashCalculation = hashCalculationsRepository.Create(Globals.DEFAULT_HASH); _synchronizerConfiguration = configurationService.Get <ISynchronizerConfiguration>(); _communicationConfiguration = (CommunicationConfigurationBase)configurationService["generalTcpCommunication"]; _blockParsersRepositoriesRepository = blockParsersRepositoriesRepository; _nodesResolutionService = nodesResolutionService; _identityKeyProvider = identityKeyProvidersRegistry.GetInstance(); _clientState = statesRepository.GetInstance <IClientState>(); _logger = loggerService.GetLogger(nameof(NetworkSynchronizer)); }
public SyncHeightVerifier(IStatesRepository statesRepository, IHashCalculationsRepository hashCalculationsRepository, ILoggerService loggerService) { _log = loggerService.GetLogger(GetType().Name); _synchronizationContext = statesRepository.GetInstance <ISynchronizationContext>(); _proofOfWorkCalculation = hashCalculationsRepository.Create(Globals.POW_TYPE); }
public ShardsManager(IStatesRepository statesRepository, INodesDataService nodesDataService) { _synchronizationContext = statesRepository.GetInstance <ISynchronizationContext>(); _syncContextChangedUnsibscriber = _synchronizationContext.SubscribeOnStateChange(new ActionBlock <string>((Action <string>)OnSyncContextChanged)); _nodesDataService = nodesDataService; }
public SynchronizationConfirmedVerifier(IStatesRepository statesRepository, ILoggerService loggerService) { _synchronizationContext = statesRepository.GetInstance <ISynchronizationContext>(); _loggerService = loggerService; }
public TransactionRegistrationLoadModule(ILoggerService loggerService, IClientCommunicationServiceRepository clientCommunicationServiceRepository, IConfigurationService configurationService, IIdentityKeyProvidersRegistry identityKeyProvidersRegistry, ISerializersFactory signatureSupportSerializersFactory, INodesDataService nodesDataService, ISigningService cryptoService, IPerformanceCountersRepository performanceCountersRepository, IStatesRepository statesRepository, IHashCalculationsRepository proofOfWorkCalculationRepository, IHashCalculationsRepository hashCalculationRepository) : base(loggerService, clientCommunicationServiceRepository, configurationService, identityKeyProvidersRegistry, signatureSupportSerializersFactory, nodesDataService, cryptoService, performanceCountersRepository, hashCalculationRepository) { _synchronizationContext = statesRepository.GetInstance <ISynchronizationContext>(); _proofOfWorkCalculation = proofOfWorkCalculationRepository.Create(Globals.POW_TYPE); }
public void MemPool_AddedNonUniqueTransactions_NotAllContained() { SynchronizationDescriptor synchronizationDescriptor = new SynchronizationDescriptor(1, new byte[Globals.DEFAULT_HASH_SIZE], DateTime.Now, DateTime.Now, 1); IHash transactionKeyHash = HashFactory.Hash128.CreateMurmur3_128(); ILogger logger = Substitute.For <ILogger>(); ILoggerService loggerService = Substitute.For <ILoggerService>(); IIdentityKeyProvider identityKeyProvider = new TransactionRegistryKeyProvider(); IIdentityKeyProvidersRegistry identityKeyProvidersRegistry = Substitute.For <IIdentityKeyProvidersRegistry>(); IHashCalculationsRepository hashCalculationsRepository = Substitute.For <IHashCalculationsRepository>(); ISigningService signingService = Substitute.For <ISigningService>(); SynchronizationContext synchronizationContext = new SynchronizationContext(loggerService); synchronizationContext.UpdateLastSyncBlockDescriptor(synchronizationDescriptor); IStatesRepository statesRepository = Substitute.For <IStatesRepository>(); hashCalculationsRepository.Create(HashType.MurMur).Returns(new MurMurHashCalculation()); logger.WhenForAnyArgs(l => l.Error(null)).DoNotCallBase(); logger.WhenForAnyArgs(l => l.Warning(null)).DoNotCallBase(); logger.WhenForAnyArgs(l => l.Info(null)).DoNotCallBase(); loggerService.GetLogger(null).Returns(logger); identityKeyProvidersRegistry.GetTransactionsIdenityKeyProvider().ReturnsForAnyArgs(identityKeyProvider); //identityKeyProvider.GetKey(null).ReturnsForAnyArgs(c => new Key16() { Value = c.Arg<Memory<byte>>() }); statesRepository.GetInstance <ISynchronizationContext>().Returns(synchronizationContext); byte[] privateKey = ConfidentialAssetsHelper.GetRandomSeed(); Ed25519.KeyPairFromSeed(out byte[] publicKey, out byte[] expandedPrivateKey, privateKey); signingService.WhenForAnyArgs(s => s.Sign(null, null)).Do(c => { ((SignedPacketBase)c.ArgAt <IPacket>(0)).Signer = new Key32(publicKey); ((SignedPacketBase)c.ArgAt <IPacket>(0)).Signature = Ed25519.Sign(c.Arg <byte[]>(), expandedPrivateKey); }); signingService.PublicKeys.ReturnsForAnyArgs(new IKey[] { new Key32(publicKey) }); TransactionRegistryMemPool transactionRegistryMemPool = new TransactionRegistryMemPool(loggerService, identityKeyProvidersRegistry, statesRepository, hashCalculationsRepository); SortedList <ushort, RegistryRegisterBlock> expectedBlocks = new SortedList <ushort, RegistryRegisterBlock>(); ulong[] heights = new ulong[] { 1, 2, 2, 5, 4, 3, 4, 3, 4, 5, 3 }; HashSet <ulong> addedHeights = new HashSet <ulong>(); ushort order = 0; for (ulong i = 0; i < (ulong)heights.Length; i++) { RegistryRegisterBlock transactionRegisterBlock = PacketsBuilder.GetTransactionRegisterBlock(synchronizationContext.LastBlockDescriptor.BlockHeight, 1, null, heights[i], PacketType.Transactional, BlockTypes.Transaction_TransferFunds, new byte[Globals.POW_HASH_SIZE], new byte[Globals.DEFAULT_HASH_SIZE], privateKey); RegistryRegisterBlockSerializer serializer = new RegistryRegisterBlockSerializer(); serializer.Initialize(transactionRegisterBlock); serializer.SerializeBody(); signingService.Sign(transactionRegisterBlock); serializer.SerializeFully(); if (!addedHeights.Contains(heights[i])) { expectedBlocks.Add(order++, transactionRegisterBlock); addedHeights.Add(heights[i]); } transactionRegistryMemPool.EnqueueTransactionWitness(transactionRegisterBlock); } SortedList <ushort, RegistryRegisterBlock> actualBlocks = transactionRegistryMemPool.DequeueStateWitnessBulk(); Assert.Equal(expectedBlocks.Count, actualBlocks.Count); for (ushort i = 0; i < (ushort)expectedBlocks.Count; i++) { Assert.Equal(expectedBlocks[i].BlockHeight, actualBlocks[i].BlockHeight); } }
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(); }