@yuants/vendor-binance 0.8.7 → 0.10.0

package/dist/legacy_index.js

@@ -1,401 +1,164 @@
-import { addAccountMarket, provideAccountInfoService } from '@yuants/data-account';
-import { providePendingOrdersService } from '@yuants/data-order';
-import { Terminal } from '@yuants/protocol';
-import { addAccountTransferAddress } from '@yuants/transfer';
-import { decodePath, encodePath, formatTime } from '@yuants/utils';
-import { createHash } from 'crypto';
-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) => {
-    const expired_at = Date.now() - 600000; // 10min expired
-    const cache = _mapSymbolToOpenInterest[symbol];
-    if (cache) {
-        if (cache.updated_at > expired_at) {
-            return cache.value;
-        }
-    }
-    const data = await getFutureOpenInterest({ symbol });
-    const value = +data.openInterest || 0;
-    _mapSymbolToOpenInterest[symbol] = { value, updated_at: Date.now() };
-    return value;
-};
-const mapOrderDirectionToSide = (direction) => {
-    switch (direction) {
-        case 'OPEN_LONG':
-        case 'CLOSE_SHORT':
-            return 'BUY';
-        case 'OPEN_SHORT':
-        case 'CLOSE_LONG':
-            return 'SELL';
-    }
-    throw new Error(`Unknown direction: ${direction}`);
-};
-const mapOrderDirectionToPosSide = (direction) => {
-    switch (direction) {
-        case 'OPEN_LONG':
-        case 'CLOSE_LONG':
-            return 'LONG';
-        case 'OPEN_SHORT':
-        case 'CLOSE_SHORT':
-            return 'SHORT';
-    }
-    throw new Error(`Unknown direction: ${direction}`);
-};
-const mapOrderTypeToOrdType = (order_type) => {
-    switch (order_type) {
-        case 'LIMIT':
-        case 'MAKER':
-            return 'LIMIT';
-        case 'MARKET':
-            return 'MARKET';
-    }
-    throw new Error(`Unknown order type: ${order_type}`);
-};
-const mapBinanceOrderTypeToYuants = (binanceType) => {
-    switch (binanceType) {
-        case 'LIMIT':
-            return 'LIMIT';
-        case 'MARKET':
-            return 'MARKET';
-        default:
-            return 'LIMIT';
-    }
-};
-const mapBinanceSideToYuantsDirection = (side, positionSide) => {
-    if (!side || !positionSide) {
-        return undefined;
-    }
-    if (positionSide === 'LONG') {
-        return side === 'BUY' ? 'OPEN_LONG' : 'CLOSE_LONG';
-    }
-    if (positionSide === 'SHORT') {
-        return side === 'SELL' ? 'OPEN_SHORT' : 'CLOSE_SHORT';
-    }
-    return undefined;
-};
-const deriveClientOrderId = (order) => {
-    if (order.order_id)
-        return `${order.order_id}`;
-    if (order.comment)
-        return order.comment;
-    const payload = JSON.stringify({
-        account_id: order.account_id,
-        product_id: order.product_id,
-        order_direction: order.order_direction,
-        order_type: order.order_type,
-        price: order.price,
-        volume: order.volume,
-    });
-    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') {
-//     return combineLatest([mapSymbolToFuturePremiumIndex$, mapSymbolToFutureBookTicker$]).pipe(
-//       combineLatestWith(defer(() => getOpenInterest(symbol))),
-//       map(([[mapSymbolToFuturePremiumIndex, mapSymbolToFutureBookTicker], openInterestVolume]): ITick => {
-//         const premiumIndex = mapSymbolToFuturePremiumIndex.get(symbol);
-//         const bookTicker = mapSymbolToFutureBookTicker.get(symbol);
-//         if (!premiumIndex) {
-//           throw new Error(`Premium Index Not Found: ${symbol}`);
-//         }
-//         if (!bookTicker) {
-//           throw new Error(`Book Ticker Not Found: ${symbol}`);
-//         }
-//         return {
-//           datasource_id: 'binance',
-//           product_id,
-//           updated_at: Date.now(),
-//           price: +premiumIndex.markPrice,
-//           ask: +bookTicker.askPrice,
-//           bid: +bookTicker.bidPrice,
-//           interest_rate_for_long: -+premiumIndex.lastFundingRate,
-//           interest_rate_for_short: +premiumIndex.lastFundingRate,
-//           settlement_scheduled_at: premiumIndex.nextFundingTime,
-//           open_interest: openInterestVolume,
-//         };
-//       }),
-//     );
-//   }
-//   return EMPTY;
-// });
-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 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 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;
-                    }
-                    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 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: SPOT_UNIFIED_NETWORK_ID,
-                currency: 'USDT',
-                address: `unified`,
-                onApply: {
-                    INIT: async (order) => {
-                        const transferResult = await postAssetTransfer(credential, {
-                            type: 'MAIN_PORTFOLIO_MARGIN',
-                            asset: 'USDT',
-                            amount: order.current_amount,
-                        });
-                        if (isApiError(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 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: '' + transferResult.tranId };
-                    },
-                },
-                onEval: async (order) => {
-                    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 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}` } };
-            });
-        }
-        {
-            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,
-                    orderId: order.order_id,
-                });
-                if (isApiError(cancelResult)) {
-                    return { res: { code: cancelResult.code, message: cancelResult.msg } };
-                }
-                return { res: { code: 0, message: 'OK' } };
-            });
-        }
-    })();
-}
+"use strict";
+// import { Terminal } from '@yuants/protocol';
+// import { addAccountTransferAddress } from '@yuants/transfer';
+// import { getDefaultCredential, isApiError } from './api/client';
+// import {
+//   getDepositAddress,
+//   getDepositHistory,
+//   getSpotAccountInfo,
+//   getSubAccountList,
+//   getWithdrawHistory,
+//   postAssetTransfer,
+//   postWithdraw,
+// } from './api/private-api';
+// const terminal = Terminal.fromNodeEnv();
+// const isPublicOnly = process.env.PUBLIC_ONLY === 'true';
+// // provideTicks(terminal, 'binance', (product_id) => {
+// //   const [instType, symbol] = decodePath(product_id);
+// //   if (instType === 'usdt-future') {
+// //     return combineLatest([mapSymbolToFuturePremiumIndex$, mapSymbolToFutureBookTicker$]).pipe(
+// //       combineLatestWith(defer(() => getOpenInterest(symbol))),
+// //       map(([[mapSymbolToFuturePremiumIndex, mapSymbolToFutureBookTicker], openInterestVolume]): ITick => {
+// //         const premiumIndex = mapSymbolToFuturePremiumIndex.get(symbol);
+// //         const bookTicker = mapSymbolToFutureBookTicker.get(symbol);
+// //         if (!premiumIndex) {
+// //           throw new Error(`Premium Index Not Found: ${symbol}`);
+// //         }
+// //         if (!bookTicker) {
+// //           throw new Error(`Book Ticker Not Found: ${symbol}`);
+// //         }
+// //         return {
+// //           datasource_id: 'binance',
+// //           product_id,
+// //           updated_at: Date.now(),
+// //           price: +premiumIndex.markPrice,
+// //           ask: +bookTicker.askPrice,
+// //           bid: +bookTicker.bidPrice,
+// //           interest_rate_for_long: -+premiumIndex.lastFundingRate,
+// //           interest_rate_for_short: +premiumIndex.lastFundingRate,
+// //           settlement_scheduled_at: premiumIndex.nextFundingTime,
+// //           open_interest: openInterestVolume,
+// //         };
+// //       }),
+// //     );
+// //   }
+// //   return EMPTY;
+// // });
+// 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`;
+//     // 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 postAssetTransfer(credential, {
+//               type: 'MAIN_PORTFOLIO_MARGIN',
+//               asset: 'USDT',
+//               amount: order.current_amount!,
+//             });
+//             if (isApiError(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 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: '' + transferResult.tranId };
+//           },
+//         },
+//         onEval: async (order) => {
+//           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?.find((v) => v.id === wdId);
+//               const txId = record?.txId;
+//               if (!txId) {
+//                 return { state: 'PENDING', context: wdId };
+//               }
+//               return { state: 'COMPLETE', transaction_id: txId };
+//             },
+//           },
+//           onEval: async (order) => {
+//             const checkResult = await getDepositHistory(credential, {
+//               coin: 'USDT',
+//               txId: order.current_transaction_id,
+//             });
+//             if (checkResult?.[0]?.status !== 1) {
+//               return { state: 'PENDING' };
+//             }
+//             const received_amount = +checkResult[0].amount;
+//             return { state: 'COMPLETE', received_amount };
+//           },
+//         });
+//       }
+//     }
+//   })();
+// }
 //# sourceMappingURL=legacy_index.js.map