private async Task <IssueAssociatedBlindedAsset> IssueAssociatedAttribute(string schemeName, string content, byte[] blindingPointValue, byte[] blindingPointRoot, string issuer, IStateTransactionsService transactionsService) { byte[] assetId = await _assetsService.GenerateAssetId(schemeName, content, issuer).ConfigureAwait(false); byte[] groupId; if (AttributesSchemes.AttributeSchemes.FirstOrDefault(a => a.Name == schemeName)?.ValueType == AttributeValueType.Date) { groupId = await _identityAttributesService.GetGroupId(schemeName, DateTime.ParseExact(content, "yyyy-MM-dd", null), issuer).ConfigureAwait(false); } else { groupId = schemeName switch { AttributesSchemes.ATTR_SCHEME_NAME_PLACEOFBIRTH => await _identityAttributesService.GetGroupId(schemeName, content, issuer).ConfigureAwait(false), _ => await _identityAttributesService.GetGroupId(schemeName, issuer).ConfigureAwait(false), }; } return(transactionsService.IssueAssociatedAsset(assetId, groupId, blindingPointValue, blindingPointRoot, out byte[] originatingCommitment)); }
public ServiceProviderUpdater(ulong accountId, IStateClientCryptoService clientCryptoService, IAssetsService assetsService, IDataAccessService dataAccessService, IIdentityAttributesService identityAttributesService, IBlockParsersRepositoriesRepository blockParsersRepositoriesRepository, IGatewayService gatewayService, IStateTransactionsService transactionsService, IHubContext <IdentitiesHub> idenitiesHubContext, IAppConfig appConfig, ILoggerService loggerService) { _accountId = accountId; _clientCryptoService = clientCryptoService; _assetsService = assetsService; _dataAccessService = dataAccessService; _identityAttributesService = identityAttributesService; _blockParsersRepositoriesRepository = blockParsersRepositoriesRepository; _gatewayService = gatewayService; _transactionsService = transactionsService; _idenitiesHubContext = idenitiesHubContext; _appConfig = appConfig; _logger = loggerService.GetLogger(nameof(ServiceProviderUpdater)); PipeIn = new ActionBlock <PacketBase>(p => { if (p is DocumentSignRecord documentSignRecord) { ProcessDocumentSignRecord(documentSignRecord); } if (p is DocumentRecord documentRecord) { ProcessDocumentRecord(documentRecord); } if (p is DocumentSignRequest documentSignRequest) { ProcessDocumentSignRequest(documentSignRequest); } if (p is EmployeeRegistrationRequest employeeRegistrationRequest) { ProcessEmployeeRegistrationRequest(employeeRegistrationRequest); } if (p is OnboardingRequest packet) { ProcessOnboarding(packet); } if (p is TransitionAuthenticationProofs transitionAuthentication) { ProcessAuthentication(transitionAuthentication); } if (p is TransitionCompromisedProofs compromisedProofs) { ProcessCompromisedProofs(compromisedProofs); } if (p is TransferAsset transferAsset) { ProcessTransferAsset(transferAsset); } }); }
private IActionResult TransferAssetToUtxo(IStateTransactionsService transactionsService, ConfidentialAccount account, byte[] rootAssetId) { try { bool sent = transactionsService.TransferAssetToUtxo(rootAssetId, account); if (sent) { return(Ok()); } else { throw new Exception("Sending failed"); } } catch (Exception ex) { return(BadRequest(new { ex.Message })); } }
public void InitializeStateExecutionServices(ulong accountId, byte[] secretKey) { if (_statePersistencyItems.ContainsKey(accountId)) { return; } IPacketsProvider packetsProvider = ServiceLocator.Current.GetInstance <IPacketsProvider>(); IStateTransactionsService transactionsService = ServiceLocator.Current.GetInstance <StateTransactionsService>(); IStateClientCryptoService clientCryptoService = ServiceLocator.Current.GetInstance <StateClientCryptoService>(); IWalletSynchronizer walletSynchronizer = ServiceLocator.Current.GetInstance <StateWalletSynchronizer>(); CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(); packetsProvider.Initialize(accountId, cancellationTokenSource.Token); clientCryptoService.Initialize(secretKey); transactionsService.Initialize(clientCryptoService, _gatewayService.GetLastBlockHeight(ConfidentialAssetsHelper.GetPublicKey(secretKey))); transactionsService.PipeOutTransactions.LinkTo(_gatewayService.PipeInTransactions); ServiceProviderUpdater updater = new ServiceProviderUpdater(accountId, clientCryptoService, _assetsService, _dataAccessService, _identityAttributesService, _blockParsersRepositoriesRepository, _gatewayService, transactionsService, _identitiesHubContext, _appConfig, _loggerService); walletSynchronizer.Initialize(accountId, clientCryptoService, _gatewayService, cancellationTokenSource.Token); packetsProvider.PipeOut.LinkTo(walletSynchronizer.PipeIn); walletSynchronizer.PipeOut.LinkTo(updater.PipeIn); walletSynchronizer.Start(); packetsProvider.Start(); var state = new StatePersistency { AccountId = accountId, PacketsProvider = packetsProvider, TransactionsService = transactionsService, ClientCryptoService = clientCryptoService, WalletSynchronizer = walletSynchronizer, CancellationTokenSource = cancellationTokenSource }; _statePersistencyItems.Add(accountId, state); }
private void ProcessIssuingAssociatedAttribute(IdentityAttribute identityAttribute, byte[] blindingPoint, byte[] rootAssetId, IStateTransactionsService transactionsService) { byte[] assetId = _assetsService.GenerateAssetId(identityAttribute.AttributeType, identityAttribute.Content); byte[] groupId = null; switch (identityAttribute.AttributeType) { case AttributeType.PlaceOfBirth: groupId = _identityAttributesService.GetGroupId(identityAttribute.AttributeType, identityAttribute.Content); break; case AttributeType.DateOfBirth: groupId = _identityAttributesService.GetGroupId(identityAttribute.AttributeType, DateTime.ParseExact(identityAttribute.Content, "yyyy-MM-dd", null)); break; default: groupId = _identityAttributesService.GetGroupId(identityAttribute.AttributeType); break; } transactionsService.IssueAssociatedAsset(assetId, groupId, blindingPoint, rootAssetId, out byte[] originatingCommitment); _externalDataAccessService.UpdateAssociatedIdentityAttributeCommitment(identityAttribute.AttributeId, originatingCommitment); }
private void ProcessIssuingAssociatedAttributes(IdentityRequestDto identityRequest, IStateTransactionsService transactionsService, byte[] rootAssetId, byte[] faceImage) { byte[] blindingPoint = identityRequest.BlindingPoint.HexStringToByteArray(); Identity identity = _externalDataAccessService.GetIdentityByRootAttribute(identityRequest.RootAttributeContent); if (identity != null) { foreach (var identityAttribute in identity.AssociatedAttributes) { ProcessIssuingAssociatedAttribute(identityAttribute, blindingPoint, rootAssetId, transactionsService); } } }
public ServiceProviderUpdater(long accountId, IStateClientCryptoService clientCryptoService, IAssetsService assetsService, ISchemeResolverService schemeResolverService, IDataAccessService dataAccessService, IIdentityAttributesService identityAttributesService, IBlockParsersRepositoriesRepository blockParsersRepositoriesRepository, IGatewayService gatewayService, IStateTransactionsService transactionsService, ISpValidationsService spValidationsService, IHubContext <IdentitiesHub> idenitiesHubContext, ILoggerService loggerService, IConsentManagementService consentManagementService, IUniversalProofsPool universalProofsPool, CancellationToken cancellationToken) { _accountId = accountId; _clientCryptoService = clientCryptoService; _assetsService = assetsService; _schemeResolverService = schemeResolverService; _dataAccessService = dataAccessService; _identityAttributesService = identityAttributesService; _blockParsersRepositoriesRepository = blockParsersRepositoriesRepository; _gatewayService = gatewayService; _transactionsService = transactionsService; _spValidationsService = spValidationsService; _idenitiesHubContext = idenitiesHubContext; _consentManagementService = consentManagementService; _universalProofsPool = universalProofsPool; _cancellationToken = cancellationToken; _logger = loggerService.GetLogger(nameof(ServiceProviderUpdater)); _cancellationToken.Register(() => { PipeIn?.Complete(); PipInNotifications?.Complete(); }); PipeIn = new ActionBlock <PacketBase>(async p => { if (p == null) { _logger.Error($"[{_accountId}]: Obtained NULL packet"); return; } _logger.Info($"[{_accountId}]: Obtained {p.GetType().Name} packet"); try { if (p is DocumentSignRecord documentSignRecord) { ProcessDocumentSignRecord(documentSignRecord); } if (p is DocumentRecord documentRecord) { ProcessDocumentRecord(documentRecord); } if (p is DocumentSignRequest documentSignRequest) { ProcessDocumentSignRequest(documentSignRequest); } if (p is EmployeeRegistrationRequest employeeRegistrationRequest) { ProcessEmployeeRegistrationRequest(employeeRegistrationRequest); } if (p is IdentityProofs packet) { await ProcessIdentityProofs(packet).ConfigureAwait(false); } if (p is TransitionCompromisedProofs compromisedProofs) { ProcessCompromisedProofs(new Key32(compromisedProofs.CompromisedKeyImage)); } if (p is TransferAsset transferAsset) { ProcessTransferAsset(transferAsset); } if (p is UniversalTransport universalTransport) { await ProcessUniversalTransport(universalTransport).ConfigureAwait(false); } } catch (Exception ex) { _logger.Error($"[{_accountId}]: Failed to process packet {p.GetType().Name}", ex); } }); }
public void InitializeStateExecutionServices(long accountId, byte[] secretKey, Func <long, IStateTransactionsService, IStateClientCryptoService, CancellationToken, IUpdater> updaterFactory = null) { lock (_statePersistencyItems) { if (_statePersistencyItems.ContainsKey(accountId)) { _logger.Info($"[{accountId}]: Account with id {accountId} already registered at StatePersistency"); return; } _logger.Info($"[{accountId}]: {nameof(InitializeStateExecutionServices)} for account with id {accountId}"); try { IWitnessPackagesProvider packetsProvider = _witnessPackagesProviderRepository.GetInstance(_restApiConfiguration.WitnessProviderName); IStateTransactionsService transactionsService = ActivatorUtilities.CreateInstance <StateTransactionsService>(_serviceProvider); IStateClientCryptoService clientCryptoService = ActivatorUtilities.CreateInstance <StateClientCryptoService>(_serviceProvider); IWalletSynchronizer walletSynchronizer = ActivatorUtilities.CreateInstance <StateWalletSynchronizer>(_serviceProvider); StatePacketsExtractor statePacketsExtractor = ActivatorUtilities.CreateInstance <StatePacketsExtractor>(_serviceProvider); CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(); packetsProvider.Initialize(accountId, cancellationTokenSource.Token); clientCryptoService.Initialize(secretKey); transactionsService.AccountId = accountId; ulong lastBlockHeight = AsyncUtil.RunSync(() => _gatewayService.GetLastBlockHeight(ConfidentialAssetsHelper.GetPublicKey(Ed25519.SecretKeyFromSeed(secretKey)))); transactionsService.Initialize(clientCryptoService, lastBlockHeight); transactionsService.PipeOutTransactions.LinkTo(_gatewayService.PipeInTransactions); statePacketsExtractor.Initialize(clientCryptoService); statePacketsExtractor.AccountId = accountId; IUpdater updater = updaterFactory != null?updaterFactory(accountId, transactionsService, clientCryptoService, cancellationTokenSource.Token) : CreateStateUpdater(accountId, transactionsService, clientCryptoService, cancellationTokenSource.Token); walletSynchronizer.Initialize(accountId, clientCryptoService); packetsProvider.PipeOut.LinkTo(statePacketsExtractor.PipeIn); statePacketsExtractor.PipeOutPackets.LinkTo(walletSynchronizer.PipeInPackets); statePacketsExtractor.PipeOutProcessed.LinkTo(walletSynchronizer.PipeInPackage); foreach (var externalUpdater in _externalUpdatersRepository.GetInstances()) { externalUpdater.Initialize(accountId); } walletSynchronizer.PipeOutPackets.LinkTo( new ActionBlock <PacketBase>(async p => { var tasks = new List <Task> { updater.PipeIn.SendAsync(p) }; foreach (var externalUpdater in _externalUpdatersRepository.GetInstances()) { tasks.Add(externalUpdater.PipeIn.SendAsync(p)); } await Task.WhenAll(tasks).ConfigureAwait(false); })); packetsProvider.Start(); var state = new StatePersistency { AccountId = accountId, PacketsProvider = packetsProvider, TransactionsService = transactionsService, PacketsExtractor = statePacketsExtractor, ClientCryptoService = clientCryptoService, WalletSynchronizer = walletSynchronizer, CancellationTokenSource = cancellationTokenSource }; _statePersistencyItems.Add(accountId, state); } catch (Exception ex) { _logger.Error($"[{accountId}]: Failure during {nameof(InitializeStateExecutionServices)} for account with id {accountId}", ex); throw; } } }
private IUpdater CreateStateUpdater(long accountId, IStateTransactionsService transactionsService, IStateClientCryptoService clientCryptoService, CancellationToken cancellationToken) => new ServiceProviderUpdater(accountId, clientCryptoService, _assetsService, _schemeResolverService, _dataAccessService, _identityAttributesService, _blockParsersRepositoriesRepository, _gatewayService, transactionsService, _spValidationsService, _identitiesHubContext, _loggerService, _consentManagementService, _universalProofsPool, _serviceProvider.GetService <IElectionCommitteeService>(), cancellationToken);
private async Task <IEnumerable <IssuanceDetailsDto.IssuanceDetailsAssociated> > IssueAssociatedAttributes(Dictionary <long, AttributeIssuanceDetails> attributes, IStateTransactionsService transactionsService, string issuer, byte[] rootAssetId = null) { List <IssuanceDetailsDto.IssuanceDetailsAssociated> issuanceDetails = new List <IssuanceDetailsDto.IssuanceDetailsAssociated>(); if (attributes.Any(kv => kv.Value.Definition.IsRoot)) { var rootKv = attributes.FirstOrDefault(kv => kv.Value.Definition.IsRoot); var packet = await IssueAssociatedAttribute(rootKv.Value.Definition.SchemeName, rootKv.Value.Value.Value, rootKv.Value.Value.BlindingPointValue, rootKv.Value.Value.BlindingPointRoot, issuer, transactionsService).ConfigureAwait(false); _dataAccessService.UpdateIdentityAttributeCommitment(rootKv.Key, packet.AssetCommitment); issuanceDetails.Add(new IssuanceDetailsDto.IssuanceDetailsAssociated { AttributeName = rootKv.Value.Definition.AttributeName, AssetCommitment = packet.AssetCommitment.ToHexString(), BindingToRootCommitment = packet.RootAssetCommitment.ToHexString() }); rootAssetId = _assetsService.GenerateAssetId(rootKv.Value.Definition.SchemeId, rootKv.Value.Value.Value); } if (rootAssetId == null) { throw new ArgumentException("Either rootAssetId must be provided outside or one of attributes must be root one"); } foreach (var kv in attributes.Where(a => !a.Value.Definition.IsRoot)) { byte[] rootCommitment = _assetsService.GetCommitmentBlindedByPoint(rootAssetId, kv.Value.Value.BlindingPointRoot); var packet = await IssueAssociatedAttribute(kv.Value.Definition.SchemeName, kv.Value.Value.Value, kv.Value.Value.BlindingPointValue, rootCommitment, issuer, transactionsService).ConfigureAwait(false); issuanceDetails.Add(new IssuanceDetailsDto.IssuanceDetailsAssociated { AttributeName = kv.Value.Definition.AttributeName, AssetCommitment = packet.AssetCommitment.ToHexString(), BindingToRootCommitment = packet.RootAssetCommitment.ToHexString() }); _dataAccessService.UpdateIdentityAttributeCommitment(kv.Key, packet.AssetCommitment); } return(issuanceDetails); }