@pear-protocol/utils 1.6.1 → 1.7.0

package/dist/market-reference-price.d.ts

@@ -0,0 +1,52 @@
+/** The reference price a market order is priced from, so it reaches the opposite side of the book (#785). */
+import type { Connector, InstrumentPrecision, Side } from '@pear-protocol/types';
+import { type GridPrice, type PriceRounding } from './precise-price';
+/**
+ * Where a market leg's price starts (#1180):
+ * - `touch`: the opposite side of the book, so a manual order fills even on a wide spread;
+ * - `mid`: the mid, so an automated order never prices past the user's slippage from it.
+ */
+export type MarketPricing = 'touch' | 'mid';
+/** Every origin a market order can be placed from. */
+type MarketOrigin = 'auto-rebalance' | 'copy' | 'direct' | 'manual-rebalance' | 'schedule' | 'trigger' | 'vault-liquidity';
+/** A cached price-feed value with its top of book, either side absent when the feed has not published it. */
+export type MarketQuote = {
+    p: string;
+    bid: string | null;
+    ask: string | null;
+};
+/** The price a market leg's slippage is applied to, and which way to round it onto the grid. */
+export type MarketReference = {
+    price: string;
+    rounding: PriceRounding;
+};
+/**
+ * The limit a market leg is placed at: its reference (the touch or the mid, per `pricing`) padded by the
+ * account's slippage tolerance and rounded onto the venue's price grid. Every market prepare prices a
+ * leg without a caller bound this way, and a close TWAP values its smallest slice at the same limit.
+ */
+export declare function resolveMarketLimitPrice(connector: Connector, quote: MarketQuote, precision: InstrumentPrecision, side: Side, slippageToleranceBps: number, pricing: MarketPricing): GridPrice;
+/**
+ * The price a market leg's slippage is applied to: the best ask for a BUY, the best bid for a SELL.
+ *
+ * The spread is the price of trading now, not slippage, so the limit starts at the touch and the
+ * user's slippage tolerance covers the market moving before the fill. Priced from the mid instead,
+ * a slippage smaller than half the spread cannot reach the book, and the venue rejects the IOC order.
+ * A quote without a usable touch (a mark series, a top of book not yet received, a crossed book)
+ * falls back to the mid, exactly as before.
+ *
+ * A touch already sits on the grid on the far side of the book, so the padded touch rounds inwards
+ * and still reaches it; rounding outwards would add a grid step beyond the slippage. The mid sits
+ * inside the spread, so a mid fallback keeps rounding outwards to cross.
+ */
+export declare function resolveMarketReference(quote: MarketQuote, side: Side, pricing: MarketPricing): MarketReference;
+/**
+ * The pricing an order's origin gets when it opens or adjusts: a person placing a market order wants it
+ * filled, so it reaches the touch; an automated order (a trigger, a schedule slice, an auto-rebalance) is
+ * price-sensitive, so it is bounded at the user's slippage from the mid and simply does not fill across a
+ * wider spread (#1180). A close never asks: it always reaches the touch, because a close that does not fill
+ * leaves the position's risk open, which costs more than the spread. The one exception is a keeper's
+ * vault-liquidity close, bounded at the mid (`closePricingFor`): an unfilled cut leaves the position as it was.
+ */
+export declare function marketPricingFor(origin: MarketOrigin): MarketPricing;
+export {};

package/dist/precise-quantity-with-mode.d.ts

@@ -0,0 +1,21 @@
+/** How a leg's amount becomes a venue quantity. Pure, so every caller sizes a leg by one rule. */
+import type { Connector, InstrumentPrecision, Side } from '@pear-protocol/types';
+/**
+ * Apply venue precision, capping constrained USD additions without changing reductions or explicit quantities.
+ * A USD amount is sized against `referencePrice`, which the caller chooses per path:
+ * - unconstrained: the unpadded mid, never the slippage-padded limit (dividing by the limit would inflate a
+ *   SELL and shrink a BUY), so the planned notional equals the requested amount at the mid;
+ * - constrained (a deadline or any capped leg): the leg's own order limit, so a USD addition that is not
+ *   reduce-only never exceeds its amount at that limit, the budget the caller enforces. A
+ *   reduce-only SELL keeps its upward rounding and may exceed it; a cap below the mid grows a SELL's value
+ *   at the mid, which is the caller's chosen price.
+ * The venue minimum is still the caller's check, at the limit: Hyperliquid does not document
+ * which price its minimum uses, and at the limit a passing order cannot be refused for it.
+ */
+export declare function preciseQuantityWithMode(connector: Connector, leg: {
+    symbol: string;
+    side: Side;
+    mode: 'QUANTITY' | 'USD';
+    amount: string;
+    reduceOnly: boolean;
+}, precision: InstrumentPrecision, referencePrice: string, constrainUsdQuantity?: boolean): string;

