@dimes-dot-fi/sdk 1.5.0 → 2.0.1

package/dist/quote-CanwfT9m.d.cts

@@ -0,0 +1,39 @@
+import { H as HintAdjustment } from './dimes-client-DZPhU1CG.cjs';
+import { Q as Quote } from './aliases-BJyM8ydu.cjs';
+
+type Side = "yes" | "no";
+interface QuoteParams {
+    marketTicker: string;
+    side: Side;
+    collateralUsd: number;
+    leverageBps: number;
+    slippageBps: number;
+    /**
+     * Allow the order to fill less than the requested notional (down to `minFillBps`),
+     * opening the position at the actual fill size. Defaults to atomic (fully filled or rejected).
+     */
+    allowPartialFill?: boolean;
+    /** Minimum acceptable fill in basis points. Only valid when `allowPartialFill` is true. */
+    minFillBps?: number;
+}
+interface MarketMovedEvent {
+    originalDraft: Quote;
+    newDraft: Quote;
+    retryCount: number;
+}
+interface QuoteOptions {
+    maxRetries?: number;
+    autoCorrect?: boolean;
+    onDraftReady?: (draft: Quote) => void;
+    onMarketMoved?: (event: MarketMovedEvent) => boolean | undefined;
+    onCorrection?: (adjustment: HintAdjustment) => boolean | undefined;
+}
+interface QuoteResult {
+    quote: Quote;
+    /** @deprecated Renamed to {@link QuoteResult.quote}. Still populated for backward compatibility. */
+    offer: Quote;
+    corrections: HintAdjustment[];
+    retries: number;
+}
+
+export type { MarketMovedEvent as M, QuoteParams as Q, Side as S, QuoteOptions as a, QuoteResult as b };

package/dist/react/index.cjs

@@ -1,10 +1,18 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+var _chunk7SAMK7CScjs = require('../chunk-7SAMK7CS.cjs');
 
-var _chunkY5WQ3UWFcjs = require('../chunk-Y5WQ3UWF.cjs');
 
 
 var _chunk72LTVPD2cjs = require('../chunk-72LTVPD2.cjs');
 
+
+
+var _chunkFAW2C5AMcjs = require('../chunk-FAW2C5AM.cjs');
+require('../chunk-53U53KZ2.cjs');
+
 // src/react/provider.tsx
 var _react = require('react');
 var _jsxruntime = require('react/jsx-runtime');
