public static SwapViewModel CreateSwapViewModel(Swap swap, ICurrencies currencies, IAccount account)
{
var soldCurrency = currencies.GetByName(swap.SoldCurrency);
var purchasedCurrency = currencies.GetByName(swap.PurchasedCurrency);
var fromAmount = AmountHelper.QtyToAmount(swap.Side, swap.Qty, swap.Price, soldCurrency.DigitsMultiplier);
var toAmount = AmountHelper.QtyToAmount(swap.Side.Opposite(), swap.Qty, swap.Price, purchasedCurrency.DigitsMultiplier);
var quoteCurrency = swap.Symbol.QuoteCurrency() == swap.SoldCurrency
? soldCurrency
: purchasedCurrency;
var swapViewModel = new SwapViewModel
{
Id = swap.Id.ToString(),
Mode = ModeBySwap(swap),
Time = swap.TimeStamp,
FromAmount = fromAmount,
FromCurrencyCode = soldCurrency.Name,
ToAmount = toAmount,
ToCurrencyCode = purchasedCurrency.Name,
Price = swap.Price,
PriceFormat = $"F{quoteCurrency.Digits}",
Account = account
};
swapViewModel.UpdateSwap(swap);
return(swapViewModel);
}
private async Task <Error> SendSwapAsync()
{
try
{
var account = App.Account;
var requiredAmount = Amount + Fee;
var fromWallets = (await account
.GetUnspentAddressesAsync(
currency: FromCurrency,
requiredAmount: requiredAmount))
.ToList();
var refundWallet = await account
.GetRefundAddressAsync(FromCurrency, fromWallets);
var toWallet = await account
.GetRedeemAddressAsync(ToCurrency);
var symbol = Symbols.SymbolByCurrencies(FromCurrency, ToCurrency);
var side = symbol.OrderSideForBuyCurrency(ToCurrency);
var terminal = App.Terminal;
var orderBook = terminal.GetOrderBook(symbol);
var price = orderBook.EstimatedDealPrice(side, Amount);
if (price == 0)
{
return(new Error(Errors.NoLiquidity, Resources.CvNoLiquidity));
}
var qty = Math.Round(AmountHelper.AmountToQty(side, Amount, price), symbol.QtyDigits);
var order = new Order
{
Symbol = symbol,
TimeStamp = DateTime.UtcNow,
Price = price,
Qty = qty,
Fee = Fee,
Side = side,
Type = OrderType.FillOrKill,
FromWallets = fromWallets.ToList(),
ToWallet = toWallet,
RefundWallet = refundWallet
};
await order.CreateProofOfPossessionAsync(account);
terminal.OrderSendAsync(order);
}
catch (Exception e)
{
Log.Error(e, "Conversion error");
return(new Error(Errors.SwapError, Resources.CvConversionError));
}
return(null);
}
public Decimal GetTrendByMarket(string currency, string marketId)
{
var tm = AmountHelper.DateTimeToUnixTimestamp(DateTime.UtcNow);
var exchange_stats = _dtoMain.mainDb.GetCollection <ExchangeTicker>("aaexchanges_real_twodays");
DateTimeOffset dateTimeDaily = new DateTimeOffset(DateTime.UtcNow.Year, DateTime.UtcNow.Month, DateTime.UtcNow.Day, 0, 0, 0,
new TimeSpan(0, 0, 0)).AddDays(-1);
long unixTimeDaily = AmountHelper.DateTimeToUnixTimestamp(dateTimeDaily.UtcDateTime);
var exchangeStats = exchange_stats.Find(m => m.InCurrency == currency && m.OutCurrency == "BTC" && m.MarketID == marketId && m.Time >= unixTimeDaily).ToList();
Decimal dict24Prev = 0.0m;
Decimal dict24Now = 0.0m;
int a = 0, b = 0, i = 0;
foreach (var ex in exchangeStats)
{
if (i == 0)
{
dict24Prev += ex.Last;
a++;
}
else
{
dict24Now += ex.Last;
b++;
}
i++;
}
if (a == 0 || b == 0 || dict24Prev == 0)
{
return(0.0m);
}
Decimal trend = (dict24Now / b) * 100 / (dict24Prev / a) - 100;
return(trend);
}
/// <summary>
/// When an order needs to be captured the cartridge needs to make an API Call
/// POST /ordermanagement/v1/orders/{order_id}/captures for the amount which needs to be captured.
/// If it's a partial capture the API call will be the same just for the
/// amount that should be captured. Many captures can be made up to the whole amount authorized.
/// The shipment information can be added in this call or amended aftewards using the method
/// "Add shipping info to a capture".
/// The amount captured never can be greater than the authorized.
/// When an order is Partally Captured the status of the order in Klarna is PART_CAPTURED
/// </summary>
public override bool Process(IPayment payment, IOrderForm orderForm, IOrderGroup orderGroup, IShipment shipment, ref string message)
{
if (payment.TransactionType == TransactionType.Capture.ToString())
{
var amount = AmountHelper.GetAmount(payment.Amount);
var orderId = orderGroup.Properties[Common.Constants.KlarnaOrderIdField]?.ToString();
if (!string.IsNullOrEmpty(orderId))
{
try
{
var captureData = KlarnaOrderService.CaptureOrder(orderId, amount, "Capture the payment", orderGroup, orderForm, payment, shipment);
AddNoteAndSaveChanges(orderGroup, payment.TransactionType, $"Captured {payment.Amount}, id {captureData.CaptureId}");
}
catch (Exception ex) when(ex is ApiException || ex is WebException)
{
var exceptionMessage = GetExceptionMessage(ex);
payment.Status = PaymentStatus.Failed.ToString();
message = exceptionMessage;
AddNoteAndSaveChanges(orderGroup, payment.TransactionType, $"Error occurred {exceptionMessage}");
Logger.Error(exceptionMessage, ex);
return(false);
}
}
return(true);
}
else if (Successor != null)
{
return(Successor.Process(payment, orderForm, orderGroup, shipment, ref message));
}
return(false);
}
public static SwapViewModel CreateSwapViewModel(ClientSwap swap)
{
var fromCurrency = CurrencyViewModelCreator.CreateViewModel(
currency: swap.SoldCurrency,
subscribeToUpdates: false);
var toCurrency = CurrencyViewModelCreator.CreateViewModel(
currency: swap.PurchasedCurrency,
subscribeToUpdates: false);
var fromAmount = AmountHelper.QtyToAmount(swap.Side, swap.Qty, swap.Price);
var toAmount = AmountHelper.QtyToAmount(swap.Side.Opposite(), swap.Qty, swap.Price);
return(new SwapViewModel
{
Id = swap.Id.ToString(),
CompactState = CompactStateBySwap(swap),
Mode = ModeBySwap(swap),
Time = swap.TimeStamp,
FromBrush = new SolidColorBrush(fromCurrency.AmountColor),
FromAmount = fromAmount,
FromAmountFormat = fromCurrency.CurrencyFormat,
FromCurrencyCode = fromCurrency.CurrencyCode,
ToBrush = new SolidColorBrush(toCurrency.AmountColor),
ToAmount = toAmount,
ToAmountFormat = toCurrency.CurrencyFormat,
ToCurrencyCode = toCurrency.CurrencyCode,
Price = swap.Price,
PriceFormat = $"F{swap.Symbol.Quote.Digits}"
});
}
private async Task <IBitcoinBasedTransaction> CreateRefundTxAsync(
Swap swap,
IBitcoinBasedTransaction paymentTx,
string refundAddress,
DateTimeOffset lockTime,
byte[] redeemScript)
{
Log.Debug("Create refund tx for swap {@swapId}", swap.Id);
var currency = Currencies.Get <BitcoinBasedCurrency>(Currency);
var amountInSatoshi = currency.CoinToSatoshi(AmountHelper.QtyToAmount(swap.Side, swap.Qty, swap.Price, currency.DigitsMultiplier));
var tx = await _transactionFactory
.CreateSwapRefundTxAsync(
paymentTx : paymentTx,
amount : amountInSatoshi,
refundAddress : refundAddress,
lockTime : lockTime,
redeemScript : redeemScript)
.ConfigureAwait(false);
if (tx == null)
{
throw new InternalException(
code: Errors.TransactionCreationError,
description: $"Refund tx creation error for swap {swap.Id}");
}
tx.Type = BlockchainTransactionType.Output | BlockchainTransactionType.SwapRefund;
Log.Debug("Refund tx successfully created for swap {@swapId}", swap.Id);
return(tx);
}
public ShippingOptionUpdateResponse UpdateShippingMethod(ICart cart, ShippingOptionUpdateRequest shippingOptionUpdateRequest)
{
var configuration = GetConfiguration(cart.Market);
var shipment = cart.GetFirstShipment();
if (shipment != null && Guid.TryParse(shippingOptionUpdateRequest.SelectedShippingOption.Id, out Guid guid))
{
shipment.ShippingMethodId = guid;
shipment.ShippingAddress = shippingOptionUpdateRequest.ShippingAddress.ToOrderAddress(cart);
_orderRepository.Save(cart);
}
var totals = _orderGroupTotalsCalculator.GetTotals(cart);
var result = new ShippingOptionUpdateResponse
{
OrderAmount = AmountHelper.GetAmount(totals.Total),
OrderTaxAmount = AmountHelper.GetAmount(totals.TaxTotal),
OrderLines = GetOrderLines(cart, totals, configuration.SendProductAndImageUrl),
PurchaseCurrency = cart.Currency.CurrencyCode
};
if (ServiceLocator.Current.TryGetExistingInstance(out ICheckoutOrderDataBuilder checkoutOrderDataBuilder))
{
checkoutOrderDataBuilder.Build(result, cart, configuration);
}
return(result);
}
public AddressUpdateResponse UpdateAddress(ICart cart, AddressUpdateRequest addressUpdateRequest)
{
var configuration = GetConfiguration(cart.Market);
var shipment = cart.GetFirstShipment();
if (shipment != null)
{
shipment.ShippingAddress = addressUpdateRequest.ShippingAddress.ToOrderAddress(cart);
_orderRepository.Save(cart);
}
var totals = _orderGroupTotalsCalculator.GetTotals(cart);
var result = new AddressUpdateResponse
{
OrderAmount = AmountHelper.GetAmount(totals.Total),
OrderTaxAmount = AmountHelper.GetAmount(totals.TaxTotal),
OrderLines = GetOrderLines(cart, totals, configuration.SendProductAndImageUrl),
PurchaseCurrency = cart.Currency.CurrencyCode,
ShippingOptions = configuration.ShippingOptionsInIFrame ? GetShippingOptions(cart, cart.Currency, ContentLanguage.PreferredCulture) : Enumerable.Empty <ShippingOption>()
};
if (ServiceLocator.Current.TryGetExistingInstance(out ICheckoutOrderDataBuilder checkoutOrderDataBuilder))
{
checkoutOrderDataBuilder.Build(result, cart, configuration);
}
return(result);
}
public decimal EstimatedDealPrice(Side side, decimal amount)
{
var amountToFill = amount;
lock (SyncRoot)
{
var book = side == Side.Buy
? Sells
: Buys;
if (amount == 0)
{
return(book.Any() ? book.First().Key : 0);
}
foreach (var entryPair in book)
{
var qty = entryPair.Value.Qty();
var availableAmount = AmountHelper.QtyToAmount(side, qty, entryPair.Key);
amountToFill -= availableAmount;
if (amountToFill <= 0)
{
return(entryPair.Key);
}
}
}
return(0m);
}
public override async Task <decimal> GetRewardForRedeemAsync(
decimal maxRewardPercent,
decimal maxRewardPercentInBase,
string feeCurrencyToBaseSymbol,
decimal feeCurrencyToBasePrice,
string feeCurrencySymbol = null,
decimal feeCurrencyPrice = 0,
CancellationToken cancellationToken = default)
{
var rewardForRedeemInEth = await base.GetRewardForRedeemAsync(
maxRewardPercent : maxRewardPercent,
maxRewardPercentInBase : maxRewardPercentInBase,
feeCurrencyToBaseSymbol : feeCurrencyToBaseSymbol,
feeCurrencyToBasePrice : feeCurrencyToBasePrice,
feeCurrencySymbol : feeCurrencySymbol,
feeCurrencyPrice : feeCurrencyPrice,
cancellationToken : cancellationToken);
if (feeCurrencySymbol == null || feeCurrencyPrice == 0)
{
return(0m);
}
return(AmountHelper.RoundDown(feeCurrencySymbol.IsBaseCurrency(Name)
? rewardForRedeemInEth / feeCurrencyPrice
: rewardForRedeemInEth *feeCurrencyPrice, DigitsMultiplier));
}
private async Task <Error> SendSwapAsync()
{
try
{
var account = App.Account;
var requiredAmount = Amount + EstimatedPaymentFee;
var fromWallets = (await account
.GetUnspentAddressesAsync(
currency: FromCurrency,
amount: requiredAmount,
fee: 0,
feePrice: 0,
isFeePerTransaction: false,
addressUsagePolicy: AddressUsagePolicy.UseMinimalBalanceFirst))
.ToList();
if (requiredAmount > 0 && !fromWallets.Any())
{
return(new Error(Errors.SwapError, Resources.CvInsufficientFunds));
}
var symbol = App.Account.Symbols.SymbolByCurrencies(FromCurrency, ToCurrency);
var side = symbol.OrderSideForBuyCurrency(ToCurrency);
var terminal = App.Terminal;
var orderBook = terminal.GetOrderBook(symbol);
var price = orderBook.EstimatedDealPrice(side, Amount);
if (price == 0)
{
return(new Error(Errors.NoLiquidity, Resources.CvNoLiquidity));
}
var qty = Math.Round(AmountHelper.AmountToQty(side, Amount, price), symbol.Base.Digits);
var order = new Order
{
Symbol = symbol,
TimeStamp = DateTime.UtcNow,
Price = price,
Qty = qty,
Side = side,
Type = OrderType.FillOrKill,
FromWallets = fromWallets.ToList(),
};
await order.CreateProofOfPossessionAsync(account);
terminal.OrderSendAsync(order);
}
catch (Exception e)
{
Log.Error(e, "Conversion error");
return(new Error(Errors.SwapError, Resources.CvConversionError));
}
return(null);
}
public static OrderLine GetOrderLine(this ILineItem lineItem, bool includeProductAndImageUrl = false)
{
return(GetOrderLine(
lineItem,
includeProductAndImageUrl,
AmountHelper.GetAmount(lineItem.PlacedPrice),
AmountHelper.GetAmount(lineItem.PlacedPrice * lineItem.Quantity),
0, 0, 0));
}
private CheckoutOrderData GetCheckoutOrderData(
ICart cart, IMarket market, PaymentMethodDto paymentMethodDto)
{
var totals = _orderGroupCalculator.GetOrderGroupTotals(cart);
var shipment = cart.GetFirstShipment();
var marketCountry = CountryCodeHelper.GetTwoLetterCountryCode(market.Countries.FirstOrDefault());
if (string.IsNullOrWhiteSpace(marketCountry))
{
throw new ConfigurationException($"Please select a country in CM for market {cart.MarketId}");
}
var checkoutConfiguration = GetCheckoutConfiguration(market);
var orderData = new PatchedCheckoutOrderData
{
PurchaseCountry = marketCountry,
PurchaseCurrency = cart.Currency.CurrencyCode,
Locale = ContentLanguage.PreferredCulture.Name,
// Non-negative, minor units. Total amount of the order, including tax and any discounts.
OrderAmount = AmountHelper.GetAmount(totals.Total),
// Non-negative, minor units. The total tax amount of the order.
OrderTaxAmount = AmountHelper.GetAmount(totals.TaxTotal),
MerchantUrls = GetMerchantUrls(cart),
OrderLines = GetOrderLines(cart, totals, checkoutConfiguration.SendProductAndImageUrl)
};
if (checkoutConfiguration.SendShippingCountries)
{
orderData.ShippingCountries = GetCountries().ToList();
}
// KCO_6 Setting to let the user select shipping options in the iframe
if (checkoutConfiguration.SendShippingOptionsPriorAddresses)
{
if (checkoutConfiguration.ShippingOptionsInIFrame)
{
orderData.ShippingOptions = GetShippingOptions(cart, cart.Currency, ContentLanguage.PreferredCulture);
}
else
{
if (shipment != null)
{
orderData.SelectedShippingOption = ShippingManager.GetShippingMethod(shipment.ShippingMethodId)
?.ShippingMethod?.FirstOrDefault()
?.ToShippingOption();
}
}
}
if (paymentMethodDto != null)
{
orderData.Options = GetOptions(cart.MarketId);
}
return(orderData);
}
static void Main()
{
//var k = NumberToWord.AmountToWords(101.155);
var k1 = AmountHelper.AmountToWords(101.155, "", "");
var k2 = 10.0;
var k = k2.ToWords();
Console.WriteLine("Hello World!");
}
public Dictionary <string, Decimal> GetTrendByMarkets(string currency)
{
Dictionary <string, Decimal> markets = new Dictionary <string, Decimal>();
var tm = AmountHelper.DateTimeToUnixTimestamp(DateTime.UtcNow);
var exchange_stats = _dtoMain.mainDb.GetCollection <ExchangeTicker>("aaexchanges_real_twodays");
DateTimeOffset dateTimeDaily = new DateTimeOffset(DateTime.UtcNow.Year, DateTime.UtcNow.Month, DateTime.UtcNow.Day, 0, 0, 0,
new TimeSpan(0, 0, 0)).AddDays(-1);
long unixTimeDaily = AmountHelper.DateTimeToUnixTimestamp(dateTimeDaily.UtcDateTime);
var exchangeStats = exchange_stats.Find(m => m.InCurrency == currency && m.OutCurrency == "BTC" && m.Time >= unixTimeDaily).ToList();
Dictionary <string, List <ExchangeTicker> > marketsList = new Dictionary <string, List <ExchangeTicker> >();
foreach (var mrkt in exchangeStats)
{
if (!marketsList.ContainsKey(mrkt.MarketID))
{
marketsList.Add(mrkt.MarketID, new List <ExchangeTicker>());
marketsList[mrkt.MarketID].Add(mrkt);
}
else
{
marketsList[mrkt.MarketID].Add(mrkt);
}
}
foreach (KeyValuePair <string, List <ExchangeTicker> > kv in marketsList)
{
Decimal dict24Prev = 0.0m;
Decimal dict24Now = 0.0m;
int a = 0, b = 0, i = 0;
foreach (var ex in kv.Value)
{
if (i == 0)
{
dict24Prev += ex.Last;
a++;
}
else
{
dict24Now += ex.Last;
b++;
}
i++;
}
if (a == 0 || b == 0 || dict24Prev == 0)
{
markets.Add(kv.Key, 0.0m);
continue;
}
Decimal trend = (dict24Now / b) * 100 / (dict24Prev / a) - 100;
markets.Add(kv.Key, trend);
}
return(markets);
}
private async Task <IBitcoinBasedTransaction> CreatePaymentTxAsync(
Swap swap,
string refundAddress,
DateTimeOffset lockTime)
{
var currency = Currencies.Get <BitcoinBasedConfig>(swap.SoldCurrency);
Log.Debug("Create swap payment {@currency} tx for swap {@swapId}",
currency.Name,
swap.Id);
var amountInSatoshi = currency.CoinToSatoshi(
AmountHelper.QtyToSellAmount(
swap.Side,
swap.Qty,
swap.Price,
currency.DigitsMultiplier));
// maker network fee
if (swap.MakerNetworkFee > 0)
{
var makerNetworkFeeInSatoshi = currency.CoinToSatoshi(swap.MakerNetworkFee);
if (makerNetworkFeeInSatoshi < amountInSatoshi) // network fee size check
{
amountInSatoshi += makerNetworkFeeInSatoshi;
}
}
var tx = await _transactionFactory
.CreateSwapPaymentTxAsync(
fromOutputs : swap.FromOutputs,
amount : amountInSatoshi,
refundAddress : refundAddress,
toAddress : swap.PartyAddress,
lockTime : lockTime,
secretHash : swap.SecretHash,
secretSize : DefaultSecretSize,
currencyConfig : currency)
.ConfigureAwait(false);
if (tx == null)
{
throw new InternalException(
code: Errors.TransactionCreationError,
description: $"Payment tx creation error for swap {swap.Id}");
}
tx.Type = BlockchainTransactionType.Output | BlockchainTransactionType.SwapPayment;
Log.Debug("Payment tx successfully created for swap {@swapId}", swap.Id);
return(tx);
}
private Session GetSessionRequest(ICart cart, PaymentsConfiguration config, Uri siteUrl, bool includePersonalInformation = false)
{
var market = _marketService.GetMarket(cart.MarketId);
var totals = _orderGroupCalculator.GetOrderGroupTotals(cart);
var request = new Session
{
PurchaseCountry = CountryCodeHelper.GetTwoLetterCountryCode(market.Countries.FirstOrDefault()),
OrderAmount = AmountHelper.GetAmount(totals.Total),
// Non-negative, minor units. The total tax amount of the order.
OrderTaxAmount = AmountHelper.GetAmount(totals.TaxTotal),
PurchaseCurrency = cart.Currency.CurrencyCode,
Locale = _languageService.GetPreferredCulture().Name,
OrderLines = GetOrderLines(cart, totals, config.SendProductAndImageUrlField).ToArray()
};
var paymentMethod = PaymentManager.GetPaymentMethodBySystemName(
Constants.KlarnaPaymentSystemKeyword, _languageService.GetPreferredCulture().Name, returnInactive: true);
if (paymentMethod != null)
{
request.MerchantUrl = new MerchantUrl
{
Confirmation = ToFullSiteUrl(siteUrl, config.ConfirmationUrl),
Notification = ToFullSiteUrl(siteUrl, config.NotificationUrl),
};
request.Options = GetWidgetOptions(paymentMethod, cart.MarketId);
request.AutoCapture = config.AutoCapture;
}
if (includePersonalInformation)
{
var shipment = cart.GetFirstShipment();
var payment = cart.GetFirstForm()?.Payments.FirstOrDefault();
if (shipment?.ShippingAddress != null)
{
request.ShippingAddress = shipment.ShippingAddress.ToAddress();
}
if (payment?.BillingAddress != null)
{
request.BillingAddress = payment.BillingAddress.ToAddress();
}
else if (request.ShippingAddress != null)
{
request.BillingAddress = new OrderManagementAddressInfo()
{
Email = request.ShippingAddress?.Email,
Phone = request.ShippingAddress?.Phone
};
}
}
return(request);
}
private List <OrderLine> GetOrderLinesWithTax(ICart cart, OrderGroupTotals orderGroupTotals, bool sendProductAndImageUrl)
{
var shipment = cart.GetFirstShipment();
var orderLines = new List <OrderLine>();
var market = _marketService.GetMarket(cart.MarketId);
// Line items
foreach (var lineItem in cart.GetAllLineItems())
{
var orderLine = lineItem.GetOrderLineWithTax(market, cart.GetFirstShipment(), cart.Currency, sendProductAndImageUrl);
orderLines.Add(orderLine);
}
// Shipment
if (shipment != null && orderGroupTotals.ShippingTotal.Amount > 0)
{
var shipmentOrderLine = shipment.GetOrderLine(cart, orderGroupTotals, true);
orderLines.Add(shipmentOrderLine);
}
// Without tax
var orderLevelDiscount = AmountHelper.GetAmount(cart.GetOrderDiscountTotal());
if (orderLevelDiscount > 0)
{
// Order level discounts with tax
var totalOrderAmountWithoutDiscount =
orderLines
.Sum(x => x.TotalAmount);
var totalOrderAmountWithDiscount = AmountHelper.GetAmount(orderGroupTotals.Total.Amount);
var orderLevelDiscountIncludingTax = totalOrderAmountWithoutDiscount - totalOrderAmountWithDiscount;
// Tax
var totalTaxAmountWithoutDiscount =
orderLines
.Sum(x => x.TotalTaxAmount);
var totalTaxAmountWithDiscount = AmountHelper.GetAmount(orderGroupTotals.TaxTotal);
var discountTax = totalTaxAmountWithoutDiscount - totalTaxAmountWithDiscount;
var taxRate = discountTax * 100 / (orderLevelDiscountIncludingTax - discountTax);
orderLines.Add(new OrderLine()
{
Type = OrderLineType.discount,
Name = "Discount",
Quantity = 1,
TotalAmount = orderLevelDiscountIncludingTax * -1,
UnitPrice = orderLevelDiscountIncludingTax * -1,
TotalTaxAmount = discountTax * -1,
TaxRate = AmountHelper.GetAmount(taxRate)
});
}
return(orderLines);
}
private decimal RequiredAmountInTokens(Swap swap, Erc20Config erc20)
{
var requiredAmountInERC20 = AmountHelper.QtyToSellAmount(swap.Side, swap.Qty, swap.Price, erc20.DigitsMultiplier);
// maker network fee
if (swap.MakerNetworkFee > 0 && swap.MakerNetworkFee < requiredAmountInERC20) // network fee size check
{
requiredAmountInERC20 += AmountHelper.RoundDown(swap.MakerNetworkFee, erc20.DigitsMultiplier);
}
return(requiredAmountInERC20);
}
private async Task <IBitcoinBasedTransaction> CreateRedeemTxAsync(
Swap swap,
IBitcoinBasedTransaction paymentTx,
string redeemAddress,
byte[] redeemScript,
bool increaseSequenceNumber = false)
{
Log.Debug("Create redeem tx for swap {@swapId}", swap.Id);
var currency = Currencies.Get <BitcoinBasedConfig>(Currency);
var amountInSatoshi = currency.CoinToSatoshi(
AmountHelper.QtyToSellAmount(
swap.Side.Opposite(),
swap.Qty,
swap.Price,
currency.DigitsMultiplier));
var sequenceNumber = 0u;
if (increaseSequenceNumber)
{
var previousSequenceNumber = (swap?.RedeemTx as IBitcoinBasedTransaction)?.GetSequenceNumber(0) ?? 0;
sequenceNumber = previousSequenceNumber == 0
? Sequence.SEQUENCE_FINAL - 1024
: (previousSequenceNumber == Sequence.SEQUENCE_FINAL
? Sequence.SEQUENCE_FINAL
: previousSequenceNumber + 1);
}
var tx = await _transactionFactory
.CreateSwapRedeemTxAsync(
paymentTx : paymentTx,
amount : amountInSatoshi,
redeemAddress : redeemAddress,
redeemScript : redeemScript,
currency : currency,
sequenceNumber : sequenceNumber)
.ConfigureAwait(false);
if (tx == null)
{
throw new InternalException(
code: Errors.TransactionCreationError,
description: $"Redeem tx creation error for swap {swap.Id}");
}
tx.Type = BlockchainTransactionType.Output | BlockchainTransactionType.SwapRedeem;
return(tx);
}
public static ShippingOption ToShippingOption(this ShippingMethodDto.ShippingMethodRow method)
{
return(new ShippingOption
{
Id = method.ShippingMethodId.ToString(),
Name = method.DisplayName,
Price = AmountHelper.GetAmount(method.BasePrice),
PreSelected = method.IsDefault,
TaxAmount = 0,
TaxRate = 0,
Description = method.Description
});
}
private List <OrderLine> GetOrderLinesWithoutTax(ICart cart, OrderGroupTotals orderGroupTotals, bool sendProductAndImageUrl)
{
var shipment = cart.GetFirstShipment();
var orderLines = new List <OrderLine>();
// Line items
foreach (var lineItem in cart.GetAllLineItems())
{
var orderLine = lineItem.GetOrderLine(sendProductAndImageUrl);
orderLines.Add(orderLine);
}
// Shipment
if (shipment != null && orderGroupTotals.ShippingTotal.Amount > 0)
{
var shipmentOrderLine = shipment.GetOrderLine(cart, orderGroupTotals, false);
orderLines.Add(shipmentOrderLine);
}
// Sales tax
orderLines.Add(new PatchedOrderLine()
{
Type = "sales_tax",
Name = "Sales Tax",
Quantity = 1,
TotalAmount = AmountHelper.GetAmount(orderGroupTotals.TaxTotal),
UnitPrice = AmountHelper.GetAmount(orderGroupTotals.TaxTotal),
TotalTaxAmount = 0,
TaxRate = 0
});
// Order level discounts
var orderDiscount = cart.GetOrderDiscountTotal(cart.Currency);
var entryLevelDiscount = cart.GetAllLineItems().Sum(x => x.GetEntryDiscount());
var totalDiscount = orderDiscount.Amount + entryLevelDiscount;
if (totalDiscount > 0)
{
orderLines.Add(new PatchedOrderLine()
{
Type = "discount",
Name = "Discount",
Quantity = 1,
TotalAmount = -AmountHelper.GetAmount(totalDiscount),
UnitPrice = -AmountHelper.GetAmount(totalDiscount),
TotalTaxAmount = 0,
TaxRate = 0
});
}
return(orderLines);
}
public static Prices GetPrices(ILineItem lineItem, IMarket market, IShipment shipment, Currency currency)
{
/*
* unit_price integer required
* Minor units. Includes tax, excludes discount. (max value: 100000000)
* tax_rate integer required
* Non-negative. In percent, two implicit decimals. I.e 2500 = 25%.
* total_amount integer required
* Includes tax and discount. Must match (quantity * unit_price) - total_discount_amount within �quantity. (max value: 100000000)
* total_tax_amount integer required
* Must be within �1 of total_amount - total_amount * 10000 / (10000 + tax_rate). Negative when type is discount.
* total_discount_amount integer
* Non - negative minor units. Includes tax.
*/
var taxType = TaxType.SalesTax;
// All excluding tax
var unitPrice = lineItem.PlacedPrice;
var totalPriceWithoutDiscount = lineItem.PlacedPrice * lineItem.Quantity;
var extendedPrice = lineItem.GetDiscountedPrice(currency);
var discountAmount = (totalPriceWithoutDiscount - extendedPrice);
// Tax value
var taxValues = _lineItemTaxCalculator.Service.GetTaxValuesForLineItem(lineItem, market, shipment);
var taxPercentage = taxValues
.Where(x => x.TaxType == taxType)
.Sum(x => (decimal)x.Percentage);
// Using ITaxCalculator instead of ILineItemCalculator because ILineItemCalculator
// calculates tax from the price which includes order discount amount and line item discount amount
// but should use only line item discount amount
var salesTax =
_taxCalculator.Service.GetSalesTax(lineItem, market, shipment.ShippingAddress, extendedPrice);
// Includes tax, excludes discount. (max value: 100000000)
var unitPriceIncludingTax = AmountHelper.GetAmount(
_lineItemTaxCalculator.Service.PriceIncludingTaxPercent(unitPrice, taxPercentage, market));
// Non - negative minor units. Includes tax
var totalDiscountAmount = AmountHelper.GetAmount(
_lineItemTaxCalculator.Service.PriceIncludingTaxPercent(discountAmount, taxPercentage, market));
// Includes tax and discount. Must match (quantity * unit_price) - total_discount_amount within quantity. (max value: 100000000)
var totalAmount = AmountHelper.GetAmount(
_lineItemTaxCalculator.Service.PriceIncludingTaxAmount(extendedPrice, salesTax.Amount, market));
// Non-negative. In percent, two implicit decimals. I.e 2500 = 25%.
var taxRate = AmountHelper.GetAmount(taxPercentage);
// Must be within 1 of total_amount - total_amount * 10000 / (10000 + tax_rate). Negative when type is discount.
var totalTaxAmount = AmountHelper.GetAmount(salesTax.Amount);
return(new Prices(unitPriceIncludingTax, taxRate, totalDiscountAmount, totalAmount, totalTaxAmount));
}
public static SwapViewModel CreateSwapViewModel(Swap swap, ICurrencies currencies)
{
try
{
var soldCurrency = currencies.GetByName(swap.SoldCurrency);
var purchasedCurrency = currencies.GetByName(swap.PurchasedCurrency);
var fromCurrencyViewModel = CurrencyViewModelCreator.CreateViewModel(
currencyConfig: soldCurrency,
subscribeToUpdates: false);
var toCurrencyViewModel = CurrencyViewModelCreator.CreateViewModel(
currencyConfig: purchasedCurrency,
subscribeToUpdates: false);
var fromAmount = AmountHelper.QtyToAmount(swap.Side, swap.Qty, swap.Price, soldCurrency.DigitsMultiplier);
var toAmount = AmountHelper.QtyToAmount(swap.Side.Opposite(), swap.Qty, swap.Price, purchasedCurrency.DigitsMultiplier);
var quoteCurrency = swap.Symbol.QuoteCurrency() == swap.SoldCurrency
? soldCurrency
: purchasedCurrency;
return(new SwapViewModel
{
Id = swap.Id.ToString(),
CompactState = CompactStateBySwap(swap),
Mode = ModeBySwap(swap),
Time = swap.TimeStamp,
FromBrush = new SolidColorBrush(fromCurrencyViewModel.AmountColor),
FromAmount = fromAmount,
FromAmountFormat = fromCurrencyViewModel.CurrencyFormat,
FromCurrencyCode = fromCurrencyViewModel.CurrencyCode,
ToBrush = new SolidColorBrush(toCurrencyViewModel.AmountColor),
ToAmount = toAmount,
ToAmountFormat = toCurrencyViewModel.CurrencyFormat,
ToCurrencyCode = toCurrencyViewModel.CurrencyCode,
Price = swap.Price,
PriceFormat = $"F{quoteCurrency.Digits}"
});
}
catch (Exception e)
{
Log.Error(e, $"Error while create SwapViewModel for {swap.Symbol} swap with id {swap.Id}");
return(null);
}
}
public Task <IBitcoinBasedTransaction> CreateSwapRefundTxAsync(
IBitcoinBasedTransaction paymentTx,
ClientSwap swap,
string refundAddress,
DateTimeOffset lockTime)
{
var currency = (BitcoinBasedCurrency)paymentTx.Currency;
var orderAmount = (long)(AmountHelper.QtyToAmount(swap.Side, swap.Qty, swap.Price) *
currency.DigitsMultiplier);
var swapOutputs = paymentTx.Outputs
.Cast <BitcoinBasedTxOutput>()
.Where(o => o.Value == orderAmount && o.IsSwapPayment)
.ToList();
if (swapOutputs.Count != 1)
{
throw new Exception("Payment tx must have only one swap payment output");
}
var estimatedSigSize = EstimateSigSize(swapOutputs, forRefund: true);
var txSize = currency
.CreateSwapRefundTx(
unspentOutputs: swapOutputs,
destinationAddress: refundAddress,
changeAddress: refundAddress,
amount: orderAmount,
fee: 0,
lockTime: lockTime)
.VirtualSize();
var fee = (long)(currency.FeeRate * (txSize + estimatedSigSize));
if (orderAmount - fee < 0)
{
throw new Exception($"Insufficient funds for fee. Available {orderAmount}, required {fee}");
}
var tx = currency.CreateSwapRefundTx(
unspentOutputs: swapOutputs,
destinationAddress: refundAddress,
changeAddress: refundAddress,
amount: orderAmount - fee,
fee: fee,
lockTime: lockTime);
return(Task.FromResult(tx));
}
#pragma warning restore 649
public static OrderLine GetOrderLine(this IShipment shipment, ICart cart, OrderGroupTotals totals, bool includeTaxes)
{
var total = AmountHelper.GetAmount(totals.ShippingTotal);
var totalTaxAmount = 0;
var taxRate = 0;
if (includeTaxes)
{
var market = _marketService.Service.GetMarket(cart.MarketId);
var shippingTaxTotal = _shippingCalculator.Service.GetShippingTax(shipment, market, cart.Currency);
if (shippingTaxTotal.Amount > 0)
{
totalTaxAmount = AmountHelper.GetAmount(shippingTaxTotal.Amount);
var shippingTotalExcludingTax = market.PricesIncludeTax
? totals.ShippingTotal.Amount - shippingTaxTotal.Amount
: totals.ShippingTotal.Amount;
taxRate = AmountHelper.GetAmount(shippingTaxTotal.Amount * 100 / shippingTotalExcludingTax);
if (!market.PricesIncludeTax)
{
total = total + totalTaxAmount;
}
}
}
var shipmentOrderLine = new OrderLine
{
Name = shipment.ShippingMethodName,
Quantity = 1,
UnitPrice = total,
TotalAmount = total,
TaxRate = taxRate,
TotalTaxAmount = totalTaxAmount,
Type = OrderLineType.shipping_fee
};
if (string.IsNullOrEmpty(shipmentOrderLine.Name))
{
var shipmentMethod = Mediachase.Commerce.Orders.Managers.ShippingManager.GetShippingMethod(shipment.ShippingMethodId)
.ShippingMethod.FirstOrDefault();
if (shipmentMethod != null)
{
shipmentOrderLine.Name = shipmentMethod.DisplayName;
}
}
return(shipmentOrderLine);
}
public void GetAmount_Should_ReturnDynamicRewardForFriendMention()
{
_statServiceMock.Setup(x => x.GetPreviousDayStat()).Returns(new Stat
{
Id = 1,
TotalWithdrawals = 333,
NewUsers = 190,
WithdrawalAmount = 2233.5m
});
var amountHelper = new AmountHelper(_appSettings, _statServiceMock.Object);
var reward = amountHelper.GetAmount(RewardType.FriendMention);
Assert.True(reward < _appSettings.BotSettings.AmountForTweetWithFriendMention);
}
public void GetAmount_Should_ReturnFixedRewardForTag()
{
_statServiceMock.Setup(x => x.GetPreviousDayStat()).Returns(new Stat
{
Id = 1,
TotalWithdrawals = 1,
NewUsers = 190,
WithdrawalAmount = 12.5m
});
var amountHelper = new AmountHelper(_appSettings, _statServiceMock.Object);
var reward = amountHelper.GetAmount(RewardType.Tag);
Assert.True(reward == _appSettings.BotSettings.AmountForTweetWithTag);
}
public List <ExchangesCurrency> GetExchangePrice(string currency, List <Exchanges> extList = null)
{
List <Exchanges> exchanges = extList;
if (exchanges == null)
{
exchanges = GetExchanges();
}
var tm = AmountHelper.DateTimeToUnixTimestamp(DateTime.UtcNow);
var exchange_stats = _dtoMain.mainDb.GetCollection <ExchangeTicker>("aaexchanges_real");
var exchangeStats = exchange_stats.Find(m => m.InCurrency == currency && m.OutCurrency == "BTC").SortByDescending(s => s.Volume).ToList();
var lst = new List <ExchangesCurrency>();
if (exchangeStats.Count == 0)
{
return(lst);
}
var trends = GetTrendByMarkets(currency);
foreach (var ex in exchangeStats)
{
var exchange = exchanges.FirstOrDefault(m => m.MarketId == ex.MarketID);
if (exchange == null)
{
continue;
}
string exchangeUrlCoin = currency;
if (exchange.ExchangeDirectUrlParam == "lower")
{
exchangeUrlCoin = exchangeUrlCoin.ToLower();
}
var directUrl = string.Format(exchange.ExchangeDirectUrl, exchangeUrlCoin);
lst.Add(new ExchangesCurrency()
{
Buy = ex.Buy,
Sell = ex.Sell,
Last = ex.Last,
Volume = ex.Volume,
Change = trends.ContainsKey(ex.MarketID) ? trends[ex.MarketID] : 0.0m,
Exchange = exchange.Exchange,
ExchangeUrl = exchange.ExchangeUrl,
ExchangeDirectUrl = directUrl,
Time = ex.Time,
MarketID = ex.MarketID
});
}
return(lst);
}
public (decimal, decimal) EstimateOrderPrices(
Side side,
decimal amount,
decimal amountDigitsMultiplier,
decimal qtyDigitsMultiplier)
{
var requiredAmount = amount;
lock (SyncRoot)
{
var book = side == Side.Buy
? Sells
: Buys;
if (amount == 0)
{
return(book.Any()
? (book.First().Key, book.First().Key)
: (0m, 0m));
}
var totalUsedQuoteAmount = 0m;
var totalUsedQty = 0m;
foreach (var entryPair in book)
{
var qty = entryPair.Value.Qty();
var price = entryPair.Key;
var availableAmount = AmountHelper.QtyToAmount(side, qty, price, amountDigitsMultiplier);
var usedAmount = Math.Min(requiredAmount, availableAmount);
var usedQty = AmountHelper.AmountToQty(side, usedAmount, price, qtyDigitsMultiplier);
totalUsedQuoteAmount += usedQty * price;
totalUsedQty += usedQty;
requiredAmount -= usedAmount;
if (requiredAmount <= 0)
{
return(price, totalUsedQuoteAmount / totalUsedQty);
}
}
}
return(0m, 0m);
}