package/dist/vaults/action-typed-data.d.ts

@@ -2,7 +2,7 @@
  * Every action a leader-signed route may carry. A new route must add its member
  * here, which forces the typed-data switch below to name it at build time.
  */
-export type LeaderActionName = 'withdraw-to-evm' | 'set-trader' | 'agent-approve' | 'set-unified-account' | 'update-metadata';
+export type LeaderActionName = 'withdraw-to-evm' | 'set-trader' | 'agent-approve' | 'set-unified-account' | 'set-account-mode' | 'update-metadata';
 /**
  * EIP-712 domain for off-chain vault-service auth. `chainId` is pinned to 999
  * (HyperEVM) by the shared contract — signing is offline, so there is no chain
@@ -78,6 +78,21 @@ export declare const VAULT_ACTION_TYPES: {
             readonly type: "uint256";
         }];
     };
+    readonly 'set-account-mode': {
+        readonly SetAccountMode: readonly [{
+            readonly name: "vault";
+            readonly type: "address";
+        }, {
+            readonly name: "mode";
+            readonly type: "string";
+        }, {
+            readonly name: "nonce";
+            readonly type: "string";
+        }, {
+            readonly name: "deadline";
+            readonly type: "uint256";
+        }];
+    };
     readonly 'update-metadata': {
         readonly UpdateVaultMetadata: readonly [{
             readonly name: "vault";
@@ -149,6 +164,7 @@ export type LeaderActionTypedData = {
         name?: string;
         about?: string;
         imageUri?: string;
+        mode?: string;
         nonce: string;
         deadline: bigint;
     };
@@ -161,6 +177,7 @@ export type LeaderActionTypedData = {
  *  - token    = body.tokenId ?? '0', verbatim string (withdraw only)
  *  - trader   = body.traderAddress, checksummed (set-trader only)
  *  - name / about / imageUri = the full display set, verbatim strings; '' means cleared (update-metadata only)
+ *  - mode     = body.mode, verbatim string (set-account-mode only)
  *  - nonce    = body.nonce (client-generated; salts the signature for idempotency)
  *  - deadline = body.deadline (unix seconds) as uint256
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pear-protocol/utils",
-  "version": "1.6.1",
+  "version": "1.7.0",
   "description": "Pear Protocol Utility functions",
   "private": false,
   "type": "module",
@@ -27,7 +27,7 @@
   },
   "dependencies": {
     "@noble/hashes": "^1.3.2",
-    "@pear-protocol/types": "^2.25.0",
+    "@pear-protocol/types": "^2.27.0",
     "@scure/base": "^2.3.0",
     "bignumber.js": "9.3.1"
   },

package/dist/sync/applicables/basket.d.ts

@@ -1,39 +0,0 @@
-/**
- * Detecting baskets — grouping raw external fills into the orders they were
- * placed as, each combined into per-symbol legs with FIFO queues for splitting
- * across positions.
- */
-import type { HttpTypes, Side } from '@pear-protocol/types';
-import type { FillPart } from './types';
-/**
- * A detected order: its legs combined by symbol+side. Legs carry per-source FIFO
- * queues, so {@link CombinedLeg.take} can split a single exchange fill across
- * several positions.
- */
-export declare class Basket {
-    readonly legs: CombinedLeg[];
-    readonly fills: HttpTypes.UnknownExternalFill[];
-    private constructor();
-    /** Detect baskets from a fill stream, returned in ascending time order. */
-    static detect(fills: HttpTypes.UnknownExternalFill[]): Basket[];
-}
-/**
- * One combined symbol+side leg of a basket. Owns the per-source FIFO queue, so
- * taking quantity from the leg (splitting fills across positions) is a method on
- * its own state instead of an outside helper mutating a plain object.
- */
-export declare class CombinedLeg {
-    readonly symbol: string;
-    readonly side: Side;
-    private _totalSize;
-    private readonly queue;
-    constructor(symbol: string, side: Side);
-    get totalSize(): BigNumber;
-    /** Append a fill to this leg's queue and grow the total size. */
-    addFill(fill: HttpTypes.UnknownExternalFill): void;
-    /**
-     * Take `qty` of fill slices from this leg (FIFO across source fills, consumes the queue).
-     * Returns the parts taken, which are consumed from the queue.
-     */
-    take(qty: BigNumber): FillPart[];
-}

