public async Task Setting_Should_ResultInOptionsSet(string method, HttpMethodParameterPosition pos)
{
// arrange
// act
var client = new TestRestClient(new TestClientOptions()
{
Api1Options = new RestApiClientOptions
{
BaseAddress = "http://test.address.com"
}
});
client.Api1.SetParameterPosition(new HttpMethod(method), pos);
client.SetResponse("{}", out var request);
await client.RequestWithParams <TestObject>(new HttpMethod(method), new Dictionary <string, object>
{
{ "TestParam1", "Value1" },
{ "TestParam2", 2 },
},
new Dictionary <string, string>
{
{ "TestHeader", "123" }
});
// assert
Assert.AreEqual(request.Method, new HttpMethod(method));
Assert.AreEqual(request.Content?.Contains("TestParam1") == true, pos == HttpMethodParameterPosition.InBody);
Assert.AreEqual(request.Uri.ToString().Contains("TestParam1"), pos == HttpMethodParameterPosition.InUri);
Assert.AreEqual(request.Content?.Contains("TestParam2") == true, pos == HttpMethodParameterPosition.InBody);
Assert.AreEqual(request.Uri.ToString().Contains("TestParam2"), pos == HttpMethodParameterPosition.InUri);
Assert.AreEqual(request.GetHeaders().First().Key, "TestHeader");
Assert.IsTrue(request.GetHeaders().First().Value.Contains("123"));
}
public override void AuthenticateRequest(RestApiClient apiClient, Uri uri, HttpMethod method, Dictionary <string, object> providedParameters,
bool auth, ArrayParametersSerialization arraySerialization,
HttpMethodParameterPosition parameterPosition, out SortedDictionary <string, object> uriParameters, out SortedDictionary <string, object> bodyParameters, out Dictionary <string, string> headers)
{
var uriParam = new SortedDictionary <string, object>();
bodyParameters = new();
uriParameters = new();
headers = new();
if (parameterPosition == HttpMethodParameterPosition.InBody && method == HttpMethod.Post)
{
bodyParameters = new SortedDictionary <string, object>(providedParameters);
}
if (parameterPosition == HttpMethodParameterPosition.InUri && method == HttpMethod.Get)
{
uriParam = new SortedDictionary <string, object>(providedParameters);
}
if (auth)
{
if (uri.PathAndQuery.Contains("v3"))
{
headers = AddAuthenticationToHeaders(uri.ToString(), method, providedParameters, auth, parameterPosition, arraySerialization);
}
else
{
var uriAuthParam = AddAuthenticationToParameters(uri.ToString(), method, providedParameters, auth, parameterPosition, arraySerialization);
foreach (var p in uriAuthParam)
{
uriParam.Add(p.Key, p.Value);
}
}
}
uriParameters = uriParam;
}
/// <summary>
/// Authenticate a request. Output parameters should include the providedParameters input
/// </summary>
/// <param name="apiClient">The Api client sending the request</param>
/// <param name="uri">The uri for the request</param>
/// <param name="method">The method of the request</param>
/// <param name="providedParameters">The request parameters</param>
/// <param name="auth">If the requests should be authenticated</param>
/// <param name="arraySerialization">Array serialization type</param>
/// <param name="parameterPosition">The position where the providedParameters should go</param>
/// <param name="uriParameters">Parameters that need to be in the Uri of the request. Should include the provided parameters if they should go in the uri</param>
/// <param name="bodyParameters">Parameters that need to be in the body of the request. Should include the provided parameters if they should go in the body</param>
/// <param name="headers">The headers that should be send with the request</param>
public abstract void AuthenticateRequest(
RestApiClient apiClient,
Uri uri,
HttpMethod method,
Dictionary <string, object> providedParameters,
bool auth,
ArrayParametersSerialization arraySerialization,
HttpMethodParameterPosition parameterPosition,
out SortedDictionary <string, object> uriParameters,
out SortedDictionary <string, object> bodyParameters,
out Dictionary <string, string> headers
);
public override Dictionary <string, string> AddAuthenticationToHeaders(string uri,
HttpMethod method, Dictionary <string, object> parameters, bool signed,
HttpMethodParameterPosition parameterPosition, ArrayParametersSerialization arraySerialization)
{
if (!signed)
{
return(new Dictionary <string, string>());
}
if (ExanteCredentials.ApplicationId is null ||
ExanteCredentials.ClientId is null ||
ExanteCredentials.SharedKey is null)
{
throw new ArgumentException("No valid API credentials");
}
var securityKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(ExanteCredentials.SharedKey));
var credentials = new SigningCredentials(securityKey, SecurityAlgorithms.HmacSha256);
var payload = new JwtPayload(ExanteCredentials.ClientId,
null,
new[]
{
new Claim(JwtRegisteredClaimNames.Sub, ExanteCredentials.ApplicationId),
new Claim(JwtRegisteredClaimNames.Iss, ExanteCredentials.ClientId),
},
new Dictionary <string, object> {
{ JwtRegisteredClaimNames.Aud, tokenPermissions }
},
null,
DateTime.UtcNow.AddHours(1),
DateTime.UtcNow
);
var securityToken = new JwtSecurityToken(new JwtHeader(credentials), payload);
var token = new JwtSecurityTokenHandler().WriteToken(securityToken);
return(new Dictionary <string, string>
{
{ "Authorization", $"Bearer {token}" }
});
}
public override void AuthenticateRequest(RestApiClient apiClient, Uri uri, HttpMethod method, Dictionary <string, object> providedParameters, bool auth, ArrayParametersSerialization arraySerialization, HttpMethodParameterPosition parameterPosition, out SortedDictionary <string, object> uriParameters, out SortedDictionary <string, object> bodyParameters, out Dictionary <string, string> headers)
{
uriParameters = parameterPosition == HttpMethodParameterPosition.InUri ? new SortedDictionary <string, object>(providedParameters) : new SortedDictionary <string, object>();
bodyParameters = parameterPosition == HttpMethodParameterPosition.InBody ? new SortedDictionary <string, object>(providedParameters) : new SortedDictionary <string, object>();
headers = new Dictionary <string, string>();
if (!auth)
{
return;
}
// Auth requests are always POST
if (uri.AbsolutePath.Contains("v1"))
{
bodyParameters.Add("request", uri.AbsolutePath);
bodyParameters.Add("nonce", _nonceProvider.GetNonce().ToString());
var signature = JsonConvert.SerializeObject(bodyParameters);
var payload = Convert.ToBase64String(Encoding.ASCII.GetBytes(signature));
var signedData = Sign(payload);
headers.Add("X-BFX-APIKEY", Credentials.Key !.GetString());
headers.Add("X-BFX-PAYLOAD", payload);
headers.Add("X-BFX-SIGNATURE", signedData.ToLower(CultureInfo.InvariantCulture));
}
else if (uri.AbsolutePath.Contains("v2"))
{
var json = JsonConvert.SerializeObject(bodyParameters);
var n = _nonceProvider.GetNonce().ToString();
var signature = $"/api{uri.AbsolutePath}{n}{json}";
var signedData = SignHMACSHA384(signature);
headers.Add("bfx-apikey", Credentials.Key !.GetString());
headers.Add("bfx-nonce", n);
headers.Add("bfx-signature", signedData.ToLower(CultureInfo.InvariantCulture));
}
}
//Create hmac signature with secretKey as a key and sign request "method+timestamp+url+body"
//Like as basic authorization add header "Authorization: HS256 " + base64(publicKey+":"+timestamp+":"+signature hex encoded)
public override Dictionary <string, string> AddAuthenticationToHeaders(string uri, HttpMethod method, Dictionary <string, object> parameters, bool signed, HttpMethodParameterPosition parameterPosition, ArrayParametersSerialization arrayParametersSerialization)
{
// var time = TimeStamp;
//if (!signed)
// return new Dictionary<string, string>();
//var result = new Dictionary<string, string>();
//string additionalData = String.Empty;
//if (parameters != null && parameters.Any() && method != HttpMethod.Delete && method != HttpMethod.Get)
//{
// additionalData = JsonConvert.SerializeObject(parameters.ToDictionary(p => p.Key, p => p.Value));
//}
//var dataToSign = CreateAuthPayload(method, time, uri.Split(new[] { ".com" }, StringSplitOptions.None)[1], additionalData);
//var signedData = Sign(dataToSign);
//var b64 = Base64Encode($"{Credentials.Key.GetString()}:{time}:{signedData}");
//result.Add("Authorization", $"HS256 {b64}");
//return result;
if (!signed)
{
return(new Dictionary <string, string>());
}
if (Credentials.Key == null)
{
throw new ArgumentException("ApiKey/Secret needed");
}
if (Credentials.Secret == null)
{
throw new ArgumentException("ApiKey/Secret needed");
}
var result = new Dictionary <string, string>();
var encoded = Convert.ToBase64String(Encoding.GetEncoding("ISO-8859-1").GetBytes(Credentials.Key.GetString() + ":" + Credentials.Secret.GetString()));
result.Add("Authorization", "Basic " + encoded);
return(result);
}
public override Dictionary <string, string> AddAuthenticationToHeaders(string uri, HttpMethod method, Dictionary <string, object> parameters, bool signed, HttpMethodParameterPosition parameterPosition, ArrayParametersSerialization arrayParametersSerialization)
{
var apiexpires = ApiExpires;
if (!signed)
{
return(new Dictionary <string, string>());
}
var result = new Dictionary <string, string>();
result.Add("api-key", Credentials.Key.GetString());
result.Add("api-expires", apiexpires.ToString(CultureInfo.InvariantCulture));
string additionalData = String.Empty;
if (parameters != null && parameters.Any() && method != HttpMethod.Get)
{
additionalData = JsonConvert.SerializeObject(parameters.OrderBy(p => p.Key).ToDictionary(p => p.Key, p => p.Value));
}
var dataToSign = CreateAuthPayload(method, uri.Split(new[] { ".com" }, StringSplitOptions.None)[1], apiexpires, additionalData);
var signedData = Sign(dataToSign);
result.Add("api-signature", signedData);
return(result);
}
public Dictionary <string, object> AddAuthenticationToParameters(string uri, HttpMethod method, Dictionary <string, object> parameters, bool signed, HttpMethodParameterPosition postParameterPosition, ArrayParametersSerialization arraySerialization)
{
if (!signed)
{
return(parameters);
}
if (uri.Contains("v2"))
{
parameters.Add("access_key", Credentials.Key.GetString());
var n = Nonce;
parameters.Add("tonce", n);
parameters = parameters.OrderBy(p => p.Key).ToDictionary(k => k.Key, v => v.Value);
var paramString = parameters.CreateParamString(false, ArrayParametersSerialization.MultipleValues);
var signData = method + "|";
signData += uri + "|";
signData += paramString;
byte[] signBytes;
lock (encryptLock)
signBytes = encryptor.ComputeHash(Encoding.UTF8.GetBytes(signData));
parameters.Add("signature", ByteArrayToString(signBytes));
}
return(parameters);
}
public override void AuthenticateRequest(RestApiClient apiClient, Uri uri, HttpMethod method, Dictionary <string, object> providedParameters, bool auth, ArrayParametersSerialization arraySerialization, HttpMethodParameterPosition parameterPosition, out SortedDictionary <string, object> uriParameters, out SortedDictionary <string, object> bodyParameters, out Dictionary <string, string> headers)
{
uriParameters = parameterPosition == HttpMethodParameterPosition.InUri ? new SortedDictionary <string, object>(providedParameters) : new SortedDictionary <string, object>();
bodyParameters = parameterPosition == HttpMethodParameterPosition.InBody ? new SortedDictionary <string, object>(providedParameters) : new SortedDictionary <string, object>();
headers = new Dictionary <string, string>();
if (!auth)
{
return;
}
var parameters = parameterPosition == HttpMethodParameterPosition.InUri ? uriParameters: bodyParameters;
parameters.Add("access_id", Credentials.Key !.GetString());
parameters.Add("tonce", _nonceProvider.GetNonce());
headers.Add("Authorization", SignMD5(uri.SetParameters(parameters).Query.Replace("?", "") + "&secret_key=" + Credentials.Secret !.GetString()));
}
public override Dictionary <string, object> AddAuthenticationToParameters(string uri, HttpMethod method, Dictionary <string, object> parameters, bool signed, HttpMethodParameterPosition parameterPosition, ArrayParametersSerialization arraySerialization)
{
if (!signed)
{
return(parameters);
}
parameters.Add("nonce", _nonceProvider.GetNonce());
return(parameters);
}
public override Dictionary <string, string> AddAuthenticationToHeaders(string uri, HttpMethod method, Dictionary <string, object> parameters, bool signed, HttpMethodParameterPosition parameterPosition, ArrayParametersSerialization arraySerialization)
{
if (!signed)
{
return(new Dictionary <string, string>());
}
if (Credentials.Key == null)
{
throw new ArgumentException("ApiKey/Secret needed");
}
var result = new Dictionary <string, string>
{
["KC-API-KEY"] = Credentials.Key.GetString(),
["KC-API-TIMESTAMP"] = Math.Round((DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalMilliseconds).ToString(CultureInfo.InvariantCulture),
["KC-API-PASSPHRASE"] = ((KucoinApiCredentials)Credentials).PassPhrase.GetString()
};
var jsonContent = string.Empty;
if (parameterPosition == HttpMethodParameterPosition.InBody)
{
jsonContent = JsonConvert.SerializeObject(parameters.OrderBy(p => p.Key).ToDictionary(p => p.Key, p => p.Value));
}
uri = uri.Substring(uri.IndexOf(".com", StringComparison.InvariantCulture) + 4);
var signData = result["KC-API-TIMESTAMP"] + method + Uri.UnescapeDataString(uri) + jsonContent;
result["KC-API-SIGN"] = Convert.ToBase64String(encryptor.ComputeHash(Encoding.UTF8.GetBytes(signData)));
return(result);
}
public override Dictionary <string, object> AddAuthenticationToParameters(string uri, HttpMethod method, Dictionary <string, object> parameters, bool signed, HttpMethodParameterPosition parameterPosition, ArrayParametersSerialization arraySerialization)
{
if (!signed)
{
return(parameters);
}
if (!parameters.ContainsKey("request_id"))
{
parameters.Add("request_id", Nonce);
}
else
{
parameters["request_id"] = Nonce;
}
return(parameters);
}
public override Dictionary <string, string> AddAuthenticationToHeaders(string uri, HttpMethod method, Dictionary <string, object> parameters, bool signed, HttpMethodParameterPosition parameterPosition, ArrayParametersSerialization arrayParametersSerialization)
{
if (!signed)
{
return(new Dictionary <string, string>());
}
var result = new Dictionary <string, string>();
result.Add("login-token", Credentials.Key.GetString());
// result.Add("X-Auth-Token", Credentials.Key.GetString());
var dataToSign = CreateAuthPayload(parameters);
var signedData = Sign(dataToSign);
result.Add("x-auth-sign", signedData);
return(result);
}
/// <summary>
/// Add authentication to the header dictionary based on the provided credentials
/// </summary>
/// <param name="uri">The uri the request is for</param>
/// <param name="method">The HTTP method of the request</param>
/// <param name="parameters">The provided parameters for the request</param>
/// <param name="signed">Wether or not the request needs to be signed. If not typically the parameters list can just be returned</param>
/// <param name="parameterPosition">Where post parameters are placed, in the URI or in the request body</param>
/// <param name="arraySerialization">How array parameters are serialized</param>
/// <returns>Should return a dictionary containing any header key/value pairs needed for authenticating the request</returns>
public virtual Dictionary <string, string> AddAuthenticationToHeaders(string uri, HttpMethod method, Dictionary <string, object> parameters, bool signed,
HttpMethodParameterPosition parameterPosition, ArrayParametersSerialization arraySerialization)
{
return(new Dictionary <string, string>());
}
public override Dictionary <string, string> AddAuthenticationToHeaders(string uri, HttpMethod method, Dictionary <string, object> parameters, bool signed, HttpMethodParameterPosition parameterPosition, ArrayParametersSerialization arraySerialization)
{
if (!signed)
{
return(new Dictionary <string, string>());
}
if (Credentials.Key == null || Credentials.Secret == null)
{
throw new ArgumentException("No valid API credentials provided. Key/Secret needed.");
}
if (uri.Contains("/v1/"))
{
var sign = string.Empty;
var apiKey = Credentials.Key.GetString();
var apiSecret = Credentials.Secret.GetString();
var nonce = DateTime.UtcNow.ToUnixTimeMilliseconds();
string message = apiKey + nonce;
using (HMACSHA256 hmac = new HMACSHA256(Convert.FromBase64String(apiSecret)))
{
byte[] signatureBytes = hmac.ComputeHash(Encoding.UTF8.GetBytes(message));
sign = Convert.ToBase64String(signatureBytes);
}
return(new Dictionary <string, string> {
{ "X-PCK", Credentials.Key.GetString() },
{ "X-Stamp", nonce.ToString() },
{ "X-Signature", sign },
});
}
else if (uri.Contains("/v3/"))
{
return(new Dictionary <string, string>());
}
return(new Dictionary <string, string>());
}
public override Dictionary <string, string> AddAuthenticationToHeaders(string uri, HttpMethod method, Dictionary <string, object> parameters, bool signed, HttpMethodParameterPosition postParameterPosition, ArrayParametersSerialization arraySerialization)
{
if (!signed && !signPublicRequests)
{
return(new Dictionary <string, string>());
}
if (Credentials == null || Credentials.Key == null || PassPhrase == null)
{
throw new ArgumentException("No valid API credentials provided. Key/Secret/PassPhrase needed.");
}
var time = (DateTime.UtcNow.ToUnixTimeMilliSeconds() / 1000.0m).ToString(CultureInfo.InvariantCulture);
var signtext = time + method.Method.ToUpper() + uri.Replace("https://www.okx.com", "").Trim('?');
if (method == HttpMethod.Post)
{
if (parameters.Count == 1 && parameters.Keys.First() == OkexClient.BodyParameterKey)
{
signtext += JsonConvert.SerializeObject(parameters[OkexClient.BodyParameterKey]);
}
else
{
signtext += JsonConvert.SerializeObject(parameters.OrderBy(p => p.Key).ToDictionary(p => p.Key, p => p.Value));
}
}
var signature = Base64Encode(encryptor.ComputeHash(Encoding.UTF8.GetBytes(signtext)));
var headerParameters = new Dictionary <string, string> {
{ "OK-ACCESS-KEY", Credentials.Key.GetString() },
{ "OK-ACCESS-SIGN", signature },
{ "OK-ACCESS-TIMESTAMP", time },
{ "OK-ACCESS-PASSPHRASE", PassPhrase.GetString() },
};
if (this.demoTradingService)
{
headerParameters.Add("x-simulated-trading", "1");
}
return(headerParameters);
}
public override Dictionary <string, object> AddAuthenticationToParameters(string uri, HttpMethod method, Dictionary <string, object> parameters, bool signed, HttpMethodParameterPosition parameterPosition, ArrayParametersSerialization arraySerialization)
{
if (!signed)
{
return(parameters);
}
string signData;
if (parameterPosition == HttpMethodParameterPosition.InUri)
{
signData = parameters.CreateParamString(true, arraySerialization);
}
else
{
var formData = HttpUtility.ParseQueryString(string.Empty);
foreach (var kvp in parameters.OrderBy(p => p.Key))
{
if (kvp.Value.GetType().IsArray)
{
var array = (Array)kvp.Value;
foreach (var value in array)
{
formData.Add(kvp.Key, value.ToString());
}
}
else
{
formData.Add(kvp.Key, kvp.Value.ToString());
}
}
signData = formData.ToString();
}
lock (signLock)
parameters.Add("signature", ByteToString(encryptor.ComputeHash(Encoding.UTF8.GetBytes(signData))));
return(parameters);
}
public override Dictionary <string, string> AddAuthenticationToHeaders(string uri, HttpMethod method, Dictionary <string, object> parameters, bool signed, HttpMethodParameterPosition parameterPosition, ArrayParametersSerialization arraySerialization)
{
if (!signed)
{
return(new Dictionary <string, string>());
}
if (Credentials.Key == null)
{
throw new ArgumentException("ApiKey/Secret needed");
}
var nonce = parameters.Single(n => n.Key == "nonce").Value;
var paramList = parameters.OrderBy(o => o.Key != "nonce");
var pars = string.Join("&", paramList.Select(p => $"{p.Key}={p.Value}"));
var result = new Dictionary <string, string> {
{ "API-Key", Credentials.Key.GetString() }
};
var np = nonce + pars;
byte[] nonceParamsBytes;
using (var sha = SHA256.Create())
nonceParamsBytes = sha.ComputeHash(Encoding.UTF8.GetBytes(np));
var pathBytes = Encoding.UTF8.GetBytes(uri.Split(new[] { ".com" }, StringSplitOptions.None)[1].Split('?')[0]);
var allBytes = pathBytes.Concat(nonceParamsBytes).ToArray();
var sign = encryptor.ComputeHash(allBytes);
result.Add("API-Sign", Convert.ToBase64String(sign));
return(result);
}
public override Dictionary <string, object> AddAuthenticationToParameters(string uri, HttpMethod method, Dictionary <string, object> parameters, bool signed, HttpMethodParameterPosition parameterPosition, ArrayParametersSerialization arraySerialization)
{
if (!signed)
{
return(parameters);
}
var query = parameters.CreateParamString(true, arraySerialization);
parameters.Add("signature", ByteToString(encryptor.ComputeHash(Encoding.UTF8.GetBytes(query))).ToLower());
return(parameters);
}
public void SetParameterPosition(HttpMethod method, HttpMethodParameterPosition position)
{
ParameterPositions[method] = position;
}
public override Dictionary <string, string> AddAuthenticationToHeaders(string uri, HttpMethod method, Dictionary <string, object> parameters, bool signed, HttpMethodParameterPosition parameterPosition, ArrayParametersSerialization arraySerialization)
{
if (Credentials.Key == null)
{
throw new ArgumentException("No valid API credentials provided. Key/Secret needed.");
}
return(new Dictionary <string, string> {
{ "X-BH-APIKEY", Credentials.Key.GetString() }
});
}
public Dictionary <string, string> AddAuthenticationToHeaders(string uri, HttpMethod method, Dictionary <string, object> parameters, bool signed, HttpMethodParameterPosition postParameterPosition, ArrayParametersSerialization arraySerialization)
{
if (!signed)
{
return(new Dictionary <string, string>());
}
var result = new Dictionary <string, string>();
if (uri.Contains("v3"))
{
var json = JsonConvert.SerializeObject(parameters.OrderBy(p => p.Key).ToDictionary(p => p.Key, p => p.Value));
if (string.IsNullOrEmpty(json) && method == HttpMethod.Post)
{
json = "{}";
}
var n = Nonce;
var signature = $"{uri.Split(new[] { ".io" }, StringSplitOptions.None)[1]}{n}{json}";
var signedData = SignV3(signature);
result.Add("kun-apikey", Credentials.Key.GetString());
result.Add("kun-nonce", n);
result.Add("kun-signature", signedData.ToLower());
}
return(result);
}
public override Dictionary <string, string> AddAuthenticationToHeaders(string uri, HttpMethod method, Dictionary <string, object> parameters, bool signed, HttpMethodParameterPosition parameterPosition, ArrayParametersSerialization arraySerialization)
{
var headers = new Dictionary <string, string>
{
{ "user-agent", "ParibuApp/342 (Android 12)" },
{ "x-app-version", "342" },
};
// Check Point
if (!signed)
{
return(headers);
}
// Authorization
headers["Authorization"] = "Bearer " + AccessToken.GetString();
// Return
return(headers);
}
public override Dictionary <string, object> AddAuthenticationToParameters(string uri, HttpMethod method, Dictionary <string, object> parameters, bool signed, HttpMethodParameterPosition parameterPosition, ArrayParametersSerialization arraySerialization)
{
if (!signed && !signPublicRequests)
{
return(parameters);
}
return(SignRequest(uri, method, parameters,
"AccessKeyId", "SignatureMethod", "SignatureVersion", "Timestamp", "Signature", 2));
}
public override Dictionary <string, object> AddAuthenticationToParameters(string uri, HttpMethod method, Dictionary <string, object> parameters, bool signed, HttpMethodParameterPosition postParameters, ArrayParametersSerialization arraySerialization)
{
return(base.AddAuthenticationToParameters(uri, method, parameters, signed, postParameters, arraySerialization));
}
