public virtual async Task <ExchangeWithdrawalResponse> WithdrawAsync(ExchangeWithdrawalRequest withdrawalRequest)
{
// *NOTE* do not wrap in CacheMethodCall
await new SynchronizationContextRemover();
withdrawalRequest.Currency = NormalizeMarketSymbol(withdrawalRequest.Currency);
return(await OnWithdrawAsync(withdrawalRequest));
}
protected override async Task <ExchangeWithdrawalResponse> OnWithdrawAsync(ExchangeWithdrawalRequest withdrawalRequest)
{
ExchangeWithdrawalResponse response = new ExchangeWithdrawalResponse {
Success = false
};
string symbol = NormalizeSymbol(withdrawalRequest.Symbol);
var payload = GetNoncePayload();
JArray array = await MakeJsonRequestAsync <JArray>("/payment-methods", null, GetNoncePayload(), "GET");
if (array != null)
{
var rc = array.Where(t => t.Value <string>("currency") == symbol).FirstOrDefault();
payload = GetNoncePayload();
payload["amount"] = withdrawalRequest.Amount;
payload["currency"] = symbol;
payload["method"] = rc.Value <string>("id");
if (!String.IsNullOrEmpty(withdrawalRequest.AddressTag))
{
payload["tag"] = withdrawalRequest.AddressTag;
}
// "status": 0, "message": "Your transaction is pending. Please confirm it via email.", "payoutId": "65", "balance": []...
JToken token = MakeJsonRequest <JToken>("/withdrawals/make", null, payload, "POST");
response.Id = token["payoutId"].ToStringInvariant();
response.Message = token["message"].ToStringInvariant();
response.Success = token["status"].ConvertInvariant <int>().Equals(0);
}
return(response);
}
protected override async Task <ExchangeWithdrawalResponse> OnWithdrawAsync(ExchangeWithdrawalRequest withdrawalRequest)
{
ExchangeWithdrawalResponse withdraw = new ExchangeWithdrawalResponse()
{
Success = false
};
var payload = await OnGetNoncePayloadAsync();
payload["amount"] = withdrawalRequest.Amount;
payload["currency_code"] = withdrawalRequest.Symbol;
payload["address"] = withdrawalRequest.Address;
if (!string.IsNullOrEmpty(withdrawalRequest.AddressTag))
{
payload["paymentId"] = withdrawalRequest.AddressTag;
}
//{ "id": "d2ce578f-647d-4fa0-b1aa-4a27e5ee597b"} that's all folks!
JToken token = await MakeJsonRequestAsync <JToken>("/payment/payout", null, payload, "POST");
if (token != null && token["id"] != null)
{
withdraw.Success = true;
withdraw.Id = token["id"].ToStringInvariant();
}
return(withdraw);
}
protected override async Task <ExchangeWithdrawalResponse> OnWithdrawAsync(ExchangeWithdrawalRequest request)
{
var nonce = await GenerateNonceAsync();
var payload = new Dictionary <string, object>
{
{ "nonce", nonce },
{ "amount", request.Amount },
{ "currency", request.Currency },
{ "crypto_address", request.Address },
{ "add_network_fee_to_total", !request.TakeFeeFromAmount },
};
if (!string.IsNullOrEmpty(request.AddressTag))
{
payload.Add("destination_tag", request.AddressTag);
}
var result = await MakeJsonRequestAsync <WithdrawalResult>("/withdrawals/crypto", null, payload, "POST");
var feeParsed = decimal.TryParse(result.Fee, out var fee);
return(new ExchangeWithdrawalResponse
{
Id = result.Id,
Fee = feeParsed ? fee : (decimal?)null
});
}
public override ExchangeWithdrawalResponse Withdraw(ExchangeWithdrawalRequest withdrawalRequest)
{
Dictionary <string, object> payload = GetNoncePayload();
payload["asset"] = withdrawalRequest.Asset;
payload["address"] = withdrawalRequest.ToAddress;
payload["amount"] = withdrawalRequest.Amount;
if (!string.IsNullOrWhiteSpace(withdrawalRequest.Name))
{
payload["name"] = withdrawalRequest.Name;
}
if (!string.IsNullOrWhiteSpace(withdrawalRequest.AddressTag))
{
payload["addressTag"] = withdrawalRequest.AddressTag;
}
// yes, .html ...
JToken response = MakeJsonRequest <JToken>("/withdraw.html", WithdrawalUrlPrivate, payload, "POST");
CheckError(response);
ExchangeWithdrawalResponse withdrawalResponse = new ExchangeWithdrawalResponse
{
Id = response["id"].ToStringInvariant(),
Message = response["msg"].ToStringInvariant(),
};
if (response["success"] == null || !response["success"].ConvertInvariant <bool>())
{
throw new APIException(response["msg"].ToStringInvariant());
}
return(withdrawalResponse);
}
//Withdraw 14
protected override async Task <ExchangeWithdrawalResponse> OnWithdrawAsync(ExchangeWithdrawalRequest withdrawalRequest)
{
if (string.IsNullOrWhiteSpace(withdrawalRequest.Currency))
{
throw new APIException("Symbol empty");
}
if (string.IsNullOrWhiteSpace(withdrawalRequest.Address))
{
throw new APIException("Address empty");
}
Dictionary <string, object> payload = new Dictionary <string, object>
{
{ "account", withdrawalRequest.Address },
{ "amount", withdrawalRequest.Amount },
{ "api_key", PublicApiKey.ToUnsecureString() },
{ "assetCode", withdrawalRequest.Currency },
{ "fee", withdrawalRequest.TakeFeeFromAmount }
};
JObject resp = await MakeJsonRequestAsync <JObject>("/withdraw.do", null, payload, "POST");
CheckResponseToken(resp);
return(ParseWithdrawalResponse(resp));
}
/// <summary>
/// Function to withdraw from Bitsamp exchange. At the moment only XRP is supported.
/// </summary>
/// <param name="withdrawalRequest"></param>
/// <returns></returns>
protected override async Task <ExchangeWithdrawalResponse> OnWithdrawAsync(ExchangeWithdrawalRequest withdrawalRequest)
{
string baseurl = null;
string url;
switch (withdrawalRequest.Symbol)
{
case "BTC":
// use old API for Bitcoin withdraw
baseurl = "https://www.bitstamp.net/api/";
url = "/bitcoin_withdrawal/";
break;
default:
// this will work for some currencies and fail for others, caller must be aware of the supported currencies
url = "/" + withdrawalRequest.Symbol.ToLowerInvariant() + "_withdrawal/";
break;
}
Dictionary <string, object> payload = await OnGetNoncePayloadAsync();
payload["address"] = withdrawalRequest.Address.ToStringInvariant();
payload["amount"] = withdrawalRequest.Amount.ToStringInvariant();
payload["destination_tag"] = withdrawalRequest.AddressTag.ToStringInvariant();
JObject responseObject = await MakeJsonRequestAsync <JObject>(url, baseurl, payload, "POST");
CheckJsonResponse(responseObject);
return(new ExchangeWithdrawalResponse
{
Id = responseObject["id"].ToStringInvariant(),
Message = responseObject["message"].ToStringInvariant(),
Success = responseObject["success"].ConvertInvariant <bool>()
});
}
/// <summary>
/// Bitbank does not support withdrawing to arbitrary address (for security reason).
/// We must first register address from its web form.
/// So we will call two methods here.
/// 1. Get address from already registered account. (fail if does not exist)
/// 2. Withdraw to that address.
/// </summary>
/// <param name="withdrawalRequest"></param>
/// <returns></returns>
protected override async Task <ExchangeWithdrawalResponse> OnWithdrawAsync(ExchangeWithdrawalRequest withdrawalRequest)
{
var asset = withdrawalRequest.Currency.ToLowerInvariant();
var payload1 = await GetNoncePayloadAsync();
payload1.Add("asset", asset);
JToken token1 = await MakeJsonRequestAsync <JToken>($"/user/withdrawal_account", baseUrl : BaseUrlPrivate, payload : payload1);
if (!token1["accounts"].ToArray().Any(a => a["address"].ToStringInvariant() == withdrawalRequest.Address))
{
throw new APIException($"Could not withdraw to address {withdrawalRequest.Address}! You must register the address from web form first.");
}
var uuid = token1["uuid"].ToStringInvariant();
var payload2 = await GetNoncePayloadAsync();
payload2.Add("asset", asset);
payload2.Add("amount", withdrawalRequest.Amount);
payload2.Add("uuid", uuid);
JToken token2 = await MakeJsonRequestAsync <JToken>($"/user/request_withdrawal", baseUrl : BaseUrlPrivate, payload : payload2, requestMethod : "POST");
var resp = new ExchangeWithdrawalResponse
{
Id = token2["txid"].ToStringInvariant()
};
var status = token2["status"].ToStringInvariant();
resp.Success = status != "REJECTED" && status != "CANCELED";
resp.Message = "{" + $"label:{token2["label"]}, fee:{token2["fee"]}" + "}";
return(resp);
}
protected override async Task <ExchangeWithdrawalResponse> OnWithdrawAsync(ExchangeWithdrawalRequest withdrawalRequest)
{
/*
* "currencySymbol": "string",
* "quantity": "number (double)",
* "cryptoAddress": "string",
* "cryptoAddressTag": "string",
* "clientWithdrawalId": "string (uuid)"
*/
string url = "/withdrawals";
var payload = await GetNoncePayloadAsync();
payload.Add("currencySymbol", withdrawalRequest.Currency);
payload.Add("quantity", withdrawalRequest.Amount);
payload.Add("cryptoAddress", withdrawalRequest.Address);
if (withdrawalRequest.AddressTag != null)
{
payload.Add("cryptoAddressTag", withdrawalRequest.AddressTag);
}
JToken result = await MakeJsonRequestAsync <JToken>(url, null, payload, "POST");
/*
* {
* "id": "string (uuid)",
* "currencySymbol": "string",
* "quantity": "number (double)",
* "cryptoAddress": "string",
* "cryptoAddressTag": "string",
* "txCost": "number (double)",
* "txId": "string",
* "status": "string",
* "createdAt": "string (date-time)",
* "completedAt": "string (date-time)",
* "clientWithdrawalId": "string (uuid)",
* "accountId": "string (uuid)"
* }
*/
ExchangeWithdrawalResponse withdrawalResponse = new ExchangeWithdrawalResponse
{
Id = result["id"].ToStringInvariant(),
Message = result["status"].ToStringInvariant(),
Fee = result.Value <decimal?>("txCost")
};
return(withdrawalResponse);
}
/// <summary>
/// Function to withdraw from Bitsamp exchange. At the moment only XRP is supported.
/// </summary>
/// <param name="withdrawalRequest"></param>
/// <returns></returns>
public override ExchangeWithdrawalResponse Withdraw(ExchangeWithdrawalRequest withdrawalRequest)
{
string baseurl = null;
string url = "";
switch (withdrawalRequest.Symbol)
{
case "XRP":
url = "/xrp_withdrawal/";
break;
case "BCH":
url = "/bch_withdrawal/";
break;
case "LTC":
url = "/ltc_withdrawal/";
break;
case "ETH":
url = "/eth_withdrawal/";
break;
case "BTC":
baseurl = "https://www.bitstamp.net/api/";
url = "/bitcoin_withdrawal/";
break;
default:
throw new NotImplementedException();
}
Dictionary <string, object> payload = GetNoncePayload();
payload["address"] = withdrawalRequest.Address.ToStringInvariant();
payload["amount"] = withdrawalRequest.Amount.ToStringInvariant();
payload["destination_tag"] = withdrawalRequest.AddressTag.ToStringInvariant();
JObject responseObject = MakeJsonRequest <JObject>(url, baseurl, payload, "POST");
CheckError(responseObject);
return(new ExchangeWithdrawalResponse()
{
Id = responseObject["id"].ToStringInvariant(),
Message = responseObject["message"].ToStringInvariant(),
Success = (bool)responseObject["success"]
});
}
/// <summary>
/// Kucoin doesn't support withdraws to Cryptonight currency addresses (No Address Tag paramater)
/// </summary>
/// <param name="withdrawalRequest"></param>
/// <returns></returns>
protected override async Task <ExchangeWithdrawalResponse> OnWithdrawAsync(ExchangeWithdrawalRequest withdrawalRequest)
{
ExchangeWithdrawalResponse response = new ExchangeWithdrawalResponse {
Success = true
};
var payload = await GetNoncePayloadAsync();
payload["address"] = withdrawalRequest.Address;
payload["amount"] = withdrawalRequest.Amount;
JToken token = await MakeJsonRequestAsync <JToken>("/account/" + withdrawalRequest.Currency + "/withdraw/apply", null, payload, "POST");
// no data is returned. Check error will throw exception on failure
return(response);
}
/// <summary>
/// Warning: Use with discretion
/// <rant> Yobit trading seems fine, their API is stable, but their deposits/withdraws are *VERY* problematic.
/// I'm being kind. Waited as much as two-weeks for deposts to show up on Exchange, even though they were confirmed on the blockchain.
/// </rant>
/// </summary>
/// <param name="withdrawalRequest"></param>
/// <returns></returns>
protected override async Task <ExchangeWithdrawalResponse> OnWithdrawAsync(ExchangeWithdrawalRequest withdrawalRequest)
{
ExchangeWithdrawalResponse response = new ExchangeWithdrawalResponse {
Success = false
};
var payload = await GetNoncePayloadAsync();
payload.Add("method", "WithdrawCoinsToAddress");
payload.Add("coinName", withdrawalRequest.Currency);
payload.Add("amount", withdrawalRequest.Amount);
payload.Add("address", withdrawalRequest.Address);
await MakeJsonRequestAsync <JToken>("/", PrivateURL, payload, "POST");
response.Success = true;
return(response);
}
/// <summary>
/// Warning: Use with discretion
/// <rant> Yobit trading seems fine, their API is stable, but their deposits/withdraws are *VERY* problematic.
/// I'm being kind. Waited as much as two-weeks for deposts to show up on Exchange, even though they were confirmed on the blockchain.
/// </rant>
/// </summary>
/// <param name="withdrawalRequest"></param>
/// <returns></returns>
protected override async Task <ExchangeWithdrawalResponse> OnWithdrawAsync(ExchangeWithdrawalRequest withdrawalRequest)
{
ExchangeWithdrawalResponse response = new ExchangeWithdrawalResponse {
Success = false
};
var payload = GetNoncePayload();
payload.Add("method", "WithdrawCoinsToAddress");
payload.Add("coinName", withdrawalRequest.Symbol);
payload.Add("amount", withdrawalRequest.Amount);
payload.Add("address", withdrawalRequest.Address);
JToken token = await MakeJsonRequestAsync <JToken>("/", PrivateURL, payload, "POST");
CheckError(token); // will throw exception on error
response.Success = true;
return(response);
}
protected override async Task <ExchangeWithdrawalResponse> OnWithdrawAsync(ExchangeWithdrawalRequest withdrawalRequest)
{
ExchangeWithdrawalResponse response = new ExchangeWithdrawalResponse {
Success = false
};
if (!String.IsNullOrEmpty(withdrawalRequest.AddressTag))
{
withdrawalRequest.AddressTag = "::" + withdrawalRequest.AddressTag;
}
// {"fault": null,"userId": 797,"userName": "******","id": 11285042,"state": "APPROVED","createDate": 1432197911364,"lastModifyDate": 1432197911802,"verificationType": "NONE","verificationData": null, "comment": null, "description": "Transfer from Livecoin", "amount": 0.002, "currency": "BTC", "accountTo": "B1099909", "acceptDate": null, "valueDate": null, "docDate": 1432197911364, "docNumber": 11111111, "correspondentDetails": null, "accountFrom": "B0000001", "outcome": false, "external": null, "externalKey": "1111111", "externalSystemId": 18, "externalServiceId": null, "wallet": "1111111" }
JToken token = await MakeJsonRequestAsync <JToken>("/payment/out/coin?currency=" + withdrawalRequest.Currency + "&wallet=" + withdrawalRequest.Address + withdrawalRequest.AddressTag + "&amount=" + withdrawalRequest.Amount, BaseUrl, await GetNoncePayloadAsync(), "POST");
response.Success = true;
return(response);
}
protected override async Task<ExchangeWithdrawalResponse> OnWithdrawAsync(ExchangeWithdrawalRequest withdrawalRequest)
{
ExchangeWithdrawalResponse response = new ExchangeWithdrawalResponse { Success = false };
var payload = GetNoncePayload();
payload.Add("Currency", withdrawalRequest.Symbol);
payload.Add("Address", withdrawalRequest.Address);
if (!string.IsNullOrEmpty(withdrawalRequest.AddressTag)) payload.Add("PaymentId", withdrawalRequest.AddressTag);
payload.Add("Amount", withdrawalRequest.Amount);
JToken token = await MakeJsonRequestAsync<JToken>("/SubmitWithdraw", null, payload, "POST");
if (token["Success"].ConvertInvariant<bool>() == true)
{
response.Id = token["Data"].ConvertInvariant<int>().ToStringInvariant();
response.Success = true;
}
return response;
}
protected override async Task <ExchangeWithdrawalResponse> OnWithdrawAsync(ExchangeWithdrawalRequest request)
{
var parameters = new Dictionary <string, object>
{
{ "coin", request.Currency },
{ "size", request.Amount },
{ "address", request.Address },
{ "nonce", await GenerateNonceAsync() },
{ "password", request.Password },
{ "code", request.Code }
};
var result = await MakeJsonRequestAsync <JToken>("/wallet/withdrawals", null, parameters, "POST");
return(new ExchangeWithdrawalResponse
{
Id = result["id"].ToString()
});
}
protected override async Task <ExchangeWithdrawalResponse> OnWithdrawAsync(ExchangeWithdrawalRequest withdrawalRequest)
{
var payload = await GetNoncePayloadAsync();
payload["address"] = withdrawalRequest.Address;
payload["amount"] = withdrawalRequest.Amount;
payload["currency"] = withdrawalRequest.Currency;
if (withdrawalRequest.AddressTag != null)
{
payload["attr-tag"] = withdrawalRequest.AddressTag;
}
JToken result = await MakeJsonRequestAsync <JToken>("/dw/withdraw/api/create", PrivateUrlV1, payload, "POST");
return(new ExchangeWithdrawalResponse
{
Id = result.Root["data"].ToStringInvariant(),
Message = result.Root["status"].ToStringInvariant()
});
}
protected override async Task <ExchangeWithdrawalResponse> OnWithdrawAsync(ExchangeWithdrawalRequest withdrawalRequest)
{
var payload = await GetNoncePayloadAsync();
payload["currency"] = withdrawalRequest.Currency;
payload["quantity"] = withdrawalRequest.Amount;
payload["address"] = withdrawalRequest.Address;
if (!string.IsNullOrEmpty(withdrawalRequest.AddressTag))
{
payload["comments"] = withdrawalRequest.AddressTag;
}
await MakeJsonRequestAsync <JToken>("/account/withdraw", BaseUrl, payload);
// Bleutrade doesn't return any info, just an empty string on success. The MakeJsonRequestAsync will throw an exception if there's an error
return(new ExchangeWithdrawalResponse()
{
Success = true
});
}
/// <summary>A withdrawal request. Fee is automatically subtracted from the amount.</summary>
/// <param name="withdrawalRequest">The withdrawal request.</param>
/// <returns>Withdrawal response from Binance</returns>
public override ExchangeWithdrawalResponse Withdraw(ExchangeWithdrawalRequest withdrawalRequest)
{
if (string.IsNullOrWhiteSpace(withdrawalRequest.Symbol))
{
throw new APIException("Symbol must be provided for Withdraw");
}
if (string.IsNullOrWhiteSpace(withdrawalRequest.Address))
{
throw new APIException("Address must be provided for Withdraw");
}
if (withdrawalRequest.Amount <= 0)
{
throw new APIException("Withdrawal amount must be positive and non-zero");
}
Dictionary <string, object> payload = GetNoncePayload();
payload["asset"] = withdrawalRequest.Symbol;
payload["address"] = withdrawalRequest.Address;
payload["amount"] = withdrawalRequest.Amount;
payload["name"] = withdrawalRequest.Description ?? "apiwithdrawal"; // Contrary to what the API docs say, name is required
if (!string.IsNullOrWhiteSpace(withdrawalRequest.AddressTag))
{
payload["addressTag"] = withdrawalRequest.AddressTag;
}
JToken response = MakeJsonRequest <JToken>("/withdraw.html", WithdrawalUrlPrivate, payload, "POST");
CheckError(response);
ExchangeWithdrawalResponse withdrawalResponse = new ExchangeWithdrawalResponse
{
Id = response["id"].ToStringInvariant(),
Message = response["msg"].ToStringInvariant(),
};
return(withdrawalResponse);
}
protected override async Task <ExchangeWithdrawalResponse> OnWithdrawAsync(ExchangeWithdrawalRequest withdrawalRequest)
{
var response = new ExchangeWithdrawalResponse {
Success = false
};
var payload = await GetNoncePayloadAsync();
payload.Add("Currency", withdrawalRequest.Currency);
payload.Add("Address", withdrawalRequest.Address);
if (!string.IsNullOrEmpty(withdrawalRequest.AddressTag))
{
payload.Add("PaymentId", withdrawalRequest.AddressTag);
}
payload.Add("Amount", withdrawalRequest.Amount);
var token = await MakeJsonRequestAsync <JToken>("/SubmitWithdraw", null, payload, "POST");
response.Id = token.ConvertInvariant <int>().ToStringInvariant();
response.Success = true;
return(response);
}
protected override async Task <ExchangeWithdrawalResponse> OnWithdrawAsync(ExchangeWithdrawalRequest withdrawalRequest)
{
ExchangeWithdrawalResponse response = new ExchangeWithdrawalResponse {
Success = false
};
var payload = await GetNoncePayloadAsync();
payload.Add("method", "withdraw");
payload.Add("coin", withdrawalRequest.Currency);
payload.Add("amount", withdrawalRequest.Amount);
payload.Add("address", withdrawalRequest.Address);
// ( [success] => 1 [error] => Array ([0] => Withdraw requested. ))
JToken token = await MakeJsonRequestAsync <JToken>("/api", null, payload, "POST");
if (token["success"].ConvertInvariant <int>() == 1)
{
response.Success = true;
}
return(response);
}
public override ExchangeWithdrawalResponse Withdraw(ExchangeWithdrawalRequest withdrawalRequest)
{
// Example: https://bittrex.com/api/v1.1/account/withdraw?apikey=API_KEY¤cy=EAC&quantity=20.40&address=EAC_ADDRESS
string url = $"/account/withdraw?currency={NormalizeSymbol(withdrawalRequest.Asset)}&quantity={withdrawalRequest.Amount}&address={withdrawalRequest.ToAddress}";
if (!string.IsNullOrWhiteSpace(withdrawalRequest.AddressTag))
{
url += $"&paymentid{withdrawalRequest.AddressTag}";
}
JToken response = MakeJsonRequest <JToken>(url, null, GetNoncePayload());
JToken result = CheckError(response);
ExchangeWithdrawalResponse withdrawalResponse = new ExchangeWithdrawalResponse
{
Id = result["uuid"].ToStringInvariant(),
Message = result["msg"].ToStringInvariant()
};
return(withdrawalResponse);
}
protected override async Task <ExchangeWithdrawalResponse> OnWithdrawAsync(ExchangeWithdrawalRequest withdrawalRequest)
{
// If we have an address tag, verify that Polo lets you specify it as part of the withdrawal
if (!string.IsNullOrWhiteSpace(withdrawalRequest.AddressTag))
{
if (!WithdrawalFieldCount.TryGetValue(withdrawalRequest.Currency, out int fieldCount) || fieldCount == 0)
{
throw new APIException($"Coin {withdrawalRequest.Currency} has unknown withdrawal field count. Please manually verify the number of fields allowed during a withdrawal (Address + Tag = 2) and add it to PoloniexWithdrawalFields.csv before calling Withdraw");
}
else if (fieldCount == 1)
{
throw new APIException($"Coin {withdrawalRequest.Currency} only allows an address to be specified and address tag {withdrawalRequest.AddressTag} was provided.");
}
else if (fieldCount > 2)
{
throw new APIException("More than two fields on a withdrawal is unsupported.");
}
}
var paramsList = new List <object> {
"currency", NormalizeMarketSymbol(withdrawalRequest.Currency), "amount", withdrawalRequest.Amount, "address", withdrawalRequest.Address
};
if (!string.IsNullOrWhiteSpace(withdrawalRequest.AddressTag))
{
paramsList.Add("paymentId");
paramsList.Add(withdrawalRequest.AddressTag);
}
JToken token = await MakePrivateAPIRequestAsync("withdraw", paramsList.ToArray());
ExchangeWithdrawalResponse resp = new ExchangeWithdrawalResponse {
Message = token["response"].ToStringInvariant()
};
return(resp);
}
/// <summary>A withdrawal request. Fee is automatically subtracted from the amount.</summary>
/// <param name="withdrawalRequest">The withdrawal request.</param>
/// <returns>Withdrawal response from Binance</returns>
protected override async Task <ExchangeWithdrawalResponse> OnWithdrawAsync(ExchangeWithdrawalRequest withdrawalRequest)
{
if (string.IsNullOrWhiteSpace(withdrawalRequest.Currency))
{
throw new ArgumentException("Symbol must be provided for Withdraw");
}
else if (string.IsNullOrWhiteSpace(withdrawalRequest.Address))
{
throw new ArgumentException("Address must be provided for Withdraw");
}
else if (withdrawalRequest.Amount <= 0)
{
throw new ArgumentException("Withdrawal amount must be positive and non-zero");
}
Dictionary <string, object> payload = await GetNoncePayloadAsync();
payload["asset"] = withdrawalRequest.Currency;
payload["address"] = withdrawalRequest.Address;
payload["amount"] = withdrawalRequest.Amount;
payload["name"] = withdrawalRequest.Description ?? "apiwithdrawal"; // Contrary to what the API docs say, name is required
if (!string.IsNullOrWhiteSpace(withdrawalRequest.AddressTag))
{
payload["addressTag"] = withdrawalRequest.AddressTag;
}
JToken response = await MakeJsonRequestAsync <JToken>("/withdraw.html", WithdrawalUrlPrivate, payload, "POST");
ExchangeWithdrawalResponse withdrawalResponse = new ExchangeWithdrawalResponse
{
Id = response["id"].ToStringInvariant(),
Message = response["msg"].ToStringInvariant(),
};
return(withdrawalResponse);
}
/// <summary> /// A withdrawal request. /// </summary> /// <param name="withdrawalRequest">The withdrawal request.</param> public virtual ExchangeWithdrawalResponse Withdraw(ExchangeWithdrawalRequest withdrawalRequest) => throw new NotImplementedException();
/// <summary> /// Asynchronous withdraws. /// </summary> /// <param name="withdrawalRequest">The withdrawal request.</param> public Task WithdrawAsync(ExchangeWithdrawalRequest withdrawalRequest) => Task.Factory.StartNew(() => Withdraw(withdrawalRequest));
/// <summary>
/// Asynchronous withdraws request.
/// </summary>
/// <param name="withdrawalRequest">The withdrawal request.</param>
public async Task <ExchangeWithdrawalResponse> WithdrawAsync(ExchangeWithdrawalRequest withdrawalRequest)
{
await new SynchronizationContextRemover();
return(await OnWithdrawAsync(withdrawalRequest));
}
/// <summary> /// A withdrawal request. /// </summary> /// <param name="withdrawalRequest">The withdrawal request.</param> public ExchangeWithdrawalResponse Withdraw(ExchangeWithdrawalRequest withdrawalRequest) => WithdrawAsync(withdrawalRequest).GetAwaiter().GetResult();
protected virtual Task <ExchangeWithdrawalResponse> OnWithdrawAsync(ExchangeWithdrawalRequest withdrawalRequest) => throw new NotImplementedException();
protected override Task <ExchangeWithdrawalResponse> OnWithdrawAsync(ExchangeWithdrawalRequest withdrawalRequest)
{
throw new NotImplementedException("Huobi does not provide a withdraw API");
}