package/dist/sync/applicables/constants.d.ts

@@ -1,26 +0,0 @@
-import type { HttpTypes } from '@pear-protocol/types';
-import type { BasketRule } from './types';
-/**
- * Float-precision dust floor. Exchange quantities are exact decimal strings and the
- * whole matcher is BigNumber, so a real full close nets to exact zero. This floor only
- * absorbs sub-1e-8 dust that a stray float (anywhere upstream) could leave behind —
- * without it, that dust keeps a position "open", so a later reopen of the same pair
- * merges in and every lifecycle collapses onto one position. NOT a per-instrument
- * tolerance: a genuine partial close (>= 1e-8) stays open, as it should.
- */
-export declare const DUST: BigNumber;
-/**
- * How long before an open position's creation a fill may still belong to it. Fills can
- * reach sync out of order by seconds across cycles (observed up to ~30s), so a strict
- * cutoff would split one position in two; anything older predates the position and must
- * not be replayed into it (see pear-protocol/backend#1067).
- */
-export declare const LATE_FILL_GRACE_MS: number;
-export declare const MISSED_HISTORY_FILL_PREFIX = "opening-synthetic-";
-export declare const BASKET_RULES: BasketRule[];
-/**
- * True when `cloid` is a Pear-originated cloid for the given connector.
- * A missing or empty cloid is always false; connector-specific prefix rules
- * are applied via the `PEAR_CLOID_CHECK` table.
- */
-export declare function isPearCloid(connector: HttpTypes.Connector, cloid: string | null | undefined): boolean;

package/dist/sync/applicables/exposure.d.ts

@@ -1,39 +0,0 @@
-import type { Side, SignedDecimalString } from '@pear-protocol/types';
-import type { FillPart } from './types';
-/**
- * Signed per-asset exposure of a position — the running `symbol -> quantity` book
- * (BUY positive, SELL negative). Wraps the raw map so the signed-quantity math, the
- * exact-zero closure rule, and leg-set queries live in one place instead of scattered helpers.
- *
- * Mutable by design: the matcher mutates a working position's exposure in place while
- * replaying fills. Use {@link clone} when a caller needs an independent copy.
- */
-export declare class Exposure {
-    private readonly legs;
-    private constructor();
-    /** Create an exposure with no legs — the starting state for a new position. */
-    static empty(): Exposure;
-    /** Build from a wire `Record<symbol, quantity>` (existing DB position exposure). */
-    static fromRecord(record: Record<string, string>): Exposure;
-    /** Net signed exposure a set of fill parts contributes for `symbol` (BUY +, SELL −). */
-    static netFromParts(parts: FillPart[], symbol: string): BigNumber;
-    /** Return an independent copy of this exposure so mutations do not alias. */
-    clone(): Exposure;
-    /** Signed exposure for `symbol` (0 when absent). */
-    get(symbol: string): BigNumber;
-    /** Apply a signed `delta` to `symbol`, creating the leg if it does not exist. */
-    addDelta(symbol: string, delta: BigNumber): void;
-    /** Convert a side+quantity pair to a signed delta and forward to `addDelta`. */
-    addSigned(symbol: string, quantity: string, side: Side): void;
-    /** Active (non-zero) long and short leg sets. */
-    activeLegs(): {
-        longs: Set<string>;
-        shorts: Set<string>;
-    };
-    /** True when every leg is exactly zero (a fully CLOSED position). */
-    isAllZero(): boolean;
-    /** All symbols with a leg, including zeroed ones (a closed leg still carries cost basis). */
-    symbols(): string[];
-    /** Canonical signed-string view for the wire (`+0` for zero). */
-    toSigned(): Record<string, SignedDecimalString>;
-}

package/dist/sync/applicables/fills.d.ts

