public async Task TxCommitQuantumTest(KeyPair alphaKeyPair, ConnectionState state, Type excpectedException)
{
context.AppState.State = ApplicationState.Ready;
var clientConnection = new AuditorWebSocketConnection(context, new FakeAuditorConnectionInfo(new FakeWebSocket()))
{
ConnectionState = state
};
var ledgerNotification = new TxNotification
{
TxCursor = 0,
Payments = new List <PaymentBase>()
};
var envelope = new TxCommitQuantum
{
Source = ledgerNotification.CreateEnvelope()
}.CreateEnvelope();
envelope.Sign(alphaKeyPair);
using var writer = new XdrBufferWriter();
var inMessage = envelope.ToIncomingMessage(writer);
await AssertMessageHandling(clientConnection, inMessage, excpectedException);
}
public async Task TxCommitQuantumTest(KeyPair alphaKeyPair, ConnectionState state, Type excpectedException)
{
Global.AppState.State = ApplicationState.Ready;
var clientConnection = new AuditorWebSocketConnection(new FakeWebSocket(), null)
{
ConnectionState = state
};
var ledgerNotification = new TxNotification
{
TxCursor = 0,
Payments = new List <PaymentBase>()
};
var envelope = new TxCommitQuantum
{
Source = ledgerNotification.CreateEnvelope()
}.CreateEnvelope();
envelope.Sign(alphaKeyPair);
await AssertMessageHandling(clientConnection, envelope, excpectedException);
}
private bool TryGetTxCommit(long cursor, out TxCommitQuantum txCommit)
{
lock (syncRoot)
return(pendingTxCommits.Remove(cursor, out txCommit));
}
/// <summary>
/// This method inits Global, generates genesis snapshot and adds clients to constellation
/// </summary>
/// <param name="clients">Clients to add to constellation</param>
/// <param name="auditors">Auditors to add to constellation</param>
/// <param name="settings">Settings that will be used to init Global</param>
public static async Task Setup(List <KeyPair> clients, List <KeyPair> auditors, BaseSettings settings, IStorage storage)
{
await Global.Setup(settings, storage);
var assets = new List <AssetSettings> {
new AssetSettings {
Id = 1, Code = "X", Issuer = KeyPair.Random()
}
};
var initQuantum = new ConstellationInitQuantum
{
Apex = 1,
Assets = assets,
Auditors = auditors.Select(a => (RawPubKey)a.PublicKey).ToList(),
MinAccountBalance = 1,
MinAllowedLotSize = 1,
Vault = settings is AlphaSettings ? settings.KeyPair.PublicKey : ((AuditorSettings)settings).AlphaKeyPair.PublicKey,
PrevHash = new byte[] { },
RequestRateLimits = new RequestRateLimits {
HourLimit = 1000, MinuteLimit = 100
}
};
if (!Global.IsAlpha)
{
initQuantum.Timestamp = DateTime.UtcNow.Ticks;
}
var envelope = initQuantum.CreateEnvelope();
if (!Global.IsAlpha)
{
var alphaKeyPair = KeyPair.FromSecretSeed(TestEnvironment.AlphaKeyPair.SecretSeed);
envelope.Sign(alphaKeyPair);
}
await Global.QuantumHandler.HandleAsync(envelope);
var deposits = new List <PaymentBase>();
Action <byte[], int> addAssetsFn = (acc, asset) =>
{
deposits.Add(new Deposit
{
Destination = acc,
Amount = 10000,
Asset = asset,
PaymentResult = PaymentResults.Success
});
};
for (int i = 0; i < clients.Count; i++)
{
//add xlm
addAssetsFn(clients[i].PublicKey, 0);
for (var c = 0; c < assets.Count; c++)
{
addAssetsFn(clients[i].PublicKey, assets[c].Id);
}
}
var depositQuantum = new TxCommitQuantum
{
Apex = 2,
PrevHash = Global.QuantumStorage.LastQuantumHash,
Source = new TxNotification
{
TxCursor = 2,
Payments = deposits
}.CreateEnvelope()
};
depositQuantum.Source.Sign(TestEnvironment.Auditor1KeyPair);
await Global.QuantumHandler.HandleAsync(depositQuantum.CreateEnvelope());
//save all effects
await SnapshotHelper.ApplyUpdates();
}
public async Task TxCommitQuantumTest(int cursor, int amount, int asset, Type excpectedException)
{
context.AppState.State = ApplicationState.Ready;
long apex = context.QuantumStorage.CurrentApex;
var client1StartBalanceAmount = (long)0;
var account1 = context.AccountStorage.GetAccount(TestEnvironment.Client1KeyPair).Account;
var clientAccountBalance = account1.GetBalance(asset);
var withdrawalDest = KeyPair.Random();
var txHash = new byte[] { };
if (clientAccountBalance != null && amount > 0)
{
client1StartBalanceAmount = clientAccountBalance.Amount;
context.Constellation.TryFindAssetSettings(asset, out var assetSettings);
var account = new stellar_dotnet_sdk.Account(TestEnvironment.Client1KeyPair.AccountId, 1);
var txBuilder = new TransactionBuilder(account);
txBuilder.SetFee(10_000);
txBuilder.AddTimeBounds(new stellar_dotnet_sdk.TimeBounds(DateTimeOffset.UtcNow, new TimeSpan(0, 5, 0)));
txBuilder.AddOperation(
new PaymentOperation.Builder(withdrawalDest, assetSettings.ToAsset(), Amount.FromXdr(amount).ToString())
.SetSourceAccount((KeyPair)context.Constellation.Vault)
.Build()
);
var tx = txBuilder.Build();
txHash = tx.Hash();
var txV1 = tx.ToXdrV1();
var txStream = new XdrDataOutputStream();
stellar_dotnet_sdk.xdr.Transaction.Encode(txStream, txV1);
var accountWrapper = context.AccountStorage.GetAccount(TestEnvironment.Client1KeyPair);
var withdrawal = new WithdrawalRequest
{
Account = accountWrapper.Account.Id,
TransactionXdr = txStream.ToArray(),
RequestId = DateTime.UtcNow.Ticks,
AccountWrapper = accountWrapper
};
MessageEnvelope quantum = withdrawal.CreateEnvelope();
quantum.Sign(TestEnvironment.Client1KeyPair);
if (!context.IsAlpha)
{
quantum = new RequestQuantum {
Apex = ++apex, RequestEnvelope = quantum, Timestamp = DateTime.UtcNow.Ticks
}.CreateEnvelope();
quantum.Sign(TestEnvironment.AlphaKeyPair);
}
//create withdrawal
await context.QuantumHandler.HandleAsync(quantum);
}
var depositAmount = new Random().Next(10, 1000);
var ledgerNotification = new TxNotification
{
TxCursor = (uint)cursor,
Payments = new List <PaymentBase>
{
new Deposit
{
Amount = depositAmount,
Destination = TestEnvironment.Client1KeyPair,
Asset = asset
},
new Withdrawal
{
TransactionHash = txHash,
PaymentResult = PaymentResults.Success
}
}
};
var ledgerNotificationEnvelope = ledgerNotification.CreateEnvelope();
ledgerNotificationEnvelope.Sign(TestEnvironment.Auditor1KeyPair);
var ledgerCommitEnv = new TxCommitQuantum
{
Source = ledgerNotificationEnvelope,
Apex = ++apex
}.CreateEnvelope();
if (!context.IsAlpha)
{
var msg = ((TxCommitQuantum)ledgerCommitEnv.Message);
msg.Timestamp = DateTime.UtcNow.Ticks;
ledgerCommitEnv = msg.CreateEnvelope().Sign(TestEnvironment.AlphaKeyPair);
}
await AssertQuantumHandling(ledgerCommitEnv, excpectedException);
if (excpectedException == null)
{
Assert.AreEqual(context.TxCursorManager.TxCursor, ledgerNotification.TxCursor);
Assert.AreEqual(account1.GetBalance(asset).Liabilities, 0);
Assert.AreEqual(account1.GetBalance(asset).Amount, client1StartBalanceAmount - amount + depositAmount); //acc balance + deposit - withdrawal
}
}
