@pear-protocol/exchanges-sdk 0.3.0 → 0.5.0

package/dist/syncer/hyperliquid/syncer.test.js

@@ -0,0 +1,274 @@
+import { vi, describe, beforeEach, it, expect } from 'vitest';
+import { HyperliquidAccountSyncer } from './syncer';
+
+const { fetchInfoMock } = vi.hoisted(() => ({ fetchInfoMock: vi.fn() }));
+vi.mock("../../client/hyperliquid/rest", () => ({ fetchInfo: fetchInfoMock }));
+const account = {
+  exchangeIdentifier: "0x1111111111111111111111111111111111111111"
+};
+const instrument = {
+  id: "HL-BTC",
+  base: "BTC"
+};
+function rawFill(time, tid = time) {
+  return {
+    coin: "BTC",
+    px: "100000",
+    sz: "0.1",
+    side: "B",
+    time,
+    startPosition: "0",
+    dir: "Open Long",
+    closedPnl: "0",
+    hash: "0xabc",
+    oid: 123,
+    crossed: true,
+    fee: "1",
+    builderFee: "0.2",
+    tid,
+    feeToken: "USDC",
+    twapId: null
+  };
+}
+function createSyncer() {
+  return new HyperliquidAccountSyncer({
+    sdk: {},
+    connector: "hyperliquid",
+    account,
+    credentials: { signer_key: "sk" },
+    demo: true
+  });
+}
+describe("HyperliquidAccountSyncer fill mapping", () => {
+  beforeEach(() => {
+    fetchInfoMock.mockReset().mockImplementation(async (body) => {
+      if (body.type === "userTwapSliceFillsByTime") {
+        return [];
+      }
+      return [
+        {
+          coin: "BTC",
+          px: "100000",
+          sz: "0.1",
+          side: "B",
+          time: 17e11,
+          startPosition: "0",
+          dir: "Open Long",
+          closedPnl: "0",
+          hash: "0xabc",
+          oid: 123,
+          crossed: true,
+          fee: "1",
+          builderFee: "0.2",
+          tid: 456,
+          feeToken: "USDC",
+          twapId: null
+        }
+      ];
+    });
+  });
+  it("uses a globally unique identity, excludes builder fee from trade fee, and routes to testnet", async () => {
+    const syncer = createSyncer();
+    const fills = await syncer.listExternalFills({
+      since: /* @__PURE__ */ new Date(1699999e6),
+      instruments: [instrument],
+      openPositions: [],
+      provisionalFills: []
+    });
+    expect(fills).toEqual([
+      expect.objectContaining({
+        exchangeFillId: "1700000000000:BTC:456",
+        tradeFee: "0.8",
+        builderFee: "0.2"
+      })
+    ]);
+    expect(fetchInfoMock).toHaveBeenCalledWith(expect.objectContaining({ type: "userFillsByTime" }), true);
+    expect(fetchInfoMock).toHaveBeenCalledWith(
+      expect.objectContaining({ type: "userFillsByTime", aggregateByTime: false }),
+      true
+    );
+    expect(fetchInfoMock).toHaveBeenCalledWith(
+      expect.objectContaining({ type: "userTwapSliceFillsByTime", aggregateByTime: false }),
+      true
+    );
+  });
+  it("fails closed when a maker rebate cannot satisfy the backend external-fill fee contract", async () => {
+    fetchInfoMock.mockImplementation(async (body) => {
+      if (body.type === "userTwapSliceFillsByTime") return [];
+      return [
+        {
+          coin: "BTC",
+          px: "100000",
+          sz: "0.1",
+          side: "B",
+          time: 17e11,
+          startPosition: "0",
+          dir: "Open Long",
+          closedPnl: "0",
+          hash: "0xabc",
+          oid: 123,
+          crossed: false,
+          fee: "-0.08",
+          builderFee: "0.02",
+          tid: 456,
+          feeToken: "USDC",
+          twapId: null
+        }
+      ];
+    });
+    const syncer = createSyncer();
+    await expect(
+      syncer.listExternalFills({
+        since: /* @__PURE__ */ new Date(1699999e6),
+        instruments: [instrument],
+        openPositions: [],
+        provisionalFills: []
+      })
+    ).rejects.toThrow(
+      "Hyperliquid fill 1700000000000:BTC:456 has a negative net trade fee (-0.1); the backend external-fill contract does not accept Hyperliquid rebates."
+    );
+  });
+  it("warns when inclusive fill pagination cannot move past the current timestamp", async () => {
+    const consoleWarn = vi.spyOn(console, "warn").mockImplementation(() => void 0);
+    const event = {
+      coin: "BTC",
+      px: "100000",
+      sz: "0.1",
+      side: "B",
+      time: 1e3,
+      startPosition: "0",
+      dir: "Open Long",
+      closedPnl: "0",
+      hash: "0xabc",
+      oid: 123,
+      crossed: true,
+      fee: "1",
+      builderFee: "0.2",
+      tid: 456,
+      feeToken: "USDC",
+      twapId: null
+    };
+    fetchInfoMock.mockImplementation(
+      async (body) => body.type === "userFillsByTime" ? Array.from({ length: 2e3 }, () => event) : []
+    );
+    const syncer = createSyncer();
+    await syncer.listExternalFills({
+      since: /* @__PURE__ */ new Date(1e3),
+      instruments: [instrument],
+      openPositions: [],
+      provisionalFills: []
+    });
+    expect(consoleWarn).toHaveBeenCalledWith(
+      "Hyperliquid fills pagination stalled at timestamp 1000; returned history may be incomplete."
+    );
+    expect(fetchInfoMock).toHaveBeenCalledTimes(2);
+    consoleWarn.mockRestore();
+  });
+  it("counts raw fills before rejecting history older than the 10,000-fill retention boundary", async () => {
+    let page = 0;
+    fetchInfoMock.mockImplementation(async (body) => {
+      if (body.type !== "userFillsByTime") return [];
+      const firstTime = 1e3 + page * 2e3;
+      page += 1;
+      return Array.from({ length: 2e3 }, (_, index) => rawFill(firstTime + index));
+    });
+    const syncer = createSyncer();
+    await expect(
+      syncer.listExternalFills({
+        since: /* @__PURE__ */ new Date(0),
+        instruments: [instrument],
+        openPositions: [],
+        provisionalFills: []
+      })
+    ).rejects.toThrow(
+      "Hyperliquid fill history is incomplete: requested since 0 predates oldest reachable fill 1000 within the 10000-fill retention limit."
+    );
+    expect(fetchInfoMock).toHaveBeenCalledTimes(5);
+    expect(fetchInfoMock).toHaveBeenCalledWith(expect.objectContaining({ aggregateByTime: false }), true);
+  });
+  it("accepts a request exactly at the oldest reachable fill at the retention boundary", async () => {
+    let page = 0;
+    fetchInfoMock.mockImplementation(async (body) => {
+      if (body.type === "userTwapSliceFillsByTime") return [];
+      if (page >= 5) return [];
+      const firstTime = 1e3 + page * 2e3;
+      page += 1;
+      return Array.from({ length: 2e3 }, (_, index) => rawFill(firstTime + index));
+    });
+    const syncer = createSyncer();
+    const fills = await syncer.listExternalFills({
+      since: /* @__PURE__ */ new Date(1e3),
+      instruments: [instrument],
+      openPositions: [],
+      provisionalFills: []
+    });
+    expect(fills).toHaveLength(1e4);
+    expect(fetchInfoMock).toHaveBeenCalledTimes(7);
+  });
+});
+describe("HyperliquidAccountSyncer position and funding snapshots", () => {
+  beforeEach(() => {
+    fetchInfoMock.mockReset();
+  });
+  it("de-duplicates DEX descriptors and derives mark price from current position value", async () => {
+    fetchInfoMock.mockImplementation(async (body) => {
+      if (body.type === "perpDexs") return [null, null, { name: "xyz" }];
+      if (body.type === "clearinghouseState" && body.dex === "") {
+        return {
+          assetPositions: [
+            {
+              position: {
+                coin: "BTC",
+                szi: "2",
+                entryPx: "150",
+                positionValue: "400"
+              }
+            }
+          ]
+        };
+      }
+      if (body.type === "clearinghouseState") return { assetPositions: [] };
+      throw new Error(`Unexpected request: ${body.type}`);
+    });
+    const syncer = createSyncer();
+    const positions = await syncer.listExternalPositions({
+      instruments: [
+        {
+          ...instrument,
+          precision: { quantity: { contractSize: 1 } }
+        }
+      ]
+    });
+    expect(positions).toEqual([
+      expect.objectContaining({ symbol: "HL-BTC", size: "2", entryPrice: "150", markPrice: "200" })
+    ]);
+    expect(fetchInfoMock).toHaveBeenCalledTimes(3);
+  });
+  it("de-duplicates an inclusive funding boundary and stops when its cursor cannot advance", async () => {
+    const consoleWarn = vi.spyOn(console, "warn").mockImplementation(() => void 0);
+    const event = {
+      time: 1e3,
+      hash: "0xabc",
+      delta: {
+        type: "funding",
+        coin: "BTC",
+        usdc: "-2",
+        szi: "4",
+        fundingRate: "0.0001",
+        nSamples: null
+      }
+    };
+    fetchInfoMock.mockResolvedValue(Array.from({ length: 500 }, () => event));
+    const syncer = createSyncer();
+    const payments = await syncer.listExternalFunding({
+      since: /* @__PURE__ */ new Date(1e3),
+      instruments: [instrument]
+    });
+    expect(payments).toHaveLength(1);
+    expect(fetchInfoMock).toHaveBeenCalledTimes(1);
+    expect(consoleWarn).toHaveBeenCalledWith(
+      "Hyperliquid funding pagination stalled at timestamp 1000; returned history may be incomplete."
+    );
+    consoleWarn.mockRestore();
+  });
+});

