@lifi/perps-sdk-provider-lighter 35.0.0 → 36.0.0

package/dist/cjs/websocket/orderBookSide.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderBookSide = exports.askOrder = exports.bidOrder = void 0;
+const perps_sdk_1 = require("@lifi/perps-sdk");
+const bidOrder = (a, b) => (0, perps_sdk_1.compareDecimalStrings)(b, a);
+exports.bidOrder = bidOrder;
+const askOrder = (a, b) => (0, perps_sdk_1.compareDecimalStrings)(a, b);
+exports.askOrder = askOrder;
+class OrderBookSide {
+    order;
+    providerKey;
+    byPrice = new Map();
+    levels = [];
+    constructor(order, providerKey) {
+        this.order = order;
+        this.providerKey = providerKey;
+    }
+    apply(updates) {
+        for (const { price, size } of updates) {
+            if (!(0, perps_sdk_1.isDecimalString)(price)) {
+                perps_sdk_1.wsLog.skippedRow(this.providerKey, 'order book level', 'price', price);
+                continue;
+            }
+            if (!(0, perps_sdk_1.isDecimalString)(size)) {
+                perps_sdk_1.wsLog.skippedRow(this.providerKey, 'order book level', 'size', size);
+                this.remove(price);
+                continue;
+            }
+            if ((0, perps_sdk_1.isDecimalStringZero)(size)) {
+                this.remove(price);
+                continue;
+            }
+            const existing = this.byPrice.get(price);
+            if (existing) {
+                existing.size = size;
+            }
+            else {
+                const level = { price, size };
+                this.byPrice.set(price, level);
+                this.levels.splice(this.bound(level.price, (c) => c > 0), 0, level);
+            }
+        }
+    }
+    toLevels() {
+        return this.levels.map(({ price, size }) => ({ price, size }));
+    }
+    remove(price) {
+        const existing = this.byPrice.get(price);
+        if (existing === undefined) {
+            return;
+        }
+        this.byPrice.delete(price);
+        this.levels.splice(this.levels.indexOf(existing, this.bound(existing.price, (c) => c >= 0)), 1);
+    }
+    bound(price, isPast) {
+        let lo = 0;
+        let hi = this.levels.length;
+        while (lo < hi) {
+            const mid = (lo + hi) >>> 1;
+            if (isPast(this.order(this.levels[mid].price, price))) {
+                hi = mid;
+            }
+            else {
+                lo = mid + 1;
+            }
+        }
+        return lo;
+    }
+}
+exports.OrderBookSide = OrderBookSide;
+//# sourceMappingURL=orderBookSide.js.map

package/dist/cjs/websocket/orderBookSide.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"orderBookSide.js","sourceRoot":"","sources":["../../../src/websocket/orderBookSide.ts"],"names":[],"mappings":"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"}

