@pear-protocol/utils 1.5.0 → 1.6.1

package/dist/index.js

@@ -1288,35 +1288,43 @@ BigNumber7.config({
   DECIMAL_PLACES: 30,
   ROUNDING_MODE: BigNumber7.ROUND_DOWN
 });
-function preciseQuantity(connector, raw, precision, side) {
+function preciseQuantity(connector, raw, precision, side, rounding = "side") {
+  const roundingMode = resolveRoundingMode2(side, rounding);
   switch (connector) {
     case "hyperliquid":
-      return preciseHyperliquidQuantity(raw, precision, side);
+      return preciseHyperliquidQuantity(raw, precision, roundingMode);
     case "binance":
     case "bybit":
     case "okx":
     case "lighter":
     case "lighter_rhc":
-      return preciseStepGridQuantity(raw, precision, side);
+      return preciseStepGridQuantity(raw, precision, roundingMode);
   }
 }
 __name(preciseQuantity, "preciseQuantity");
-function preciseHyperliquidQuantity(raw, precision, side) {
+function resolveRoundingMode2(side, rounding) {
+  if (rounding === "floor") {
+    return BigNumber7.ROUND_FLOOR;
+  }
+  return side === "BUY" ? BigNumber7.ROUND_FLOOR : BigNumber7.ROUND_CEIL;
+}
+__name(resolveRoundingMode2, "resolveRoundingMode");
+function preciseHyperliquidQuantity(raw, precision, roundingMode) {
   const decimals = precision.quantity.decimals;
   const quantity = new BigNumber7(raw);
-  const rounded = quantity.decimalPlaces(decimals, side === "BUY" ? BigNumber7.ROUND_FLOOR : BigNumber7.ROUND_CEIL);
+  const rounded = quantity.decimalPlaces(decimals, roundingMode);
   return rounded.toFixed();
 }
 __name(preciseHyperliquidQuantity, "preciseHyperliquidQuantity");
-function preciseStepGridQuantity(raw, precision, side) {
+function preciseStepGridQuantity(raw, precision, roundingMode) {
   const step = precision.quantity.step;
   const contractQuantity = baseToContracts(raw, precision.quantity.contractSize);
   const stepBN = new BigNumber7(step);
   const scaled = contractQuantity.div(stepBN);
-  const rounded = side === "BUY" ? scaled.integerValue(BigNumber7.ROUND_FLOOR) : scaled.integerValue(BigNumber7.ROUND_CEIL);
+  const rounded = scaled.integerValue(roundingMode);
   const result = rounded.times(stepBN);
   const maxDecimals = precision.quantity.decimals;
-  const final = result.decimalPlaces(maxDecimals, side === "BUY" ? BigNumber7.ROUND_FLOOR : BigNumber7.ROUND_CEIL);
+  const final = result.decimalPlaces(maxDecimals, roundingMode);
   return final.toFixed();
 }
 __name(preciseStepGridQuantity, "preciseStepGridQuantity");
@@ -1429,8 +1437,8 @@ function requestedBaseQuantity(leg, referencePrice) {
   }
 }
 __name(requestedBaseQuantity, "requestedBaseQuantity");
-function isRefusedBelowMinimum(quantity, price, precision, heldByAnotherPosition) {
-  if (!heldByAnotherPosition) {
+function isRefusedBelowMinimum(quantity, price, precision, isPartialVenueReduce) {
+  if (!isPartialVenueReduce) {
     return false;
   }
   const minQuantity = precision.quantity.min;
@@ -1490,14 +1498,6 @@ var Basket = class _Basket {
   static detect(fills) {
     return groupFillsIntoBaskets(fills).map((group) => new _Basket(combineFillsBySymbolAndSide(group), group));
   }
-  /** Active long symbol set the matcher compares against open positions. */
-  get longs() {
-    return new Set(this.legs.filter((leg) => leg.side === "BUY").map((leg) => leg.symbol));
-  }
-  /** Active short symbol set the matcher compares against open positions. */
-  get shorts() {
-    return new Set(this.legs.filter((leg) => leg.side === "SELL").map((leg) => leg.symbol));
-  }
 };
 var CombinedLeg = class {
   static {
@@ -1649,15 +1649,6 @@ var Exposure = class _Exposure {
       shorts
     };
   }
-  /** True once every leg sits within DUST of zero (effectively closed). */
-  isFlat() {
-    for (const qty of this.legs.values()) {
-      if (isGreaterThanOrEqual(qty.abs(), DUST)) {
-        return false;
-      }
-    }
-    return true;
-  }
   /** True when every leg is exactly zero (a fully CLOSED position). */
   isAllZero() {
     for (const qty of this.legs.values()) {
@@ -1667,18 +1658,6 @@ var Exposure = class _Exposure {
     }
     return true;
   }
-  /**
-  * Snap every non-zero leg to exactly zero. Called once a position is flat so it
-  * reads CLOSED (all-zero exposure) and never lingers in the open list with stray
-  * dust that a later reopen of the same pair could merge into.
-  */
-  snapToZero() {
-    for (const [symbol, qty] of this.legs) {
-      if (!qty.isZero()) {
-        this.legs.set(symbol, ZERO);
-      }
-    }
-  }
   /** All symbols with a leg, including zeroed ones (a closed leg still carries cost basis). */
   symbols() {
     return [
@@ -1727,7 +1706,7 @@ function buildSyntheticFill(args) {
   return {
     // Content-addressed id — no wall-clock, no positionId, so re-syncs collide
     // on the dedup index and synthetic generation stays idempotent.
-    exchangeFillId: `synthetic-${args.positionKey}-${args.symbol}-${args.side}`,
+    exchangeFillId: syntheticFillId(args),
     cloid: null,
     connector: args.connector,
     symbol: args.symbol,
@@ -1750,6 +1729,13 @@ function buildSyntheticFill(args) {
   };
 }
 __name(buildSyntheticFill, "buildSyntheticFill");
+function syntheticFillId(args) {
+  if (args.lifecycleStartedAt === null) {
+    return `synthetic-${args.positionKey}-${args.symbol}-${args.side}`;
+  }
+  return `synthetic-${args.positionKey}-${args.lifecycleStartedAt}-${args.symbol}-${args.side}`;
+}
+__name(syntheticFillId, "syntheticFillId");
 function buildMissedHistoryFills(args) {
   const { orphanFills, pear, connector, entryBySymbol, snapshot } = args;
   const fillTotals = /* @__PURE__ */ new Map();
@@ -1858,7 +1844,7 @@ function findNeededSynthetics(args) {
           symbol: gap.symbol,
           side: gap.side,
           quantity: gap.quantity,
-          closedReason: "NETTED"
+          closedReason: "USER"
         });
         break;
       case "gap":
@@ -1894,20 +1880,22 @@ function assignSyntheticsToPositions(args) {
       if (!target) {
         target = existing ? (
           // seed its exposure and origin so folding the synthetic yields the true
-          // final state (a gone-close nets to zero -> CLOSED/NETTED, a gap writes
+          // final state (a gone-close nets to zero -> CLOSED/USER, a gap writes
           // the full total, not just the delta).
           {
             positionKey,
             parts: [],
             closed: false,
             exposure: Exposure.fromRecord(existing.exposure),
-            existingOrigin: existing.origin
+            existingOrigin: existing.origin,
+            lifecycleStartedAt: Date.parse(existing.createdAt)
           }
         ) : {
           positionKey,
           parts: [],
           closed: false,
-          exposure: Exposure.empty()
+          exposure: Exposure.empty(),
+          lifecycleStartedAt: null
         };
         created.push(target);
       }
@@ -1977,11 +1965,9 @@ function matchPositions(args) {
   for (const basket of Basket.detect(orphanFills)) {
     const at = basketTime(basket);
     book.foldIntoLive(at);
-    const exactCloseTarget = findExactCloseTarget(book.live(at), basket.longs, basket.shorts);
     const leftover = applyCloses({
       legs: basket.legs,
       book,
-      exactCloseTarget,
       at
     });
     if (leftover.length === 0) {
@@ -2025,6 +2011,8 @@ var WorkingBook = class WorkingBook2 {
         // A partial fill on the original order leaves exposure short of the
         // symbols the key was hashed from, so a recomputed key would never match.
         positionKey: p.positionKey,
+        createdAt: Date.parse(p.createdAt),
+        orderId: p.id,
         exposure: Exposure.fromRecord(p.exposure),
         parts: [],
         closed: false,
@@ -2043,9 +2031,9 @@ var WorkingBook = class WorkingBook2 {
       symbols
     });
   }
-  /** Working positions open and already existing at basket time `at`, in insertion order. */
+  /** Working positions open and already existing at basket time `at`, in creation order. */
   live(at) {
-    return this.all.filter((position) => !position.closed && position.liveFrom <= at);
+    return this.all.filter((position) => !position.closed && position.liveFrom <= at).sort((a, b) => a.createdAt - b.createdAt || a.orderId.localeCompare(b.orderId));
   }
   /** Look up a position open and existing at `at` by its positionKey (for dedup on merge). */
   findLiveByKey(key, at) {
@@ -2073,9 +2061,11 @@ var WorkingBook = class WorkingBook2 {
     }
   }
   /** Register a fresh empty working position under `key` and return it. */
-  create(key) {
+  create(key, createdAt) {
     const position = {
       positionKey: key,
+      createdAt,
+      orderId: key,
       exposure: Exposure.empty(),
       parts: [],
       closed: false,
@@ -2085,12 +2075,11 @@ var WorkingBook = class WorkingBook2 {
     this.all.push(position);
     return position;
   }
-  /** Flip a position to closed once every leg is within DUST of zero. */
+  /** Flip a position to closed once every leg is exactly zero. */
   markClosedIfFlat(position) {
-    if (position.closed || !position.exposure.isFlat()) {
+    if (position.closed || !position.exposure.isAllZero()) {
       return;
     }
-    position.exposure.snapToZero();
     position.closed = true;
   }
   /** Working positions that received fills become MatchedPosition records; untouched ones are dropped. */
@@ -2100,22 +2089,13 @@ var WorkingBook = class WorkingBook2 {
       parts: position.parts,
       closed: position.closed,
       exposure: position.exposure,
-      existingOrigin: position.existingOrigin
+      existingOrigin: position.existingOrigin,
+      lifecycleStartedAt: position.createdAt
     }));
   }
 };
-function findExactCloseTarget(openList, basketLongs, basketShorts) {
-  return openList.find((position) => {
-    const { longs, shorts } = position.exposure.activeLegs();
-    return setEq(longs, basketShorts) && setEq(shorts, basketLongs);
-  });
-}
-__name(findExactCloseTarget, "findExactCloseTarget");
-var setEq = /* @__PURE__ */ __name((a, b) => a.size === b.size && [
-  ...a
-].every((x) => b.has(x)), "setEq");
 function applyCloses(args) {
-  const { legs, book, exactCloseTarget, at } = args;
+  const { legs, book, at } = args;
   const openList = book.live(at);
   const leftover = [];
   for (const leg of legs) {
@@ -2128,9 +2108,6 @@ function applyCloses(args) {
       }
       return closeTargetIsLong ? qty.isPositive() : qty.isNegative();
     });
-    if (exactCloseTarget) {
-      holders.sort((a, b) => a === exactCloseTarget ? -1 : b === exactCloseTarget ? 1 : 0);
-    }
     for (const position of holders) {
       if (isLessThanOrEqual(remaining, ZERO)) {
         break;
@@ -2142,7 +2119,7 @@ function applyCloses(args) {
       remaining = remaining.minus(reduce);
       book.markClosedIfFlat(position);
     }
-    if (isGreaterThanOrEqual(remaining, DUST)) {
+    if (isGreaterThan(remaining, ZERO)) {
       leftover.push({
         side: leg.side,
         qty: remaining,
@@ -2173,143 +2150,99 @@ function resolveLeftoverTarget(args) {
     ])
   ];
   const positionKey = book.keyFor(symbols);
-  return book.findLiveByKey(positionKey, at) ?? book.create(positionKey);
+  return book.findLiveByKey(positionKey, at) ?? book.create(positionKey, at);
 }
 __name(resolveLeftoverTarget, "resolveLeftoverTarget");
 function applyLeftover(target, leftover) {
   for (const entry of leftover) {
-    target.parts.push(...entry.leg.take(entry.qty));
+    const parts = entry.leg.take(entry.qty);
+    target.parts.push(...parts);
+    if (target.existingOrigin === void 0) {
+      target.createdAt = Math.min(...target.parts.map((part) => part.source.timestamp));
+      target.orderId = target.parts.filter((part) => part.source.timestamp === target.createdAt).map((part) => part.source.exchangeFillId).sort()[0] ?? target.positionKey;
+    }
     target.exposure.addSigned(entry.leg.symbol, entry.qty.toFixed(), entry.side);
   }
 }
 __name(applyLeftover, "applyLeftover");
+function setEq(a, b) {
+  return a.size === b.size && [
+    ...a
+  ].every((symbol) => b.has(symbol));
+}
+__name(setEq, "setEq");
 
 // src/sync/applicables/fills.ts
-function assignPartIds(positions) {
-  const bySource = /* @__PURE__ */ new Map();
-  for (const pos of positions) {
-    for (const part of pos.parts) {
-      const list = bySource.get(part.source.exchangeFillId) ?? [];
-      list.push(part);
-      bySource.set(part.source.exchangeFillId, list);
-    }
-  }
-  const resolution = /* @__PURE__ */ new Map();
-  for (const [sourceId, parts] of bySource) {
-    const single = parts.length === 1 ? parts[0] : void 0;
-    if (single && isEqualTo(single.quantity, single.source.quantity)) {
-      resolution.set(single, {
-        exchangeFillId: sourceId
-      });
-      continue;
-    }
-    parts.forEach((part, i) => {
-      resolution.set(part, {
-        exchangeFillId: `${sourceId}-p${i}`,
-        original: {
-          exchangeFillId: sourceId,
-          quantity: part.source.quantity
-        }
-      });
-    });
-  }
-  return (part) => {
-    const id = resolution.get(part);
-    if (!id) {
-      throw new Error("applicables: fill part was never assigned an id");
-    }
-    return id;
-  };
-}
-__name(assignPartIds, "assignPartIds");
-function partToApplicableFill(part, id, connector, liquidationOutcome) {
-  const fill = part.source;
-  const base = {
-    exchangeFillId: id.exchangeFillId,
+function sourceToApplicableFill(fill, connector) {
+  const synthetic = isMissedHistoryFill(fill);
+  return {
+    exchangeFillId: fill.exchangeFillId,
     connector,
     symbol: fill.symbol,
     side: fill.side,
-    quantity: part.quantity,
+    quantity: fill.quantity,
     price: fill.price,
-    usd: multiply(part.quantity, fill.price).toFixed(),
-    timestamp: fill.timestamp
+    usd: multiply(fill.quantity, fill.price).toFixed(),
+    timestamp: fill.timestamp,
+    cloid: synthetic ? null : fill.cloid ?? null,
+    reduceOnly: synthetic ? false : fill.reduceOnly,
+    synthetic,
+    isExternal: synthetic || !isPearCloid(connector, fill.cloid),
+    tradeFee: synthetic ? "0" : fill.tradeFee,
+    builderFee: synthetic ? "0" : fill.builderFee,
+    liquidation: synthetic ? null : fill.liquidation
   };
-  if (isMissedHistoryFill(fill)) {
-    return {
-      ...base,
-      cloid: null,
-      reduceOnly: false,
-      synthetic: true,
-      isExternal: true,
-      tradeFee: "0",
-      builderFee: "0",
-      liquidation: null
-    };
-  }
-  const fromPear = isPearCloid(connector, fill.cloid);
-  return {
-    ...base,
-    cloid: fill.cloid ?? null,
-    reduceOnly: fill.reduceOnly,
-    synthetic: false,
-    isExternal: !fromPear,
-    tradeFee: feeShareForPart(fill.tradeFee, part.quantity, fill.quantity),
-    builderFee: feeShareForPart(fill.builderFee, part.quantity, fill.quantity),
-    liquidation: fill.liquidation ? {
-      mark: fill.liquidation.mark,
-      outcome: liquidationOutcome ?? void 0
-    } : null,
-    ...id.original ? {
-      original: id.original
-    } : {}
-  };
-}
-__name(partToApplicableFill, "partToApplicableFill");
-function feeShareForPart(totalFee, partQty, sourceQty) {
-  if (isEqualTo(partQty, sourceQty)) {
-    return totalFee;
-  }
-  if (isZero(sourceQty)) {
-    return "0";
-  }
-  const feeShare = divide(multiply(totalFee, partQty), sourceQty);
-  return feeShare.toFixed();
 }
-__name(feeShareForPart, "feeShareForPart");
+__name(sourceToApplicableFill, "sourceToApplicableFill");
 
 // src/sync/applicables/position.ts
 function assembleApplicables(args) {
   const { positions, connector, synthByPosition, now } = args;
-  const partIdFor = assignPartIds(positions);
+  const fillsById = /* @__PURE__ */ new Map();
   const applicables = [];
   for (const pos of positions) {
-    const applicable = assembleOneApplicable(pos, connector, partIdFor, synthByPosition.get(pos) ?? [], now);
+    const applicable = assembleOneApplicable(pos, connector, fillsById, synthByPosition.get(pos) ?? [], now);
     if (applicable) {
       applicables.push(applicable);
     }
   }
-  return applicables;
+  return {
+    fills: [
+      ...fillsById.values()
+    ].sort((a, b) => a.timestamp - b.timestamp || a.exchangeFillId.localeCompare(b.exchangeFillId)),
+    applicables
+  };
 }
 __name(assembleApplicables, "assembleApplicables");
-function assembleOneApplicable(pos, connector, partIdFor, assignedSynthetics, now) {
-  const { realFills, closedReason } = finalizeRealFills(pos, connector, partIdFor);
+function assembleOneApplicable(pos, connector, fillsById, assignedSynthetics, now) {
+  const { realFills, assignments, closedReason } = finalizeRealFills(pos, connector);
   const syntheticFills = assignedSynthetics.map((synthetic) => buildSyntheticFill({
     positionKey: pos.positionKey,
+    lifecycleStartedAt: pos.lifecycleStartedAt,
     connector,
     timestamp: anchorSyntheticTimestamp(realFills, synthetic.symbol, now),
     ...synthetic
   }));
-  const fills = [
-    ...realFills,
-    ...syntheticFills
-  ].sort((a, b) => a.timestamp - b.timestamp);
-  if (fills.length === 0) {
+  for (const part of pos.parts) {
+    fillsById.set(part.source.exchangeFillId, sourceToApplicableFill(part.source, connector));
+  }
+  for (const fill of syntheticFills) {
+    fillsById.set(fill.exchangeFillId, fill);
+    assignments.push({
+      exchangeFillId: fill.exchangeFillId,
+      quantity: fill.quantity
+    });
+  }
+  if (realFills.length === 0 && syntheticFills.length === 0) {
     return null;
   }
   const exposure = finalExposure(pos, assignedSynthetics);
   const closed = exposure.isAllZero();
   const status = closed ? "CLOSED" : "OPEN";
-  const origin = mergeOrigin(pos.existingOrigin, fills);
+  const origin = mergeOrigin(pos.existingOrigin, [
+    ...realFills,
+    ...syntheticFills
+  ]);
   return {
     positionKey: pos.positionKey,
     exposure: exposure.toSigned(),
@@ -2318,32 +2251,46 @@ function assembleOneApplicable(pos, connector, partIdFor, assignedSynthetics, no
     ...closed ? {
       closedReason
     } : {},
-    fills,
+    assignments: assignments.sort((a, b) => (fillsById.get(a.exchangeFillId)?.timestamp ?? 0) - (fillsById.get(b.exchangeFillId)?.timestamp ?? 0)),
     metadata: buildMetadata(new Set(exposure.symbols()), realFills)
   };
 }
 __name(assembleOneApplicable, "assembleOneApplicable");
-function finalizeRealFills(position, connector, partIdFor) {
+function finalizeRealFills(position, connector) {
   const newestFirst = [
     ...position.parts
   ].sort((a, b) => a.source.timestamp - b.source.timestamp).reverse();
   const exposure = position.exposure.clone();
   const realFills = [];
-  let closedReason = "NETTED";
+  const assignments = [];
+  let closedReason = "USER";
   for (const [index, part] of newestFirst.entries()) {
     const after = exposure.get(part.source.symbol);
-    const flatAfter = exposure.isFlat();
+    const flatAfter = exposure.isAllZero();
     exposure.addDelta(part.source.symbol, negate(signedBySide(part.quantity, part.source.side)));
     const reducesLeg = isGreaterThan(exposure.get(part.source.symbol).abs(), after.abs());
     const liquidationOutcome = part.source.liquidation && reducesLeg ? flatAfter ? "CLOSED" : "REDUCED" : null;
     if (index === 0 && position.closed && liquidationOutcome === "CLOSED") {
       closedReason = "LIQUIDATED";
     }
-    realFills.push(partToApplicableFill(part, partIdFor(part), connector, liquidationOutcome));
+    realFills.push({
+      ...sourceToApplicableFill(part.source, connector),
+      quantity: part.quantity,
+      usd: multiply(part.quantity, part.source.price).toFixed()
+    });
+    assignments.push({
+      exchangeFillId: part.source.exchangeFillId,
+      quantity: part.quantity,
+      ...liquidationOutcome === null ? {} : {
+        liquidationOutcome
+      }
+    });
   }
   realFills.reverse();
+  assignments.reverse();
   return {
     realFills,
+    assignments,
     closedReason
   };
 }
@@ -2468,7 +2415,7 @@ var PearHoldings = class _PearHoldings {
   /** Filter `openPositions` to the given connector and wrap. */
   static from(args) {
     const { openPositions, connector } = args;
-    return new _PearHoldings(openPositions.filter((position) => position.connector === connector));
+    return new _PearHoldings(openPositions.filter((position) => position.connector === connector).sort((a, b) => Date.parse(a.createdAt) - Date.parse(b.createdAt) || a.id.localeCompare(b.id)));
   }
   /** The open Pear positions for this connector. */
   positions() {
@@ -2598,7 +2545,7 @@ __name(isStrictTimestampBoundary, "isStrictTimestampBoundary");
 async function computeSyncPayload(args) {
   const { tradeAccountId, connector, openPositions, entryBySymbol, provisionalFills, confirmedExchangeFillIds, externalFills, exchangePositions, neverSynced } = args;
   const fillsToProcess = _prepareExternalFills(externalFills, confirmedExchangeFillIds);
-  const orphans = _excludeClaimedFills(provisionalFills, fillsToProcess);
+  const orphans = _excludeClaimedFills(provisionalFills.filter((fill) => fill.tradeAccountId === tradeAccountId && fill.connector === connector), fillsToProcess);
   const { keptOrphans, firstSyncTrim } = applyFirstSyncCutoff({
     neverSynced,
     fillsToProcess,
@@ -2606,7 +2553,7 @@ async function computeSyncPayload(args) {
     exchangePositions,
     connector
   });
-  const applicables = buildApplicables({
+  const { fills, applicables } = buildApplicables({
     tradeAccountId,
     connector,
     orphanFills: keptOrphans,
@@ -2620,6 +2567,7 @@ async function computeSyncPayload(args) {
   }
   const externalMaxTs = latestFillTimestamp(fillsToProcess);
   return {
+    fills,
     applicables,
     exchangePositions,
     meta: {
@@ -2666,12 +2614,12 @@ function _excludeClaimedFills(provisionalFills, externalFills) {
   for (const fill of provisionalFills) {
     const cloid = _normalizeCloid(fill.cloid);
     if (cloid) {
-      ownedCloids.add(cloid);
+      ownedCloids.add(`${fill.connector}:${cloid}`);
     }
   }
   return externalFills.filter((fill) => {
     const cloid = _normalizeCloid(fill.cloid);
-    return cloid === void 0 || !ownedCloids.has(cloid);
+    return cloid === void 0 || !ownedCloids.has(`${fill.connector}:${cloid}`);
   });
 }
 __name(_excludeClaimedFills, "_excludeClaimedFills");

package/dist/precise-quantity.d.ts

@@ -1,7 +1,13 @@
 import type { Connector, InstrumentPrecision, Side } from '@pear-protocol/types';
 import BigNumber from 'bignumber.js';
 /**
- * Round a raw quantity to an exchange-valid string for the given connector
- * (BUY rounds down, SELL rounds up).
+ * Rounding strategy for quantities that fall off the venue grid.
+ * 'side' keeps the historical behavior (BUY floors, SELL ceils); 'floor'
+ * rounds down on both sides so a fractional amount is never exceeded.
  */
-export declare function preciseQuantity(connector: Connector, raw: BigNumber.Value, precision: InstrumentPrecision, side: Side): string;
+export type QuantityRounding = 'side' | 'floor';
+/**
+ * Round a raw quantity to an exchange-valid string for the given connector.
+ * Default 'side' rounding: BUY rounds down, SELL rounds up.
+ */
+export declare function preciseQuantity(connector: Connector, raw: BigNumber.Value, precision: InstrumentPrecision, side: Side, rounding?: QuantityRounding): string;

package/dist/reduce-only-minimum.d.ts

@@ -35,8 +35,9 @@ export declare function requestedBaseQuantity(leg: {
     amount: string;
 }, referencePrice: string): string;
 /**
- * Whether a close leg is refused for its size. A close places the position's whole exposure, so it closes
- * the venue position, valid at any size, unless another position holds the asset: then the venue reads it
- * as a partial reduce, held to its minimum order quantity and minimum order value at the order price (#1184).
+ * Whether a close leg is refused for its size. A close that flattens the venue position is valid at any
+ * size. When the venue reads it as a partial reduce instead, because another position holds the asset or
+ * the close leaves part of the position open, it is held to the venue's minimum order quantity and minimum
+ * order value at the order price (#1184).
  */
-export declare function isRefusedBelowMinimum(quantity: string, price: string, precision: InstrumentPrecision, heldByAnotherPosition: boolean): boolean;
+export declare function isRefusedBelowMinimum(quantity: string, price: string, precision: InstrumentPrecision, isPartialVenueReduce: boolean): boolean;

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

@@ -16,10 +16,6 @@ export declare class Basket {
     private constructor();
     /** Detect baskets from a fill stream, returned in ascending time order. */
     static detect(fills: HttpTypes.UnknownExternalFill[]): Basket[];
-    /** Active long symbol set the matcher compares against open positions. */
-    get longs(): Set<string>;
-    /** Active short symbol set the matcher compares against open positions. */
-    get shorts(): Set<string>;
 }
 /**
  * One combined symbol+side leg of a basket. Owns the per-source FIFO queue, so

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

@@ -3,7 +3,7 @@ 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
- * DUST rule, and the leg-set queries live in one place instead of scattered helpers.
+ * 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.
@@ -30,16 +30,8 @@ export declare class Exposure {
         longs: Set<string>;
         shorts: Set<string>;
     };
-    /** True once every leg sits within DUST of zero (effectively closed). */
-    isFlat(): boolean;
     /** True when every leg is exactly zero (a fully CLOSED position). */
     isAllZero(): boolean;
-    /**
-     * Snap every non-zero leg to exactly zero. Called once a position is flat so it
-     * reads CLOSED (all-zero exposure) and never lingers in the open list with stray
-     * dust that a later reopen of the same pair could merge into.
-     */
-    snapToZero(): void;
     /** 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). */

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

@@ -1,16 +1,3 @@
 import type { HttpTypes } from '@pear-protocol/types';
-import type { FillPart, MatchedPosition, PartId } from './types';
-/**
- * A source fill may be split into multiple slices (different positions). Build a
- * stable id per slice: unsplit slices keep the native id; split slices get a
- * deterministic `-pN` suffix plus an `original` pointer to the source.
- * Returns an accessor; every part of every given position has an id by construction.
- */
-export declare function assignPartIds(positions: MatchedPosition[]): (part: FillPart) => PartId;
-/**
- * Convert a matched fill slice into the wire-shape ApplicableFill the server persists.
- * Three shapes emerge: a real external fill, a real Pear fill (cloid we minted), or a
- * missed-history synthetic (external, priced to reconcile with the exchange entry).
- * Fees are quantity-prorated when the source fill was split across positions.
- */
-export declare function partToApplicableFill(part: FillPart, id: PartId, connector: HttpTypes.Connector, liquidationOutcome: 'CLOSED' | 'REDUCED' | null): HttpTypes.ApplicableFill;
+/** 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

@@ -3,8 +3,8 @@
  * find-or-creates into positions.
  *
  * Each fill is processed against the currently open positions, oldest first:
- *   1. close out an exact-match inverse position (same active legs),
- *   2. else reduce any other positions partially holding that leg,
+ *   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.
  *
@@ -20,7 +20,7 @@ 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 (exact active-set match, cross-
+ * 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.
  */
@@ -31,4 +31,7 @@ export declare function buildApplicables(args: {
     openPositions: HttpTypes.OpenPositionLite[];
     entryBySymbol: Record<string, string>;
     exchangePositions: HttpTypes.ExternalPosition[];
-}): HttpTypes.ApplicablePosition[];
+}): {
+    fills: HttpTypes.ApplicableFill[];
+    applicables: HttpTypes.ApplicablePosition[];
+};

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

@@ -3,9 +3,7 @@ import type { PearHoldings } from './snapshot';
 import type { MatchedPosition } from './types';
 /**
  * Replay external fills to decide which position each fill slice belongs to. Flow :
- *   - findExactCloseTarget picks the open position whose ACTIVE legs mirror the
- *     basket (dead legs ignored) — the basket closes that position first,
- *   - applyCloses reduces holders (the mirrored target first, then any other),
+ *   - 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).

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

@@ -5,13 +5,15 @@
 import type { HttpTypes } from '@pear-protocol/types';
 import type { MatchedPosition, NeededSynthetic } from './types';
 /**
- * Assemble the final ApplicablePosition records: resolve stable per-slice fill
- * ids once across all positions, then build each applicable (dropping unchanged
- * positions that produced no fills).
+ * 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;
-}): HttpTypes.ApplicablePosition[];
+}): {
+    fills: HttpTypes.ApplicableFill[];
+    applicables: HttpTypes.ApplicablePosition[];
+};

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

@@ -40,9 +40,10 @@ export declare function alignPositionsWithExchange(args: {
     positions: MatchedPosition[];
     synthByPosition: Map<MatchedPosition, NeededSynthetic[]>;
 };
-/** Build the content-addressed synthetic fill for a position/asset/side triple. */
+/** 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;

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

@@ -26,6 +26,8 @@ export type FillPart = {
  */
 export type WorkingPosition = {
     positionKey: string;
+    createdAt: number;
+    orderId: string;
     exposure: Exposure;
     parts: FillPart[];
     closed: boolean;
@@ -51,6 +53,12 @@ export type MatchedPosition = {
     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 = {
@@ -72,11 +80,3 @@ export type NeededSynthetic = {
     quantity: string;
     closedReason?: HttpTypes.PositionClosedReason;
 };
-/** Per-slice id + `original` pointer, resolved once across ALL positions so split slices stay unique. */
-export type PartId = {
-    exchangeFillId: string;
-    original?: {
-        exchangeFillId: string;
-        quantity: string;
-    };
-};

package/dist/sync/types.d.ts

@@ -11,6 +11,7 @@ export type ComputeSyncPayloadArgs = {
     neverSynced: boolean;
 };
 export type ComputeSyncPayloadResult = {
+    fills: HttpTypes.ApplicableFill[];
     applicables: HttpTypes.ApplicablePosition[];
     exchangePositions: HttpTypes.ExternalPosition[];
     meta: {

package/package.json

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