@riocrypto/common-server 1.0.2747 → 1.0.2749

package/build/clients/axios-with-logging.js

@@ -18,6 +18,7 @@ function buildAxiosWithLogging() {
         "private",
         "credential",
         "passphrase",
+        "signature",
         "csrf",
     ];
     function maskHeaderValue(value) {
@@ -34,6 +35,25 @@ function buildAxiosWithLogging() {
         });
         return maskedHeaders;
     }
+    function maskUrl(url) {
+        if (!url)
+            return "unknown";
+        try {
+            const parsed = new URL(url);
+            const params = new URLSearchParams(parsed.search);
+            params.forEach((value, key) => {
+                const lower = key.toLowerCase();
+                if (sensitiveSubstrings.some((sub) => lower.includes(sub))) {
+                    params.set(key, maskHeaderValue(value));
+                }
+            });
+            parsed.search = params.toString();
+            return parsed.toString();
+        }
+        catch (_a) {
+            return url;
+        }
+    }
     // Request Interceptor
     axiosWithLogging.interceptors.request.use((config) => {
         var _a;
@@ -43,7 +63,7 @@ function buildAxiosWithLogging() {
             // Mask sensitive headers in the configuration
             const maskedHeaders = maskHeaders(customConfig.headers);
             // Combine and log the full request configuration with masked headers
-            const logMessage = `Request: method=${customConfig.method}, url=${customConfig.url}, headers=${JSON.stringify(maskedHeaders)}, data=${JSON.stringify(customConfig.data)}`;
+            const logMessage = `Request: method=${customConfig.method}, url=${maskUrl(customConfig.url)}, headers=${JSON.stringify(maskedHeaders)}, data=${JSON.stringify(customConfig.data)}`;
             ((_a = logger_1.default.getLogger()) === null || _a === void 0 ? void 0 : _a.info(logMessage)) || console.log(logMessage);
         }
         return config;
@@ -61,21 +81,21 @@ function buildAxiosWithLogging() {
         // Check if logging is disabled for this request
         if (!customConfig.skipLogging) {
             // Combine and log the full response details
-            const logMessage = `Response: url=${customConfig.url}, status=${response.status}, data=${JSON.stringify(response.data)}`;
+            const logMessage = `Response: url=${maskUrl(customConfig.url)}, status=${response.status}, data=${JSON.stringify(response.data)}`;
             ((_a = logger_1.default.getLogger()) === null || _a === void 0 ? void 0 : _a.info(logMessage)) || console.log(logMessage);
         }
         return response;
     }, (error) => {
-        var _a, _b;
+        var _a, _b, _c;
         // Combine and log the response error details without headers
-        let logMessage = `Response Error: url=${error.config ? error.config.url : "unknown"}, message=${error.message}`;
+        let logMessage = `Response Error: url=${maskUrl((_a = error.config) === null || _a === void 0 ? void 0 : _a.url)}, message=${error.message}`;
         if (error.response) {
             logMessage += `, status=${error.response.status}, data=${JSON.stringify(error.response.data)}`;
         }
-        ((_a = logger_1.default.getLogger()) === null || _a === void 0 ? void 0 : _a.info(logMessage)) || console.log(logMessage);
+        ((_b = logger_1.default.getLogger()) === null || _b === void 0 ? void 0 : _b.info(logMessage)) || console.log(logMessage);
         return Promise.reject({
             message: logMessage,
-            status: (_b = error.response) === null || _b === void 0 ? void 0 : _b.status,
+            status: (_c = error.response) === null || _c === void 0 ? void 0 : _c.status,
         });
     });
     return axiosWithLogging;

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

@@ -0,0 +1,206 @@
+import { Crypto } from "@riocrypto/common";
+export interface BinanceBalance {
+    asset: string;
+    free: string;
+    locked: string;
+}
+export interface BinanceAccountInfo {
+    balances: BinanceBalance[];
+}
+export interface BinanceDepositAddress {
+    address: string;
+    coin: string;
+    tag: string;
+    url: string;
+}
+export interface BinanceOrderResponse {
+    symbol: string;
+    orderId: number;
+    orderListId: number;
+    clientOrderId: string;
+    transactTime?: number;
+    price: string;
+    origQty: string;
+    executedQty: string;
+    cummulativeQuoteQty: string;
+    status: string;
+    timeInForce: string;
+    type: string;
+    side: string;
+    fills?: Array<{
+        price: string;
+        qty: string;
+        commission: string;
+        commissionAsset: string;
+    }>;
+}
+export interface BinanceWithdrawHistoryItem {
+    id: string;
+    amount: string;
+    transactionFee: string;
+    coin: string;
+    status: number;
+    address: string;
+    txId: string;
+    applyTime: string;
+    network: string;
+    transferType: number;
+    withdrawOrderId?: string;
+    info: string;
+    confirmNo: number;
+}
+export interface BinanceDepositHistoryItem {
+    id: string;
+    amount: string;
+    coin: string;
+    network: string;
+    status: number;
+    address: string;
+    addressTag: string;
+    txId: string;
+    insertTime: number;
+    transferType: number;
+    confirmTimes: string;
+    unlockConfirm: number;
+    walletType: number;
+}
+export interface BinanceTradeItem {
+    id: number;
+    price: string;
+    qty: string;
+    quoteQty: string;
+    time: number;
+    isBuyerMaker: boolean;
+    isBestMatch: boolean;
+}
+export interface BinanceOrderBook {
+    lastUpdateId: number;
+    bids: [string, string][];
+    asks: [string, string][];
+}
+export interface BinanceExchangeInfo {
+    timezone: string;
+    serverTime: number;
+    symbols: any[];
+}
+export interface BinanceFiatWithdrawResponse {
+    code: string;
+    message: string;
+    data: {
+        orderId: string;
+    };
+}
+export interface BinanceFiatOrderDetail {
+    code: string;
+    message: string;
+    data: {
+        orderId: string;
+        orderStatus: string;
+        amount: string;
+        fee: string;
+        fiatCurrency: string;
+        errorCode: string;
+        errorMessage: string;
+        ext: Record<string, any>;
+    };
+}
+export declare enum BinanceOrderStatus {
+    NEW = "NEW",
+    PARTIALLY_FILLED = "PARTIALLY_FILLED",
+    FILLED = "FILLED",
+    CANCELED = "CANCELED",
+    PENDING_CANCEL = "PENDING_CANCEL",
+    REJECTED = "REJECTED",
+    EXPIRED = "EXPIRED",
+    EXPIRED_IN_MATCH = "EXPIRED_IN_MATCH"
+}
+declare class BinanceClient {
+    private apiKey;
+    private apiSecret;
+    private baseUrl;
+    private axiosClient;
+    constructor(apiKey: string, apiSecret: string, env: "Production" | "Staging");
+    private buildQueryString;
+    private sign;
+    private signedGet;
+    private signedPost;
+    private signedPostWithBody;
+    private signedDelete;
+    private publicGet;
+    getAccountInformation(skipLogging?: boolean): Promise<BinanceAccountInfo>;
+    getBalance(asset: string): Promise<number>;
+    getAllBalances(assets?: string[]): Promise<Record<string, number>>;
+    newOrder(params: {
+        symbol: string;
+        side: string;
+        type: string;
+        timeInForce?: string;
+        quantity?: number;
+        quoteOrderQty?: number;
+        price?: string | number;
+    }): Promise<BinanceOrderResponse>;
+    getOrder(symbol: string, orderId: number): Promise<BinanceOrderResponse>;
+    cancelOrder(symbol: string, orderId: number): Promise<any>;
+    getOpenOrders(symbol: string): Promise<BinanceOrderResponse[]>;
+    getAllOrders(symbol: string): Promise<BinanceOrderResponse[]>;
+    getMyTrades(symbol: string, orderId?: number): Promise<any[]>;
+    getRecentTrades(symbol: string, limit?: number): Promise<BinanceTradeItem[]>;
+    getExchangeInfo(): Promise<BinanceExchangeInfo>;
+    getOrderBook(symbol: string, limit?: number): Promise<BinanceOrderBook>;
+    getDepositAddress(coin: string, network?: string): Promise<BinanceDepositAddress>;
+    withdraw(params: {
+        coin: string;
+        address: string;
+        amount: number;
+        network?: string;
+        withdrawOrderId?: string;
+        addressTag?: string;
+    }): Promise<{
+        id: string;
+    }>;
+    getWithdrawHistory(params?: {
+        coin?: string;
+        withdrawOrderId?: string;
+        status?: number;
+        offset?: number;
+        limit?: number;
+        startTime?: number;
+        endTime?: number;
+    }): Promise<BinanceWithdrawHistoryItem[]>;
+    getDepositHistory(params?: {
+        coin?: string;
+        status?: number;
+        startTime?: number;
+        endTime?: number;
+        offset?: number;
+        limit?: number;
+        txId?: string;
+    }): Promise<BinanceDepositHistoryItem[]>;
+    withdrawFiat(params: {
+        currency: string;
+        apiPaymentMethod: string;
+        amount: number;
+        accountInfo: {
+            accountNumber: string;
+            [key: string]: any;
+        };
+        ext?: Record<string, any>;
+    }): Promise<BinanceFiatWithdrawResponse>;
+    getFiatOrderDetail(orderNo: string): Promise<BinanceFiatOrderDetail>;
+    private convertCryptoToBinanceDescriptor;
+    getDepositAddressForCrypto(cryptoAsset: Crypto): Promise<{
+        address: string;
+        memo?: string;
+    }>;
+    withdrawCrypto(cryptoAsset: Crypto, amount: number, address: string, memo?: string): Promise<string>;
+    withdrawMXN(amount: number, clabe: string): Promise<string>;
+    getWithdrawalHistoryByOrderId(withdrawalId: string): Promise<BinanceWithdrawHistoryItem[]>;
+    getDepositByTxHash(hash: string): Promise<BinanceDepositHistoryItem | undefined>;
+    createMarketOrder(symbol: string, amount: number, side: "BUY" | "SELL"): Promise<BinanceOrderResponse>;
+    createLimitOrder(symbol: string, side: "BUY" | "SELL", quantity: number, price: string | number, timeInForce?: string): Promise<BinanceOrderResponse>;
+    getLatestTradedPrice(symbol: string): Promise<number>;
+    getLowestAsk(symbol: string, limit?: number): Promise<number>;
+    getHighestBid(symbol: string, limit?: number): Promise<number>;
+}
+export declare const buildBinanceClient: () => Promise<BinanceClient>;
+export {};

package/build/clients/binance-client.js

@@ -0,0 +1,398 @@
+"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.buildBinanceClient = exports.BinanceOrderStatus = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const common_1 = require("@riocrypto/common");
+const axios_with_logging_1 = require("./axios-with-logging");
+const secret_manager_client_1 = require("./secret-manager-client");
+const mongoose_1 = __importDefault(require("mongoose"));
+var BinanceOrderStatus;
+(function (BinanceOrderStatus) {
+    BinanceOrderStatus["NEW"] = "NEW";
+    BinanceOrderStatus["PARTIALLY_FILLED"] = "PARTIALLY_FILLED";
+    BinanceOrderStatus["FILLED"] = "FILLED";
+    BinanceOrderStatus["CANCELED"] = "CANCELED";
+    BinanceOrderStatus["PENDING_CANCEL"] = "PENDING_CANCEL";
+    BinanceOrderStatus["REJECTED"] = "REJECTED";
+    BinanceOrderStatus["EXPIRED"] = "EXPIRED";
+    BinanceOrderStatus["EXPIRED_IN_MATCH"] = "EXPIRED_IN_MATCH";
+})(BinanceOrderStatus = exports.BinanceOrderStatus || (exports.BinanceOrderStatus = {}));
+class BinanceClient {
+    constructor(apiKey, apiSecret, env) {
+        this.apiKey = apiKey;
+        this.apiSecret = apiSecret;
+        this.baseUrl =
+            env === "Production"
+                ? "https://api.binance.com"
+                : "https://testnet.binance.vision";
+        this.axiosClient = (0, axios_with_logging_1.buildAxiosWithLogging)();
+    }
+    buildQueryString(params) {
+        const filtered = {};
+        for (const [key, value] of Object.entries(params)) {
+            if (value !== undefined && value !== null) {
+                filtered[key] = String(value);
+            }
+        }
+        return new URLSearchParams(filtered).toString();
+    }
+    sign(queryString) {
+        return crypto_1.default
+            .createHmac("sha256", this.apiSecret)
+            .update(queryString)
+            .digest("hex");
+    }
+    signedGet(path, params = {}, skipLogging = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const allParams = Object.assign(Object.assign({}, params), { timestamp: Date.now() });
+            const queryString = this.buildQueryString(allParams);
+            const signature = this.sign(queryString);
+            const response = yield this.axiosClient.get(`${this.baseUrl}${path}?${queryString}&signature=${signature}`, { headers: { "X-MBX-APIKEY": this.apiKey }, skipLogging });
+            return response.data;
+        });
+    }
+    signedPost(path, params = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const allParams = Object.assign(Object.assign({}, params), { timestamp: Date.now() });
+            const queryString = this.buildQueryString(allParams);
+            const signature = this.sign(queryString);
+            const response = yield this.axiosClient.post(`${this.baseUrl}${path}?${queryString}&signature=${signature}`, null, { headers: { "X-MBX-APIKEY": this.apiKey } });
+            return response.data;
+        });
+    }
+    signedPostWithBody(path, body, queryParams = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const allQueryParams = Object.assign(Object.assign({}, queryParams), { timestamp: Date.now() });
+            const queryString = this.buildQueryString(allQueryParams);
+            const bodyString = JSON.stringify(body);
+            const signature = this.sign(queryString + bodyString);
+            const response = yield this.axiosClient.post(`${this.baseUrl}${path}?${queryString}&signature=${signature}`, body, {
+                headers: {
+                    "X-MBX-APIKEY": this.apiKey,
+                    "Content-Type": "application/json",
+                },
+            });
+            return response.data;
+        });
+    }
+    signedDelete(path, params = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const allParams = Object.assign(Object.assign({}, params), { timestamp: Date.now() });
+            const queryString = this.buildQueryString(allParams);
+            const signature = this.sign(queryString);
+            const response = yield this.axiosClient.delete(`${this.baseUrl}${path}?${queryString}&signature=${signature}`, { headers: { "X-MBX-APIKEY": this.apiKey } });
+            return response.data;
+        });
+    }
+    publicGet(path, params = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const filtered = {};
+            for (const [key, value] of Object.entries(params)) {
+                if (value !== undefined && value !== null) {
+                    filtered[key] = String(value);
+                }
+            }
+            const response = yield this.axiosClient.get(`${this.baseUrl}${path}`, {
+                params: filtered,
+                headers: { "X-MBX-APIKEY": this.apiKey },
+            });
+            return response.data;
+        });
+    }
+    // Account
+    getAccountInformation(skipLogging = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.signedGet("/api/v3/account", {}, skipLogging);
+        });
+    }
+    getBalance(asset) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const info = yield this.getAccountInformation();
+            const balance = info.balances.find((b) => b.asset === asset);
+            return (balance === null || balance === void 0 ? void 0 : balance.free) ? parseFloat(balance.free) : 0;
+        });
+    }
+    getAllBalances(assets) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const info = yield this.getAccountInformation(true);
+            const result = {};
+            if (assets) {
+                const assetSet = new Set(assets);
+                info.balances
+                    .filter((b) => assetSet.has(b.asset))
+                    .forEach((b) => {
+                    result[b.asset] = parseFloat(b.free) || 0;
+                });
+            }
+            else {
+                info.balances.forEach((b) => {
+                    result[b.asset] = parseFloat(b.free) || 0;
+                });
+            }
+            console.log("Binance balances:", JSON.stringify(result));
+            return result;
+        });
+    }
+    // Trading
+    newOrder(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.signedPost("/api/v3/order", params);
+        });
+    }
+    getOrder(symbol, orderId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.signedGet("/api/v3/order", { symbol, orderId });
+        });
+    }
+    cancelOrder(symbol, orderId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.signedDelete("/api/v3/order", { symbol, orderId });
+        });
+    }
+    getOpenOrders(symbol) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.signedGet("/api/v3/openOrders", { symbol });
+        });
+    }
+    getAllOrders(symbol) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.signedGet("/api/v3/allOrders", { symbol });
+        });
+    }
+    getMyTrades(symbol, orderId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.signedGet("/api/v3/myTrades", { symbol, orderId });
+        });
+    }
+    // Market data
+    getRecentTrades(symbol, limit) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.publicGet("/api/v3/trades", { symbol, limit });
+        });
+    }
+    getExchangeInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.publicGet("/api/v3/exchangeInfo");
+        });
+    }
+    getOrderBook(symbol, limit) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.publicGet("/api/v3/depth", { symbol, limit });
+        });
+    }
+    // Wallet
+    getDepositAddress(coin, network) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.signedGet("/sapi/v1/capital/deposit/address", {
+                coin,
+                network,
+            });
+        });
+    }
+    withdraw(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.signedPost("/sapi/v1/capital/withdraw/apply", params);
+        });
+    }
+    getWithdrawHistory(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.signedGet("/sapi/v1/capital/withdraw/history", params || {});
+        });
+    }
+    getDepositHistory(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.signedGet("/sapi/v1/capital/deposit/hisrec", params || {});
+        });
+    }
+    // Fiat
+    withdrawFiat(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.signedPostWithBody("/sapi/v2/fiat/withdraw", params);
+        });
+    }
+    getFiatOrderDetail(orderNo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.signedGet("/sapi/v1/fiat/get-order-detail", { orderNo });
+        });
+    }
+    // Convenience methods
+    convertCryptoToBinanceDescriptor(cryptoAsset) {
+        switch (cryptoAsset) {
+            case common_1.Crypto.USDC:
+                return { coin: "USDC", network: "ETH" };
+            case common_1.Crypto.USDCPolygon:
+                return { coin: "USDC", network: "MATIC" };
+            case common_1.Crypto.USDCSolana:
+                return { coin: "USDC", network: "SOL" };
+            case common_1.Crypto.USDCStellar:
+                return { coin: "USDC", network: "XLM" };
+            case common_1.Crypto.USDCBase:
+                return { coin: "USDC", network: "BASE" };
+            case common_1.Crypto.USDTEthereum:
+                return { coin: "USDT", network: "ETH" };
+            case common_1.Crypto.USDTPolygon:
+                return { coin: "USDT", network: "MATIC" };
+            case common_1.Crypto.USDTTron:
+                return { coin: "USDT", network: "TRX" };
+            case common_1.Crypto.ETH:
+                return { coin: "ETH", network: "ETH" };
+            case common_1.Crypto.TRON:
+                return { coin: "TRX", network: "TRX" };
+            case common_1.Crypto.SOL:
+                return { coin: "SOL", network: "SOL" };
+            default:
+                return null;
+        }
+    }
+    getDepositAddressForCrypto(cryptoAsset) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const descriptor = this.convertCryptoToBinanceDescriptor(cryptoAsset);
+            if (!descriptor) {
+                throw new Error("Unsupported crypto");
+            }
+            const response = yield this.getDepositAddress(descriptor.coin, descriptor.network);
+            return { address: response.address, memo: response.tag };
+        });
+    }
+    withdrawCrypto(cryptoAsset, amount, address, memo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if ([common_1.RioEnv.Sandbox, common_1.RioEnv.Local, common_1.RioEnv.Test].includes(process.env.RIO_ENV)) {
+                throw new Error("Binance withdraw not allowed in sandbox");
+            }
+            const descriptor = this.convertCryptoToBinanceDescriptor(cryptoAsset);
+            if (!descriptor) {
+                throw new Error("Unsupported crypto");
+            }
+            console.log("Withdrawing from Binance");
+            const withdrawOrderId = new mongoose_1.default.Types.ObjectId().toString();
+            console.log("Withdraw order id: ", withdrawOrderId);
+            try {
+                const response = yield this.withdraw({
+                    coin: descriptor.coin,
+                    address,
+                    amount,
+                    withdrawOrderId,
+                    network: descriptor.network,
+                    addressTag: memo,
+                });
+                console.log("Response: ", response);
+                return withdrawOrderId;
+            }
+            catch (error) {
+                console.log("Error withdrawing from Binance");
+                console.log("Error: ", error);
+                throw error;
+            }
+        });
+    }
+    withdrawMXN(amount, clabe) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if ([common_1.RioEnv.Sandbox, common_1.RioEnv.Local, common_1.RioEnv.Test].includes(process.env.RIO_ENV)) {
+                throw new Error("Binance fiat withdraw not allowed in sandbox");
+            }
+            const response = yield this.withdrawFiat({
+                currency: "MXN",
+                apiPaymentMethod: "bank_transfer",
+                amount,
+                accountInfo: { accountNumber: clabe },
+            });
+            if (response.code !== "000000") {
+                throw new Error(`Fiat withdraw failed: ${response.message}`);
+            }
+            return response.data.orderId;
+        });
+    }
+    getWithdrawalHistoryByOrderId(withdrawalId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log("Withdrawal id: ", withdrawalId);
+            return this.getWithdrawHistory({ withdrawOrderId: withdrawalId });
+        });
+    }
+    getDepositByTxHash(hash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getDepositHistory({ txId: hash });
+            return response.find((deposit) => deposit.txId === hash);
+        });
+    }
+    createMarketOrder(symbol, amount, side) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.newOrder({
+                symbol,
+                side,
+                type: "MARKET",
+                quantity: side === "SELL" ? amount : undefined,
+                quoteOrderQty: side === "BUY" ? amount : undefined,
+            });
+        });
+    }
+    createLimitOrder(symbol, side, quantity, price, timeInForce = "GTC") {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.newOrder({
+                symbol,
+                side,
+                type: "LIMIT",
+                timeInForce,
+                quantity,
+                price,
+            });
+        });
+    }
+    getLatestTradedPrice(symbol) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const trades = yield this.getRecentTrades(symbol);
+            return Number(trades[0].price);
+        });
+    }
+    getLowestAsk(symbol, limit = 5) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const orderBook = yield this.getOrderBook(symbol, limit);
+            const lowestAsk = (_b = (_a = orderBook.asks) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b[0];
+            if (!lowestAsk) {
+                throw new Error("No lowest ask found");
+            }
+            return parseFloat(lowestAsk);
+        });
+    }
+    getHighestBid(symbol, limit = 5) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const orderBook = yield this.getOrderBook(symbol, limit);
+            const highestBid = (_b = (_a = orderBook.bids) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b[0];
+            if (!highestBid) {
+                throw new Error("No highest bid found");
+            }
+            return parseFloat(highestBid);
+        });
+    }
+}
+const buildBinanceClient = () => __awaiter(void 0, void 0, void 0, function* () {
+    const BINANCE_API_KEY = yield secret_manager_client_1.secretManagerClient.getSecretValue("BINANCE_API_KEY");
+    if (!BINANCE_API_KEY) {
+        throw new common_1.SecretManagerError();
+    }
+    const BINANCE_API_SECRET = yield secret_manager_client_1.secretManagerClient.getSecretValue("BINANCE_API_SECRET");
+    if (!BINANCE_API_SECRET) {
+        throw new common_1.SecretManagerError();
+    }
+    const env = [
+        common_1.RioEnv.Production,
+        common_1.RioEnv.Development,
+    ].includes(process.env.RIO_ENV)
+        ? "Production"
+        : "Staging";
+    return new BinanceClient(BINANCE_API_KEY, BINANCE_API_SECRET, env);
+});
+exports.buildBinanceClient = buildBinanceClient;