package/dist/esm/LighterProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LighterProvider.d.ts","sourceRoot":"","sources":["../../src/LighterProvider.ts"],"names":[],"mappings":"AAAA,OAAO,EAeL,KAAK,mBAAmB,EAqBxB,KAAK,cAAc,EAEpB,MAAM,iBAAiB,CAAA;AAmCxB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAQnC,OAAO,EAUL,KAAK,iBAAiB,EACvB,MAAM,gBAAgB,CAAA;AAiLvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,WAAW,sBAAsB;IACrC;;;;OAIG;IACH,OAAO,CAAC,EAAE,cAAc,CAAA;IACxB;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,4FAA4F;IAC5F,oBAAoB,CAAC,EAAE,MAAM,CAAA;IAC7B,4FAA4F;IAC5F,uBAAuB,CAAC,EAAE,MAAM,CAAA;CACjC;AAcD;;;;;;;;GAQG;AACH,MAAM,WAAW,oBAAqB,SAAQ,mBAAmB;IAC/D;;;;OAIG;IACH,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAA;CAChE;AAED;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,GAChC,YAAY,iBAAiB,EAC7B,UAAS,sBAA2B,KACnC,oBAwgDF,CAAA;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,eAAe,GAC1B,UAAS,sBAA2B,KACnC,oBACyD,CAAA;AAE5D;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,iBAAiB,GAC5B,UAAS,sBAA2B,KACnC,oBAA6E,CAAA;AAEhF;;;;GAIG;AACH,eAAO,MAAM,OAAO,aA7BT,sBAAsB,KAC9B,oBA4BmC,CAAA"}
+{"version":3,"file":"LighterProvider.d.ts","sourceRoot":"","sources":["../../src/LighterProvider.ts"],"names":[],"mappings":"AAAA,OAAO,EAgBL,KAAK,mBAAmB,EAsBxB,KAAK,cAAc,EAQpB,MAAM,iBAAiB,CAAA;AAkCxB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAQnC,OAAO,EAUL,KAAK,iBAAiB,EACvB,MAAM,gBAAgB,CAAA;AA4LvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,WAAW,sBAAsB;IACrC;;;;OAIG;IACH,OAAO,CAAC,EAAE,cAAc,CAAA;IACxB;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,4FAA4F;IAC5F,oBAAoB,CAAC,EAAE,MAAM,CAAA;IAC7B,4FAA4F;IAC5F,uBAAuB,CAAC,EAAE,MAAM,CAAA;CACjC;AAcD;;;;;;;;GAQG;AACH,MAAM,WAAW,oBAAqB,SAAQ,mBAAmB;IAC/D;;;;OAIG;IACH,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAA;CAChE;AAED;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,GAChC,YAAY,iBAAiB,EAC7B,UAAS,sBAA2B,KACnC,oBA8nDF,CAAA;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,eAAe,GAC1B,UAAS,sBAA2B,KACnC,oBACyD,CAAA;AAE5D;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,iBAAiB,GAC5B,UAAS,sBAA2B,KACnC,oBAA6E,CAAA;AAEhF;;;;GAIG;AACH,eAAO,MAAM,OAAO,aA7BT,sBAAsB,KAC9B,oBA4BmC,CAAA"}

package/dist/esm/LighterProvider.js

@@ -1,6 +1,5 @@
-import { ACTIVE_ORDER_STATUSES, calculateTransferable, explorerTxUrl, explorerTxUrlFromBase, getAssetRegistry, getMarketRegistry, getMarketsContext, getProviders, isActiveOrderStatus, isDecimalString, localStorageAdapter, numberToDecimalString, PerpsError, paginateActivity, resolveQuote, resolveRetryPolicy, toPerpsMarketDisplay, } from '@lifi/perps-sdk';
+import { ACTIVE_ORDER_STATUSES, calculateTransferable, estimateLiquidationPriceAtMarketRate, explorerTxUrl, explorerTxUrlFromBase, getAssetRegistry, getMarketRegistry, getMarketsContext, getProviders, isActiveOrderStatus, isDecimalStringGreaterThan, localStorageAdapter, numberToDecimalString, PerpsError, paginateActivity, resolveQuote, resolveRetryPolicy, safeAbsDecimalString, safeAddDecimalString, safeMultiplyDecimalString, subtractDecimalString, toPerpsMarketDisplay, unknownToDecimalString, } from '@lifi/perps-sdk';
 import { ActionType, ActivityType, MarginMode, PerpsErrorCode, } from '@lifi/perps-types';
-import Big from 'big.js';
 import { boundAccountTiers, projectLighterConfigSettings, resolveAccountTier, } from './accountConfig.js';
 import { getAccountSummary, lighterConfig } from './accountSummary.js';
 import { lighterAvailableToTrade } from './availableToTrade.js';
