@pear-protocol/utils 1.1.0 → 1.3.0

package/dist/copy/equity-fraction.d.ts

@@ -0,0 +1,13 @@
+/** Pure gross-notional valuation for copy sizing. */
+import type { Fill, InstrumentPriceMap, PositionExposure, TradeLeg, UnsignedDecimalString } from '@pear-protocol/types';
+/** Size a non-empty set of validated positive fill notionals without a market-price lookup. */
+export declare function computeFilledEntrySizing(fills: ReadonlyArray<Pick<Fill, 'symbol' | 'usd'>>, equity: UnsignedDecimalString): {
+    equityFraction: UnsignedDecimalString;
+    legNotionals: Record<string, UnsignedDecimalString>;
+};
+/** Value signed exposure against equity; missing prices contribute no notional. */
+export declare function computeEquityFraction(exposure: PositionExposure, priceMap: InstrumentPriceMap, equity: UnsignedDecimalString): UnsignedDecimalString;
+/** Value USD and quantity entry legs; missing quantity prices contribute no notional. */
+export declare function computeEntryEquityFraction(legs: ReadonlyArray<Pick<TradeLeg, 'symbol' | 'mode' | 'amount'>>, priceMap: InstrumentPriceMap, equity: UnsignedDecimalString): UnsignedDecimalString;
+/** Divide valued notional by validated positive equity without capping leverage. */
+export declare function computeNotionalEquityFraction(notional: Fill['usd'], equity: UnsignedDecimalString): UnsignedDecimalString;

package/dist/copy/index.d.ts

@@ -0,0 +1 @@
+export * from './equity-fraction';

package/dist/fills/compute.d.ts

@@ -8,5 +8,9 @@ import type { Fill } from './fill.types';
  *  - Reduce position   : entry price unchanged
  *  - Close to zero     : keep last entry price (for tracking purpose)
  *  - Flip sign         : entry price resets to flip fill's price
+ *
+ * A 0-price (unpriceable synthetic) fill that opens or adds to the held size taints the
+ * basis until the size flattens or flips: the entry is then unknown and reported as zero,
+ * the same "no entry" answer callers already get for an empty ledger.
  */
 export declare function computeEntryPriceForAsset(fills: Fill[]): BigNumber;

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export * from './asset/index';
 export * from './basket/index';
 export * from './contract-size';
+export * from './copy/index';
 export * from './fills/index';
 export * from './math/index';
 export * from './position/index';
@@ -10,4 +11,5 @@ export * from './proxy';
 export * from './sync/index';
 export * from './validate-leverage';
 export * from './validate-quantity';
+export * from './vaults/index';
 export * from './xauth/index';

package/dist/index.js

@@ -1,7 +1,8 @@
 import BigNumber7 from 'bignumber.js';
 import { sha256 } from '@noble/hashes/sha2';
-import { bytesToHex, randomBytes, utf8ToBytes } from '@noble/hashes/utils';
+import { bytesToHex, utf8ToBytes, randomBytes } from '@noble/hashes/utils';
 import { WATERMARK_FUTURE_SKEW_MS } from '@pear-protocol/types';
+import { keccak_256 } from '@noble/hashes/sha3';
 import { base64urlnopad } from '@scure/base';
 
 var __defProp = Object.defineProperty;
