Перевести код из Node JS в C#

Код на Node JS

import * as request from 'request'
import * as crypto from 'crypto'
import * as querystring from 'querystring'
import * as url from 'url'
import 'es6-shim'
const W_BASEURL = "https://api.com"
const W_DEFAULT_API_VERSION = "2"
const W_DEFAULT_API_FORMAT = "json"
export class WClient {
    constructor(private config: any, private masqueradeTarget?: string) {
        if(!config.secretKey) throw new Error('config.secretKey is missing');
        if(!config.apiKey)  throw new Error('config.apiKey is missing');
        this.config.options = this.config.options || {};
    }
    public get(path: string, params?: any, options?: any): Promise<any> {
        return this.request("GET", path, params, options)
    }
    public post(path: string, body?: any, options?: any): Promise<any> {
        return this.request("POST", path, body, options)
    }
    public put(path: string, body?: any, options?: any): Promise<any> {
        return this.request("PUT", path, body, options)
    }
    public delete(path: string, body?: any, options?: any): Promise<any> {
        return this.request("DELETE", path, body, options)
    }
    /**
     * returns a new W client which is ostensibly authenticated as the supplied
     * target
     *
     * @param target an account ID or an SRN
     */
    public masqueraded(target: string): WClient {
        return new WClient(this.config, target);
    }
    private request(method: string, path: string, params: any = {}, options: any = {}): Promise<any> {
        if(!path)
            throw "path required"
        let requestOptions = this.buildRequestOptions(method, path, params, options)
        return new Promise((resolve, reject) => {
            request(requestOptions, (err, res) => {
                if(err)
                    throw err;
                else if(res.statusCode >= 200 && res.statusCode < 300)
                    resolve(res.body || {})
                else
                    reject(res.body || { statusCode: res.statusCode })
            })
        })
    }
    private buildRequestOptions(method: string, path: string, params: any, options: any): request.UrlOptions & request.CoreOptions {
        options = options || {};
        let parsedUrl = url.parse(url.resolve(this.config.baseUrl || W_BASEURL, path), true)
        let json = !(options.headers || {}).hasOwnProperty('Content-Type') || options.headers['Content-Type'] == 'application/json';
        let requestOptions: request.UrlOptions & request.CoreOptions = {
            ...this.config.options,
            ...options,
            url: parsedUrl.protocol + "//" + parsedUrl.host + parsedUrl.pathname, // no querystring here!
            method: method,
            headers: {
                ...this.config.options.headers,
                ...options.headers,
                "X-Api-Version": this.config.apiVersion || W_DEFAULT_API_VERSION,
                "X-Api-Key": this.config.apiKey
            },
            qs: {
                ...this.config.qs,
                ...options.qs,
                timestamp: new Date().getTime(),
                format: this.config.format || W_DEFAULT_API_FORMAT
            },
            json: json
        };
        if(requestOptions.method == "GET")
            requestOptions.qs = Object.assign(requestOptions.qs, params)
        else
            requestOptions.body = params
        Object.assign(requestOptions.qs, parsedUrl.query);
        if(this.masqueradeTarget && !('masqueradeAs' in requestOptions))
            requestOptions.qs.masqueradeAs = this.masqueradeTarget;
        requestOptions.headers["X-Api-Signature"] = this.buildSignature(requestOptions);
        return requestOptions
    }
    private buildSignature(requestOptions: request.UrlOptions & request.CoreOptions): string {
        let buffers: Buffer[] = [];
        const encoding = 'utf8';
        buffers.push(Buffer.from(requestOptions.url.toString(), encoding));
        buffers.push(Buffer.from(requestOptions.url.toString().indexOf('?') < 0 ? "?" : "&", encoding));
        buffers.push(Buffer.from(querystring.stringify(requestOptions.qs), encoding));
        if(requestOptions.body) {
            if(typeof requestOptions.body == 'string')
                buffers.push(Buffer.from(requestOptions.body, encoding));
            else if(requestOptions.body instanceof Buffer)
                buffers.push(requestOptions.body);
            else
                buffers.push(Buffer.from(JSON.stringify(requestOptions.body), encoding));
        }
        return crypto.createHmac("sha256", this.config.secretKey)
            .update(Buffer.concat(buffers))
            .digest("hex")
    }
}

Код на JS