package/dist/syncer/lighter/funding.js

@@ -0,0 +1,25 @@
+import BigNumber from 'bignumber.js';
+
+function toFundingPaymentEntries(events, instrumentIds) {
+  return events.reduce((entries, event) => {
+    const instrumentId = event.market_id.toString();
+    if (!instrumentIds.has(instrumentId)) {
+      console.warn(`Lighter market id ${event.market_id} not found in instrument id map.`);
+      return entries;
+    }
+    const unsignedSize = new BigNumber(event.position_size).abs();
+    const signedSize = event.position_side === "short" ? unsignedSize.negated() : unsignedSize;
+    const fundingPerUnit = signedSize.isZero() ? "0" : new BigNumber(event.change).div(signedSize).toFixed();
+    entries.push({
+      connector: "lighter",
+      instrumentId,
+      fundingRate: event.rate,
+      notional: event.change,
+      fundingPerUnit,
+      timestamp: event.timestamp
+    });
+    return entries;
+  }, []);
+}
+
+export { toFundingPaymentEntries };

package/dist/syncer/lighter/funding.test.js

@@ -0,0 +1,48 @@
+import { describe, it, expect } from 'vitest';
+import { toFundingPaymentEntries } from './funding';
+
+describe("Lighter funding mapping", () => {
+  it("derives funding per unit against signed long and short exposure", () => {
+    const result = toFundingPaymentEntries(
+      [
+        fundingEvent({ funding_id: 1, position_side: "long", change: "-2" }),
+        fundingEvent({ funding_id: 2, position_side: "short", change: "2" })
+      ],
+      /* @__PURE__ */ new Set(["1"])
+    );
+    expect(result).toEqual([
+      {
+        connector: "lighter",
+        instrumentId: "1",
+        fundingRate: "0.0001",
+        notional: "-2",
+        fundingPerUnit: "-0.5",
+        timestamp: 1e3
+      },
+      {
+        connector: "lighter",
+        instrumentId: "1",
+        fundingRate: "0.0001",
+        notional: "2",
+        fundingPerUnit: "-0.5",
+        timestamp: 1e3
+      }
+    ]);
+  });
+  it("skips funding for unknown instruments", () => {
+    expect(toFundingPaymentEntries([fundingEvent({})], /* @__PURE__ */ new Set())).toEqual([]);
+  });
+});
+function fundingEvent(overrides) {
+  return {
+    timestamp: 1e3,
+    market_id: 1,
+    funding_id: 1,
+    change: "-2",
+    discount: "0",
+    rate: "0.0001",
+    position_size: "4",
+    position_side: "long",
+    ...overrides
+  };
+}