@@ -124,6 +125,7 @@ __name(compareValue, "compareValue");
 function computeEntryPriceForAsset(fills) {
   let entryPrice = ZERO;
   let positionSize = ZERO;
+  let unpriced = false;
   for (const fill of fills) {
     const price = new BigNumber7(fill.price);
     const quantity = new BigNumber7(fill.quantity);
@@ -133,11 +135,16 @@ function computeEntryPriceForAsset(fills) {
     const isFlip = !positionSize.isZero() && !newPositionSize.isZero() && newPositionSize.isPositive() !== positionSize.isPositive();
     if (positionSize.isZero() || isFlip) {
       entryPrice = price;
+      unpriced = price.isZero();
     } else if (isSameDirection) {
       entryPrice = entryPrice.times(positionSize.abs()).plus(price.times(quantity)).div(newPositionSize.abs());
+      unpriced = unpriced || price.isZero();
     }
     positionSize = newPositionSize;
   }
+  if (unpriced) {
+    return ZERO;
+  }
   return entryPrice;
 }
 __name(computeEntryPriceForAsset, "computeEntryPriceForAsset");
@@ -381,6 +388,9 @@ function computeAssetUnrealizedPnLs(exposureMap, priceMap, fills) {
     const currentPrice = new BigNumber7(priceString);
     const assetFills = fills.filter((fill) => fill.symbol === id);
     const entryPrice = computeEntryPriceForAsset(assetFills);
+    if (entryPrice.isZero()) {
+      continue;
+    }
     const upnl = signedQuantity.multipliedBy(currentPrice.minus(entryPrice));
     result.push({
       id,
@@ -865,6 +875,61 @@ function baseToContracts(base, contractSize) {
 }
 __name(baseToContracts, "baseToContracts");
 
+// src/copy/equity-fraction.ts
+function computeFilledEntrySizing(fills, equity) {
+  const notionals = /* @__PURE__ */ new Map();
+  let total = parse("0");
+  for (const fill of fills) {
+    const notional = parse(fill.usd);
+    notionals.set(fill.symbol, (notionals.get(fill.symbol) ?? parse("0")).plus(notional));
+    total = total.plus(notional);
+  }
+  const legNotionals = {};
+  for (const [symbol, notional] of notionals) {
+    legNotionals[symbol] = notional.toFixed();
+  }
+  return {
+    equityFraction: computeNotionalEquityFraction(total.toFixed(), equity),
+    legNotionals
+  };
+}
+__name(computeFilledEntrySizing, "computeFilledEntrySizing");
+function computeEquityFraction(exposure, priceMap, equity) {
+  let notional = parse("0");
+  for (const [symbol, quantity] of Object.entries(exposure)) {
+    const price = priceMap[symbol];
+    if (price !== void 0) {
+      notional = notional.plus(parse(quantity).abs().multipliedBy(price));
+    }
+  }
+  return computeNotionalEquityFraction(notional.toFixed(), equity);
+}
+__name(computeEquityFraction, "computeEquityFraction");
+function computeEntryEquityFraction(legs, priceMap, equity) {
+  let notional = parse("0");
+  for (const leg of legs) {
+    const amount = parse(leg.amount).abs();
+    switch (leg.mode) {
+      case "USD":
+        notional = notional.plus(amount);
+        break;
+      case "QUANTITY": {
+        const price = priceMap[leg.symbol];
+        if (price !== void 0) {
+          notional = notional.plus(amount.multipliedBy(price));
+        }
+        break;
+      }
+    }
+  }
+  return computeNotionalEquityFraction(notional.toFixed(), equity);
+}
+__name(computeEntryEquityFraction, "computeEntryEquityFraction");
+function computeNotionalEquityFraction(notional, equity) {
+  return parse(notional).dividedBy(equity).toFixed();
+}
+__name(computeNotionalEquityFraction, "computeNotionalEquityFraction");
+
 // src/fills/group.ts
 function groupFillsByPosition(fills) {
   const byPosition = /* @__PURE__ */ new Map();
@@ -1268,6 +1333,7 @@ __name(proxyFetch, "proxyFetch");
 
 // src/sync/applicables/constants.ts
 var DUST = parse("0.00000001");
+var LATE_FILL_GRACE_MS = 5 * 6e4;
 var MISSED_HISTORY_FILL_PREFIX = "opening-synthetic-";
 var BASKET_RULES = [
   // V2 Basket Hyperliquid — legs of one Pear basket order share the order's cloid.
@@ -1303,12 +1369,14 @@ var Basket = class _Basket {
     __name(this, "Basket");
   }
   legs;
-  constructor(legs) {
+  fills;
+  constructor(legs, fills) {
     this.legs = legs;
+    this.fills = fills;
   }
   /** Detect baskets from a fill stream, returned in ascending time order. */
   static detect(fills) {
-    return groupFillsIntoBaskets(fills).map((group) => new _Basket(combineFillsBySymbolAndSide(group)));
+    return groupFillsIntoBaskets(fills).map((group) => new _Basket(combineFillsBySymbolAndSide(group), group));
   }
   /** Active long symbol set the matcher compares against open positions. */
   get longs() {
@@ -1515,189 +1583,6 @@ var Exposure = class _Exposure {
   }
 };
 
-// src/sync/applicables/matching.ts
-function matchPositions(args) {
-  const { tradeAccountId, orphanFills, pear } = args;
-  const book = WorkingBook.load({
-    tradeAccountId,
-    openPositions: pear.positions()
-  });
-  for (const basket of Basket.detect(orphanFills)) {
-    const exactCloseTarget = findExactCloseTarget(book.open(), basket.longs, basket.shorts);
-    const leftover = applyCloses({
-      legs: basket.legs,
-      book,
-      exactCloseTarget
-    });
-    if (leftover.length === 0) {
-      continue;
-    }
-    const target = resolveLeftoverTarget({
-      book,
-      leftover
-    });
-    applyLeftover(target, leftover);
-  }
-  return book.toMatched();
-}
-__name(matchPositions, "matchPositions");
-var WorkingBook = class WorkingBook2 {
-  static {
-    __name(this, "WorkingBook");
-  }
-  tradeAccountId;
-  all = [];
-  openByKey = /* @__PURE__ */ new Map();
-  constructor(tradeAccountId) {
-    this.tradeAccountId = tradeAccountId;
-  }
-  /** Seed the book from existing open DB positions (they arrive pre-filtered by connector). */
-  static load(args) {
-    const { tradeAccountId, openPositions } = args;
-    const book = new WorkingBook2(tradeAccountId);
-    for (const p of openPositions) {
-      const position = {
-        // Trust the position's own stored key — never recompute it from exposure.
-        // 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,
-        exposure: Exposure.fromRecord(p.exposure),
-        parts: [],
-        closed: false,
-        existingOrigin: p.origin
-      };
-      book.all.push(position);
-      book.openByKey.set(position.positionKey, position);
-    }
-    return book;
-  }
-  /** Deterministic position key for a symbol set under this book's trade account. */
-  keyFor(symbols) {
-    return generateDeterministicPositionKey({
-      tradeAccountId: this.tradeAccountId,
-      symbols
-    });
-  }
-  /** Currently open working positions, in insertion order. */
-  open() {
-    return this.all.filter((position) => !position.closed);
-  }
-  /** Look up an open working position by its positionKey (for dedup on merge). */
-  findOpenByKey(key) {
-    return this.openByKey.get(key);
-  }
-  /** Register a fresh empty working position under `key` and return it. */
-  create(key) {
-    const position = {
-      positionKey: key,
-      exposure: Exposure.empty(),
-      parts: [],
-      closed: false
-    };
-    this.all.push(position);
-    this.openByKey.set(key, position);
-    return position;
-  }
-  /** Flip a position to closed once every leg is within DUST of zero. */
-  markClosedIfFlat(position) {
-    if (position.closed || !position.exposure.isFlat()) {
-      return;
-    }
-    position.exposure.snapToZero();
-    position.closed = true;
-    this.openByKey.delete(position.positionKey);
-  }
-  /** Working positions that received fills become MatchedPosition records; untouched ones are dropped. */
-  toMatched() {
-    return this.all.filter((position) => position.parts.length > 0).map((position) => ({
-      positionKey: position.positionKey,
-      parts: position.parts,
-      closed: position.closed,
-      exposure: position.exposure,
-      existingOrigin: position.existingOrigin
-    }));
-  }
-};
-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 } = args;
-  const openList = book.open();
-  const leftover = [];
-  for (const leg of legs) {
-    let remaining = leg.totalSize;
-    const closeTargetIsLong = sideSign(leg.side) === -1;
-    const holders = openList.filter((position) => {
-      const qty = position.exposure.get(leg.symbol);
-      if (qty.isZero()) {
-        return false;
-      }
-      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;
-      }
-      const have = position.exposure.get(leg.symbol).abs();
-      const reduce = min(have, remaining);
-      position.parts.push(...leg.take(reduce));
-      position.exposure.addDelta(leg.symbol, signedBySide(reduce, leg.side));
-      remaining = remaining.minus(reduce);
-      book.markClosedIfFlat(position);
-    }
-    if (isGreaterThanOrEqual(remaining, DUST)) {
-      leftover.push({
-        side: leg.side,
-        qty: remaining,
-        leg
-      });
-    }
-  }
-  return leftover;
-}
-__name(applyCloses, "applyCloses");
-function resolveLeftoverTarget(args) {
-  const { book, leftover } = args;
-  const leftoverLongs = new Set(leftover.filter((entry) => entry.side === "BUY").map((entry) => entry.leg.symbol));
-  const leftoverShorts = new Set(leftover.filter((entry) => entry.side === "SELL").map((entry) => entry.leg.symbol));
-  const target = book.open().find((position) => {
-    const { longs, shorts } = position.exposure.activeLegs();
-    const sameActiveShape = setEq(leftoverLongs, longs) && setEq(leftoverShorts, shorts);
-    const noDormantLegs = position.exposure.symbols().length === longs.size + shorts.size;
-    return sameActiveShape && noDormantLegs;
-  });
-  if (target) {
-    return target;
-  }
-  const symbols = [
-    .../* @__PURE__ */ new Set([
-      ...leftoverLongs,
-      ...leftoverShorts
-    ])
-  ];
-  const positionKey = book.keyFor(symbols);
-  return book.findOpenByKey(positionKey) ?? book.create(positionKey);
-}
-__name(resolveLeftoverTarget, "resolveLeftoverTarget");
-function applyLeftover(target, leftover) {
-  for (const entry of leftover) {
-    target.parts.push(...entry.leg.take(entry.qty));
-    target.exposure.addSigned(entry.leg.symbol, entry.qty.toFixed(), entry.side);
-  }
-}
-__name(applyLeftover, "applyLeftover");
-
 // src/sync/applicables/synthetics.ts
 function isMissedHistoryFill(fill) {
   return fill.exchangeFillId.startsWith(MISSED_HISTORY_FILL_PREFIX);
@@ -1892,7 +1777,8 @@ function assignSyntheticsToPositions(args) {
       const positionKey = existing ? existing.positionKey : keyOf([
         symbol
       ]);
-      target = positions.find((pos) => pos.positionKey === positionKey) ?? created.find((pos) => pos.positionKey === positionKey);
+      const isKeyTarget = /* @__PURE__ */ __name((pos) => pos.positionKey === positionKey && (!existing || pos.existingOrigin !== void 0), "isKeyTarget");
+      target = positions.find(isKeyTarget) ?? created.find(isKeyTarget);
       if (!target) {
         target = existing ? (
           // seed its exposure and origin so folding the synthetic yields the true
@@ -1969,6 +1855,223 @@ function findGapToTarget(args) {
 }
 __name(findGapToTarget, "findGapToTarget");
 
+// src/sync/applicables/matching.ts
+function matchPositions(args) {
+  const { tradeAccountId, orphanFills, pear } = args;
+  const book = WorkingBook.load({
+    tradeAccountId,
+    openPositions: pear.positions()
+  });
+  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) {
+      continue;
+    }
+    const target = resolveLeftoverTarget({
+      book,
+      leftover,
+      at
+    });
+    applyLeftover(target, leftover);
+  }
+  book.foldIntoLive(Number.POSITIVE_INFINITY);
+  return book.toMatched();
+}
+__name(matchPositions, "matchPositions");
+function basketTime(basket) {
+  const realTimestamps = basket.fills.filter((fill) => !isMissedHistoryFill(fill)).map((fill) => fill.timestamp);
+  if (realTimestamps.length === 0) {
+    return Number.POSITIVE_INFINITY;
+  }
+  return Math.min(...realTimestamps);
+}
+__name(basketTime, "basketTime");
+var WorkingBook = class WorkingBook2 {
+  static {
+    __name(this, "WorkingBook");
+  }
+  tradeAccountId;
+  all = [];
+  constructor(tradeAccountId) {
+    this.tradeAccountId = tradeAccountId;
+  }
+  /** Seed the book from existing open DB positions (they arrive pre-filtered by connector). */
+  static load(args) {
+    const { tradeAccountId, openPositions } = args;
+    const book = new WorkingBook2(tradeAccountId);
+    for (const p of openPositions) {
+      const position = {
+        // Trust the position's own stored key — never recompute it from exposure.
+        // 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,
+        exposure: Exposure.fromRecord(p.exposure),
+        parts: [],
+        closed: false,
+        existingOrigin: p.origin,
+        // A seeded position takes fills from its creation, less the late-arrival grace.
+        liveFrom: Date.parse(p.createdAt) - LATE_FILL_GRACE_MS
+      };
+      book.all.push(position);
+    }
+    return book;
+  }
+  /** Deterministic position key for a symbol set under this book's trade account. */
+  keyFor(symbols) {
+    return generateDeterministicPositionKey({
+      tradeAccountId: this.tradeAccountId,
+      symbols
+    });
+  }
+  /** Working positions open and already existing at basket time `at`, in insertion order. */
+  live(at) {
+    return this.all.filter((position) => !position.closed && position.liveFrom <= at);
+  }
+  /** Look up a position open and existing at `at` by its positionKey (for dedup on merge). */
+  findLiveByKey(key, at) {
+    return this.live(at).find((position) => position.positionKey === key);
+  }
+  /**
+  * Fold every open position opened mid-replay into the open seeded position sharing its
+  * key once that seeded position is live at `at`. The earlier open was still holding
+  * exposure when the seeded position was created, and the server keeps at most one open
+  * row per key. Ownership is ambiguous here — exposure and timestamps cannot prove the
+  * seeded position traded on top of that history — so the fold conservatively keeps
+  * the attribution the matcher gave before #1067.
+  */
+  foldIntoLive(at) {
+    for (const seeded of this.live(at).filter((position) => position.existingOrigin !== void 0)) {
+      const earlier = this.all.filter((position) => position.existingOrigin === void 0 && !position.closed && position.positionKey === seeded.positionKey);
+      for (const position of earlier) {
+        seeded.parts.push(...position.parts);
+        for (const symbol of position.exposure.symbols()) {
+          seeded.exposure.addDelta(symbol, position.exposure.get(symbol));
+        }
+        this.all = this.all.filter((candidate) => candidate !== position);
+      }
+      this.markClosedIfFlat(seeded);
+    }
+  }
+  /** Register a fresh empty working position under `key` and return it. */
+  create(key) {
+    const position = {
+      positionKey: key,
+      exposure: Exposure.empty(),
+      parts: [],
+      closed: false,
+      // Opened by this replay's own fills, so it takes fills from the start.
+      liveFrom: Number.NEGATIVE_INFINITY
+    };
+    this.all.push(position);
+    return position;
+  }
+  /** Flip a position to closed once every leg is within DUST of zero. */
+  markClosedIfFlat(position) {
+    if (position.closed || !position.exposure.isFlat()) {
+      return;
+    }
+    position.exposure.snapToZero();
+    position.closed = true;
+  }
+  /** Working positions that received fills become MatchedPosition records; untouched ones are dropped. */
+  toMatched() {
+    return this.all.filter((position) => position.parts.length > 0).map((position) => ({
+      positionKey: position.positionKey,
+      parts: position.parts,
+      closed: position.closed,
+      exposure: position.exposure,
+      existingOrigin: position.existingOrigin
+    }));
+  }
+};
+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 openList = book.live(at);
+  const leftover = [];
+  for (const leg of legs) {
+    let remaining = leg.totalSize;
+    const closeTargetIsLong = sideSign(leg.side) === -1;
+    const holders = openList.filter((position) => {
+      const qty = position.exposure.get(leg.symbol);
+      if (qty.isZero()) {
+        return false;
+      }
+      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;
+      }
+      const have = position.exposure.get(leg.symbol).abs();
+      const reduce = min(have, remaining);
+      position.parts.push(...leg.take(reduce));
+      position.exposure.addDelta(leg.symbol, signedBySide(reduce, leg.side));
+      remaining = remaining.minus(reduce);
+      book.markClosedIfFlat(position);
+    }
+    if (isGreaterThanOrEqual(remaining, DUST)) {
+      leftover.push({
+        side: leg.side,
+        qty: remaining,
+        leg
+      });
+    }
+  }
+  return leftover;
+}
+__name(applyCloses, "applyCloses");
+function resolveLeftoverTarget(args) {
+  const { book, leftover, at } = args;
+  const leftoverLongs = new Set(leftover.filter((entry) => entry.side === "BUY").map((entry) => entry.leg.symbol));
+  const leftoverShorts = new Set(leftover.filter((entry) => entry.side === "SELL").map((entry) => entry.leg.symbol));
+  const target = book.live(at).find((position) => {
+    const { longs, shorts } = position.exposure.activeLegs();
+    const sameActiveShape = setEq(leftoverLongs, longs) && setEq(leftoverShorts, shorts);
+    const noDormantLegs = position.exposure.symbols().length === longs.size + shorts.size;
+    return sameActiveShape && noDormantLegs;
+  });
+  if (target) {
+    return target;
+  }
+  const symbols = [
+    .../* @__PURE__ */ new Set([
+      ...leftoverLongs,
+      ...leftoverShorts
+    ])
+  ];
+  const positionKey = book.keyFor(symbols);
+  return book.findLiveByKey(positionKey, at) ?? book.create(positionKey);
+}
+__name(resolveLeftoverTarget, "resolveLeftoverTarget");
+function applyLeftover(target, leftover) {
+  for (const entry of leftover) {
+    target.parts.push(...entry.leg.take(entry.qty));
+    target.exposure.addSigned(entry.leg.symbol, entry.qty.toFixed(), entry.side);
+  }
+}
+__name(applyLeftover, "applyLeftover");
+
 // src/sync/applicables/fills.ts
 function assignPartIds(positions) {
   const bySource = /* @__PURE__ */ new Map();
@@ -2007,7 +2110,7 @@ function assignPartIds(positions) {
   };
 }
 __name(assignPartIds, "assignPartIds");
-function partToApplicableFill(part, id, connector) {
+function partToApplicableFill(part, id, connector, liquidationOutcome) {
   const fill = part.source;
   const base = {
     exchangeFillId: id.exchangeFillId,
@@ -2040,7 +2143,10 @@ function partToApplicableFill(part, id, connector) {
     isExternal: !fromPear,
     tradeFee: feeShareForPart(fill.tradeFee, part.quantity, fill.quantity),
     builderFee: feeShareForPart(fill.builderFee, part.quantity, fill.quantity),
-    liquidation: fill.liquidation,
+    liquidation: fill.liquidation ? {
+      mark: fill.liquidation.mark,
+      outcome: liquidationOutcome ?? void 0
+    } : null,
     ...id.original ? {
       original: id.original
     } : {}
@@ -2074,7 +2180,7 @@ function assembleApplicables(args) {
 }
 __name(assembleApplicables, "assembleApplicables");
 function assembleOneApplicable(pos, connector, partIdFor, assignedSynthetics, now) {
-  const realFills = pos.parts.map((part) => partToApplicableFill(part, partIdFor(part), connector)).sort((a, b) => a.timestamp - b.timestamp);
+  const { realFills, closedReason } = finalizeRealFills(pos, connector, partIdFor);
   const syntheticFills = assignedSynthetics.map((synthetic) => buildSyntheticFill({
     positionKey: pos.positionKey,
     connector,
@@ -2098,13 +2204,38 @@ function assembleOneApplicable(pos, connector, partIdFor, assignedSynthetics, no
     origin,
     status,
     ...closed ? {
-      closedReason: "NETTED"
+      closedReason
     } : {},
     fills,
     metadata: buildMetadata(new Set(exposure.symbols()), realFills)
   };
 }
 __name(assembleOneApplicable, "assembleOneApplicable");
+function finalizeRealFills(position, connector, partIdFor) {
+  const newestFirst = [
+    ...position.parts
+  ].sort((a, b) => a.source.timestamp - b.source.timestamp).reverse();
+  const exposure = position.exposure.clone();
+  const realFills = [];
+  let closedReason = "NETTED";
+  for (const [index, part] of newestFirst.entries()) {
+    const after = exposure.get(part.source.symbol);
+    const flatAfter = exposure.isFlat();
+    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.reverse();
+  return {
+    realFills,
+    closedReason
+  };
+}
+__name(finalizeRealFills, "finalizeRealFills");
 function finalExposure(pos, synthetics) {
   const exposure = pos.exposure.clone();
   for (const synthetic of synthetics) {
@@ -2355,8 +2486,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 { reconcilables, confirmables: confirmableFills, orphans } = _segregateExternalFills(provisionalFills, fillsToProcess);
-  const confirmablesByPosition = groupConfirmablesByPosition(confirmableFills);
+  const orphans = _excludeClaimedFills(provisionalFills, fillsToProcess);
   const { keptOrphans, firstSyncTrim } = applyFirstSyncCutoff({
     neverSynced,
     fillsToProcess,
@@ -2373,13 +2503,11 @@ async function computeSyncPayload(args) {
     exchangePositions
   });
   const mustPostFirstSyncCheckpoint = neverSynced;
-  if (!mustPostFirstSyncCheckpoint && isEmptyCycle(reconcilables, confirmablesByPosition, applicables)) {
+  if (!mustPostFirstSyncCheckpoint && applicables.length === 0) {
     return null;
   }
   const externalMaxTs = latestFillTimestamp(fillsToProcess);
   return {
-    reconcilables: Object.keys(reconcilables).length > 0 ? reconcilables : null,
-    confirmables: Object.keys(confirmablesByPosition).length > 0 ? confirmablesByPosition : null,
     applicables,
     exchangePositions,
     meta: {
@@ -2421,77 +2549,20 @@ function _prepareExternalFills(externalFills, confirmedExchangeFillIdsInput) {
   return Array.from(dedupedByExchangeFillId.values()).sort((a, b) => a.timestamp - b.timestamp);
 }
 __name(_prepareExternalFills, "_prepareExternalFills");
-function _segregateExternalFills(provisionalFills, externalFills) {
-  const provisionalFillsMap = /* @__PURE__ */ new Map();
+function _excludeClaimedFills(provisionalFills, externalFills) {
+  const ownedCloids = /* @__PURE__ */ new Set();
   for (const fill of provisionalFills) {
     const cloid = _normalizeCloid(fill.cloid);
-    if (!cloid) {
-      continue;
+    if (cloid) {
+      ownedCloids.add(cloid);
     }
-    provisionalFillsMap.set(cloid, fill);
   }
-  const orphans = [];
-  const fillsByCloid = /* @__PURE__ */ new Map();
-  for (const fill of externalFills) {
+  return externalFills.filter((fill) => {
     const cloid = _normalizeCloid(fill.cloid);
-    if (!cloid) {
-      orphans.push(fill);
-    } else {
-      fillsByCloid.set(cloid, [
-        ...fillsByCloid.get(cloid) || [],
-        fill
-      ]);
-    }
-  }
-  const reconcilables = {};
-  const confirmableFills = [];
-  for (const [cloid, fills] of fillsByCloid.entries()) {
-    if (fills.length > 1) {
-      const provisional = provisionalFillsMap.get(cloid);
-      if (provisional) {
-        const [first, second, ...rest] = fills;
-        if (!first || !second) {
-          throw new Error("Corrupted state: sibling group must contain at least 2 fills for reconcile");
-        }
-        reconcilables[cloid] = [
-          {
-            ...first,
-            cloid
-          },
-          {
-            ...second,
-            cloid
-          },
-          ...rest.map((fill) => ({
-            ...fill,
-            cloid
-          }))
-        ];
-      } else {
-        orphans.push(...fills);
-      }
-    } else {
-      const fill = fills[0];
-      const provisional = provisionalFillsMap.get(cloid);
-      if (provisional) {
-        confirmableFills.push({
-          ...fill,
-          type: "confirm",
-          cloid,
-          positionId: provisional.positionId
-        });
-      } else {
-        orphans.push(fill);
-      }
-    }
-  }
-  return {
-    reconcilables,
-    confirmables: confirmableFills,
-    orphans
-  };
+    return cloid === void 0 || !ownedCloids.has(cloid);
+  });
 }
-__name(_segregateExternalFills, "_segregateExternalFills");
+__name(_excludeClaimedFills, "_excludeClaimedFills");
 function _normalizeCloid(cloid) {
   const value = cloid?.trim();
   if (!value) {
@@ -2525,16 +2596,6 @@ function _isValidExternalTimestamp(timestamp) {
   return timestamp <= Date.now() + WATERMARK_FUTURE_SKEW_MS;
 }
 __name(_isValidExternalTimestamp, "_isValidExternalTimestamp");
-function groupConfirmablesByPosition(confirmableFills) {
-  return confirmableFills.reduce((acc, fill) => {
-    acc[fill.positionId] = [
-      ...acc[fill.positionId] || [],
-      fill
-    ];
-    return acc;
-  }, {});
-}
-__name(groupConfirmablesByPosition, "groupConfirmablesByPosition");
 function latestFillTimestamp(fills) {
   const last = fills[fills.length - 1];
   if (!last) {
@@ -2585,10 +2646,6 @@ function applyFirstSyncCutoff(args) {
   };
 }
 __name(applyFirstSyncCutoff, "applyFirstSyncCutoff");
-function isEmptyCycle(reconcilables, confirmablesByPosition, applicables) {
-  return Object.keys(reconcilables).length === 0 && Object.keys(confirmablesByPosition).length === 0 && applicables.length === 0;
-}
-__name(isEmptyCycle, "isEmptyCycle");
 
 // src/validate-leverage.ts
 function validateLeverage(leverage, instrument) {
@@ -2629,6 +2686,246 @@ function validateQuantity(quantity, price, precision) {
   return true;
 }
 __name(validateQuantity, "validateQuantity");
+var VAULT_ACTION_DOMAIN = {
+  name: "PearVaultService",
+  version: "1",
+  chainId: 999
+};
+var VAULT_ACTION_TYPES = {
+  "withdraw-to-evm": {
+    WithdrawToEvm: [
+      {
+        name: "vault",
+        type: "address"
+      },
+      {
+        name: "amount",
+        type: "string"
+      },
+      {
+        name: "token",
+        type: "string"
+      },
+      {
+        name: "nonce",
+        type: "string"
+      },
+      {
+        name: "deadline",
+        type: "uint256"
+      }
+    ]
+  },
+  "set-trader": {
+    SetTrader: [
+      {
+        name: "vault",
+        type: "address"
+      },
+      {
+        name: "trader",
+        type: "address"
+      },
+      {
+        name: "nonce",
+        type: "string"
+      },
+      {
+        name: "deadline",
+        type: "uint256"
+      }
+    ]
+  },
+  "agent-approve": {
+    AgentApprove: [
+      {
+        name: "vault",
+        type: "address"
+      },
+      {
+        name: "nonce",
+        type: "string"
+      },
+      {
+        name: "deadline",
+        type: "uint256"
+      }
+    ]
+  },
+  "set-unified-account": {
+    SetUnifiedAccount: [
+      {
+        name: "vault",
+        type: "address"
+      },
+      {
+        name: "nonce",
+        type: "string"
+      },
+      {
+        name: "deadline",
+        type: "uint256"
+      }
+    ]
+  },
+  "update-metadata": {
+    UpdateVaultMetadata: [
+      {
+        name: "vault",
+        type: "address"
+      },
+      {
+        name: "name",
+        type: "string"
+      },
+      {
+        name: "about",
+        type: "string"
+      },
+      {
+        name: "imageUri",
+        type: "string"
+      },
+      {
+        name: "nonce",
+        type: "string"
+      },
+      {
+        name: "deadline",
+        type: "uint256"
+      }
+    ]
+  }
+};
+var CREATE_VAULT_TYPES = {
+  CreateVault: [
+    {
+      name: "leader",
+      type: "address"
+    },
+    {
+      name: "name",
+      type: "string"
+    },
+    {
+      name: "description",
+      type: "string"
+    },
+    {
+      name: "imageUri",
+      type: "string"
+    },
+    {
+      name: "configId",
+      type: "uint256"
+    },
+    {
+      name: "maxWithdrawalPeriodDays",
+      type: "uint256"
+    },
+    {
+      name: "nonce",
+      type: "string"
+    },
+    {
+      name: "deadline",
+      type: "uint256"
+    }
+  ]
+};
+function buildLeaderActionTypedData(action, vaultAddress, body) {
+  const vault = checksumAddress(vaultAddress);
+  const nonce = String(body.nonce ?? "");
+  const deadline = BigInt(body.deadline ?? 0);
+  switch (action) {
+    case "withdraw-to-evm":
+      return {
+        types: VAULT_ACTION_TYPES[action],
+        primaryType: "WithdrawToEvm",
+        message: {
+          vault,
+          amount: String(body.amount ?? ""),
+          token: String(body.tokenId ?? "0"),
+          nonce,
+          deadline
+        }
+      };
+    case "set-trader":
+      return {
+        types: VAULT_ACTION_TYPES[action],
+        primaryType: "SetTrader",
+        message: {
+          vault,
+          trader: checksumAddress(String(body.traderAddress ?? "")),
+          nonce,
+          deadline
+        }
+      };
+    case "agent-approve":
+      return {
+        types: VAULT_ACTION_TYPES[action],
+        primaryType: "AgentApprove",
+        message: {
+          vault,
+          nonce,
+          deadline
+        }
+      };
+    case "set-unified-account":
+      return {
+        types: VAULT_ACTION_TYPES[action],
+        primaryType: "SetUnifiedAccount",
+        message: {
+          vault,
+          nonce,
+          deadline
+        }
+      };
+    case "update-metadata":
+      return {
+        types: VAULT_ACTION_TYPES[action],
+        primaryType: "UpdateVaultMetadata",
+        message: {
+          vault,
+          name: String(body.name ?? ""),
+          about: String(body.about ?? ""),
+          imageUri: String(body.imageUri ?? ""),
+          nonce,
+          deadline
+        }
+      };
+  }
+}
+__name(buildLeaderActionTypedData, "buildLeaderActionTypedData");
+function buildCreateVaultMessage(body) {
+  return {
+    leader: checksumAddress(String(body.leader ?? "")),
+    name: String(body.name ?? ""),
+    description: String(body.description ?? ""),
+    imageUri: String(body.imageUri ?? ""),
+    configId: BigInt(String(body.configId ?? 0)),
+    maxWithdrawalPeriodDays: BigInt(String(body.maxWithdrawalPeriodDays ?? 0)),
+    nonce: String(body.nonce ?? ""),
+    deadline: BigInt(body.deadline ?? 0)
+  };
+}
+__name(buildCreateVaultMessage, "buildCreateVaultMessage");
+function checksumAddress(address) {
+  if (!/^0x[0-9a-fA-F]{40}$/.test(address)) {
+    throw new Error(`invalid address: ${address}`);
+  }
+  const lower = address.slice(2).toLowerCase();
+  const hash = keccak_256(utf8ToBytes(lower));
+  let out = "";
+  for (const [index, byte] of hash.subarray(0, 20).entries()) {
+    const high = lower.charAt(index * 2);
+    const low = lower.charAt(index * 2 + 1);
+    out += byte >> 4 >= 8 ? high.toUpperCase() : high;
+    out += (byte & 15) >= 8 ? low.toUpperCase() : low;
+  }
+  return `0x${out}`;
+}
+__name(checksumAddress, "checksumAddress");
 var STORAGE_PREFIX = "pear.x-handoff.";
 function startXHandoff(storage) {
   const handoffId = base64urlnopad.encode(randomBytes(16));
@@ -2700,4 +2997,4 @@ function takeVerifier(handoffId, storage) {
 }
 __name(takeVerifier, "takeVerifier");
 
-export { BIPS, ZERO, abs, add, aggregateRealizedPositionState, baseToContracts, buildApplicables, compareValue, computeAssetEntryNotional, computeAssetGrossRealizedPnL, computeAssetRealizedPnLs, computeAssetUndeterminedSizes, computeAssetUnrealizedPnL, computeAssetUnrealizedPnLs, computeBasketWeightedRatioV1, computeDeployedCapital, computeDeployedCapitalState, computeEntryPriceForAsset, computeFillTransitions, computeMaxBasketSize, computeMultiQuoteBasketSize, computePositionEntryPrices, computeRealizedPnlBySymbol, computeRealizedPnlFromFills, computeRealizedPositionState, computeSyncPayload, computeUnrealizedPositionState, computeUnrealizedPositionStateFromEntryPrices, configureProxy, contractsToBase, countDecimals, deriveBasketKey, divide, exponentiate, finishXHandoff, generateDeterministicPositionKey, groupFillsByAsset, groupFillsByPosition, isEqualTo, isFiniteDecimal, isGreaterThan, isGreaterThanOrEqual, isLessThan, isLessThanOrEqual, isNegative, isPositive, isZero, min, multiply, negate, parse, precisePrice, preciseQuantity, proxyFetch, sideSign, sign, signed, signedBySide, sizeBasket, sizeBasketByLeverageMode, sizeBasketPerAssetLeverage, startXHandoff, stripXReturn, subtract, sumAttributedFunding, toDecimalString, validateLeverage, validateQuantity, walkPositionLedger, walkPositionTransitions };
+export { BIPS, CREATE_VAULT_TYPES, VAULT_ACTION_DOMAIN, VAULT_ACTION_TYPES, ZERO, abs, add, aggregateRealizedPositionState, baseToContracts, buildApplicables, buildCreateVaultMessage, buildLeaderActionTypedData, compareValue, computeAssetEntryNotional, computeAssetGrossRealizedPnL, computeAssetRealizedPnLs, computeAssetUndeterminedSizes, computeAssetUnrealizedPnL, computeAssetUnrealizedPnLs, computeBasketWeightedRatioV1, computeDeployedCapital, computeDeployedCapitalState, computeEntryEquityFraction, computeEntryPriceForAsset, computeEquityFraction, computeFillTransitions, computeFilledEntrySizing, computeMaxBasketSize, computeMultiQuoteBasketSize, computeNotionalEquityFraction, computePositionEntryPrices, computeRealizedPnlBySymbol, computeRealizedPnlFromFills, computeRealizedPositionState, computeSyncPayload, computeUnrealizedPositionState, computeUnrealizedPositionStateFromEntryPrices, configureProxy, contractsToBase, countDecimals, deriveBasketKey, divide, exponentiate, finishXHandoff, generateDeterministicPositionKey, groupFillsByAsset, groupFillsByPosition, isEqualTo, isFiniteDecimal, isGreaterThan, isGreaterThanOrEqual, isLessThan, isLessThanOrEqual, isNegative, isPositive, isZero, min, multiply, negate, parse, precisePrice, preciseQuantity, proxyFetch, sideSign, sign, signed, signedBySide, sizeBasket, sizeBasketByLeverageMode, sizeBasketPerAssetLeverage, startXHandoff, stripXReturn, subtract, sumAttributedFunding, toDecimalString, validateLeverage, validateQuantity, walkPositionLedger, walkPositionTransitions };

package/dist/position/key.d.ts

@@ -11,8 +11,8 @@ type PositionKeyInput = {
  * exactly what the active-position unique index relies on and what makes the
  * apply UPSERT find-or-create the single correct target.
  *
- * PHASE-1 LEG ID WARNING: `symbols` must be instrument ids
- * (`leg.id ?? leg.symbol`, or exposure keys). A phase-3 ticker here re-hashes and orphans every position.
+ * SYMBOL-MIGRATION id-forever: `symbols` must be instrument ids
+ * (`leg.id ?? leg.symbol`, or exposure keys). A display ticker here re-hashes and orphans every position.
  */
 export declare function generateDeterministicPositionKey(input: PositionKeyInput): string;
 export {};

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

@@ -12,6 +12,7 @@ import type { FillPart } from './types';
  */
 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[];

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

@@ -9,6 +9,13 @@ import type { BasketRule } from './types';
  * 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[];
 /**

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

@@ -13,4 +13,4 @@ export declare function assignPartIds(positions: MatchedPosition[]): (part: Fill
  * 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): HttpTypes.ApplicableFill;
+export declare function partToApplicableFill(part: FillPart, id: PartId, connector: HttpTypes.Connector, liquidationOutcome: 'CLOSED' | 'REDUCED' | null): HttpTypes.ApplicableFill;

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

@@ -9,6 +9,11 @@ import type { MatchedPosition } from './types';
  *   - 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;

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

@@ -31,6 +31,11 @@ export type WorkingPosition = {
     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 = {

package/dist/sync/compute.d.ts

@@ -14,15 +14,10 @@ export declare function computeSyncPayload(args: ComputeSyncPayloadArgs): Promis
  */
 export declare function _prepareExternalFills(externalFills: HttpTypes.UnknownExternalFill[], confirmedExchangeFillIdsInput: string[]): HttpTypes.UnknownExternalFill[];
 /**
- * Partition external fills into reconcilables, confirmables, and orphans.
- * Fills whose cloid matches a provisional fill we own go to confirm or reconcile;
- * everything else (no cloid, or cloid we do not own) becomes an orphan.
+ * 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 _segregateExternalFills(provisionalFills: HttpTypes.ProvisionalFill[], externalFills: HttpTypes.UnknownExternalFill[]): {
-    reconcilables: HttpTypes.ReconcileFillsRequest;
-    confirmables: HttpTypes.ConfirmableExternalFill[];
-    orphans: HttpTypes.UnknownExternalFill[];
-};
+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. */

package/dist/sync/types.d.ts

@@ -11,8 +11,6 @@ export type ComputeSyncPayloadArgs = {
     neverSynced: boolean;
 };
 export type ComputeSyncPayloadResult = {
-    reconcilables: HttpTypes.ReconcileFillsRequest | null;
-    confirmables: HttpTypes.ConfirmFillsRequest | null;
     applicables: HttpTypes.ApplicablePosition[];
     exchangePositions: HttpTypes.ExternalPosition[];
     meta: {

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

@@ -0,0 +1,181 @@
+/**
+ * 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';
+/**
+ * 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
+ * switch and this must NOT be read from env. `verifyingContract` is omitted on
+ * purpose: this is service auth, not an on-chain contract call.
+ */
+export declare const VAULT_ACTION_DOMAIN: {
+    readonly name: "PearVaultService";
+    readonly version: "1";
+    readonly chainId: 999;
+};
+/**
+ * EIP-712 types per action — the one copy both signer and verifier import.
+ * One struct per action: every signed parameter is a readable field in the
+ * wallet prompt, and the primary-type name itself discriminates the action,
+ * so structurally identical actions can never replay into each other.
+ */
+export declare const VAULT_ACTION_TYPES: {
+    readonly 'withdraw-to-evm': {
+        readonly WithdrawToEvm: readonly [{
+            readonly name: "vault";
+            readonly type: "address";
+        }, {
+            readonly name: "amount";
+            readonly type: "string";
+        }, {
+            readonly name: "token";
+            readonly type: "string";
+        }, {
+            readonly name: "nonce";
+            readonly type: "string";
+        }, {
+            readonly name: "deadline";
+            readonly type: "uint256";
+        }];
+    };
+    readonly 'set-trader': {
+        readonly SetTrader: readonly [{
+            readonly name: "vault";
+            readonly type: "address";
+        }, {
+            readonly name: "trader";
+            readonly type: "address";
+        }, {
+            readonly name: "nonce";
+            readonly type: "string";
+        }, {
+            readonly name: "deadline";
+            readonly type: "uint256";
+        }];
+    };
+    readonly 'agent-approve': {
+        readonly AgentApprove: readonly [{
+            readonly name: "vault";
+            readonly type: "address";
+        }, {
+            readonly name: "nonce";
+            readonly type: "string";
+        }, {
+            readonly name: "deadline";
+            readonly type: "uint256";
+        }];
+    };
+    readonly 'set-unified-account': {
+        readonly SetUnifiedAccount: readonly [{
+            readonly name: "vault";
+            readonly type: "address";
+        }, {
+            readonly name: "nonce";
+            readonly type: "string";
+        }, {
+            readonly name: "deadline";
+            readonly type: "uint256";
+        }];
+    };
+    readonly 'update-metadata': {
+        readonly UpdateVaultMetadata: readonly [{
+            readonly name: "vault";
+            readonly type: "address";
+        }, {
+            readonly name: "name";
+            readonly type: "string";
+        }, {
+            readonly name: "about";
+            readonly type: "string";
+        }, {
+            readonly name: "imageUri";
+            readonly type: "string";
+        }, {
+            readonly name: "nonce";
+            readonly type: "string";
+        }, {
+            readonly name: "deadline";
+            readonly type: "uint256";
+        }];
+    };
+};
+/**
+ * EIP-712 type for a create — the one copy both signer and verifier import.
+ * Every signed parameter is a readable field in the wallet prompt.
+ */
+export declare const CREATE_VAULT_TYPES: {
+    readonly CreateVault: readonly [{
+        readonly name: "leader";
+        readonly type: "address";
+    }, {
+        readonly name: "name";
+        readonly type: "string";
+    }, {
+        readonly name: "description";
+        readonly type: "string";
+    }, {
+        readonly name: "imageUri";
+        readonly type: "string";
+    }, {
+        readonly name: "configId";
+        readonly type: "uint256";
+    }, {
+        readonly name: "maxWithdrawalPeriodDays";
+        readonly type: "uint256";
+    }, {
+        readonly name: "nonce";
+        readonly type: "string";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
+    }];
+};
+/**
+ * One action's complete signable typed data. Widened (non-generic) on purpose:
+ * viem's generic overloads cannot take a union of per-action shapes at one call site.
+ */
+export type LeaderActionTypedData = {
+    types: Record<string, readonly {
+        name: string;
+        type: string;
+    }[]>;
+    primaryType: string;
+    message: {
+        vault: `0x${string}`;
+        amount?: string;
+        token?: string;
+        trader?: `0x${string}`;
+        name?: string;
+        about?: string;
+        imageUri?: string;
+        nonce: string;
+        deadline: bigint;
+    };
+};
+/**
+ * Canonical typed-data reconstruction from the request path + body. Signer and
+ * verifier MUST call this same builder with these same normalized values:
+ *  - vault    = the :vaultAddress path segment (checksummed inside the signed EIP-712 message; storage stays lowercase)
+ *  - amount   = body.amount, verbatim decimal string (withdraw only)
+ *  - 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)
+ *  - nonce    = body.nonce (client-generated; salts the signature for idempotency)
+ *  - deadline = body.deadline (unix seconds) as uint256
+ */
+export declare function buildLeaderActionTypedData(action: LeaderActionName, vaultAddress: string, body: Record<string, unknown>): LeaderActionTypedData;
+/**
+ * Canonical CreateVault reconstruction from the request body. Signer and verifier
+ * MUST call this same builder; absent optionals sign as '' and 0.
+ */
+export declare function buildCreateVaultMessage(body: Record<string, unknown>): {
+    leader: `0x${string}`;
+    name: string;
+    description: string;
+    imageUri: string;
+    configId: bigint;
+    maxWithdrawalPeriodDays: bigint;
+    nonce: string;
+    deadline: bigint;
+};

package/dist/vaults/index.d.ts

@@ -0,0 +1 @@
+export * from './action-typed-data';

package/package.json

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