@liberfi.io/react-predict 0.3.52 → 0.3.54

package/dist/index.js

@@ -1567,7 +1567,6 @@ function useOrder(params, queryOptions = {}) {
 }
 function useCancelOrder(options, mutationOptions = {}) {
   const client = usePredictClient();
-  const queryClient = reactQuery.useQueryClient();
   const { onSuccess, onError, ...restMutationOptions } = mutationOptions;
   return reactQuery.useMutation({
     mutationFn: async (vars) => {
@@ -1575,7 +1574,6 @@ function useCancelOrder(options, mutationOptions = {}) {
       return client.cancelOrder(vars.id, vars.source, headers);
     },
     onSuccess: (...args) => {
-      queryClient.invalidateQueries({ queryKey: ["predict", "orders"] });
       onSuccess?.(...args);
     },
     onError: (...args) => {
@@ -1584,6 +1582,480 @@ function useCancelOrder(options, mutationOptions = {}) {
     ...restMutationOptions
   });
 }
+var DEFAULT_MAX_DURATION_MS = 3e4;
+var FAST_INTERVAL_MS = 2e3;
+var SLOW_INTERVAL_MS = 3e3;
+var SLOW_AFTER_MS = 12e3;
+var QUERY_PREFIXES = [
+  ["predict", "trades"],
+  ["predict", "trades-by-wallet"],
+  ["predict", "available-shares"]
+];
+var OPEN_ORDER_STATUSES = /* @__PURE__ */ new Set(["live", "open", "submitted", "pending"]);
+function getPositionsWallets(input) {
+  const wallets = {
+    kalshi_user: input.kalshiUser ?? (input.source === "kalshi" ? input.user : void 0),
+    polymarket_user: input.polymarketUser ?? (input.source === "polymarket" ? input.user : void 0)
+  };
+  return wallets.kalshi_user || wallets.polymarket_user ? wallets : void 0;
+}
+function getOrdersWalletSets(input) {
+  const wallets = getPositionsWallets(input);
+  const sourceWallet = input.source === "kalshi" ? { kalshi_user: input.user } : { polymarket_user: input.user };
+  const result = [];
+  if (input.user) {
+    result.push(sourceWallet);
+  }
+  if (wallets) {
+    const duplicate = result.some(
+      (item) => item.kalshi_user === wallets.kalshi_user && item.polymarket_user === wallets.polymarket_user
+    );
+    if (!duplicate) {
+      result.push(wallets);
+    }
+  }
+  return result;
+}
+function getSourceOnlyWallets(input) {
+  if (!input.user) return void 0;
+  return input.source === "kalshi" ? { kalshi_user: input.user } : { polymarket_user: input.user };
+}
+function dataForSourcePositions(data, source) {
+  if (!data || typeof data !== "object") return data;
+  const response = data;
+  if (!Array.isArray(response.positions)) return data;
+  return {
+    ...response,
+    positions: response.positions.filter(
+      (position) => !position.source || position.source === source
+    )
+  };
+}
+function normalizeBalanceData(data) {
+  if (!data || typeof data !== "object") return data;
+  const balance = data;
+  return {
+    source: balance.source,
+    user: balance.user,
+    balance: balance.balance,
+    raw_balance: balance.raw_balance
+  };
+}
+function normalizePositionsData(data, input) {
+  if (!data || typeof data !== "object") return data;
+  const response = data;
+  return (response.positions ?? []).filter((position) => {
+    const eventSlug = typeof position.event === "object" && position.event ? position.event.slug : void 0;
+    const marketSlug = typeof position.market === "object" && position.market ? position.market.slug : void 0;
+    if (input.marketSlug && marketSlug && marketSlug !== input.marketSlug) {
+      return false;
+    }
+    if (input.eventSlug && eventSlug && eventSlug !== input.eventSlug) {
+      return false;
+    }
+    if (position.source && position.source !== input.source) return false;
+    return true;
+  }).map((position) => ({
+    source: position.source,
+    side: position.side,
+    size: position.size,
+    redeemable: position.redeemable,
+    eventSlug: typeof position.event === "object" && position.event ? position.event.slug : void 0,
+    marketSlug: typeof position.market === "object" && position.market ? position.market.slug : void 0
+  })).sort(
+    (a, b) => `${a.source}:${a.marketSlug}:${a.side}`.localeCompare(
+      `${b.source}:${b.marketSlug}:${b.side}`
+    )
+  );
+}
+function normalizeOrdersData(data, input) {
+  if (!data || typeof data !== "object") return data;
+  const response = data;
+  return (response.orders ?? response.items ?? []).filter((order) => {
+    const eventSlug = typeof order.event === "object" && order.event ? order.event.slug : void 0;
+    const marketSlug = typeof order.market === "object" && order.market ? order.market.slug : void 0;
+    const status = typeof order.status === "string" ? order.status : "";
+    if (!OPEN_ORDER_STATUSES.has(status)) return false;
+    if (input.marketSlug && marketSlug && marketSlug !== input.marketSlug) {
+      return false;
+    }
+    if (input.eventSlug && eventSlug && eventSlug !== input.eventSlug) {
+      return false;
+    }
+    if (order.source && order.source !== input.source) return false;
+    return true;
+  }).map((order) => ({
+    id: order.id,
+    source: order.source,
+    status: order.status,
+    side: order.side,
+    outcome: order.outcome,
+    price: order.price,
+    originalSize: order.original_size,
+    marketSlug: typeof order.market === "object" && order.market ? order.market.slug : void 0,
+    eventSlug: typeof order.event === "object" && order.event ? order.event.slug : void 0
+  })).sort((a, b) => String(a.id).localeCompare(String(b.id)));
+}
+function getCachedAccountSnapshot(client, input) {
+  const snapshot = {};
+  if (input.user) {
+    const balance = client.getQueryData(
+      balanceQueryKey(input.source, input.user)
+    );
+    if (balance !== void 0) {
+      snapshot.balance = normalizeBalanceData(balance);
+    }
+  }
+  const wallets = getPositionsWallets(input);
+  const multiPositions = wallets ? client.getQueryData(positionsMultiQueryKey(wallets)) : void 0;
+  const singlePositions = input.user ? client.getQueryData(positionsQueryKey(input.user, input.source)) : void 0;
+  const positions = multiPositions ?? singlePositions;
+  if (positions !== void 0) {
+    snapshot.positions = normalizePositionsData(positions, input);
+  }
+  const orders = input.user ? client.getQueryData(
+    ordersQueryKey({ source: input.source, wallet_address: input.user })
+  ) : void 0;
+  if (orders !== void 0) {
+    snapshot.orders = normalizeOrdersData(orders, input);
+  }
+  return snapshot;
+}
+function serializeSnapshotField(value) {
+  return JSON.stringify(value);
+}
+function didFieldChange(field, baseline, current) {
+  if (baseline[field] === void 0 || current[field] === void 0) {
+    return false;
+  }
+  return serializeSnapshotField(current[field]) !== serializeSnapshotField(baseline[field]);
+}
+function parseNumeric(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string") {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : void 0;
+  }
+  return void 0;
+}
+function getBalanceAmount(snapshot) {
+  if (!snapshot.balance || typeof snapshot.balance !== "object")
+    return void 0;
+  const balance = snapshot.balance;
+  return parseNumeric(balance.raw_balance) ?? parseNumeric(balance.balance);
+}
+function getPositionSizeTotal(snapshot) {
+  if (!Array.isArray(snapshot.positions)) return void 0;
+  return snapshot.positions.reduce((total, position) => {
+    if (!position || typeof position !== "object") return total;
+    const size = parseNumeric(position.size);
+    return total + (size ?? 0);
+  }, 0);
+}
+function getOpenOrderCount(snapshot) {
+  if (!Array.isArray(snapshot.orders)) return void 0;
+  return snapshot.orders.length;
+}
+function hasBothAccountFields(snapshot) {
+  return snapshot.balance !== void 0 && snapshot.positions !== void 0;
+}
+function isTradeResultConfirmed(expectation, baseline, current) {
+  const ordersChanged = didFieldChange("orders", baseline, current);
+  const baselineOpenOrders = getOpenOrderCount(baseline);
+  const currentOpenOrders = getOpenOrderCount(current);
+  const openOrdersIncreased = baselineOpenOrders !== void 0 && currentOpenOrders !== void 0 && currentOpenOrders > baselineOpenOrders;
+  if (expectation === "buy-limit" || expectation === "sell-limit") {
+    if (baselineOpenOrders === void 0) {
+      return currentOpenOrders !== void 0 && currentOpenOrders > 0;
+    }
+    return openOrdersIncreased || ordersChanged;
+  }
+  if (!hasBothAccountFields(baseline) || !hasBothAccountFields(current)) {
+    return false;
+  }
+  const balanceChanged = didFieldChange("balance", baseline, current);
+  const positionsChanged = didFieldChange("positions", baseline, current);
+  const baselineBalance = getBalanceAmount(baseline);
+  const currentBalance = getBalanceAmount(current);
+  const baselinePositionSize = getPositionSizeTotal(baseline);
+  const currentPositionSize = getPositionSizeTotal(current);
+  const balanceDecreased = baselineBalance !== void 0 && currentBalance !== void 0 && currentBalance < baselineBalance;
+  const balanceIncreased = baselineBalance !== void 0 && currentBalance !== void 0 && currentBalance > baselineBalance;
+  const positionsIncreased = baselinePositionSize !== void 0 && currentPositionSize !== void 0 && currentPositionSize > baselinePositionSize;
+  const positionsDecreased = baselinePositionSize !== void 0 && currentPositionSize !== void 0 && currentPositionSize < baselinePositionSize;
+  switch (expectation) {
+    case "buy-market":
+      return balanceDecreased && positionsIncreased;
+    case "sell-market":
+      return balanceIncreased && positionsDecreased;
+    case "redeem":
+      return balanceChanged && positionsChanged;
+    case "cancel-order":
+      return false;
+    default:
+      return false;
+  }
+}
+function hasOpenTargetOrder(client, orderId) {
+  const orderQueries = client.getQueriesData({
+    queryKey: ["predict", "orders"]
+  });
+  return orderQueries.some(([, data]) => dataContainsOpenOrder(data, orderId));
+}
+function dataContainsOpenOrder(data, orderId) {
+  if (!data || typeof data !== "object") return false;
+  if (Array.isArray(data)) {
+    return data.some((item) => dataContainsOpenOrder(item, orderId));
+  }
+  const record = data;
+  if (record.id === orderId) {
+    const status = typeof record.status === "string" ? record.status : "";
+    return !status || OPEN_ORDER_STATUSES.has(status);
+  }
+  for (const value of Object.values(record)) {
+    if (dataContainsOpenOrder(value, orderId)) return true;
+  }
+  return false;
+}
+function refetchActiveTradeResultQueries(queryClient) {
+  for (const queryKey of QUERY_PREFIXES) {
+    void queryClient.refetchQueries({ queryKey, type: "active" });
+  }
+}
+function requestBalanceSnapshot(queryClient, predictClient, input) {
+  if (!input.user) return Promise.resolve(void 0);
+  const queryKey = balanceQueryKey(input.source, input.user);
+  return queryClient.cancelQueries({ queryKey }).then(() => predictClient.getBalance(input.source, input.user)).then((data) => {
+    queryClient.setQueryData(queryKey, data);
+    return normalizeBalanceData(data);
+  });
+}
+function requestPositionsSnapshot(queryClient, predictClient, input) {
+  const wallets = getPositionsWallets(input);
+  if (!wallets) return Promise.resolve(void 0);
+  const sourceOnlyWallets = getSourceOnlyWallets(input);
+  const cancelTasks = [
+    queryClient.cancelQueries({ queryKey: positionsMultiQueryKey(wallets) })
+  ];
+  if (sourceOnlyWallets) {
+    cancelTasks.push(
+      queryClient.cancelQueries({
+        queryKey: positionsMultiQueryKey(sourceOnlyWallets)
+      })
+    );
+  }
+  if (input.user) {
+    cancelTasks.push(
+      queryClient.cancelQueries({
+        queryKey: positionsQueryKey(input.user, input.source)
+      })
+    );
+  }
+  return Promise.all(cancelTasks).then(() => predictClient.getPositions(wallets)).then((data) => {
+    queryClient.setQueryData(positionsMultiQueryKey(wallets), data);
+    if (sourceOnlyWallets) {
+      queryClient.setQueryData(
+        positionsMultiQueryKey(sourceOnlyWallets),
+        dataForSourcePositions(data, input.source)
+      );
+    }
+    if (input.user) {
+      queryClient.setQueryData(
+        positionsQueryKey(input.user, input.source),
+        dataForSourcePositions(data, input.source)
+      );
+    }
+    return normalizePositionsData(data, input);
+  });
+}
+function requestOrdersSnapshot(queryClient, predictClient, input) {
+  if (!input.user) return Promise.resolve(void 0);
+  const params = { source: input.source, wallet_address: input.user };
+  return Promise.resolve(input.getOrdersHeaders?.()).then((headers) => predictClient.listOrders(params, headers)).then((data) => {
+    queryClient.setQueryData(ordersQueryKey(params), data);
+    return normalizeOrdersData(data, input);
+  });
+}
+function refreshEnrichedOrdersSnapshot(queryClient, predictClient, input) {
+  const walletSets = getOrdersWalletSets(input);
+  if (walletSets.length === 0) return Promise.resolve();
+  return Promise.resolve(input.getOrdersHeaders?.()).then(
+    (headers) => Promise.all(
+      walletSets.map(
+        (wallets) => predictClient.listOrdersMulti(wallets, headers).then((data) => {
+          queryClient.setQueryData(ordersMultiQueryKey(wallets), data);
+        })
+      )
+    )
+  ).then(() => void 0).catch(() => void 0);
+}
+function isLimitExpectation(expectation) {
+  return expectation === "buy-limit" || expectation === "sell-limit";
+}
+function nextPollInterval(startedAt) {
+  const elapsed = Date.now() - startedAt;
+  return elapsed < SLOW_AFTER_MS ? FAST_INTERVAL_MS : SLOW_INTERVAL_MS;
+}
+function createDeferredConfirmation() {
+  let resolveResult = () => void 0;
+  const promise = new Promise((resolve) => {
+    resolveResult = resolve;
+  });
+  return { promise, resolve: resolveResult };
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+async function runFixedIntervalConfirmation({
+  queryClient,
+  predictClient,
+  input,
+  startedAt,
+  deadlineAt,
+  initialBaseline,
+  hadTargetOrder,
+  confirm,
+  delay
+}) {
+  const baseline = { ...initialBaseline };
+  const current = { ...initialBaseline };
+  const inFlight = {
+    balance: false,
+    positions: false,
+    orders: false
+  };
+  let settled = false;
+  const finishConfirmed = () => {
+    settled = true;
+    if (!isLimitExpectation(input.expectation)) {
+      confirm();
+      return;
+    }
+    void refreshEnrichedOrdersSnapshot(
+      queryClient,
+      predictClient,
+      input
+    ).finally(confirm);
+  };
+  const handleSnapshot = (field, value) => {
+    if (value === void 0 || settled) return;
+    if (baseline[field] === void 0) {
+      current[field] = value;
+      if (field === "orders" && isLimitExpectation(input.expectation) && isTradeResultConfirmed(input.expectation, baseline, current)) {
+        finishConfirmed();
+        return;
+      }
+      baseline[field] = value;
+      return;
+    }
+    current[field] = value;
+    if (isTradeResultConfirmed(input.expectation, baseline, current)) {
+      finishConfirmed();
+    }
+  };
+  const pollField = (field, request) => {
+    if (inFlight[field] || settled) return;
+    inFlight[field] = true;
+    void request().then((value) => handleSnapshot(field, value)).catch(() => void 0).finally(() => {
+      inFlight[field] = false;
+    });
+  };
+  while (!settled && Date.now() <= deadlineAt) {
+    refetchActiveTradeResultQueries(queryClient);
+    if (input.expectation === "cancel-order" && input.orderId && hadTargetOrder) {
+      if (!hasOpenTargetOrder(queryClient, input.orderId)) {
+        settled = true;
+        confirm();
+        return;
+      }
+    } else if (isLimitExpectation(input.expectation)) {
+      pollField(
+        "orders",
+        () => requestOrdersSnapshot(queryClient, predictClient, input)
+      );
+    } else {
+      pollField(
+        "balance",
+        () => requestBalanceSnapshot(queryClient, predictClient, input)
+      );
+      pollField(
+        "positions",
+        () => requestPositionsSnapshot(queryClient, predictClient, input)
+      );
+    }
+    await sleep(
+      Math.min(
+        nextPollInterval(startedAt),
+        Math.max(0, deadlineAt - Date.now())
+      )
+    );
+  }
+  if (!settled) delay();
+}
+function useTradeResultConfirmation() {
+  const queryClient = reactQuery.useQueryClient();
+  const predictClient = usePredictClient();
+  const mountedRef = react.useRef(true);
+  const [state, setState] = react.useState({
+    status: "idle"
+  });
+  react.useEffect(() => {
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+  const start = react.useCallback(
+    async (input) => {
+      const {
+        expectation,
+        orderId,
+        maxDurationMs = DEFAULT_MAX_DURATION_MS
+      } = input;
+      const startedAt = Date.now();
+      const deadlineAt = startedAt + maxDurationMs;
+      const preflightBaseline = getCachedAccountSnapshot(queryClient, input);
+      const hadTargetOrder = expectation === "cancel-order" && orderId ? hasOpenTargetOrder(queryClient, orderId) : false;
+      if (mountedRef.current) {
+        setState({ status: "confirming", startedAt, deadlineAt });
+      }
+      const result = createDeferredConfirmation();
+      let resolved = false;
+      const resolveOnce = (confirmationResult) => {
+        if (resolved) return;
+        resolved = true;
+        result.resolve(confirmationResult);
+      };
+      const confirm = () => {
+        if (mountedRef.current) {
+          setState({ status: "confirmed", startedAt, deadlineAt });
+        }
+        resolveOnce("confirmed");
+      };
+      const delay = () => {
+        if (mountedRef.current) {
+          setState({ status: "delayed", startedAt, deadlineAt });
+        }
+        resolveOnce("delayed");
+      };
+      void runFixedIntervalConfirmation({
+        queryClient,
+        predictClient,
+        input,
+        startedAt,
+        deadlineAt,
+        initialBaseline: preflightBaseline,
+        hadTargetOrder,
+        confirm,
+        delay
+      });
+      return await result.promise;
+    },
+    [predictClient, queryClient]
+  );
+  return { start, state };
+}
 
 // src/hooks/predict/matches.params.ts
 function matchesQueryKey(params) {
@@ -1703,13 +2175,8 @@ function useDFlowQuote(params, queryOptions = {}) {
 }
 function useDFlowSubmit(mutationOptions = {}) {
   const client = usePredictClient();
-  const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
     mutationFn: (body) => client.submitDFlowTransaction(body),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["predict", "orders"] });
-      queryClient.invalidateQueries({ queryKey: ["predict", "positions"] });
-    },
     ...mutationOptions
   });
 }
@@ -1853,7 +2320,7 @@ function usePolymarketDeposit(mutationOptions = {}) {
 }
 async function pollTxUntilConfirmed(client, txHash) {
   for (let i = 0; i < TX_POLL_MAX_ATTEMPTS; i++) {
-    await sleep(TX_POLL_INTERVAL);
+    await sleep2(TX_POLL_INTERVAL);
     const result = await client.depositStatus(txHash, "polymarket");
     if (result.status === "confirmed") return;
     if (result.status === "failed") {
@@ -1864,7 +2331,7 @@ async function pollTxUntilConfirmed(client, txHash) {
     `Deposit transaction timed out after ${TX_POLL_MAX_ATTEMPTS * TX_POLL_INTERVAL / 1e3}s: ${txHash}`
   );
 }
-function sleep(ms) {
+function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 var polymarketDepositAddressesQueryKey = (safeAddress) => ["polymarket", "deposit-addresses", safeAddress];
@@ -1938,7 +2405,6 @@ function usePolymarketWithdrawStatusQuery(params) {
 }
 function useRedeemPosition() {
   const client = usePredictClient();
-  const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
     mutationFn: async ({
       wallet_address,
@@ -1989,10 +2455,6 @@ function useRedeemPosition() {
         );
       }
       return result;
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["predict", "positions"] });
-      queryClient.invalidateQueries({ queryKey: ["predict", "balance"] });
     }
   });
 }
@@ -2521,7 +2983,6 @@ var TX_POLL_MAX_ATTEMPTS2 = 60;
 function useCreatePolymarketOrder(mutationOptions = {}) {
   const client = usePredictClient();
   const { credentials, authenticate } = usePolymarket();
-  const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
     mutationFn: async ({
       input,
@@ -2596,11 +3057,6 @@ function useCreatePolymarketOrder(mutationOptions = {}) {
       });
       return result.raw;
     },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["predict", "orders"] });
-      queryClient.invalidateQueries({ queryKey: ["predict", "positions"] });
-      queryClient.invalidateQueries({ queryKey: ["predict", "balance"] });
-    },
     ...mutationOptions
   });
 }
@@ -2850,6 +3306,7 @@ exports.useRunPolymarketSetup = useRunPolymarketSetup;
 exports.useSearchEvents = useSearchEvents;
 exports.useSimilarEvents = useSimilarEvents;
 exports.useTickSize = useTickSize;
+exports.useTradeResultConfirmation = useTradeResultConfirmation;
 exports.useTrades = useTrades;
 exports.useTradesSubscription = useTradesSubscription;
 exports.useWithdrawBuildMutation = useWithdrawBuildMutation;