"use strict";
var __assign = (this && this.__assign) || Object.assign || function(t) {
    for (var s, i = 1, n = arguments.length; i < n; i++) {
        s = arguments[i];
        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
            t[p] = s[p];
    }
    return t;
};
Object.defineProperty(exports, "__esModule", { value: true });
var request = require("request");
var crypto = require("crypto");
var querystring = require("querystring");
var url = require("url");
require("es6-shim");
var W_BASEURL = "https://api.com";
var W_DEFAULT_API_VERSION = "2";
var W_DEFAULT_API_FORMAT = "json";
var Client = (function () {
    function Client(config, masqueradeTarget) {
        this.config = config;
        this.masqueradeTarget = masqueradeTarget;
        if (!config.secretKey)
            throw new Error('config.secretKey is missing');
        if (!config.apiKey)
            throw new Error('config.apiKey is missing');
        this.config.options = this.config.options || {};
    }
    Client.prototype.get = function (path, params, options) {
        return this.request("GET", path, params, options);
    };
    Client.prototype.post = function (path, body, options) {
        return this.request("POST", path, body, options);
    };
    Client.prototype.put = function (path, body, options) {
        return this.request("PUT", path, body, options);
    };
    Client.prototype.delete = function (path, body, options) {
        return this.request("DELETE", path, body, options);
    };
    Client.prototype.masqueraded = function (target) {
        return new Client(this.config, target);
    };
    Client.prototype.request = function (method, path, params, options) {
        if (params === void 0) { params = {}; }
        if (options === void 0) { options = {}; }
        if (!path)
            throw "path required";
        var requestOptions = this.buildRequestOptions(method, path, params, options);
        return new Promise(function (resolve, reject) {
            request(requestOptions, function (err, res) {
                if (err)
                    throw err;
                else if (res.statusCode >= 200 && res.statusCode < 300)
                    resolve(res.body || {});
                else
                    reject(res.body || { statusCode: res.statusCode });
            });
        });
    };
    Client.prototype.buildRequestOptions = function (method, path, params, options) {
        options = options || {};
        var parsedUrl = url.parse(url.resolve(this.config.baseUrl || W_BASEURL, path), true);
        var json = !(options.headers || {}).hasOwnProperty('Content-Type') || options.headers['Content-Type'] == 'application/json';
        var requestOptions = __assign({}, this.config.options, options, { 
            url: parsedUrl.protocol + "//" + parsedUrl.host + parsedUrl.pathname, 
            method: method, 
            headers: __assign({}, 
                this.config.options.headers, 
                options.headers, 
                { "X-Api-Version": this.config.apiVersion || W_DEFAULT_API_VERSION, 
                "X-Api-Key": this.config.apiKey }), 
            qs: __assign({}, this.config.qs, options.qs, 
                { timestamp: new Date().getTime(), 
                    format: this.config.format || W_DEFAULT_API_FORMAT }), json: json });
        if (requestOptions.method == "GET")
            requestOptions.qs = Object.assign(requestOptions.qs, params);
        else
            requestOptions.body = params;
        Object.assign(requestOptions.qs, parsedUrl.query);
        if (this.masqueradeTarget && !('masqueradeAs' in requestOptions))
            requestOptions.qs.masqueradeAs = this.masqueradeTarget;
        requestOptions.headers["X-Api-Signature"] = this.buildSignature(requestOptions);
        return requestOptions;
    };
    Client.prototype.buildSignature = function (requestOptions) {
        var buffers = [];
        var encoding = 'utf8';
        buffers.push(Buffer.from(requestOptions.url.toString(), encoding));
        buffers.push(Buffer.from(requestOptions.url.toString().indexOf('?') < 0 ? "?" : "&", encoding));
        buffers.push(Buffer.from(querystring.stringify(requestOptions.qs), encoding));
        if (requestOptions.body) {
            if (typeof requestOptions.body == 'string')
                buffers.push(Buffer.from(requestOptions.body, encoding));
            else if (requestOptions.body instanceof Buffer){
                console.log("BUFFER");
                console.log(requestOptions.body);
                buffers.push(requestOptions.body);
            }
            else
                buffers.push(Buffer.from(JSON.stringify(requestOptions.body), encoding));
        }
        return crypto.createHmac("sha256", this.config.secretKey)
            .update(Buffer.concat(buffers))
            .digest("hex");
    };
    return Client;
}());
exports.Client = Client;

Сделал так, но есть недоработки, такие как:

1. Проверка на masqueradeAs
2. Загрузка файлов
3. Указание headers

Что есть:

using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Security.Cryptography;
using System.Text;
using System.Linq;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json;
using ConfigAccess;
using LogAccess;
using System.Collections.Specialized;
namespace WApiLib
{
    public class WApi
    {
        private static readonly string domain = Configuration.Get()["W:Domain"];
        private static readonly string apiKey = Configuration.Get()["W:ApiKey"];
        private static readonly string secKey = Configuration.Get()["W:SecKey"];
        public HttpWebResponse Get(string path)
        {
            return Get(path, new Dictionary<string, object>());
        }
        public HttpWebResponse Get(string path, Dictionary<string, object> queryParams)
        {
            return Request("GET", path, queryParams);
        }
        public HttpWebResponse Post(string path, Dictionary<string, object> body)
        {
            return Request("POST", path, body);
        }
        private HttpWebResponse Request(string method, string path, Dictionary<string, object> body)
        {
            Dictionary<string, object> queryParams = new Dictionary<string, object>();
            if (method.Equals("GET"))
                queryParams = body;
            queryParams.Add("timestamp", DateTimeOffset.UtcNow.ToUnixTimeMilliseconds());
            string queryString = queryParams.Aggregate("", (previous, current) => previous + "&" + current.Key + "=" + current.Value).Remove(0, 1);
            string url = domain + path + "?" + queryString;
            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
            request.Method = method;
            request.ContentType = "application/json";
            request.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
            if (!method.Equals("GET"))
            {
                url += JsonConvert.SerializeObject(body);
                using (StreamWriter writer = new StreamWriter(request.GetRequestStream()))
                    writer.Write(JsonConvert.SerializeObject(body));
            }
            request.Headers["X-Api-Key"] = apiKey;
            request.Headers["X-Api-Signature"] = CalcAuthSigHash(secKey, url);
            request.Headers["X-Api-Version"] = Configuration.Get()["W:ApiVersion"];
            try
            {
                return (HttpWebResponse)request.GetResponse();
            }
            catch (WebException e)
            {
                string msg = new StreamReader(e.Response.GetResponseStream()).ReadToEnd();
                Log.Error(msg);
                throw new SystemException(msg);
            }
        }
        private static byte[] GetBytes(string str)
        {
            return Encoding.UTF8.GetBytes(str);
        }
        private static string GetString(byte[] bytes)
        {
            return BitConverter.ToString(bytes);
        }
        private static String CalcAuthSigHash(string key, string value)
        {
            HMACSHA256 hmac = new HMACSHA256(GetBytes(key));
            string hash = GetString(hmac.ComputeHash(GetBytes(value))).Replace("-", "");
            return hash;
        }
    }
}