@riocrypto/common 1.0.432 → 1.0.435

package/build/clients/bitstamp-client.d.ts

@@ -0,0 +1,9 @@
+import { Crypto } from "../types/crypto";
+declare class BitstampClient {
+    private apiKey;
+    private secret;
+    constructor(apiKey: string, secret: string);
+    getWithdrawFee(crypto: Crypto): number | null;
+}
+export declare const bitstampClient: BitstampClient;
+export {};

package/build/clients/bitstamp-client.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bitstampClient = void 0;
+const crypto_1 = require("../types/crypto");
+class BitstampClient {
+    constructor(apiKey, secret) {
+        this.apiKey = apiKey;
+        this.secret = secret;
+    }
+    getWithdrawFee(crypto) {
+        if (crypto === crypto_1.Crypto.BTC) {
+            return 0.0005;
+        }
+        else if (crypto === crypto_1.Crypto.ETH) {
+            return 0.006;
+        }
+        else if (crypto === crypto_1.Crypto.USDC) {
+            return 20;
+        }
+        else {
+            return null;
+        }
+    }
+}
+//   private getHeaders(data: string, url: string, path: string, method: string) {
+//     const nonce = uuidv4();
+//     const timestamp = Date.now();
+//     let message = `${
+//       this.apiKey
+//     }${method}${url}${path}${""}${""}${nonce}${timestamp}${"v2"}${data}`;
+//     const headers = {
+//       "X-Auth": "BITSTAMP " + this.apiKey,
+//       "X-Auth-Signature": crypto
+//         .createHmac("sha256", this.secret)
+//         .update(message)
+//         .digest("hex"),
+//       "X-Auth-Nonce": nonce,
+//       "X-Auth-Timestamp": timestamp,
+//       "X-Auth-Version": "v2",
+//     };
+//     return headers;
+//   }
+// }
+exports.bitstampClient = new BitstampClient(process.env.BITSTAMP_API_KEY, process.env.BITSTAMP_SECRET);

package/build/clients/ccxt-wrapper.d.ts

@@ -0,0 +1,38 @@
+import { CCXTLiquidityProvider } from "../types/ccxt-liquidity-provider";
+import { Fiat } from "../types/fiat";
+import { Side } from "../types/side";
+declare class CCXTWrapper {
+    constructor();
+    createBuyOrder(amount: number, crypto: Crypto, fiat: Fiat, ccxtLiquidityProvider: CCXTLiquidityProvider): Promise<{
+        ccxtId: any;
+        price: any;
+        amountCrypto: any;
+        amountFiat: number;
+        crypto: Crypto;
+        fiat: Fiat;
+        side: Side;
+    }>;
+    createSellOrder(amount: number, crypto: Crypto, fiat: Fiat, ccxtLiquidityProvider: CCXTLiquidityProvider): Promise<{
+        ccxtId: any;
+        price: any;
+        amountCrypto: number;
+        amountFiat: number;
+        crypto: Crypto;
+        fiat: Fiat;
+        side: Side;
+    }>;
+    transfer(side: Side, amount: number, crypto: Crypto, cryptoAddress: string, ccxtLiquidityProvider: CCXTLiquidityProvider): Promise<void>;
+    getBuyQuote(amount: number, crypto: Crypto, fiat: Fiat): Promise<{
+        price: number;
+        amountCrypto: number;
+        amountFiat: number;
+        crypto: Crypto;
+        fiat: Fiat;
+        side: Side;
+    }>;
+    private getOptimalExchange;
+    private round;
+    private getExchange;
+}
+export declare const ccxtWrapper: CCXTWrapper;
+export {};

package/build/clients/ccxt-wrapper.js