@@ -35,7 +43,8 @@ function reducer(state, action) {
     case "done":
       return {
         phase: "promoted",
-        offer: action.result.offer,
+        quote: action.result.quote,
+        offer: action.result.quote,
         corrections: action.result.corrections,
         retries: action.result.retries,
         draft: state.draft
@@ -59,7 +68,7 @@ function useQuote() {
     async (params, options) => {
       dispatch({ type: "loading" });
       try {
-        const result = await _chunkY5WQ3UWFcjs.executeQuote.call(void 0, client, params, {
+        const result = await _chunk7SAMK7CScjs.executeQuote.call(void 0, client, params, {
           ...options,
           onDraftReady: (draft) => {
             dispatch({ type: "draftReady", draft });
@@ -89,6 +98,125 @@ function useQuote() {
   return { state, execute, reset };
 }
 
+// src/react/use-quote-machine.ts
+
+var DEFAULT_MAX_RETRIES = 3;
+function reducer2(_state, action) {
+  switch (action.type) {
+    case "loading":
+      return { phase: "loading-draft" };
+    case "draftReady":
+      return { phase: "draft-ready", draft: action.draft, quotedAt: action.quotedAt };
+    case "promoting":
+      return { phase: "promoting", draft: action.draft, quotedAt: action.quotedAt };
+    case "promoted":
+      return {
+        phase: "promoted",
+        draft: action.draft,
+        promotedQuote: action.promotedQuote,
+        correctedFrom: action.correctedFrom,
+        quotedAt: action.quotedAt
+      };
+    case "marketMoved":
+      return {
+        phase: "market-moved",
+        originalDraft: action.originalDraft,
+        newDraft: action.newDraft,
+        retryCount: action.retryCount,
+        quotedAt: action.quotedAt
+      };
+    case "error":
+      return { phase: "error", error: action.error, draft: action.draft };
+    case "reset":
+      return { phase: "idle" };
+    default:
+      return _state;
+  }
+}
+function useQuoteMachine(options) {
+  const client = useDimesClient();
+  const maxRetries = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _7 => _7.maxRetries]), () => ( DEFAULT_MAX_RETRIES));
+  const [state, dispatch] = _react.useReducer.call(void 0, reducer2, { phase: "idle" });
+  const lastParamsRef = _react.useRef.call(void 0, null);
+  const quotedAtRef = _react.useRef.call(void 0, 0);
+  const getDraft = _react.useCallback.call(void 0, 
+    async (params) => {
+      dispatch({ type: "loading" });
+      const quoteParams = _chunk7SAMK7CScjs.buildQuoteParams.call(void 0, params);
+      lastParamsRef.current = quoteParams;
+      try {
+        const draft = await client.createDraftQuote(quoteParams);
+        quotedAtRef.current = Date.now();
+        dispatch({ type: "draftReady", draft, quotedAt: quotedAtRef.current });
+      } catch (err) {
+        dispatch({ type: "error", error: err });
+      }
+    },
+    [client]
+  );
+  const promote = _react.useCallback.call(void 0, 
+    async (draft, retryCount = 0) => {
+      const quotedAt = quotedAtRef.current;
+      dispatch({ type: "promoting", draft, quotedAt });
+      try {
+        const promotedQuote = await client.promoteDraftQuote(draft.id);
+        dispatch({ type: "promoted", draft, promotedQuote, quotedAt });
+      } catch (err) {
+        if (_chunk7SAMK7CScjs.isMarketMovedError.call(void 0, err) && retryCount < maxRetries && lastParamsRef.current) {
+          try {
+            const newDraft = await client.createDraftQuote(lastParamsRef.current);
+            quotedAtRef.current = Date.now();
+            dispatch({
+              type: "marketMoved",
+              originalDraft: draft,
+              newDraft,
+              retryCount: retryCount + 1,
+              quotedAt: quotedAtRef.current
+            });
+          } catch (draftErr) {
+            dispatch({ type: "error", error: draftErr, draft });
+          }
+        } else {
+          dispatch({ type: "error", error: err, draft });
+        }
+      }
+    },
+    [client, maxRetries]
+  );
+  const acceptChanges = _react.useCallback.call(void 0, 
+    async (newDraft, retryCount) => {
+      await promote(newDraft, retryCount);
+    },
+    [promote]
+  );
+  const correctAndPromote = _react.useCallback.call(void 0, 
+    async (originalDraft, adjustedParams) => {
+      dispatch({ type: "promoting", draft: originalDraft, quotedAt: quotedAtRef.current });
+      lastParamsRef.current = adjustedParams;
+      try {
+        const promotedQuote = await client.createQuote(adjustedParams);
+        quotedAtRef.current = Date.now();
+        dispatch({
+          type: "promoted",
+          draft: promotedQuote,
+          promotedQuote,
+          correctedFrom: originalDraft,
+          quotedAt: quotedAtRef.current
+        });
+      } catch (err) {
+        dispatch({ type: "error", error: err });
+      }
+    },
+    [client]
+  );
+  const reset = _react.useCallback.call(void 0, () => {
+    dispatch({ type: "reset" });
+    lastParamsRef.current = null;
+    quotedAtRef.current = 0;
+  }, []);
+  return { state, getDraft, promote, acceptChanges, correctAndPromote, reset };
+}
+
 // src/react/use-markets.ts
 var _reactquery = require('@tanstack/react-query');
 function useMarkets(params, queryOptions) {
@@ -99,6 +227,15 @@ function useMarkets(params, queryOptions) {
     ...queryOptions
   });
 }
+function useSearchMarkets(params, queryOptions) {
+  const client = useDimesClient();
+  return _reactquery.useQuery.call(void 0, {
+    queryKey: ["dimes", "markets", "search", params],
+    queryFn: () => client.searchMarkets(params),
+    enabled: !!params.query,
+    ...queryOptions
+  });
+}
 function useMarket(ticker, queryOptions) {
   const client = useDimesClient();
   return _reactquery.useQuery.call(void 0, {
@@ -111,15 +248,97 @@ function useMarket(ticker, queryOptions) {
 
 // src/react/use-positions.ts
 
-function usePositions(params, queryOptions) {
-  const client = useDimesClient();
-  return _reactquery.useQuery.call(void 0, {
-    queryKey: ["dimes", "positions", params],
-    queryFn: () => client.getPositions(params),
-    ...queryOptions
+
+// src/react/ws-reconcile.ts
+var positionsQueryKey = ["dimes", "positions"];
+var marketsQueryKey = ["dimes", "markets"];
+var defaultReconciliationWindowMs = 12e3;
+var transientPositionStatuses = /* @__PURE__ */ new Set(["pending", "closing", "settling", "unwinding"]);
+var wsPositionTimestamps = /* @__PURE__ */ new Map();
+function mergePositionEvent(queryClient, event, now) {
+  const position = event.data;
+  queryClient.setQueriesData({ queryKey: positionsQueryKey }, (old) => {
+    if (!old) {
+      return old;
+    }
+    const idx = old.findIndex((p) => p.id === position.id);
+    if (idx >= 0) {
+      const next = [...old];
+      next[idx] = position;
+      return next;
+    }
+    if (event.type === "position.created") {
+      return [position, ...old];
+    }
+    return old;
+  });
+  wsPositionTimestamps.set(position.id, now);
+}
+function reconcilePolledPositions(oldData, newData, windowMs, now) {
+  if (!oldData) {
+    return newData;
+  }
+  return newData.map((polled) => {
+    const wsTime = wsPositionTimestamps.get(polled.id);
+    if (wsTime !== void 0 && now - wsTime < windowMs) {
+      const fresher = oldData.find((p) => p.id === polled.id);
+      return _nullishCoalesce(fresher, () => ( polled));
+    }
+    if (wsTime !== void 0) {
+      wsPositionTimestamps.delete(polled.id);
+    }
+    return polled;
+  });
+}
+function mergeMarket(prev, delta) {
+  return {
+    ...prev,
+    ...delta,
+    leverage: delta.leverage ? { ...prev.leverage, ...delta.leverage } : prev.leverage
+  };
+}
+function mergeMarketDeltas(queryClient, deltas) {
+  queryClient.setQueriesData({ queryKey: marketsQueryKey }, (old) => {
+    if (!old) {
+      return old;
+    }
+    const data = old.data.map((market) => {
+      const delta = deltas.find((d) => d.id === market.id);
+      return delta ? mergeMarket(market, delta) : market;
+    });
+    const changed = data.some((market, i) => market !== old.data[i]);
+    return changed ? { ...old, data } : old;
   });
 }
 
+// src/react/use-positions.ts
+var DEFAULT_FAST_POLL_MS = 5e3;
+var DEFAULT_SLOW_POLL_MS = 15e3;
+function adaptiveRefetchInterval(adaptive) {
+  const fastMs = typeof adaptive === "object" ? _nullishCoalesce(adaptive.fastMs, () => ( DEFAULT_FAST_POLL_MS)) : DEFAULT_FAST_POLL_MS;
+  const slowMs = typeof adaptive === "object" ? _nullishCoalesce(adaptive.slowMs, () => ( DEFAULT_SLOW_POLL_MS)) : DEFAULT_SLOW_POLL_MS;
+  return (query) => _optionalChain([query, 'access', _8 => _8.state, 'access', _9 => _9.data, 'optionalAccess', _10 => _10.some, 'call', _11 => _11((p) => transientPositionStatuses.has(p.status))]) ? fastMs : slowMs;
+}
+function reconcileStructuralSharing(reconcile) {
+  const windowMs = typeof reconcile === "number" ? reconcile : defaultReconciliationWindowMs;
+  return (oldData, newData) => reconcilePolledPositions(oldData, newData, windowMs, Date.now());
+}
+function usePositions(params, queryOptions, options) {
+  const client = useDimesClient();
+  const queryKey = _optionalChain([options, 'optionalAccess', _12 => _12.scope]) !== void 0 ? ["dimes", "positions", params, options.scope] : ["dimes", "positions", params];
+  const config = {
+    queryKey,
+    queryFn: () => client.getPositions(params)
+  };
+  if (_optionalChain([options, 'optionalAccess', _13 => _13.adaptivePolling])) {
+    config.refetchInterval = adaptiveRefetchInterval(options.adaptivePolling);
+  }
+  if (_optionalChain([options, 'optionalAccess', _14 => _14.reconcile])) {
+    config.structuralSharing = reconcileStructuralSharing(options.reconcile);
+  }
+  return _reactquery.useQuery.call(void 0, { ...config, ...queryOptions });
+}
+
 // src/react/use-contract-info.ts
 
 function useContractInfo(queryOptions) {
@@ -134,25 +353,204 @@ function useContractInfo(queryOptions) {
 
 // src/react/use-limits.ts
 
-function useLimits(queryOptions) {
+function useUserLimits(queryOptions) {
+  const client = useDimesClient();
+  return _reactquery.useQuery.call(void 0, {
+    queryKey: ["dimes", "user-limits"],
+    queryFn: () => client.getUserLimits(),
+    ...queryOptions
+  });
+}
+function usePartnerLimits(queryOptions) {
   const client = useDimesClient();
   return _reactquery.useQuery.call(void 0, {
-    queryKey: ["dimes", "limits"],
-    queryFn: () => client.getLimits(),
+    queryKey: ["dimes", "partner-limits"],
+    queryFn: () => client.getPartnerLimits(),
     ...queryOptions
   });
 }
+function useLimits(queryOptions) {
+  return useUserLimits(queryOptions);
+}
 
 // src/react/use-cancel-position.ts
 
-function useCancelPosition(mutationOptions) {
+var HTTP_CONFLICT = 409;
+function useCancelPosition(mutationOptions, options) {
   const client = useDimesClient();
+  const treatConflictAsAlreadyCancelling = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _15 => _15.treatConflictAsAlreadyCancelling]), () => ( false));
   return _reactquery.useMutation.call(void 0, {
-    mutationFn: (positionId) => client.cancelPosition(positionId),
+    mutationFn: async (positionId) => {
+      try {
+        await client.cancelPosition(positionId);
+        return "cancelled";
+      } catch (err) {
+        if (treatConflictAsAlreadyCancelling && err instanceof _chunk72LTVPD2cjs.DimesApiError && err.status === HTTP_CONFLICT) {
+          return "already_cancelling";
+        }
+        throw err;
+      }
+    },
     ...mutationOptions
   });
 }
 
+// src/react/use-position-stream.ts
+
+
+function usePositionStream(options) {
+  const client = useDimesClient();
+  const queryClient = _reactquery.useQueryClient.call(void 0, );
+  const socketRef = _react.useRef.call(void 0, null);
+  const [connected, setConnected] = _react.useState.call(void 0, false);
+  const enabled = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _16 => _16.enabled]), () => ( true));
+  const mode = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _17 => _17.mode]), () => ( "reconcile"));
+  const pauseOnHidden = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _18 => _18.pauseOnHidden]), () => ( true));
+  const invalidateOnReconnect = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _19 => _19.invalidateOnReconnect]), () => ( true));
+  const optionsRef = _react.useRef.call(void 0, options);
+  optionsRef.current = options;
+  _react.useEffect.call(void 0, () => {
+    if (!enabled) {
+      return void 0;
+    }
+    const socket = new (0, _chunkFAW2C5AMcjs.PositionSocket)({
+      baseUrl: client.baseUrl,
+      getToken: () => client.getToken()
+    });
+    socketRef.current = socket;
+    const unsubEvent = socket.on("*", (event) => {
+      if (mode === "reconcile") {
+        mergePositionEvent(queryClient, event, Date.now());
+      }
+      _optionalChain([optionsRef, 'access', _20 => _20.current, 'optionalAccess', _21 => _21.onEvent, 'optionalCall', _22 => _22(event)]);
+    });
+    const unsubNotification = socket.onNotification((event) => {
+      _optionalChain([optionsRef, 'access', _23 => _23.current, 'optionalAccess', _24 => _24.onNotification, 'optionalCall', _25 => _25(event)]);
+    });
+    let firstConnect = true;
+    const unsubConnect = socket.onConnect(() => {
+      setConnected(true);
+      if (firstConnect) {
+        firstConnect = false;
+      } else if (mode === "reconcile" && invalidateOnReconnect) {
+        void queryClient.invalidateQueries({ queryKey: positionsQueryKey });
+      }
+      _optionalChain([optionsRef, 'access', _26 => _26.current, 'optionalAccess', _27 => _27.onConnect, 'optionalCall', _28 => _28()]);
+    });
+    const unsubDisconnect = socket.onDisconnect(() => {
+      setConnected(false);
+      _optionalChain([optionsRef, 'access', _29 => _29.current, 'optionalAccess', _30 => _30.onDisconnect, 'optionalCall', _31 => _31()]);
+    });
+    const unsubError = socket.onError((error) => {
+      _optionalChain([optionsRef, 'access', _32 => _32.current, 'optionalAccess', _33 => _33.onError, 'optionalCall', _34 => _34(error)]);
+    });
+    const handleVisibility = pauseOnHidden && typeof document !== "undefined" ? () => {
+      if (document.hidden) {
+        socket.disconnect();
+      } else {
+        socket.connect();
+      }
+    } : null;
+    if (handleVisibility) {
+      document.addEventListener("visibilitychange", handleVisibility);
+    }
+    socket.connect();
+    return () => {
+      if (handleVisibility) {
+        document.removeEventListener("visibilitychange", handleVisibility);
+      }
+      unsubEvent();
+      unsubNotification();
+      unsubConnect();
+      unsubDisconnect();
+      unsubError();
+      socket.disconnect();
+      socketRef.current = null;
+      setConnected(false);
+    };
+  }, [client, queryClient, enabled, mode, pauseOnHidden, invalidateOnReconnect]);
+  return { socket: socketRef.current, connected };
+}
+
+// src/react/use-market-stream.ts
+
+
+function useMarketStream(options) {
+  const client = useDimesClient();
+  const queryClient = _reactquery.useQueryClient.call(void 0, );
+  const socketRef = _react.useRef.call(void 0, null);
+  const [connected, setConnected] = _react.useState.call(void 0, false);
+  const enabled = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _35 => _35.enabled]), () => ( true));
+  const mode = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _36 => _36.mode]), () => ( "reconcile"));
+  const pauseOnHidden = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _37 => _37.pauseOnHidden]), () => ( true));
+  const invalidateOnReconnect = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _38 => _38.invalidateOnReconnect]), () => ( true));
+  const optionsRef = _react.useRef.call(void 0, options);
+  optionsRef.current = options;
+  _react.useEffect.call(void 0, () => {
+    if (!enabled) {
+      return void 0;
+    }
+    const socket = new (0, _chunkFAW2C5AMcjs.MarketSocket)({
+      baseUrl: client.baseUrl,
+      getToken: () => client.getToken()
+    });
+    socketRef.current = socket;
+    const unsubEvent = socket.on("*", (event) => {
+      if (mode === "reconcile" && event.type !== "market.discovered") {
+        mergeMarketDeltas(queryClient, event.data);
+      }
+      _optionalChain([optionsRef, 'access', _39 => _39.current, 'optionalAccess', _40 => _40.onEvent, 'optionalCall', _41 => _41(event)]);
+    });
+    let firstConnect = true;
+    const unsubConnect = socket.onConnect(() => {
+      setConnected(true);
+      if (firstConnect) {
+        firstConnect = false;
+      } else if (mode === "reconcile" && invalidateOnReconnect) {
+        void queryClient.invalidateQueries({ queryKey: marketsQueryKey });
+      }
+      _optionalChain([optionsRef, 'access', _42 => _42.current, 'optionalAccess', _43 => _43.onConnect, 'optionalCall', _44 => _44()]);
+    });
+    const unsubDisconnect = socket.onDisconnect(() => {
+      setConnected(false);
+      _optionalChain([optionsRef, 'access', _45 => _45.current, 'optionalAccess', _46 => _46.onDisconnect, 'optionalCall', _47 => _47()]);
+    });
+    const unsubError = socket.onError((error) => {
+      _optionalChain([optionsRef, 'access', _48 => _48.current, 'optionalAccess', _49 => _49.onError, 'optionalCall', _50 => _50(error)]);
+    });
+    const handleVisibility = pauseOnHidden && typeof document !== "undefined" ? () => {
+      if (document.hidden) {
+        socket.disconnect();
+      } else {
+        socket.connect();
+      }
+    } : null;
+    if (handleVisibility) {
+      document.addEventListener("visibilitychange", handleVisibility);
+    }
+    socket.connect();
+    return () => {
+      if (handleVisibility) {
+        document.removeEventListener("visibilitychange", handleVisibility);
+      }
+      unsubEvent();
+      unsubConnect();
+      unsubDisconnect();
+      unsubError();
+      socket.disconnect();
+      socketRef.current = null;
+      setConnected(false);
+    };
+  }, [client, queryClient, enabled, mode, pauseOnHidden, invalidateOnReconnect]);
+  return { socket: socketRef.current, connected };
+}
+
+
+
+
+
+
+
 
 
 
@@ -162,5 +560,5 @@ function useCancelPosition(mutationOptions) {
 
 
 
-exports.DimesProvider = DimesProvider; exports.useCancelPosition = useCancelPosition; exports.useContractInfo = useContractInfo; exports.useDimesClient = useDimesClient; exports.useLimits = useLimits; exports.useMarket = useMarket; exports.useMarkets = useMarkets; exports.usePositions = usePositions; exports.useQuote = useQuote;
+exports.DimesProvider = DimesProvider; exports.useCancelPosition = useCancelPosition; exports.useContractInfo = useContractInfo; exports.useDimesClient = useDimesClient; exports.useLimits = useLimits; exports.useMarket = useMarket; exports.useMarketStream = useMarketStream; exports.useMarkets = useMarkets; exports.usePartnerLimits = usePartnerLimits; exports.usePositionStream = usePositionStream; exports.usePositions = usePositions; exports.useQuote = useQuote; exports.useQuoteMachine = useQuoteMachine; exports.useSearchMarkets = useSearchMarkets; exports.useUserLimits = useUserLimits;
 //# sourceMappingURL=index.cjs.map