@gbozee/ultimate 0.0.2-26 → 0.0.2-28

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;
@@ -801,10 +813,20 @@ declare class ExchangeAccount$1 {
 }
 declare class App {
 	app_db: AppDatabase;
+	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: {
@@ -920,9 +942,18 @@ 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 declare function initialize(password?: string): Promise<App>;
 
 export {
 	ExchangeAccount$1 as ExchangeAccount,

package/dist/index.js

@@ -33796,19 +33796,210 @@ 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 {
+    const axiosOptions = proxyAgent ? {
+      httpAgent: proxyAgent,
+      httpsAgent: proxyAgent
+    } : undefined;
+    if (!proxyAgent) {
+      console.log("using no proxy");
+    }
     const Klass = type === "future" ? import_binance.USDMClient : type === "spot" ? import_binance.MainClient : import_binance.MainClient;
     const client = new Klass({
       api_key: credentials.api_key,
       api_secret: credentials.api_secret,
       recvWindow: 1e4,
       beautifyResponses: true
-    }, {
-      httpAgent: proxyAgent,
-      httpsAgent: proxyAgent
-    });
+    }, axiosOptions);
     return client;
   } catch (e2) {
     console.log(e2);
@@ -34342,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, {
@@ -34613,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();
@@ -34628,14 +34841,15 @@ var import_bybit_api = __toESM(require_lib2(), 1);
 async function initClient2(credentials, options) {
   const { proxyAgent } = options;
   try {
+    const axiosOptions = proxyAgent ? {
+      httpAgent: proxyAgent,
+      httpsAgent: proxyAgent
+    } : undefined;
     const client = new import_bybit_api.RestClientV5({
       key: credentials.api_key,
       secret: credentials.api_secret,
       recv_window: 1e4
-    }, {
-      httpAgent: proxyAgent,
-      httpsAgent: proxyAgent
-    });
+    }, axiosOptions);
     return client;
   } catch (e2) {
     console.log(e2);
@@ -35282,6 +35496,8 @@ class BybitExchange {
   async getDelistedSpotSymbols() {
     return [];
   }
+  async crossAccountTransfer(payload) {
+  }
 }
 
 // src/helpers/accounts.ts
@@ -36363,13 +36579,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);
       }
@@ -37497,16 +37713,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 } = payload;
-  const proxyAgent = await app_db.getProxyForAccount(account);
+  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,
@@ -37517,16 +37742,20 @@ async function getExchangeAccount(payload) {
 // src/app.ts
 class App {
   app_db;
+  proxyOptions;
   getCredentials;
-  constructor(app_db, getCredentials) {
+  constructor(app_db, getCredentials, proxyOptions) {
     this.app_db = app_db;
     this.getCredentials = getCredentials;
+    this.proxyOptions = proxyOptions;
   }
   async getExchangeAccount(account) {
     return await getExchangeAccount({
       account,
       app_db: this.app_db,
-      getCredentials: this.getCredentials
+      getCredentials: this.getCredentials,
+      proxyOptions: this.proxyOptions,
+      canWithdraw: this.proxyOptions?.canWithdraw
     });
   }
   async syncAccount(payload) {
@@ -37905,7 +38134,8 @@ async function initApp(payload) {
           }
           return {
             api_key: credential?.api_key,
-            api_secret: credential?.api_secret
+            api_secret: credential?.api_secret,
+            email: credential?.email
           };
         };
       }
@@ -37913,7 +38143,11 @@ async function initApp(payload) {
       console.log("error", error);
     }
   }
-  const app = new App(app_db, _getCredentials);
+  const app = new App(app_db, _getCredentials, {
+    proxy: payload.proxy,
+    ignore_proxy: payload.ignore_proxy,
+    canWithdraw: payload.canWithdraw
+  });
   return app;
 }
 function getCredentials(account, exchange) {
@@ -37948,10 +38182,12 @@ function getCredentials(account, exchange) {
   }
   return {
     api_key: apiKey,
-    api_secret: apiSecret
+    api_secret: apiSecret,
+    email: process.env.POCKETBASE_EMAIL
   };
 }
-async function initialize(password) {
+async function initialize(payload) {
+  const { password, proxy, ignore_proxy, canWithdraw } = payload;
   const app = await initApp({
     db: {
       host: process.env.POCKETBASE_HOST,
@@ -37959,7 +38195,10 @@ async function initialize(password) {
       password: process.env.POCKETBASE_PASSWORD
     },
     password,
-    getCredentials
+    getCredentials,
+    proxy,
+    ignore_proxy,
+    canWithdraw
   });
   return app;
 }

package/package.json

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