@@ -1,3 +0,0 @@
-import type { HttpTypes } from '@pear-protocol/types';
-/** Format one canonical source receipt without changing its quantity or fees. */
-export declare function sourceToApplicableFill(fill: HttpTypes.UnknownExternalFill, connector: HttpTypes.Connector): HttpTypes.ApplicableFill;

package/dist/sync/applicables/index.d.ts

@@ -1,37 +0,0 @@
-/**
- * Turn a batch of external fills into `applicables` — fill baskets the server
- * find-or-creates into positions.
- *
- * Each fill is processed against the currently open positions, oldest first:
- *   1. reduce opposing positions in creation order,
- *   2. consume each opposing leg before opening its remainder,
- *   3. else merge the leftover into an open position already holding those legs, or open a new one.
- * A fill can be split across several positions when it closes more than one.
- *
- * Once fills are assigned, one synthetic per asset covers any remaining gap to the
- * exchange snapshot (the source of truth). Position exposure is NOT computed here —
- * the server sums the assigned fills; the opening cost basis (initialExposureUSD) is
- * derived per position from its own real fills and carried in `metadata`.
- *
- * Pipeline: snapshot → add missed-history fills → match → align with exchange → assemble.
- * Diff outcomes: discover (new fill), gap (residual vs snapshot), gone (netted to zero)
- */
-import type { HttpTypes } from '@pear-protocol/types';
-/**
- * Build the `applicables` bucket: baskets of fills (real + synthetic) keyed by a
- * deterministic positionKey, plus creation metadata. Positions are derived by
- * replaying fills through dynamic matching (oldest-first cross-
- * position close, subset-merge of leftover opens), so same-asset exposure
- * consolidates instead of fragmenting per basket symbol-set.
- */
-export declare function buildApplicables(args: {
-    tradeAccountId: string;
-    connector: HttpTypes.Connector;
-    orphanFills: HttpTypes.UnknownExternalFill[];
-    openPositions: HttpTypes.OpenPositionLite[];
-    entryBySymbol: Record<string, string>;
-    exchangePositions: HttpTypes.ExternalPosition[];
-}): {
-    fills: HttpTypes.ApplicableFill[];
-    applicables: HttpTypes.ApplicablePosition[];
-};

package/dist/sync/applicables/matching.d.ts

@@ -1,20 +0,0 @@
-import type { HttpTypes } from '@pear-protocol/types';
-import type { PearHoldings } from './snapshot';
-import type { MatchedPosition } from './types';
-/**
- * Replay external fills to decide which position each fill slice belongs to. Flow :
- *   - applyCloses reduces holders (the oldest eligible position first),
- *   - resolveLeftoverTarget merges into a position whose FULL leg set (active and
- *     dormant) is exactly the leftover's, else opens new (same-shape ADDs consolidate here).
- * The asset SET of a position never grows, so positionKey == key(opening symbols).
- *
- * Every phase only sees positions that already existed when the basket happened: a
- * basket older than an open position's creation (beyond LATE_FILL_GRACE_MS) cannot
- * close, reduce or merge into it, so a late-fetched earlier lifecycle is not bound to a
- * position opened after it (pear-protocol/backend#1067).
- */
-export declare function matchPositions(args: {
-    tradeAccountId: string;
-    orphanFills: HttpTypes.UnknownExternalFill[];
-    pear: PearHoldings;
-}): MatchedPosition[];

package/dist/sync/applicables/position.d.ts

@@ -1,19 +0,0 @@
-/**
- * Builds the final `ApplicablePosition` output — folds assigned synthetics into
- * exposure, derives status/origin/metadata.
- */
-import type { HttpTypes } from '@pear-protocol/types';
-import type { MatchedPosition, NeededSynthetic } from './types';
-/**
- * Assemble canonical receipts once and position assignments separately, dropping
- * unchanged positions that produced no fills.
- */
-export declare function assembleApplicables(args: {
-    positions: MatchedPosition[];
-    connector: HttpTypes.Connector;
-    synthByPosition: Map<MatchedPosition, NeededSynthetic[]>;
-    now: number;
-}): {
-    fills: HttpTypes.ApplicableFill[];
-    applicables: HttpTypes.ApplicablePosition[];
-};

package/dist/sync/applicables/snapshot.d.ts

