public IEnumerable <ValidationResult> Validate(ECurrency currency)
{
if (string.IsNullOrWhiteSpace(Checksum))
{
yield return(new ValidationResult($"{nameof(Checksum)} parameter is required.", new[] { nameof(Checksum) }));
}
if (MatchedOrders == null)
{
yield return(new ValidationResult($"{nameof(MatchedOrders)} is required.", new[] { nameof(MatchedOrders) }));
}
else
{
foreach (var matchedOrder in MatchedOrders)
{
IEnumerable <ValidationResult> validation = matchedOrder.Validate(currency);
if (validation.Any())
{
foreach (var item in validation)
{
throw new ArgumentNullException(item.ErrorMessage);
}
}
}
}
}
private async Task <Result <FeeResponse, ErrorResponse> > getFeeAsync(ECurrency currency)
{
var result = new Result <FeeResponse, ErrorResponse>();
string requestUri = $"{mEnv.BaseUrl}/v1/{currency}/Fee";
try
{
using (HttpClient httpClient = new HttpClient())
using (HttpResponseMessage response = await httpClient.GetAsync(requestUri))
{
FeeResponse feeResponse = await response.Content.ReadAsAsync <FeeResponse>();
if (response.IsSuccessStatusCode)
{
result.IsSuccess = true;
result.Data = feeResponse;
return(result);
}
string contentString = await response.Content.ReadAsStringAsync();
result.Error = ResponseHandler.GetError(response.StatusCode, requestUri, contentString);
}
}
catch (HttpRequestException)
{
result.IsSuccess = false;
result.Error = ResponseHandler.GetExceptionError();
}
return(result);
}
private static void AssignValue(string input, ref ECurrency currency)
{
switch (input)
{
case "EUR": {
currency = ECurrency.EUR;
break;
}
case "USD": {
currency = ECurrency.USD;
break;
}
case "RON": {
currency = ECurrency.RON;
break;
}
default: {
currency = ECurrency.NO_CURRENCY;
break;
}
}
}
private Dictionary <ECurrency, Decimal> ParseCurrencies(
XmlNodeList nodes)
{
Dictionary <ECurrency, Decimal> dictionary = new Dictionary <ECurrency, Decimal>()
{
{
ECurrency.RUR,
Decimal.One
}
};
foreach (XmlElement node in nodes)
{
if (node["NumCode"] != null)
{
string key = node["NumCode"].InnerText.Trim();
if (this._innerCurrencies.ContainsKey(key))
{
ECurrency innerCurrency = this._innerCurrencies[key];
dictionary.Add(innerCurrency, this.ExtractActualCurse(node));
}
}
}
return(dictionary);
}
internal static string GetAddressSignature(string privateKey, ECurrency currency, Environment environment)
{
if (string.IsNullOrWhiteSpace(privateKey))
{
throw new ArgumentNullException(nameof(privateKey));
}
string timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds().ToString();
string signature = null;
if (currency == ECurrency.BTC)
{
BitcoinSecret secret = new BitcoinSecret(privateKey, environment.Network);
signature = secret.PrivateKey.SignMessage(timestamp);
}
else if (currency.IsGluwaCoinCurrency())
{
var signer = new EthereumMessageSigner();
signature = signer.EncodeUTF8AndSign(timestamp, new EthECKey(privateKey));
}
else
{
throw new ArgumentOutOfRangeException($"Unsupported currency: {currency}");
}
string signatureToEncode = $"{timestamp}.{signature}";
byte[] signatureByte = Encoding.UTF8.GetBytes(signatureToEncode);
string encodedData = Convert.ToBase64String(signatureByte);
return(encodedData);
}
private static void ProcessInput(string fCurrency, ref ECurrency fromCurrency, string tCurrency, ref ECurrency toCurrency)
{
fCurrency = fCurrency.ToUpper().Trim();
tCurrency = tCurrency.ToUpper().Trim();
AssignValue(tCurrency, ref toCurrency);
AssignValue(fCurrency, ref fromCurrency);
}
public void CacheOut(ECurrency toCurrency, double val)
{
KeyValuePair <double, int> usdPair;
KeyValuePair <double, int> eurPair;
double sumInRon;
XmlReader.ExchangeRates.TryGetValue(ECurrency.USD.ToString(), out usdPair);
XmlReader.ExchangeRates.TryGetValue(ECurrency.EUR.ToString(), out eurPair);
sumInRon = (double)(val * eurPair.Key);
switch (toCurrency)
{
case ECurrency.USD:
money.TotalCacheValue = val;
break;
case ECurrency.EUR:
money.TotalCacheValue = (double)(sumInRon / usdPair.Key);
break;
case ECurrency.RON:
money.TotalCacheValue = (double)(val / usdPair.Key);
break;
}
Console.WriteLine($"{money.TotalCacheValue} {ECurrency.USD}");
}
public Foo(string name, ECurrency currency, decimal amount)
{
Id = Guid.NewGuid();
Name = name;
Currency = currency;
Amount = amount;
}
public Decimal GetActualCurse(ECurrency currency)
{
if (!this.IsLoadedData || !this.LastLoadData.ContainsKey(currency))
{
return(Decimal.Zero);
}
return(this.LastLoadData[currency]);
}
public Currency GetCurrency(ECurrency currency)
{
var request = new RestRequest($"public/currency/{currency.ToString()}", Method.GET);
IRestResponse response = client.Execute(request);
var content = response.Content;
return(JsonConvert.DeserializeObject <Currency>(content));
}
public Task <string> BuyListing(long id, ECurrency currency, double subtotal, double total, Proxy proxy = null)
{
var subtotalConverted = (long)(subtotal * 100);
var totalConverted = (long)(total * 100);
var fee = totalConverted - subtotalConverted;
return(BuyListing(id, currency, subtotalConverted, fee, totalConverted, proxy));
}
public Task <JListings> Listings(EApp app, string hashName, ECurrency currency, int count = 10, bool withAuth = false, Proxy proxy = null)
{
var request = new RestRequest($"/market/listings/{(int)app}/{hashName}/render");
request.AddQueryParameter("currency", ((int)currency).ToString());
request.AddQueryParameter("count", count.ToString());
return(_client.SteamRequestAsync <JListings>(request, withAuth, proxy));
}
public string GetCurrency(ECurrency currency)
{
switch (currency)
{
case ECurrency.Euro: return("978");
default: return("978");
}
}
/// <summary>
/// Get a list of accepted quotes.
/// </summary>
/// <param name="currency">The source currency of the quote.</param>
/// <param name="address">The sending address of the quote.</param>
/// <param name="privateKey">The privateKey of the sending address.</param>
/// <response code="200">array of Quotes.</response>
/// <response code="400_InvalidUrlParameters">Invalid URL parameters.</response>
/// <response code="403_SignatureMissing">X-REQUEST-SIGNATURE header is missing.</response>
/// <response code="403_SignatureExpired">X-REQUEST-SIGNATURE has expired.</response>
/// <response code="403_InvalidSignature">Invalid X-REQUEST-SIGNATURE.</response>
/// <response code="500">Server error.</response>
/// <returns></returns>
public async Task <Result <List <GetQuotesResponse>, ErrorResponse> > GetQuotesAsync(
ECurrency currency,
string address,
string privateKey)
{
GetQuotesOptions options = new GetQuotesOptions();
return(await GetQuotesAsync(currency, address, privateKey, options));
}
/// <summary>
/// Constructs a Currency object from an ECurrency value.
/// </summary>
/// <param name="eCurrency"></param>
public Currency(ECurrency eCurrency)
{
this.eCurrency = eCurrency;
if (markets.Contains(eCurrency))
significance = markets.IndexOf(eCurrency) + 1;
else
significance = 0;
}
public static int GetCurrency(ECurrency Currency)
{
string identifier = Currency.ToIdentifier();
if (VirtualCurrency.ContainsKey(identifier) == true)
{
return(VirtualCurrency[identifier]);
}
return(0);
}
/// <summary>
/// Returns a products list, where all producs have a price accourding to a currency.
/// </summary>
/// <param name="currency">Currency that determines each product price.</param>
/// <returns>Products.</returns>
public IEnumerable <Product> ListByCurrency(ECurrency currency)
{
var products = _repositorio.List();
if (currency == ECurrency.Real)
{
products.ApplyExchangeRate(3.30M);
}
return(products);
}
public Task <JRecent> Recent(string country, ELanguage language, ECurrency currency, Proxy proxy = null)
{
var request = new RestRequest("/market/recent");
request.AddQueryParameter("country", country);
request.AddQueryParameter("language", language.ToString().ToLower());
request.AddQueryParameter("currency", ((int)currency).ToString());
return(_client.SteamRequestAsync <JRecent>(request, false, proxy));
}
public Task <JPriceOverview> PriceOverview(ECurrency currency, EApp app, string hashName, Proxy proxy = null)
{
var request = new RestRequest("/market/priceoverview/");
request.AddQueryParameter("currency", ((int)currency).ToString());
request.AddQueryParameter("appid", ((int)app).ToString());
request.AddQueryParameter("market_hash_name", hashName);
return(_client.SteamRequestAsync <JPriceOverview>(request, false, proxy));
}
public async Task <AppResult <Rate_vw> > GetRateAsync(ECurrency from, ECurrency to)
{
var result = await _requester.SendAsync <RatesData>(ERestCall.Get);
return(new AppResult <Rate_vw>(new Rate_vw()
{
Date = result.Date,
ExchangeRate = result.GetRate(from.ToString(), to.ToString()),
From = from,
To = to
}));
}
/// <summary>
/// Constructs a Currency object from an ECurrency value.
/// </summary>
/// <param name="eCurrency"></param>
public Currency(ECurrency eCurrency)
{
this.eCurrency = eCurrency;
if (markets.Contains(eCurrency))
{
significance = markets.IndexOf(eCurrency) + 1;
}
else
{
significance = 0;
}
}
public Task <JCreateOrder> CreateOrder(string hashName, EApp app, ECurrency currency, double totalPrice, int quantity, Proxy proxy = null)
{
var request = new RestRequest("/market/createbuyorder/", Method.POST);
request.AddHeader("Referer", $"https://steamcommunity.com/market/listings/{(int)app}/{hashName}");
request.AddParameter("sessionid", _client.Auth.Session(), ParameterType.GetOrPost);
request.AddParameter("currency", (int)currency, ParameterType.GetOrPost);
request.AddParameter("appid", (int)app, ParameterType.GetOrPost);
request.AddParameter("market_hash_name", HttpUtility.UrlDecode(hashName), ParameterType.GetOrPost);
request.AddParameter("price_total", (totalPrice * 100 * quantity).ToString(CultureInfo.InvariantCulture), ParameterType.GetOrPost);
request.AddParameter("quantity", quantity, ParameterType.GetOrPost);
return(_client.SteamRequestAsync <JCreateOrder>(request, true, proxy));
}
public Task <string> BuyListing(long id, ECurrency currency, long subtotal, long fee, long total, Proxy proxy = null)
{
var request = new RestRequest($"/market/buylisting/{id}", Method.POST);
request.AddHeader("Referer", "https://steamcommunity.com/market/");
request.AddParameter("sessionid", _client.Auth.Session(), ParameterType.GetOrPost);
request.AddParameter("currency", (int)currency, ParameterType.GetOrPost);
request.AddParameter("quantity", 1, ParameterType.GetOrPost);
request.AddParameter("subtotal", subtotal, ParameterType.GetOrPost);
request.AddParameter("fee", fee, ParameterType.GetOrPost);
request.AddParameter("total", total, ParameterType.GetOrPost);
return(_client.SteamRequestRawAsync(request, true, proxy));
}
/// <summary>
/// Get an accepted quote with ID.
/// </summary>
/// <param name="currency">The source currency of the quote.</param>
/// <param name="privateKey">The privateKey of the sending address of the quote.</param>
/// <param name="ID">ID of the accepted quote.</param>
/// <response code="200">The quote with a specified ID.</response>
/// <response code="400_InvalidUrlParameters">Invalid URL parameters.</response>
/// <response code="403_SignatureMissing">X-REQUEST-SIGNATURE header is missing.</response>
/// <response code="403_SignatureExpired">X-REQUEST-SIGNATURE has expired.</response>
/// <response code="403_InvalidSignature">Invalid X-REQUEST-SIGNATURE.</response>
/// <response code="404">Quote is not found.</response>
/// <response code="500">Server error.</response>
/// <returns></returns>
public async Task <Result <GetQuoteResponse, ErrorResponse> > GetQuoteAsync(ECurrency currency, string privateKey, Guid?ID)
{
#region
if (!currency.IsGluwaExchangeCurrency())
{
throw new ArgumentOutOfRangeException($"Unsupported currency: {currency}");
}
if (ID == null || ID == Guid.Empty)
{
throw new ArgumentNullException(nameof(ID));
}
#endregion
var result = new Result <GetQuoteResponse, ErrorResponse>();
string requestUri = $"{mEnv.BaseUrl}/v1/Quotes/{ID}";
try
{
using (HttpClient httpClient = new HttpClient())
{
httpClient.DefaultRequestHeaders.Add(X_REQUEST_SIGNATURE, GluwaService.GetAddressSignature(privateKey, currency, mEnv));
using (HttpResponseMessage response = await httpClient.GetAsync(requestUri))
{
if (response.IsSuccessStatusCode)
{
GetQuoteResponse quoteResponse = await response.Content.ReadAsAsync <GetQuoteResponse>();
result.IsSuccess = true;
result.Data = quoteResponse;
return(result);
}
string contentString = await response.Content.ReadAsStringAsync();
result.Error = ResponseHandler.GetError(response.StatusCode, requestUri, contentString);
}
}
}
catch (HttpRequestException)
{
result.IsSuccess = false;
result.Error = ResponseHandler.GetExceptionError();
}
return(result);
}
private static void ConsumeCurrency(ECurrency _Currency, int _Amount)
{
SubtractUserVirtualCurrencyRequest request = new SubtractUserVirtualCurrencyRequest()
{
Amount = _Amount,
VirtualCurrency = _Currency.ToIdentifier()
};
PlayFabClientAPI.SubtractUserVirtualCurrency(request, OnTransactionResult,
(error) =>
{
Debug.Log("Got error substractin user currency :");
Debug.Log(error.GenerateErrorReport());
});
}
/// <summary>
/// Get balance for specified currency.
/// </summary>
/// <param name="currency">Currency type.</param>
/// <param name="address">Your public Address.</param>
/// <param name="includeUnspentOutputs">(For BTC only) if "true", the response includes unspent outputs for the address. "false" by default.</param>
/// <response code="200">Balance and associated currency.</response>
/// <response code="400">Invalid address format.</response>
/// <response code="500">Server error.</response>
/// <response code="503">Service unavailable for the specified currency or temporarily.</response>
public async Task <Result <BalanceResponse, ErrorResponse> > GetBalanceAsync(ECurrency currency, string address, bool includeUnspentOutputs = false)
{
if (string.IsNullOrWhiteSpace(address))
{
throw new ArgumentNullException(nameof(address));
}
var result = new Result <BalanceResponse, ErrorResponse>();
string requestUri = $"{mEnv.BaseUrl}/v1/{currency}/Addresses/{address}";
List <string> queryParams = new List <string>();
queryParams.Add($"includeUnspentOutputs={includeUnspentOutputs}");
if (queryParams.Any())
{
requestUri = $"{requestUri}?{string.Join("&", queryParams)}";
}
try
{
using (HttpClient httpClient = new HttpClient())
using (HttpResponseMessage response = await httpClient.GetAsync(requestUri))
{
if (response.IsSuccessStatusCode)
{
BalanceResponse balanceResponse = await response.Content.ReadAsAsync <BalanceResponse>();
result.IsSuccess = true;
result.Data = balanceResponse;
return(result);
}
string contentString = await response.Content.ReadAsStringAsync();
result.Error = ResponseHandler.GetError(response.StatusCode, requestUri, contentString);
}
}
catch (HttpRequestException)
{
result.IsSuccess = false;
result.Error = ResponseHandler.GetExceptionError();
}
return(result);
}
private static void UpdateCurrency(
EBookmakers bookmaker,
Settings settings,
ECurrency newCurrency)
{
Dictionary <EBookmakers, Bookmaker> dictionary = settings.UserSettings.BookmakersList.ToDictionary <Bookmaker, EBookmakers, Bookmaker>((Func <Bookmaker, EBookmakers>)(x => x.EBookmaker), (Func <Bookmaker, Bookmaker>)(x => x));
if (!dictionary.ContainsKey(bookmaker))
{
Bookmaker bookmaker1 = AllBookmakersHelper.GetBookmaker(bookmaker);
settings.UserSettings.BookmakersList.Add(bookmaker1);
}
else
{
dictionary[bookmaker].CurrentCurrency = newCurrency;
}
}
internal static bool IsGluwaCoinCurrency(this ECurrency currency)
{
switch (currency)
{
case ECurrency.KRWG:
case ECurrency.USDG:
case ECurrency.NGNG:
case ECurrency.sUSDCG:
case ECurrency.sNGNG:
return(true);
case ECurrency.BTC:
return(false);
default:
throw new ArgumentOutOfRangeException($"Unsupported currency: {currency}");
}
}
private string getGluwacoinReserveTxnSignature(
ECurrency currency,
string address,
string amount,
string fee,
string target,
string executor,
BigInteger nonce,
BigInteger expiryBlockNumber,
string privateKey)
{
BigInteger convertAmount = BigInteger.Zero;
BigInteger convertFee = BigInteger.Zero;
if (currency.IsGluwacoinSideChainCurrency())
{
convertAmount = GluwacoinConverter.ConvertToGluwacoinSideChainBigInteger(amount, currency);
convertFee = GluwacoinConverter.ConvertToGluwacoinSideChainBigInteger(fee, currency);
}
else
{
convertAmount = GluwacoinConverter.ConvertToGluwacoinBigInteger(amount);
convertFee = GluwacoinConverter.ConvertToGluwacoinBigInteger(fee);
}
ABIEncode abiEncode = new ABIEncode();
byte[] messageHash = abiEncode.GetSha3ABIEncodedPacked(
new ABIValue("address", GluwaService.getGluwacoinContractAddress(currency, mEnv)),
new ABIValue("address", address),
new ABIValue("address", target),
new ABIValue("address", executor),
new ABIValue("uint256", convertAmount),
new ABIValue("uint256", convertFee),
new ABIValue("uint256", nonce),
new ABIValue("uint256", expiryBlockNumber)
);
EthereumMessageSigner signer = new EthereumMessageSigner();
string signature = signer.Sign(messageHash, privateKey);
return(signature);
}
public string GetParseNumber(ECurrency typeCurrency)
{
float _currencyRemain = GetCurrency(typeCurrency);
switch (Mathf.Log10(GetCurrency(typeCurrency)))
{
case float _c when _c >= 6: return(SetNumber(6, "M"));
case float _c when _c >= 3: return(SetNumber(3, "K"));
default: return(_currencyRemain.ToString("N0"));
}
string SetNumber(int count, string formats)
{
StringBuilder _number = new StringBuilder().Append(_currencyRemain).Remove(((int)Mathf.Log10(_currencyRemain) - (count - 1)), count);
return($"{_number}{formats}");
}
}
public IEnumerable <ValidationResult> Validate(ECurrency currency)
{
if (OrderID == null || OrderID == Guid.Empty)
{
yield return(new ValidationResult($"{nameof(OrderID)} parameter is required.", new[] { nameof(OrderID) }));
}
else if (string.IsNullOrWhiteSpace(DestinationAddress))
{
yield return(new ValidationResult($"{nameof(DestinationAddress)} parameter is required.", new[] { nameof(DestinationAddress) }));
}
else if (string.IsNullOrWhiteSpace(SourceAmount))
{
yield return(new ValidationResult($"{nameof(SourceAmount)} parameter is required.", new[] { nameof(SourceAmount) }));
}
else if (string.IsNullOrWhiteSpace(Fee))
{
yield return(new ValidationResult($"{nameof(Fee)} parameter is required.", new[] { nameof(Fee) }));
}
if (currency == ECurrency.BTC)
{
if (string.IsNullOrWhiteSpace(ReservedFundsAddress))
{
yield return(new ValidationResult($"{nameof(ReservedFundsAddress)} parameter is required for {currency}.", new[] { nameof(ReservedFundsAddress) }));
}
else if (string.IsNullOrWhiteSpace(ReservedFundsRedeemScript))
{
yield return(new ValidationResult($"{nameof(ReservedFundsRedeemScript)} parameter is required for {currency}.", new[] { nameof(ReservedFundsRedeemScript) }));
}
}
else
{
if (string.IsNullOrWhiteSpace(ExpiryBlockNumber))
{
yield return(new ValidationResult($"{nameof(ExpiryBlockNumber)} parameter is required for {currency}.", new[] { nameof(ExpiryBlockNumber) }));
}
else if (string.IsNullOrWhiteSpace((Executor)))
{
yield return(new ValidationResult($"{nameof(Executor)} parameter is required for {currency}.", new[] { nameof(Executor) }));
}
}
}
