@riocrypto/common 1.0.433 → 1.0.436

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,7 @@ export * from "./models/bank-payout";
 export * from "./models/order";
 export * from "./models/partner";
 export * from "./models/user";
+export * from "./models/ccxt-order";
+export * from "./clients/bitstamp-client";
+export * from "./clients/ccxt-wrapper";
+export * from "./clients/fixer-client";

package/build/index.js

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

package/build/models/ccxt-order.d.ts

@@ -0,0 +1,8 @@
+import mongoose from "mongoose";
+interface CCXTOrderDoc extends mongoose.Document {
+    orderId: string;
+    status: string;
+    ccxtId: string;
+}
+declare const buildCCXTOrder: (mongoose: typeof mongoose) => void;
+export { buildCCXTOrder, CCXTOrderDoc };

package/build/models/ccxt-order.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCCXTOrder = void 0;
+const buildCCXTOrder = (mongoose) => {
+    const CCXTOrderSchema = new mongoose.Schema({
+        orderId: {
+            type: String,
+            required: true,
+        },
+        ccxtId: {
+            type: String,
+            required: true,
+        },
+        status: {
+            type: String,
+            required: true,
+        },
+    }, {
+        toJSON: {
+            transform(doc, ret) {
+                ret.id = ret._id;
+                delete ret._id;
+                delete ret.__v;
+            },
+        },
+    });
+    CCXTOrderSchema.statics.build = (attrs) => {
+        return new CCXTOrder(attrs);
+    };
+    const CCXTOrder = mongoose.model("CCXTOrder", CCXTOrderSchema);
+};
+exports.buildCCXTOrder = buildCCXTOrder;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riocrypto/common",
-  "version": "1.0.433",
+  "version": "1.0.436",
   "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",