@@ -1,41 +0,0 @@
-import type { HttpTypes } from '@pear-protocol/types';
-/**
- * The exchange position snapshot — the enforced source of truth for exposure. Wraps the
- * per-symbol lookup so callers ask `snapshot.signedSize(symbol)` instead of threading a
- * raw map plus a sign helper.
- */
-export declare class ExchangeSnapshot {
-    private readonly bySymbol;
-    private constructor();
-    /** Index `positions` by symbol for O(1) lookup. */
-    static from(positions: HttpTypes.ExternalPosition[]): ExchangeSnapshot;
-    /** Raw exchange position for `symbol`, or `undefined` when the exchange holds nothing. */
-    get(symbol: string): HttpTypes.ExternalPosition | undefined;
-    /** Signed exchange exposure for `symbol` (0 when the exchange has no position). */
-    signedSize(symbol: string): BigNumber;
-    /** All symbols the exchange currently reports a position for. */
-    symbols(): string[];
-}
-/**
- * What Pear's DB currently holds for one connector — the open positions, filtered
- * once, plus the per-symbol views the synthetic steps need.
- */
-export declare class PearHoldings {
-    private readonly filtered;
-    private constructor();
-    /** Filter `openPositions` to the given connector and wrap. */
-    static from(args: {
-        openPositions: HttpTypes.OpenPositionLite[];
-        connector: HttpTypes.Connector;
-    }): PearHoldings;
-    /** The open Pear positions for this connector. */
-    positions(): HttpTypes.OpenPositionLite[];
-    /** Sum existing open Pear exposure per symbol. */
-    totalBySymbol(): Map<string, BigNumber>;
-    /**
-     * Which open DB position holds each active asset — the fallback target for a
-     * synthetic when no matched position already carries that asset. First open
-     * position with a non-zero leg wins per symbol.
-     */
-    positionBySymbol(): Map<string, HttpTypes.OpenPositionLite>;
-}

package/dist/sync/applicables/synthetics.d.ts

@@ -1,53 +0,0 @@
-/**
- * Everything synthetic lives here — the missed-history fills added before matching,
- * the per-asset check against the exchange afterwards, and the assignment of each
- * needed synthetic to one position.
- */
-import type { HttpTypes, Side } from '@pear-protocol/types';
-import type { ExchangeSnapshot, PearHoldings } from './snapshot';
-import type { MatchedPosition, NeededSynthetic } from './types';
-/** True when an external fill was minted by the missed-history pass (its id carries the prefix). */
-export declare function isMissedHistoryFill(fill: HttpTypes.UnknownExternalFill): boolean;
-/**
- * The exchange only returns recent fills — anything older is invisible to us.
- * This adds stand-in (synthetic) fills covering that missed history, so the
- * matcher replays the correct running exposure from the start. Returns the
- * complete fill list, oldest first.
- */
-export declare function addFillsForMissedHistory(args: {
-    orphanFills: HttpTypes.UnknownExternalFill[];
-    pear: PearHoldings;
-    connector: HttpTypes.Connector;
-    entryBySymbol: Record<string, string>;
-    snapshot: ExchangeSnapshot;
-}): HttpTypes.UnknownExternalFill[];
-/**
- * Compare what we now hold per asset with what the exchange says, and create one
- * correcting synthetic per asset that is off — assigned to exactly one position
- * (creating the position if none holds that asset). This is the safety net for
- * residual drift, the only discovery path when no fills were fetched at all
- * (e.g. first sync of an account whose fill history is beyond the fetch window),
- * and the only close path for positions the exchange dropped without any fill
- * activity this cycle. Returns the position list (extended with any created
- * positions) plus the synthetics per position — the input array is never mutated.
- */
-export declare function alignPositionsWithExchange(args: {
-    positions: MatchedPosition[];
-    pear: PearHoldings;
-    snapshot: ExchangeSnapshot;
-    tradeAccountId: string;
-}): {
-    positions: MatchedPosition[];
-    synthByPosition: Map<MatchedPosition, NeededSynthetic[]>;
-};
-/** Build the content-addressed synthetic fill for a position lifecycle/asset/side. */
-export declare function buildSyntheticFill(args: {
-    positionKey: string;
-    lifecycleStartedAt: number | null;
-    connector: HttpTypes.Connector;
-    symbol: string;
-    side: Side;
-    quantity: string;
-    timestamp: number;
-    closedReason?: HttpTypes.PositionClosedReason;
-}): HttpTypes.ApplicableFill;

package/dist/sync/applicables/types.d.ts