@@ -0,0 +1,117 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ccxtWrapper = void 0;
+const ccxt_1 = __importDefault(require("ccxt"));
+const ccxt_liquidity_provider_1 = require("../types/ccxt-liquidity-provider");
+const side_1 = require("../types/side");
+class CCXTWrapper {
+    constructor() { }
+    createBuyOrder(amount, crypto, fiat, ccxtLiquidityProvider) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const exchange = yield this.getExchange(ccxtLiquidityProvider);
+            const order = yield exchange.createOrder(`${crypto}/${fiat}`, "market", "buy", amount);
+            return {
+                ccxtId: order.id,
+                price: order.price,
+                amountCrypto: order.amount,
+                amountFiat: amount,
+                crypto,
+                fiat,
+                side: side_1.Side.Buy,
+            };
+        });
+    }
+    createSellOrder(amount, crypto, fiat, ccxtLiquidityProvider) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // @ts-ignore
+            const exchange = yield this.getExchange(ccxtLiquidityProvider);
+            const order = yield exchange.createOrder(`${crypto}/${fiat}`, "market", "sell", amount);
+            return {
+                ccxtId: order.id,
+                price: order.price,
+                amountCrypto: amount,
+                amountFiat: order.amount * order.price,
+                crypto,
+                fiat,
+                side: side_1.Side.Sell,
+            };
+        });
+    }
+    transfer(side, amount, crypto, cryptoAddress, ccxtLiquidityProvider) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const exchange = yield this.getExchange(ccxtLiquidityProvider);
+            const params = ccxtLiquidityProvider === ccxt_liquidity_provider_1.CCXTLiquidityProvider.Kraken
+                ? {
+                    key: "Metamask",
+                }
+                : undefined;
+            yield exchange.withdraw(crypto, this.round(amount, 8), cryptoAddress, undefined, params);
+        });
+    }
+    getBuyQuote(amount, crypto, fiat) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const exchange = yield this.getOptimalExchange(crypto);
+            if (!exchange)
+                throw new Error("Unable to get optimal exchange");
+            let ticker = yield exchange.fetchTicker(`${crypto}/${fiat}`);
+            if (!ticker.vwap)
+                throw new Error("Unable to get ticker vwap");
+            return {
+                price: ticker.vwap,
+                amountCrypto: amount / ticker.vwap,
+                amountFiat: amount,
+                crypto,
+                fiat,
+                side: side_1.Side.Buy,
+            };
+        });
+    }
+    getOptimalExchange(crypto) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (let exchangeId of ccxt_1.default.exchanges) {
+                if (exchangeId === "bitstamp") {
+                    //@ts-ignore
+                    const exchangeClass = ccxt_1.default[exchangeId], exchange = new exchangeClass({
+                        apiKey: process.env[`${exchangeId.toLocaleUpperCase()}_API_KEY`],
+                        secret: process.env[`${exchangeId.toLocaleUpperCase()}_SECRET`],
+                    });
+                    return exchange;
+                }
+            }
+            return null;
+        });
+    }
+    round(value, precision) {
+        if (Number.isInteger(precision)) {
+            var shift = Math.pow(10, precision);
+            // Limited preventing decimal issue
+            return Math.round(value * shift + 0.00000000000001) / shift;
+        }
+        else {
+            return Math.round(value);
+        }
+    }
+    getExchange(ccxtLiquidityProvider) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // @ts-ignore
+            const exchangeClass = ccxt_1.default[ccxtLiquidityProvider], exchange = new exchangeClass({
+                apiKey: process.env[`${ccxtLiquidityProvider.toLocaleUpperCase()}_API_KEY`],
+                secret: process.env[`${ccxtLiquidityProvider.toLocaleUpperCase()}_SECRET`],
+            });
+            return exchange;
+        });
+    }
+}
+exports.ccxtWrapper = new CCXTWrapper();

package/build/clients/fixer-client.d.ts

@@ -0,0 +1,8 @@
+import { Fiat } from "../types/fiat";
+declare class FixerClient {
+    private apiKey;
+    constructor(apiKey: string);
+    convert(from: Fiat, to: Fiat): Promise<number>;
+}
+export declare const fixerClient: FixerClient;
+export {};

package/build/clients/fixer-client.js

@@ -0,0 +1,34 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fixerClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+class FixerClient {
+    constructor(apiKey) {
+        this.apiKey = apiKey;
+    }
+    convert(from, to) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fixerResponse = yield axios_1.default.get(`https://api.apilayer.com/fixer/latest?base=${from}&symbols=${to}`, {
+                headers: {
+                    apikey: this.apiKey,
+                    "Accept-Encoding": "gzip,deflate,compress",
+                },
+            });
+            const exchangeRate = fixerResponse.data.rates[to];
+            return exchangeRate;
+        });
+    }
+}
+exports.fixerClient = new FixerClient(process.env.FIXER_API_KEY);

package/build/index.d.ts

@@ -155,3 +155,6 @@ export * from "./models/bank-payout";
 export * from "./models/order";
 export * from "./models/partner";
 export * from "./models/user";
+export * from "./clients/bitstamp-client";
+export * from "./clients/ccxt-wrapper";
+export * from "./clients/fixer-client";

package/build/index.js

