@yuants/vendor-huobi 0.11.41 → 0.13.0

package/dist/index.js

@@ -1,547 +1,51 @@
-import { addAccountMarket, provideAccountInfoService } from '@yuants/data-account';
+import { addAccountMarket } from '@yuants/data-account';
 import { Terminal } from '@yuants/protocol';
-import { addAccountTransferAddress } from '@yuants/transfer';
-import { formatTime, roundToStep } from '@yuants/utils';
-import { catchError, combineLatestWith, defer, distinct, filter, first, firstValueFrom, from, map, mergeMap, of, reduce, repeat, retry, shareReplay, tap, timeout, toArray, } from 'rxjs';
-import { client } from './api';
+import { formatTime } from '@yuants/utils';
+import { provideSpotAccountInfoService, provideSwapAccountInfoService } from './account-info';
+import { getAccount, getDefaultCredential, getSubUserList, getSwapUnifiedAccountType, getUid, postSwapSwitchAccountType, } from './api/private-api';
 import './interest_rate';
-import { spotProductService, swapProductService } from './product';
+import { provideOrderSubmitService } from './order-actions';
+import './order-actions-with-credentials';
 import './quote';
+import { setupSpotSuperMarginTransfer, setupSpotSwapTransfer, setupSubAccountTransfers, setupTrc20WithdrawalAddresses, } from './transfer';
+import { spotAccountUidCache } from './uid';
 const terminal = Terminal.fromNodeEnv();