@@ -1,82 +0,0 @@
-import type { HttpTypes, Side } from '@pear-protocol/types';
-import type { CombinedLeg } from './basket';
-import type { Exposure } from './exposure';
-/**
- * A basket-detection rule. Fills for which `matches` is true AND that produce the same
- * `key` are grouped into one basket. Rules are tried in order; the first match wins. A
- * fill matching no rule falls back to the default (its own exchangeFillId), so it never
- * groups with anything else.
- */
-export type BasketRule = {
-    matches: (fill: HttpTypes.UnknownExternalFill) => boolean;
-    key: (fill: HttpTypes.UnknownExternalFill) => string;
-};
-/**
- * A slice of a source external fill assigned to one virtual position. A single
- * external fill can be split across positions (e.g. a SELL that closes two open
- * longs), so each slice tracks its source for fill-id and fee derivation.
- */
-export type FillPart = {
-    source: HttpTypes.UnknownExternalFill;
-    quantity: string;
-};
-/**
- * A working position the matcher builds while replaying fills.
- * Mutable mid-replay — its `exposure` is updated in place as fills land.
- */
-export type WorkingPosition = {
-    positionKey: string;
-    createdAt: number;
-    orderId: string;
-    exposure: Exposure;
-    parts: FillPart[];
-    closed: boolean;
-    /** Origin of the seeded existing position; undefined for positions opened mid-replay. */
-    existingOrigin?: HttpTypes.PositionOrigin;
-    /**
-     * Earliest basket time (ms) this position may take fills from: its creation minus the
-     * late-fill grace for a seeded position, -Infinity for one opened mid-replay.
-     */
-    liveFrom: number;
-};
-/** A matched position that received fill slices, ready to become an applicable. */
-export type MatchedPosition = {
-    positionKey: string;
-    parts: FillPart[];
-    /** Lifecycle ended within this batch (exposure returned to zero). */
-    closed: boolean;
-    /**
-     * Exposure after replaying real fills (existing position + applied part deltas).
-     * Does NOT yet include the correcting synthetics from the align step — assembly
-     * folds those in to get the final exposure.
-     */
-    exposure: Exposure;
-    /** Origin of the seeded existing position; undefined when this applicable creates a position. */
-    existingOrigin?: HttpTypes.PositionOrigin;
-    /**
-     * When this lifecycle of the position key began (ms): the stored creation time of a seeded
-     * position, else the earliest fill this replay assigned to it. Null for a position the align
-     * step mints from the snapshot alone — no fill or stored row dates that lifecycle.
-     */
-    lifecycleStartedAt: number | null;
-};
-/** One combined leg that could not be closed against existing exposure — an open. */
-export type Leftover = {
-    side: Side;
-    qty: BigNumber;
-    leg: CombinedLeg;
-};
-/** A per-asset difference vs the exchange: 'gone' = exchange no longer has the asset, 'gap' = quantities differ. */
-export type ExposureGap = {
-    kind: 'gone' | 'gap';
-    symbol: string;
-    side: Side;
-    quantity: string;
-};
-/** A synthetic fill the server needs to mint for an asset, plus where to attach it. */
-export type NeededSynthetic = {
-    symbol: string;
-    side: Side;
-    quantity: string;
-    closedReason?: HttpTypes.PositionClosedReason;
-};

package/dist/sync/compute.d.ts

