@lifi/perps-sdk-provider-ondo 9.0.0 → 10.0.0

package/src/utils/mapActivity.ts

@@ -1,13 +1,17 @@
 import type {
+  DepositActivity,
   FundingActivity,
   LiquidationActivity,
   MarketDisplay,
+  WithdrawalActivity,
 } from '@lifi/perps-types'
 import { ActivityType } from '@lifi/perps-types'
 import { ONDO_PROVIDER_KEY } from '../constants.js'
 import type {
   OndoFundingFeeTransfer,
   OndoLiquidationEvent,
+  OndoWalletDeposit,
+  OndoWalletWithdrawal,
 } from '../types/wire.js'
 
 /**
@@ -37,25 +41,114 @@ export const mapFundingActivity = (
 }
 
 /**
- * Map an Ondo liquidation event to a {@link LiquidationActivity}. Ondo does
- * not report the account value at liquidation time, and its margin accounts
- * are cross-only, so `accountValue` is `'0'` and `leverageType` is `'cross'`.
+ * Map an Ondo liquidation event to a {@link LiquidationActivity}, or `null`
+ * when the event names no triggering position. Ondo margin accounts are
+ * cross-only, so `leverageType` is always `'cross'`. Ondo reports no account
+ * value at liquidation time, so `accountValue` stays absent. One Ondo event
+ * carries the whole cross-margin cascade in `triggeringPositions`, so every
+ * liquidated market and size reaches `liquidatedPositions`.
  *
  * @public
  */
 export const mapLiquidationActivity = (
   event: OndoLiquidationEvent,
   resolveMarket: (market: string) => MarketDisplay
-): LiquidationActivity => ({
-  id: event.id,
-  provider: ONDO_PROVIDER_KEY,
-  timestamp: new Date(event.time).toISOString(),
-  type: ActivityType.LIQUIDATION,
-  liquidatedNotionalPosition: event.filledQuoteSize ?? '0',
-  accountValue: '0',
-  leverageType: 'cross',
-  liquidatedPositions: (event.triggeringPositions ?? []).map((p) => ({
+): LiquidationActivity | null => {
+  const liquidatedPositions = (event.triggeringPositions ?? []).map((p) => ({
     market: resolveMarket(p.market),
     size: p.netQuantity,
-  })),
+  }))
+  if (liquidatedPositions.length === 0) {
+    return null
+  }
+  return {
+    id: event.id,
+    provider: ONDO_PROVIDER_KEY,
+    timestamp: new Date(event.time).toISOString(),
+    type: ActivityType.LIQUIDATION,
+    ...(event.filledQuoteSize === undefined
+      ? {}
+      : { liquidatedNotionalPosition: event.filledQuoteSize }),
+    leverageType: 'cross',
+    liquidatedPositions,
+  }
+}
+
+// Ondo reports no transaction id on a deposit it has not yet matched to a
+// chain transaction, so two such deposits would share the bare `deposit:`
+// key. Fall back to the fields the venue does report.
+const depositId = (deposit: OndoWalletDeposit): string => {
+  if (deposit.txid === '') {
+    return `deposit:${deposit.time}:${deposit.coin}:${deposit.size}`
+  }
+  return deposit.logIndex === undefined
+    ? `deposit:${deposit.txid}`
+    : `deposit:${deposit.txid}:${deposit.logIndex}`
+}
+
+/**
+ * Map an Ondo wallet deposit to a {@link DepositActivity}. Ondo carries no
+ * deposit id on the wire and addresses a single deposit by transaction id, so
+ * the id is `deposit:<txid>`, suffixed with `logIndex` when one transaction
+ * carried several deposits. `coin` is already a display symbol, so it is the
+ * normalized asset identity.
+ *
+ * @public
+ */
+export const mapDepositActivity = (
+  deposit: OndoWalletDeposit
+): DepositActivity => ({
+  id: depositId(deposit),
+  provider: ONDO_PROVIDER_KEY,
+  timestamp: new Date(deposit.time).toISOString(),
+  type: ActivityType.DEPOSIT,
+  asset: deposit.coin,
+  amount: deposit.size,
+  ...(deposit.txid === ''
+    ? {}
+    : { explorerLink: `https://scan.li.fi/tx/${deposit.txid}` }),
 })
+
+const SETTLING_WITHDRAWAL_STATUSES = new Set<string>([
+  'complete',
+  'pending',
+  'unknown',
+])
+
+/** Ondo denominates a withdrawal fee in USD, whatever asset it withdraws. */
+const ONDO_WITHDRAWAL_FEE_SYMBOL = 'USD'
+
+/**
+ * Map an Ondo wallet withdrawal to a {@link WithdrawalActivity}, or `null`
+ * when the venue reports a status under which no value left the account. Ondo
+ * charges the fee in USD, so `fee.asset` is `USD` and not the withdrawn asset.
+ *
+ * @public
+ */
+export const mapWithdrawalActivity = (
+  withdrawal: OndoWalletWithdrawal
+): WithdrawalActivity | null => {
+  if (!SETTLING_WITHDRAWAL_STATUSES.has(withdrawal.status)) {
+    return null
+  }
+  return {
+    id: withdrawal.withdrawal_id,
+    provider: ONDO_PROVIDER_KEY,
+    timestamp: new Date(withdrawal.time).toISOString(),
+    type: ActivityType.WITHDRAWAL,
+    asset: withdrawal.coin,
+    amount: withdrawal.size,
+    // Loose equality also drops a `null` the live API may send for "no fee".
+    ...(withdrawal.usdFee == null
+      ? {}
+      : {
+          fee: {
+            amount: withdrawal.usdFee,
+            asset: ONDO_WITHDRAWAL_FEE_SYMBOL,
+          },
+        }),
+    ...(withdrawal.txid === ''
+      ? {}
+      : { explorerLink: `https://scan.li.fi/tx/${withdrawal.txid}` }),
+  }
+}

package/src/utils/mapFill.ts

@@ -35,7 +35,11 @@ export const mapFill = (fill: OndoFill, market: MarketDisplay): Fill => ({
   price: fill.price,
   status: FillStatus.FILLED,
   liquidity: fill.isMaker ? LiquidityRole.MAKER : LiquidityRole.TAKER,
-  fee: new Big(fill.fee).minus(fill.feeRebate ?? '0').toFixed(),
+  // Ondo charges the fill fee in the market's quote asset.
+  fee: {
+    amount: new Big(fill.fee).minus(fill.feeRebate ?? '0').toFixed(),
+    asset: market.quoteAsset.displaySymbol,
+  },
   realizedPnl: fill.pnl,
   classification:
     fill.direction !== undefined

package/src/utils/mapOrder.ts

@@ -22,6 +22,10 @@ const toIso = (time: string): string => new Date(time).toISOString()
 const mapSide = (side: OndoOrder['side']): OrderSide =>
   side === 'buy' ? OrderSide.BUY : OrderSide.SELL
 
+/** Resting quantity: submitted size minus filled size, in base-asset units. */
+const deriveRemainingSize = (size: string, filledSize: string): string =>
+  new Big(size).minus(filledSize).toFixed()
+
 /** @public */
 export const mapOrderType = (type: OndoOrderType): OrderType => {
   switch (type) {
@@ -88,7 +92,11 @@ export const isTriggerOrder = (order: OndoOrder): boolean =>
   order.stopOrderType !== undefined ||
   order.triggerPrice !== undefined
 
-/** Map an active non-trigger Ondo order to an {@link OpenOrder}. @public */
+/**
+ * Map an active non-trigger Ondo order to an {@link OpenOrder}. Ondo reports
+ * the submitted and filled quantities only, so `remainingSize` is derived.
+ * @public
+ */
 export const mapOrder = (
   order: OndoOrder,
   market: MarketDisplay
@@ -97,7 +105,8 @@ export const mapOrder = (
   market,
   side: mapSide(order.side),
   type: mapOrderType(order.type),
-  size: order.size,
+  originalSize: new Big(order.size).toFixed(),
+  remainingSize: deriveRemainingSize(order.size, order.filledSize),
   price: order.price,
   filledSize: order.filledSize,
   reduceOnly: order.reduceOnly ?? false,
@@ -177,7 +186,7 @@ export const mapOrderDetail = (
     type: mapOrderType(order.type),
     price: order.price,
     originalSize: order.size,
-    remainingSize: new Big(order.size).minus(filled).toFixed(),
+    remainingSize: deriveRemainingSize(order.size, order.filledSize),
     filledSize: order.filledSize,
     timeInForce:
       order.timeInForce === undefined