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 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 SignatureSupportSerializerBase(PacketType packetType, ushort blockType, ICryptoService cryptoService, IIdentityKeyProvidersRegistry identityKeyProvidersRegistry, IHashCalculationsRepository hashCalculationsRepository)
: base(packetType, blockType)
{
_cryptoService = cryptoService;
_transactionKeyIdentityKeyProvider = identityKeyProvidersRegistry.GetTransactionsIdenityKeyProvider();
_transactionKeyHashCalculation = hashCalculationsRepository.Create(HashType.MurMur);
}
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 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 BlockHandler(IHashCalculation hashCalculation, ICallNumberRepository callNumberRepository, ILogger <BlockHandler> logger,
BlockchainMetadata blockchainMetadata)
{
_hashCalculation = hashCalculation;
_callNumberRepository = callNumberRepository;
_logger = logger;
_blockchainMetadata = blockchainMetadata;
}
private DataAccessService(IConfigurationService configurationService, IIdentityKeyProvidersRegistry identityKeyProvidersRegistry, IHashCalculationsRepository hashCalculationsRepository, ILoggerService loggerService)
{
_cancellationTokenSource = new CancellationTokenSource();
_configurationService = configurationService;
_identityKeyProvider = identityKeyProvidersRegistry.GetInstance();
_defaultHashCalculation = hashCalculationsRepository.Create(Globals.DEFAULT_HASH);
_logger = loggerService.GetLogger(nameof(DataAccessService));
}
public ConsentManagementService(IDataAccessService dataAccessService, IAccountsService accountsService,
IRelationsProofsValidationService relationsProofsValidationService, IConfigurationService configurationService,
IHashCalculationsRepository hashCalculationsRepository, ILoggerService loggerService, IHubContext <ConsentManagementHub> hubContext)
{
_logger = loggerService.GetLogger(nameof(ConsentManagementService));
_dataAccessService = dataAccessService;
_accountsService = accountsService;
_relationsProofsValidationService = relationsProofsValidationService;
_hubContext = hubContext;
_azureConfiguration = configurationService.Get <IAzureConfiguration>();
_hashCalculation = hashCalculationsRepository.Create(Globals.DEFAULT_HASH);
PipeIn = new ActionBlock <PacketBase>(async p =>
{
try
{
if (p is GroupsRelationsProofs relationsProofs)
{
_logger.LogIfDebug(() => $"[{_accountId}]: checking relation proofs {JsonConvert.SerializeObject(relationsProofs, new ByteArrayJsonConverter())}");
UtxoPersistency utxoPersistency = _executionContextManager.ResolveUtxoExecutionServices(_accountId);
utxoPersistency.ClientCryptoService.DecodeEcdhTuple(relationsProofs.EcdhTuple, relationsProofs.TransactionPublicKey, out byte[] blindingFactor, out byte[] imageHash, out byte[] issuer, out byte[] sessionKey);
string keyImage = relationsProofs.KeyImage.ToString();
_proofsSessions.AddOrUpdate(keyImage, new ProofsSession {
SessionKey = sessionKey.ToHexString(), CreationTime = DateTime.UtcNow
}, (k, v) => v);
RelationProofsSession relationProofsSession = PopRelationProofSession(sessionKey.ToHexString());
_logger.LogIfDebug(() => $"{nameof(relationProofsSession)}={JsonConvert.SerializeObject(relationProofsSession, new ByteArrayJsonConverter())}");
RelationProofsValidationResults validationResults
= await _relationsProofsValidationService
.VerifyRelationProofs(relationsProofs, _clientCryptoService, relationProofsSession)
.ConfigureAwait(false);
await _hubContext.Clients.Group(sessionKey.ToHexString()).SendAsync("ValidationResults", validationResults).ConfigureAwait(false);
}
else if (p is TransitionCompromisedProofs compromisedProofs)
{
if (_proofsSessions.TryGetValue(compromisedProofs.CompromisedKeyImage.ToHexString(), out ProofsSession proofsSession))
{
await _hubContext.Clients.Group(proofsSession.SessionKey).SendAsync("ProofsCompromised", proofsSession).ConfigureAwait(false);
}
}
}
catch (Exception ex)
{
_logger.Error($"[{_accountId}]: failure during processing {p.GetType().Name}", ex);
}
});
PipInNotifications = new ActionBlock <SynchronizerNotificationBase>(n =>
{
});
}
public void Utilize(IHashCalculation obj)
{
if (!_hashCalculations.ContainsKey(obj.HashType))
{
throw new HashAlgorithmNotSupportedException(obj.HashType);
}
_hashCalculations[obj.HashType].Push(obj);
}
public TransactionalChainManagerImpl(IChainDataServicesManager chainDataServicesManager, IIdentityKeyProvidersRegistry identityKeyProvidersRegistry, IHashCalculationsRepository hashCalculationsRepository, ILogger logger)
{
_logger = logger;
_transactionalDataService = chainDataServicesManager.GetChainDataService(PacketType.Transactional);
_registryChainDataService = chainDataServicesManager.GetChainDataService(PacketType.Registry);
_utxoConfidentialDataService = chainDataServicesManager.GetChainDataService(PacketType.UtxoConfidential);
_identityKeyProvider = identityKeyProvidersRegistry.GetInstance();
_hashCalculation = hashCalculationsRepository.Create(Globals.DEFAULT_HASH);
}
public ServiceProvidersController(IAccountsService accountsService, IExecutionContextManager executionContextManager, IDataAccessService dataAccessService, IIdentityAttributesService identityAttributesService, IHashCalculationsRepository hashCalculationsRepository, IAssetsService assetsService, IOptions <AppSettings> appSettings)
{
_accountsService = accountsService;
_executionContextManager = executionContextManager;
_dataAccessService = dataAccessService;
_identityAttributesService = identityAttributesService;
_assetsService = assetsService;
_appSettings = appSettings.Value;
_hashCalculation = hashCalculationsRepository.Create(Globals.DEFAULT_HASH);
}
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 SyncManagerImpl(ISynchronizationContext synchronizationContext, IChainDataServicesManager chainDataServicesManager, IHashCalculationsRepository hashCalculationsRepository, ILogger logger)
{
_synchronizationContext = synchronizationContext;
_logger = logger;
_syncChainDataService = chainDataServicesManager.GetChainDataService(PacketType.Synchronization);
_registryChainDataService = chainDataServicesManager.GetChainDataService(PacketType.Registry);
_transactionalDataService = chainDataServicesManager.GetChainDataService(PacketType.Transactional);
_utxoConfidentialDataService = chainDataServicesManager.GetChainDataService(PacketType.UtxoConfidential);
_hashCalculation = hashCalculationsRepository.Create(Globals.DEFAULT_HASH);
}
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 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 DataAccessService(IConfigurationService configurationService, IIdentityKeyProvidersRegistry identityKeyProvidersRegistry, IHashCalculationsRepository hashCalculationsRepository, ILoggerService loggerService)
{
_cancellationTokenSource = new CancellationTokenSource();
_configurationService = configurationService;
_dataContext = new DataContext(_configurationService.Get <ISQLiteConfiguration>());
_dataContext.ChangeTracker.StateChanged += (s, e) =>
{
AccountIdentity accountIdentity = e.Entry.Entity as AccountIdentity;
};
_identityKeyProvider = identityKeyProvidersRegistry.GetInstance();
_defaultHashCalculation = hashCalculationsRepository.Create(Globals.DEFAULT_HASH);
_logger = loggerService.GetLogger(nameof(DataAccessService));
}
private static SortedList <ushort, IKey> GetTransactionHeaderKeys(IHashCalculation hashCalculationTransactionKey, SortedList <ushort, ITransactionRegistryBlock> transactionHeaders)
{
SortedList <ushort, IKey> transactionHeaderKeys = new SortedList <ushort, IKey>(transactionHeaders.Count);
foreach (ushort order in transactionHeaders.Keys)
{
ITransactionRegistryBlock registryRegisterBlock = transactionHeaders[order];
byte[] hashBytes = hashCalculationTransactionKey.CalculateHash(registryRegisterBlock.RawData);
IKey key = new Key16(hashBytes);
transactionHeaderKeys.Add(order, key);
}
return(transactionHeaderKeys);
}
public ServiceProvidersController(
IAccountsService accountsService, IExecutionContextManager executionContextManager,
IDataAccessService dataAccessService, IIdentityAttributesService identityAttributesService, IConsentManagementService consentManagementService,
IHashCalculationsRepository hashCalculationsRepository, IAssetsService assetsService, IConfigurationService configurationService, ILoggerService loggerService)
{
_accountsService = accountsService;
_executionContextManager = executionContextManager;
_dataAccessService = dataAccessService;
_identityAttributesService = identityAttributesService;
_consentManagementService = consentManagementService;
_assetsService = assetsService;
_hashCalculation = hashCalculationsRepository.Create(Globals.DEFAULT_HASH);
_restApiConfiguration = configurationService.Get <IRestApiConfiguration>();
_logger = loggerService.GetLogger(nameof(ServiceProvidersController));
}
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 SpUsersController(IAccountsServiceEx accountsService,
IDataAccessService dataAccessService,
IHashCalculationsRepository hashCalculationsRepository,
IExecutionContextManager executionContextManager,
IAssetsService assetsService,
IUniversalProofsPool universalProofsPool,
IDocumentSignatureVerifier documentSignatureVerifier)
{
_accountsService = accountsService;
_dataAccessService = dataAccessService;
_executionContextManager = executionContextManager;
_assetsService = assetsService;
_universalProofsPool = universalProofsPool;
_documentSignatureVerifier = documentSignatureVerifier;
_hashCalculation = hashCalculationsRepository.Create(Globals.DEFAULT_HASH);
}
public LoadModuleBase(ILoggerService loggerService, IClientCommunicationServiceRepository clientCommunicationServiceRepository,
IConfigurationService configurationService, IIdentityKeyProvidersRegistry identityKeyProvidersRegistry,
ISerializersFactory signatureSupportSerializersFactory, INodesDataService nodesDataService, ICryptoService cryptoService,
IPerformanceCountersRepository performanceCountersRepository, IHashCalculationsRepository hashCalculationRepository)
: base(loggerService)
{
_communicationService = clientCommunicationServiceRepository.GetInstance(nameof(TcpClientCommunicationService));
_configurationService = configurationService;
_signatureSupportSerializersFactory = signatureSupportSerializersFactory;
_nodesDataService = nodesDataService;
_cryptoService = cryptoService;
_identityKeyProvider = identityKeyProvidersRegistry.GetInstance();
_loadCountersService = performanceCountersRepository.GetInstance <LoadCountersService>();
_hashCalculation = hashCalculationRepository.Create(Globals.DEFAULT_HASH);
_proofOfWorkCalculation = hashCalculationRepository.Create(Globals.POW_TYPE);
}
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 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 IHashCalculation Create(HashType key)
{
if (!_hashCalculations.ContainsKey(key))
{
throw new HashAlgorithmNotSupportedException(key);
}
lock (_sync)
{
if (_hashCalculations[key].Count > 1)
{
return(_hashCalculations[key].Pop());
}
IHashCalculation calculationTemp = _hashCalculations[key].Pop();
IHashCalculation calculation = (IHashCalculation)_applicationContext.Container.Resolve(calculationTemp.GetType());
_hashCalculations[key].Push(calculationTemp);
return(calculation);
}
}
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 RegistryDataService(ITranslatorsRepository translatorsRepository, IHashCalculationsRepository hashCalculationsRepository)
{
_translatorsRepository = translatorsRepository;
_defaultHashCalculation = hashCalculationsRepository.Create(Globals.DEFAULT_HASH);
}
public ClientState(ICryptoService cryptoService, IHashCalculationsRepository hashCalculationsRepository)
{
_cryptoService = cryptoService;
_defaultHashCalculation = hashCalculationsRepository.Create(Globals.DEFAULT_HASH);
}
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);
}
