@riocrypto/common-server 1.0.506

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

@@ -0,0 +1,16 @@
+declare class BitstampClient {
+    private apiKey;
+    private apiSecret;
+    constructor(apiKey: string, apiSecret: string);
+    getHeaders(payload?: any): Promise<{
+        "X-Auth": string;
+        "X-Auth-Signature": string;
+        "X-Auth-Nonce": string;
+        "X-Auth-Timestamp": string;
+        "X-Auth-Version": string;
+        "Content-Type": string;
+    }>;
+    getTransactions(): Promise<any>;
+}
+export declare const bitstampClient: BitstampClient;
+export {};

package/build/clients/bitstamp-client.js

@@ -0,0 +1,83 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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.bitstampClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+const crypto = __importStar(require("crypto"));
+const uuid = __importStar(require("uuid"));
+class BitstampClient {
+    constructor(apiKey, apiSecret) {
+        this.apiKey = apiKey;
+        this.apiSecret = apiSecret;
+    }
+    getHeaders(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const timestamp = String(Math.round(Date.now()));
+            const nonce = uuid.v4().toString();
+            const content_type = "application/x-www-form-urlencoded";
+            let payload_string = new URLSearchParams(payload).toString();
+            const message = `BITSTAMP ${this.apiKey}POSTwww.bitstamp.net/api/v2/crypto-transactions/${content_type}${nonce}${timestamp}v2${payload_string}`;
+            const message_encoded = new TextEncoder().encode(message);
+            const signature = crypto
+                .createHmac("sha256", this.apiSecret)
+                .update(message_encoded)
+                .digest("hex");
+            const headers = {
+                "X-Auth": `BITSTAMP ${this.apiKey}`,
+                "X-Auth-Signature": signature,
+                "X-Auth-Nonce": nonce,
+                "X-Auth-Timestamp": timestamp,
+                "X-Auth-Version": "v2",
+                "Content-Type": content_type,
+            };
+            return headers;
+        });
+    }
+    getTransactions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const payload = { offset: "0" };
+            let payload_string = new URLSearchParams(payload).toString();
+            const headers = yield this.getHeaders(payload);
+            const response = yield axios_1.default.post("https://www.bitstamp.net/api/v2/crypto-transactions/", payload_string, { headers });
+            if (response.status !== 200) {
+                throw new Error("Status code not 200");
+            }
+            return response.data;
+        });
+    }
+}
+exports.bitstampClient = new BitstampClient(process.env.BITSTAMP_API_KEY, process.env.BITSTAMP_SECRET);

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

@@ -0,0 +1,48 @@
+import { Crypto } from "../types/crypto";
+import { CCXTLiquidityProvider } from "../types/ccxt-liquidity-provider";
+import { Fiat } from "../types/fiat";
+import { Side } from "../types/side";
+declare class CCXTClient {
+    private env;
+    constructor(env: "production" | "development");
+    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;
+    getSellQuote(amount: number, crypto: Crypto, fiat: Fiat): Promise<{
+        price: number;
+        amountCrypto: number;
+        amountFiat: number;
+        crypto: Crypto;
+        fiat: Fiat;
+    }>;
+    getDepositAddress(crypto: Crypto): Promise<string>;
+}
+export declare const ccxtWrapper: CCXTClient;
+export {};

package/build/clients/ccxt-client.js

@@ -0,0 +1,201 @@
+"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 rio_env_1 = require("../types/rio-env");
+const side_1 = require("../types/side");
+class CCXTClient {
+    constructor(env) {
+        this.env = env;
+    }
+    createBuyOrder(amount, crypto, fiat, ccxtLiquidityProvider) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.env === "production") {
+                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,
+                };
+            }
+            else {
+                return {
+                    ccxtId: "1",
+                    price: 1,
+                    amountCrypto: amount,
+                    amountFiat: amount,
+                    crypto,
+                    fiat,
+                    side: side_1.Side.Buy,
+                };
+            }
+        });
+    }
+    createSellOrder(amount, crypto, fiat, ccxtLiquidityProvider) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.env === "production") {
+                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,
+                };
+            }
+            else {
+                return {
+                    ccxtId: "1",
+                    price: 1,
+                    amountCrypto: amount,
+                    amountFiat: amount,
+                    crypto,
+                    fiat,
+                    side: side_1.Side.Sell,
+                };
+            }
+        });
+    }
+    transfer(side, amount, crypto, cryptoAddress, ccxtLiquidityProvider) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.env === "production") {
+                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* () {
+            if (this.env === "production") {
+                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,
+                };
+            }
+            else {
+                return {
+                    price: 0.5,
+                    amountCrypto: amount,
+                    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;
+        });
+    }
+    getSellQuote(amount, crypto, fiat) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.env === "production") {
+                const exchange = yield this.getOptimalExchange(crypto);
+                if (!exchange)
+                    throw new Error("Unable to get optimal exchange");
+                exchange.options["fetchMarketsMethod"] = "fetch_markets_from_api";
+                let ticker = yield exchange.fetchTicker(`${crypto}/${fiat}`);
+                if (!ticker.vwap)
+                    throw new Error("Unable to get ticker vwap");
+                return {
+                    price: ticker.vwap,
+                    amountCrypto: amount,
+                    amountFiat: amount * ticker.vwap,
+                    crypto,
+                    fiat,
+                };
+            }
+            else {
+                return {
+                    price: 1,
+                    amountCrypto: 100,
+                    amountFiat: 100,
+                    crypto,
+                    fiat,
+                };
+            }
+        });
+    }
+    getDepositAddress(crypto) {
+        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 depositAddress = yield exchange.fetchDepositAddress(crypto);
+            if (!depositAddress)
+                throw new Error("Unable to get deposit address");
+            return depositAddress.address;
+        });
+    }
+}
+exports.ccxtWrapper = new CCXTClient([rio_env_1.RioEnv.Production, rio_env_1.RioEnv.Staging].includes(process.env.RIO_ENV)
+    ? "production"
+    : "development");

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

