public TestBase()
{
_transactionHashKeyProvider = Substitute.For <IIdentityKeyProvider>();
_identityKeyProvider = Substitute.For <IIdentityKeyProvider>();
_identityKeyProvidersRegistry = Substitute.For <IIdentityKeyProvidersRegistry>();
_hashCalculationRepository = Substitute.For <IHashCalculationsRepository>();
_blockParsersRepositoriesRepository = Substitute.For <IBlockParsersRepositoriesRepository>();
_blockParsersRepository = Substitute.For <IBlockParsersRepository>();
_cryptoService = Substitute.For <ICryptoService>();
_identityKeyProvidersRegistry.GetInstance().Returns(_identityKeyProvider);
_identityKeyProvidersRegistry.GetTransactionsIdenityKeyProvider().Returns(_transactionHashKeyProvider);
_identityKeyProvider.GetKey(null).ReturnsForAnyArgs(c => new Key32()
{
Value = c.Arg <Memory <byte> >()
});
_transactionHashKeyProvider.GetKey(null).ReturnsForAnyArgs(c => new Key16()
{
Value = c.Arg <Memory <byte> >()
});
_hashCalculationRepository.Create(HashType.MurMur).Returns(new MurMurHashCalculation());
_blockParsersRepositoriesRepository.GetBlockParsersRepository(PacketType.Registry).ReturnsForAnyArgs(_blockParsersRepository);
_privateKey = CryptoHelper.GetRandomSeed();
Ed25519.KeyPairFromSeed(out _publicKey, out _expandedPrivateKey, _privateKey);
_cryptoService.Sign(null).ReturnsForAnyArgs(c => Ed25519.Sign(c.Arg <byte[]>(), _expandedPrivateKey));
_cryptoService.PublicKey.Returns(new Key32()
{
Value = _publicKey
});
ServiceLocator.Current.GetInstance <IUnityContainer>().RegisterInstance(_blockParsersRepositoriesRepository);
}
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 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 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 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 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);
}
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 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 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 TestBase()
{
_transactionHashKeyProvider = Substitute.For <IIdentityKeyProvider>();
_identityKeyProvider = Substitute.For <IIdentityKeyProvider>();
_identityKeyProvidersRegistry = Substitute.For <IIdentityKeyProvidersRegistry>();
_hashCalculationRepository = Substitute.For <IHashCalculationsRepository>();
_blockParsersRepositoriesRepository = Substitute.For <IBlockParsersRepositoriesRepository>();
_blockParsersRepository = Substitute.For <IBlockParsersRepository>();
_signingService = Substitute.For <ISigningService>();
_identityKeyProvidersRegistry.GetInstance().Returns(_identityKeyProvider);
_identityKeyProvidersRegistry.GetTransactionsIdenityKeyProvider().Returns(_transactionHashKeyProvider);
_identityKeyProvider.GetKey(null).ReturnsForAnyArgs(c => new Key32()
{
Value = c.Arg <Memory <byte> >()
});
_transactionHashKeyProvider.GetKey(null).ReturnsForAnyArgs(c => new Key16()
{
Value = c.Arg <Memory <byte> >()
});
_hashCalculationRepository.Create(HashType.MurMur).Returns(new MurMurHashCalculation());
_blockParsersRepositoriesRepository.GetBlockParsersRepository(PacketType.Registry).ReturnsForAnyArgs(_blockParsersRepository);
_privateKey = ConfidentialAssetsHelper.GetRandomSeed();
_privateViewKey = ConfidentialAssetsHelper.GetRandomSeed();
Ed25519.KeyPairFromSeed(out _publicKey, out _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(((SignedPacketBase)c.ArgAt <IPacket>(0)).BodyBytes.ToArray(), _expandedPrivateKey);
});
_signingService.PublicKeys.Returns(new IKey[] { new Key32()
{
Value = _publicKey
} });
_utxoSigningService = new UtxoSigningService(_identityKeyProvidersRegistry);
_utxoSigningService.Initialize(_privateKey, _privateViewKey);
ServiceLocator.Current.GetInstance <IUnityContainer>().RegisterInstance(_blockParsersRepositoriesRepository);
}
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);
}
private static SortedList <ushort, RegistryRegisterBlock> GetTransactionHeaders(ulong syncBlockHeight, ulong blockHeight, uint nonce, ushort expectedCount)
{
PacketType expectedReferencedPacketType = PacketType.Transactional;
ushort expectedReferencedBlockType = BlockTypes.Transaction_TransferFunds;
SortedList <ushort, RegistryRegisterBlock> transactionHeaders = new SortedList <ushort, RegistryRegisterBlock>(expectedCount);
for (ushort j = 0; j < expectedCount; j++)
{
RegistryRegisterBlock registryRegisterBlock = new RegistryRegisterBlock
{
SyncBlockHeight = syncBlockHeight,
Nonce = nonce + j,
PowHash = BinaryHelper.GetPowHash(1234 + j),
BlockHeight = blockHeight,
ReferencedPacketType = expectedReferencedPacketType,
ReferencedBlockType = expectedReferencedBlockType,
ReferencedBodyHash = BinaryHelper.GetDefaultHash(473826643 + j),
ReferencedTarget = BinaryHelper.GetDefaultHash(BinaryHelper.GetRandomPublicKey())
};
ISigningService signingService = GetRandomCryptoService();
IIdentityKeyProvider transactionIdentityKeyProvider = Substitute.For <IIdentityKeyProvider>();
transactionIdentityKeyProvider.GetKey(null).ReturnsForAnyArgs(c => new Key16(c.ArgAt <Memory <byte> >(0)));
IIdentityKeyProvidersRegistry transactionIdentityKeyProvidersRegistry = Substitute.For <IIdentityKeyProvidersRegistry>();
transactionIdentityKeyProvidersRegistry.GetTransactionsIdenityKeyProvider().Returns(transactionIdentityKeyProvider);
IHashCalculationsRepository transactionHashCalculationsRepository = Substitute.For <IHashCalculationsRepository>();
transactionHashCalculationsRepository.Create(HashType.MurMur).Returns(new MurMurHashCalculation());
RegistryRegisterBlockSerializer serializer1 = new RegistryRegisterBlockSerializer();
serializer1.Initialize(registryRegisterBlock);
serializer1.SerializeBody();
signingService.Sign(registryRegisterBlock);
serializer1.SerializeFully();
transactionHeaders.Add(j, registryRegisterBlock);
}
return(transactionHeaders);
}
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 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 UtxoConfidentialStorageHandler(IStatesRepository statesRepository, IServerCommunicationServicesRegistry communicationServicesRegistry, IRawPacketProvidersFactory rawPacketProvidersFactory, IRegistryMemPool registryMemPool, IConfigurationService configurationService, IHashCalculationsRepository hashCalculationRepository, IChainDataServicesManager chainDataServicesManager) : base(statesRepository, communicationServicesRegistry, rawPacketProvidersFactory, registryMemPool, configurationService, hashCalculationRepository, chainDataServicesManager)
{
}
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 SynchronizationRegistryCombinedBlockSerializer(ICryptoService cryptoService, IIdentityKeyProvidersRegistry identityKeyProvidersRegistry, IHashCalculationsRepository hashCalculationsRepository)
: base(PacketType.Synchronization, BlockTypes.Synchronization_RegistryCombinationBlock, cryptoService, identityKeyProvidersRegistry, hashCalculationsRepository)
{
}
public TransferFundsBlockParser(IHashCalculationsRepository proofOfWorkCalculationRepository, IIdentityKeyProvidersRegistry identityKeyProvidersRegistry)
: base(proofOfWorkCalculationRepository, identityKeyProvidersRegistry)
{
}
public AcceptAssetTransitionBlockParser(IHashCalculationsRepository proofOfWorkCalculationRepository, IIdentityKeyProvidersRegistry identityKeyProvidersRegistry)
: base(proofOfWorkCalculationRepository, identityKeyProvidersRegistry)
{
}
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 RegistryDataService(ITranslatorsRepository translatorsRepository, IHashCalculationsRepository hashCalculationsRepository)
{
_translatorsRepository = translatorsRepository;
_defaultHashCalculation = hashCalculationsRepository.Create(Globals.DEFAULT_HASH);
}
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 RegistryConfidenceBlockSerializer(ICryptoService cryptoService, IIdentityKeyProvidersRegistry identityKeyProvidersRegistry, IHashCalculationsRepository hashCalculationsRepository)
: base(PacketType.Registry, BlockTypes.Registry_ConfidenceBlock, cryptoService, identityKeyProvidersRegistry, hashCalculationsRepository)
{
}
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));
}
public RegistryFullBlockParser(IIdentityKeyProvidersRegistry identityKeyProvidersRegistry, IHashCalculationsRepository hashCalculationRepository) : base(identityKeyProvidersRegistry, hashCalculationRepository)
{
_registryRegisterBlockParser = new RegistryRegisterBlockParser(identityKeyProvidersRegistry, hashCalculationRepository);
_blockParsersRepositoriesRepository = new Lazy <IBlockParsersRepositoriesRepository>(() => ServiceLocator.Current.GetInstance <IBlockParsersRepositoriesRepository>());
}
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 TransferFundsBlockSerializer(ICryptoService cryptoService, IIdentityKeyProvidersRegistry identityKeyProvidersRegistry,
IHashCalculationsRepository hashCalculationsRepository)
: base(PacketType.Transactional, BlockTypes.Transaction_TransferFunds, cryptoService, identityKeyProvidersRegistry, hashCalculationsRepository)
{
}
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);
}
