@orderly.network/hooks 2.0.1-alpha.1 → 2.0.1-alpha.3

package/dist/index.mjs

@@ -32,9 +32,9 @@ var __export = (target, all) => {
 // src/version.ts
 if (typeof window !== "undefined") {
   window.__ORDERLY_VERSION__ = window.__ORDERLY_VERSION__ || {};
-  window.__ORDERLY_VERSION__["@orderly.network/hooks"] = "2.0.1-alpha.1";
+  window.__ORDERLY_VERSION__["@orderly.network/hooks"] = "2.0.1-alpha.3";
 }
-var version_default = "2.0.1-alpha.1";
+var version_default = "2.0.1-alpha.3";
 var fetcher = (url, init = {}, queryOptions) => get(url, init, queryOptions?.formatter);
 var OrderlyContext = createContext({
   // configStore: new MemoryConfigStore(),
@@ -987,6 +987,9 @@ var MarkPriceCalculator = class extends BaseCalculator {
 
 // src/orderly/calculator/calculatorContext.ts
 var CalculatorContext = class _CalculatorContext {
+  static get instance() {
+    return this._instance;
+  }
   static create(scope, data) {
     if (!this._instance) {
       this._instance = new _CalculatorContext(scope, data);
@@ -1021,6 +1024,9 @@ var CalculatorContext = class _CalculatorContext {
     this.accountInfo = void 0;
     this.portfolio = void 0;
   }
+  deleteByName(name) {
+    delete this.output[name];
+  }
   // get positions(): API.PositionTPSLExt[] {
   //   if (this.output.positionCalculator) return this.output.positionCalculator;
   //   return usePositionStore.getState().positions;
@@ -1050,32 +1056,36 @@ var CalculatorService = class {
     this.calculators = new Map(calculators);
   }
   register(scope, calculator) {
-    const count = this.referenceCount.get(calculator.name);
+    const ref_count_name = `${scope}_${calculator.name}`;
+    const count = this.referenceCount.get(ref_count_name);
     if (typeof count !== "undefined" && count > 0) {
-      this.referenceCount.set(calculator.name, count + 1);
+      this.referenceCount.set(ref_count_name, count + 1);
       return;
     }
-    const queue = this.calculators.get(scope);
-    if (Array.isArray(queue)) {
-      queue.push(calculator);
+    const calculators = this.calculators.get(scope);
+    if (Array.isArray(calculators)) {
+      calculators.push(calculator);
     } else {
       this.calculators.set(scope, [calculator]);
     }
-    this.referenceCount.set(calculator.name, 1);
+    this.referenceCount.set(ref_count_name, 1);
   }
   unregister(scope, calculator) {
-    const count = this.referenceCount.get(calculator.name);
+    const ref_count_name = `${scope}_${calculator.name}`;
+    const count = this.referenceCount.get(ref_count_name);
     if (typeof count !== "undefined" && count > 1) {
-      this.referenceCount.set(calculator.name, count - 1);
+      this.referenceCount.set(ref_count_name, count - 1);
       return;
     }
-    const queue = this.calculators.get(scope);
-    if (Array.isArray(queue)) {
-      const index = queue.indexOf(calculator);
+    const calculators = this.calculators.get(scope);
+    if (Array.isArray(calculators)) {
+      const index = calculators.findIndex((c) => c.name === calculator.name);
       if (index > -1) {
-        queue.splice(index, 1);
+        calculators[index].destroy?.();
+        calculators.splice(index, 1);
       }
     }
+    this.referenceCount.delete(ref_count_name);
   }
   async calc(scope, data, options) {
     if (scope !== "position" /* POSITION */) {
@@ -1242,6 +1252,11 @@ var usePositionStore = create()(
           state.positions[key] = positions2;
         });
       },
+      closePosition: (symbol) => {
+        set((state) => {
+          delete state.positions[symbol];
+        });
+      },
       clearAll: () => {
         set((state) => {
           state.positions = {
@@ -1479,7 +1494,7 @@ var PositionCalculator = class extends BaseCalculator {
   }
   preprocess(data) {
     let rows = data.rows;
-    if (this.symbol !== AllPositions) {
+    if (this.symbol !== AllPositions && Array.isArray(rows)) {
       rows = rows.filter((item) => item.symbol === this.symbol);
     }
     return {
@@ -1489,7 +1504,20 @@ var PositionCalculator = class extends BaseCalculator {
   }
   getPosition(_, ctx) {
     let positions2 = ctx.get((output) => output[this.name]) || usePositionStore.getState().positions[this.symbol];
-    return positions2;
+    if (this.symbol === AllPositions) {
+      return positions2;
+    }
+    if (positions2 && Array.isArray(positions2.rows)) {
+      return positions2;
+    }
+    return this.preprocess(this.getAllPositions(ctx));
+  }
+  destroy() {
+    usePositionStore.getState().actions.closePosition(this.symbol);
+    CalculatorContext.instance?.deleteByName(this.name);
+  }
+  getAllPositions(ctx) {
+    return ctx.get((output) => output[AllPositions]) || usePositionStore.getState().positions[AllPositions];
   }
 };
 PositionCalculator.logPosition = (symbol = "all") => {
@@ -1557,15 +1585,13 @@ var PortfolioCalculator = class extends BaseCalculator {
     if (scope === "markPrice" /* MARK_PRICE */) {
       markPrices = data;
     } else {
-      markPrices = ctx.get((cache) => cache[this.name]);
-    }
-    if (scope === "position" /* POSITION */) {
-      positions2 = data;
-    } else {
-      positions2 = ctx.get(
-        (output) => output.positionCalculator_all
+      markPrices = ctx.get(
+        (cache) => cache[MarketCalculatorName]
       );
     }
+    positions2 = ctx.get(
+      (output) => output.positionCalculator_all
+    );
     let holding = portfolio.holding;
     const accountInfo = ctx.accountInfo;
     const symbolsInfo = ctx.symbolsInfo;
@@ -1624,7 +1650,8 @@ var PortfolioCalculator = class extends BaseCalculator {
       totalUnrealizedROI,
       freeCollateral,
       availableBalance,
-      unsettledPnL
+      unsettledPnL,
+      holding
     };
   }
   update(data, scope) {
@@ -1635,7 +1662,8 @@ var PortfolioCalculator = class extends BaseCalculator {
         freeCollateral: data.freeCollateral,
         availableBalance: data.availableBalance,
         totalUnrealizedROI: data.totalUnrealizedROI,
-        unsettledPnL: data.unsettledPnL
+        unsettledPnL: data.unsettledPnL,
+        holding: Array.isArray(data.holding) ? data.holding : []
       });
     }
   }
@@ -2903,7 +2931,7 @@ var useFundingRate = (symbol) => {
     if (getTimestamp() > next_funding_time) {
       return null;
     }
-    return (Number(est_funding_rate2) * 100).toFixed(4);
+    return new Decimal(Number(est_funding_rate2) * 100).toFixed(4, Decimal.ROUND_DOWN);
   }, [data]);
   return {
     ...data,
@@ -2971,11 +2999,27 @@ var usePositionStream = (symbol = "all", options) => {
       "position" /* POSITION */,
       positionCalculator.current
     );
+    calculatorService.register(
+      "markPrice" /* MARK_PRICE */,
+      positionCalculator.current
+    );
+    calculatorService.register(
+      "indexPrice" /* INDEX_PRICE */,
+      positionCalculator.current
+    );
     return () => {
       calculatorService.unregister(
         "position" /* POSITION */,
         positionCalculator.current
       );
+      calculatorService.unregister(
+        "markPrice" /* MARK_PRICE */,
+        positionCalculator.current
+      );
+      calculatorService.unregister(
+        "indexPrice" /* INDEX_PRICE */,
+        positionCalculator.current
+      );
     };
   }, [symbol]);
   const formattedPositions = usePositionStore((state) => {
@@ -4047,6 +4091,16 @@ var useDeposit = (options) => {
     [account5, getAllowance, options?.address, dst]
   );
   const deposit = useCallback(async () => {
+    if (!options?.address) {
+      throw new Error("address is required");
+    }
+    const _allowance = await account5.assetsManager.getAllowance({
+      address: options?.address
+    });
+    setAllowance(() => _allowance);
+    if (new Decimal(quantity).greaterThan(_allowance)) {
+      throw new Error("Insufficient allowance");
+    }
     return account5.assetsManager.deposit(quantity, depositFee).then((res) => {
       updateAllowanceWhenTxSuccess(res.hash);
       setBalance((value) => new Decimal(value).sub(quantity).toString());
@@ -5856,6 +5910,7 @@ var usePrivateDataObserver = (options) => {
     onError: (error) => {
       statusActions.updateApiError("positions", error.message);
     }
+    // revalidateOnFocus: false,
   });
   useEffect(() => {
     const handler = (state2) => {
@@ -5884,6 +5939,7 @@ var usePrivateDataObserver = (options) => {
     "/v1/client/holding",
     {
       formatter: (data) => data.holding
+      // revalidateOnFocus: false,
     }
   );
   useEffect(() => {
@@ -13669,7 +13725,7 @@ var useOrderEntry2 = (symbol, options) => {
     throw new Error("symbol is required and must be a string");
   }
   const ee = useEventEmitter();
-  const fieldDirty = useRef({});
+  useRef({});
   const [meta, setMeta] = useState({
     dirty: {},
     submitted: false,
@@ -13753,11 +13809,17 @@ var useOrderEntry2 = (symbol, options) => {
     return true;
   };
   const setValue = (key, value, options2) => {
-    const { shouldUpdateLastChangedField = true } = options2 || {};
+    const { shouldUpdateLastChangedField = true, shouldUpdateDirty = true } = options2 || {};
     if (!canSetTPSLPrice(key, formattedOrder.order_type)) {
       return;
     }
-    fieldDirty.current[key] = true;
+    if (shouldUpdateDirty) {
+      setMeta(
+        produce((draft) => {
+          draft.dirty[key] = true;
+        })
+      );
+    }
     const values2 = setValueInternal(key, value, prepareData());
     if (values2) {
       interactiveValidate(values2);
@@ -13845,9 +13907,10 @@ var useOrderEntry2 = (symbol, options) => {
       })
     );
   };
-  const submitOrder = async () => {
+  const submitOrder = async (options2) => {
     const creator = getOrderCreator(formattedOrder);
     const errors = await validate(formattedOrder, creator, prepareData());
+    const { resetOnSuccess = true } = options2 || {};
     setMeta(
       produce((draft) => {
         draft.submitted = true;
@@ -13864,10 +13927,11 @@ var useOrderEntry2 = (symbol, options) => {
     }
     const order = generateOrder(creator, prepareData());
     const result = await doCreateOrder(order);
-    if (result.success) {
+    if (result.success && resetOnSuccess) {
       reset();
       resetMetaState();
     }
+    return result;
   };
   return {
     ...orderEntryActions,