public UserIdentitiesUpdater(ulong accountId, IUtxoClientCryptoService clientCryptoService, IAssetsService assetsService, IDataAccessService externalDataAccessService, IHubContext <IdentitiesHub> idenitiesHubContext, IRelationsProofsValidationService relationsProofsValidationService, ITrackingService trackingService)
{
_accountId = accountId;
_clientCryptoService = clientCryptoService;
_assetsService = assetsService;
_dataAccessService = externalDataAccessService;
_idenitiesHubContext = idenitiesHubContext;
_relationsProofsValidationService = relationsProofsValidationService;
_trackingService = trackingService;
PipeIn = new ActionBlock <PacketBase>(p =>
{
try
{
if (p is TransferAssetToUtxo packet)
{
_clientCryptoService.DecodeEcdhTuple(packet.TransferredAsset.EcdhTuple, packet.TransactionPublicKey, out byte[] blindingFactor, out byte[] assetId);
AttributeType attributeType = _assetsService.GetAttributeType(assetId);
_idenitiesHubContext.Clients.Group(_accountId.ToString(CultureInfo.InvariantCulture)).SendAsync("PushAttribute", new UserAttributeDto {
AttributeType = attributeType.ToString(), Source = packet.Signer.ArraySegment.Array.ToHexString(), AssetId = assetId.ToHexString(), OriginalBlindingFactor = blindingFactor.ToHexString(), OriginalCommitment = packet.TransferredAsset.AssetCommitment.ToHexString(), LastBlindingFactor = blindingFactor.ToHexString(), LastCommitment = packet.TransferredAsset.AssetCommitment.ToHexString(), LastTransactionKey = packet.TransactionPublicKey.ToHexString(), LastDestinationKey = packet.DestinationKey.ToHexString(), Validated = false, IsOverriden = false
});
}
else if (p is GroupsRelationsProofs relationsProofs && _clientCryptoService.CheckTarget(relationsProofs.DestinationKey2, relationsProofs.TransactionPublicKey))
{
RelationProofsValidationResults validationResults = _relationsProofsValidationService.VerifyRelationProofs(relationsProofs, _clientCryptoService);
_idenitiesHubContext.Clients.Group(_accountId.ToString(CultureInfo.InvariantCulture)).SendAsync("PushRelationValidation", validationResults);
}
}
catch
{
}
});
}
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 ExecutionContextManager(IHubContext <IdentitiesHub> identitiesHubContext, IAssetsService assetsService, IDataAccessService dataAccessService, IIdentityAttributesService identityAttributesService, IBlockParsersRepositoriesRepository blockParsersRepositoriesRepository, IAppConfig appConfig, IGatewayService gatewayService, ITrackingService trackingService, ILoggerService loggerService, IRelationsProofsValidationService relationsProofsValidationService)
{
_accountIdCancellationList = new Dictionary <ulong, ICollection <IDisposable> >();
_identitiesHubContext = identitiesHubContext;
_assetsService = assetsService;
_dataAccessService = dataAccessService;
_identityAttributesService = identityAttributesService;
_blockParsersRepositoriesRepository = blockParsersRepositoriesRepository;
_appConfig = appConfig;
_gatewayService = gatewayService;
_trackingService = trackingService;
_loggerService = loggerService;
_relationsProofsValidationService = relationsProofsValidationService;
}
public ExecutionContextManager(IServiceProvider serviceProvider,
IHubContext <IdentitiesHub> identitiesHubContext,
IAssetsService assetsService,
IDataAccessService dataAccessService,
IIdentityAttributesService identityAttributesService,
IWitnessPackagesProviderRepository witnessPackagesProviderRepository,
IBlockParsersRepositoriesRepository blockParsersRepositoriesRepository,
IConfigurationService configurationService,
IGatewayService gatewayService,
ITrackingService trackingService,
ILoggerService loggerService,
ISpValidationsService spValidationsService,
IRelationsProofsValidationService relationsProofsValidationService,
ISchemeResolverService schemeResolverService,
IUniversalProofsPool universalProofsPool,
IExternalUpdatersRepository externalUpdatersRepository,
IConsentManagementService consentManagementService)
{
_accountIdCancellationList = new Dictionary <long, ICollection <IDisposable> >();
_serviceProvider = serviceProvider;
_identitiesHubContext = identitiesHubContext;
_assetsService = assetsService;
_dataAccessService = dataAccessService;
_identityAttributesService = identityAttributesService;
_witnessPackagesProviderRepository = witnessPackagesProviderRepository;
_blockParsersRepositoriesRepository = blockParsersRepositoriesRepository;
_gatewayService = gatewayService;
_trackingService = trackingService;
_loggerService = loggerService;
_spValidationsService = spValidationsService;
_logger = loggerService.GetLogger(nameof(ExecutionContextManager));
_relationsProofsValidationService = relationsProofsValidationService;
_schemeResolverService = schemeResolverService;
_universalProofsPool = universalProofsPool;
_externalUpdatersRepository = externalUpdatersRepository;
_consentManagementService = consentManagementService;
_restApiConfiguration = configurationService.Get <IRestApiConfiguration>();
}
public UserIdentitiesUpdater(long accountId, IUtxoClientCryptoService clientCryptoService,
IAssetsService assetsService, IDataAccessService dataAccessService,
IHubContext <IdentitiesHub> idenitiesHubContext, IRelationsProofsValidationService relationsProofsValidationService,
ISchemeResolverService schemeResolverService, ILoggerService loggerService, CancellationToken cancellationToken)
{
_accountId = accountId;
_clientCryptoService = clientCryptoService;
_assetsService = assetsService;
_dataAccessService = dataAccessService;
_idenitiesHubContext = idenitiesHubContext;
_relationsProofsValidationService = relationsProofsValidationService;
_schemeResolverService = schemeResolverService;
_cancellationToken = cancellationToken;
_cancellationToken.Register(() =>
{
PipeIn?.Complete();
PipInNotifications?.Complete();
});
_logger = loggerService.GetLogger(nameof(UserIdentitiesUpdater));
PipeIn = new ActionBlock <PacketBase>(async p =>
{
try
{
if (p is TransferAssetToUtxo packet)
{
_logger.LogIfDebug(() => $"[{_accountId}]: Processing {nameof(TransferAssetToUtxo)}");
UserRootAttribute userRootAttribute = _dataAccessService.GetRootAttributeByOriginalCommitment(_accountId, packet.TransferredAsset.AssetCommitment);
if (userRootAttribute != null)
{
_clientCryptoService.DecodeEcdhTuple(packet.TransferredAsset.EcdhTuple, packet.TransactionPublicKey, out byte[] blindingFactor, out byte[] assetId);
await _assetsService.GetAttributeSchemeName(assetId, packet.Signer.ToString()).ContinueWith(t =>
{
if (t.IsCompleted && !t.IsFaulted)
{
_idenitiesHubContext.Clients.Group(_accountId.ToString(CultureInfo.InvariantCulture))
.SendAsync("PushAttribute",
new UserAttributeDto
{
SchemeName = t.Result,
Source = packet.Signer.ToString(),
Content = userRootAttribute.Content,
Validated = true,
IsOverriden = false
});
}
}, TaskScheduler.Current).ConfigureAwait(false);
await ObtainRelations(packet, assetId).ConfigureAwait(false);
await ObtainRegistrations(packet, assetId).ConfigureAwait(false);
}
else
{
_logger.Error($"[{_accountId}]: No Root Attribute found by commitment {packet.TransferredAsset.AssetCommitment.ToHexString()}");
}
}
}
catch (Exception ex)
{
_logger.Error($"Failure during processing {nameof(PipeIn)}, packet {p?.GetType().Name}", ex);
}
});
PipInNotifications = new ActionBlock <SynchronizerNotificationBase>(n =>
{
try
{
_logger.LogIfDebug(() => $"[{_accountId}]: notification {n.GetType().Name} {JsonConvert.SerializeObject(n, new ByteArrayJsonConverter())}");
ProcessEligibilityCommitmentsDisabled(n);
NotifyUserAttributeLastUpdate(n);
NotifyCompromisedKeyImage(n);
}
catch (Exception ex)
{
_logger.Error($"Failure during processing {nameof(PipInNotifications)}, notification {n?.GetType().Name}", ex);
}
});
}