package/dist/syncer/lighter/syncer.js

@@ -1,6 +1,7 @@
 import BigNumber from 'bignumber.js';
-import { fetchAccount, fetchTradesSince } from '../../client/lighter/rest';
+import { fetchAccount, fetchTradesSince, fetchPositionFundingSince } from '../../client/lighter/rest';
 import { BaseAccountSyncer } from '../base';
+import { toFundingPaymentEntries } from './funding';
 
 const LIGHTER_FEE_TICK_DENOMINATOR = new BigNumber(1e6);
 class LighterAccountSyncer extends BaseAccountSyncer {
@@ -20,7 +21,7 @@ class LighterAccountSyncer extends BaseAccountSyncer {
     const contractSizeByInstrumentId = new Map(
       instruments.map((instrument) => [instrument.id, instrument.precision.quantity.contractSize])
     );
-    const response = await fetchAccount(this.accountIndex);
+    const response = await fetchAccount(this.accountIndex, this.demo);
     const rawPositions = response.accounts?.[0]?.positions ?? [];
     return rawPositions.reduce((positions, rawPosition) => {
       const instrumentId = rawPosition.market_id.toString();
@@ -29,12 +30,13 @@ class LighterAccountSyncer extends BaseAccountSyncer {
       const contractSize = contractSizeByInstrumentId.get(instrumentId) ?? 1;
       const size = signedSize.abs().times(contractSize).toFixed();
       const side = rawPosition.sign === 1 ? "BUY" : "SELL";
+      const markPrice = new BigNumber(rawPosition.position_value).abs().div(size).toFixed();
       positions.push({
         symbol: instrumentId,
         size,
         side,
         entryPrice: rawPosition.avg_entry_price,
-        markPrice: rawPosition.avg_entry_price
+        markPrice
       });
       return positions;
     }, []);
@@ -43,12 +45,13 @@ class LighterAccountSyncer extends BaseAccountSyncer {
     since,
     instruments
   }) {
+    this.assertAuthenticatedSyncAvailable();
     const { token } = await this.sdk.core.misc.lighter.createAuthToken({
       accountIndex: this.accountIndex,
       apiKeyIndex: this.apiKeyIndex,
       apiPrivateKey: this.apiPrivateKey
     });
-    const trades = await fetchTradesSince(this.accountIndex, token, since);
+    const trades = await fetchTradesSince(this.accountIndex, token, since, this.demo);
     const instrumentIds = new Set(instruments.map((instrument) => instrument.id));
     return trades.toSorted((a, b) => a.timestamp - b.timestamp).reduce((fills, rawFill) => {
       const instrumentId = rawFill.market_id.toString();
@@ -76,8 +79,19 @@ class LighterAccountSyncer extends BaseAccountSyncer {
       return fills;
     }, []);
   }
-  async listExternalFunding(_params) {
-    throw new Error("funding sync is not implemented for lighter");
+  async listExternalFunding({
+    since,
+    instruments
+  }) {
+    this.assertAuthenticatedSyncAvailable();
+    const { token } = await this.sdk.core.misc.lighter.createAuthToken({
+      accountIndex: this.accountIndex,
+      apiKeyIndex: this.apiKeyIndex,
+      apiPrivateKey: this.apiPrivateKey
+    });
+    const fundingEvents = await fetchPositionFundingSince(this.accountIndex, token, since, this.demo);
+    const instrumentIds = new Set(instruments.map((instrument) => instrument.id));
+    return toFundingPaymentEntries(fundingEvents, instrumentIds);
   }
   isReduceOnly(rawFill) {
     if (rawFill.type === "liquidation" || rawFill.type === "deleverage" || rawFill.type === "market-settlement") {
@@ -87,6 +101,10 @@ class LighterAccountSyncer extends BaseAccountSyncer {
     if (!accountSide) {
       return false;
     }
+    const positionSignChanged = this.isMaker(rawFill, accountSide) ? rawFill.maker_position_sign_changed : rawFill.taker_position_sign_changed;
+    if (positionSignChanged) {
+      return false;
+    }
     const positionSizeBefore = this.getPositionSizeBefore(rawFill, accountSide);
     if (positionSizeBefore.isZero()) {
       return false;
@@ -116,6 +134,12 @@ class LighterAccountSyncer extends BaseAccountSyncer {
     const rateTick = this.isMaker(rawFill, side) ? rawFill.integrator_maker_fee : rawFill.integrator_taker_fee;
     return this.feeTickToAmount(rateTick, rawFill.usd_amount);
   }
+  /** Prevents testnet reads from silently minting a mainnet auth token. */
+  assertAuthenticatedSyncAvailable() {
+    if (this.demo) {
+      throw new Error("Lighter demo authenticated sync is unavailable because backend signing is mainnet-only");
+    }
+  }
   // Lighter fees come as ppm rates (÷1e6), not amounts — the charged fee is that rate times the trade's USD notional.
   feeTickToAmount(rateTick, usdAmount) {
     const rate = new BigNumber(rateTick ?? 0).abs().div(LIGHTER_FEE_TICK_DENOMINATOR);

package/dist/syncer/lighter/syncer.test.js

@@ -1,8 +1,10 @@
 import { vi, describe, beforeEach, it, expect } from 'vitest';
-import { fetchTradesSince } from '../../client/lighter/rest';
+import { fetchTradesSince, fetchPositionFundingSince, fetchAccount } from '../../client/lighter/rest';
 import { LighterAccountSyncer } from './syncer';
 
 vi.mock("../../client/lighter/rest", () => ({
+  fetchAccount: vi.fn(),
+  fetchPositionFundingSince: vi.fn(),
   fetchTradesSince: vi.fn()
 }));
 const ACCOUNT_INDEX = 87440;
@@ -78,11 +80,29 @@ const TRADES = [
     taker_position_size_before: "0.00000",
     maker_position_size_before: "0.00000",
     integrator_maker_fee: 50
+  },
+  {
+    // A flip is not a reduce-only fill: Lighter explicitly reports that the
+    // account-side position sign changed after crossing through zero.
+    trade_id: 90000000002,
+    trade_id_str: "90000000002",
+    type: "trade",
+    market_id: 1,
+    size: "0.00200",
+    price: "65000.0",
+    usd_amount: "130.000000",
+    ask_account_id: ACCOUNT_INDEX,
+    bid_account_id: 726722,
+    is_maker_ask: false,
+    timestamp: 1782050001e3,
+    taker_position_size_before: "0.00100",
+    taker_position_sign_changed: true,
+    maker_position_size_before: "0.00000"
   }
 ];
-function createSyncer() {
+function createSyncer(demo = false, createAuthToken = vi.fn().mockResolvedValue({ token: "test-token" })) {
   const sdk = {
-    core: { misc: { lighter: { createAuthToken: vi.fn().mockResolvedValue({ token: "test-token" }) } } }
+    core: { misc: { lighter: { createAuthToken } } }
   };
   const config = {
     sdk,
@@ -90,12 +110,12 @@ function createSyncer() {
     account: { exchangeIdentifier: String(ACCOUNT_INDEX) },
     credentials: { api_key_index: 0, api_private_key: "test-key" },
     ws: {},
-    demo: false
+    demo
   };
   return new LighterAccountSyncer(config);
 }
-async function listFills() {
-  const syncer = createSyncer();
+async function listFills(demo = false) {
+  const syncer = createSyncer(demo);
   const params = {
     since: /* @__PURE__ */ new Date(0),
     instruments: [{ id: "1" }],
@@ -104,6 +124,26 @@ async function listFills() {
   };
   return syncer.listExternalFills(params);
 }
+async function listFunding(demo = false) {
+  const syncer = createSyncer(demo);
+  const params = {
+    since: /* @__PURE__ */ new Date(1e3),
+    instruments: [{ id: "1" }]
+  };
+  return syncer.listExternalFunding(params);
+}
+async function listPositions() {
+  const syncer = createSyncer();
+  const params = {
+    instruments: [
+      {
+        id: "1",
+        precision: { quantity: { contractSize: 0.01 } }
+      }
+    ]
+  };
+  return syncer.listExternalPositions(params);
+}
 const byId = (fills, id) => fills.find((fill) => fill.exchangeFillId === id);
 describe("LighterAccountSyncer fee mapping", () => {
   beforeEach(() => {
@@ -145,4 +185,90 @@ describe("LighterAccountSyncer fee mapping", () => {
       builderFee: "0.005"
     });
   });
+  it("does not classify a position flip as reduce-only", async () => {
+    const fills = await listFills();
+    expect(byId(fills, "90000000002")).toMatchObject({
+      side: "SELL",
+      reduceOnly: false
+    });
+  });
+});
+describe("LighterAccountSyncer funding mapping", () => {
+  it("fetches paginated position funding with the generated auth token", async () => {
+    vi.mocked(fetchPositionFundingSince).mockResolvedValue([
+      {
+        timestamp: 1e3,
+        market_id: 1,
+        funding_id: 7,
+        change: "-2",
+        discount: "0",
+        rate: "0.0001",
+        position_size: "4",
+        position_side: "long"
+      }
+    ]);
+    await expect(listFunding()).resolves.toEqual([
+      {
+        connector: "lighter",
+        instrumentId: "1",
+        fundingRate: "0.0001",
+        notional: "-2",
+        fundingPerUnit: "-0.5",
+        timestamp: 1e3
+      }
+    ]);
+    expect(fetchPositionFundingSince).toHaveBeenCalledWith(ACCOUNT_INDEX, "test-token", /* @__PURE__ */ new Date(1e3), false);
+  });
+});
+describe("LighterAccountSyncer demo authentication boundary", () => {
+  it("rejects authenticated demo history reads before minting a mainnet token", async () => {
+    vi.clearAllMocks();
+    await expect(listFills(true)).rejects.toThrow("backend signing is mainnet-only");
+    await expect(listFunding(true)).rejects.toThrow("backend signing is mainnet-only");
+    expect(fetchTradesSince).not.toHaveBeenCalled();
+    expect(fetchPositionFundingSince).not.toHaveBeenCalled();
+  });
+});
+describe("LighterAccountSyncer position mapping", () => {
+  it("derives mark price from position value in normalized base units", async () => {
+    vi.mocked(fetchAccount).mockResolvedValue({
+      code: 200,
+      accounts: [
+        {
+          account_type: 0,
+          collateral: "1000",
+          total_asset_value: "1000",
+          available_balance: "900",
+          cross_asset_value: "1000",
+          cross_initial_margin_requirement: "100",
+          cross_maintenance_margin_requirement: "50",
+          positions: [
+            {
+              market_id: 1,
+              symbol: "BTC",
+              initial_margin_fraction: "10",
+              sign: -1,
+              position: "100",
+              avg_entry_price: "50000",
+              position_value: "60000",
+              unrealized_pnl: "-10000",
+              liquidation_price: "70000",
+              margin_mode: 0,
+              allocated_margin: "0"
+            }
+          ]
+        }
+      ]
+    });
+    await expect(listPositions()).resolves.toEqual([
+      {
+        symbol: "1",
+        size: "1",
+        side: "SELL",
+        entryPrice: "50000",
+        markPrice: "60000"
+      }
+    ]);
+    expect(fetchAccount).toHaveBeenCalledWith(ACCOUNT_INDEX, false);
+  });
 });

package/dist/tracker/base.js

@@ -1,8 +1,9 @@
 class BaseAccountTracker {
   onError;
   demo;
-  credentials = null;
+  credentials;
   balance = null;
+  balanceInitialized = false;
   positions = /* @__PURE__ */ new Map();
   initialized = false;
   balanceListeners = /* @__PURE__ */ new Set();
@@ -10,11 +11,17 @@ class BaseAccountTracker {
   assetEntries = /* @__PURE__ */ new Map();
   constructor(config) {
     this.demo = config.demo;
+    this.credentials = config.credentials;
     this.onError = (error) => {
       console.warn("[AccountTracker] error:", error.message);
       config.onError?.(error);
     };
   }
+  async snapshotAssets(coins) {
+    const unique = [...new Set(coins)];
+    if (unique.length === 0) return {};
+    return this.fetchAssetSnapshots(unique);
+  }
   async disconnect() {
     this.balanceListeners.clear();
     this.positionListeners.clear();
@@ -33,7 +40,7 @@ class BaseAccountTracker {
   }
   trackBalance(cb) {
     this.balanceListeners.add(cb);
-    if (this.balance) this.notify(cb, this.balance);
+    if (this.balanceInitialized) this.notify(cb, this.balance);
     return () => this.balanceListeners.delete(cb);
   }
   trackPosition(cb) {
@@ -70,17 +77,27 @@ class BaseAccountTracker {
   getTrackedAsset(coin) {
     return this.assetEntries.get(coin)?.info ?? null;
   }
+  /** Drops cached account snapshots without broadcasting a fabricated explicit-null update. */
+  resetAccountState() {
+    this.balance = null;
+    this.balanceInitialized = false;
+    this.positions.clear();
+    this.initialized = false;
+  }
   onStateUpdate(update) {
-    if (update.balance) this.applyBalanceUpdate(update.balance);
-    if (update.positions) this.applyPositionsUpdate(update.positions);
+    const hasAccountState = update.balance !== void 0 || update.positions !== void 0;
+    if (update.balance !== void 0) this.applyBalanceUpdate(update.balance);
+    if (update.positions) this.applyPositionsUpdate(update.positions, update.positionsMode ?? "merge");
     if (update.trackedAssets) this.applyTrackedAssetsUpdate(update.trackedAssets);
-    if (!this.initialized) this.initialized = true;
+    if (hasAccountState && !this.initialized) this.initialized = true;
   }
   applyBalanceUpdate(balance) {
     this.balance = balance;
+    this.balanceInitialized = true;
     this.broadcast(this.balanceListeners, balance);
   }
-  applyPositionsUpdate(positions) {
+  applyPositionsUpdate(positions, mode) {
+    if (mode === "replace") this.positions.clear();
     for (const [key, pos] of positions) {
       if (pos.size === "0") this.positions.delete(key);
       else this.positions.set(key, pos);