public async Task Simulation_Originate()
{
var monitor = ConnectIdentity("IdentityID");
simulation.SetBalance("IdentityID", 100);
var task = new CreateContractTask
{
ManagerID = "IdentityID",
SourceID = "IdentityID",
Name = "Identity",
TransferAmount = TransferAmount,
NetworkFee = NetworkFee,
StorageFee = StorageFee,
ServiceFee = ServiceFee,
};
task = simulation.PrepareCreateContract(task);
await simulation.Hub.WhenPendingSent;
monitor.AssertCount(0);
task = simulation.CreateContract(task, "InstanceID");
await simulation.Hub.WhenPendingSent;
monitor.AssertCount(2);
var transferPending = monitor.Single <TransactionPendingEvent>();
Assert.AreEqual(
-task.TotalAmount,
transferPending.Amount
);
var originatePending = monitor.Single <OriginatePendingEvent>();
Assert.AreEqual(
task.TransferAmount,
originatePending.Amount
);
monitor.Clear();
simulation.CreateBlock();
await simulation.Hub.WhenPendingSent;
monitor.AssertCount(2);
// Source
var balanceChanged = monitor.Single <BalanceChangedEvent>();
var expectedBalance = StartBalance - task.TotalAmount;
Assert.AreEqual(expectedBalance, balanceChanged.Balance);
var entry = balanceChanged.Entry;
Assert.IsNotNull(entry);
// Destination
var originate = monitor.Single <OriginateEvent>();
Assert.AreEqual(
task.TransferAmount,
originate.Balance
);
entry = originate.Entry;
Assert.IsNotNull(entry);
}
public async Task <CreateContractTask> CreateContract(CreateContractTask task)
{
await CallService();
return(simulation.CreateContract(PrepareTask(task), InstanceID));
}
public async Task <CreateContractTask> PrepareCreateContract(CreateContractTask task)
{
await CallService();
return(simulation.PrepareCreateContract(PrepareTask(task)));
}
public Task <CreateContractTask> CreateContract(CreateContractTask contract)
{
throw new NotImplementedException();
}
public Task <CreateContractTask> PrepareCreateContract(CreateContractTask request)
{
throw new NotImplementedException();
}
public async Task <ProtectedTaskflow <CreateContractTask> > CreateAccount(string name, Identity managerIdentity, TokenStore source, decimal transferAmount, string stereotype = null)
{
Trace($"Create Account '{name}' for {managerIdentity}, transferring {transferAmount} from {source}");
// Create Task and Flow
var task = new CreateContractTask
{
Name = name,
Stereotype = stereotype ?? Account.DefaultStereotype,
ManagerID = managerIdentity.AccountID,
SourceID = source.AccountID,
SourceManagerPublicKey = managerIdentity.PublicKey.ToString(),
NetworkFee = DefaultOperationFee,
TransferAmount = transferAmount,
};
var flow = new ProtectedTaskflow <CreateContractTask>(task);
// Prepare Task
try
{
Trace("Prepare CreateContract");
flow.Task = task = await Connection.PrepareCreateContract(task);
}
catch
{
flow.Update(TaskProgress.Failed);
}
if (flow.IsFailed)
{
return(flow);
}
// External Signing
if (await Sign(task, source.Manager))
{
try
{
// Submit
Trace("Execute CreateContract");
flow.Task = await Connection.CreateContract(task);
flow.SetPending(this);
}
catch (Exception e)
{
Trace(e);
flow.Update(TaskProgress.Failed);
}
}
else
{
Trace("Sign cancelled");
flow.Update(TaskProgress.Cancelled);
}
return(flow);
}
