public AuthKeyNegotiator(
[NotNull] IClientTransportConfig clientTransportConfig,
[NotNull] IMTProtoClientBuilder mtProtoBuilder,
[NotNull] TLRig tlRig,
[NotNull] INonceGenerator nonceGenerator,
[NotNull] IHashServices hashServices,
[NotNull] IEncryptionServices encryptionServices,
[NotNull] IKeyChain keyChain)
{
Argument.IsNotNull(() => clientTransportConfig);
Argument.IsNotNull(() => mtProtoBuilder);
Argument.IsNotNull(() => tlRig);
Argument.IsNotNull(() => nonceGenerator);
Argument.IsNotNull(() => hashServices);
Argument.IsNotNull(() => encryptionServices);
Argument.IsNotNull(() => keyChain);
_clientTransportConfig = clientTransportConfig;
_mtProtoBuilder = mtProtoBuilder;
_tlRig = tlRig;
_nonceGenerator = nonceGenerator;
_hashServices = hashServices;
_encryptionServices = encryptionServices;
_keyChain = keyChain;
}
CreateRoundWithOutputsReadyToSignAsync(Arena arena, IKeyChain keyChain, SmartCoin coin1, SmartCoin coin2)
{
// Create the round.
await arena.TriggerAndWaitRoundAsync(TimeSpan.FromSeconds(21));
var round = Assert.Single(arena.Rounds);
round.MaxVsizeAllocationPerAlice = 11 + 31 + MultipartyTransactionParameters.SharedOverhead;
var arenaClient = WabiSabiFactory.CreateArenaClient(arena);
// Register Alices.
using RoundStateUpdater roundStateUpdater = new(TimeSpan.FromSeconds(2), arena);
await roundStateUpdater.StartAsync(CancellationToken.None);
var task1 = AliceClient.CreateRegisterAndConfirmInputAsync(RoundState.FromRound(round), arenaClient, coin1, keyChain, roundStateUpdater, CancellationToken.None);
var task2 = AliceClient.CreateRegisterAndConfirmInputAsync(RoundState.FromRound(round), arenaClient, coin2, keyChain, roundStateUpdater, CancellationToken.None);
while (Phase.OutputRegistration != round.Phase)
{
await arena.TriggerAndWaitRoundAsync(TimeSpan.FromSeconds(21));
}
await Task.WhenAll(task1, task2);
var aliceClient1 = task1.Result;
var aliceClient2 = task2.Result;
// Register outputs.
var bobClient = new BobClient(round.Id, arenaClient);
using var destKey1 = new Key();
using var destKey2 = new Key();
await bobClient.RegisterOutputAsync(
destKey1.PubKey.WitHash.ScriptPubKey,
aliceClient1.IssuedAmountCredentials.Take(ProtocolConstants.CredentialNumber),
aliceClient1.IssuedVsizeCredentials.Take(ProtocolConstants.CredentialNumber),
CancellationToken.None).ConfigureAwait(false);
await bobClient.RegisterOutputAsync(
destKey1.PubKey.WitHash.ScriptPubKey,
aliceClient2.IssuedAmountCredentials.Take(ProtocolConstants.CredentialNumber),
aliceClient2.IssuedVsizeCredentials.Take(ProtocolConstants.CredentialNumber),
CancellationToken.None).ConfigureAwait(false);
await roundStateUpdater.StopAsync(CancellationToken.None);
return(round, aliceClient1, aliceClient2);
}
public AuthKeyNegotiator(
[NotNull] IClientTransportConfig clientTransportConfig,
[NotNull] IMTProtoClientBuilder mtProtoBuilder,
[NotNull] TLRig tlRig,
[NotNull] INonceGenerator nonceGenerator,
[NotNull] IHashServices hashServices,
[NotNull] IEncryptionServices encryptionServices,
[NotNull] IKeyChain keyChain)
{
_clientTransportConfig = clientTransportConfig;
_mtProtoBuilder = mtProtoBuilder;
_tlRig = tlRig;
_nonceGenerator = nonceGenerator;
_hashServices = hashServices;
_encryptionServices = encryptionServices;
_keyChain = keyChain;
}
/// <param name="minAnonScoreTarget">Coins those have reached anonymity target, but still can be mixed if desired.</param>
/// <param name="consolidationMode">If true, then aggressively try to consolidate as many coins as it can.</param>
public CoinJoinClient(
IWasabiHttpClientFactory httpClientFactory,
IKeyChain keyChain,
IDestinationProvider destinationProvider,
RoundStateUpdater roundStatusUpdater,
int minAnonScoreTarget = int.MaxValue,
bool consolidationMode = false,
TimeSpan doNotRegisterInLastMinuteTimeLimit = default)
{
HttpClientFactory = httpClientFactory;
KeyChain = keyChain;
DestinationProvider = destinationProvider;
RoundStatusUpdater = roundStatusUpdater;
MinAnonScoreTarget = minAnonScoreTarget;
ConsolidationMode = consolidationMode;
SecureRandom = new SecureRandom();
DoNotRegisterInLastMinuteTimeLimit = doNotRegisterInLastMinuteTimeLimit;
}
public MTProtoClientBuilder(
[NotNull] IClientTransportFactory clientTransportFactory,
[NotNull] TLRig tlRig,
[NotNull] IMessageIdGenerator messageIdGenerator,
[NotNull] IMessageCodec messageCodec,
[NotNull] IHashServices hashServices,
[NotNull] IEncryptionServices encryptionServices,
[NotNull] INonceGenerator nonceGenerator,
[NotNull] IKeyChain keyChain)
{
_clientTransportFactory = clientTransportFactory;
_tlRig = tlRig;
_messageIdGenerator = messageIdGenerator;
_messageCodec = messageCodec;
_hashServices = hashServices;
_encryptionServices = encryptionServices;
_nonceGenerator = nonceGenerator;
_keyChain = keyChain;
}
public MTProtoClientBuilder(
[NotNull] IClientTransportFactory clientTransportFactory,
[NotNull] TLRig tlRig,
[NotNull] IMessageIdGenerator messageIdGenerator,
[NotNull] IMessageCodec messageCodec,
[NotNull] IHashServices hashServices,
[NotNull] IEncryptionServices encryptionServices,
[NotNull] INonceGenerator nonceGenerator,
[NotNull] IKeyChain keyChain)
{
_clientTransportFactory = clientTransportFactory;
_tlRig = tlRig;
_messageIdGenerator = messageIdGenerator;
_messageCodec = messageCodec;
_hashServices = hashServices;
_encryptionServices = encryptionServices;
_nonceGenerator = nonceGenerator;
_keyChain = keyChain;
}
public AuthKeyNegotiator([NotNull] IMTProtoConnectionFactory connectionFactory, [NotNull] TLRig tlRig, [NotNull] INonceGenerator nonceGenerator,
[NotNull] IHashServices hashServices, [NotNull] IEncryptionServices encryptionServices, [NotNull] IKeyChain keyChain,
[NotNull] ITransportConfigProvider transportConfigProvider)
{
Argument.IsNotNull(() => connectionFactory);
Argument.IsNotNull(() => tlRig);
Argument.IsNotNull(() => nonceGenerator);
Argument.IsNotNull(() => hashServices);
Argument.IsNotNull(() => encryptionServices);
Argument.IsNotNull(() => keyChain);
Argument.IsNotNull(() => transportConfigProvider);
_connectionFactory = connectionFactory;
_tlRig = tlRig;
_nonceGenerator = nonceGenerator;
_hashServices = hashServices;
_encryptionServices = encryptionServices;
_keyChain = keyChain;
_transportConfigProvider = transportConfigProvider;
}
public static async Task <AliceClient> CreateRegisterAndConfirmInputAsync(
RoundState roundState,
ArenaClient arenaClient,
SmartCoin coin,
IKeyChain keyChain,
RoundStateUpdater roundStatusUpdater,
CancellationToken cancellationToken)
{
AliceClient?aliceClient = null;
try
{
aliceClient = await RegisterInputAsync(roundState, arenaClient, coin, keyChain, cancellationToken).ConfigureAwait(false);
await aliceClient.ConfirmConnectionAsync(roundStatusUpdater, cancellationToken).ConfigureAwait(false);
Logger.LogInfo($"Round ({aliceClient.RoundId}), Alice ({aliceClient.AliceId}): Connection was confirmed.");
}
catch (OperationCanceledException)
{
if (aliceClient is { })
CreateRoundWithTwoConfirmedConnectionsAsync(Arena arena, IKeyChain keyChain, SmartCoin coin1, SmartCoin coin2)
{
// Get the round.
await arena.TriggerAndWaitRoundAsync(TimeSpan.FromSeconds(21));
var arenaClient = WabiSabiFactory.CreateArenaClient(arena);
var round = Assert.Single(arena.Rounds);
// Refresh the Arena States because of vsize manipulation.
await arena.TriggerAndWaitRoundAsync(TimeSpan.FromSeconds(21));
using RoundStateUpdater roundStateUpdater = new(TimeSpan.FromSeconds(2), arena);
await roundStateUpdater.StartAsync(CancellationToken.None);
var task1 = AliceClient.CreateRegisterAndConfirmInputAsync(RoundState.FromRound(round), arenaClient, coin1, keyChain, roundStateUpdater, CancellationToken.None);
var task2 = AliceClient.CreateRegisterAndConfirmInputAsync(RoundState.FromRound(round), arenaClient, coin2, keyChain, roundStateUpdater, CancellationToken.None);
while (Phase.ConnectionConfirmation != round.Phase)
{
await arena.TriggerAndWaitRoundAsync(TimeSpan.FromSeconds(21));
}
await Task.WhenAll(task1, task2);
var aliceClient1 = await task1;
var aliceClient2 = await task2;
await arena.TriggerAndWaitRoundAsync(TimeSpan.FromSeconds(21));
Assert.Equal(Phase.OutputRegistration, round.Phase);
await roundStateUpdater.StopAsync(CancellationToken.None);
return(round,
arenaClient,
new[]
{
aliceClient1,
aliceClient2
});
}
CreateRoundWithTwoConfirmedConnectionsAsync(Arena arena, IKeyChain keyChain, SmartCoin coin1, SmartCoin coin2)
{
// Create the round.
await arena.TriggerAndWaitRoundAsync(TimeSpan.FromSeconds(21));
var arenaClient = WabiSabiFactory.CreateArenaClient(arena);
var round = Assert.Single(arena.Rounds);
round.MaxVsizeAllocationPerAlice = 11 + 31 + MultipartyTransactionParameters.SharedOverhead;
using RoundStateUpdater roundStateUpdater = new(TimeSpan.FromSeconds(2), arena);
await roundStateUpdater.StartAsync(CancellationToken.None);
var task1 = AliceClient.CreateRegisterAndConfirmInputAsync(RoundState.FromRound(round), arenaClient, coin1, keyChain, roundStateUpdater, CancellationToken.None);
var task2 = AliceClient.CreateRegisterAndConfirmInputAsync(RoundState.FromRound(round), arenaClient, coin2, keyChain, roundStateUpdater, CancellationToken.None);
while (Phase.ConnectionConfirmation != round.Phase)
{
await arena.TriggerAndWaitRoundAsync(TimeSpan.FromSeconds(21));
}
await Task.WhenAll(task1, task2);
var aliceClient1 = task1.Result;
var aliceClient2 = task2.Result;
await arena.TriggerAndWaitRoundAsync(TimeSpan.FromSeconds(21));
Assert.Equal(Phase.OutputRegistration, round.Phase);
await roundStateUpdater.StopAsync(CancellationToken.None);
return(round,
arenaClient,
new[]
{
aliceClient1,
aliceClient2
});
}
public async Task StartOutputRegistrationsAsync(IEnumerable <TxOut> txOuts, BobClient bobClient, IKeyChain keyChain, ImmutableList <DateTimeOffset> outputRegistrationScheduledDates, CancellationToken cancellationToken)
{
using CancellationTokenSource ctsOnError = new();
using CancellationTokenSource linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, ctsOnError.Token);
var nodes = Graph.Outputs.Select(node =>
{
var amountCredsToPresentTasks = Graph.InEdges(node, CredentialType.Amount).Select(edge => DependencyTasks[edge].Task);
var vsizeCredsToPresentTasks = Graph.InEdges(node, CredentialType.Vsize).Select(edge => DependencyTasks[edge].Task);
SmartRequestNode smartRequestNode = new(
amountCredsToPresentTasks,
vsizeCredsToPresentTasks,
Array.Empty <TaskCompletionSource <Credential> >(),
Array.Empty <TaskCompletionSource <Credential> >());
return(smartRequestNode);
});
var tasks = txOuts.Zip(nodes, outputRegistrationScheduledDates,
async(txOut, smartRequestNode, scheduledDate) =>
{
try
{
var delay = scheduledDate - DateTimeOffset.UtcNow;
if (delay > TimeSpan.Zero)
{
await Task.Delay(delay, cancellationToken).ConfigureAwait(false);
}
await smartRequestNode.StartOutputRegistrationAsync(bobClient, txOut.ScriptPubKey, cancellationToken).ConfigureAwait(false);
}
catch (WabiSabiProtocolException ex) when(ex.ErrorCode == WabiSabiProtocolErrorCode.AlreadyRegisteredScript)
{
Logger.LogDebug($"Output registration error, code:'{ex.ErrorCode}' message:'{ex.Message}'.");
if (keyChain is KeyChain {
KeyManager: var keyManager
} &&
keyManager.TryGetKeyForScriptPubKey(txOut.ScriptPubKey, out var hdPubKey))
{
hdPubKey.SetKeyState(KeyState.Used);
}
}
public OwnerAuthService(IUserController userController, IKeyChain keyChain) : base(userController, keyChain)
{
}
/// <summary>Initializes a new instance of the <see cref="LoginService"/> class.</summary>
public BaseAuthService(IUserController userController, IKeyChain keyChain)
{
this._userController = userController;
this._keyChain = keyChain;
}
