public async Task <JsonResult> TransactionCheck(string accfrom, string accto, string amount, int reqnum)
{
if (accfrom == accto)
{
return(Json(new TransactionCheckResult()
{
IsSameAccs = true, ReqNum = reqnum
}));
}
decimal decAmount;
if (!decimal.TryParse(amount, out decAmount))
{
return(Json(new TransactionCheckResult()
{
IsParsed = false, ReqNum = reqnum
}));
}
TransactionCheckResult checkResult = await _accDatabaseManager.CheckTransaction(accfrom, User.Identity.Name, accto, User.Identity.Name, decAmount);
checkResult.ReqNum = reqnum;
return(Json(checkResult));
}
public TransactionPolicyError[] Check(Transaction transaction, ICoin[] spentCoins)
{
spentCoins = spentCoins ?? new ICoin[0];
var errors = new List <TransactionPolicyError>();
if (transaction.Version > Transaction.CURRENT_VERSION || transaction.Version < 1)
{
errors.Add(new TransactionPolicyError("Invalid transaction version, expected " + Transaction.CURRENT_VERSION));
}
IEnumerable <IGrouping <OutPoint, IndexedTxIn> > dups = transaction.Inputs.AsIndexedInputs().GroupBy(i => i.PrevOut);
foreach (IGrouping <OutPoint, IndexedTxIn> dup in dups)
{
IndexedTxIn[] duplicates = dup.ToArray();
if (duplicates.Length != 1)
{
errors.Add(new DuplicateInputPolicyError(duplicates));
}
}
foreach (IndexedTxIn input in transaction.Inputs.AsIndexedInputs())
{
ICoin coin = spentCoins.FirstOrDefault(s => s.Outpoint == input.PrevOut);
if (coin == null)
{
errors.Add(new CoinNotFoundPolicyError(input));
}
}
foreach (Coin output in transaction.Outputs.AsCoins())
{
if (output.Amount < Money.Zero)
{
errors.Add(new OutputPolicyError("Output value should not be less than zero", (int)output.Outpoint.N));
}
}
Money fees = transaction.GetFee(spentCoins);
if (fees != null)
{
if (fees < Money.Zero)
{
errors.Add(new NotEnoughFundsPolicyError("Not enough funds in this transaction", -fees));
}
}
TransactionCheckResult check = transaction.Check();
if (check != TransactionCheckResult.Success)
{
errors.Add(new TransactionPolicyError("Context free check of the transaction failed " + check));
}
return(errors.ToArray());
}
public async Task <IActionResult> TransactToAccountFormAction(IndexModel model)
{
TransactionCheckResult result = await _accDatabaseManager.TransactionAsync(model.TransactToAccount.AccountFromName,
User.Identity.Name,
model.TransactToAccount.AccountToName,
User.Identity.Name,
Convert.ToDecimal(model.TransactToAccount.Amount));
if (model == null)
{
model = new IndexModel();
}
model.Accounts = await _accDatabaseManager.GetAccountsAsync(User.Identity.Name);
if (result.IsSameAccs == true)
{
model.ActivityMessage = "Transaction failed: select different accounts.";
model.ActivityMessageError = true;
return(View(nameof(HomeController.Index), model));
}
if (result.IsEnough == false)
{
model.ActivityMessage = "Transaction failed: not enough funds.";
model.ActivityMessageError = true;
return(View(nameof(HomeController.Index), model));
}
await _logManager.WriteAsync(User.Identity.Name, $"Transaction: {result.SendAmount} {result.CurrFrom} subtracted from '{model.TransactToAccount.AccountFromName}' account ({result.Commission} {result.CurrFrom} commission).");
await _logManager.WriteAsync(User.Identity.Name, $"Transaction: {result.Receive} {result.CurrTo} added to '{model.TransactToAccount.AccountToName}' account.");
await _logManager.WriteAsync(result.CommissionOwner, $"Commission getting: {result.Commission} {result.CurrFrom} added to '{result.CommissionAccName}' account.");
model.ActivityMessage = "Transaction complete.";
return(View(nameof(HomeController.Index), model));
}
public PrepareTransferException(TransactionCheckResult checkResult) : this(
$"Failed to check transaction with result: {checkResult.ToString()}")
{
}
