@yuants/vendor-binance 0.7.8 → 0.8.0

package/dist/legacy_index.js

@@ -4,7 +4,9 @@ import { Terminal } from '@yuants/protocol';
 import { addAccountTransferAddress } from '@yuants/transfer';
 import { decodePath, encodePath, formatTime } from '@yuants/utils';
 import { createHash } from 'crypto';
-import { client, isError } from './api';
+import { getDefaultCredential, isApiError } from './api/client';
+import { deleteUmOrder, getDepositAddress, getDepositHistory, getSpotAccountInfo, getSubAccountList, getUnifiedAccountBalance, getUnifiedUmAccount, getUnifiedUmOpenOrders, getWithdrawHistory, postAssetTransfer, postUmOrder, postWithdraw, } from './api/private-api';
+import { getFutureOpenInterest } from './api/public-api';
 const terminal = Terminal.fromNodeEnv();
 const _mapSymbolToOpenInterest = {};
 const getOpenInterest = async (symbol) => {
@@ -15,7 +17,7 @@ const getOpenInterest = async (symbol) => {
             return cache.value;
         }
     }
-    const data = await client.getFutureOpenInterest({ symbol });
+    const data = await getFutureOpenInterest({ symbol });
     const value = +data.openInterest || 0;
     _mapSymbolToOpenInterest[symbol] = { value, updated_at: Date.now() };
     return value;
@@ -89,6 +91,7 @@ const deriveClientOrderId = (order) => {
     });
     return `YUANTS${createHash('sha256').update(payload).digest('hex').slice(0, 24)}`;
 };
+const isPublicOnly = process.env.PUBLIC_ONLY === 'true';
 // provideTicks(terminal, 'binance', (product_id) => {
 //   const [instType, symbol] = decodePath(product_id);
 //   if (instType === 'usdt-future') {