@@ -0,0 +1,6 @@
+import { AxiosInstance, AxiosStatic } from "axios";
+export declare class EtherscanClient {
+    private axios;
+    constructor(axios: AxiosStatic | AxiosInstance);
+    getTransactions(address: string): Promise<any[]>;
+}

package/build/clients/etherscan-client.js

@@ -0,0 +1,24 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EtherscanClient = void 0;
+class EtherscanClient {
+    constructor(axios) {
+        this.axios = axios;
+    }
+    getTransactions(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.axios.get(`https://api.etherscan.io/api?module=account&action=txlist&address=${address}&startblock=0&endblock=99999999&page=1&offset=100&sort=asc&apikey=${"DDR78IVPYXCVGFKTT6YWBBYZBRD18S2EW1"}`);
+            return data.result;
+        });
+    }
+}
+exports.EtherscanClient = EtherscanClient;

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

@@ -0,0 +1,15 @@
+import { Crypto } from "../types/crypto";
+import { FireblocksSDK } from "fireblocks-sdk";
+declare class FireblocksClient {
+    fireblocks: FireblocksSDK;
+    constructor(privateKey: string, apiKey: string);
+    estimateWithdrawFromExchangeFee(crypto: Crypto, address: string, amountCrypto: number): Promise<string | undefined>;
+    estimateWithdrawFromVaultFee(crypto: Crypto, address: string, amountCrypto: number): Promise<string | undefined>;
+    withdrawFromExchange(crypto: Crypto, address: string, amountCrypto: number): Promise<void>;
+    withdrawFromVault(crypto: Crypto, address: string, amountCrypto: number): Promise<void>;
+    getVaultCryptoBalance(crypto: Crypto): Promise<number>;
+    getExchangeCryptoBalance(crypto: Crypto): Promise<number>;
+    getExchangeFiatBalance(): Promise<number>;
+}
+export declare const fireblocksClient: FireblocksClient;
+export {};

package/build/clients/fireblocks-client.js

