public FullTransactionSingleModule(ILoggerService loggerService, IClientCommunicationServiceRepository clientCommunicationServiceRepository,
IConfigurationService configurationService, IIdentityKeyProvidersRegistry identityKeyProvidersRegistry,
ISerializersFactory signatureSupportSerializersFactory, INodesDataService nodesDataService,
ISigningService cryptoService, IPerformanceCountersRepository performanceCountersRepository, IHashCalculationsRepository hashCalculationRepository)
: base(loggerService, clientCommunicationServiceRepository, configurationService, identityKeyProvidersRegistry, signatureSupportSerializersFactory, nodesDataService, cryptoService, performanceCountersRepository, hashCalculationRepository)
{
}
public ElevationManager(ILog logger, ISigningService signService)
{
Logger = logger;
lockObj = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
authTokenMap = new Dictionary <Guid, ManagedSession>();
signingService = signService;
}
public AuthController(
IAuthRepository repository,
IUserRepository usersRepository,
IConfiguration configuration,
ISigningService signing,
IMapper mapper)
{
_repository = repository;
_usersRepository = usersRepository;
_configuration = configuration;
_signing = signing;
_mapper = mapper;
}
public LoadModuleBase(ILoggerService loggerService, IClientCommunicationServiceRepository clientCommunicationServiceRepository,
IConfigurationService configurationService, IIdentityKeyProvidersRegistry identityKeyProvidersRegistry,
ISerializersFactory signatureSupportSerializersFactory, INodesDataService nodesDataService, ISigningService cryptoService,
IPerformanceCountersRepository performanceCountersRepository, IHashCalculationsRepository hashCalculationRepository)
: base(loggerService)
{
_communicationService = clientCommunicationServiceRepository.GetInstance(nameof(TcpClientCommunicationService));
_configurationService = configurationService;
_serializersFactory = 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 MainPlatform(
IUserInput userInputService,
IOptions <UserInfoSettings> options,
ISigningService signingService,
IGamePlatform gamePlatform,
ILogger <MainPlatform> logger,
ISingleStorage <AuthInfo> authInfo,
IStatisticsService statisticsService)
{
_userInputService = userInputService;
_settings = options.Value;
_signingService = signingService;
_gamePlatform = gamePlatform;
_logger = logger;
_authInfo = authInfo;
_statisticsService = statisticsService;
}
public void Initialize(byte[] secretKey, CancellationToken ct)
{
if (secretKey == null)
{
throw new ArgumentNullException(nameof(secretKey));
}
ISigningService signingService = _signingServicesRepository.GetInstance("AccountSigningService");
signingService.Initialize(secretKey);
_nodeContext.Initialize(signingService);
InitializeCommunicationLayer();
ObtainConfiguredModules();
InitializeModules(ct);
}
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);
}
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);
}
private static ISigningService GetRandomCryptoService()
{
ISigningService signingService = Substitute.For <ISigningService>();
byte[] privateKey = ConfidentialAssetsHelper.GetRandomSeed();
byte[] expandedPrivateKey;
byte[] publicKey;
Ed25519.KeyPairFromSeed(out publicKey, out expandedPrivateKey, privateKey);
signingService.WhenForAnyArgs(s => s.Sign(null, null)).Do(c =>
{
((SignedPacketBase)c.ArgAt <IPacket>(0)).Signer = new Key32()
{
Value = publicKey
};
((SignedPacketBase)c.ArgAt <IPacket>(0)).Signature = Ed25519.Sign(c.Arg <byte[]>(), expandedPrivateKey);
});
signingService.PublicKeys.Returns(new IKey[] { new Key32()
{
Value = publicKey
} });
return(signingService);
}
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 Initialize(ISigningService signingService)
{
SigningService = signingService;
AccountKey = SigningService.PublicKeys[0];
}
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();
}
public SignController(ISigningService signingService)
{
_signingService = signingService;
}
public JwtFactory(IOptions <JwtTokenOptions> options, ISigningService signingConfiguration)
{
_options = options;
_signingConfiguration = signingConfiguration;
}
public SyncConfirmedSingleModule(ILoggerService loggerService, IClientCommunicationServiceRepository clientCommunicationServiceRepository, IConfigurationService configurationService, IIdentityKeyProvidersRegistry identityKeyProvidersRegistry, ISerializersFactory signatureSupportSerializersFactory, INodesDataService nodesDataService, ISigningService cryptoService, IPerformanceCountersRepository performanceCountersRepository, IStatesRepository statesRepository, IHashCalculationsRepository hashCalculationRepository)
: base(loggerService, clientCommunicationServiceRepository, configurationService, identityKeyProvidersRegistry, signatureSupportSerializersFactory, nodesDataService, cryptoService, performanceCountersRepository, hashCalculationRepository)
{
_synchronizationContext = statesRepository.GetInstance <ISynchronizationContext>();
}