/// <summary>Constructor</summary>
/// <param name="unitPrice">Unit Price used</param>
/// <param name="amount">Number of Measure Units (same as MeasureUnit in unitPrice)</param>
/// <param name="currencyItem">Currency Item used</param>
/// <exception cref="PriceException">Thrown when no conversion defined between currency units</exception>
public ItemPrice(IUnitPrice unitPrice, decimal amount = 1, ICurrencyItem currencyItem = null)
{
// unit calculus: [C1] = [C2/M1] * [M1] * [C1/C2]
// C1, C2 - currency units; M1 - measure unit
Prepare(unitPrice, currencyItem);
MeasureItem = null;
MeasureRate = amount;
Amount = amount;
}
/// <summary>Constructor</summary>
/// <param name="unitPrice">Unit Price used</param>
/// <param name="measureItem">Measure Item used</param>
/// <param name="currencyItem">Currency Item used</param>
/// <exception cref="PriceException">Thrown when no conversion defined between currency units</exception>
/// <exception cref="MeasureException">Thrown when Measure Units have different types</exception>
public ItemPrice(IUnitPrice unitPrice, IMeasureItem measureItem, ICurrencyItem currencyItem = null)
{
// unit calculus: [C1] = [C2/M1] * [M2 * (M1/M2)] * [C1/C2]
// C1, C2 - currency units; M1, M2 - measure units
Prepare(unitPrice, currencyItem);
MeasureItem = measureItem.ThrowIfNull(nameof(measureItem));
MeasureRate = MeasureItem.AmountOf(UnitPrice.MeasureUnit);
Amount = MeasureItem.Amount;
}
/// <summary>Constructor helper</summary>
/// <param name="unitPrice">Unit Price used</param>
/// <param name="currencyItem">Currency Item used</param>
/// <exception cref="PriceException">Thrown when no conversion defined between currency units</exception>
private void Prepare(IUnitPrice unitPrice, ICurrencyItem currencyItem)
{
UnitPrice = unitPrice.ThrowIfNull(nameof(unitPrice));
CurrencyItem = currencyItem;
VATrate = UnitPrice.VATrate;
CurrencyUnit = CurrencyItem != null ? CurrencyItem.Unit : UnitPrice.CurrencyUnit;
if (CurrencyItem != null && CurrencyItem.Base != UnitPrice.CurrencyUnit)
{
throw new PriceException(PriceException.NO_CURRENCY_CONVERSION);
}
}
public ICurrencyItem CopyFrom(ICurrencyItem aCurrencyItem)
{
Id = aCurrencyItem.Id;
Name = aCurrencyItem.Name;
Ticker = aCurrencyItem.Ticker;
Precision = aCurrencyItem.Precision;
MinConfirmations = aCurrencyItem.MinConfirmations;
LiveDate = aCurrencyItem.LiveDate;
Icon = aCurrencyItem.Icon;
FeePerKb = aCurrencyItem.FeePerKb;
ChainParamaters = aCurrencyItem.ChainParamaters;
CurrentStatus = aCurrencyItem.CurrentStatus;
return(this);
}
internal ITransactionMaker GetMaker(ICurrencyItem aCurrencyItem, KeyManager aKeyManager)
{
if (!FMakers.TryGetValue(aCurrencyItem.Id, out ITransactionMaker lResult))
{
if (aCurrencyItem.ChainParamaters.Capabilities.HasFlag(CapablityFlags.EthereumProtocol))
{
if (aCurrencyItem.Id < 0)
{
lResult = new TokenTransactionMaker(aCurrencyItem, aKeyManager, FServerConnection);
}
else
{
lResult = new EthereumTransactioMaker(aCurrencyItem, aKeyManager, FServerConnection);
}
}
else
{
lResult = new BitcoinTransactionMaker(aCurrencyItem, aKeyManager, FServerConnection);
}
FMakers.TryAdd(aCurrencyItem.Id, lResult);
}
return(lResult);
}
public TokenTransactionMaker(ICurrencyItem aCurrencyItem, KeyManager aKeyManager, ServerConnection aServerConnection) : base(aKeyManager, aServerConnection)
{
FToken = aCurrencyItem as ICurrencyToken ?? throw new ArgumentException(nameof(aCurrencyItem), $"Currency item is not a token. Argument must implement {nameof(ICurrencyToken)}");
FCurrencyItem = aServerConnection.GetCurrency(FToken.ParentCurrencyID);
}
public void RemoveCurrenciesToWatch(ICurrencyItem aCurrency) => FCurrencyWatchInventory.TryRemove(aCurrency.Id, out _);
public void AddCurrenciesToWatch(ICurrencyItem aCurrency)
{
FCurrencyWatchInventory.TryAdd(aCurrency.Id, aCurrency);
FCoreUpdaterTimer.Change(5000, Timeout.Infinite);
}
internal EthereumTransactioMaker(ICurrencyItem aCurrencyItem, KeyManager aKeyManager, ServerConnection aServerConnection) : base(aCurrencyItem, aKeyManager, aServerConnection)
{
}
public GUICurrency(ICurrencyItem aCurrency) : this()
{
this.CopyFrom(aCurrency);
}
private string PrepareNewTransaction(string aToAddress, decimal aAmount, decimal aTxFee, ICurrencyItem aCurrencyItem, TransactionUnit[] aUnspentOutputs, out CurrencyTransaction aCurrencyTransaction)
{
if (!FServerConnection.DirectCheckAddress(aCurrencyItem.Id, aToAddress))
{
throw new ClientExceptions.InvalidAddressException("Address provided not valid. Please verify");
}
var lTxOutputs = new List <TransactionUnit>();
lTxOutputs.Add(new TransactionUnit(0, aCurrencyItem.AmountToBigInteger(aAmount), aToAddress));
BigInteger lTotal = 0;
foreach (var lOutput in aUnspentOutputs)
{
lTotal += lOutput.Amount;
}
var lSendTotal = aCurrencyItem.AmountToDecimal(lTotal);
if (lSendTotal < (aAmount + aTxFee))
{
throw new InvalidOperationException($"The amount to send '{aAmount + aTxFee}' is greater than the balance of transactions '{aCurrencyItem.AmountToDecimal(lTotal)}'.");
}
else if (lSendTotal > (aAmount + aTxFee))
{
lTxOutputs.Add(new TransactionUnit(0, lTotal - aCurrencyItem.AmountToBigInteger(aAmount + aTxFee), FServerConnection.GetCoinAddress(aCurrencyItem.Id)));
}
aCurrencyTransaction = new CurrencyTransaction(aUnspentOutputs, lTxOutputs.ToArray(), aCurrencyItem.AmountToLong(aTxFee), aCurrencyItem.Id);
return(FServerConnection.DirectCreateTransaction(aCurrencyTransaction));
}
internal BitcoinTransactionMaker(ICurrencyItem aCurrencyItem, KeyManager aKeyManager, ServerConnection aServerConnection) : base(aCurrencyItem, aKeyManager, aServerConnection)
{
}
internal BaseTransactionMaker(ICurrencyItem aCurrencyItem, KeyManager aKeyManager, ServerConnection aServerConnection) : this(aKeyManager, aServerConnection)
{
FCurrencyItem = aCurrencyItem;
}