@@ -15,13 +14,16 @@ import { LT_ACCOUNT_TRADING_MODE_SIMPLE, LT_ACCOUNT_TRADING_MODE_UNIFIED, LT_MAR
 import { decodeActivityCursor, encodeActivityCursor, } from './utils/activityCursor.js';
 import { LIGHTER_RETRY_DEFAULTS, LighterApiClient, LighterAuthRejectedError, LighterTokenRevokedError, } from './utils/apiClient.js';
 import { isAssetMarginEnabled } from './utils/assetCollateral.js';
-import { estimateLiquidationPrice, fetchDetailedAccount, leverageFromImf, lighterAsset, lighterWithdrawableBalances, mapFill, mapOpenPositions, mapOrder, mapPortfolioHistory, positionRemovableMargin, snapOrderPrice, snapOrderSize, toBigOrNull, toIsoFromMs, toIsoFromSeconds, toRequiredBig, } from './utils/index.js';
+import { fetchDetailedAccount, leverageFromImf, lighterAsset, lighterFastWithdrawal, lighterWithdrawableBalances, lighterWithdrawalTypes, mapFill, mapOpenPositions, mapOrder, mapPortfolioHistory, positionRemovableMargin, snapOrderPrice, snapOrderSize, toIsoFromMs, toIsoFromSeconds, } from './utils/index.js';
+import { requireOpenPositions } from './utils/mapOpenPositions.js';
 import { fetchRegisteredApiKey, normalizeLighterPublicKey, } from './utils/registeredApiKey.js';
 import { collateralSpotBalance, pooledSettlementSpendable, pooledSettlementUnits, } from './utils/settlementPool.js';
 import { spotPriceByAssetId, spotValuation } from './utils/spotPrice.js';
 import { isPlaceholderTxHash } from './utils/txHash.js';
 import { wireList } from './utils/wireList.js';
 const ZERO_FEE_TIER = { maker: '0', taker: '0' };
+/** The sum of `values`, or `undefined` when any term is not a decimal string. */
+const safeSum = (values) => values.reduce((sum, value) => sum === undefined ? undefined : safeAddDecimalString(sum, value), '0');
 const tickToFeeString = (tick) => numberToDecimalString(tick / LIGHTER_FEE_TICK_SCALE);
 const projectFeeTier = (limits) => ({
     maker: tickToFeeString(limits.current_maker_fee_tick),
@@ -306,6 +308,54 @@ export const createLighterProvider = (deployment, options = {}) => {
             return await run(fresh);
         }
     };
+    /**
+     * {@link retryOnRevoked}, then one retry with the standard token when the
+     * venue rejects the read-only one. The fallback sits outside
+     * `retryOnRevoked`, so a revocation the standard token reports never
+     * replaces the read-only one. The key is re-read at retry time because
+     * `REGISTER_API_KEY` can rotate it.
+     */
+    const retryWithStandardToken = (address, apiKey, token, run) => retryOnRevoked(address, token, run).catch(async (err) => {
+        if (!(err instanceof LighterAuthRejectedError) || apiKey === null) {
+            throw err;
+        }
+        const current = (await keyStore.get(address)) ?? apiKey;
+        return run(await getStandardAuthToken(address, current.apiKeyPrivateKey, {
+            apiKeyIndex: current.apiKeyIndex,
+            accountIndex: current.accountIndex,
+        }));
+    });
+    const perpsCategoryId = async () => {
+        const { providers } = await getProviders(requireClient());
+        return (providers
+            .find((p) => p.key === providerKey)
+            ?.categories.find((c) => c.quoteAsset !== null)?.id ?? providerKey);
+    };
+    /**
+     * The fast-withdraw terms for `accountIndex`, or `undefined` when no token
+     * resolves, a read fails, or Lighter offers no fast withdrawal.
+     */
+    const readFastWithdrawal = async (client, address, accountIndex) => {
+        try {
+            const apiKey = await keyStore.get(address);
+            const token = await resolveAuthToken(address, apiKey ?? undefined);
+            if (token === undefined) {
+                return undefined;
+            }
+            const info = await retryWithStandardToken(address, apiKey, token, (t) => client.getAuthed('/api/v1/fastwithdraw/info', t, { account_index: accountIndex }));
+            if (info.code !== 200 || !(info.to_account_index > 0)) {
+                return undefined;
+            }
+            const feeInfo = await retryWithStandardToken(address, apiKey, token, (t) => client.getAuthed('/api/v1/transferFeeInfo', t, {
+                account_index: accountIndex,
+                to_account_index: info.to_account_index,
+            }));
+            return lighterFastWithdrawal(info, feeInfo);
+        }
+        catch {
+            return undefined;
+        }
+    };
     const fetchAccountLimits = (client, accountIndex, authToken) => client.getAuthed('/api/v1/accountLimits', authToken, {
         account_index: accountIndex,
     });
@@ -409,7 +459,10 @@ export const createLighterProvider = (deployment, options = {}) => {
         if (leverage === undefined || !(leverage > 0)) {
             throw new PerpsError(PerpsErrorCode.SDKError, `The backend market '${marketId}' carries no positive Lighter default leverage`);
         }
-        return { marginMode: MarginMode.CROSS, leverage };
+        return {
+            marginMode: MarginMode.CROSS,
+            leverage: numberToDecimalString(leverage),
+        };
     };
     const resolveAccountExists = async (address, opts) => (await fetchAccountIfExists(apiClient(opts), address)) !== undefined;
     let setupPromise;
@@ -518,24 +571,24 @@ export const createLighterProvider = (deployment, options = {}) => {
                     ? readOnlyTokenManager.get(params.address, localKey.accountIndex)
                     : Promise.resolve(undefined),
             ]);
-            const positions = mapOpenPositions(account.positions, (id) => toPerpsMarketDisplay(registry.require(String(id))));
-            const totalMarginUsed = positions.reduce((sum, p) => sum.plus(toRequiredBig(p.marginUsed, 'marginUsed')), new Big(0));
-            const totalUnrealizedPnl = positions.reduce((sum, p) => sum.plus(toRequiredBig(p.unrealizedPnl, 'unrealizedPnl')), new Big(0));
+            const positions = requireOpenPositions(account.positions, (id) => toPerpsMarketDisplay(registry.require(String(id))));
+            const totalMarginUsed = safeSum(positions.map((p) => p.marginUsed));
+            const totalUnrealizedPnl = safeSum(positions.map((p) => p.unrealizedPnl));
             const instanceMeta = providers.find((p) => p.key === providerKey);
             const categories = instanceMeta?.categories ?? [];
             const perpsCategory = categories.find((c) => c.quoteAsset !== null);
-            const availableBalance = toRequiredBig(account.available_balance, 'available_balance');
+            const availableBalance = unknownToDecimalString(account.available_balance, 'available_balance', providerKey);
             // Each asset has a spot route (`balance`) and a perps route
             // (`margin_balance`). The instance's settlement asset is valued 1:1; an
             // asset no spot market prices keeps a zero USD value. A unified account
             // pools both settlement routes into one spot row.
             const isPooled = (asset) => account.account_trading_mode === LT_ACCOUNT_TRADING_MODE_UNIFIED &&
                 asset.asset_id === collateral.assetIndex;
-            const heldAssets = account.assets.filter((asset) => (isPooled(asset)
+            const heldAssets = account.assets.filter((asset) => isDecimalStringGreaterThan(isPooled(asset)
                 ? pooledSettlementUnits(asset)
-                : toRequiredBig(asset.balance, 'balance')).gt(0));
+                : unknownToDecimalString(asset.balance, 'balance', providerKey), '0'));
             const marginAssets = account.assets.filter((asset) => !isPooled(asset) &&
-                toRequiredBig(asset.margin_balance, 'margin_balance').gt(0));
+                isDecimalStringGreaterThan(unknownToDecimalString(asset.margin_balance, 'margin_balance', providerKey), '0'));
             const spotPrices = spotPriceByAssetId(registry.markets, LIGHTER_SPOT_CATEGORY_ID, prices, new Set([...heldAssets, ...marginAssets]
                 .filter((a) => a.asset_id !== collateral.assetIndex)
                 .map((a) => String(a.asset_id))));
