public async Task AliceTimesoutAsync()
{
// Alice times out when its deadline is reached.
WabiSabiConfig cfg = new();
var round = WabiSabiFactory.CreateRound(cfg);
using Key key = new();
var coin = WabiSabiFactory.CreateCoin(key);
var rpc = WabiSabiFactory.CreatePreconfiguredRpcClient(coin);
using Arena arena = await WabiSabiFactory.CreateAndStartArenaAsync(cfg, rpc, round);
var arenaClient = WabiSabiFactory.CreateArenaClient(arena);
// Register Alices.
var minAliceDeadline = DateTimeOffset.UtcNow + cfg.ConnectionConfirmationTimeout * 0.9;
var aliceClient = new AliceClient(round.Id, arenaClient, coin, round.FeeRate, key.GetBitcoinSecret(round.Network));
await aliceClient.RegisterInputAsync(CancellationToken.None).ConfigureAwait(false);
var alice = Assert.Single(round.Alices);
alice.Deadline = DateTimeOffset.UtcNow - TimeSpan.FromMilliseconds(1);
await arena.TriggerAndWaitRoundAsync(TimeSpan.FromSeconds(21));
Assert.Empty(round.Alices);
await arena.StopAsync(CancellationToken.None);
}
public async Task InputRegistrationTimedoutAsync()
{
WabiSabiConfig cfg = new() { StandardInputRegistrationTimeout = TimeSpan.Zero };
var round = WabiSabiFactory.CreateRound(cfg);
using Key key = new();
var ownershipProof = WabiSabiFactory.CreateOwnershipProof(key, round.Id);
var coin = WabiSabiFactory.CreateCoin(key);
var rpc = WabiSabiFactory.CreatePreconfiguredRpcClient(coin);
using Arena arena = await ArenaBuilder.From(cfg).With(rpc).CreateAndStartAsync();
await arena.TriggerAndWaitRoundAsync(TimeSpan.FromSeconds(21));
arena.Rounds.Add(round);
var arenaClient = WabiSabiFactory.CreateArenaClient(arena);
var ex = await Assert.ThrowsAsync <WrongPhaseException>(
async() => await arenaClient.RegisterInputAsync(round.Id, coin.Outpoint, ownershipProof, CancellationToken.None));
Assert.Equal(WabiSabiProtocolErrorCode.WrongPhase, ex.ErrorCode);
Assert.Equal(Phase.InputRegistration, round.Phase);
await arena.StopAsync(CancellationToken.None);
}
public async Task SuccessWithAliceUpdateIntraRoundAsync()
{
WabiSabiConfig cfg = new();
var round = WabiSabiFactory.CreateRound(cfg);
using Key key = new();
var ownershipProof = WabiSabiFactory.CreateOwnershipProof(key, round.Id);
var coin = WabiSabiFactory.CreateCoin(key);
// Make sure an Alice have already been registered with the same input.
var preAlice = WabiSabiFactory.CreateAlice(coin, WabiSabiFactory.CreateOwnershipProof(key), round);
round.Alices.Add(preAlice);
var rpc = WabiSabiFactory.CreatePreconfiguredRpcClient(coin);
using Arena arena = await ArenaBuilder.From(cfg).With(rpc).CreateAndStartAsync(round);
var arenaClient = WabiSabiFactory.CreateArenaClient(arena);
var ex = await Assert.ThrowsAsync <WabiSabiProtocolException>(async() => await arenaClient.RegisterInputAsync(round.Id, coin.Outpoint, ownershipProof, CancellationToken.None).ConfigureAwait(false));
Assert.Equal(WabiSabiProtocolErrorCode.AliceAlreadyRegistered, ex.ErrorCode);
await arena.StopAsync(CancellationToken.None);
}
public async Task InputRegistrationTimeoutCanBeModifiedRuntimeAsync()
{
WabiSabiConfig cfg = new() { StandardInputRegistrationTimeout = TimeSpan.FromHours(1) };
using Key key = new();
var coin = WabiSabiFactory.CreateCoin(key);
using Arena arena = await WabiSabiFactory.CreateAndStartArenaAsync(cfg, WabiSabiFactory.CreatePreconfiguredRpcClient(coin));
await arena.TriggerAndWaitRoundAsync(TimeSpan.FromSeconds(21));
var round = arena.Rounds.First();
var ownershipProof = WabiSabiFactory.CreateOwnershipProof(key, round.Id);
round.InputRegistrationTimeFrame = round.InputRegistrationTimeFrame with {
Duration = TimeSpan.Zero
};
var arenaClient = WabiSabiFactory.CreateArenaClient(arena);
var ex = await Assert.ThrowsAsync <WabiSabiProtocolException>(
async() => await arenaClient.RegisterInputAsync(round.Id, coin.Outpoint, ownershipProof, CancellationToken.None));
Assert.Equal(WabiSabiProtocolErrorCode.WrongPhase, ex.ErrorCode);
Assert.Equal(Phase.InputRegistration, round.Phase);
await arena.StopAsync(CancellationToken.None);
}
public async Task SuccessFromPreviousCoinJoinAsync()
{
WabiSabiConfig cfg = new();
var round = WabiSabiFactory.CreateRound(cfg);
using Key key = new();
var coin = WabiSabiFactory.CreateCoin(key);
var rpc = WabiSabiFactory.CreatePreconfiguredRpcClient(coin);
var coinJoinIdsStore = new InMemoryCoinJoinIdStore();
coinJoinIdsStore.Add(coin.Outpoint.Hash);
using Arena arena = await ArenaBuilder.From(cfg).With(rpc).With(coinJoinIdsStore).CreateAndStartAsync(round);
var minAliceDeadline = DateTimeOffset.UtcNow + cfg.ConnectionConfirmationTimeout * 0.9;
var arenaClient = WabiSabiFactory.CreateArenaClient(arena);
var ownershipProof = WabiSabiFactory.CreateOwnershipProof(key, round.Id);
var(resp, _) = await arenaClient.RegisterInputAsync(round.Id, coin.Outpoint, ownershipProof, CancellationToken.None);
AssertSingleAliceSuccessfullyRegistered(round, minAliceDeadline, resp);
var myAlice = Assert.Single(round.Alices);
Assert.True(myAlice.IsPayingZeroCoordinationFee);
await arena.StopAsync(CancellationToken.None);
}
public async Task EveryoneSignedAsync()
{
WabiSabiConfig cfg = new()
{
MaxInputCountByRound = 2,
MinInputCountByRoundMultiplier = 0.5
};
using Key key1 = new();
using Key key2 = new();
var coin1 = WabiSabiFactory.CreateCoin(key1);
var coin2 = WabiSabiFactory.CreateCoin(key2);
var mockRpc = WabiSabiFactory.CreatePreconfiguredRpcClient(coin1, coin2);
using Arena arena = await WabiSabiFactory.CreateAndStartArenaAsync(cfg, mockRpc);
var(round, aliceClient1, aliceClient2) = await CreateRoundWithOutputsReadyToSignAsync(arena, key1, coin1, key2, coin2).ConfigureAwait(false);
await arena.TriggerAndWaitRoundAsync(TimeSpan.FromSeconds(21));
Assert.Equal(Phase.TransactionSigning, round.Phase);
var signedCoinJoin = round.Assert <SigningState>().CreateTransaction();
await aliceClient1.SignTransactionAsync(signedCoinJoin, CancellationToken.None);
await aliceClient2.SignTransactionAsync(signedCoinJoin, CancellationToken.None);
await arena.TriggerAndWaitRoundAsync(TimeSpan.FromSeconds(21));
Assert.Equal(Phase.TransactionBroadcasting, round.Phase);
await arena.StopAsync(CancellationToken.None);
}
public async Task AllBobsRegisteredAsync()
{
WabiSabiConfig cfg = new()
{
MaxInputCountByRound = 2,
MinInputCountByRoundMultiplier = 0.5
};
using Key key1 = new();
using Key key2 = new();
var coin1 = WabiSabiFactory.CreateCoin(key1);
var coin2 = WabiSabiFactory.CreateCoin(key2);
var mockRpc = WabiSabiFactory.CreatePreconfiguredRpcClient(coin1, coin2);
using Arena arena = await WabiSabiFactory.CreateAndStartArenaAsync(cfg, mockRpc);
var(round, arenaClient, alices) = await CreateRoundWithTwoConfirmedConnectionsAsync(arena, key1, coin1, key2, coin2);
var(amountCredentials1, vsizeCredentials1) = (alices[0].IssuedAmountCredentials, alices[0].IssuedVsizeCredentials);
var(amountCredentials2, vsizeCredentials2) = (alices[1].IssuedAmountCredentials, alices[1].IssuedVsizeCredentials);
// Register outputs.
var bobClient = new BobClient(round.Id, arenaClient);
using var destKey1 = new Key();
await bobClient.RegisterOutputAsync(
coin1.Amount - round.FeeRate.GetFee(coin1.ScriptPubKey.EstimateInputVsize()),
destKey1.PubKey.WitHash.ScriptPubKey,
amountCredentials1.Take(ProtocolConstants.CredentialNumber),
vsizeCredentials1.Take(ProtocolConstants.CredentialNumber),
CancellationToken.None);
using var destKey2 = new Key();
await bobClient.RegisterOutputAsync(
coin2.Amount - round.FeeRate.GetFee(coin2.ScriptPubKey.EstimateInputVsize()),
destKey2.PubKey.WitHash.ScriptPubKey,
amountCredentials2.Take(ProtocolConstants.CredentialNumber),
vsizeCredentials2.Take(ProtocolConstants.CredentialNumber),
CancellationToken.None);
foreach (var alice in alices)
{
await alice.ReadyToSignAsync(CancellationToken.None);
}
await arena.TriggerAndWaitRoundAsync(TimeSpan.FromSeconds(21));
Assert.Equal(Phase.TransactionSigning, round.Phase);
var tx = round.Assert <SigningState>().CreateTransaction();
Assert.Equal(2, tx.Inputs.Count);
Assert.Equal(2, tx.Outputs.Count);
await arena.StopAsync(CancellationToken.None);
}
public async Task AlicesSpentAsync()
{
WabiSabiConfig cfg = new()
{
MaxInputCountByRound = 2,
MinInputCountByRoundMultiplier = 0.5
};
using Key key1 = new();
using Key key2 = new();
var coin1 = WabiSabiFactory.CreateCoin(key1);
var coin2 = WabiSabiFactory.CreateCoin(key2);
var mockRpc = WabiSabiFactory.CreatePreconfiguredRpcClient(coin1, coin2);
mockRpc.Setup(rpc => rpc.SendRawTransactionAsync(It.IsAny <Transaction>()))
.ThrowsAsync(new RPCException(RPCErrorCode.RPC_TRANSACTION_REJECTED, "", null));
using Arena arena = await WabiSabiFactory.CreateAndStartArenaAsync(cfg, mockRpc);
var(round, aliceClient1, aliceClient2) = await CreateRoundWithOutputsReadyToSignAsync(arena, key1, coin1, key2, coin2);
await aliceClient1.ReadyToSignAsync(CancellationToken.None);
await aliceClient2.ReadyToSignAsync(CancellationToken.None);
await arena.TriggerAndWaitRoundAsync(TimeSpan.FromSeconds(21));
Assert.Equal(Phase.TransactionSigning, round.Phase);
var signedCoinJoin = round.Assert <SigningState>().CreateTransaction();
await aliceClient1.SignTransactionAsync(signedCoinJoin, CancellationToken.None);
await aliceClient2.SignTransactionAsync(signedCoinJoin, CancellationToken.None);
await arena.TriggerAndWaitRoundAsync(TimeSpan.FromSeconds(21));
Assert.DoesNotContain(round, arena.ActiveRounds);
Assert.Equal(Phase.Ended, round.Phase);
Assert.False(round.WasTransactionBroadcast);
// There should be no inmate, because we aren't punishing spenders with banning
// as there's no reason to ban already spent UTXOs,
// the cost of spending the UTXO is the punishment instead.
Assert.Empty(arena.Prison.GetInmates());
await arena.StopAsync(CancellationToken.None);
}
public async Task SomeBobsRegisteredTimeoutAsync()
{
WabiSabiConfig cfg = new()
{
MaxInputCountByRound = 2,
MinInputCountByRoundMultiplier = 0.5,
OutputRegistrationTimeout = TimeSpan.Zero
};
using Key key1 = new();
using Key key2 = new();
var coin1 = WabiSabiFactory.CreateCoin(key1);
var coin2 = WabiSabiFactory.CreateCoin(key2);
var mockRpc = WabiSabiFactory.CreatePreconfiguredRpcClient(coin1, coin2);
using Arena arena = await WabiSabiFactory.CreateAndStartArenaAsync(cfg, mockRpc).ConfigureAwait(false);
var(round, arenaClient, alices) = await CreateRoundWithTwoConfirmedConnectionsAsync(arena, key1, coin1, key2, coin2).ConfigureAwait(false);
var(realAmountCredentials1, realVsizeCredentials1) = alices[0];
var(realAmountCredentials2, realVsizeCredentials2) = alices[1];
// Register outputs.
var bobClient = new BobClient(round.Id, arenaClient);
using var destKey = new Key();
await bobClient.RegisterOutputAsync(
coin1.Amount - round.FeeRate.GetFee(coin1.ScriptPubKey.EstimateInputVsize()),
destKey.PubKey.WitHash.ScriptPubKey,
realAmountCredentials1,
realVsizeCredentials1,
CancellationToken.None).ConfigureAwait(false);
await arena.TriggerAndWaitRoundAsync(TimeSpan.FromSeconds(21));
Assert.Equal(Phase.TransactionSigning, round.Phase);
var tx = round.Assert <SigningState>().CreateTransaction();
Assert.Equal(2, tx.Inputs.Count);
Assert.Equal(2, tx.Outputs.Count);
Assert.Contains(cfg.BlameScript, tx.Outputs.Select(x => x.ScriptPubKey));
await arena.StopAsync(CancellationToken.None);
}
public async Task SuccessAsync()
{
WabiSabiConfig cfg = new();
var round = WabiSabiFactory.CreateRound(cfg);
using Key key = new();
var coin = WabiSabiFactory.CreateCoin(key);
using Arena arena = await WabiSabiFactory.CreateAndStartArenaAsync(cfg, WabiSabiFactory.CreatePreconfiguredRpcClient(coin), round);
var minAliceDeadline = DateTimeOffset.UtcNow + cfg.ConnectionConfirmationTimeout * 0.9;
var arenaClient = WabiSabiFactory.CreateArenaClient(arena);
var resp = await arenaClient.RegisterInputAsync(round.Id, coin.Outpoint, key, CancellationToken.None);
AssertSingleAliceSuccessfullyRegistered(round, minAliceDeadline, resp);
await arena.StopAsync(CancellationToken.None);
}
public async Task TimeoutInsufficientPeersAsync()
{
WabiSabiConfig cfg = new()
{
MaxInputCountByRound = 2,
MinInputCountByRoundMultiplier = 1,
TransactionSigningTimeout = TimeSpan.Zero
};
using Key key1 = new();
using Key key2 = new();
var coin1 = WabiSabiFactory.CreateCoin(key1);
var coin2 = WabiSabiFactory.CreateCoin(key2);
var mockRpc = WabiSabiFactory.CreatePreconfiguredRpcClient(coin1, coin2);
mockRpc.Setup(rpc => rpc.SendRawTransactionAsync(It.IsAny <Transaction>()))
.ThrowsAsync(new RPCException(RPCErrorCode.RPC_TRANSACTION_REJECTED, "", null));
using Arena arena = await WabiSabiFactory.CreateAndStartArenaAsync(cfg, mockRpc);
var(round, aliceClient1, aliceClient2) = await CreateRoundWithOutputsReadyToSignAsync(arena, key1, coin1, key2, coin2);
await aliceClient1.ReadyToSignAsync(CancellationToken.None);
await aliceClient2.ReadyToSignAsync(CancellationToken.None);
await arena.TriggerAndWaitRoundAsync(TimeSpan.FromSeconds(21));
Assert.Equal(Phase.TransactionSigning, round.Phase);
var signedCoinJoin = round.Assert <SigningState>().CreateTransaction();
await aliceClient1.SignTransactionAsync(signedCoinJoin, CancellationToken.None);
await arena.TriggerAndWaitRoundAsync(TimeSpan.FromSeconds(21));
Assert.DoesNotContain(round, arena.ActiveRounds);
Assert.Equal(Phase.Ended, round.Phase);
Assert.False(round.WasTransactionBroadcast);
Assert.Empty(arena.Rounds.Where(x => x.IsBlameRound));
Assert.Contains(aliceClient2.Coin.Outpoint, arena.Prison.GetInmates().Select(x => x.Utxo));
await arena.StopAsync(CancellationToken.None);
}
static Coin CreateCoin()
{
using var key = new Key();
return(WabiSabiFactory.CreateCoin(key));
}
public async Task TimeoutSufficientPeersAsync()
{
WabiSabiConfig cfg = new()
{
MaxInputCountByRound = 2,
MinInputCountByRoundMultiplier = 1,
TransactionSigningTimeout = TimeSpan.Zero,
OutputRegistrationTimeout = TimeSpan.Zero
};
using Key key1 = new();
using Key key2 = new();
var coin1 = WabiSabiFactory.CreateCoin(key1);
var coin2 = WabiSabiFactory.CreateCoin(key2);
var mockRpc = WabiSabiFactory.CreatePreconfiguredRpcClient(coin1, coin2);
mockRpc.Setup(rpc => rpc.SendRawTransactionAsync(It.IsAny <Transaction>()))
.ThrowsAsync(new RPCException(RPCErrorCode.RPC_TRANSACTION_REJECTED, "", null));
using Arena arena = await WabiSabiFactory.CreateAndStartArenaAsync(cfg, mockRpc);
var(round, aliceClient1, aliceClient2) = await CreateRoundWithOutputsReadyToSignAsync(arena, key1, coin1, key2, coin2);
// Make sure not all alices signed.
var alice3 = WabiSabiFactory.CreateAlice(round);
alice3.ConfirmedConnection = true;
round.Alices.Add(alice3);
round.CoinjoinState = round.Assert <ConstructionState>().AddInput(alice3.Coin);
await arena.TriggerAndWaitRoundAsync(TimeSpan.FromSeconds(21));
Assert.Equal(Phase.TransactionSigning, round.Phase);
var signedCoinJoin = round.Assert <SigningState>().CreateTransaction();
await aliceClient1.SignTransactionAsync(signedCoinJoin, CancellationToken.None);
await aliceClient2.SignTransactionAsync(signedCoinJoin, CancellationToken.None);
await arena.TriggerAndWaitRoundAsync(TimeSpan.FromSeconds(21));
Assert.DoesNotContain(round, arena.ActiveRounds);
Assert.Single(arena.Rounds.Where(x => x.IsBlameRound));
var badOutpoint = alice3.Coin.Outpoint;
Assert.Contains(badOutpoint, arena.Prison.GetInmates().Select(x => x.Utxo));
var blameRound = arena.Rounds.Single(x => x.IsBlameRound);
Assert.True(blameRound.IsBlameRound);
Assert.NotNull(blameRound.BlameOf);
Assert.Equal(round.Id, blameRound.BlameOf?.Id);
var whitelist = blameRound.BlameWhitelist;
Assert.Contains(aliceClient1.Coin.Outpoint, whitelist);
Assert.Contains(aliceClient2.Coin.Outpoint, whitelist);
Assert.DoesNotContain(badOutpoint, whitelist);
await arena.StopAsync(CancellationToken.None);
}
public async Task DiffTooSmallToBlameAsync()
{
WabiSabiConfig cfg = new()
{
MaxInputCountByRound = 2,
MinInputCountByRoundMultiplier = 0.5,
OutputRegistrationTimeout = TimeSpan.Zero
};
using Key key1 = new();
using Key key2 = new();
var coin1 = WabiSabiFactory.CreateCoin(key1);
var coin2 = WabiSabiFactory.CreateCoin(key2);
var mockRpc = WabiSabiFactory.CreatePreconfiguredRpcClient(coin1, coin2);
using Arena arena = await WabiSabiFactory.CreateAndStartArenaAsync(cfg, mockRpc);
var(round, arenaClient, alices) = await CreateRoundWithTwoConfirmedConnectionsAsync(arena, key1, coin1, key2, coin2);
var(amountCredentials1, vsizeCredentials1) = (alices[0].IssuedAmountCredentials, alices[0].IssuedVsizeCredentials);
var(amountCredentials2, vsizeCredentials2) = (alices[1].IssuedAmountCredentials, alices[1].IssuedVsizeCredentials);
// Register outputs.
var bobClient = new BobClient(round.Id, arenaClient);
using var destKey1 = new Key();
using var destKey2 = new Key();
await bobClient.RegisterOutputAsync(
coin1.Amount - round.FeeRate.GetFee(coin1.ScriptPubKey.EstimateInputVsize()),
destKey1.PubKey.WitHash.ScriptPubKey,
amountCredentials1.Take(ProtocolConstants.CredentialNumber),
vsizeCredentials1.Take(ProtocolConstants.CredentialNumber),
CancellationToken.None);
await bobClient.RegisterOutputAsync(
coin2.Amount - round.FeeRate.GetFee(coin2.ScriptPubKey.EstimateInputVsize()),
destKey2.PubKey.WitHash.ScriptPubKey,
amountCredentials2.Take(ProtocolConstants.CredentialNumber),
vsizeCredentials2.Take(ProtocolConstants.CredentialNumber),
CancellationToken.None);
// Add another input. The input must be able to pay for itself, but
// the remaining amount after deducting the fees needs to be less
// than the minimum.
var txParams = round.Assert <ConstructionState>().Parameters;
var extraAlice = WabiSabiFactory.CreateAlice(txParams.FeeRate.GetFee(Constants.P2wpkhInputVirtualSize) + txParams.AllowedOutputAmounts.Min - new Money(1L), round);
round.Alices.Add(extraAlice);
round.CoinjoinState = round.Assert <ConstructionState>().AddInput(extraAlice.Coin);
await arena.TriggerAndWaitRoundAsync(TimeSpan.FromSeconds(21));
Assert.Equal(Phase.TransactionSigning, round.Phase);
var tx = round.Assert <SigningState>().CreateTransaction();
Assert.Equal(3, tx.Inputs.Count);
Assert.Equal(2, tx.Outputs.Count);
Assert.DoesNotContain(cfg.BlameScript, tx.Outputs.Select(x => x.ScriptPubKey));
await arena.StopAsync(CancellationToken.None);
}