@gbozee/ultimate 0.0.2-27 → 0.0.2-29

package/dist/index.d.ts

@@ -151,6 +151,18 @@ export interface BaseExchange {
 	}): Promise<any>;
 	getDelistedSpotSymbols(): Promise<any>;
 	getOpenPositions(): Promise<any>;
+	crossAccountTransfer(payload: {
+		from: {
+			owner: string;
+			wallet: string;
+		};
+		to: {
+			owner: string;
+			wallet: string;
+		};
+		asset: string;
+		amount: number;
+	}): Promise<any>;
 }
 export interface BaseSystemFields {
 	id: string;
@@ -604,6 +616,7 @@ declare class ExchangeAccount$1 {
 		place?: boolean;
 		update_db?: boolean;
 		raw?: boolean;
+		use_current?: boolean;
 	}): Promise<any>;
 	getPositionConfig(payload: {
 		symbol: string;
@@ -720,6 +733,7 @@ declare class ExchangeAccount$1 {
 		place?: boolean;
 		raw?: boolean;
 		tp?: boolean;
+		stop?: boolean;
 	}): Promise<any>;
 	verifyStopLoss(payload: {
 		symbol: string;
@@ -795,6 +809,7 @@ declare class ExchangeAccount$1 {
 		kind: "long" | "short";
 		place?: boolean;
 		tp?: boolean;
+		stop?: boolean;
 		raw?: boolean;
 		cancel?: boolean;
 	}): Promise<any>;
@@ -804,14 +819,17 @@ declare class App {
 	proxyOptions?: {
 		proxy?: any;
 		ignore_proxy?: boolean;
+		canWithdraw?: boolean;
 	};
 	private getCredentials;
 	constructor(app_db: AppDatabase, getCredentials: (account: string, exchange: string) => {
 		api_key: string;
 		api_secret: string;
+		email: string;
 	}, proxyOptions?: {
 		proxy?: any;
 		ignore_proxy?: boolean;
+		canWithdraw?: boolean;
 	});
 	getExchangeAccount(account: ExchangeType): Promise<ExchangeAccount$1>;
 	syncAccount(payload: {
@@ -927,14 +945,17 @@ export declare function initApp(payload: {
 	getCredentials: (account: string, exchange: string) => {
 		api_key: string;
 		api_secret: string;
+		email: string;
 	};
 	proxy?: any;
 	ignore_proxy?: boolean;
+	canWithdraw?: boolean;
 }): Promise<App>;
 export declare function initialize(payload: {
 	password?: string;
 	proxy?: any;
 	ignore_proxy?: boolean;
+	canWithdraw?: boolean;
 }): Promise<App>;
 
 export {

package/dist/index.js

@@ -33796,6 +33796,193 @@ function createGapPairs(arr, gap, item) {
 }
 
 // src/exchanges/binance.ts
+var CONSTANTS = {
+  SPOT_TO_FIAT: "MAIN_C2C",
+  SPOT_TO_USDT_FUTURE: "MAIN_UMFUTURE",
+  SPOT_TO_COIN_FUTURE: "MAIN_CMFUTURE",
+  SPOT_TO_MARGIN_CROSS: "MAIN_MARGIN",
+  SPOT_TO_MINING: "MAIN_MINING",
+  FIAT_TO_SPOT: "C2C_MAIN",
+  FIAT_TO_USDT_FUTURE: "C2C_UMFUTURE",
+  FIAT_TO_MINING: "C2C_MINING",
+  USDT_FUTURE_TO_SPOT: "UMFUTURE_MAIN",
+  USDT_FUTURE_TO_FIAT: "UMFUTURE_C2C",
+  USDT_FUTURE_TO_MARGIN_CROSS: "UMFUTURE_MARGIN",
+  COIN_FUTURE_TO_SPOT: "CMFUTURE_MAIN",
+  MARGIN_CROSS_TO_SPOT: "MARGIN_MAIN",
+  MARGIN_CROSS_TO_USDT_FUTURE: "MARGIN_UMFUTURE",
+  MINING_TO_SPOT: "MINING_MAIN",
+  MINING_TO_USDT_FUTURE: "MINING_UMFUTURE",
+  MINING_TO_FIAT: "MINING_C2C"
+};
+
+class AccountService {
+  getCredentials;
+  proxyAgent;
+  constructor(payload) {
+    this.getCredentials = payload.getCredentials;
+    this.proxyAgent = payload.proxyAgent;
+  }
+  async getAccount(owner) {
+    const credentials = this.getCredentials(owner, "binance");
+    const email = credentials.email;
+    const is_sub_account = owner !== "main_account";
+    return {
+      email,
+      owner,
+      is_sub_account: Boolean(is_sub_account),
+      getFutureAccountClient: (...args) => initClient(credentials, {
+        type: "main",
+        proxyAgent: this.proxyAgent
+      })
+    };
+  }
+  async crossAccountTransfer(symbol, params) {
+    const { to, from, asset, amount } = params;
+    if (to && from && asset && amount) {
+      const toAccount = await this.getAccount(to.owner);
+      const fromAccount = await this.getAccount(from.owner);
+      const mainAccount = await this.getAccount("main_account");
+      const [mainFutureClient, toFutureClient] = await Promise.all([
+        mainAccount.getFutureAccountClient(symbol),
+        toAccount.getFutureAccountClient(symbol)
+      ]);
+      const [fromSpotClient, fromFutureClient] = await Promise.all([
+        fromAccount.getFutureAccountClient(symbol),
+        fromAccount.getFutureAccountClient(symbol)
+      ]);
+      const isSubAccountTransfer = toAccount.is_sub_account && fromAccount.is_sub_account;
+      const is_coin = !["USDT", "USDC", "BUSD"].includes(asset.toUpperCase());
+      if (from.owner === to.owner) {
+        if (from.wallet === "spot" && to.wallet === "future") {
+          const type = is_coin ? CONSTANTS.SPOT_TO_COIN_FUTURE : CONSTANTS.SPOT_TO_USDT_FUTURE;
+          await fromFutureClient.submitUniversalTransfer({
+            asset: asset.toUpperCase(),
+            amount,
+            type,
+            fromSymbol: symbol,
+            toSymbol: symbol
+          });
+        } else {
+          const type = is_coin ? CONSTANTS.COIN_FUTURE_TO_SPOT : CONSTANTS.USDT_FUTURE_TO_SPOT;
+          await fromFutureClient.submitUniversalTransfer({
+            asset: asset.toUpperCase(),
+            amount,
+            type,
+            fromSymbol: symbol,
+            toSymbol: symbol
+          });
+        }
+      } else {
+        if (from.wallet === "future") {
+          const futureType = is_coin ? 2 : 1;
+          const rr = await mainFutureClient.subAccountFuturesAssetTransfer({
+            email: toAccount.email,
+            toEmail: toAccount.email,
+            fromEmail: fromAccount.email,
+            futuresType: futureType,
+            asset: asset.toUpperCase(),
+            amount
+          });
+          console.log({
+            rr
+          });
+          if (to.wallet === "spot") {
+            const type = is_coin ? CONSTANTS.COIN_FUTURE_TO_SPOT : CONSTANTS.USDT_FUTURE_TO_SPOT;
+            await toFutureClient.submitUniversalTransfer({
+              asset: asset.toUpperCase(),
+              amount,
+              type,
+              fromSymbol: symbol,
+              toSymbol: symbol
+            });
+          }
+          return rr;
+        }
+        if (from.wallet === "spot" && to.wallet === "spot") {
+          if (isSubAccountTransfer) {
+            await fromSpotClient.subAccountTransferToSameMaster({
+              toEmail: toAccount.email,
+              amount,
+              asset: asset.toUpperCase()
+            });
+          } else {
+            const type = is_coin ? CONSTANTS.SPOT_TO_COIN_FUTURE : CONSTANTS.SPOT_TO_USDT_FUTURE;
+            await fromFutureClient.submitUniversalTransfer({
+              asset: asset.toUpperCase(),
+              amount,
+              type,
+              fromSymbol: symbol,
+              toSymbol: symbol
+            });
+            const future_type = is_coin ? 2 : 1;
+            await mainFutureClient.subAccountFuturesAssetTransfer({
+              toEmail: toAccount.email,
+              fromEmail: fromAccount.email,
+              futuresType: future_type,
+              asset: asset.toUpperCase(),
+              amount
+            });
+            const _type_second = is_coin ? CONSTANTS.COIN_FUTURE_TO_SPOT : CONSTANTS.USDT_FUTURE_TO_SPOT;
+            await toFutureClient.submitUniversalTransfer({
+              asset: asset.toUpperCase(),
+              amount,
+              type: _type_second,
+              fromSymbol: symbol,
+              toSymbol: symbol
+            });
+          }
+        }
+        if (from.wallet === "spot" && to.wallet === "future") {
+          if (isSubAccountTransfer) {
+            await fromSpotClient.subAccountTransferToSameMaster({
+              toEmail: toAccount.email,
+              amount,
+              asset: asset.toUpperCase()
+            });
+            const type = is_coin ? CONSTANTS.SPOT_TO_COIN_FUTURE : CONSTANTS.SPOT_TO_USDT_FUTURE;
+            await toFutureClient.submitUniversalTransfer({
+              asset: asset.toUpperCase(),
+              amount,
+              type,
+              fromSymbol: symbol,
+              toSymbol: symbol
+            });
+          } else {
+            if (!mainAccount.is_sub_account) {
+              const type = is_coin ? CONSTANTS.SPOT_TO_COIN_FUTURE : CONSTANTS.SPOT_TO_USDT_FUTURE;
+              await mainFutureClient.submitUniversalTransfer({
+                asset: asset.toUpperCase(),
+                amount,
+                type,
+                fromSymbol: symbol,
+                toSymbol: symbol
+              });
+            }
+            if (!toAccount.is_sub_account) {
+              const type = is_coin ? CONSTANTS.SPOT_TO_COIN_FUTURE : CONSTANTS.SPOT_TO_USDT_FUTURE;
+              await fromFutureClient.submitUniversalTransfer({
+                asset: asset.toUpperCase(),
+                amount,
+                type,
+                fromSymbol: symbol,
+                toSymbol: symbol
+              });
+            }
+            const future_type = is_coin ? 2 : 1;
+            await mainFutureClient.subAccountFuturesAssetTransfer({
+              toEmail: toAccount.email,
+              fromEmail: fromAccount.email,
+              futuresType: future_type,
+              asset: asset.toUpperCase(),
+              amount
+            });
+          }
+        }
+      }
+    }
+  }
+}
 async function initClient(credentials, options) {
   const { proxyAgent, type = "future" } = options || {};
   try {
@@ -34346,10 +34533,16 @@ async function getAllOpenOrders(payload) {
 class BinanceExchange {
   client;
   main_client;
+  getCredentials;
+  proxyAgent;
   constructor(client, main_client) {
     this.client = client;
     this.main_client = main_client;
   }
+  setAccountDetails(payload) {
+    this.getCredentials = payload.getCredentials;
+    this.proxyAgent = payload.proxyAgent;
+  }
   async placeStopOrders(payload) {
     if (payload.place) {
       return placeStopOrder(this.client, {
@@ -34617,6 +34810,22 @@ class BinanceExchange {
     const response = await this.client.getPositionsV3();
     return Array.from(new Set(response.map((x) => x.symbol)));
   }
+  async crossAccountTransfer(payload) {
+    const { from, to, asset, amount } = payload;
+    if (this.getCredentials) {
+      const instance = new AccountService({
+        getCredentials: this.getCredentials,
+        proxyAgent: this.proxyAgent
+      });
+      const result = await instance.crossAccountTransfer("BTCUSDT", {
+        from: { owner: from.owner, wallet: from.wallet },
+        to: { owner: to.owner, wallet: to.wallet },
+        asset,
+        amount
+      });
+      return result;
+    }
+  }
 }
 function getPricePlaces(target) {
   const numStr = target.toString();
@@ -35287,6 +35496,8 @@ class BybitExchange {
   async getDelistedSpotSymbols() {
     return [];
   }
+  async crossAccountTransfer(payload) {
+  }
 }
 
 // src/helpers/accounts.ts
@@ -35523,7 +35734,10 @@ function processPosition(codeNode, input, kind) {
 }
 async function reduceMajorPositionCalculation(input, exchange_instance) {
   try {
-    const conditionsCheck = input.position.tp_quantity !== input.quantity || input.position.take_profit !== to_f(input.stop, "%.1f");
+    let conditionsCheck = input.position.tp_quantity !== input.quantity || input.position.take_profit !== to_f(input.stop, input.price_places);
+    if (input.opposite_position.stop_quantity) {
+      conditionsCheck = conditionsCheck || input.opposite_position.stop_quantity !== input.to_place.quantity;
+    }
     console.log("conditionsCheck for ", input.position.kind, conditionsCheck);
     console.log("opposite_check", {
       kind: input.opposite_position.kind,
@@ -36339,9 +36553,13 @@ class ExchangeAccount {
       return result;
     }
     if (action === "place_stop_orders" && payload.place) {
+      const instance = await this.syncAccount({
+        symbol: payload.symbol,
+        kind: app_config.kind
+      });
       let result = await this.exchange.placeStopOrders({
         symbol: payload.symbol,
-        quantity: trades[0].avg_size,
+        quantity: payload.use_current ? instance.quantity : trades[0].avg_size,
         kind: app_config.kind,
         stop: payload.stop,
         price_places: app_config.price_places,
@@ -36368,13 +36586,13 @@ class ExchangeAccount {
       if (db_position) {
         const config = db_position.expand?.config;
         const params = {
-          entry: payload.params.entry !== undefined ? payload.params.entry : config.entry,
-          stop: payload.params.stop !== undefined ? payload.params.stop : config.stop,
-          risk_reward: payload.params.risk_reward !== undefined ? payload.params.risk_reward : config.risk_reward,
-          risk: payload.params.risk !== undefined ? payload.params.risk : config.risk,
-          profit_percent: payload.params.profit_percent !== undefined ? payload.params.profit_percent : config.profit_percent,
+          entry: payload.params.entry !== undefined ? payload.params.entry : config?.entry,
+          stop: payload.params.stop !== undefined ? payload.params.stop : config?.stop,
+          risk_reward: payload.params.risk_reward !== undefined ? payload.params.risk_reward : config?.risk_reward,
+          risk: payload.params.risk !== undefined ? payload.params.risk : config?.risk,
+          profit_percent: payload.params.profit_percent !== undefined ? payload.params.profit_percent : config?.profit_percent,
           place_tp: payload.params.place_tp !== undefined ? payload.params.place_tp : true,
-          profit: payload.params.profit !== undefined ? payload.params.profit : config.profit
+          profit: payload.params.profit !== undefined ? payload.params.profit : config?.profit
         };
         return await this.app_db.createOrUpdatePositionConfig(db_position, params);
       }
@@ -36685,7 +36903,7 @@ class ExchangeAccount {
     return null;
   }
   async triggerTradeFromConfig(payload) {
-    const { symbol, kind, place = true } = payload;
+    const { symbol, kind, place = true, stop } = payload;
     const position2 = await this.syncAccount({
       symbol,
       kind
@@ -36693,14 +36911,16 @@ class ExchangeAccount {
     if (position2?.config) {
       const config = position2.expand.config;
       let entry = payload.tp ? position2.entry || config.entry : config.entry;
-      return await this.placeSharedOrder("place_limit_orders", {
+      const v = stop ? "place_stop_orders" : "place_limit_orders";
+      return await this.placeSharedOrder(v, {
         symbol,
         entry,
         stop: config.stop,
         risk_reward: config.risk_reward,
         risk: config.risk,
         place,
-        raw: payload.raw
+        raw: payload.raw,
+        use_current: Boolean(stop)
       });
     }
   }
@@ -37446,7 +37666,7 @@ class ExchangeAccount {
     return 0;
   }
   async placeTrade(payload) {
-    const { symbol, kind, place, tp, raw: _raw, cancel } = payload;
+    const { symbol, kind, place, tp, raw: _raw, cancel, stop } = payload;
     if (cancel) {
       await this.cancelOrders({
         symbol,
@@ -37457,7 +37677,8 @@ class ExchangeAccount {
       return await this.triggerTradeFromConfig({
         symbol,
         kind,
-        raw: payload.raw
+        raw: payload.raw,
+        stop
       });
     }
     await this.syncAccount({
@@ -37502,17 +37723,25 @@ function getExchangeKlass(exchange) {
     if (!client) {
       throw new Error(`Failed to initialize ${exchange} client`);
     }
-    return new func(client, main_client);
+    const instance = new func(client, main_client);
+    if (payload.canWithdraw) {
+      instance.setAccountDetails({
+        getCredentials: payload.getCredentials,
+        proxyAgent: payload.proxyAgent
+      });
+    }
+    return instance;
   };
 }
 async function getExchangeAccount(payload) {
-  const { account, app_db, proxyOptions = {} } = payload;
+  const { account, app_db, proxyOptions = {}, canWithdraw = false } = payload;
   const _proxyAgent = await app_db.getProxyForAccount(account);
   const proxyAgent = proxyOptions?.ignore_proxy ? null : proxyOptions?.proxy || _proxyAgent;
   const exchange_instance = await getExchangeKlass(account.exchange)({
     account: account.owner,
     getCredentials: payload.getCredentials,
-    proxyAgent
+    proxyAgent,
+    canWithdraw
   });
   return new ExchangeAccount(payload.account, {
     exchange: exchange_instance,
@@ -37535,7 +37764,8 @@ class App {
       account,
       app_db: this.app_db,
       getCredentials: this.getCredentials,
-      proxyOptions: this.proxyOptions
+      proxyOptions: this.proxyOptions,
+      canWithdraw: this.proxyOptions?.canWithdraw
     });
   }
   async syncAccount(payload) {
@@ -37914,7 +38144,8 @@ async function initApp(payload) {
           }
           return {
             api_key: credential?.api_key,
-            api_secret: credential?.api_secret
+            api_secret: credential?.api_secret,
+            email: credential?.email
           };
         };
       }
@@ -37924,7 +38155,8 @@ async function initApp(payload) {
   }
   const app = new App(app_db, _getCredentials, {
     proxy: payload.proxy,
-    ignore_proxy: payload.ignore_proxy
+    ignore_proxy: payload.ignore_proxy,
+    canWithdraw: payload.canWithdraw
   });
   return app;
 }
@@ -37960,11 +38192,12 @@ function getCredentials(account, exchange) {
   }
   return {
     api_key: apiKey,
-    api_secret: apiSecret
+    api_secret: apiSecret,
+    email: process.env.POCKETBASE_EMAIL
   };
 }
 async function initialize(payload) {
-  const { password, proxy, ignore_proxy } = payload;
+  const { password, proxy, ignore_proxy, canWithdraw } = payload;
   const app = await initApp({
     db: {
       host: process.env.POCKETBASE_HOST,
@@ -37974,7 +38207,8 @@ async function initialize(payload) {
     password,
     getCredentials,
     proxy,
-    ignore_proxy
+    ignore_proxy,
+    canWithdraw
   });
   return app;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gbozee/ultimate",
   "type": "module",
-  "version": "0.0.2-27",
+  "version": "0.0.2-29",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",