@lifi/perps-sdk-provider-hyperliquid 13.0.1 → 14.0.0

package/src/HyperliquidProvider.ts

@@ -17,7 +17,6 @@ import {
   type ProviderGetPortfolioHistoryParams,
   type ProviderGetPositionsParams,
   type ProviderGetQuoteParams,
-  type ProviderGetRunningTwapsParams,
   resolveQuote,
   type SDKRequestOptions,
   type SignActionsContext,
@@ -46,7 +45,6 @@ import {
   type Quote,
   type SignedActionStep,
   type SigningMethod,
-  type TwapOrder,
 } from '@lifi/perps-types'
 import { type Address, type Hex, isAddress } from 'viem'
 import { projectHyperliquidConfigSettings } from './accountConfig.js'
@@ -67,7 +65,6 @@ import { getOrder } from './services/getOrder.js'
 import { getOrders } from './services/getOrders.js'
 import { getPortfolioHistory } from './services/getPortfolioHistory.js'
 import { getPositions } from './services/getPositions.js'
-import { getRunningTwaps } from './services/getRunningTwaps.js'
 import {
   type HyperliquidAgent,
   HyperliquidAgentStore,
@@ -331,22 +328,13 @@ export function hyperliquidProvider(
         contextRef.require(),
         {
           address: params.address,
+          statuses: params.statuses,
           marketId: params.marketId,
           limit: params.limit,
         },
         opts
       ),
 
-    getRunningTwaps: (
-      params: ProviderGetRunningTwapsParams,
-      opts?: SDKRequestOptions
-    ): Promise<TwapOrder[]> =>
-      getRunningTwaps(
-        contextRef.require(),
-        { address: params.address, marketId: params.marketId },
-        opts
-      ),
-
     getOrder: (
       params: ProviderGetOrderParams,
       opts?: SDKRequestOptions

package/src/constants.ts

@@ -15,6 +15,16 @@ export const PROVIDER_KEY = 'hyperliquid'
  */
 export const DEFAULT_HYPERLIQUID_API_URL = 'https://api.hyperliquid.xyz'
 
+/**
+ * Hyperliquid explorer RPC endpoint. It serves the `userDetails` transaction
+ * window from a host separate from the REST API, and it answers a browser
+ * cross-origin POST.
+ *
+ * @public
+ */
+export const HYPERLIQUID_EXPLORER_RPC_URL =
+  'https://rpc.hyperliquid.xyz/explorer'
+
 /**
  * Approximate published baseline maker/taker fee tier for Hyperliquid, used to
  * seed fee math before the live account `feeTier` resolves. Rates are fractions

package/src/index.ts

@@ -15,6 +15,7 @@ export { projectHyperliquidConfigSettings } from './accountConfig.js'
 export { getAccountSummary } from './accountSummary.js'
 export {
   DEFAULT_HYPERLIQUID_API_URL,
+  HYPERLIQUID_EXPLORER_RPC_URL,
   HYPERLIQUID_FEE_TIER_FALLBACK,
   PROVIDER_KEY as HYPERLIQUID_PROVIDER_KEY,
 } from './constants.js'
@@ -39,8 +40,6 @@ export type { GetPortfolioHistoryParams } from './services/getPortfolioHistory.j
 export { getPortfolioHistory } from './services/getPortfolioHistory.js'
 export type { GetPositionsParams } from './services/getPositions.js'
 export { getPositions } from './services/getPositions.js'
-export type { GetRunningTwapsParams } from './services/getRunningTwaps.js'
-export { getRunningTwaps } from './services/getRunningTwaps.js'
 export type { HyperliquidAgent } from './signers/HyperliquidAgentStore.js'
 export { HyperliquidAgentStore } from './signers/HyperliquidAgentStore.js'
 export * from './types/index.js'

package/src/services/getAccount.ts

@@ -26,6 +26,7 @@ import {
 import { isUnifiedAbstraction } from '../utils/abstractionMode.js'
 import { toWireBig } from '../utils/decimal.js'
 import {
+  assetIsOutcome,
   partitionSpotBalances,
   perpsDexNames,
   spotAssetFromToken,
@@ -102,9 +103,9 @@ const buildBalances = (
   quoteAssetByCategory: Map<string, Asset>
 ): BalancePartition => {
   const { balances, collateralBalances } = partitionSpotBalances(
-    spotState.balances.map((b) =>
-      spotBalance(spotAssetFromToken(b), b.total, priceById)
-    ),
+    spotState.balances
+      .filter((b) => !assetIsOutcome(b.coin))
+      .map((b) => spotBalance(spotAssetFromToken(b), b.total, priceById)),
     quoteAssetIds,
     abstraction === HlAbstractionMode.PORTFOLIO_MARGIN
   )
@@ -127,6 +128,7 @@ const buildBalances = (
         asset: quoteAssetByCategory.get(categoryId)!,
         units: value.toFixed(),
         valueUsd: value.toFixed(),
+        price: '1',
       })
     }
   }
@@ -220,7 +222,9 @@ export const getAccount = async (
 
   const positions: Position[] = stateResults.flatMap((state) =>
     state.assetPositions
-      .filter(isOpenAssetPosition)
+      .filter(
+        (ap) => !assetIsOutcome(ap.position.coin) && isOpenAssetPosition(ap)
+      )
       .map((ap) =>
         mapPosition(
           ap,

package/src/services/getActivity.ts

@@ -1,4 +1,9 @@
-import { getMarketRegistry, type SDKRequestOptions } from '@lifi/perps-sdk'
+import {
+  type AssetRegistry,
+  getAssetRegistry,
+  getMarketRegistry,
+  type SDKRequestOptions,
+} from '@lifi/perps-sdk'
 import type {
   ActivitiesResponse,
   ActivityItem,
@@ -14,10 +19,24 @@ import {
 } from '../constants.js'
 import type { HyperliquidContext } from '../context.js'
 import type {
+  HlUserFills,
   HlUserFunding,
   HlUserNonFundingLedgerUpdates,
 } from '../types/index.js'
-import { mapFundingActivity, mapLedgerEntry } from '../utils/index.js'
+import {
+  isCollateralTransferDelta,
+  isDepositDelta,
+  isLiquidationDelta,
+  isSendAssetDelta,
+  isSpotTransferDelta,
+  isVaultTransferDelta,
+  isWithdrawDelta,
+} from '../types/index.js'
+import {
+  mapFundingActivity,
+  mapLedgerEntry,
+  mapLiquidationFills,
+} from '../utils/index.js'
 import {
   hlInfoOptions,
   type InfoRequestOptions,
@@ -48,6 +67,12 @@ const MARKET_BEARING_TYPES: ReadonlySet<ActivityType> = new Set([
   ActivityType.LIQUIDATION,
 ])
 
+const ASSET_BEARING_TYPES: ReadonlySet<ActivityType> = new Set([
+  ActivityType.DEPOSIT,
+  ActivityType.WITHDRAWAL,
+  ActivityType.TRANSFER,
+])
+
 const needsMarkets = (typeFilter: ActivityType[] | undefined): boolean =>
   !typeFilter || typeFilter.some((t) => MARKET_BEARING_TYPES.has(t))
 
@@ -55,14 +80,19 @@ const fetchActivityData = async (
   apiUrl: string,
   typeFilter: ActivityType[] | undefined,
   timeParams: { user: Address; startTime?: number; endTime?: number },
+  assetRegistry: AssetRegistry,
   resolveMarket: (coin: string) => MarketDisplay | undefined,
   options?: InfoRequestOptions
 ): Promise<ActivityItem[]> => {
   const needLedger =
     !typeFilter || typeFilter.some((t) => t !== ActivityType.FUNDING)
   const needFunding = !typeFilter || typeFilter.includes(ActivityType.FUNDING)
+  // A liquidation executed as a market order reaches the account as fills
+  // with a `liquidation` field and never as a ledger `liquidation` delta.
+  const needLiquidationFills =
+    !typeFilter || typeFilter.includes(ActivityType.LIQUIDATION)
 
-  const [ledgerUpdates, fundingUpdates] = await Promise.all([
+  const [ledgerUpdates, fundingUpdates, fills] = await Promise.all([
     needLedger
       ? infoRequest<HlUserNonFundingLedgerUpdates>(
           apiUrl,
@@ -77,14 +107,38 @@ const fetchActivityData = async (
           options
         )
       : Promise.resolve([] as HlUserFunding),
+    needLiquidationFills
+      ? infoRequest<HlUserFills>(
+          apiUrl,
+          timeParams.startTime === undefined
+            ? { type: 'userFills', user: timeParams.user }
+            : { type: 'userFillsByTime', ...timeParams },
+          options
+        )
+      : Promise.resolve([] as HlUserFills),
   ])
 
   const ledgerItems: ActivityItem[] = ledgerUpdates.flatMap(
     (entry): ActivityItem[] => {
+      if (
+        typeFilter !== undefined &&
+        ((isDepositDelta(entry.delta) &&
+          !typeFilter.includes(ActivityType.DEPOSIT)) ||
+          (isWithdrawDelta(entry.delta) &&
+            !typeFilter.includes(ActivityType.WITHDRAWAL)) ||
+          (!typeFilter.includes(ActivityType.TRANSFER) &&
+            (isSpotTransferDelta(entry.delta) ||
+              isSendAssetDelta(entry.delta) ||
+              isCollateralTransferDelta(entry.delta) ||
+              isVaultTransferDelta(entry.delta))))
+      ) {
+        return []
+      }
       const item = mapLedgerEntry(
         entry,
         PROVIDER_KEY,
         timeParams.user,
+        assetRegistry,
         resolveMarket
       )
       return item === null ? [] : [item]
@@ -98,7 +152,20 @@ const fetchActivityData = async (
     }
   )
 
-  const merged = [...ledgerItems, ...fundingItems].sort(
+  const ledgerLiquidationHashes = new Set(
+    ledgerUpdates
+      .filter((entry) => isLiquidationDelta(entry.delta))
+      .map((entry) => entry.hash)
+  )
+  const liquidationItems = mapLiquidationFills(
+    fills,
+    PROVIDER_KEY,
+    timeParams.user,
+    resolveMarket,
+    ledgerLiquidationHashes
+  )
+
+  const merged = [...ledgerItems, ...fundingItems, ...liquidationItems].sort(
     (a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()
   )
 
@@ -112,8 +179,8 @@ const fetchActivityData = async (
 /**
  * Fetch a chronological activity feed (deposits, withdrawals, transfers,
  * liquidations, funding) for `address`. Combines results from Hyperliquid's
- * `userNonFundingLedgerUpdates` and `userFunding` endpoints, sorted
- * newest-first.
+ * `userNonFundingLedgerUpdates`, `userFunding`, and `userFills` endpoints,
+ * sorted newest-first.
  *
  * Cursor-based pagination uses the ms-since-epoch timestamp of the last item
  * on the current page.
@@ -131,6 +198,13 @@ export const getActivity = async (
   if (needsMarkets(params.type)) {
     await registry.sync()
   }
+  const assetRegistry = getAssetRegistry(client, PROVIDER_KEY)
+  if (
+    params.type === undefined ||
+    params.type.some((type) => ASSET_BEARING_TYPES.has(type))
+  ) {
+    await assetRegistry.sync()
+  }
   const infoOpts = hlInfoOptions(client, options)
 
   const limit = Math.min(
@@ -152,6 +226,7 @@ export const getActivity = async (
     apiUrl,
     params.type,
     timeParams,
+    assetRegistry,
     (coin) => registry.get(coin),
     infoOpts
   )

package/src/services/getFills.ts

@@ -12,7 +12,7 @@ import type {
   HlUserFills,
   HlUserFillsByTime,
 } from '../types/index.js'
-import { mapFill } from '../utils/index.js'
+import { assetIsOutcome, mapFill } from '../utils/index.js'
 import { hlInfoOptions, infoRequest } from '../utils/infoClient.js'
 
 /**
@@ -112,6 +112,9 @@ export const getFills = async (
   // only its own row instead of rejecting the whole page. The registry warns
   // once per unresolved id. A delisted market still resolves, so its rows stay.
   const items = page.flatMap((f): Fill[] => {
+    if (assetIsOutcome(f.coin)) {
+      return []
+    }
     const market = registry.get(f.coin)
     return market === undefined ? [] : [mapFill(f, market)]
   })

package/src/services/getOrder.ts

@@ -8,8 +8,11 @@ import type { Order } from '@lifi/perps-types'
 import { PerpsErrorCode } from '@lifi/perps-types'
 import { PROVIDER_KEY } from '../constants.js'
 import type { HyperliquidContext } from '../context.js'
-import type { HlOrderStatusResponse } from '../types/index.js'
-import { mapOrder } from '../utils/index.js'
+import type {
+  HlOrderStatusResponse,
+  HlTwapHistoryEntry,
+} from '../types/index.js'
+import { assetIsOutcome, mapOrder } from '../utils/index.js'
 import { hlInfoOptions, infoRequest } from '../utils/infoClient.js'
 
 /**
@@ -30,11 +33,15 @@ export const getOrder = async (
   params: GetOrderParams,
   options?: SDKRequestOptions
 ): Promise<Order> => {
-  const oid = Number.parseInt(params.id, 10)
-  if (Number.isNaN(oid)) {
+  const isClientId = /^0x[0-9a-fA-F]{32}$/.test(params.id)
+  const oid = isClientId ? params.id : Number(params.id)
+  if (
+    !isClientId &&
+    (!/^[0-9]+$/.test(params.id) || !Number.isSafeInteger(oid))
+  ) {
     const err = new PerpsError(
       PerpsErrorCode.ValidationError,
-      `Invalid order ID: ${params.id}. Must be a numeric oid.`
+      `Invalid order ID: ${params.id}. Expected a numeric oid or a 128-bit cloid.`
     )
     err.tool = PROVIDER_KEY
     throw err
@@ -47,6 +54,23 @@ export const getOrder = async (
   )
 
   if (status.status !== 'order') {
+    const history = await infoRequest<HlTwapHistoryEntry[]>(
+      apiUrl,
+      { type: 'twapHistory', user: params.address },
+      hlInfoOptions(client, options)
+    )
+    const twap = history.find(
+      (entry) =>
+        String(entry.twapId) === params.id && !assetIsOutcome(entry.state.coin)
+    )
+    if (twap !== undefined) {
+      const registry = getMarketRegistry(client, PROVIDER_KEY)
+      await registry.sync()
+      return mapOrder(twap, registry.require(twap.state.coin))
+    }
+  }
+
+  if (status.status !== 'order' || assetIsOutcome(status.order.order.coin)) {
     const err = new PerpsError(
       PerpsErrorCode.OrderNotFound,
       `Order not found: ${params.id}`

package/src/services/getOrders.ts

@@ -1,102 +1,217 @@
-import { getMarketRegistry, type SDKRequestOptions } from '@lifi/perps-sdk'
-import type { OpenOrder, OrdersResponse, TriggerOrder } from '@lifi/perps-types'
-import type { Address } from 'viem'
+import {
+  ACTIVE_ORDER_STATUSES,
+  createWarnOnce,
+  ExplorerChainId,
+  explorerTxUrl,
+  getMarketRegistry,
+  isActiveOrderStatus,
+  type MarketRegistry,
+  PerpsError,
+  type ProviderGetOrdersParams,
+  type SDKRequestOptions,
+} from '@lifi/perps-sdk'
+import type { MarketDisplay, Order, OrdersResponse } from '@lifi/perps-types'
 import { PROVIDER_KEY } from '../constants.js'
 import type { HyperliquidContext } from '../context.js'
 import type {
-  HlFrontendOpenOrder,
+  HlExplorerTx,
   HlFrontendOpenOrders,
+  HlHistoricalOrders,
+  HlTwapHistoryEntry,
 } from '../types/index.js'
 import {
-  isTriggerOrder,
-  mapOpenOrder,
-  mapTriggerOrder,
+  assetIsOutcome,
+  fetchUserTransactions,
+  mapOrder,
+  matchOrderActionHash,
   perpsDexNames,
 } from '../utils/index.js'
-import { hlInfoOptions, infoRequest } from '../utils/infoClient.js'
+import {
+  hlInfoOptions,
+  type InfoRequestOptions,
+  infoRequest,
+} from '../utils/infoClient.js'
+
+/** Parameters for a lifecycle-filtered Hyperliquid order read. */
+export type GetOrdersParams = ProviderGetOrdersParams
+
+const warn = createWarnOnce()
+
+const warnOnce = (key: string, detail?: string): void => {
+  warn(
+    key,
+    `[${PROVIDER_KEY}] ${detail === undefined ? key : `${key}: ${detail}`}`
+  )
+}
 
 /**
- * Parameters for {@link getOrders}.
- *
- * @public
+ * Map one venue row, or drop it. An outcome market identity, a coin the backend
+ * market list does not hold, and a row the mapper rejects each drop only their
+ * own row instead of rejecting the whole page; each distinct mapper message
+ * warns once.
  */
-export interface GetOrdersParams {
-  address: Address
-  /** Optional filter using the normalized opaque `Market.id`. */
-  marketId?: string
-  /** Page-size hint; Hyperliquid returns all open orders in one response. */
-  limit?: number
+const mapRow = (
+  coin: string,
+  registry: MarketRegistry,
+  map: (market: MarketDisplay) => Order
+): Order | undefined => {
+  if (assetIsOutcome(coin)) {
+    return undefined
+  }
+  const market = registry.get(coin)
+  if (market === undefined) {
+    return undefined
+  }
+  try {
+    return map(market)
+  } catch (error) {
+    if (!(error instanceof PerpsError)) {
+      throw error
+    }
+    warnOnce(`dropped order row: ${error.message}`)
+    return undefined
+  }
 }
 
 /**
- * Fetch open + trigger orders across every supported perps sub-dex for
- * `address`, normalised into `OrdersResponse`. Trigger orders that appear as
- * children of a parent limit order (Hyperliquid's `normalTpsl` flow) are
- * extracted and surfaced alongside top-level trigger orders. The backend's
- * enriched asset list supplies the sub-dex fan-out and display fields; only
- * `frontendOpenOrders` is read direct.
- * @throws {PerpsError} On Hyperliquid REST error, network, or parsing failures.
- * @public
+ * Set `explorerLink` on each row whose placement transaction the explorer
+ * window still holds. One explorer read serves the whole page, and it is
+ * skipped when no row carries a client order id to match on. The link is
+ * supplementary, so an explorer failure warns and leaves the rows unlinked
+ * instead of failing the order read.
  */
+const withExplorerLinks = async (
+  orders: Order[],
+  address: string,
+  options: InfoRequestOptions
+): Promise<Order[]> => {
+  if (!orders.some((order) => order.clientOrderId !== undefined)) {
+    return orders
+  }
+  let txs: HlExplorerTx[]
+  try {
+    txs = await fetchUserTransactions(address, options)
+  } catch (error) {
+    if (!(error instanceof PerpsError)) {
+      throw error
+    }
+    // The message stays out of the key: a transport failure names hosts and
+    // ports, so keying on it would let the dedupe set grow without bound.
+    warnOnce('explorer link lookup failed', error.message)
+    return orders
+  }
+  return orders.map((order) => {
+    const explorerLink = explorerTxUrl(
+      ExplorerChainId.HYPERLIQUID,
+      matchOrderActionHash(txs, order)
+    )
+    return explorerLink === undefined ? order : { ...order, explorerLink }
+  })
+}
+
+/** Read regular, trigger, and TWAP orders from the requested lifecycle feeds. */
 export const getOrders = async (
   { client, apiUrl }: HyperliquidContext,
   params: GetOrdersParams,
   options?: SDKRequestOptions
 ): Promise<OrdersResponse> => {
+  const statuses = params.statuses ?? [...ACTIVE_ORDER_STATUSES]
+  if (statuses.length === 0) {
+    return {
+      provider: PROVIDER_KEY,
+      orders: [],
+      pagination: { limit: params.limit ?? 0, hasMore: false },
+    }
+  }
   const registry = getMarketRegistry(client, PROVIDER_KEY)
   const markets = await registry.sync()
   const infoOpts = hlInfoOptions(client, options)
-
-  const ordersResults = await Promise.all(
-    perpsDexNames(markets).map((name) =>
-      infoRequest<HlFrontendOpenOrders>(
-        apiUrl,
-        {
-          type: 'frontendOpenOrders',
-          user: params.address,
-          ...(name ? { dex: name } : {}),
-        },
-        infoOpts
-      )
+  const active = statuses.some(isActiveOrderStatus)
+  const terminal = statuses.some((status) => !isActiveOrderStatus(status))
+  const [open, historical, twaps] = await Promise.all([
+    active
+      ? Promise.all(
+          perpsDexNames(markets).map((name) =>
+            infoRequest<HlFrontendOpenOrders>(
+              apiUrl,
+              {
+                type: 'frontendOpenOrders',
+                user: params.address,
+                ...(name ? { dex: name } : {}),
+              },
+              infoOpts
+            )
+          )
+        )
+      : [],
+    terminal
+      ? infoRequest<HlHistoricalOrders>(
+          apiUrl,
+          { type: 'historicalOrders', user: params.address },
+          infoOpts
+        )
+      : [],
+    infoRequest<HlTwapHistoryEntry[]>(
+      apiUrl,
+      { type: 'twapHistory', user: params.address },
+      infoOpts
+    ),
+  ])
+  const rows = new Map<string, Order>()
+  const keep = (key: string, order: Order | undefined): void => {
+    if (order !== undefined) {
+      rows.set(key, order)
+    }
+  }
+  for (const detail of historical) {
+    const key = String(detail.order.oid)
+    // The feed carries one row per lifecycle transition, newest first, and a
+    // terminal row shares its timestamp with the `open` row beneath it, so
+    // only the first row of an id states that order's current status.
+    if (rows.has(key)) {
+      continue
+    }
+    keep(
+      key,
+      mapRow(detail.order.coin, registry, (market) => mapOrder(detail, market))
     )
+  }
+  const raw = open.flat()
+  const childIds = new Set(
+    raw.flatMap((order) => (order.children ?? []).map((child) => child.oid))
   )
-
-  const raw: HlFrontendOpenOrder[] = ordersResults.flat()
-
-  const childOids = new Set<number>()
-  for (const o of raw) {
-    for (const child of o.children ?? []) {
-      childOids.add(child.oid)
+  for (const order of raw) {
+    if (!childIds.has(order.oid)) {
+      keep(
+        String(order.oid),
+        mapRow(order.coin, registry, (market) => mapOrder(order, market))
+      )
+    }
+    for (const child of order.children ?? []) {
+      keep(
+        String(child.oid),
+        mapRow(child.coin, registry, (market) =>
+          mapOrder(child, market, String(order.oid))
+        )
+      )
     }
   }
-
-  const nonChild = raw.filter((o) => !childOids.has(o.oid))
-
-  let openOrders: OpenOrder[] = nonChild
-    .filter((o) => !isTriggerOrder(o))
-    .map((o) => mapOpenOrder(o, registry.require(o.coin)))
-
-  let triggerOrders: TriggerOrder[] = [
-    ...nonChild
-      .filter((o) => isTriggerOrder(o))
-      .map((o) => mapTriggerOrder(o, registry.require(o.coin))),
-    ...raw
-      .filter((o) => childOids.has(o.oid))
-      .map((o) => mapTriggerOrder(o, registry.require(o.coin))),
-  ]
-
-  if (params.marketId !== undefined) {
-    openOrders = openOrders.filter((o) => o.market.id === params.marketId)
-    triggerOrders = triggerOrders.filter((o) => o.market.id === params.marketId)
+  // TWAP ids and regular order ids occupy separate venue namespaces.
+  for (const twap of twaps) {
+    keep(
+      `twap:${twap.twapId}`,
+      mapRow(twap.state.coin, registry, (market) => mapOrder(twap, market))
+    )
   }
-
+  const matching = [...rows.values()].filter(
+    (order) =>
+      statuses.includes(order.status) &&
+      (params.marketId === undefined || order.market.id === params.marketId)
+  )
+  const orders = await withExplorerLinks(matching, params.address, infoOpts)
   return {
     provider: PROVIDER_KEY,
-    openOrders,
-    triggerOrders,
-    pagination: {
-      limit: params.limit ?? openOrders.length + triggerOrders.length,
-      hasMore: false,
-    },
+    orders,
+    pagination: { limit: params.limit ?? orders.length, hasMore: false },
   }
 }

package/src/services/getPositions.ts

@@ -9,6 +9,7 @@ import { PROVIDER_KEY } from '../constants.js'
 import type { HyperliquidContext } from '../context.js'
 import type { HlClearinghouseState } from '../types/index.js'
 import {
+  assetIsOutcome,
   isOpenAssetPosition,
   mapPosition,
   perpsDexNames,
@@ -61,7 +62,9 @@ export const getPositions = async (
 
   let positions = stateResults.flatMap((state) =>
     state.assetPositions
-      .filter(isOpenAssetPosition)
+      .filter(
+        (ap) => !assetIsOutcome(ap.position.coin) && isOpenAssetPosition(ap)
+      )
       .map((ap) =>
         mapPosition(
           ap,