@0xmonaco/react 1.0.55 → 1.0.56

package/dist/coverage.d.ts

@@ -78,6 +78,7 @@ export declare const INTENTIONALLY_EXCLUDED: {
     get_portfolio_stats: string;
     get_portfolio_summary: string;
     get_screener: string;
+    get_sweeper_chains: string;
     get_sub_account_limits: string;
     get_trade_by_id: string;
     get_trading_pair_by_id: string;

package/dist/coverage.js

@@ -78,6 +78,7 @@ export const INTENTIONALLY_EXCLUDED = {
     get_portfolio_stats: "Portfolio analytics endpoint; no React hook yet.",
     get_portfolio_summary: "Authoritative portfolio analytics is available through @0xmonaco/core; no dedicated React hook in this release.",
     get_screener: "Market lookup available via the core client / list+symbol hooks; no dedicated React hook.",
+    get_sweeper_chains: "Sweeper chain/asset listing; deposit-onboarding data available via the core client, not a UI action. No React hook.",
     get_sub_account_limits: "Sub-account administration; no React hook.",
     get_trade_by_id: "Trade-history lookup with a core client method but no dedicated React hook yet.",
     get_trading_pair_by_id: "Market lookup available via the core client / list+symbol hooks; no dedicated React hook.",

package/dist/hooks/useUserBalances/useUserBalances.d.ts

@@ -13,13 +13,9 @@ export declare function updateBalanceFromEvent(balance: AccountBalance, event: U
  * - A held asset the snapshot omits has no balance left, so it is zeroed rather
  *   than left showing a figure that is no longer true. The row itself stays —
  *   a portfolio needs to render "0 WSEI", not to lose the line.
- * - The snapshot's totals are taken VERBATIM. A snapshot row is built from the
- *   same accounts-service read that produced the REST row, so its `total`
- *   already is the REST `totalBalance` with margin collateral included —
- *   unlike a live event, whose `total` can describe the spot balance alone and
- *   therefore needs {@link updateBalanceFromEvent}'s margin reconciliation.
- *   Running a snapshot row through that would add the derived margin component
- *   a second time.
+ * - The snapshot's totals and durable spot-row version are taken VERBATIM.
+ *   A snapshot row is built from the same `user_balances` state as REST and a
+ *   versioned live event. Margin collateral is not part of this row.
  * - A row for an asset the list does not hold cannot be completed here: the
  *   wire payload carries no `assetId`, `decimals` or wrapped-native flag. That
  *   case is reported by {@link snapshotHasUnknownAsset} rather than from here,
@@ -60,6 +56,16 @@ export declare function snapshotHasUnknownAsset(current: AccountBalance[], items
  * second is a deliberate "give me the server's answer" action.
  */
 export declare function reconcileBalances(current: AccountBalance[], fetched: AccountBalance[]): AccountBalance[];
+/**
+ * Merge a deliberate REST refresh without letting its response roll back a
+ * versioned live row that arrived while the request was in flight.
+ *
+ * Version zero is the backward-compatible representation of an unversioned
+ * REST row. It may refresh other legacy state, but cannot replace a known
+ * producer-versioned row. A known versioned row omitted by the response is
+ * retained because its authoritative zero would be an explicit tombstone.
+ */
+export declare function mergeBalanceRefresh(current: AccountBalance[], fetched: AccountBalance[]): AccountBalance[];
 /**
  * Overlay buffered wire state onto rows a REST read has just supplied metadata
  * for.
@@ -72,15 +78,67 @@ export declare function reconcileBalances(current: AccountBalance[], fetched: Ac
  * takes the update path. Buffering the newest wire state for an unheld token
  * and laying it over the row once metadata arrives is what closes that.
  *
- * Only entries newer than the read are applied. One buffered BEFORE the read
- * started is already reflected in its result, and re-applying it would roll the
- * row back to that older value.
+ * Eligibility is NOT one rule, and the split is the point:
+ *
+ * - a RANKED frame always replays. It carries a version, so
+ *   `updateBalanceFromData` can compare and reject it if the row is genuinely
+ *   newer. Gating it on arrival instead would drop it whenever persistence
+ *   lags — a read STARTED after the frame was buffered can still return an
+ *   older version — and dropping it deletes the buffer entry, leaving the
+ *   stale row installed with nothing left to correct it.
+ * - an UNRANKED frame has nothing to compare against and applies fail-open, so
+ *   arrival position is the only thing that can tell whether the read already
+ *   reflects it. Re-applying one it does reflect rolls the row back.
+ *
+ * For that second rule the mark is the point the read was ASKED for, not the
+ * point it starts: a frame that asks for a read has already advanced the
+ * sequence past where the read begins, so measuring from the start would
+ * exclude the very frame the read exists to place.
  */
-export declare function applyBufferedBalances(rows: AccountBalance[], buffered: Map<string, {
+export type BufferedFrame = {
     data: UserBalanceEventData;
+    /**
+     * Arrival position of THIS payload. Orders it against the other slot on
+     * replay, so a retained frame keeps the place it actually arrived in.
+     */
     seq: number;
+    /**
+     * Most recent arrival for this slot, retained payload or not. Used ONLY for
+     * read eligibility: it answers "did anything land for this token after the
+     * in-flight read was asked for", which is a different question from "where
+     * does this payload sit in the sequence". Collapsing the two let a retained
+     * frame inherit a later arrival's position and replay out of order.
+     */
+    latestSeq: number;
     source: "event" | "snapshot";
-}>, readSeq: number): AccountBalance[];
+};
+/**
+ * Wire state held for a token the list cannot apply yet.
+ *
+ * THREE kinds of frame arrive here and none supersedes another, so each keeps
+ * its own slot and they replay together in arrival order:
+ *
+ * - a RANKED spot frame carries a real version and describes whole-row state,
+ *   so ranking orders it against other ranked frames;
+ * - an UNRANKED SNAPSHOT is still the whole authoritative row — its totals are
+ *   taken verbatim — it simply came from a producer that does not stamp
+ *   versions yet;
+ * - an UNRANKED LIVE notification (margin, funding, a legacy producer) carries
+ *   no version, applies fail-open, and DERIVES its total from the row it lands
+ *   on so a margin component survives.
+ *
+ * One slot for everything let the ranking rule discard whichever kind arrived
+ * second. One slot for both unranked kinds was the same bug a level down: a
+ * funding notification overwrote the snapshot baseline, and its derivation
+ * then ran against whatever the REST row happened to carry instead of against
+ * the row the snapshot established.
+ */
+export type BufferedUnheld = {
+    ranked?: BufferedFrame;
+    unrankedSnapshot?: BufferedFrame;
+    unrankedEvent?: BufferedFrame;
+};
+export declare function applyBufferedBalances(rows: AccountBalance[], buffered: Map<string, BufferedUnheld>, readSeq: number): AccountBalance[];
 /**
  * Hook for subscribing to real-time user balance updates via WebSocket (authenticated)
  *

package/dist/hooks/useUserBalances/useUserBalances.js

@@ -53,11 +53,54 @@ async function readAllBalances(profile) {
  * Update an AccountBalance with data from a WebSocket balance event
  */
 export function updateBalanceFromEvent(balance, event) {
-    return updateBalanceFromData(balance, event.data);
+    return updateBalanceFromData(balance, event.data, "event");
 }
-function updateBalanceFromData(balance, data) {
-    const totalBalance = totalBalanceFromData(balance, data);
-    const totalBalanceRaw = totalBalanceRawFromData(balance, data);
+/**
+ * Collapse every shape of "unranked" to 0 so callers can compare numerically.
+ *
+ * `AccountBalance.version` is optional, and a REST response from a server that
+ * predates the field carries no version at all — so the type now says what the
+ * runtime does. That is exactly why every read goes through here rather than
+ * comparing the field: `undefined <= 710` is false in BOTH directions, so an
+ * un-normalized guard does not fail loudly, it silently passes and lets a
+ * stale row win. Absent, null, non-finite and an explicit 0 all mean the same
+ * thing.
+ */
+function rankedVersion(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+function updateBalanceFromData(balance, data, source) {
+    // Legacy live margin notifications remain fail-open. A legacy snapshot,
+    // however, cannot order against an already-versioned spot row and therefore
+    // must not replace it.
+    // An explicit `version: 0` is the documented legacy sentinel and means the
+    // same thing as an omitted one: unranked. Checking only for `undefined` let a
+    // version-0 snapshot overwrite a held real version and reset it to 0, after
+    // which later stale spot frames would win.
+    if (source === "snapshot" && rankedVersion(data.version) === 0 && rankedVersion(balance.version) > 0) {
+        return balance;
+    }
+    // Version 0 is the unranked sentinel on both sides, so it orders nothing:
+    // rank only when the incoming frame and the held row each carry a real
+    // version. Otherwise a version-0 REST row rejects a version-0 subscribe
+    // snapshot that carries newer amounts, which is exactly the rolling-deploy
+    // case where an older producer has not started stamping yet.
+    const incomingRank = rankedVersion(data.version);
+    const heldRank = rankedVersion(balance.version);
+    if (incomingRank > 0 && heldRank > 0 && incomingRank <= heldRank) {
+        return balance;
+    }
+    // The margin-preserving derivation belongs to UNRANKED live notifications
+    // only. A snapshot is the whole row by definition, so it takes `total`
+    // verbatim whether or not it carries a version — deriving from it would add a
+    // previously held margin component back on top of a figure that already
+    // accounts for everything, turning a snapshot total of 1000 into 1250.
+    //
+    // Unranked means absent OR the explicit 0 sentinel: both describe a frame
+    // that reports the spot leg alone, so both need the reconciliation.
+    const derivesTotal = source === "event" && rankedVersion(data.version) === 0;
+    const totalBalance = derivesTotal ? totalBalanceFromData(balance, data) : data.total;
+    const totalBalanceRaw = derivesTotal ? totalBalanceRawFromData(balance, data) : data.totalRaw;
     return {
         ...balance,
         availableBalance: data.available,
@@ -66,6 +109,17 @@ function updateBalanceFromData(balance, data) {
         lockedBalanceRaw: data.lockedRaw,
         totalBalance: totalBalance,
         totalBalanceRaw: totalBalanceRaw,
+        // An unranked frame is a margin collateral notification or a legacy
+        // producer, and by scope it must not touch the spot ranking dimension:
+        // margin frames stay unranked and fail open. Writing the sentinel onto the
+        // row would drop it out of the ranked dimension, and the NEXT stale spot
+        // frame would then pass the ordering guard — trading a spot-ordering
+        // guarantee for a margin problem that shared token-keyed rows cause and
+        // that a dedicated margin identity resolves.
+        //
+        // `??` is not the test: an explicit `0` is the documented sentinel and is
+        // not nullish, so it would be written through as if it were a real rank.
+        version: rankedVersion(data.version) > 0 ? data.version : balance.version,
     };
 }
 /**
@@ -77,13 +131,9 @@ function updateBalanceFromData(balance, data) {
  * - A held asset the snapshot omits has no balance left, so it is zeroed rather
  *   than left showing a figure that is no longer true. The row itself stays —
  *   a portfolio needs to render "0 WSEI", not to lose the line.
- * - The snapshot's totals are taken VERBATIM. A snapshot row is built from the
- *   same accounts-service read that produced the REST row, so its `total`
- *   already is the REST `totalBalance` with margin collateral included —
- *   unlike a live event, whose `total` can describe the spot balance alone and
- *   therefore needs {@link updateBalanceFromEvent}'s margin reconciliation.
- *   Running a snapshot row through that would add the derived margin component
- *   a second time.
+ * - The snapshot's totals and durable spot-row version are taken VERBATIM.
+ *   A snapshot row is built from the same `user_balances` state as REST and a
+ *   versioned live event. Margin collateral is not part of this row.
  * - A row for an asset the list does not hold cannot be completed here: the
  *   wire payload carries no `assetId`, `decimals` or wrapped-native flag. That
  *   case is reported by {@link snapshotHasUnknownAsset} rather than from here,
@@ -98,6 +148,10 @@ export function applyBalanceSnapshot(current, items) {
     const balances = current.map((held) => {
         const item = byToken.get(held.token.toLowerCase());
         if (!item) {
+            // Since versioned zero rows are explicit tombstones, omission cannot
+            // safely zero a known versioned row. Retain it until a newer row arrives.
+            if (rankedVersion(held.version) > 0)
+                return held;
             return {
                 ...held,
                 availableBalance: "0",
@@ -108,15 +162,7 @@ export function applyBalanceSnapshot(current, items) {
                 totalBalanceRaw: "0",
             };
         }
-        return {
-            ...held,
-            availableBalance: item.available,
-            lockedBalance: item.locked,
-            totalBalance: item.total,
-            availableBalanceRaw: item.availableRaw,
-            lockedBalanceRaw: item.lockedRaw,
-            totalBalanceRaw: item.totalRaw,
-        };
+        return updateBalanceFromData(held, item, "snapshot");
     });
     return { balances, hasUnknownAsset: snapshotHasUnknownAsset(current, items) };
 }
@@ -155,43 +201,70 @@ export function reconcileBalances(current, fetched) {
     return added.length === 0 ? current : [...current, ...added];
 }
 /**
- * Overlay buffered wire state onto rows a REST read has just supplied metadata
- * for.
- *
- * A frame naming a token the list does not hold yet is dropped by the event
- * handler — there is no row to apply it to — and the repair read that follows
- * may have queried the server BEFORE that frame. Appending its result would
- * then leave the token at a value the stream has already moved past, with no
- * later frame to correct it because every subsequent frame finds a row and
- * takes the update path. Buffering the newest wire state for an unheld token
- * and laying it over the row once metadata arrives is what closes that.
+ * Merge a deliberate REST refresh without letting its response roll back a
+ * versioned live row that arrived while the request was in flight.
  *
- * Only entries newer than the read are applied. One buffered BEFORE the read
- * started is already reflected in its result, and re-applying it would roll the
- * row back to that older value.
+ * Version zero is the backward-compatible representation of an unversioned
+ * REST row. It may refresh other legacy state, but cannot replace a known
+ * producer-versioned row. A known versioned row omitted by the response is
+ * retained because its authoritative zero would be an explicit tombstone.
  */
+export function mergeBalanceRefresh(current, fetched) {
+    const currentByToken = new Map(current.map((row) => [row.token.toLowerCase(), row]));
+    const fetchedTokens = new Set();
+    const merged = fetched.map((incoming) => {
+        const token = incoming.token.toLowerCase();
+        fetchedTokens.add(token);
+        const held = currentByToken.get(token);
+        if (!held)
+            return incoming;
+        const heldVersion = rankedVersion(held.version);
+        if (heldVersion > 0 && rankedVersion(incoming.version) <= heldVersion)
+            return held;
+        return incoming;
+    });
+    for (const held of current) {
+        // `rankedVersion` is defensive consistency here rather than a behavior
+        // change: `undefined > 0` is already false, so an unranked held row is
+        // dropped either way. Kept so every version read in this file goes through
+        // one rule.
+        if (rankedVersion(held.version) > 0 && !fetchedTokens.has(held.token.toLowerCase()))
+            merged.push(held);
+    }
+    return merged;
+}
 export function applyBufferedBalances(rows, buffered, readSeq) {
     if (buffered.size === 0)
         return rows;
     return rows.map((row) => {
         const entry = buffered.get(row.token.toLowerCase());
-        if (!entry || entry.seq <= readSeq)
+        if (!entry)
             return row;
-        if (entry.source === "event") {
-            // A live non-margin frame can carry spot total only. Replaying it as a
-            // snapshot would replace the REST row's margin component instead of
-            // preserving it through the ordinary event reconciliation.
-            return updateBalanceFromData(row, entry.data);
-        }
-        return {
-            ...row,
-            availableBalance: entry.data.available,
-            lockedBalance: entry.data.locked,
-            totalBalance: entry.data.total,
-            availableBalanceRaw: entry.data.availableRaw,
-            lockedBalanceRaw: entry.data.lockedRaw,
-            totalBalanceRaw: entry.data.totalRaw,
-        };
+        // Replay in ARRIVAL order and apply each with its own source semantics:
+        // whichever kind landed last is what the client would have seen had the row
+        // been known.
+        const frames = [entry.ranked, entry.unrankedSnapshot, entry.unrankedEvent]
+            .filter((frame) => {
+            if (frame === undefined)
+                return false;
+            // A RANKED frame always replays. The read-start gate assumes anything
+            // buffered before the read is already reflected in its result, and that
+            // is false here: persistence is asynchronous, so a read started later
+            // can still return an OLDER version. Skipping the frame would then
+            // delete it and leave the stale row installed. It carries a version, so
+            // `updateBalanceFromData` can compare and reject it if the row is
+            // genuinely newer — which is strictly safer than guessing from arrival.
+            if (rankedVersion(frame.data.version) > 0)
+                return true;
+            // An UNRANKED frame has nothing to compare against, so the request
+            // mark is the only thing stopping a re-apply of state the read already
+            // includes. It applies fail-open by design — a margin or funding
+            // notification is not ordered against the spot row — so replaying one
+            // the read already reflects would roll the row back.
+            return frame.latestSeq > readSeq;
+        })
+            .sort((a, b) => a.seq - b.seq);
+        return frames.reduce((acc, frame) => updateBalanceFromData(acc, frame.data, frame.source), row);
     });
 }
 function parseDecimal(value) {
@@ -313,9 +386,24 @@ export function useUserBalances() {
      * newer than every frame that set it.
      */
     const repairDirty = useRef(false);
+    /**
+     * Buffer position the next repair read must be measured from.
+     *
+     * A read is measured from the point it was ASKED for, not the point it
+     * starts. Those differ every time: a frame is buffered and only then does it
+     * request the read, and a read coalesced behind an in-flight one does not
+     * start until frames later than its request have landed. Measuring from the
+     * start excluded every frame that asked for the read — including the single
+     * frame that is the whole reason the buffer exists — because its own entry
+     * had already advanced the sequence past the mark.
+     *
+     * Coalesced requests keep the EARLIEST mark, so the one trailing read
+     * replays every frame that asked for it.
+     */
+    const repairSince = useRef(null);
     /**
      * Newest wire state for tokens the list does not hold yet, with a monotonic
-     * sequence so a read can tell which entries postdate it. Cleared per token
+     * sequence so a read can tell which entries postdate the request for it. Cleared per token
      * once a read has supplied that token's metadata; entries for tokens a read
      * did not return stay buffered for the next one.
      */
@@ -325,16 +413,55 @@ export function useUserBalances() {
     const [error, setError] = useState(null);
     const [subscribed, setSubscribed] = useState(false);
     const clearError = useCallback(() => setError(null), []);
-    /** Remember a frame for a token the list cannot represent yet. */
+    /**
+     * Remember a frame for a token the list cannot represent yet.
+     *
+     * Returns the buffer position from BEFORE anything was recorded, which is
+     * the mark the read these frames are about to ask for must be measured
+     * from.
+     */
     const bufferUnheld = useCallback((items, source) => {
+        const before = bufferSeq.current;
         const held = new Set(balancesRef.current.map((row) => row.token.toLowerCase()));
         for (const item of items) {
             const token = item.tokenAddress.toLowerCase();
             if (held.has(token))
                 continue;
             bufferSeq.current += 1;
-            bufferedUnheld.current.set(token, { data: item, seq: bufferSeq.current, source });
+            // Route by KIND, not by rank alone. A ranked spot frame orders against
+            // other ranked frames; an unranked live notification cannot be ordered
+            // against anything, so it occupies its own slot rather than losing to —
+            // or evicting — a buffered spot frame.
+            const existing = bufferedUnheld.current.get(token) ?? {};
+            const seq = bufferSeq.current;
+            const incomingVersion = rankedVersion(item.version);
+            const next = incomingVersion > 0
+                ? {
+                    ...existing,
+                    // Equal ranked versions are the same state, so the first stands.
+                    // Only the watermark advances — rewriting its `seq` would move the
+                    // retained payload behind an unranked frame that arrived earlier.
+                    ranked: rankedVersion(existing.ranked?.data.version) >= incomingVersion && existing.ranked
+                        ? { ...existing.ranked, latestSeq: seq }
+                        : { data: item, seq, latestSeq: seq, source },
+                }
+                : source === "snapshot"
+                    ? {
+                        ...existing,
+                        // Nothing orders two unranked snapshots, so the latest stands —
+                        // but it must not evict a live notification, whose derivation
+                        // needs the baseline this establishes.
+                        unrankedSnapshot: { data: item, seq, latestSeq: seq, source },
+                    }
+                    : {
+                        ...existing,
+                        // Nothing can order two unranked notifications, so the latest
+                        // arrival stands.
+                        unrankedEvent: { data: item, seq, latestSeq: seq, source },
+                    };
+            bufferedUnheld.current.set(token, next);
         }
+        return before;
     }, []);
     /**
      * Apply a new list, reducing against the ref rather than through a functional
@@ -362,13 +489,15 @@ export function useUserBalances() {
      * event arriving while the request is in flight is overwritten by the older
      * response.
      */
-    const loadBalances = useCallback(async (mode) => {
+    const loadBalances = useCallback(async (mode, sinceSeq) => {
         if (!sdk?.profile)
             return;
         const generation = readGeneration.current;
-        // Captured where the read starts: only frames buffered AFTER this point
-        // are newer than what the response will carry.
-        const readSeq = bufferSeq.current;
+        // The point this read was ASKED for. Only frames buffered after it can
+        // be newer than what the response will carry; a frame that asked for
+        // this read is by definition one of them. Reads nobody asked for — the
+        // initial load, a manual refresh — are measured from where they start.
+        const readSeq = sinceSeq ?? bufferSeq.current;
         // A read belonging to a previous client must not write ANY of this state
         // — not the rows, not the error, not the loading flag. Clearing `loading`
         // from a stale request would mark the hook loaded while the new client's
@@ -389,7 +518,7 @@ export function useUserBalances() {
                 const repaired = applyBufferedBalances(fetched, bufferedUnheld.current, readSeq);
                 for (const row of fetched)
                     bufferedUnheld.current.delete(row.token.toLowerCase());
-                applyBalances(mode === "replace" ? repaired : (prev) => reconcileBalances(prev, repaired));
+                applyBalances(mode === "replace" ? (prev) => mergeBalanceRefresh(prev, repaired) : (prev) => reconcileBalances(prev, repaired));
             }
         }
         catch (err) {
@@ -428,7 +557,10 @@ export function useUserBalances() {
          * live, so the response is already potentially stale by the time it lands
          * — and coalesces, so a burst of frames for an unheld token costs one read.
          */
-        const refetch = () => {
+        const refetch = (sinceSeq) => {
+            // Keep the EARLIEST mark asked for: the read that eventually runs has to
+            // replay every frame that requested it, not just the last one's.
+            repairSince.current = repairSince.current === null ? sinceSeq : Math.min(repairSince.current, sinceSeq);
             // Already reading: remember that something asked again, so the trailing
             // read below picks up whatever those frames carried.
             if (repairInFlight.current) {
@@ -445,7 +577,11 @@ export function useUserBalances() {
             const generation = readGeneration.current;
             repairInFlight.current = true;
             repairDirty.current = false;
-            loadBalances("reconcile")
+            // Consumed here rather than on completion: frames that land while this
+            // read runs belong to the trailing read, and must set a fresh mark.
+            const readSeq = repairSince.current ?? bufferSeq.current;
+            repairSince.current = null;
+            loadBalances("reconcile", readSeq)
                 .catch((err) => {
                 if (!cancelled) {
                     setError(err instanceof Error ? err : new Error(String(err)));
@@ -460,7 +596,7 @@ export function useUserBalances() {
                 // which every request made so far is subsumed. Clearing it in both
                 // places would read as two rules for one thing.
                 if (repairDirty.current && !cancelled)
-                    refetch();
+                    refetch(repairSince.current ?? bufferSeq.current);
             });
         };
         fetchBalances()
@@ -479,8 +615,7 @@ export function useUserBalances() {
                     if (!held && !cancelled) {
                         // The updater below cannot apply this frame — there is no row
                         // for it — so hold it until the read supplies one.
-                        bufferUnheld([event.data], "event");
-                        refetch();
+                        refetch(bufferUnheld([event.data], "event"));
                     }
                     applyBalances((prev) => {
                         // Find by token address and update (case-insensitive for addresses)
@@ -509,8 +644,7 @@ export function useUserBalances() {
                     if (snapshotHasUnknownAsset(balancesRef.current, items) && !cancelled) {
                         // Held before the read is issued, so a frame the read predates
                         // is not lost when its row finally appears.
-                        bufferUnheld(items, "snapshot");
-                        refetch();
+                        refetch(bufferUnheld(items, "snapshot"));
                     }
                     applyBalances((prev) => applyBalanceSnapshot(prev, items).balances);
                 });
@@ -534,6 +668,7 @@ export function useUserBalances() {
             readGeneration.current += 1;
             repairInFlight.current = false;
             repairDirty.current = false;
+            repairSince.current = null;
             bufferedUnheld.current = new Map();
             setSubscribed(false);
         };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@0xmonaco/react",
-	"version": "1.0.55",
+	"version": "1.0.56",
 	"type": "module",
 	"homepage": "https://docs.0xmonaco.com/sdk/typescript",
 	"main": "./dist/index.js",
@@ -16,8 +16,8 @@
 		"lint": "biome lint ."
 	},
 	"dependencies": {
-		"@0xmonaco/core": "1.0.55",
-		"@0xmonaco/types": "1.0.55"
+		"@0xmonaco/core": "1.0.56",
+		"@0xmonaco/types": "1.0.56"
 	},
 	"devDependencies": {
 		"@types/react": "^19.1.12",