@@ -546,7 +599,7 @@ export const createLighterProvider = (deployment, options = {}) => {
                     asset,
                     units,
                     valueUsd,
-                    ...(price === undefined ? {} : { price: price.toFixed() }),
+                    ...(price === undefined ? {} : { price }),
                 };
             };
             const registryAsset = (a) => assetRegistry.get(String(a.asset_id)) ??
@@ -559,28 +612,26 @@ export const createLighterProvider = (deployment, options = {}) => {
             // account's free margin; every other perps-route asset releases none.
             const collateralBalances = marginAssets.map((a) => {
                 const isSettlement = a.asset_id === collateral.assetIndex;
-                const marginBalance = toRequiredBig(a.margin_balance, 'margin_balance').toFixed();
+                const marginBalance = unknownToDecimalString(a.margin_balance, 'margin_balance', providerKey);
                 return {
-                    ...toBalance(a, perpsCategory?.id ?? providerKey, isSettlement ? settlementAsset : registryAsset(a), isDecimalString(a.margin_balance) ? a.margin_balance : marginBalance),
+                    ...toBalance(a, perpsCategory?.id ?? providerKey, isSettlement ? settlementAsset : registryAsset(a), marginBalance),
                     transferable: isSettlement
-                        ? calculateTransferable(availableBalance.toFixed(), marginBalance)
+                        ? calculateTransferable(availableBalance, marginBalance)
                         : '0',
                 };
             });
             const balances = heldAssets.map((a) => {
                 if (isPooled(a)) {
-                    const units = pooledSettlementUnits(a).toFixed();
+                    const units = pooledSettlementUnits(a);
                     return {
                         ...toBalance(a, LIGHTER_SPOT_CATEGORY_ID, registryAsset(a), units),
-                        transferable: calculateTransferable(pooledSettlementSpendable(a, availableBalance).toFixed(), units),
+                        transferable: calculateTransferable(pooledSettlementSpendable(a, availableBalance), units),
                     };
                 }
-                const balance = toRequiredBig(a.balance, 'balance');
+                const balance = unknownToDecimalString(a.balance, 'balance', providerKey);
                 return {
-                    ...toBalance(a, LIGHTER_SPOT_CATEGORY_ID, registryAsset(a), isDecimalString(a.balance) ? a.balance : balance.toFixed()),
-                    transferable: calculateTransferable(balance
-                        .minus(toRequiredBig(a.locked_balance, 'locked_balance'))
-                        .toFixed(), balance.toFixed()),
+                    ...toBalance(a, LIGHTER_SPOT_CATEGORY_ID, registryAsset(a), balance),
+                    transferable: calculateTransferable(subtractDecimalString(balance, unknownToDecimalString(a.locked_balance, 'locked_balance', providerKey)), balance),
                 };
             });
             const assetCollateral = account.assets.flatMap((a) => a.margin_mode === undefined
@@ -620,8 +671,12 @@ export const createLighterProvider = (deployment, options = {}) => {
                 balances,
                 collateralBalances,
                 positions,
-                marginUsed: totalMarginUsed.toFixed(),
-                unrealizedPnl: totalUnrealizedPnl.toFixed(),
+                ...(totalMarginUsed === undefined
+                    ? {}
+                    : { marginUsed: totalMarginUsed }),
+                ...(totalUnrealizedPnl === undefined
+                    ? {}
+                    : { unrealizedPnl: totalUnrealizedPnl }),
                 feeTier: limitsResult === undefined
                     ? ZERO_FEE_TIER
                     : projectFeeTier(limitsResult),
@@ -635,8 +690,21 @@ export const createLighterProvider = (deployment, options = {}) => {
             return lighterDepositFlow(providerKey, await resolveAccountExists(params.address, opts));
         },
         async getWithdrawableBalances(params, opts) {
-            const account = await fetchDetailedAccount(apiClient(opts), params.address);
-            return lighterWithdrawableBalances(account, collateral.assetIndex);
+            const [account, categoryId] = await Promise.all([
+                fetchDetailedAccount(apiClient(opts), params.address),
+                perpsCategoryId(),
+            ]);
+            return lighterWithdrawableBalances(account, collateral.assetIndex, categoryId);
+        },
+        async getWithdrawalTypes(params, opts) {
+            const client = apiClient(opts);
+            const [account, categoryId] = await Promise.all([
+                fetchDetailedAccount(client, params.address),
+                perpsCategoryId(),
+            ]);
+            const rows = lighterWithdrawableBalances(account, collateral.assetIndex, categoryId);
+            const fast = await readFastWithdrawal(client, params.address, account.index);
+            return lighterWithdrawalTypes(rows, { categoryId, asset: { id: String(collateral.assetIndex) } }, fast);
         },
         async getPositions(params, opts) {
             const client = apiClient(opts);
@@ -668,8 +736,7 @@ export const createLighterProvider = (deployment, options = {}) => {
             }
             const account = await plugin.getAccount({ address: params.address }, opts);
             const config = lighterConfig(account);
-            const crossFreeCollateral = toRequiredBig(config.crossAssetValue, 'crossAssetValue').minus(toRequiredBig(config.crossInitialMarginRequirement, 'crossInitialMarginRequirement'));
-            return lighterAvailableToTrade(market, crossFreeCollateral.toFixed(), account.positions);
+            return lighterAvailableToTrade(market, subtractDecimalString(unknownToDecimalString(config.crossAssetValue, 'crossAssetValue', providerKey), unknownToDecimalString(config.crossInitialMarginRequirement, 'crossInitialMarginRequirement', providerKey)), account.positions);
         },
         /**
          * Lighter reports a market's margin mode and leverage on the account's
@@ -687,7 +754,7 @@ export const createLighterProvider = (deployment, options = {}) => {
             // An unparsable IMF throws; a non-positive one means no stored setting.
             const leverage = row === undefined
                 ? undefined
-                : leverageFromImf(toRequiredBig(row.initial_margin_fraction, 'initial_margin_fraction').toFixed());
+                : leverageFromImf(unknownToDecimalString(row.initial_margin_fraction, 'initial_margin_fraction', providerKey));
             if (row === undefined || leverage === undefined) {
                 return resolveDefaultMarketSettings(marketId);
             }
@@ -755,7 +822,7 @@ export const createLighterProvider = (deployment, options = {}) => {
                         continue;
                     }
                     const order = mapOrder(raw, market);
-                    if (statuses.has(order.status)) {
+                    if (order !== undefined && statuses.has(order.status)) {
                         orders.push(order);
                     }
                 }
@@ -790,7 +857,14 @@ export const createLighterProvider = (deployment, options = {}) => {
                 registry.sync(),
             ]);
             const notFound = () => new PerpsError(PerpsErrorCode.OrderNotFound, `Lighter order ${params.id} not found for ${params.address}`);
-            const detail = (order) => mapOrder(order, registry.require(String(order.market_index)));
+            const mapDetail = (order) => mapOrder(order, registry.require(String(order.market_index)));
+            const detail = (order) => {
+                const mapped = mapDetail(order);
+                if (mapped === undefined) {
+                    throw notFound();
+                }
+                return mapped;
+            };
             // A tx-hash route would require mapping the caller's executeAction tx
             // hash → wasm nonce → matching order, which the LI.FI backend did via
             // its `UserAction` table; the SDK has no equivalent persistence, so we
@@ -813,7 +887,7 @@ export const createLighterProvider = (deployment, options = {}) => {
                 // client order index can match more than one row. Prefer the live one.
                 const matches = orders
                     .filter((o) => String(o.client_order_index) === clientOrderIndex)
-                    .map(detail);
+                    .flatMap((o) => mapDetail(o) ?? []);
                 const hit = matches.find((o) => isActiveOrderStatus(o.status)) ?? matches[0];
                 if (hit === undefined) {
                     throw notFound();
@@ -861,10 +935,8 @@ export const createLighterProvider = (deployment, options = {}) => {
             // resolves, so its rows stay.
             const items = wireList(response.trades).flatMap((t) => {
                 const market = registry.get(String(t.market_id));
-                if (market === undefined) {
-                    return [];
-                }
-                return [mapFill(t, account.index, market)];
+                const mapped = market && mapFill(t, account.index, market);
+                return mapped ? [mapped] : [];
             });
             return {
                 provider: providerKey,
@@ -895,22 +967,9 @@ export const createLighterProvider = (deployment, options = {}) => {
                 ignore_transfers: false,
             };
             const read = (tok) => client.getAuthed('/api/v1/pnl', tok, queryParams);
-            // The read-only token may not be accepted on `/pnl`; the standard token
-            // is, so a read signed from the SDK's own key retries once with it. The
-            // fallback sits outside `retryOnRevoked`, so a revocation the standard
-            // token reports never replaces the read-only one. The key is re-read at
-            // retry time because `REGISTER_API_KEY` can rotate it.
-            const response = await retryOnRevoked(params.address, token, read).catch(async (err) => {
-                if (!(err instanceof LighterAuthRejectedError) || apiKey === null) {
-                    throw err;
-                }
-                const current = (await keyStore.get(params.address)) ?? apiKey;
-                return read(await getStandardAuthToken(params.address, current.apiKeyPrivateKey, {
-                    apiKeyIndex: current.apiKeyIndex,
-                    accountIndex: current.accountIndex,
-                }));
-            });
-            return mapPortfolioHistory(params.range, wireList(response.pnl), new Big(getAccountSummary(account, account.positions).portfolioValue));
+            // The read-only token may not be accepted on `/pnl`; the standard token is.
+            const response = await retryWithStandardToken(params.address, apiKey, token, read);
+            return mapPortfolioHistory(params.range, wireList(response.pnl), getAccountSummary(account, account.positions).portfolioValue);
         },
         async getActivity(params, opts) {
             const token = await requireAuthToken('activity read', params.address);
@@ -986,8 +1045,8 @@ export const createLighterProvider = (deployment, options = {}) => {
                     if (market === undefined) {
                         return [];
                     }
-                    const price = toBigOrNull(l.trade.price);
-                    const size = toBigOrNull(l.trade.size);
+                    const notional = safeMultiplyDecimalString(l.trade.price, l.trade.size);
+                    const liquidatedNotionalPosition = notional === undefined ? undefined : safeAbsDecimalString(notional);
                     const marginMode = wireList(l.info.positions).find((p) => p.market_id === l.market_id)?.margin_mode;
                     // Lighter reports the margin mode as an integer, so the venue
                     // vocabulary the contract asks for is the SDK's own literal. An
@@ -1004,14 +1063,9 @@ export const createLighterProvider = (deployment, options = {}) => {
                             provider: providerKey,
                             timestamp: toIsoFromMs(l.executed_at),
                             type: ActivityType.LIQUIDATION,
-                            ...(price === null || size === null
+                            ...(liquidatedNotionalPosition === undefined
                                 ? {}
-                                : {
-                                    liquidatedNotionalPosition: price
-                                        .times(size)
-                                        .abs()
-                                        .toFixed(),
-                                }),
+                                : { liquidatedNotionalPosition }),
                             // The account value at liquidation time is the pre-trade
                             // snapshot, not the settled one Lighter also reports.
                             ...(accountValue === undefined ? {} : { accountValue }),
@@ -1075,7 +1129,7 @@ export const createLighterProvider = (deployment, options = {}) => {
         },
         snapOrderPrice,
         snapOrderSize,
-        estimateLiquidationPrice,
+        estimateLiquidationPrice: estimateLiquidationPriceAtMarketRate,
         positionRemovableMargin,
         projectConfig(config, setup) {
             if (config.provider !== providerKey) {