@@ -0,0 +1,140 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fireblocksClient = void 0;
+const fireblocks_sdk_1 = require("fireblocks-sdk");
+class FireblocksClient {
+    constructor(privateKey, apiKey) {
+        this.fireblocks = new fireblocks_sdk_1.FireblocksSDK(privateKey, apiKey, "https://api.fireblocks.io");
+    }
+    estimateWithdrawFromExchangeFee(crypto, address, amountCrypto) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let estimate = yield this.fireblocks.estimateFeeForTransaction({
+                assetId: crypto,
+                source: {
+                    type: fireblocks_sdk_1.PeerType.VAULT_ACCOUNT,
+                    id: "0",
+                },
+                destination: {
+                    type: fireblocks_sdk_1.PeerType.ONE_TIME_ADDRESS,
+                    oneTimeAddress: {
+                        address,
+                    },
+                },
+                amount: amountCrypto,
+                operation: fireblocks_sdk_1.TransactionOperation.TRANSFER,
+            });
+            return estimate.medium.networkFee;
+        });
+    }
+    estimateWithdrawFromVaultFee(crypto, address, amountCrypto) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let estimate = yield this.fireblocks.estimateFeeForTransaction({
+                assetId: crypto,
+                source: {
+                    type: fireblocks_sdk_1.PeerType.VAULT_ACCOUNT,
+                    id: "0",
+                },
+                destination: {
+                    type: fireblocks_sdk_1.PeerType.ONE_TIME_ADDRESS,
+                    oneTimeAddress: {
+                        address,
+                    },
+                },
+                amount: amountCrypto,
+                operation: fireblocks_sdk_1.TransactionOperation.TRANSFER,
+            });
+            return estimate.medium.networkFee;
+        });
+    }
+    withdrawFromExchange(crypto, address, amountCrypto) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let withdraw = yield this.fireblocks.createTransaction({
+                assetId: crypto,
+                source: {
+                    type: fireblocks_sdk_1.PeerType.EXCHANGE_ACCOUNT,
+                    id: "b227e245-a32e-c7ab-ff37-b365fa361077",
+                },
+                destination: {
+                    type: fireblocks_sdk_1.PeerType.ONE_TIME_ADDRESS,
+                    oneTimeAddress: {
+                        address,
+                    },
+                },
+                amount: amountCrypto,
+                operation: fireblocks_sdk_1.TransactionOperation.TRANSFER,
+            });
+        });
+    }
+    withdrawFromVault(crypto, address, amountCrypto) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let withdraw = yield this.fireblocks.createTransaction({
+                assetId: crypto,
+                source: {
+                    type: fireblocks_sdk_1.PeerType.VAULT_ACCOUNT,
+                    id: "2",
+                },
+                destination: {
+                    type: fireblocks_sdk_1.PeerType.ONE_TIME_ADDRESS,
+                    oneTimeAddress: {
+                        address,
+                    },
+                },
+                amount: amountCrypto,
+                operation: fireblocks_sdk_1.TransactionOperation.TRANSFER,
+            });
+        });
+    }
+    getVaultCryptoBalance(crypto) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let vault = yield this.fireblocks.getVaultAccountById("2");
+            let balance = 0;
+            if (!(vault === null || vault === void 0 ? void 0 : vault.assets)) {
+                throw new Error();
+            }
+            vault.assets.forEach((asset) => {
+                if (asset.id === crypto) {
+                    balance += Number(asset.available);
+                }
+            });
+            return balance;
+        });
+    }
+    getExchangeCryptoBalance(crypto) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let exchanges = yield this.fireblocks.getExchangeAccounts();
+            let balance = 0;
+            exchanges.forEach((exchange) => {
+                exchange.assets.forEach((asset) => {
+                    if (asset.id === crypto) {
+                        balance += Number(asset.available);
+                    }
+                });
+            });
+            return balance;
+        });
+    }
+    getExchangeFiatBalance() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let exchanges = yield this.fireblocks.getExchangeAccounts();
+            let balance = 0;
+            exchanges.forEach((exchange) => {
+                exchange.assets.forEach((asset) => {
+                    if (asset.id === "USD") {
+                        balance += Number(asset.available);
+                    }
+                });
+            });
+            return balance;
+        });
+    }
+}
+exports.fireblocksClient = new FireblocksClient(process.env.FIREBLOCKS_PRIVATE_KEY, process.env.FIREBLOCKS_API_KEY);

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/clients/gueno-client.d.ts

@@ -0,0 +1,10 @@
+declare class GuenoClient {
+    private email;
+    private password;
+    private env;
+    constructor(email: string, password: string, env: "sandbox" | "production");
+    getAddressRiskScore(address: string, protocol: Crypto): Promise<any>;
+    getAccessToken(): Promise<any>;
+}
+export declare const guenoClient: GuenoClient;
+export {};

package/build/clients/gueno-client.js

@@ -0,0 +1,44 @@
+"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.guenoClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+class GuenoClient {
+    constructor(email, password, env) {
+        this.email = email;
+        this.password = password;
+        this.env = env;
+    }
+    getAddressRiskScore(address, protocol) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const accessToken = yield this.getAccessToken();
+            const { data } = yield axios_1.default.get(`https://api-gueno.${this.env === "production" ? "prd" : "stg"}.gueno.com/api/amlCrypto/addressRiskScore?address=${address}&protocol=${protocol}`, {
+                headers: {
+                    Authorization: `Bearer ${accessToken}`,
+                },
+            });
+            return data;
+        });
+    }
+    getAccessToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield axios_1.default.post(`https://api-gueno.${this.env === "production" ? "prd" : "stg"}.gueno.com/api/auth/login`, {
+                email: this.email,
+                password: this.password,
+            });
+            return data.access_token;
+        });
+    }
+}
+exports.guenoClient = new GuenoClient(process.env.GUENO_EMAIL, process.env.GUENO_PASSWORD, process.env.GUENO_ENV);

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

@@ -0,0 +1,6 @@
+declare class KapstarClient {
+    constructor();
+    getBRLExchangeRateUSD(): Promise<number>;
+}
+export declare const kapstarClient: KapstarClient;
+export {};

package/build/clients/kapstar-client.js

@@ -0,0 +1,26 @@
+"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.kapstarClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+class KapstarClient {
+    constructor() { }
+    getBRLExchangeRateUSD() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const kapstarResponse = yield axios_1.default.get(`https://api.ecsa.finance/quotation-service/v1/quotation/last`);
+            return 1 / kapstarResponse.data;
+        });
+    }
+}
+exports.kapstarClient = new KapstarClient();