public virtual ITransactionEnvelope GenerateNeuraliumMultiTransferTransaction(Guid accountUuid, List <RecipientSet> recipients, Amount tip, CorrelationContext correlationContext)
{
try {
INeuraliumMultiTransferTransaction multiTransferTransaction = new NeuraliumMultiTransferTransaction();
ITransactionEnvelope envelope = this.GenerateTransaction(multiTransferTransaction, GlobalsService.TRANSACTION_KEY_NAME, EnvelopeSignatureTypes.Instance.Published, () => {
multiTransferTransaction.Recipients.AddRange(recipients);
multiTransferTransaction.Total = recipients.Sum(e => e.Amount);
multiTransferTransaction.Tip = tip;
// let's ensure we have the balance
Amount balance = this.CentralCoordinator.ChainComponentProvider.WalletProvider.GetAccountBalance(accountUuid, false).Total;
// make sure that the amount spent and tip are less than what we have in total
if ((balance - (multiTransferTransaction.Total + tip)) < 0)
{
//TODO: what to do here?
throw new InvalidOperationException("We don't have enough to transfer");
}
});
return(envelope);
} catch (Exception ex) {
throw new ApplicationException("failed to generate neuralium key change transaction", ex);
}
}
public override void InsertLocalTransactionCacheEntry(ITransactionEnvelope transactionEnvelope)
{
base.InsertLocalTransactionCacheEntry(transactionEnvelope);
AccountId targetAccountId = transactionEnvelope.Contents.Uuid.Account;
TotalAPI total = this.GetAccountBalance(targetAccountId, true);
this.centralCoordinator.PostSystemEvent(NeuraliumSystemEventGenerator.NeuraliumAccountTotalUpdated(targetAccountId.SequenceId, targetAccountId.AccountType, total));
}
protected override ValidationResult ValidateContents(ITransactionEnvelope envelope)
{
ValidationResult result = base.ValidateContents(envelope);
if (result.Invalid)
{
return(result);
}
return(NeuraliumTransactionCreationUtils.ValidateTransaction(envelope.Contents.RehydratedTransaction));
}
public override ITransactionEnvelope GenerateDebugTransaction()
{
try {
ITransaction transaction = this.CreateNewDebugTransaction();
ITransactionEnvelope envelope = this.GenerateTransaction(transaction, GlobalsService.TRANSACTION_KEY_NAME, null);
return(envelope);
} catch (Exception ex) {
throw new ApplicationException("failed to generate neuralium debug transaction", ex);
}
}
public virtual ITransactionEnvelope GenerateRefillNeuraliumsTransaction(Guid accountUuid, CorrelationContext correlationContext)
{
try {
INeuraliumRefillNeuraliumsTransaction refillTransaction = new NeuraliumRefillNeuraliumsTransaction();
ITransactionEnvelope envelope = this.GenerateTransaction(refillTransaction, GlobalsService.TRANSACTION_KEY_NAME, EnvelopeSignatureTypes.Instance.Published);
return(envelope);
} catch (Exception ex) {
throw new ApplicationException("failed to generate neuralium key change transaction", ex);
}
}
protected override void FillWalletTransactionCacheEntry(IWalletTransactionCache walletAccountTransactionCache, ITransactionEnvelope transactionEnvelope, AccountId targetAccountId)
{
this.EnsureWalletLoaded();
base.FillWalletTransactionCacheEntry(walletAccountTransactionCache, transactionEnvelope, targetAccountId);
ITransaction transaction = transactionEnvelope.Contents.RehydratedTransaction;
if (walletAccountTransactionCache is INeuraliumWalletTransactionCache neuraliumWalletTransactionCache)
{
bool ours = transaction.TransactionId.Account == targetAccountId;
//here we record the impact amount. + value increases our amount. - reduces
if (transaction is INeuraliumTransferTransaction neuraliumTransferTransaction)
{
neuraliumWalletTransactionCache.Amount = neuraliumTransferTransaction.Amount;
neuraliumWalletTransactionCache.MoneratyTransactionType = NeuraliumWalletTransactionCache.MoneratyTransactionTypes.Debit;
}
else if (transaction is INeuraliumMultiTransferTransaction neuraliumMultiTransferTransaction)
{
neuraliumWalletTransactionCache.Amount = neuraliumMultiTransferTransaction.Total;
neuraliumWalletTransactionCache.MoneratyTransactionType = NeuraliumWalletTransactionCache.MoneratyTransactionTypes.Debit;
}
else if (transaction is INeuraliumRefillNeuraliumsTransaction neuraliumsTransaction)
{
neuraliumWalletTransactionCache.Amount = 1000;
neuraliumWalletTransactionCache.MoneratyTransactionType = NeuraliumWalletTransactionCache.MoneratyTransactionTypes.Credit;
}
if (transaction is ITipTransaction tipTransaction)
{
neuraliumWalletTransactionCache.Tip = tipTransaction.Tip;
}
}
}
protected override void PrepareTransactionEntry(NeuraliumChainPoolSqlitePublicTransactions entry, ITransactionEnvelope transactionEnvelope, DateTime chainInception)
{
base.PrepareTransactionEntry(entry, transactionEnvelope, chainInception);
if (transactionEnvelope.Contents.RehydratedTransaction is ITipTransaction tipTransaction)
{
entry.Tip = tipTransaction.Tip.Value;
}
}
protected override ValidationResult PerformBasicTransactionValidation(ITransaction transaction, ITransactionEnvelope envelope, bool?accreditationCertificateValid)
{
ValidationResult result = base.PerformBasicTransactionValidation(transaction, envelope, accreditationCertificateValid);
bool validCertificate = accreditationCertificateValid.HasValue && accreditationCertificateValid.Value;
if (result == ValidationResult.ValidationResults.Valid)
{
if (!validCertificate && transaction is ITipTransaction tipTransaction)
{
byte scope = transaction.TransactionId.Scope;
// we allow one transaction for free per second
if (scope >= 1)
{
decimal tip = tipTransaction.Tip;
if (tip <= 0M)
{
return(this.CreateTrasactionValidationResult(ValidationResult.ValidationResults.Invalid, NeuraliumTransactionValidationErrorCodes.Instance.TIP_REQUIRED));
}
// tiered tip
if (scope > 3)
{
//TODO: define these values
if ((scope <= 25) && (tip <= 0.0001M))
{
return(this.CreateTrasactionValidationResult(ValidationResult.ValidationResults.Invalid, NeuraliumTransactionValidationErrorCodes.Instance.INSUFFICIENT_TIP));
}
if ((scope <= 100) && (tip <= 0.001M))
{
return(this.CreateTrasactionValidationResult(ValidationResult.ValidationResults.Invalid, NeuraliumTransactionValidationErrorCodes.Instance.INSUFFICIENT_TIP));
}
if (tip <= 0.01M)
{
return(this.CreateTrasactionValidationResult(ValidationResult.ValidationResults.Invalid, NeuraliumTransactionValidationErrorCodes.Instance.INSUFFICIENT_TIP));
}
}
}
}
}
return(result);
}
public override IBlockchainGossipMessageSet CreateTransactionCreatedGossipMessageSet(ITransactionEnvelope envelope)
{
if (!(envelope.Contents.RehydratedTransaction is INeuraliumTransaction castedTransaction))
{
throw new ApplicationException("Invalid transaction type");
}
return(this.CreateGossipMessageSet <NeuraliumGossipMessageSet <NeuraliumTransactionCreatedGossipMessage, INeuraliumTransactionEnvelope>, NeuraliumTransactionCreatedGossipMessage, INeuraliumTransactionEnvelope>((INeuraliumTransactionEnvelope)envelope));
}
public override IBlockchainGossipMessageSet CreateTransactionCreatedGossipMessageSet <GOSSIP_MESSAGE_SET, GOSSIP_MESSAGE_TYPE, EVENT_ENVELOPE_TYPE>(ITransactionEnvelope transaction)
{
return(this.CreateGossipMessageSet <GOSSIP_MESSAGE_SET, GOSSIP_MESSAGE_TYPE, IDehydratedTransaction, EVENT_ENVELOPE_TYPE, EVENT_ENVELOPE_TYPE>(transaction.Contents));
}