+const credential = getDefaultCredential();
 (async () => {
-    var _a, _b, _c;
-    const swapAccountTypeRes = await client.getSwapUnifiedAccountType();
+    var _a;
+    // 账户类型切换
+    const swapAccountTypeRes = await getSwapUnifiedAccountType(credential);
     if (((_a = swapAccountTypeRes.data) === null || _a === void 0 ? void 0 : _a.account_type) === 1) {
         console.info(formatTime(Date.now()), 'SwitchingAccountType', `previous: ${swapAccountTypeRes.data.account_type}, switching to 2 (unified account)`);
-        const switchRes = await client.postSwapSwitchAccountType({ account_type: 2 });
+        const switchRes = await postSwapSwitchAccountType(credential, { account_type: 2 });
         console.info(formatTime(Date.now()), 'SwitchingAccountType', `current: ${switchRes.data.account_type}`);
     }
-    const huobiUid = (await client.getUid()).data;
+    const huobiUid = (await getUid(credential)).data;
     console.info(formatTime(Date.now()), 'UID', huobiUid);
-    const huobiAccounts = await client.getAccount();
-    const superMarginAccountUid = (_b = huobiAccounts.data.find((v) => v.type === 'super-margin')) === null || _b === void 0 ? void 0 : _b.id;
-    const spotAccountUid = (_c = huobiAccounts.data.find((v) => v.type === 'spot')) === null || _c === void 0 ? void 0 : _c.id;
+    const huobiAccounts = await getAccount(credential);
+    const spotAccountUid = (await spotAccountUidCache.query(JSON.stringify(credential)));
     console.info(formatTime(Date.now()), 'huobiAccount', JSON.stringify(huobiAccounts));
     const account_id = `huobi/${huobiUid}`;
     const SPOT_ACCOUNT_ID = `${account_id}/spot/usdt`;
     const SUPER_MARGIN_ACCOUNT_ID = `${account_id}/super-margin`;
     const SWAP_ACCOUNT_ID = `${account_id}/swap`;
-    const subUsersRes = await client.getSubUserList();
+    const subUsersRes = await getSubUserList(credential);
     const subAccounts = subUsersRes.data;
     const isMainAccount = subUsersRes.ok;
     console.info(formatTime(Date.now()), 'subAccounts', JSON.stringify(subAccounts));
-    provideAccountInfoService(terminal, SWAP_ACCOUNT_ID, async () => {
-        // balance
-        const balance = await client.getUnifiedAccountInfo();
-        if (!balance.data) {
-            throw new Error('Failed to get unified account info');
-        }
-        const balanceData = balance.data.find((v) => v.margin_asset === 'USDT');
-        if (!balanceData) {
-            throw new Error('No USDT balance found in unified account');
-        }
-        const equity = balanceData.margin_balance;
-        const free = balanceData.withdraw_available;
-        // positions
-        const positionsRes = await client.getSwapCrossPositionInfo();
-        const mapProductIdToPerpetualProduct = await firstValueFrom(swapProductService.mapProductIdToProduct$);
-        const positions = (positionsRes.data || []).map((v) => {
-            const product_id = v.contract_code;
-            const theProduct = mapProductIdToPerpetualProduct === null || mapProductIdToPerpetualProduct === void 0 ? void 0 : mapProductIdToPerpetualProduct.get(product_id);
-            const valuation = v.volume * v.last_price * ((theProduct === null || theProduct === void 0 ? void 0 : theProduct.value_scale) || 1);
-            return {
-                position_id: `${v.contract_code}/${v.contract_type}/${v.direction}/${v.margin_mode}`,
-                datasource_id: 'HUOBI-SWAP',
-                product_id,
-                direction: v.direction === 'buy' ? 'LONG' : 'SHORT',
-                volume: v.volume,
-                free_volume: v.available,
-                position_price: v.cost_hold,
-                closable_price: v.last_price,
-                floating_profit: v.profit_unreal,
-                valuation,
-            };
-        });
-        // orders
-        // const orders: IOrder[] = [];
-        // let page_index = 1;
-        // const page_size = 50;
-        // while (true) {
-        //   const ordersRes = await client.getSwapOpenOrders({ page_index, page_size });
-        //   if (!ordersRes.data?.orders || ordersRes.data.orders.length === 0) {
-        //     break;
-        //   }
-        //   const pageOrders: IOrder[] = ordersRes.data.orders.map((v): IOrder => {
-        //     return {
-        //       order_id: v.order_id_str,
-        //       account_id: SWAP_ACCOUNT_ID,
-        //       product_id: v.contract_code,
-        //       order_type: ['lightning'].includes(v.order_price_type)
-        //         ? 'MARKET'
-        //         : ['limit', 'opponent', 'post_only', 'optimal_5', 'optimal_10', 'optimal_20'].includes(
-        //             v.order_price_type,
-        //           )
-        //         ? 'LIMIT'
-        //         : ['fok'].includes(v.order_price_type)
-        //         ? 'FOK'
-        //         : v.order_price_type.includes('ioc')
-        //         ? 'IOC'
-        //         : 'STOP', // unreachable code
-        //       order_direction:
-        //         v.direction === 'open'
-        //           ? v.offset === 'buy'
-        //             ? 'OPEN_LONG'
-        //             : 'OPEN_SHORT'
-        //           : v.offset === 'buy'
-        //           ? 'CLOSE_SHORT'
-        //           : 'CLOSE_LONG',
-        //       volume: v.volume,
-        //       submit_at: v.created_at,
-        //       price: v.price,
-        //       traded_volume: v.trade_volume,
-        //     };
-        //   });
-        //   orders.push(...pageOrders);
-        //   page_index++;
-        // }
-        return {
-            money: {
-                currency: 'USDT',
-                equity,
-                free,
-            },
-            positions,
-        };
-    }, { auto_refresh_interval: 1000 });
-    const superMarginUnifiedRawAccountBalance$ = defer(() => client.getSpotAccountBalance(superMarginAccountUid)).pipe(
-    //
-    map((res) => res.data), repeat({ delay: 1000 }), tap({
-        error: (e) => {
-            console.error(formatTime(Date.now()), 'unifiedRaw', e);
-        },
-    }), retry({ delay: 5000 }), shareReplay(1));
-    const subscriptions = new Set();
-    from(client.spot_ws.connection$).subscribe(() => {
-        subscriptions.clear();
-    });
-    // subscribe the symbols of positions we held
-    superMarginUnifiedRawAccountBalance$
-        .pipe(
-    //
-    mergeMap((res) => from((res === null || res === void 0 ? void 0 : res.list) || []).pipe(filter((v) => v.currency !== 'usdt'), map((v) => v.currency), distinct(), toArray(), map((v) => new Set(v)))))
-        .subscribe((v) => {
-        const toUnsubscribe = [...subscriptions].filter((x) => !v.has(x));
-        const toSubscribe = [...v].filter((x) => !subscriptions.has(x));
-        for (const symbol of toUnsubscribe) {
-            client.spot_ws.output$.next({
-                unsub: `market.${symbol}usdt.ticker`,
-            });
-            subscriptions.delete(symbol);
-        }
-        for (const symbol of toSubscribe) {
-            client.spot_ws.output$.next({
-                sub: `market.${symbol}usdt.ticker`,
-            });
-            subscriptions.add(symbol);
-        }
-    });
-    provideAccountInfoService(terminal, SUPER_MARGIN_ACCOUNT_ID, async () => {
-        var _a;
-        // get account balance
-        const accountBalance = await client.getSpotAccountBalance(superMarginAccountUid);
-        const balanceList = ((_a = accountBalance.data) === null || _a === void 0 ? void 0 : _a.list) || [];
-        // calculate usdt balance
-        const usdtBalance = balanceList
-            .filter((v) => v.currency === 'usdt')
-            .reduce((acc, cur) => acc + +cur.balance, 0);
-        // get positions (non-usdt currencies)
-        const positions = [];
-        const nonUsdtCurrencies = balanceList
-            .filter((v) => v.currency !== 'usdt')
-            .reduce((acc, cur) => {
-            const existing = acc.find((item) => item.currency === cur.currency);
-            if (existing) {
-                existing.balance += +cur.balance;
-            }
-            else {
-                acc.push({ currency: cur.currency, balance: +cur.balance });
-            }
-            return acc;
-        }, []);
-        // get prices and create positions
-        for (const currencyData of nonUsdtCurrencies) {
-            if (currencyData.balance > 0) {
-                try {
-                    // get current price from websocket or fallback to REST API
-                    let price;
-                    try {
-                        const tickPrice = await firstValueFrom(client.spot_ws.input$.pipe(
-                        //
-                        first((v) => { var _a, _b; return ((_a = v.ch) === null || _a === void 0 ? void 0 : _a.includes('ticker')) && ((_b = v.ch) === null || _b === void 0 ? void 0 : _b.includes(currencyData.currency)) && v.tick; }), map((v) => v.tick.bid), timeout(5000), tap({
-                            error: (e) => {
-                                subscriptions.clear();
-                            },
-                        })));
-                        price = tickPrice;
-                    }
-                    catch (_b) {
-                        // fallback to REST API
-                        const tickerRes = await client.getSpotTick({ symbol: `${currencyData.currency}usdt` });
-                        price = tickerRes.tick.close;
-                    }
-                    positions.push({
-                        position_id: `${currencyData.currency}/usdt/spot`,
-                        product_id: `${currencyData.currency}usdt`,
-                        direction: 'LONG',
-                        volume: currencyData.balance,
-                        free_volume: currencyData.balance,
-                        position_price: price,
-                        closable_price: price,
-                        floating_profit: 0,
-                        valuation: currencyData.balance * price,
-                    });
-                }
-                catch (error) {
-                    console.warn(formatTime(Date.now()), `Failed to get price for ${currencyData.currency}:`, error);
-                }
-            }
-        }
-        // calculate equity
-        const equity = positions.reduce((acc, cur) => acc + cur.closable_price * cur.volume, 0) + usdtBalance;
-        return {
-            money: {
-                currency: 'USDT',
-                equity,
-                free: equity,
-            },
-            positions,
-        };
-    }, { auto_refresh_interval: 1000 });
-    provideAccountInfoService(terminal, SPOT_ACCOUNT_ID, async () => {
-        var _a, _b;
-        const spotBalance = await client.getSpotAccountBalance(spotAccountUid);
-        const equity = +((_b = (_a = spotBalance.data.list.find((v) => v.currency === 'usdt')) === null || _a === void 0 ? void 0 : _a.balance) !== null && _b !== void 0 ? _b : 0);
-        const free = equity;
-        return {
-            money: {
-                currency: 'USDT',
-                equity,
-                free,
-            },
-            positions: [],
-        };
-    }, { auto_refresh_interval: 1000 });
+    // 设置账户信息服务
+    provideSwapAccountInfoService(terminal, SWAP_ACCOUNT_ID, credential);
+    provideSpotAccountInfoService(terminal, SPOT_ACCOUNT_ID, credential, spotAccountUid);
+    // 设置账户市场关联
     addAccountMarket(terminal, { account_id: SPOT_ACCOUNT_ID, market_id: 'HUOBI/SPOT' });
     addAccountMarket(terminal, { account_id: SUPER_MARGIN_ACCOUNT_ID, market_id: 'HUOBI/SUPER-MARGIN' });
     addAccountMarket(terminal, { account_id: SWAP_ACCOUNT_ID, market_id: 'HUOBI/SWAP' });
-    // Submit order
-    terminal.server.provideService('SubmitOrder', {
-        required: ['account_id'],
-        properties: {
-            account_id: {
-                enum: [SUPER_MARGIN_ACCOUNT_ID, SWAP_ACCOUNT_ID],
-            },
-        },
-    }, (msg) => {
-        const { account_id: req_account_id } = msg.req;
-        console.info(formatTime(Date.now()), `SubmitOrder for ${account_id}`, JSON.stringify(msg));
-        if (req_account_id === SWAP_ACCOUNT_ID) {
-            return defer(() => client.getSwapCrossPositionInfo()).pipe(mergeMap((res) => res.data), map((v) => [v.contract_code, v.lever_rate]), toArray(), map((v) => Object.fromEntries(v)), mergeMap((mapContractCodeToRate) => {
-                var _a;
-                const lever_rate = (_a = mapContractCodeToRate[msg.req.product_id]) !== null && _a !== void 0 ? _a : 20;
-                const params = {
-                    contract_code: msg.req.product_id,
-                    contract_type: 'swap',
-                    price: msg.req.price,
-                    volume: msg.req.volume,
-                    offset: msg.req.order_direction === 'OPEN_LONG' || msg.req.order_direction === 'OPEN_SHORT'
-                        ? 'open'
-                        : 'close',
-                    direction: msg.req.order_direction === 'OPEN_LONG' || msg.req.order_direction === 'CLOSE_SHORT'
-                        ? 'buy'
-                        : 'sell',
-                    // dynamically adjust the leverage
-                    lever_rate,
-                    order_price_type: msg.req.order_type === 'MARKET' ? 'market' : 'limit',
-                };
-                return client.postSwapOrder(params).then((v) => {
-                    console.info(formatTime(Date.now()), 'SubmitOrder', JSON.stringify(v), JSON.stringify(params));
-                    return v;
-                });
-            }), map((v) => {
-                if (v.status !== 'ok') {
-                    return { res: { code: 500, message: v.status } };
-                }
-                return { res: { code: 0, message: 'OK' } };
-            }), catchError((e) => {
-                console.error(formatTime(Date.now()), 'SubmitOrder', e);
-                return of({ res: { code: 500, message: `${e}` } });
-            }));
-        }
-        // for super-margin orders, we need to denote the amount of usdt to borrow, therefore we need to:
-        // 1. get the loanable amount
-        // 2. get the current balance
-        // 3. get the current price
-        // 4. combine the information to submit the order
-        return defer(() => client.getCrossMarginLoanInfo()).pipe(
-        //
-        mergeMap((res) => res.data), first((v) => v.currency === 'usdt'), map((v) => +v['loanable-amt']), combineLatestWith(superMarginUnifiedRawAccountBalance$.pipe(first(), mergeMap((res) => from(res.list).pipe(
-        // we only need the amount of usdt that can be used to trade
-        filter((v) => v.currency === 'usdt' && v.type === 'trade'), reduce((acc, cur) => acc + +cur.balance, 0))))), combineLatestWith(spotProductService.mapProductIdToProduct$.pipe(first())), mergeMap(async ([[loanable, balance], mapProductIdToProduct]) => {
-            const priceRes = await client.getSpotTick({ symbol: msg.req.product_id });
-            const theProduct = mapProductIdToProduct.get(msg.req.product_id);
-            const price = priceRes.tick.close;
-            const borrow_amount = msg.req.order_direction === 'OPEN_LONG' || msg.req.order_direction === 'CLOSE_SHORT'
-                ? Math.max(Math.min(loanable, msg.req.volume * price - balance), 0)
-                : undefined;
-            const params = {
-                symbol: msg.req.product_id,
-                'account-id': '' + superMarginAccountUid,
-                // amount: msg.req.type === OrderType.MARKET ? 0 : '' + msg.req.volume,
-                // 'market-amount': msg.req.type === OrderType.MARKET ? '' + msg.req.volume : undefined,
-                amount: '' +
-                    (msg.req.order_direction === 'OPEN_LONG' || msg.req.order_direction === 'CLOSE_SHORT'
-                        ? roundToStep(msg.req.volume * price, theProduct === null || theProduct === void 0 ? void 0 : theProduct.volume_step)
-                        : msg.req.volume),
-                'borrow-amount': '' + borrow_amount,
-                type: `${msg.req.order_direction === 'OPEN_LONG' || msg.req.order_direction === 'CLOSE_SHORT'
-                    ? 'buy'
-                    : 'sell'}-${'LIMIT' === msg.req.order_type ? 'limit' : 'market'}`,
-                'trade-purpose': msg.req.order_direction === 'OPEN_LONG' || msg.req.order_direction === 'CLOSE_SHORT'
-                    ? '1' // auto borrow
-                    : '2',
-                price: msg.req.order_type === 'MARKET' ? undefined : '' + msg.req.price,
-                source: 'super-margin-api',
-            };
-            return client.postSpotOrder(params).then((v) => {
-                console.info(formatTime(Date.now()), 'SubmitOrder', JSON.stringify(v), JSON.stringify(params));
-                return v;
-            });
-        }), map((v) => {
-            if (v.success === false) {
-                return { res: { code: v.code, message: v.message } };
-            }
-            return { res: { code: 0, message: 'OK' } };
-        }), catchError((e) => {
-            console.error(formatTime(Date.now()), 'SubmitOrder', e);
-            return of({ res: { code: 500, message: `${e}` } });
-        }));
-    });
-    // Update Spot TRC20 Addresses (Only Main Account)
-    if (isMainAccount) {
-        const res = await client.getSpotAccountDepositAddresses({ currency: 'usdt' });
-        const addresses = res.data.filter((v) => v.chain === 'trc20usdt').map((v) => v.address);
-        for (const address of addresses) {
-            addAccountTransferAddress({
-                terminal,
-                account_id: SPOT_ACCOUNT_ID,
-                currency: 'USDT',
-                address: address,
-                network_id: 'TRC20',
-                onApply: {
-                    INIT: async (order) => {
-                        var _a, _b;
-                        const res0 = await client.getV2ReferenceCurrencies({ currency: 'usdt' });
-                        const fee = (_b = (_a = res0.data
-                            .find((v) => v.currency === 'usdt')) === null || _a === void 0 ? void 0 : _a.chains.find((v) => v.chain === 'trc20usdt')) === null || _b === void 0 ? void 0 : _b.transactFeeWithdraw;
-                        if (!fee) {
-                            return { state: 'ERROR', message: 'MISSING FEE' };
-                        }
-                        const res = await client.postWithdraw({
-                            address: order.current_rx_address,
-                            amount: '' + (order.expected_amount - +fee),
-                            currency: 'usdt',
-                            fee: fee,
-                            chain: 'trc20usdt',
-                        });
-                        if (res.status != 'ok') {
-                            return { state: 'INIT', message: `${res.status}` };
-                        }
-                        return { state: 'PENDING', context: `${res.data}` };
-                    },
-                    PENDING: async (order) => {
-                        var _a;
-                        if (!order.current_tx_context) {
-                            return { state: 'ERROR', message: 'MISSING CONTEXT' };
-                        }
-                        const wdId = +order.current_tx_context;
-                        const res = await client.getDepositWithdrawHistory({
-                            currency: 'usdt',
-                            type: 'withdraw',
-                            from: `${wdId}`,
-                        });
-                        const txId = (_a = res.data.find((v) => v.id === wdId)) === null || _a === void 0 ? void 0 : _a['tx-hash'];
-                        if (!txId) {
-                            return { state: 'PENDING', context: `${wdId}` };
-                        }
-                        return {
-                            state: 'COMPLETE',
-                            transaction_id: txId,
-                        };
-                    },
-                },
-                onEval: async (order) => {
-                    const res = await client.getDepositWithdrawHistory({
-                        currency: 'usdt',
-                        type: 'deposit',
-                        direct: 'next',
-                    });
-                    const theItem = res.data.find((v) => v['tx-hash'] === order.current_transaction_id && v.state === 'safe');
-                    if (!theItem) {
-                        return { state: 'PENDING' };
-                    }
-                    return { received_amount: +theItem.amount, state: 'COMPLETE' };
-                },
-            });
-        }
-    }
-    addAccountTransferAddress({
-        terminal,
-        account_id: SPOT_ACCOUNT_ID,
-        currency: 'USDT',
-        network_id: `Huobi/${huobiUid}/SPOT-SUPER_MARGIN`,
-        address: 'SPOT',
-        onApply: {
-            INIT: async (order) => {
-                const transferInResult = await client.postSuperMarginAccountTransferIn({
-                    currency: 'usdt',
-                    amount: '' + (order.current_amount || order.expected_amount),
-                });
-                if (transferInResult.status !== 'ok') {
-                    return { state: 'INIT' };
-                }
-                return { state: 'COMPLETE' };
-            },
-        },
-        onEval: async (order) => {
-            return { received_amount: order.current_amount || order.expected_amount, state: 'COMPLETE' };
-        },
-    });
-    addAccountTransferAddress({
-        terminal,
-        account_id: SUPER_MARGIN_ACCOUNT_ID,
-        currency: 'USDT',
-        network_id: `Huobi/${huobiUid}/SPOT-SUPER_MARGIN`,
-        address: 'SUPER_MARGIN',
-        onApply: {
-            INIT: async (order) => {
-                const transferOutResult = await client.postSuperMarginAccountTransferOut({
-                    currency: 'usdt',
-                    amount: '' + (order.current_amount || order.expected_amount),
-                });
-                if (transferOutResult.status !== 'ok') {
-                    return { state: 'INIT' };
-                }
-                return { state: 'COMPLETE' };
-            },
-        },
-        onEval: async (order) => {
-            return { received_amount: order.current_amount || order.expected_amount, state: 'COMPLETE' };
-        },
-    });
-    addAccountTransferAddress({
-        terminal,
-        account_id: SPOT_ACCOUNT_ID,
-        currency: 'USDT',
-        network_id: `Huobi/${huobiUid}/SPOT-SWAP`,
-        address: 'SPOT',
-        onApply: {
-            INIT: async (order) => {
-                const transferResult = await client.postSpotAccountTransfer({
-                    from: 'spot',
-                    to: 'linear-swap',
-                    currency: 'usdt',
-                    amount: order.current_amount || order.expected_amount,
-                    'margin-account': 'USDT',
-                });
-                if (!transferResult.success) {
-                    return { state: 'INIT' };
-                }
-                return { state: 'COMPLETE' };
-            },
-        },
-        onEval: async (order) => {
-            return { received_amount: order.current_amount || order.expected_amount, state: 'COMPLETE' };
-        },
-    });
-    addAccountTransferAddress({
-        terminal,
-        account_id: SWAP_ACCOUNT_ID,
-        currency: 'USDT',
-        network_id: `Huobi/${huobiUid}/SPOT-SWAP`,
-        address: 'SWAP',
-        onApply: {
-            INIT: async (order) => {
-                const transferResult = await client.postSpotAccountTransfer({
-                    from: 'linear-swap',
-                    to: 'spot',
-                    currency: 'usdt',
-                    amount: order.current_amount || order.expected_amount,
-                    'margin-account': 'USDT',
-                });
-                if (!transferResult.success) {
-                    return { state: 'INIT' };
-                }
-                return { state: 'COMPLETE' };
-            },
-        },
-        onEval: async (order) => {
-            return { received_amount: order.current_amount || order.expected_amount, state: 'COMPLETE' };
-        },
-    });
-    if (isMainAccount) {
-        for (const subAccount of subAccounts) {
-            const SPOT_SUB_ACCOUNT_ID = `huobi/${subAccount.uid}/spot/usdt`;
-            const SUB_ACCOUNT_NETWORK_ID = `Huobi/${huobiUid}/SubAccount/${subAccount.uid}`;
-            addAccountTransferAddress({
-                terminal,
-                account_id: SPOT_ACCOUNT_ID,
-                currency: 'USDT',
-                network_id: SUB_ACCOUNT_NETWORK_ID,
-                address: '#main',
-                onApply: {
-                    INIT: async (order) => {
-                        const transferResult = await client.postSubUserTransfer({
-                            'sub-uid': +order.current_rx_address,
-                            currency: 'usdt',
-                            amount: order.current_amount || order.expected_amount,
-                            type: 'master-transfer-out',
-                        });
-                        if (transferResult.status !== 'ok') {
-                            return { state: 'INIT' };
-                        }
-                        return { state: 'COMPLETE' };
-                    },
-                },
-                onEval: async (order) => {
-                    return { received_amount: order.current_amount || order.expected_amount, state: 'COMPLETE' };
-                },
-            });
-            addAccountTransferAddress({
-                terminal,
-                account_id: SPOT_SUB_ACCOUNT_ID,
-                currency: 'USDT',
-                network_id: SUB_ACCOUNT_NETWORK_ID,
-                address: `${subAccount.uid}`,
-                onApply: {
-                    INIT: async (order) => {
-                        const transferResult = await client.postSubUserTransfer({
-                            'sub-uid': +order.current_tx_address,
-                            currency: 'usdt',
-                            amount: order.current_amount || order.expected_amount,
-                            type: 'master-transfer-in',
-                        });
-                        if (transferResult.status !== 'ok') {
-                            return { state: 'INIT' };
-                        }
-                        return { state: 'COMPLETE' };
-                    },
-                },
-                onEval: async (order) => {
-                    return { received_amount: order.current_amount || order.expected_amount, state: 'COMPLETE' };
-                },
-            });
-        }
-    }
+    // 设置订单提交服务
+    provideOrderSubmitService(terminal, SWAP_ACCOUNT_ID, SUPER_MARGIN_ACCOUNT_ID, credential);
+    // 设置转账功能
+    await setupTrc20WithdrawalAddresses(terminal, SPOT_ACCOUNT_ID, credential, isMainAccount);
+    setupSpotSuperMarginTransfer(terminal, SPOT_ACCOUNT_ID, SUPER_MARGIN_ACCOUNT_ID, credential, huobiUid);
+    setupSpotSwapTransfer(terminal, SPOT_ACCOUNT_ID, SWAP_ACCOUNT_ID, credential, huobiUid);
+    setupSubAccountTransfers(terminal, SPOT_ACCOUNT_ID, credential, huobiUid, subAccounts, isMainAccount);
 })();
 //# sourceMappingURL=index.js.map