@@ -172,3 +172,6 @@ __exportStar(require("./models/bank-payout"), exports);
 __exportStar(require("./models/order"), exports);
 __exportStar(require("./models/partner"), exports);
 __exportStar(require("./models/user"), exports);
+__exportStar(require("./clients/bitstamp-client"), exports);
+__exportStar(require("./clients/ccxt-wrapper"), exports);
+__exportStar(require("./clients/fixer-client"), exports);

package/build/middlewares/authorize.js

@@ -27,7 +27,7 @@ const missing_security_question_error_1 = require("../errors/missing-security-qu
 const admin_only_error_1 = require("../errors/admin-only-error");
 const not_broker_error_1 = require("../errors/not-broker-error");
 const authorize = (req, res, next, mongoose, authorizationTypes) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    var _a, _b, _c, _d, _e, _f, _g, _h;
     let missingKYC = false;
     if (authorizationTypes.includes(authorization_type_1.AuthorizationType.Auth) ||
         authorizationTypes.includes(authorization_type_1.AuthorizationType.UserNoKYC) ||
@@ -126,22 +126,25 @@ const authorize = (req, res, next, mongoose, authorizationTypes) => __awaiter(vo
         }
     }
     if (authorizationTypes.includes(authorization_type_1.AuthorizationType.Broker)) {
-        let businessUser;
-        const BusinessUser = yield (0, business_user_1.buildBusinessUser)(mongoose);
-        businessUser = yield BusinessUser.findOne({
-            authId: req.currentAuth.id,
-        });
-        if (!businessUser) {
-            throw new Error();
-        }
-        if ((businessUser === null || businessUser === void 0 ? void 0 : businessUser.kycStatus) !== kyc_status_1.KYCStatus.businessApproved) {
-            missingKYC = true;
-            throw new Error();
-        }
-        if ((_g = businessUser.attributes) === null || _g === void 0 ? void 0 : _g.includes(user_attribute_1.UserAttribute.broker)) {
-            throw new not_broker_error_1.NotBrokerError();
+        let brokerBusinessUser;
+        try {
+            const BusinessUser = yield (0, business_user_1.buildBusinessUser)(mongoose);
+            brokerBusinessUser = yield BusinessUser.findOne({
+                authId: req.currentAuth.id,
+                attributes: { $e: user_attribute_1.UserAttribute.broker },
+            });
+            if (!brokerBusinessUser) {
+                throw new Error();
+            }
+            if ((brokerBusinessUser === null || brokerBusinessUser === void 0 ? void 0 : brokerBusinessUser.kycStatus) !== kyc_status_1.KYCStatus.businessApproved) {
+                missingKYC = true;
+                throw new Error();
+            }
+        }
+        catch (err) {
+            brokerBusinessUser = null;
         }
-        const user = businessUser;
+        const user = brokerBusinessUser;
         if (user) {
             req.user = user;
         }
@@ -155,14 +158,17 @@ const authorize = (req, res, next, mongoose, authorizationTypes) => __awaiter(vo
         }
         if ((authorizationTypes.includes(authorization_type_1.AuthorizationType.User) ||
             authorizationTypes.includes(authorization_type_1.AuthorizationType.UserNoKYC)) &&
-            ((_h = req.cookies) === null || _h === void 0 ? void 0 : _h.jwt)) {
+            ((_g = req.cookies) === null || _g === void 0 ? void 0 : _g.jwt)) {
             throw new missing_user_error_1.MissingUserError();
         }
         if (authorizationTypes.includes(authorization_type_1.AuthorizationType.Admin) &&
             authorizationTypes.length === 1 &&
-            ((_j = req.cookies) === null || _j === void 0 ? void 0 : _j.jwt)) {
+            ((_h = req.cookies) === null || _h === void 0 ? void 0 : _h.jwt)) {
             throw new admin_only_error_1.AdminOnlyError();
         }
+        if (!req.user && authorizationTypes.includes(authorization_type_1.AuthorizationType.Broker)) {
+            throw new not_broker_error_1.NotBrokerError();
+        }
         throw new not_authorized_error_1.NotAuthorizedError();
     }
     next();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riocrypto/common",
-  "version": "1.0.432",
+  "version": "1.0.435",
   "description": "",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -23,6 +23,7 @@
     "@aws-sdk/client-s3": "^3.297.0",
     "@types/express": "^4.17.13",
     "axios": "^0.27.2",
+    "ccxt": "^3.0.30",
     "express": "^4.18.1",
     "express-validator": "^6.14.2",
     "jsonwebtoken": "^8.5.1",