package/build/index.d.ts

@@ -137,6 +137,7 @@ export * from "./clients/bitso-client";
 export * from "./clients/circle-client";
 export * from "./clients/coincover-client";
 export * from "./clients/google-sheets-api-client";
+export * from "./clients/binance-client";
 export * from "./helpers/get-user-helper";
 export * from "./helpers/get-processor-fees";
 export * from "./helpers/get-network-fees";

package/build/index.js

@@ -153,6 +153,7 @@ __exportStar(require("./clients/bitso-client"), exports);
 __exportStar(require("./clients/circle-client"), exports);
 __exportStar(require("./clients/coincover-client"), exports);
 __exportStar(require("./clients/google-sheets-api-client"), exports);
+__exportStar(require("./clients/binance-client"), exports);
 __exportStar(require("./helpers/get-user-helper"), exports);
 __exportStar(require("./helpers/get-processor-fees"), exports);
 __exportStar(require("./helpers/get-network-fees"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riocrypto/common-server",
-  "version": "1.0.2747",
+  "version": "1.0.2749",
   "description": "",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -28,7 +28,7 @@
     "@google-cloud/secret-manager": "^5.3.0",
     "@google-cloud/storage": "^6.9.5",
     "@hyperdx/node-opentelemetry": "^0.7.0",
-    "@riocrypto/common": "^1.0.2539",
+    "@riocrypto/common": "^1.0.2541",
     "@slack/web-api": "^7.9.2",
     "@types/express": "^4.17.13",
     "axios": "^1.7.4",