@@ -120,263 +123,293 @@ const deriveClientOrderId = (order) => {
 //   }
 //   return EMPTY;
 // });
-(async () => {
-    const spotAccountInfo = await client.getSpotAccountInfo();
-    if (isError(spotAccountInfo)) {
-        throw new Error(spotAccountInfo.msg);
-    }
-    const uid = spotAccountInfo.uid;
-    const SPOT_ACCOUNT_ID = `binance/${uid}/spot/usdt`;
-    const UNIFIED_ACCOUNT_ID = `binance/${uid}/unified/usdt`;
-    {
-        // unified accountInfo
-        provideAccountInfoService(terminal, UNIFIED_ACCOUNT_ID, async () => {
-            const [accountResult, umAccountResult] = await Promise.all([
-                client.getUnifiedAccountBalance(),
-                client.getUnifiedUmAccount(),
-            ]);
-            if (isError(accountResult)) {
-                throw new Error(accountResult.msg);
-            }
-            const usdtAssets = accountResult.find((v) => v.asset === 'USDT');
-            if (!usdtAssets) {
-                throw new Error('USDT not found');
-            }
-            if (isError(umAccountResult)) {
-                throw new Error(umAccountResult.msg);
-            }
-            const usdtUmAssets = umAccountResult.assets.find((v) => v.asset === 'USDT');
-            if (!usdtUmAssets) {
-                throw new Error('um USDT not found');
-            }
-            const equity = +usdtAssets.totalWalletBalance + +usdtAssets.umUnrealizedPNL;
-            const free = equity - +usdtUmAssets.initialMargin;
-            const positions = umAccountResult.positions
-                .filter((v) => +v.positionAmt !== 0)
-                .map((v) => {
+if (isPublicOnly) {
+    console.info('PUBLIC_ONLY=1, skip Binance legacy services');
+}
+else {
+    const credential = getDefaultCredential();
+    (async () => {
+        const spotAccountInfo = await getSpotAccountInfo(credential);
+        if (isApiError(spotAccountInfo)) {
+            throw new Error(spotAccountInfo.msg);
+        }
+        const uid = spotAccountInfo.uid;
+        const SPOT_ACCOUNT_ID = `binance/${uid}/spot/usdt`;
+        const UNIFIED_ACCOUNT_ID = `binance/${uid}/unified/usdt`;
+        {
+            // unified accountInfo
+            provideAccountInfoService(terminal, UNIFIED_ACCOUNT_ID, async () => {
+                const [accountResult, umAccountResult] = await Promise.all([
+                    getUnifiedAccountBalance(credential),
+                    getUnifiedUmAccount(credential),
+                ]);
+                if (isApiError(accountResult)) {
+                    throw new Error(accountResult.msg);
+                }
+                const usdtAssets = accountResult.find((v) => v.asset === 'USDT');
+                if (!usdtAssets) {
+                    throw new Error('USDT not found');
+                }
+                if (isApiError(umAccountResult)) {
+                    throw new Error(umAccountResult.msg);
+                }
+                const usdtUmAssets = umAccountResult.assets.find((v) => v.asset === 'USDT');
+                if (!usdtUmAssets) {
+                    throw new Error('um USDT not found');
+                }
+                const equity = +usdtAssets.totalWalletBalance + +usdtAssets.umUnrealizedPNL;
+                const free = equity - +usdtUmAssets.initialMargin;
+                const positions = umAccountResult.positions
+                    .filter((v) => +v.positionAmt !== 0)
+                    .map((v) => {
+                    return {
+                        position_id: `${v.symbol}/${v.positionSide}`,
+                        datasource_id: 'BINANCE',
+                        product_id: encodePath('usdt-future', v.symbol),
+                        direction: v.positionSide,
+                        volume: +v.positionAmt,
+                        free_volume: +v.positionAmt,
+                        position_price: +v.entryPrice,
+                        closable_price: +v.entryPrice + +v.unrealizedProfit / +v.positionAmt,
+                        floating_profit: +v.unrealizedProfit,
+                        valuation: +v.positionAmt * (+v.entryPrice + +v.unrealizedProfit / +v.positionAmt),
+                    };
+                });
                 return {
-                    position_id: `${v.symbol}/${v.positionSide}`,
-                    datasource_id: 'BINANCE',
-                    product_id: encodePath('usdt-future', v.symbol),
-                    direction: v.positionSide,
-                    volume: +v.positionAmt,
-                    free_volume: +v.positionAmt,
-                    position_price: +v.entryPrice,
-                    closable_price: +v.entryPrice + +v.unrealizedProfit / +v.positionAmt,
-                    floating_profit: +v.unrealizedProfit,
-                    valuation: +v.positionAmt * (+v.entryPrice + +v.unrealizedProfit / +v.positionAmt),
+                    money: {
+                        currency: 'USDT',
+                        equity,
+                        free,
+                    },
+                    positions,
                 };
-            });
-            return {
-                money: {
-                    currency: 'USDT',
-                    equity,
-                    free,
-                },
-                positions,
-            };
-        }, { auto_refresh_interval: 1000 });
-        addAccountMarket(terminal, { account_id: UNIFIED_ACCOUNT_ID, market_id: 'BINANCE/UNIFIED' });
-    }
-    {
-        // spot account info
-        provideAccountInfoService(terminal, SPOT_ACCOUNT_ID, async () => {
-            const spotAccountResult = await client.getSpotAccountInfo({ omitZeroBalances: true });
-            if (isError(spotAccountResult)) {
-                throw new Error(spotAccountResult.msg);
-            }
-            const usdtAssets = spotAccountResult.balances.find((v) => v.asset === 'USDT');
-            return {
-                money: {
-                    currency: 'USDT',
-                    equity: +((usdtAssets === null || usdtAssets === void 0 ? void 0 : usdtAssets.free) || 0),
-                    free: +((usdtAssets === null || usdtAssets === void 0 ? void 0 : usdtAssets.free) || 0),
-                },
-                positions: [],
-            };
-        });
-        addAccountMarket(terminal, { account_id: SPOT_ACCOUNT_ID, market_id: 'BINANCE/SPOT' });
-    }
-    // transfer
-    {
-        // spot -> unified
-        const SPOT_UNIFIED_NETWORK_ID = `binance/${uid}/spot/unified`;
-        addAccountTransferAddress({
-            terminal,
-            account_id: SPOT_ACCOUNT_ID,
-            network_id: SPOT_UNIFIED_NETWORK_ID,
-            currency: 'USDT',
-            address: `unified`,
-            onApply: {
-                INIT: async (order) => {
-                    const transferResult = await client.postAssetTransfer({
-                        type: 'MAIN_PORTFOLIO_MARGIN',
-                        asset: 'USDT',
-                        amount: order.current_amount,
-                    });
-                    if (isError(transferResult)) {
-                        return { state: 'INIT', message: transferResult.msg };
-                    }
-                    return { state: 'COMPLETE', transaction_id: '' + transferResult.tranId };
-                },
-            },
-            onEval: async (order) => {
-                return { state: 'COMPLETE', received_amount: order.current_amount };
-            },
-        });
-        // unified -> spot
-        addAccountTransferAddress({
-            terminal,
-            account_id: UNIFIED_ACCOUNT_ID,
-            network_id: SPOT_UNIFIED_NETWORK_ID,
-            currency: 'USDT',
-            address: `spot`,
-            onApply: {
-                INIT: async (order) => {
-                    const transferResult = await client.postAssetTransfer({
-                        type: 'PORTFOLIO_MARGIN_MAIN',
-                        asset: 'USDT',
-                        amount: order.current_amount,
-                    });
-                    if (isError(transferResult)) {
-                        return { state: 'INIT', message: transferResult.msg };
+            }, { auto_refresh_interval: 1000 });
+            addAccountMarket(terminal, { account_id: UNIFIED_ACCOUNT_ID, market_id: 'BINANCE/UNIFIED' });
+        }
+        {
+            // spot account info
+            provideAccountInfoService(terminal, SPOT_ACCOUNT_ID, async () => {
+                const spotAccountResult = await getSpotAccountInfo(credential, { omitZeroBalances: true });
+                if (isApiError(spotAccountResult)) {
+                    throw new Error(spotAccountResult.msg);
+                }
+                const usdtAssets = spotAccountResult.balances.find((v) => v.asset === 'USDT');
+                const positions = spotAccountResult.balances
+                    .filter((balance) => balance.asset !== 'USDT')
+                    .map((balance) => {
+                    const volume = +balance.free + +balance.locked;
+                    if (!volume) {
+                        return undefined;
                     }
-                    return { state: 'COMPLETE', transaction_id: '' + transferResult.tranId };
-                },
-            },
-            onEval: async (order) => {
-                return { state: 'COMPLETE', received_amount: order.current_amount };
-            },
-        });
-        const subAccountsResult = await client.getSubAccountList();
-        const isMain = !isError(subAccountsResult);
-        // main -> sub
-        // TODO...
-        // blockchain
-        if (isMain) {
-            const depositAddressResult = await client.getDepositAddress({ coin: 'USDT', network: 'TRX' });
+                    const position = {
+                        position_id: `spot/${balance.asset}`,
+                        datasource_id: 'BINANCE',
+                        product_id: encodePath('spot', `${balance.asset}USDT`),
+                        direction: 'LONG',
+                        volume,
+                        free_volume: +balance.free,
+                        position_price: 0,
+                        closable_price: 0,
+                        floating_profit: 0,
+                        valuation: 0,
+                    };
+                    return position;
+                })
+                    .filter((position) => Boolean(position));
+                return {
+                    money: {
+                        currency: 'USDT',
+                        equity: +((usdtAssets === null || usdtAssets === void 0 ? void 0 : usdtAssets.free) || 0) + +((usdtAssets === null || usdtAssets === void 0 ? void 0 : usdtAssets.locked) || 0),
+                        free: +((usdtAssets === null || usdtAssets === void 0 ? void 0 : usdtAssets.free) || 0),
+                    },
+                    positions,
+                };
+            }, {
+                auto_refresh_interval: 5000,
+            });
+            addAccountMarket(terminal, { account_id: SPOT_ACCOUNT_ID, market_id: 'BINANCE/SPOT' });
+        }
+        // transfer
+        {
+            // spot -> unified
+            const SPOT_UNIFIED_NETWORK_ID = `binance/${uid}/spot/unified`;
             addAccountTransferAddress({
                 terminal,
                 account_id: SPOT_ACCOUNT_ID,
-                network_id: 'TRC20',
+                network_id: SPOT_UNIFIED_NETWORK_ID,
                 currency: 'USDT',
-                address: depositAddressResult.address,
+                address: `unified`,
                 onApply: {
                     INIT: async (order) => {
-                        const transferResult = await client.postWithdraw({
-                            coin: 'USDT',
-                            network: 'TRX',
-                            address: order.current_rx_address,
+                        const transferResult = await postAssetTransfer(credential, {
+                            type: 'MAIN_PORTFOLIO_MARGIN',
+                            asset: 'USDT',
                             amount: order.current_amount,
                         });
-                        if (isError(transferResult)) {
-                            return { state: 'ERROR', message: transferResult.msg };
+                        if (isApiError(transferResult)) {
+                            return { state: 'INIT', message: transferResult.msg };
                         }
-                        const wdId = transferResult.id;
-                        return { state: 'PENDING', context: wdId };
+                        return { state: 'COMPLETE', transaction_id: '' + transferResult.tranId };
                     },
-                    PENDING: async (order) => {
-                        const wdId = order.current_tx_context;
-                        const withdrawResult = await client.getWithdrawHistory({ coin: 'USDT' });
-                        const record = withdrawResult === null || withdrawResult === void 0 ? void 0 : withdrawResult.find((v) => v.id === wdId);
-                        const txId = record === null || record === void 0 ? void 0 : record.txId;
-                        if (!txId) {
-                            return { state: 'PENDING', context: wdId };
+                },
+                onEval: async (order) => {
+                    return { state: 'COMPLETE', received_amount: order.current_amount };
+                },
+            });
+            // unified -> spot
+            addAccountTransferAddress({
+                terminal,
+                account_id: UNIFIED_ACCOUNT_ID,
+                network_id: SPOT_UNIFIED_NETWORK_ID,
+                currency: 'USDT',
+                address: `spot`,
+                onApply: {
+                    INIT: async (order) => {
+                        const transferResult = await postAssetTransfer(credential, {
+                            type: 'PORTFOLIO_MARGIN_MAIN',
+                            asset: 'USDT',
+                            amount: order.current_amount,
+                        });
+                        if (isApiError(transferResult)) {
+                            return { state: 'INIT', message: transferResult.msg };
                         }
-                        return { state: 'COMPLETE', transaction_id: txId };
+                        return { state: 'COMPLETE', transaction_id: '' + transferResult.tranId };
                     },
                 },
                 onEval: async (order) => {
-                    var _a;
-                    const checkResult = await client.getDepositHistory({
-                        coin: 'USDT',
-                        txId: order.current_transaction_id,
-                    });
-                    if (((_a = checkResult === null || checkResult === void 0 ? void 0 : checkResult[0]) === null || _a === void 0 ? void 0 : _a.status) !== 1) {
-                        return { state: 'PENDING' };
-                    }
-                    const received_amount = +checkResult[0].amount;
-                    return { state: 'COMPLETE', received_amount };
+                    return { state: 'COMPLETE', received_amount: order.current_amount };
                 },
             });
+            const subAccountsResult = await getSubAccountList(credential);
+            const isMain = !isApiError(subAccountsResult);
+            // main -> sub
+            // TODO...
+            // blockchain
+            if (isMain) {
+                const depositAddressResult = await getDepositAddress(credential, { coin: 'USDT', network: 'TRX' });
+                addAccountTransferAddress({
+                    terminal,
+                    account_id: SPOT_ACCOUNT_ID,
+                    network_id: 'TRC20',
+                    currency: 'USDT',
+                    address: depositAddressResult.address,
+                    onApply: {
+                        INIT: async (order) => {
+                            const transferResult = await postWithdraw(credential, {
+                                coin: 'USDT',
+                                network: 'TRX',
+                                address: order.current_rx_address,
+                                amount: order.current_amount,
+                            });
+                            if (isApiError(transferResult)) {
+                                return { state: 'ERROR', message: transferResult.msg };
+                            }
+                            const wdId = transferResult.id;
+                            return { state: 'PENDING', context: wdId };
+                        },
+                        PENDING: async (order) => {
+                            const wdId = order.current_tx_context;
+                            const withdrawResult = await getWithdrawHistory(credential, { coin: 'USDT' });
+                            const record = withdrawResult === null || withdrawResult === void 0 ? void 0 : withdrawResult.find((v) => v.id === wdId);
+                            const txId = record === null || record === void 0 ? void 0 : record.txId;
+                            if (!txId) {
+                                return { state: 'PENDING', context: wdId };
+                            }
+                            return { state: 'COMPLETE', transaction_id: txId };
+                        },
+                    },
+                    onEval: async (order) => {
+                        var _a;
+                        const checkResult = await getDepositHistory(credential, {
+                            coin: 'USDT',
+                            txId: order.current_transaction_id,
+                        });
+                        if (((_a = checkResult === null || checkResult === void 0 ? void 0 : checkResult[0]) === null || _a === void 0 ? void 0 : _a.status) !== 1) {
+                            return { state: 'PENDING' };
+                        }
+                        const received_amount = +checkResult[0].amount;
+                        return { state: 'COMPLETE', received_amount };
+                    },
+                });
+            }
         }
-    }
-    // order related
-    {
-        providePendingOrdersService(terminal, UNIFIED_ACCOUNT_ID, async () => {
-            const openOrders = await client.getUnifiedUmOpenOrders();
-            return openOrders.map((order) => {
-                var _a;
-                const order_direction = (_a = mapBinanceSideToYuantsDirection(order.side, order.positionSide)) !== null && _a !== void 0 ? _a : 'OPEN_LONG';
-                return {
-                    order_id: `${order.orderId}`,
-                    account_id: UNIFIED_ACCOUNT_ID,
-                    product_id: encodePath('usdt-future', order.symbol),
-                    order_type: mapBinanceOrderTypeToYuants(order.type),
-                    order_direction,
-                    volume: +order.origQty,
-                    traded_volume: +order.executedQty,
-                    price: order.price === undefined ? undefined : +order.price,
-                    submit_at: order.time,
-                    updated_at: new Date(order.updateTime).toISOString(),
-                    order_status: order.status,
-                };
+        // order related
+        {
+            providePendingOrdersService(terminal, UNIFIED_ACCOUNT_ID, async () => {
+                const openOrders = await getUnifiedUmOpenOrders(credential);
+                return openOrders.map((order) => {
+                    var _a;
+                    const order_direction = (_a = mapBinanceSideToYuantsDirection(order.side, order.positionSide)) !== null && _a !== void 0 ? _a : 'OPEN_LONG';
+                    return {
+                        order_id: `${order.orderId}`,
+                        account_id: UNIFIED_ACCOUNT_ID,
+                        product_id: encodePath('usdt-future', order.symbol),
+                        order_type: mapBinanceOrderTypeToYuants(order.type),
+                        order_direction,
+                        volume: +order.origQty,
+                        traded_volume: +order.executedQty,
+                        price: order.price === undefined ? undefined : +order.price,
+                        submit_at: order.time,
+                        updated_at: new Date(order.updateTime).toISOString(),
+                        order_status: order.status,
+                    };
+                });
+            }, { auto_refresh_interval: 1000 });
+            terminal.server.provideService('SubmitOrder', {
+                required: ['account_id'],
+                properties: {
+                    account_id: { const: UNIFIED_ACCOUNT_ID },
+                },
+            }, async (msg) => {
+                console.info(formatTime(Date.now()), 'SubmitOrder', msg.req);
+                const order = msg.req;
+                const [instType, symbol] = decodePath(order.product_id);
+                if (instType === 'usdt-future') {
+                    const params = {
+                        symbol,
+                        side: mapOrderDirectionToSide(order.order_direction),
+                        positionSide: mapOrderDirectionToPosSide(order.order_direction),
+                        type: mapOrderTypeToOrdType(order.order_type),
+                        timeInForce: order.order_type === 'MAKER' ? 'GTX' : order.order_type === 'LIMIT' ? 'GTC' : undefined,
+                        quantity: order.volume,
+                        price: order.price,
+                        newClientOrderId: deriveClientOrderId(order),
+                    };
+                    console.info(formatTime(Date.now()), 'SubmitOrder', 'params', JSON.stringify(params));
+                    const orderResult = await postUmOrder(credential, params);
+                    if (isApiError(orderResult)) {
+                        return { res: { code: orderResult.code, message: orderResult.msg } };
+                    }
+                    return { res: { code: 0, message: 'OK', order_id: orderResult.orderId } };
+                }
+                return { res: { code: 400, message: `unsupported type: ${instType}` } };
             });
-        }, { auto_refresh_interval: 1000 });
-        terminal.server.provideService('SubmitOrder', {
-            required: ['account_id'],
-            properties: {
-                account_id: { const: UNIFIED_ACCOUNT_ID },
-            },
-        }, async (msg) => {
-            console.info(formatTime(Date.now()), 'SubmitOrder', msg.req);
-            const order = msg.req;
-            const [instType, symbol] = decodePath(order.product_id);
-            if (instType === 'usdt-future') {
-                const params = {
+        }
+        {
+            terminal.server.provideService('CancelOrder', {
+                required: ['account_id', 'order_id', 'product_id'],
+                properties: {
+                    account_id: { const: UNIFIED_ACCOUNT_ID },
+                },
+            }, async (msg) => {
+                const order = msg.req;
+                if (!order.order_id) {
+                    return { res: { code: 400, message: 'order_id is required' } };
+                }
+                const [instType, symbol] = decodePath(order.product_id);
+                if (instType !== 'usdt-future') {
+                    return { res: { code: 400, message: `unsupported type: ${instType}` } };
+                }
+                const cancelResult = await deleteUmOrder(credential, {
                     symbol,
-                    side: mapOrderDirectionToSide(order.order_direction),
-                    positionSide: mapOrderDirectionToPosSide(order.order_direction),
-                    type: mapOrderTypeToOrdType(order.order_type),
-                    timeInForce: order.order_type === 'MAKER' ? 'GTX' : order.order_type === 'LIMIT' ? 'GTC' : undefined,
-                    quantity: order.volume,
-                    price: order.price,
-                    newClientOrderId: deriveClientOrderId(order),
-                };
-                console.info(formatTime(Date.now()), 'SubmitOrder', 'params', JSON.stringify(params));
-                const orderResult = await client.postUmOrder(params);
-                if (isError(orderResult)) {
-                    return { res: { code: orderResult.code, message: orderResult.msg } };
+                    orderId: order.order_id,
+                });
+                if (isApiError(cancelResult)) {
+                    return { res: { code: cancelResult.code, message: cancelResult.msg } };
                 }
-                return { res: { code: 0, message: 'OK', order_id: orderResult.orderId } };
-            }
-            return { res: { code: 400, message: `unsupported type: ${instType}` } };
-        });
-    }
-    {
-        terminal.server.provideService('CancelOrder', {
-            required: ['account_id', 'order_id', 'product_id'],
-            properties: {
-                account_id: { const: UNIFIED_ACCOUNT_ID },
-            },
-        }, async (msg) => {
-            const order = msg.req;
-            if (!order.order_id) {
-                return { res: { code: 400, message: 'order_id is required' } };
-            }
-            const [instType, symbol] = decodePath(order.product_id);
-            if (instType !== 'usdt-future') {
-                return { res: { code: 400, message: `unsupported type: ${instType}` } };
-            }
-            const cancelResult = await client.deleteUmOrder({
-                symbol,
-                orderId: order.order_id,
+                return { res: { code: 0, message: 'OK' } };
             });
-            if (isError(cancelResult)) {
-                return { res: { code: cancelResult.code, message: cancelResult.msg } };
-            }
-            return { res: { code: 0, message: 'OK' } };
-        });
-    }
-})();
+        }
+    })();
+}
 //# sourceMappingURL=legacy_index.js.map