Here are the examples of the csharp api object.ValidateNotNull(string) taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.
80 Examples
19
Source : BinanceSocketClientFutures.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<CallResult<UpdateSubscription>> SubscribeToAggregatedTradeUpdatesAsync(IEnumerable<string> symbols, Action<DataEvent<BinanceStreamAggregatedTrade>> onMessage)
{
symbols.ValidateNotNull(nameof(symbols));
var handler = new Action<DataEvent<BinanceCombinedStream<BinanceStreamAggregatedTrade>>>(data => onMessage(data.As(data.Data.Data, data.Data.Data.Symbol)));
symbols = symbols.Select(a => a.ToLower(CultureInfo.InvariantCulture) + aggregatedTradesStreamEndpoint).ToArray();
return await Subscribe(symbols, handler).ConfigureAwait(false);
}
19
Source : BinanceSocketClientFutures.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<CallResult<UpdateSubscription>> SubscribeToBookTickerUpdatesAsync(IEnumerable<string> symbols, Action<DataEvent<BinanceFuturesStreamBookPrice>> onMessage)
{
symbols.ValidateNotNull(nameof(symbols));
var handler = new Action<DataEvent<BinanceCombinedStream<BinanceFuturesStreamBookPrice>>>(data => onMessage(data.As(data.Data.Data, data.Data.Data.Symbol)));
symbols = symbols.Select(a => a.ToLower(CultureInfo.InvariantCulture) + bookTickerStreamEndpoint).ToArray();
return await Subscribe(symbols, handler).ConfigureAwait(false);
}
19
Source : BinanceSocketClientFuturesCoin.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<CallResult<UpdateSubscription>> SubscribeToContinuousContractKlineUpdatesAsync(IEnumerable<string> pairs, ContractType contractType, KlineInterval interval, Action<DataEvent<BinanceStreamKlineData>> onMessage)
{
pairs.ValidateNotNull(nameof(pairs));
var handler = new Action<DataEvent<BinanceCombinedStream<BinanceStreamKlineData>>>(data => onMessage(data.As(data.Data.Data, data.Data.Data.Symbol)));
pairs = pairs.Select(a => a.ToLower(CultureInfo.InvariantCulture) +
"_" +
JsonConvert.SerializeObject(contractType, new ContractTypeConverter(false)).ToLower() +
continuousKlineStreamEndpoint +
"_" +
JsonConvert.SerializeObject(interval, new KlineIntervalConverter(false))).ToArray();
return await Subscribe(pairs, handler).ConfigureAwait(false);
}
19
Source : BinanceSocketClientFuturesUsdt.cs
with MIT License
from JKorf
with MIT License
from JKorf
public override async Task<CallResult<UpdateSubscription>> SubscribeToSymbolMiniTickerUpdatesAsync(IEnumerable<string> symbols, Action<DataEvent<IBinanceMiniTick>> onMessage)
{
symbols.ValidateNotNull(nameof(symbols));
var handler = new Action<DataEvent<BinanceCombinedStream<BinanceStreamMiniTick>>>(data => onMessage(data.As<IBinanceMiniTick>(data.Data.Data, data.Data.Data.Symbol)));
symbols = symbols.Select(a => a.ToLower(CultureInfo.InvariantCulture) + symbolMiniTickerStreamEndpoint).ToArray();
return await Subscribe(symbols, handler).ConfigureAwait(false);
}
19
Source : BinanceSocketClientSpot.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<CallResult<UpdateSubscription>> SubscribeToTradeUpdatesAsync(IEnumerable<string> symbols,
Action<DataEvent<BinanceStreamTrade>> onMessage)
{
symbols.ValidateNotNull(nameof(symbols));
foreach (var symbol in symbols)
symbol.ValidateBinanceSymbol();
var handler = new Action<DataEvent<BinanceCombinedStream<BinanceStreamTrade>>>(data => onMessage(data.As(data.Data.Data, data.Data.Data.Symbol)));
symbols = symbols.Select(a => a.ToLower(CultureInfo.InvariantCulture) + tradesStreamEndpoint).ToArray();
return await Subscribe(symbols, handler).ConfigureAwait(false);
}
19
Source : BinanceSocketClientSpot.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<CallResult<UpdateSubscription>> SubscribeToBookTickerUpdatesAsync(IEnumerable<string> symbols,
Action<DataEvent<BinanceStreamBookPrice>> onMessage)
{
symbols.ValidateNotNull(nameof(symbols));
foreach (var symbol in symbols)
symbol.ValidateBinanceSymbol();
var handler = new Action<DataEvent<BinanceCombinedStream<BinanceStreamBookPrice>>>(data => onMessage(data.As(data.Data.Data, data.Data.Data.Symbol)));
symbols = symbols.Select(a => a.ToLower(CultureInfo.InvariantCulture) + bookTickerStreamEndpoint).ToArray();
return await Subscribe(symbols, handler).ConfigureAwait(false);
}
19
Source : BinanceSocketClientSpot.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<CallResult<UpdateSubscription>> SubscribeToOrderBookUpdatesAsync(IEnumerable<string> symbols,
int? updateInterval, Action<DataEvent<IBinanceEventOrderBook>> onMessage)
{
symbols.ValidateNotNull(nameof(symbols));
foreach (var symbol in symbols)
symbol.ValidateBinanceSymbol();
updateInterval?.ValidateIntValues(nameof(updateInterval), 100, 1000);
var handler = new Action<DataEvent<BinanceCombinedStream<BinanceEventOrderBook>>>(data => onMessage(data.As<IBinanceEventOrderBook>(data.Data.Data, data.Data.Data.Symbol)));
symbols = symbols.Select(a =>
a.ToLower(CultureInfo.InvariantCulture) + depthStreamEndpoint +
(updateInterval.HasValue ? $"@{updateInterval.Value}ms" : "")).ToArray();
return await Subscribe(symbols, handler).ConfigureAwait(false);
}
19
Source : BinanceSocketClientSpot.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<CallResult<UpdateSubscription>> SubscribeToUserDataUpdatesAsync(
string listenKey,
Action<DataEvent<BinanceStreamOrderUpdate>>? onOrderUpdateMessage,
Action<DataEvent<BinanceStreamOrderList>>? onOcoOrderUpdateMessage,
Action<DataEvent<BinanceStreamPositionsUpdate>>? onAccountPositionMessage,
Action<DataEvent<BinanceStreamBalanceUpdate>>? onAccountBalanceUpdate)
{
listenKey.ValidateNotNull(nameof(listenKey));
var handler = new Action<DataEvent<string>>(data =>
{
var combinedToken = JToken.Parse(data.Data);
var token = combinedToken["data"];
if (token == null)
return;
var evnt = token["e"]?.ToString();
if (evnt == null)
return;
switch (evnt)
{
case executionUpdateEvent:
{
var result = _baseClient.DeserializeInternal<BinanceStreamOrderUpdate>(token, false);
if (result)
onOrderUpdateMessage?.Invoke(data.As(result.Data, result.Data.OrderId.ToString()));
else
_log.Write(LogLevel.Warning,
"Couldn't deserialize data received from order stream: " + result.Error);
break;
}
case ocoOrderUpdateEvent:
{
var result = _baseClient.DeserializeInternal<BinanceStreamOrderList>(token, false);
if (result)
onOcoOrderUpdateMessage?.Invoke(data.As(result.Data, result.Data.OrderListId.ToString()));
else
_log.Write(LogLevel.Warning,
"Couldn't deserialize data received from oco order stream: " + result.Error);
break;
}
case accountPositionUpdateEvent:
{
var result = _baseClient.DeserializeInternal<BinanceStreamPositionsUpdate>(token, false);
if (result)
onAccountPositionMessage?.Invoke(data.As(result.Data));
else
_log.Write(LogLevel.Warning,
"Couldn't deserialize data received from account position stream: " + result.Error);
break;
}
case balanceUpdateEvent:
{
var result = _baseClient.DeserializeInternal<BinanceStreamBalanceUpdate>(token, false);
if (result)
onAccountBalanceUpdate?.Invoke(data.As(result.Data, result.Data.replacedet));
else
_log.Write(LogLevel.Warning,
"Couldn't deserialize data received from account position stream: " + result.Error);
break;
}
default:
_log.Write(LogLevel.Warning, $"Received unknown user data event {evnt}: " + data);
break;
}
});
return await Subscribe(new[] { listenKey }, handler).ConfigureAwait(false);
}
19
Source : BinanceClientMargin.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<WebCallResult<BinanceTransaction>> RepayAsync(string replacedet, decimal amount, bool? isIsolated = null, string? symbol = null, int? receiveWindow = null, CancellationToken ct = default)
{
replacedet.ValidateNotNull(nameof(replacedet));
var timestampResult = await _baseClient.CheckAutoTimestamp(ct).ConfigureAwait(false);
if (!timestampResult)
return new WebCallResult<BinanceTransaction>(timestampResult.ResponseStatusCode, timestampResult.ResponseHeaders, null, timestampResult.Error);
var parameters = new Dictionary<string, object>
{
{ "replacedet", replacedet },
{ "amount", amount.ToString(CultureInfo.InvariantCulture) },
{ "timestamp", _baseClient.GetTimestamp() }
};
parameters.AddOptionalParameter("isIsolated", isIsolated?.ToString().ToLower());
parameters.AddOptionalParameter("symbol", symbol);
parameters.AddOptionalParameter("recvWindow", receiveWindow?.ToString(CultureInfo.InvariantCulture) ?? _baseClient.DefaultReceiveWindow.TotalMilliseconds.ToString(CultureInfo.InvariantCulture));
return await _baseClient.SendRequestInternal<BinanceTransaction>(_baseClient.GetUrlSpot(marginRepayEndpoint, marginApi, marginVersion), HttpMethod.Post, ct, parameters, true).ConfigureAwait(false);
}
19
Source : BinanceClientMargin.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<WebCallResult<IEnumerable<BinanceInterestRateHistory>>> GetInterestRateHistoryAsync(string replacedet, string? vipLevel = null, DateTime? startTime = null, DateTime? endTime = null, int? limit = null, long? receiveWindow = null, CancellationToken ct = default)
{
replacedet?.ValidateNotNull(nameof(replacedet));
limit?.ValidateIntBetween(nameof(limit), 1, 100);
var timestampResult = await _baseClient.CheckAutoTimestamp(ct).ConfigureAwait(false);
if (!timestampResult)
return new WebCallResult<IEnumerable<BinanceInterestRateHistory>>(timestampResult.ResponseStatusCode, timestampResult.ResponseHeaders, null, timestampResult.Error);
var parameters = new Dictionary<string, object>
{
{ "timestamp", _baseClient.GetTimestamp() },
{ "replacedet", replacedet! }
};
parameters.AddOptionalParameter("vipLevel", vipLevel?.ToString(CultureInfo.InvariantCulture));
parameters.AddOptionalParameter("size", limit?.ToString(CultureInfo.InvariantCulture));
parameters.AddOptionalParameter("startTime", startTime.HasValue ? JsonConvert.SerializeObject(startTime.Value, new TimestampConverter()) : null);
parameters.AddOptionalParameter("endTime", endTime.HasValue ? JsonConvert.SerializeObject(endTime.Value, new TimestampConverter()) : null);
parameters.AddOptionalParameter("recvWindow", receiveWindow?.ToString(CultureInfo.InvariantCulture) ?? _baseClient.DefaultReceiveWindow.TotalMilliseconds.ToString(CultureInfo.InvariantCulture));
return await _baseClient.SendRequestInternal<IEnumerable<BinanceInterestRateHistory>>(_baseClient.GetUrlSpot(interestRateHistoryEndpoint, marginApi, marginVersion), HttpMethod.Get, ct, parameters, true).ConfigureAwait(false);
}
19
Source : BinanceClientMargin.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<WebCallResult<BinanceMarginAmount>> GetMaxBorrowAmountAsync(string replacedet, string? isolatedSymbol = null, long? receiveWindow = null, CancellationToken ct = default)
{
replacedet.ValidateNotNull(nameof(replacedet));
var timestampResult = await _baseClient.CheckAutoTimestamp(ct).ConfigureAwait(false);
if (!timestampResult)
return new WebCallResult<BinanceMarginAmount>(timestampResult.ResponseStatusCode, timestampResult.ResponseHeaders, null, timestampResult.Error);
var parameters = new Dictionary<string, object>
{
{ "replacedet", replacedet },
{ "timestamp", _baseClient.GetTimestamp() }
};
parameters.AddOptionalParameter("isolatedSymbol", isolatedSymbol);
parameters.AddOptionalParameter("recvWindow", receiveWindow?.ToString(CultureInfo.InvariantCulture) ?? _baseClient.DefaultReceiveWindow.TotalMilliseconds.ToString(CultureInfo.InvariantCulture));
return await _baseClient.SendRequestInternal<BinanceMarginAmount>(_baseClient.GetUrlSpot(maxBorrowableEndpoint, "sapi", "1"), HttpMethod.Get, ct, parameters, true).ConfigureAwait(false);
}
19
Source : BinanceClientMargin.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<WebCallResult<decimal>> GetMaxTransferAmountAsync(string replacedet, string? isolatedSymbol = null, long? receiveWindow = null, CancellationToken ct = default)
{
replacedet.ValidateNotNull(nameof(replacedet));
var timestampResult = await _baseClient.CheckAutoTimestamp(ct).ConfigureAwait(false);
if (!timestampResult)
return new WebCallResult<decimal>(timestampResult.ResponseStatusCode, timestampResult.ResponseHeaders, 0, timestampResult.Error);
var parameters = new Dictionary<string, object>
{
{ "replacedet", replacedet },
{ "timestamp", _baseClient.GetTimestamp() }
};
parameters.AddOptionalParameter("isolatedSymbol", isolatedSymbol);
parameters.AddOptionalParameter("recvWindow", receiveWindow?.ToString(CultureInfo.InvariantCulture) ?? _baseClient.DefaultReceiveWindow.TotalMilliseconds.ToString(CultureInfo.InvariantCulture));
var result = await _baseClient.SendRequestInternal<BinanceMarginAmount>(_baseClient.GetUrlSpot(maxTransferableEndpoint, "sapi", "1"), HttpMethod.Get, ct, parameters, true).ConfigureAwait(false);
if (!result)
return new WebCallResult<decimal>(result.ResponseStatusCode, result.ResponseHeaders, 0, result.Error);
return result.As(result.Data.Amount);
}
19
Source : BinanceClientMarginMarket.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<WebCallResult<BinanceMarginreplacedet>> GetMarginreplacedetAsync(string replacedet, CancellationToken ct = default)
{
replacedet.ValidateNotNull(nameof(replacedet));
var parameters = new Dictionary<string, object>
{
{"replacedet", replacedet}
};
return await _baseClient.SendRequestInternal<BinanceMarginreplacedet>(_baseClient.GetUrlSpot(marginreplacedetEndpoint, marginApi, marginVersion), HttpMethod.Get, ct, parameters).ConfigureAwait(false);
}
19
Source : BinanceClientMarginMarket.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<WebCallResult<BinanceMarginPair>> GetMarginPairAsync(string symbol, CancellationToken ct = default)
{
symbol.ValidateNotNull(nameof(symbol));
var parameters = new Dictionary<string, object>
{
{"symbol", symbol}
};
return await _baseClient.SendRequestInternal<BinanceMarginPair>(_baseClient.GetUrlSpot(marginPairEndpoint, marginApi, marginVersion), HttpMethod.Get, ct, parameters).ConfigureAwait(false);
}
19
Source : BinanceClientMarginMarket.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<WebCallResult<BinanceMarginPriceIndex>> GetMarginPriceIndexAsync(string symbol, CancellationToken ct = default)
{
symbol.ValidateNotNull(nameof(symbol));
var parameters = new Dictionary<string, object>
{
{"symbol", symbol}
};
return await _baseClient.SendRequestInternal<BinanceMarginPriceIndex>(_baseClient.GetUrlSpot(marginPriceIndexEndpoint, marginApi, marginVersion), HttpMethod.Get, ct, parameters).ConfigureAwait(false);
}
19
Source : BinanceClientMarginUserStream.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<WebCallResult<object>> KeepAliveUserStreamAsync(string listenKey, CancellationToken ct = default)
{
listenKey.ValidateNotNull(nameof(listenKey));
var timestampResult = await _baseClient.CheckAutoTimestamp(ct).ConfigureAwait(false);
if (!timestampResult)
return new WebCallResult<object>(timestampResult.ResponseStatusCode, timestampResult.ResponseHeaders, null, timestampResult.Error);
var parameters = new Dictionary<string, object>
{
{ "listenKey", listenKey },
};
return await _baseClient.SendRequestInternal<object>(_baseClient.GetUrlSpot(keepListenKeyAliveEndpoint, "sapi", "1"), HttpMethod.Put, ct, parameters, true).ConfigureAwait(false);
}
19
Source : BinanceClientSpotUserStream.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<WebCallResult<object>> KeepAliveUserStreamAsync(string listenKey, CancellationToken ct = default)
{
listenKey.ValidateNotNull(nameof(listenKey));
var timestampResult = await _baseClient.CheckAutoTimestamp(ct).ConfigureAwait(false);
if (!timestampResult)
return new WebCallResult<object>(timestampResult.ResponseStatusCode, timestampResult.ResponseHeaders, null, timestampResult.Error);
var parameters = new Dictionary<string, object>
{
{ "listenKey", listenKey }
};
return await _baseClient.SendRequestInternal<object>(_baseClient.GetUrlSpot(keepListenKeyAliveEndpoint, api, userDataStreamVersion), HttpMethod.Put, ct, parameters).ConfigureAwait(false);
}
19
Source : BinanceClientSpotUserStream.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<WebCallResult<object>> StopUserStreamAsync(string listenKey, CancellationToken ct = default)
{
listenKey.ValidateNotNull(nameof(listenKey));
var timestampResult = await _baseClient.CheckAutoTimestamp(ct).ConfigureAwait(false);
if (!timestampResult)
return new WebCallResult<object>(timestampResult.ResponseStatusCode, timestampResult.ResponseHeaders, null, timestampResult.Error);
var parameters = new Dictionary<string, object>
{
{ "listenKey", listenKey }
};
return await _baseClient.SendRequestInternal<object>(_baseClient.GetUrlSpot(closeListenKeyEndpoint, api, userDataStreamVersion), HttpMethod.Delete, ct, parameters).ConfigureAwait(false);
}
19
Source : BinanceClientLending.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<WebCallResult<BinanceRedemptionQuotaLeft>> GetLeftDailyRedemptionQuotaOfFlexibleProductAsync(string productId, RedeemType type, long? receiveWindow = null, CancellationToken ct = default)
{
productId.ValidateNotNull(nameof(productId));
var timestampResult = await _baseClient.CheckAutoTimestamp(ct).ConfigureAwait(false);
if (!timestampResult)
return new WebCallResult<BinanceRedemptionQuotaLeft>(timestampResult.ResponseStatusCode, timestampResult.ResponseHeaders, null, timestampResult.Error);
var parameters = new Dictionary<string, object>
{
{ "productId", productId },
{ "type", JsonConvert.SerializeObject(type, new RedeemTypeConverter(false)) },
{ "timestamp", _baseClient.GetTimestamp() }
};
parameters.AddOptionalParameter("recvWindow", receiveWindow?.ToString(CultureInfo.InvariantCulture) ?? _baseClient.DefaultReceiveWindow.TotalMilliseconds.ToString(CultureInfo.InvariantCulture));
return await _baseClient.SendRequestInternal<BinanceRedemptionQuotaLeft>(_baseClient.GetUrlSpot(leftDailyRedemptionQuotaEndpoint, "sapi", "1"), HttpMethod.Get, ct, parameters, true).ConfigureAwait(false);
}
19
Source : BinanceClientLending.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<WebCallResult<IEnumerable<BinanceFlexibleProductPosition>>> GetFlexibleProductPositionAsync(string replacedet, long? receiveWindow = null, CancellationToken ct = default)
{
replacedet.ValidateNotNull(nameof(replacedet));
var timestampResult = await _baseClient.CheckAutoTimestamp(ct).ConfigureAwait(false);
if (!timestampResult)
return new WebCallResult<IEnumerable<BinanceFlexibleProductPosition>>(timestampResult.ResponseStatusCode, timestampResult.ResponseHeaders, null, timestampResult.Error);
var parameters = new Dictionary<string, object>
{
{ "replacedet", replacedet },
{ "timestamp", _baseClient.GetTimestamp() }
};
parameters.AddOptionalParameter("recvWindow", receiveWindow?.ToString(CultureInfo.InvariantCulture) ?? _baseClient.DefaultReceiveWindow.TotalMilliseconds.ToString(CultureInfo.InvariantCulture));
return await _baseClient.SendRequestInternal<IEnumerable<BinanceFlexibleProductPosition>>(_baseClient.GetUrlSpot(flexiblePositionEndpoint, "sapi", "1"), HttpMethod.Get, ct, parameters, true).ConfigureAwait(false);
}
19
Source : BinanceClientMining.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<WebCallResult<IEnumerable<BinanceMinerDetails>>> GetMinerDetailsAsync(string algorithm, string userName, string workerName, CancellationToken ct = default)
{
algorithm.ValidateNotNull(nameof(algorithm));
userName.ValidateNotNull(nameof(userName));
workerName.ValidateNotNull(nameof(workerName));
var parameters = new Dictionary<string, object>()
{
{"algo", algorithm},
{"userName", userName},
{"workerName", workerName},
{"timestamp", _baseClient.GetTimestamp()}
};
var result = await _baseClient.SendRequestInternal<BinanceResult<IEnumerable<BinanceMinerDetails>>>(_baseClient.GetUrlSpot(minerDetailsEndpoint, "sapi", "1"), HttpMethod.Get, ct, parameters, true).ConfigureAwait(false);
if (!result.Success)
return WebCallResult<IEnumerable<BinanceMinerDetails>>.CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, result.Error!);
if (result.Data?.Code != 0)
return WebCallResult<IEnumerable<BinanceMinerDetails>>.CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, new ServerError(result.Data!.Code, result.Data.Message));
return result.As(result.Data.Data);
}
19
Source : BinanceClientMining.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<WebCallResult<BinanceMinerList>> GetMinerListAsync(string algorithm, string userName, int? page = null, bool? sortAscending = null, string? sortColumn = null, MinerStatus? workerStatus = null, CancellationToken ct = default)
{
algorithm.ValidateNotNull(nameof(algorithm));
userName.ValidateNotNull(nameof(userName));
var parameters = new Dictionary<string, object>()
{
{"algo", algorithm},
{"userName", userName},
{"timestamp", _baseClient.GetTimestamp()}
};
parameters.AddOptionalParameter("page", page?.ToString(CultureInfo.InvariantCulture));
parameters.AddOptionalParameter("sortAscending", sortAscending == null ? null : sortAscending == true ? "1" : "0");
parameters.AddOptionalParameter("sortColumn", sortColumn);
parameters.AddOptionalParameter("workerStatus", workerStatus == null ? null : JsonConvert.SerializeObject(workerStatus, new MinerStatusConverter(false)));
var result = await _baseClient.SendRequestInternal<BinanceResult<BinanceMinerList>>(_baseClient.GetUrlSpot(minerListEndpoint, "sapi", "1"), HttpMethod.Get, ct, parameters, true).ConfigureAwait(false);
if (!result.Success)
return WebCallResult<BinanceMinerList>.CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, result.Error!);
if (result.Data?.Code != 0)
return WebCallResult<BinanceMinerList>.CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, new ServerError(result.Data!.Code, result.Data.Message));
return result.As(result.Data.Data);
}
19
Source : BinanceClientMining.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<WebCallResult<BinanceMiningAccount>> GetMiningAccountListAsync(string algorithm, string userName, CancellationToken ct = default)
{
algorithm.ValidateNotNull(nameof(algorithm));
userName.ValidateNotNull(nameof(userName));
var parameters = new Dictionary<string, object>()
{
{"algo", algorithm},
{"userName", userName},
{"timestamp", _baseClient.GetTimestamp()}
};
var result = await _baseClient.SendRequestInternal<BinanceResult<BinanceMiningAccount>>(_baseClient.GetUrlSpot(miningAccountListEndpoint, "sapi", "1"), HttpMethod.Get, ct, parameters, true).ConfigureAwait(false);
if (!result.Success)
return WebCallResult<BinanceMiningAccount>.CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, result.Error!);
if (result.Data?.Code != 0)
return WebCallResult<BinanceMiningAccount>.CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, new ServerError(result.Data!.Code, result.Data.Message));
return result.As(result.Data.Data);
}
19
Source : BinanceClientMining.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<WebCallResult<BinanceHashrateResaleDetails>> GetHashrateResaleDetailsAsync(int configId, string userName, int? page = null, int? pageSize = null, CancellationToken ct = default)
{
userName.ValidateNotNull(nameof(userName));
var parameters = new Dictionary<string, object>()
{
{ "configId", configId.ToString(CultureInfo.InvariantCulture) },
{ "userName", userName },
{"timestamp", _baseClient.GetTimestamp()}
};
parameters.AddOptionalParameter("pageIndex", page?.ToString(CultureInfo.InvariantCulture));
parameters.AddOptionalParameter("pageSize", pageSize?.ToString(CultureInfo.InvariantCulture));
var result = await _baseClient.SendRequestInternal<BinanceResult<BinanceHashrateResaleDetails>>(_baseClient.GetUrlSpot(miningHashrateResaleDetailsEndpoint, "sapi", "1"), HttpMethod.Get, ct, parameters, true).ConfigureAwait(false);
if (!result.Success)
return WebCallResult<BinanceHashrateResaleDetails>.CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, result.Error!);
if (result.Data?.Code != 0)
return WebCallResult<BinanceHashrateResaleDetails>.CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, new ServerError(result.Data!.Code, result.Data.Message));
return result.As(result.Data.Data);
}
19
Source : BinanceClientMining.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<WebCallResult<int>> PlaceHashrateResaleRequestAsync(string userName, string algorithm, DateTime startDate, DateTime endDate, string toUser, decimal hashRate, CancellationToken ct = default)
{
userName.ValidateNotNull(nameof(userName));
algorithm.ValidateNotNull(nameof(algorithm));
toUser.ValidateNotNull(nameof(toUser));
var parameters = new Dictionary<string, object>()
{
{ "userName", userName },
{ "algo", algorithm },
{ "startDate", JsonConvert.SerializeObject(startDate, new TimestampConverter()) },
{ "endDate", JsonConvert.SerializeObject(endDate, new TimestampConverter()) },
{ "toPoolUser", toUser },
{ "hashRate", hashRate },
{"timestamp", _baseClient.GetTimestamp()}
};
var result = await _baseClient.SendRequestInternal<BinanceResult<int>>(_baseClient.GetUrlSpot(miningHashrateResaleRequest, "sapi", "1"), HttpMethod.Post, ct, parameters, true).ConfigureAwait(false);
if (!result.Success)
return WebCallResult<int>.CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, result.Error!);
if (result.Data?.Code != 0)
return WebCallResult<int>.CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, new ServerError(result.Data!.Code, result.Data.Message));
return result.As(result.Data.Data);
}
19
Source : BinanceClientMining.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<WebCallResult<bool>> PlaceHashrateResaleRequestAsync(int configId, string userName, CancellationToken ct = default)
{
userName.ValidateNotNull(nameof(userName));
var parameters = new Dictionary<string, object>()
{
{ "configId", configId },
{ "userName", userName },
{"timestamp", _baseClient.GetTimestamp()}
};
var result = await _baseClient.SendRequestInternal<BinanceResult<bool>>(_baseClient.GetUrlSpot(miningHashrateResaleCancel, "sapi", "1"), HttpMethod.Post, ct, parameters, true).ConfigureAwait(false);
if (!result.Success)
return WebCallResult<bool>.CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, result.Error!);
if (result.Data?.Code != 0)
return WebCallResult<bool>.CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, new ServerError(result.Data!.Code, result.Data.Message));
return result.As(result.Data.Data);
}
19
Source : BinanceClientWithdrawDeposit.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<WebCallResult<BinanceWithdrawalPlaced>> WithdrawAsync(string replacedet, string address, decimal amount, string? withdrawOrderId = null, string? network = null, string? addressTag = null, string? name = null, bool? transactionFeeFlag = null, int? receiveWindow = null, CancellationToken ct = default)
{
replacedet.ValidateNotNull(nameof(replacedet));
address.ValidateNotNull(nameof(address));
var timestampResult = await _baseClient.CheckAutoTimestamp(ct).ConfigureAwait(false);
if (!timestampResult)
return new WebCallResult<BinanceWithdrawalPlaced>(timestampResult.ResponseStatusCode, timestampResult.ResponseHeaders, null, timestampResult.Error);
var parameters = new Dictionary<string, object>
{
{ "coin", replacedet },
{ "address", address },
{ "amount", amount.ToString(CultureInfo.InvariantCulture) },
{ "timestamp", _baseClient.GetTimestamp() }
};
parameters.AddOptionalParameter("name", name);
parameters.AddOptionalParameter("withdrawOrderId", withdrawOrderId);
parameters.AddOptionalParameter("network", network);
parameters.AddOptionalParameter("transactionFeeFlag", transactionFeeFlag);
parameters.AddOptionalParameter("addressTag", addressTag);
parameters.AddOptionalParameter("recvWindow", receiveWindow?.ToString(CultureInfo.InvariantCulture) ?? _baseClient.DefaultReceiveWindow.TotalMilliseconds.ToString(CultureInfo.InvariantCulture));
var result = await _baseClient.SendRequestInternal<BinanceWithdrawalPlaced>(_baseClient.GetUrlSpot(withdrawEndpoint, "sapi", "1"), HttpMethod.Post, ct, parameters, true, true, HttpMethodParameterPosition.InUri).ConfigureAwait(false);
return result;
}
19
Source : BinanceSocketClientFutures.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<CallResult<UpdateSubscription>> SubscribeToUserDataUpdatesAsync(
string listenKey,
Action<DataEvent<BinanceFuturesStreamConfigUpdate>>? onConfigUpdate,
Action<DataEvent<BinanceFuturesStreamMarginUpdate>>? onMarginUpdate,
Action<DataEvent<BinanceFuturesStreamAccountUpdate>>? onAccountUpdate,
Action<DataEvent<BinanceFuturesStreamOrderUpdate>>? onOrderUpdate,
Action<DataEvent<BinanceStreamEvent>>? onListenKeyExpired)
{
listenKey.ValidateNotNull(nameof(listenKey));
var handler = new Action<DataEvent<string>>(data =>
{
var combinedToken = JToken.Parse(data.Data);
var token = combinedToken["data"];
if (token == null)
return;
var evnt = token["e"]?.ToString();
if (evnt == null)
return;
switch (evnt)
{
case configUpdateEvent:
{
var result = BaseClient.DeserializeInternal<BinanceFuturesStreamConfigUpdate>(token, false);
if (result)
onConfigUpdate?.Invoke(data.As(result.Data, result.Data.LeverageUpdateData?.Symbol));
else
Log.Write(LogLevel.Warning, "Couldn't deserialize data received from config stream: " + result.Error);
break;
}
case marginUpdateEvent:
{
var result = BaseClient.DeserializeInternal<BinanceFuturesStreamMarginUpdate>(token, false);
if (result)
onMarginUpdate?.Invoke(data.As(result.Data));
else
Log.Write(LogLevel.Warning, "Couldn't deserialize data received from order stream: " + result.Error);
break;
}
case accountUpdateEvent:
{
var result = BaseClient.DeserializeInternal<BinanceFuturesStreamAccountUpdate>(token, false);
if (result.Success)
onAccountUpdate?.Invoke(data.As(result.Data));
else
Log.Write(LogLevel.Warning, "Couldn't deserialize data received from account stream: " + result.Error);
break;
}
case orderUpdateEvent:
{
var result = BaseClient.DeserializeInternal<BinanceFuturesStreamOrderUpdate>(token, false);
if (result)
onOrderUpdate?.Invoke(data.As(result.Data, result.Data.UpdateData.Symbol));
else
Log.Write(LogLevel.Warning, "Couldn't deserialize data received from order stream: " + result.Error);
break;
}
case listenKeyExpiredEvent:
{
var result = BaseClient.DeserializeInternal<BinanceStreamEvent>(token, false);
if (result)
onListenKeyExpired?.Invoke(data.As(result.Data));
else
Log.Write(LogLevel.Warning, "Couldn't deserialize data received from the expired listen key event: " + result.Error);
break;
}
default:
Log.Write(LogLevel.Warning, $"Received unknown user data event {evnt}: " + data);
break;
}
});
return await Subscribe(new[] { listenKey }, handler).ConfigureAwait(false);
}
19
Source : BinanceSocketClientFuturesCoin.cs
with MIT License
from JKorf
with MIT License
from JKorf
public override async Task<CallResult<UpdateSubscription>> SubscribeToKlineUpdatesAsync(IEnumerable<string> symbols, IEnumerable<KlineInterval> intervals, Action<DataEvent<IBinanceStreamKlineData>> onMessage)
{
symbols.ValidateNotNull(nameof(symbols));
var handler = new Action<DataEvent<BinanceCombinedStream<BinanceFuturesStreamCoinKlineData>>>(data =>
{
var result = data.Data.Data;
onMessage(data.As<IBinanceStreamKlineData>(result, result.Symbol));
});
symbols = symbols.SelectMany(a => intervals.Select(i => a.ToLower(CultureInfo.InvariantCulture) + klineStreamEndpoint + "_" + JsonConvert.SerializeObject(i, new KlineIntervalConverter(false)))).ToArray();
return await Subscribe(symbols, handler).ConfigureAwait(false);
}
19
Source : BinanceSocketClientFuturesCoin.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<CallResult<UpdateSubscription>> SubscribeToIndexPriceUpdatesAsync(IEnumerable<string> pairs, int? updateInterval, Action<DataEvent<IEnumerable<BinanceFuturesStreamIndexPrice>>> onMessage)
{
pairs.ValidateNotNull(nameof(pairs));
updateInterval?.ValidateIntValues(nameof(updateInterval), 1000, 3000);
var internalHandler = new Action<DataEvent<JToken>>(data => HandlePossibleSingleData(data, onMessage));
pairs = pairs.Select(a => a.ToLower(CultureInfo.InvariantCulture) + indexPriceStreamEndpoint + (updateInterval == 1000 ? "@1s" : "")).ToArray();
return await Subscribe(pairs, internalHandler).ConfigureAwait(false);
}
19
Source : BinanceSocketClientFuturesCoin.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<CallResult<UpdateSubscription>> SubscribeToMarkPriceUpdatesAsync(IEnumerable<string> symbols, int? updateInterval, Action<DataEvent<IEnumerable<BinanceFuturesCoinStreamMarkPrice>>> onMessage)
{
symbols.ValidateNotNull(nameof(symbols));
updateInterval?.ValidateIntValues(nameof(updateInterval), 1000, 3000);
var internalHandler = new Action<DataEvent<JToken>>(data => HandlePossibleSingleData(data, onMessage));
symbols = symbols.Select(a => a.ToLower(CultureInfo.InvariantCulture) + markPriceStreamEndpoint + (updateInterval == 1000 ? "@1s" : "")).ToArray();
return await Subscribe(symbols, internalHandler).ConfigureAwait(false);
}
19
Source : BinanceSocketClientFuturesCoin.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<CallResult<UpdateSubscription>> SubscribeToIndexKlineUpdatesAsync(IEnumerable<string> pairs, KlineInterval interval, Action<DataEvent<BinanceStreamIndexKlineData>> onMessage)
{
pairs.ValidateNotNull(nameof(pairs));
var handler = new Action<DataEvent<BinanceCombinedStream<BinanceStreamIndexKlineData>>>(data => onMessage(data.As(data.Data.Data, data.Data.Data.Symbol)));
pairs = pairs.Select(a => a.ToLower(CultureInfo.InvariantCulture) +
indexKlineStreamEndpoint +
"_" +
JsonConvert.SerializeObject(interval, new KlineIntervalConverter(false))).ToArray();
return await Subscribe(pairs, handler).ConfigureAwait(false);
}
19
Source : BinanceSocketClientFuturesCoin.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<CallResult<UpdateSubscription>> SubscribeToMarkPriceKlineUpdatesAsync(IEnumerable<string> symbols, KlineInterval interval, Action<DataEvent<BinanceStreamIndexKlineData>> onMessage)
{
symbols.ValidateNotNull(nameof(symbols));
var handler = new Action<DataEvent<BinanceCombinedStream<BinanceStreamIndexKlineData>>>(data => onMessage(data.As(data.Data.Data, data.Data.Data.Symbol)));
symbols = symbols.Select(a => a.ToLower(CultureInfo.InvariantCulture) +
markKlineStreamEndpoint +
"_" +
JsonConvert.SerializeObject(interval, new KlineIntervalConverter(false))).ToArray();
return await Subscribe(symbols, handler).ConfigureAwait(false);
}
19
Source : BinanceSocketClientFuturesCoin.cs
with MIT License
from JKorf
with MIT License
from JKorf
public override async Task<CallResult<UpdateSubscription>> SubscribeToSymbolMiniTickerUpdatesAsync(IEnumerable<string> symbols, Action<DataEvent<IBinanceMiniTick>> onMessage)
{
symbols.ValidateNotNull(nameof(symbols));
var handler = new Action<DataEvent<BinanceCombinedStream<BinanceStreamCoinMiniTick>>>(data => onMessage(data.As<IBinanceMiniTick>(data.Data.Data, data.Data.Data.Symbol)));
symbols = symbols.Select(a => a.ToLower(CultureInfo.InvariantCulture) + symbolMiniTickerStreamEndpoint).ToArray();
return await Subscribe(symbols, handler).ConfigureAwait(false);
}
19
Source : BinanceSocketClientFuturesCoin.cs
with MIT License
from JKorf
with MIT License
from JKorf
public override async Task<CallResult<UpdateSubscription>> SubscribeToSymbolTickerUpdatesAsync(IEnumerable<string> symbols, Action<DataEvent<IBinanceTick>> onMessage)
{
symbols.ValidateNotNull(nameof(symbols));
var handler = new Action<DataEvent<BinanceCombinedStream<BinanceStreamCoinTick>>>(data => onMessage(data.As<IBinanceTick>(data.Data.Data, data.Data.Data.Symbol)));
symbols = symbols.Select(a => a.ToLower(CultureInfo.InvariantCulture) + symbolTickerStreamEndpoint).ToArray();
return await Subscribe(symbols, handler).ConfigureAwait(false);
}
19
Source : BinanceSocketClientFuturesUsdt.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<CallResult<UpdateSubscription>> SubscribeToMarkPriceUpdatesAsync(IEnumerable<string> symbols, int? updateInterval, Action<DataEvent<BinanceFuturesUsdtStreamMarkPrice>> onMessage)
{
symbols.ValidateNotNull(nameof(symbols));
updateInterval?.ValidateIntValues(nameof(updateInterval), 1000, 3000);
var handler = new Action<DataEvent<BinanceCombinedStream<BinanceFuturesUsdtStreamMarkPrice>>>(data => onMessage(data.As(data.Data.Data, data.Data.Data.Symbol)));
symbols = symbols.Select(a => a.ToLower(CultureInfo.InvariantCulture) + markPriceStreamEndpoint + (updateInterval == 1000 ? "@1s" : "")).ToArray();
return await Subscribe(symbols, handler).ConfigureAwait(false);
}
19
Source : BinanceSocketClientSpot.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<CallResult<UpdateSubscription>> SubscribeToKlineUpdatesAsync(IEnumerable<string> symbols,
IEnumerable<KlineInterval> intervals, Action<DataEvent<IBinanceStreamKlineData>> onMessage)
{
symbols.ValidateNotNull(nameof(symbols));
foreach (var symbol in symbols)
symbol.ValidateBinanceSymbol();
var handler = new Action<DataEvent<BinanceCombinedStream<BinanceStreamKlineData>>>(data => onMessage(data.As<IBinanceStreamKlineData>(data.Data.Data, data.Data.Data.Symbol)));
symbols = symbols.SelectMany(a =>
intervals.Select(i =>
a.ToLower(CultureInfo.InvariantCulture) + klineStreamEndpoint + "_" +
JsonConvert.SerializeObject(i, new KlineIntervalConverter(false)))).ToArray();
return await Subscribe(symbols, handler).ConfigureAwait(false);
}
19
Source : BinanceClientMargin.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<WebCallResult<BinanceQueryRecords<BinanceLoan>>> GetLoansAsync(string replacedet, long? transactionId = null, DateTime? startTime = null, DateTime? endTime = null, int? current = 1, int? limit = 10, string? isolatedSymbol = null, bool? archived = null, long? receiveWindow = null, CancellationToken ct = default)
{
replacedet.ValidateNotNull(nameof(replacedet));
limit?.ValidateIntBetween(nameof(limit), 1, 100);
var timestampResult = await _baseClient.CheckAutoTimestamp(ct).ConfigureAwait(false);
if (!timestampResult)
return new WebCallResult<BinanceQueryRecords<BinanceLoan>>(timestampResult.ResponseStatusCode, timestampResult.ResponseHeaders, null, timestampResult.Error);
var parameters = new Dictionary<string, object>
{
{ "replacedet", replacedet },
{ "timestamp", _baseClient.GetTimestamp() }
};
parameters.AddOptionalParameter("txId", transactionId?.ToString(CultureInfo.InvariantCulture));
// TxId or startTime must be sent. txId takes precedence.
if (!transactionId.HasValue)
{
parameters.AddOptionalParameter("startTime", BinanceClient.ToUnixTimestamp(startTime ?? DateTime.MinValue).ToString(CultureInfo.InvariantCulture));
}
else
{
parameters.AddOptionalParameter("startTime", startTime != null ? BinanceClient.ToUnixTimestamp(startTime.Value).ToString(CultureInfo.InvariantCulture) : null);
}
parameters.AddOptionalParameter("endTime", endTime != null ? BinanceClient.ToUnixTimestamp(endTime.Value).ToString(CultureInfo.InvariantCulture) : null);
parameters.AddOptionalParameter("current", current?.ToString(CultureInfo.InvariantCulture));
parameters.AddOptionalParameter("size", limit?.ToString(CultureInfo.InvariantCulture));
parameters.AddOptionalParameter("archived", archived);
parameters.AddOptionalParameter("recvWindow", receiveWindow?.ToString(CultureInfo.InvariantCulture) ?? _baseClient.DefaultReceiveWindow.TotalMilliseconds.ToString(CultureInfo.InvariantCulture));
return await _baseClient.SendRequestInternal<BinanceQueryRecords<BinanceLoan>>(_baseClient.GetUrlSpot(getLoanEndpoint, marginApi, marginVersion), HttpMethod.Get, ct, parameters, true).ConfigureAwait(false);
}
19
Source : BinanceClientMargin.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<WebCallResult<BinanceQueryRecords<BinanceRepay>>> GetRepaysAsync(string replacedet, long? transactionId = null, DateTime? startTime = null, DateTime? endTime = null, int? current = null, int? size = null, string? isolatedSymbol = null, bool? archived = null, long? receiveWindow = null, CancellationToken ct = default)
{
replacedet.ValidateNotNull(nameof(replacedet));
var timestampResult = await _baseClient.CheckAutoTimestamp(ct).ConfigureAwait(false);
if (!timestampResult)
return new WebCallResult<BinanceQueryRecords<BinanceRepay>>(timestampResult.ResponseStatusCode, timestampResult.ResponseHeaders, null, timestampResult.Error);
var parameters = new Dictionary<string, object>
{
{ "replacedet", replacedet },
{ "timestamp", _baseClient.GetTimestamp() }
};
parameters.AddOptionalParameter("txId", transactionId?.ToString(CultureInfo.InvariantCulture));
// TxId or startTime must be sent. txId takes precedence.
if (!transactionId.HasValue)
{
parameters.AddOptionalParameter("startTime", BinanceClient.ToUnixTimestamp(startTime ?? DateTime.MinValue).ToString(CultureInfo.InvariantCulture));
}
else
{
parameters.AddOptionalParameter("startTime", startTime != null ? BinanceClient.ToUnixTimestamp(startTime.Value).ToString(CultureInfo.InvariantCulture) : null);
}
parameters.AddOptionalParameter("endTime", endTime != null ? BinanceClient.ToUnixTimestamp(endTime.Value).ToString(CultureInfo.InvariantCulture) : null);
parameters.AddOptionalParameter("current", current?.ToString(CultureInfo.InvariantCulture));
parameters.AddOptionalParameter("size", size?.ToString(CultureInfo.InvariantCulture));
parameters.AddOptionalParameter("isolatedSymbol", isolatedSymbol);
parameters.AddOptionalParameter("archived", archived);
parameters.AddOptionalParameter("recvWindow", receiveWindow?.ToString(CultureInfo.InvariantCulture) ?? _baseClient.DefaultReceiveWindow.TotalMilliseconds.ToString(CultureInfo.InvariantCulture));
return await _baseClient.SendRequestInternal<BinanceQueryRecords<BinanceRepay>>(_baseClient.GetUrlSpot(getRepayEndpoint, marginApi, marginVersion), HttpMethod.Get, ct, parameters, true).ConfigureAwait(false);
}
19
Source : BinanceClientMargin.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<WebCallResult<BinanceTransaction>> IsolatedMarginAccountTransferAsync(string replacedet,
string symbol, IsolatedMarginTransferDirection from, IsolatedMarginTransferDirection to, decimal amount,
int? receiveWindow = null, CancellationToken ct = default)
{
replacedet.ValidateNotNull(nameof(replacedet));
symbol.ValidateNotNull(nameof(symbol));
var timestampResult = await _baseClient.CheckAutoTimestamp(ct).ConfigureAwait(false);
if (!timestampResult)
return new WebCallResult<BinanceTransaction>(timestampResult.ResponseStatusCode,
timestampResult.ResponseHeaders, null, timestampResult.Error);
var parameters = new Dictionary<string, object>
{
{"replacedet", replacedet},
{"symbol", symbol},
{"transFrom", JsonConvert.SerializeObject(from, new IsolatedMarginTransferDirectionConverter(false))},
{"transTo", JsonConvert.SerializeObject(to, new IsolatedMarginTransferDirectionConverter(false))},
{"amount", amount.ToString(CultureInfo.InvariantCulture)},
{"timestamp", _baseClient.GetTimestamp()}
};
parameters.AddOptionalParameter("recvWindow",
receiveWindow?.ToString(CultureInfo.InvariantCulture) ??
_baseClient.DefaultReceiveWindow.TotalMilliseconds.ToString(CultureInfo.InvariantCulture));
return await _baseClient
.SendRequestInternal<BinanceTransaction>(
_baseClient.GetUrlSpot(transferIsolatedMarginAccountEndpoint, "sapi", "1"), HttpMethod.Post, ct,
parameters, true).ConfigureAwait(false);
}
19
Source : BinanceClientMarginIsolatedUserStream.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<WebCallResult<object>> KeepAliveIsolatedMarginUserStreamAsync(string symbol, string listenKey, CancellationToken ct = default)
{
listenKey.ValidateNotNull(nameof(listenKey));
var timestampResult = await _baseClient.CheckAutoTimestamp(ct).ConfigureAwait(false);
if (!timestampResult)
return new WebCallResult<object>(timestampResult.ResponseStatusCode, timestampResult.ResponseHeaders, null, timestampResult.Error);
var parameters = new Dictionary<string, object>
{
{ "listenKey", listenKey },
{"symbol", symbol}
};
return await _baseClient.SendRequestInternal<object>(_baseClient.GetUrlSpot(keepListenKeyAliveEndpoint, "sapi", "1"), HttpMethod.Put, ct, parameters, true).ConfigureAwait(false);
}
19
Source : BinanceClientMarginIsolatedUserStream.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<WebCallResult<object>> CloseIsolatedMarginUserStreamAsync(string symbol, string listenKey, CancellationToken ct = default)
{
listenKey.ValidateNotNull(nameof(listenKey));
var timestampResult = await _baseClient.CheckAutoTimestamp(ct).ConfigureAwait(false);
if (!timestampResult)
return new WebCallResult<object>(timestampResult.ResponseStatusCode, timestampResult.ResponseHeaders, null, timestampResult.Error);
var parameters = new Dictionary<string, object>
{
{ "listenKey", listenKey },
{"symbol", symbol}
};
return await _baseClient.SendRequestInternal<object>(_baseClient.GetUrlSpot(closeListenKeyEndpoint, "sapi", "1"), HttpMethod.Delete, ct, parameters).ConfigureAwait(false);
}
19
Source : BinanceClientMarginUserStream.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<WebCallResult<object>> StopUserStreamAsync(string listenKey, CancellationToken ct = default)
{
listenKey.ValidateNotNull(nameof(listenKey));
var timestampResult = await _baseClient.CheckAutoTimestamp(ct).ConfigureAwait(false);
if (!timestampResult)
return new WebCallResult<object>(timestampResult.ResponseStatusCode, timestampResult.ResponseHeaders, null, timestampResult.Error);
var parameters = new Dictionary<string, object>
{
{ "listenKey", listenKey }
};
return await _baseClient.SendRequestInternal<object>(_baseClient.GetUrlSpot(closeListenKeyEndpoint, "sapi", "1"), HttpMethod.Delete, ct, parameters).ConfigureAwait(false);
}
19
Source : BinanceClientLending.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<WebCallResult<BinancePurchaseQuotaLeft>> GetLeftDailyPurchaseQuotaOfFlexableProductAsync(string productId, long? receiveWindow = null, CancellationToken ct = default)
{
productId.ValidateNotNull(nameof(productId));
var timestampResult = await _baseClient.CheckAutoTimestamp(ct).ConfigureAwait(false);
if (!timestampResult)
return new WebCallResult<BinancePurchaseQuotaLeft>(timestampResult.ResponseStatusCode, timestampResult.ResponseHeaders, null, timestampResult.Error);
var parameters = new Dictionary<string, object>
{
{ "productId", productId },
{ "timestamp", _baseClient.GetTimestamp() }
};
parameters.AddOptionalParameter("recvWindow", receiveWindow?.ToString(CultureInfo.InvariantCulture) ?? _baseClient.DefaultReceiveWindow.TotalMilliseconds.ToString(CultureInfo.InvariantCulture));
return await _baseClient.SendRequestInternal<BinancePurchaseQuotaLeft>(_baseClient.GetUrlSpot(leftDailyPurchaseQuotaEndpoint, "sapi", "1"), HttpMethod.Get, ct, parameters, true).ConfigureAwait(false);
}
19
Source : BinanceClientLending.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<WebCallResult<object>> RedeemFlexibleProductAsync(string productId, decimal amount, RedeemType type, long? receiveWindow = null, CancellationToken ct = default)
{
productId.ValidateNotNull(nameof(productId));
var timestampResult = await _baseClient.CheckAutoTimestamp(ct).ConfigureAwait(false);
if (!timestampResult)
return new WebCallResult<object>(timestampResult.ResponseStatusCode, timestampResult.ResponseHeaders, null, timestampResult.Error);
var parameters = new Dictionary<string, object>
{
{ "productId", productId },
{ "type", JsonConvert.SerializeObject(type, new RedeemTypeConverter(false)) },
{ "amount", amount.ToString(CultureInfo.InvariantCulture) },
{ "timestamp", _baseClient.GetTimestamp() }
};
parameters.AddOptionalParameter("recvWindow", receiveWindow?.ToString(CultureInfo.InvariantCulture) ?? _baseClient.DefaultReceiveWindow.TotalMilliseconds.ToString(CultureInfo.InvariantCulture));
return await _baseClient.SendRequestInternal<object>(_baseClient.GetUrlSpot(redeemFlexibleProductEndpoint, "sapi", "1"), HttpMethod.Post, ct, parameters, true).ConfigureAwait(false);
}
19
Source : BinanceClientLending.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<WebCallResult<BinanceLendingPurchaseResult>> ChangeToDailyPositionAsync(string projectId, int lot, long? positionId = null, long? receiveWindow = null, CancellationToken ct = default)
{
projectId.ValidateNotNull(nameof(projectId));
var timestampResult = await _baseClient.CheckAutoTimestamp(ct).ConfigureAwait(false);
if (!timestampResult)
return new WebCallResult<BinanceLendingPurchaseResult>(timestampResult.ResponseStatusCode, timestampResult.ResponseHeaders, null, timestampResult.Error);
var parameters = new Dictionary<string, object>
{
{ "projectId", projectId },
{ "lot", lot.ToString(CultureInfo.InvariantCulture) },
{ "timestamp", _baseClient.GetTimestamp() }
};
parameters.AddOptionalParameter("positionId", positionId?.ToString(CultureInfo.InvariantCulture));
parameters.AddOptionalParameter("recvWindow", receiveWindow?.ToString(CultureInfo.InvariantCulture) ?? _baseClient.DefaultReceiveWindow.TotalMilliseconds.ToString(CultureInfo.InvariantCulture));
return await _baseClient.SendRequestInternal<BinanceLendingPurchaseResult>(_baseClient.GetUrlSpot(positionChangedEndpoint, "sapi", "1"), HttpMethod.Post, ct, parameters, true).ConfigureAwait(false);
}
19
Source : BinanceClientMining.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<WebCallResult<BinanceOtherRevenueList>> GetMiningOtherRevenueListAsync(string algorithm, string userName, string? coin = null, DateTime? startDate = null, DateTime? endDate = null, int? page = null, int? pageSize = null, CancellationToken ct = default)
{
algorithm.ValidateNotNull(nameof(algorithm));
userName.ValidateNotNull(nameof(userName));
var parameters = new Dictionary<string, object>()
{
{"algo", algorithm},
{"userName", userName},
{"timestamp", _baseClient.GetTimestamp()}
};
parameters.AddOptionalParameter("page", page?.ToString(CultureInfo.InvariantCulture));
parameters.AddOptionalParameter("pageSize", pageSize?.ToString(CultureInfo.InvariantCulture));
parameters.AddOptionalParameter("coin", coin);
parameters.AddOptionalParameter("startDate", startDate.HasValue ? JsonConvert.SerializeObject(startDate.Value, new TimestampConverter()) : null);
parameters.AddOptionalParameter("endDate", endDate.HasValue ? JsonConvert.SerializeObject(endDate.Value, new TimestampConverter()) : null);
var result = await _baseClient.SendRequestInternal<BinanceResult<BinanceOtherRevenueList>>(_baseClient.GetUrlSpot(miningOtherRevenueEndpoint, "sapi", "1"), HttpMethod.Get, ct, parameters, true).ConfigureAwait(false);
if (!result.Success)
return WebCallResult<BinanceOtherRevenueList>.CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, result.Error!);
if (result.Data?.Code != 0)
return WebCallResult<BinanceOtherRevenueList>.CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, new ServerError(result.Data!.Code, result.Data.Message));
return result.As(result.Data.Data);
}
19
Source : BinanceClientMining.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<WebCallResult<BinanceMiningStatistic>> GetMiningStatisticsAsync(string algorithm, string userName, CancellationToken ct = default)
{
algorithm.ValidateNotNull(nameof(algorithm));
userName.ValidateNotNull(nameof(userName));
var parameters = new Dictionary<string, object>()
{
{"algo", algorithm},
{"userName", userName},
{"timestamp", _baseClient.GetTimestamp()}
};
var result = await _baseClient.SendRequestInternal<BinanceResult<BinanceMiningStatistic>>(_baseClient.GetUrlSpot(miningStatisticsEndpoint, "sapi", "1"), HttpMethod.Get, ct, parameters, true).ConfigureAwait(false);
if (!result.Success)
return WebCallResult<BinanceMiningStatistic>.CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, result.Error!);
if (result.Data?.Code != 0)
return WebCallResult<BinanceMiningStatistic>.CreateErrorResult(result.ResponseStatusCode, result.ResponseHeaders, new ServerError(result.Data!.Code, result.Data.Message));
return result.As(result.Data.Data);
}
19
Source : BinanceClientWithdrawDeposit.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<WebCallResult<BinanceDepositAddress>> GetDepositAddressAsync(string coin, string? network = null, int? receiveWindow = null, CancellationToken ct = default)
{
coin.ValidateNotNull(nameof(coin));
var timestampResult = await _baseClient.CheckAutoTimestamp(ct).ConfigureAwait(false);
if (!timestampResult)
return new WebCallResult<BinanceDepositAddress>(timestampResult.ResponseStatusCode, timestampResult.ResponseHeaders, null, timestampResult.Error);
var parameters = new Dictionary<string, object>
{
{ "coin", coin },
{ "timestamp", _baseClient.GetTimestamp() }
};
parameters.AddOptionalParameter("network", network);
parameters.AddOptionalParameter("recvWindow", receiveWindow?.ToString(CultureInfo.InvariantCulture) ?? _baseClient.DefaultReceiveWindow.TotalMilliseconds.ToString(CultureInfo.InvariantCulture));
return await _baseClient.SendRequestInternal<BinanceDepositAddress>(_baseClient.GetUrlSpot(depositAddressEndpoint, "sapi", "1"), HttpMethod.Get, ct, parameters, true).ConfigureAwait(false);
}
19
Source : BitfinexSocketClient.cs
with MIT License
from JKorf
with MIT License
from JKorf
public async Task<CallResult<bool>> CancelOrdersAsync(IEnumerable<long> orderIds)
{
orderIds.ValidateNotNull(nameof(orderIds));
return await CancelOrdersAsync(orderIds, null).ConfigureAwait(false);
}
See More Examples