@lifi/perps-sdk 23.0.0 → 24.0.0

package/src/transport/request.ts

@@ -20,6 +20,11 @@ import {
 export interface RequestOptions extends RequestInit {
   /** Per-call retry override. Falls back to the resolved client-level policy. */
   retry?: RetryPolicy | false
+  /**
+   * Send `x-lifi-perps-sdk`. Defaults to `true`. The LI.FI API CORS preflight
+   * does not allow the header, so a browser blocks a LI.FI API call that sends it.
+   */
+  perpsSdkHeader?: boolean
   /** Successful response metadata, delivered only after JSON decoding. */
   onResponse?: (
     headers: Headers,
@@ -40,7 +45,7 @@ export async function request<T>(
   options: RequestOptions = {},
   sdkOptions?: SDKRequestOptions
 ): Promise<T> {
-  const { retry, onResponse, ...fetchInit } = options
+  const { retry, onResponse, perpsSdkHeader = true, ...fetchInit } = options
   const policy =
     retry !== undefined
       ? resolveRetryPolicy(LIFI_RETRY_DEFAULTS, retry, LIFI_REQUEST_KEY)
@@ -48,7 +53,7 @@ export async function request<T>(
 
   const headers: Record<string, string> = {
     'Content-Type': 'application/json',
-    'x-lifi-perps-sdk': version,
+    ...(perpsSdkHeader && { 'x-lifi-perps-sdk': version }),
     ...(fetchInit.headers as Record<string, string>),
   }
 

package/src/types/api.ts

@@ -293,6 +293,16 @@ export interface GetWithdrawableBalancesParams {
   address: Address
 }
 
+/**
+ * Parameters for {@link PerpsClient.getWithdrawalTypes}.
+ *
+ * @public
+ */
+export interface GetWithdrawalTypesParams {
+  provider: string
+  address: Address
+}
+
 /**
  * Parameters for {@link PerpsClient.getPortfolioHistory}.
  *

package/src/types/provider.ts

@@ -37,7 +37,11 @@ import type {
   SDKRequestOptions,
 } from './config.js'
 import type { DepositFlow } from './deposit.js'
-import type { ProviderWithdrawableBalance, WithdrawFlow } from './withdrawal.js'
+import type {
+  ProviderWithdrawableBalance,
+  WithdrawalSourceTypes,
+  WithdrawFlow,
+} from './withdrawal.js'
 
 /**
  * Low-level SDK client: resolved config, the optional end-user wallet, and the
@@ -147,8 +151,8 @@ export interface ActionSignerContribution {
  */
 export interface LiquidationEstimateParams {
   /** Entry price in quote currency per base unit. */
-  entryPrice: number
-  leverage: number
+  entryPrice: string
+  leverage: string
   /** `true` for long, `false` for short. */
   isLong: boolean
 }
@@ -199,6 +203,15 @@ export interface ProviderGetWithdrawableBalancesParams {
   address: Address
 }
 
+/**
+ * Read params for {@link PerpsProviderPlugin.getWithdrawalTypes}.
+ *
+ * @public
+ */
+export interface ProviderGetWithdrawalTypesParams {
+  address: Address
+}
+
 /**
  * Read params for {@link PerpsProvider.getPositions}.
  *
@@ -322,7 +335,7 @@ export interface ProviderGetQuoteParams {
   /** Trade direction used to choose asks for buys or bids for sells. */
   side: QuoteSide
   /** USD notional to fill. */
-  size: number
+  size: string
   /** Product family used to disambiguate spot and perpetual markets. */
   type: TradeType
 }
@@ -434,20 +447,33 @@ export interface PerpsProviderPlugin {
   ): Promise<WithdrawFlow>
 
   /**
-   * The `(asset, route)` pairs `params.address` currently has something to
+   * The `(asset, category)` pairs `params.address` currently has something to
    * withdraw from, keyed by provider-native asset id. Only the venue knows how
-   * its balance payload splits across routes, so the split is owned here; the
+   * its balance payload splits across categories, so the split is owned here; the
    * per-asset venue minimum is applied by `PerpsClient.getWithdrawableBalances`,
    * which holds the core asset registry.
    *
-   * Optional: a provider whose withdrawals are not a per-route selection omits
-   * it, and `PerpsClient.getWithdrawableBalances` then resolves `undefined`.
+   * Optional: a provider whose withdrawals are not a per-category selection
+   * omits it, and `PerpsClient.getWithdrawableBalances` then resolves
+   * `undefined`.
    */
   getWithdrawableBalances?(
     params: ProviderGetWithdrawableBalancesParams,
     options?: SDKRequestOptions
   ): Promise<ProviderWithdrawableBalance[]>
 
+  /**
+   * The withdrawal types `params.address` can choose per withdrawable holding,
+   * each with its cap and the `withdrawalOptions` to send with it.
+   *
+   * Optional: a provider with one withdrawal type omits it, and
+   * `PerpsClient.getWithdrawalTypes` then resolves `undefined`.
+   */
+  getWithdrawalTypes?(
+    params: ProviderGetWithdrawalTypesParams,
+    options?: SDKRequestOptions
+  ): Promise<WithdrawalSourceTypes[]>
+
   getPositions(
     params: ProviderGetPositionsParams,
     options?: SDKRequestOptions
@@ -573,10 +599,6 @@ export interface PerpsProviderPlugin {
    * positions, prefer `Position.liquidationPrice` from the venue. Pure —
    * does no I/O.
    *
-   * Numbers, in and out, on purpose: this is a display-tier estimate that
-   * feeds a screen, not a wire amount. It is not a `snap*` method and must
-   * not be converted to {@link DecimalString}.
-   *
    * @returns The estimated liquidation price, or `undefined` when the venue's
    *   model cannot be evaluated client-side (degenerate inputs, or `market`
    *   lacks the margin metadata the model needs).
@@ -584,7 +606,7 @@ export interface PerpsProviderPlugin {
   estimateLiquidationPrice(
     market: PerpsMarket,
     params: LiquidationEstimateParams
-  ): number | undefined
+  ): string | undefined
 
   /**
    * Margin that can be removed from `position` under the venue margin rules,

package/src/types/withdrawal.ts

@@ -2,22 +2,22 @@ import type {
   ActionType,
   Asset,
   DecimalString,
-  WithdrawalRoute,
+  WithdrawalAssetRef,
+  WithdrawalType,
 } from '@lifi/perps-types'
 import type { Address } from 'viem'
 
-export type { WithdrawalRoute }
-
 /**
- * One withdrawable `(asset, route)` selection as the provider reports it, keyed
- * by provider-native asset id and awaiting the core asset-metadata join.
+ * One withdrawable `(asset, category)` selection as the provider reports it,
+ * keyed by provider-native asset id and awaiting the core asset-metadata join.
  *
  * @public
  */
 export interface ProviderWithdrawableBalance {
   /** Provider-native `Asset.id`; never a display symbol. */
   assetId: string
-  route: WithdrawalRoute
+  /** The provider category the row draws from; the same value as `Balance.categoryId`. */
+  categoryId: string
   /** Withdrawable amount in the asset's own units. Always greater than zero. */
   available: DecimalString
   /**
@@ -41,7 +41,7 @@ export interface ProviderWithdrawableBalance {
 }
 
 /**
- * One withdrawable `(asset, route)` selection a caller can act on: the amount
+ * One withdrawable `(asset, category)` selection a caller can act on: the amount
  * clears the asset's venue minimum, and `asset` carries the precision and
  * minimum needed to scale and validate the withdrawal.
  *
@@ -49,7 +49,8 @@ export interface ProviderWithdrawableBalance {
  */
 export interface WithdrawableBalance {
   asset: Asset
-  route: WithdrawalRoute
+  /** The provider category the row draws from; the same value as `Balance.categoryId`. */
+  categoryId: string
   /** Withdrawable amount in the asset's own units. */
   available: DecimalString
   /**
@@ -77,6 +78,32 @@ export interface WithdrawableBalance {
   isFeeDeducted?: boolean
 }
 
+/**
+ * One way a venue can settle a withdrawal from a holding.
+ *
+ * @public
+ */
+export interface WithdrawalTypeOption {
+  type: WithdrawalType
+  /** Largest `amount` this type accepts from the holding, in the asset's own units. */
+  max: DecimalString
+  /**
+   * Provider-specific options to pass unchanged as
+   * `WithdrawalParams.withdrawalOptions` when the user picks this type.
+   */
+  withdrawalOptions: Record<string, unknown>
+}
+
+/**
+ * The withdrawal types a venue offers for one holding.
+ *
+ * @public
+ */
+export interface WithdrawalSourceTypes {
+  source: WithdrawalAssetRef
+  options: WithdrawalTypeOption[]
+}
+
 /**
  * The venue accepts a withdrawal to `destination` now.
  *

package/src/utils/createSafeFunction.ts

@@ -0,0 +1,20 @@
+/**
+ * Wrap a throwing function so that it gives `undefined` in place of a throw.
+ * The wrapper logs a warning with `name` and the error, which carries the
+ * stack trace.
+ *
+ * @internal
+ */
+export function createSafeFunction<Args extends unknown[], Result>(
+  name: string,
+  throwingFunction: (...args: Args) => Result
+): (...args: Args) => Result | undefined {
+  return (...args) => {
+    try {
+      return throwingFunction(...args)
+    } catch (error) {
+      console.warn(`[perps-sdk] ${name} failed`, error)
+      return undefined
+    }
+  }
+}

package/src/utils/timestampToIsoString.ts

@@ -0,0 +1,31 @@
+import { PerpsErrorCode } from '@lifi/perps-types'
+import { PerpsError } from '../errors/PerpsError.js'
+import { createSafeFunction } from './createSafeFunction.js'
+
+/**
+ * Read a venue time (epoch milliseconds or a date string) as an ISO-8601
+ * string.
+ *
+ * @throws {PerpsError} `ValidationError` when `Date` cannot read `value`.
+ * @public
+ */
+export function timestampToIsoString(value: string | number): string {
+  const time = value === '' ? Number.NaN : new Date(value).getTime()
+  if (Number.isNaN(time)) {
+    throw new PerpsError(
+      PerpsErrorCode.ValidationError,
+      `'${String(value)}' is not a valid timestamp.`
+    )
+  }
+  return new Date(time).toISOString()
+}
+
+/**
+ * {@link timestampToIsoString}, or `undefined` with a warning when it throws.
+ *
+ * @public
+ */
+export const safeTimestampToIsoString = createSafeFunction(
+  'timestampToIsoString',
+  timestampToIsoString
+)

package/src/utils/warnOnce.ts

@@ -27,3 +27,47 @@ export const createWarnOnce = (): ((key: string, message: string) => void) => {
     console.warn(message)
   }
 }
+
+const MAX_VALUE_CHARS = 64
+
+/**
+ * Describe a skipped venue row. The venue value is cut to a fixed length, so
+ * a warner key built from the text stays small.
+ *
+ * @internal
+ */
+export const skippedRowMessage = (
+  source: string,
+  row: string,
+  field: string,
+  value: unknown,
+  expected: string
+): string => {
+  const text = String(value)
+  const shown =
+    text.length > MAX_VALUE_CHARS ? `${text.slice(0, MAX_VALUE_CHARS)}…` : text
+  return `[${source}] skipping ${row} row: \`${field}\` is not a valid ${expected}: '${shown}'`
+}
+
+const warnSkippedRowOnce = createWarnOnce()
+
+/**
+ * Warn once for each provider, row, field and expected kind that a provider
+ * mapper skipped a venue row because a required field is not valid. The key
+ * holds no venue value, so a second bad value for the same field stays silent.
+ *
+ * @param expected - What the field must be. Defaults to `'decimal'`.
+ * @internal
+ */
+export const warnSkippedVenueRow = (
+  provider: string,
+  row: string,
+  field: string,
+  value: unknown,
+  expected = 'decimal'
+): void => {
+  warnSkippedRowOnce(
+    `${provider}|${row}|${field}|${expected}`,
+    skippedRowMessage(provider, row, field, value, expected)
+  )
+}

package/src/version.ts

@@ -10,4 +10,4 @@ export const name = '@lifi/perps-sdk'
  *
  * @public
  */
-export const version = '23.0.0'
+export const version = '24.0.0'

package/src/websocket/PerpsWsClient.ts

@@ -1,4 +1,8 @@
-import { PerpsErrorCode, type Subscription } from '@lifi/perps-types'
+import {
+  PerpsErrorCode,
+  type ProvidersResponse,
+  type Subscription,
+} from '@lifi/perps-types'
 import { PerpsError } from '../errors/PerpsError.js'
 import { getProviders } from '../services/getProviders.js'
 import type { GetQuoteParams } from '../services/getQuote.js'
@@ -70,6 +74,7 @@ export class PerpsWsClient {
   private readonly options: PerpsWsClientOptions
   private providers = new Map<string, WsProvider>()
   private initPromises = new Map<string, Promise<WsProvider>>()
+  private discovery: Promise<ProvidersResponse> | undefined
   private closed = false
 
   constructor(client: PerpsSDKClient, options: PerpsWsClientOptions = {}) {
@@ -220,7 +225,7 @@ export class PerpsWsClient {
       )
     }
 
-    const { providers } = await getProviders(this.client)
+    const { providers } = await this.discoverProviders()
     this.assertOpen()
 
     const providerInfo = providers.find((d) => d.key === provider)
@@ -236,4 +241,22 @@ export class PerpsWsClient {
     this.providers.set(provider, wsProvider)
     return wsProvider
   }
+
+  /**
+   * Shares one in-flight `/providers` request between concurrent venue
+   * inits. The slot clears on settlement, so a later init fetches fresh
+   * metadata and a rejection is never cached.
+   */
+  private discoverProviders(): Promise<ProvidersResponse> {
+    if (this.discovery) {
+      return this.discovery
+    }
+    const discovery = getProviders(this.client).finally(() => {
+      if (this.discovery === discovery) {
+        this.discovery = undefined
+      }
+    })
+    this.discovery = discovery
+    return discovery
+  }
 }

package/src/websocket/wsLog.ts

@@ -1,3 +1,5 @@
+import { createWarnOnce, skippedRowMessage } from '../utils/warnOnce.js'
+
 const MAX_PAYLOAD_CHARS = 512
 
 const truncate = (raw: string): string =>
@@ -5,6 +7,8 @@ const truncate = (raw: string): string =>
     ? `${raw.slice(0, MAX_PAYLOAD_CHARS)}…(${raw.length} chars)`
     : raw
 
+const warnSkippedRowOnce = createWarnOnce()
+
 /**
  * Structured logger for WS message-handling and subscription failures, shared
  * by the provider packages so a malformed frame, a throwing mapper, or a failed
@@ -58,6 +62,33 @@ export const wsLog = {
       `[${provider}:ws] skipping item for unknown market '${marketId}'`
     )
   },
+  /**
+   * A frame row or order-book level with a required field that is not valid.
+   * Only that row is skipped. Logged once at `warn` for each provider, row and
+   * field; the key holds no venue value.
+   */
+  skippedRow(
+    provider: string,
+    row: string,
+    field: string,
+    value: unknown
+  ): void {
+    warnSkippedRowOnce(
+      `${provider}|${row}|${field}`,
+      skippedRowMessage(`${provider}:ws`, row, field, value, 'decimal')
+    )
+  },
+  /**
+   * A frame row the mapper rejected for a reason other than one field, such as
+   * a lifecycle state the SDK does not carry. Logged once at `warn` for each
+   * provider and row; the key holds no venue value.
+   */
+  droppedRow(provider: string, row: string, reason: string): void {
+    warnSkippedRowOnce(
+      `${provider}|${row}|dropped`,
+      `[${provider}:ws] skipping ${row} row: ${reason}`
+    )
+  },
   /**
    * A background market-registry refetch rejected. Unknown-market items keep
    * being skipped until the next cooldown-gated retry, so logged at `warn`.

package/src/wire/orderAmounts.ts

@@ -1,6 +1,7 @@
 import type { DecimalString, Market } from '@lifi/perps-types'
-import Big from 'big.js'
+import type Big from 'big.js'
 import { DivBig, TruncBig } from '../decimal/big.js'
+import { isDecimalStringZero } from '../decimal/compare.js'
 import { isDecimalString } from '../decimal/parse.js'
 import type { PerpsSDKClient } from '../types/provider.js'
 import { snapOrderSize } from './snap.js'
@@ -74,7 +75,7 @@ export function calculateOrderAmounts(
         ? amount.div(price).toFixed()
         : amount.times(leverage).div(price).toFixed()
   const size = snapOrderSize(sdk, market, requested)
-  if (new Big(size).eq(0)) {
+  if (isDecimalStringZero(size)) {
     return null
   }
 

package/src/wire/refuel.ts

@@ -1,32 +1,55 @@
 import { type DecimalString, PerpsErrorCode } from '@lifi/perps-types'
+import type Big from 'big.js'
 import { DivBig } from '../decimal/big.js'
-import { requireDecimal } from '../decimal/requireDecimal.js'
+import { BASE_UNITS_PATTERN } from '../decimal/convert.js'
+import { decimalStringToBig } from '../decimal/decimalStringToBig.js'
 import { PerpsError } from '../errors/PerpsError.js'
 
+/**
+ * Headroom, in percent, that {@link calculateRefuelAmount} adds over the gas
+ * deficit to pay the refuel route's own swap and bridge fees.
+ *
+ * @public
+ */
+export const REFUEL_FEE_MARGIN_PERCENT = 20
+
 /** @public */
 export interface RefuelAmountInput {
-  /** USD value of the gas the route recommends. */
-  gasUsd: DecimalString
+  /** Native gas amount the LI.FI gas suggestion recommends, in base units. */
+  recommendedAmount: DecimalString
+  /** USD value of `recommendedAmount`. */
+  recommendedUsd: DecimalString
+  /** Native balance the wallet holds on the recommendation's chain, in base units. */
+  nativeBalance: DecimalString
   /** USD price of one whole source token. */
   priceUsd: DecimalString
   /** Decimals of the source token, which the result is spelled to exactly. */
   decimals: number
 }
 
+function requireBaseUnits(value: DecimalString, field: string): Big {
+  if (!BASE_UNITS_PATTERN.test(value)) {
+    throw new PerpsError(
+      PerpsErrorCode.ValidationError,
+      `Invalid \`${field}\`: '${value}' is not an integer base-unit string.`
+    )
+  }
+  return new DivBig(value)
+}
+
 /**
- * Source-token amount whose USD value covers `gasUsd`, rounded **up** onto
- * the token's decimal grid so a refuel never lands short of the
- * recommendation. The result keeps trailing zeros to `decimals`, so it seeds
- * an amount input at the token's own precision.
- *
- * The quotient does not terminate for most prices, which is why this is a
- * big.js primitive: an 18-decimal token needs a ceiling at 10^-18, far past
- * what a `number` can carry.
+ * Source-token amount that buys the native gas the wallet lacks: the part of
+ * the recommendation above `nativeBalance`, valued pro rata on
+ * `recommendedUsd`, plus {@link REFUEL_FEE_MARGIN_PERCENT}. Rounded **up**
+ * onto the token's decimal grid so a refuel never lands short, and spelled
+ * with trailing zeros to `decimals` to seed an amount input.
  *
- * @returns `undefined` when `gasUsd` or `priceUsd` is not greater than zero,
- *   which is a route with nothing to refuel rather than a failure.
- * @throws {PerpsError} `ValidationError` when `gasUsd` or `priceUsd` is not a
- *   {@link DecimalString}, or when `decimals` is not a non-negative integer.
+ * @returns `undefined` when the wallet already holds the recommendation, or
+ *   when `recommendedAmount`, `recommendedUsd` or `priceUsd` is not greater
+ *   than zero: a route with nothing to refuel, not a failure.
+ * @throws {PerpsError} `ValidationError` when a base-unit field is not an
+ *   integer string, a USD field is not a {@link DecimalString}, or `decimals`
+ *   is not a non-negative integer.
  * @public
  */
 export function calculateRefuelAmount(
@@ -39,13 +62,26 @@ export function calculateRefuelAmount(
       `Invalid \`decimals\` for a refuel amount: ${decimals}`
     )
   }
-  const gasUsd = requireDecimal(input.gasUsd, 'gasUsd')
-  const priceUsd = requireDecimal(input.priceUsd, 'priceUsd')
-  if (!gasUsd.gt(0) || !priceUsd.gt(0)) {
+  const recommended = requireBaseUnits(
+    input.recommendedAmount,
+    'recommendedAmount'
+  )
+  const balance = requireBaseUnits(input.nativeBalance, 'nativeBalance')
+  const recommendedUsd = decimalStringToBig(input.recommendedUsd)
+  const priceUsd = decimalStringToBig(input.priceUsd)
+  const deficit = recommended.minus(balance)
+  if (
+    !recommended.gt(0) ||
+    !recommendedUsd.gt(0) ||
+    !priceUsd.gt(0) ||
+    !deficit.gt(0)
+  ) {
     return undefined
   }
-  return new DivBig(gasUsd)
-    .div(priceUsd)
+  return recommendedUsd
+    .times(deficit)
+    .times(100 + REFUEL_FEE_MARGIN_PERCENT)
+    .div(recommended.times(100).times(priceUsd))
     .round(decimals, DivBig.roundUp)
     .toFixed(decimals)
 }

package/src/wire/transferable.ts

@@ -1,5 +1,5 @@
 import type { DecimalString } from '@lifi/perps-types'
-import { requireDecimal } from '../decimal/requireDecimal.js'
+import { decimalStringToBig } from '../decimal/decimalStringToBig.js'
 
 /**
  * The part of `units` that a venue-wide free figure releases: never below
@@ -17,8 +17,8 @@ export function calculateTransferable(
   venueFigure: DecimalString,
   units: DecimalString
 ): DecimalString {
-  const figure = requireDecimal(venueFigure, 'venueFigure')
-  const held = requireDecimal(units, 'units')
+  const figure = decimalStringToBig(venueFigure)
+  const held = decimalStringToBig(units)
   if (figure.lt(0)) {
     return '0'
   }

package/src/wire/withdraw.ts

@@ -1,5 +1,5 @@
 import type { DecimalString } from '@lifi/perps-types'
-import { requireDecimal } from '../decimal/requireDecimal.js'
+import { decimalStringToBig } from '../decimal/decimalStringToBig.js'
 import type { WithdrawableBalance } from '../types/withdrawal.js'
 
 /**
@@ -18,12 +18,10 @@ export function calculateWithdrawMax(
     'available' | 'withdrawalFee' | 'isFeeDeducted'
   >
 ): DecimalString {
-  const available = requireDecimal(row.available, 'available')
+  const available = decimalStringToBig(row.available)
   if (row.isFeeDeducted !== false || row.withdrawalFee === undefined) {
     return available.toFixed()
   }
-  const funded = available.minus(
-    requireDecimal(row.withdrawalFee, 'withdrawalFee')
-  )
+  const funded = available.minus(decimalStringToBig(row.withdrawalFee))
   return funded.gt(0) ? funded.toFixed() : '0'
 }

package/dist/cjs/decimal/requireDecimal.d.ts

@@ -1,4 +0,0 @@
-import { type DecimalString } from '@lifi/perps-types';
-import Big from 'big.js';
-export declare function requireDecimal(value: DecimalString, field: string): Big;
-//# sourceMappingURL=requireDecimal.d.ts.map

package/dist/cjs/decimal/requireDecimal.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"requireDecimal.d.ts","sourceRoot":"","sources":["../../../src/decimal/requireDecimal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAkB,MAAM,mBAAmB,CAAA;AACtE,OAAO,GAAG,MAAM,QAAQ,CAAA;AAWxB,wBAAgB,cAAc,CAAC,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,GAAG,GAAG,CAQvE"}

package/dist/cjs/decimal/requireDecimal.js

@@ -1,17 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.requireDecimal = requireDecimal;
-const perps_types_1 = require("@lifi/perps-types");
-const big_js_1 = __importDefault(require("big.js"));
-const PerpsError_js_1 = require("../errors/PerpsError.js");
-const parse_js_1 = require("./parse.js");
-function requireDecimal(value, field) {
-    if (!(0, parse_js_1.isDecimalString)(value)) {
-        throw new PerpsError_js_1.PerpsError(perps_types_1.PerpsErrorCode.ValidationError, `Invalid \`${field}\`: '${value}' is not a decimal string.`);
-    }
-    return new big_js_1.default(value);
-}
-//# sourceMappingURL=requireDecimal.js.map

package/dist/cjs/decimal/requireDecimal.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"requireDecimal.js","sourceRoot":"","sources":["../../../src/decimal/requireDecimal.ts"],"names":[],"mappings":";;;;;AAYA,wCAQC;AApBD,mDAAsE;AACtE,oDAAwB;AACxB,2DAAoD;AACpD,yCAA4C;AAS5C,SAAgB,cAAc,CAAC,KAAoB,EAAE,KAAa;IAChE,IAAI,CAAC,IAAA,0BAAe,EAAC,KAAK,CAAC,EAAE,CAAC;QAC5B,MAAM,IAAI,0BAAU,CAClB,4BAAc,CAAC,eAAe,EAC9B,aAAa,KAAK,QAAQ,KAAK,4BAA4B,CAC5D,CAAA;IACH,CAAC;IACD,OAAO,IAAI,gBAAG,CAAC,KAAK,CAAC,CAAA;AACvB,CAAC"}

package/dist/esm/decimal/requireDecimal.d.ts

@@ -1,11 +0,0 @@
-import { type DecimalString } from '@lifi/perps-types';
-import Big from 'big.js';
-/**
- * Parse a decimal input, naming the field it came from when the
- * value breaks the {@link DecimalString} contract, so a malformed amount
- * fails at the SDK boundary instead of inside big.js.
- *
- * @throws {PerpsError} `ValidationError` naming `field`.
- */
-export declare function requireDecimal(value: DecimalString, field: string): Big;
-//# sourceMappingURL=requireDecimal.d.ts.map

package/dist/esm/decimal/requireDecimal.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"requireDecimal.d.ts","sourceRoot":"","sources":["../../../src/decimal/requireDecimal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAkB,MAAM,mBAAmB,CAAA;AACtE,OAAO,GAAG,MAAM,QAAQ,CAAA;AAIxB;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,GAAG,GAAG,CAQvE"}

package/dist/esm/decimal/requireDecimal.js

@@ -1,18 +0,0 @@
-import { PerpsErrorCode } from '@lifi/perps-types';
-import Big from 'big.js';
-import { PerpsError } from '../errors/PerpsError.js';
-import { isDecimalString } from './parse.js';
-/**
- * Parse a decimal input, naming the field it came from when the
- * value breaks the {@link DecimalString} contract, so a malformed amount
- * fails at the SDK boundary instead of inside big.js.
- *
- * @throws {PerpsError} `ValidationError` naming `field`.
- */
-export function requireDecimal(value, field) {
-    if (!isDecimalString(value)) {
-        throw new PerpsError(PerpsErrorCode.ValidationError, `Invalid \`${field}\`: '${value}' is not a decimal string.`);
-    }
-    return new Big(value);
-}
-//# sourceMappingURL=requireDecimal.js.map