@@ -1,28 +0,0 @@
-import { type HttpTypes } from '@pear-protocol/types';
-import type { ComputeSyncPayloadArgs, ComputeSyncPayloadResult } from './types';
-/**
- * Derive the full sync payload from raw exchange data and local state.
- *
- * Async without internal awaits — the Promise signature is part of the public
- * API consumed by exchanges-sdk, so it stays.
- */
-export declare function computeSyncPayload(args: ComputeSyncPayloadArgs): Promise<ComputeSyncPayloadResult | null>;
-/**
- * Validate, normalise, deduplicate, and filter raw external fills.
- * Fills with invalid ids/quantities/timestamps or already-confirmed ids are dropped.
- * Duplicates (same exchangeFillId) keep the earliest timestamp; result is ascending-sorted.
- */
-export declare function _prepareExternalFills(externalFills: HttpTypes.UnknownExternalFill[], confirmedExchangeFillIdsInput: string[]): HttpTypes.UnknownExternalFill[];
-/**
- * Drop external fills whose cloid is claimed by a provisional fill we own.
- * The server-side syncer owns confirming those fills; the client applies orphans only.
- */
-export declare function _excludeClaimedFills(provisionalFills: HttpTypes.ProvisionalFill[], externalFills: HttpTypes.UnknownExternalFill[]): HttpTypes.UnknownExternalFill[];
-/** Trim a cloid; empty or whitespace-only collapses to undefined. */
-export declare function _normalizeCloid(cloid?: string | null): string | undefined;
-/** Normalise an exchange fill id: trim + lowercase; absent or blank → undefined. */
-export declare function _normalizeExchangeFillId(exchangeFillId?: string | null): string | undefined;
-/** Rejects scientific-notation quantities (e.g. 1e-8) that cannot be safely parsed as fills. */
-export declare function _isValidExternalQuantity(quantity: string): boolean;
-/** Returns true only when the timestamp is a non-negative finite number no further than clock skew ahead of now. */
-export declare function _isValidExternalTimestamp(timestamp: number): boolean;

package/dist/sync/cutoff.d.ts

@@ -1,35 +0,0 @@
-/**
- * First-sync history cutoff selection.
- *
- * An account's first sync fetches a fill history that can reach back through many
- * finished lifecycles; replaying all of it would resurrect long-closed positions.
- * This module replays the history BACKWARD from the exchange snapshot (the source
- * of truth for current exposure) and picks the most recent boundary where the
- * account was EXACTLY flat, so everything before it can be dropped. Seeding from
- * the snapshot means a truncated history — a position opened before the fetched
- * window — leaves a residual at every boundary and never produces a fake cutoff.
- */
-import type { HttpTypes } from '@pear-protocol/types';
-/** Trim decision: keep `fills.slice(keepFromIndex)`; `fills.length` trims everything. */
-export type FirstSyncCutoff = {
-    keepFromIndex: number;
-};
-/**
- * Selects the first-sync cutoff boundary from an ascending-sorted, prepared fill
- * history and the current exchange snapshot.
- *
- * Boundary i is the account state BEFORE fills[i] (boundary fills.length is the
- * snapshot itself). A boundary qualifies when every leg of the backward-replayed
- * book is exactly zero (BigNumber-exact — the DUST tolerance does NOT apply) and
- * the boundary is not inside a same-millisecond fill group (Hyperliquid merges
- * feeds whose same-ms order is not execution order). On Hyperliquid the cutoff is
- * additionally capped at the first Pear-placed fill so it is always kept.
- *
- * Returns null to keep everything: empty history, no qualifying boundary, or the
- * qualifying boundary is 0 (a cutoff of 0 trims nothing, so it canonicalizes to null).
- */
-export declare function selectFirstSyncCutoff(args: {
-    fills: HttpTypes.UnknownExternalFill[];
-    exchangePositions: HttpTypes.ExternalPosition[];
-    connector: HttpTypes.Connector;
-}): FirstSyncCutoff | null;

package/dist/sync/index.d.ts

@@ -1,3 +0,0 @@
-export { buildApplicables } from './applicables';
-export { computeSyncPayload } from './compute';
-export type { ComputeSyncPayloadArgs, ComputeSyncPayloadResult } from './types';

package/dist/sync/types.d.ts

@@ -1,25 +0,0 @@
-import type { HttpTypes } from '@pear-protocol/types';
-export type ComputeSyncPayloadArgs = {
-    tradeAccountId: string;
-    connector: HttpTypes.Connector;
-    openPositions: HttpTypes.OpenPositionLite[];
-    entryBySymbol: Record<string, string>;
-    provisionalFills: HttpTypes.ProvisionalFill[];
-    confirmedExchangeFillIds: string[];
-    externalFills: HttpTypes.UnknownExternalFill[];
-    exchangePositions: HttpTypes.ExternalPosition[];
-    neverSynced: boolean;
-};
-export type ComputeSyncPayloadResult = {
-    fills: HttpTypes.ApplicableFill[];
-    applicables: HttpTypes.ApplicablePosition[];
-    exchangePositions: HttpTypes.ExternalPosition[];
-    meta: {
-        externalMaxTs: number | null;
-    };
-    firstSyncTrim: {
-        cutoffTs: number | null;
-        trimmedCount: number;
-        trimmedMaxTs: number;
-    } | null;
-};