@lifi/perps-sdk 0.0.0-preview-5cdfc44 → 0.0.0-preview-b49efcc

package/src/client/PerpsClient.ts

@@ -4,6 +4,7 @@ import type {
   ActionParamsMap,
   ActionResult,
   ActionStep,
+  AvailableToTrade,
   CreateActionResponse,
   ExecuteActionResponse,
   MarketRef,
@@ -16,19 +17,20 @@ import type {
   PositionMarginConstraints,
   Provider,
   ProviderAction,
-  SetupAction,
   SignedActionStep,
 } from '@lifi/perps-types'
 import {
   ActionType,
   META_PROVIDER,
   PerpsErrorCode,
+  PerpsSigner,
   SigningMethod,
 } from '@lifi/perps-types'
 import Big from 'big.js'
 import type { Address } from 'viem'
 import { PerpsError } from '../errors/PerpsError.js'
-import { getAssetRegistry } from '../registry/assetRegistry.js'
+import { getAssetRegistry, toAssetDisplay } from '../registry/assetRegistry.js'
+import { getMarketRegistry } from '../registry/marketRegistry.js'
 import { createAction } from '../services/createAction.js'
 import { executeAction } from '../services/executeAction.js'
 import { getAccount as fetchAccount } from '../services/getAccount.js'
@@ -87,23 +89,6 @@ import {
 import { createPerpsClient } from './createPerpsClient.js'
 import { requireProvider as resolveProvider } from './requireProvider.js'
 
-/** Absent `sequence` sorts last, so an unordered step gates nothing. */
-function sequenceOf(descriptor: ProviderAction): number {
-  return descriptor.sequence ?? Number.MAX_SAFE_INTEGER
-}
-
-/**
- * Whether the SDK can apply a preference without user input. Every declared
- * parameter must carry a `default`, since the action's params object is only
- * complete when each one has a value.
- */
-function declaresDefault(descriptor: ProviderAction): boolean {
-  const params = descriptor.params ?? []
-  return (
-    params.length > 0 && params.every((param) => param.default !== undefined)
-  )
-}
-
 /**
  * Look up an action's descriptor in the provider's metadata. Throws if the
  * action isn't declared — defensive: better to fail loudly than to mis-sign.
@@ -112,9 +97,11 @@ function findActionDescriptor(
   metadata: Provider,
   action: ActionType
 ): ProviderAction {
-  const descriptor = [...metadata.setup, ...metadata.actions].find(
-    (d) => d.type === action
-  )
+  const descriptor = [
+    ...metadata.setup,
+    ...metadata.options,
+    ...metadata.actions,
+  ].find((d) => d.type === action)
   if (!descriptor) {
     throw new PerpsError(
       PerpsErrorCode.SDKError,
@@ -467,7 +454,7 @@ export class PerpsClient {
   /**
    * Fetch the user's account state from the backend and attach the
    * SDK-projected `settings` array — one `AccountConfigSetting` per
-   * descriptor on `Provider.setup`. Callers read
+   * descriptor on `Provider.setup` + `Provider.options`. Callers read
    * `result.settings` directly without re-deriving values from the typed
    * `AccountConfig`.
    *
@@ -484,7 +471,11 @@ export class PerpsClient {
       fetchAccount(this.sdkClient, params),
       this.getProviderMetadata(params.provider),
     ])
-    const settings = plugin.projectConfig(response.config, metadata.setup)
+    const settings = plugin.projectConfig(
+      response.config,
+      metadata.setup,
+      metadata.options
+    )
     return { ...response, settings }
   }
 
@@ -509,6 +500,58 @@ export class PerpsClient {
     })
   }
 
+  /**
+   * The amounts `params.address` can still buy and sell on one market, in
+   * that market's margin asset. The order panel reads this per-market figure;
+   * account displays read the account-scoped
+   * {@link AccountSummary.availableMargin} instead.
+   *
+   * Providers that read a per-market figure answer it directly. For every
+   * other provider this falls back to the account summary, so both sides
+   * equal `availableMargin` and the asset is the market's quote asset.
+   *
+   * @throws {PerpsError} When the provider plugin is not registered, or the
+   *   market is unknown to the provider's market registry.
+   * @public
+   */
+  async getAvailableToTrade(
+    params: {
+      provider: string
+      address: Address
+      marketId: string
+    },
+    options?: SDKRequestOptions
+  ): Promise<AvailableToTrade> {
+    const plugin = this.requireProvider(params.provider)
+    const perMarket = await plugin.getAvailableToTrade?.(
+      { address: params.address, marketId: params.marketId },
+      options
+    )
+    if (perMarket !== undefined) {
+      return perMarket
+    }
+
+    const registry = getMarketRegistry(this.sdkClient, params.provider)
+    await registry.sync()
+    const market = registry.require(params.marketId)
+    const account = await fetchAccount(
+      this.sdkClient,
+      { provider: params.provider, address: params.address },
+      options
+    )
+    const { availableMargin } = plugin.getAccountSummary(
+      account,
+      account.positions
+    )
+    return {
+      providerId: market.providerId,
+      marketId: market.id,
+      asset: toAssetDisplay(market.quoteAsset),
+      buy: availableMargin,
+      sell: availableMargin,
+    }
+  }
+
   /**
    * Resolve the exact venue-owned margin requirements for `position`.
    * Returns `undefined` when the position has no individual margin adjustment.
@@ -648,16 +691,15 @@ export class PerpsClient {
   }
 
   /**
-   * Return the setup steps this account must still sign as a flat,
-   * self-describing list. Trading is gated on `isReady === true`.
-   * `checklist` carries the renderable onboarding list: every `approval` and
-   * `preference` descriptor with its satisfied state, with not-required
-   * conditional steps omitted.
+   * Return the unsatisfied entries on `Provider.setup` for this account as a
+   * flat, self-describing list. Trading is gated on `isReady === true`.
+   * `checklist` carries the renderable onboarding list: every USER-signed
+   * descriptor with its satisfied state, with not-required conditional steps
+   * omitted.
    *
-   * `automatic` descriptors are NEVER returned here — the SDK drains them with
-   * the provider's own credentials. A `preference` is listed but never staged:
-   * the user re-enters it through {@link executeProviderOption}, and the SDK
-   * applies the descriptor's declared default while it stays unsatisfied.
+   * `Provider.options` descriptors are NEVER returned here — options are
+   * post-setup tunables and never gate trading. Option state is surfaced
+   * separately via `getAccount().settings`.
    *
    * @public
    */
@@ -689,12 +731,12 @@ export class PerpsClient {
     )
 
     const plugin = this.sdkClient.getProvider(provider)
-
-    // Only an `approval` is staged by the generic loop: an `automatic` step is
-    // drained below, and a `preference` is re-entered by the user through
-    // `executeProviderOption` rather than signed off a staged step.
-    const stageable = pendingSetup.filter(
-      (descriptor) => descriptor.kind === 'approval'
+    const internalTypes = new Set(plugin?.internalSetupActions ?? [])
+    const isInternal = (descriptor: ProviderAction): boolean =>
+      internalTypes.has(descriptor.type) &&
+      !descriptor.signers.includes(PerpsSigner.USER)
+    const visibleSetup = pendingSetup.filter(
+      (descriptor) => !isInternal(descriptor)
     )
 
     // The backend filters already-satisfied setup actions and returns typed
@@ -703,7 +745,7 @@ export class PerpsClient {
     const actions = await this.buildProviderSetupActions(
       provider,
       address,
-      stageable
+      visibleSetup
     )
 
     // A staged step is one the build produced actions for — a pending
@@ -711,8 +753,10 @@ export class PerpsClient {
     // (backend-gated) or not applicable to this account.
     const stagedTypes = new Set(actions.map((step) => step.action))
     const conditionalTypes = new Set(plugin?.conditionalSetupActions ?? [])
+    const sequenceOf = (descriptor: ProviderAction): number =>
+      descriptor.sequence ?? Number.MAX_SAFE_INTEGER
     const checklist = metadata.setup
-      .filter((descriptor) => descriptor.kind !== 'automatic')
+      .filter((descriptor) => descriptor.signers.includes(PerpsSigner.USER))
       .filter(
         (descriptor) =>
           !conditionalTypes.has(descriptor.type) ||
@@ -721,21 +765,14 @@ export class PerpsClient {
       .sort((a, b) => sequenceOf(a) - sequenceOf(b))
       .map((descriptor) => ({
         descriptor,
-        satisfied:
-          descriptor.kind === 'preference'
-            ? satisfiedSetup.has(descriptor.type)
-            : !stagedTypes.has(descriptor.type),
+        satisfied: !stagedTypes.has(descriptor.type),
       }))
 
-    await this.drainSetup(
+    await this.drainInternalSetup(
       provider,
       address,
-      pendingSetup.filter(
-        (descriptor) =>
-          descriptor.kind === 'automatic' ||
-          (descriptor.kind === 'preference' && declaresDefault(descriptor))
-      ),
-      stageable.filter((descriptor) => stagedTypes.has(descriptor.type))
+      pendingSetup.filter(isInternal),
+      visibleSetup.filter((descriptor) => stagedTypes.has(descriptor.type))
     )
 
     return {
@@ -761,34 +798,43 @@ export class PerpsClient {
       return new Set()
     }
     const account = await plugin.getAccount({ address })
-    const settings = plugin.projectConfig(account.config, metadata.setup)
+    const settings = plugin.projectConfig(
+      account.config,
+      metadata.setup,
+      metadata.options
+    )
+    const setupTypes = new Set(
+      metadata.setup.map((descriptor) => descriptor.type)
+    )
     return new Set(
       settings
-        .filter((setting) => setting.satisfied)
+        .filter((setting) => setting.satisfied && setupTypes.has(setting.type))
         .map((setting) => setting.type)
     )
   }
 
   /**
-   * Drain the pending setup steps the SDK fulfils without user input: every
-   * `automatic` step, and every unsatisfied `preference` whose descriptor
-   * declares a parameter default. Each step is built, signed, and executed in
-   * place with the provider's own credentials. A step is deferred while any
-   * staged user-facing step with a lower `sequence` is outstanding — it cannot
-   * succeed before its prerequisite (e.g. SET_REFERRAL authenticates with the
-   * credential REGISTER_API_KEY installs) and each doomed attempt is venue
-   * traffic. A drain failure is swallowed so it never blocks setup — the step
-   * stays unsatisfied and is retried on a later `checkSetup`.
+   * Drain the pending setup steps the provider declares as internal via
+   * `PerpsProviderPlugin.internalSetupActions`. Each step is built, signed,
+   * and executed in place with the provider's own credentials. A step is
+   * deferred while any staged user-facing step with a lower `sequence` is
+   * outstanding — it cannot succeed before its prerequisite (e.g. SET_REFERRAL
+   * authenticates with the credential REGISTER_API_KEY installs) and each
+   * doomed attempt is venue traffic. A drain failure is swallowed so it never
+   * blocks setup — the step stays unsatisfied and is retried on a later
+   * `checkSetup`.
    */
-  private async drainSetup(
+  private async drainInternalSetup(
     provider: string,
     address: Address,
-    drainable: SetupAction[],
-    stagedVisible: SetupAction[]
+    internalPending: ProviderAction[],
+    stagedVisible: ProviderAction[]
   ): Promise<void> {
-    for (const descriptor of drainable) {
+    const sequenceOf = (descriptor: ProviderAction): number =>
+      descriptor.sequence ?? Number.MAX_SAFE_INTEGER
+    for (const descriptor of internalPending) {
       // A tie (equal sequences, or both absent) declares no order, so the
-      // drained step defers to the next checkSetup rather than racing.
+      // internal step defers to the next checkSetup rather than racing.
       const blocked = stagedVisible.some(
         (staged) => sequenceOf(staged) <= sequenceOf(descriptor)
       )
@@ -816,7 +862,7 @@ export class PerpsClient {
         }
       } catch (error) {
         console.debug(
-          `[perps-sdk] setup step '${descriptor.type}' for '${provider}' did not drain; will retry on the next checkSetup.`,
+          `[perps-sdk] internal setup step '${descriptor.type}' for '${provider}' did not complete; will retry on the next checkSetup.`,
           error
         )
       }
@@ -868,9 +914,7 @@ export class PerpsClient {
 
   /**
    * Build the unsigned setup `ActionStep`s still outstanding for an account,
-   * ordered by descriptor `sequence`. Only an `approval` step is staged: an
-   * `automatic` step drains inside {@link checkSetup} and a `preference`
-   * carries the user's own selection. The backend filters already-satisfied
+   * ordered by descriptor `sequence`. The backend filters already-satisfied
    * setup; each plugin contributes its own signer-bearing request fields and
    * any local-state params (e.g. Lighter's known pubkey).
    *
@@ -885,7 +929,7 @@ export class PerpsClient {
     const actions = await this.buildProviderSetupActions(
       provider,
       address,
-      metadata.setup.filter((descriptor) => descriptor.kind === 'approval')
+      metadata.setup
     )
     return { actions }
   }
@@ -939,45 +983,6 @@ export class PerpsClient {
     return { results: { results } }
   }
 
-  /**
-   * The lowest-`sequence` visible setup step that runs before `descriptor` and
-   * is not satisfied, or `undefined` when nothing blocks it. A `preference`
-   * reads its satisfied state from the plugin projection; an `approval` is
-   * satisfied once the provider stages no action for it, so only the earlier
-   * steps are staged here.
-   */
-  private async findBlockingSetupStep(
-    provider: string,
-    address: Address,
-    descriptor: SetupAction
-  ): Promise<SetupAction | undefined> {
-    const metadata = await this.getProviderMetadata(provider)
-    const earlier = metadata.setup
-      .filter(
-        (d) => d.kind !== 'automatic' && sequenceOf(d) < sequenceOf(descriptor)
-      )
-      .sort((a, b) => sequenceOf(a) - sequenceOf(b))
-    if (earlier.length === 0) {
-      return undefined
-    }
-
-    const satisfiedSetup = await this.resolveSatisfiedSetup(provider, address)
-    const pending = earlier.filter((d) => !satisfiedSetup.has(d.type))
-    if (pending.length === 0) {
-      return undefined
-    }
-
-    const stageable = pending.filter((d) => d.kind === 'approval')
-    const staged =
-      stageable.length === 0
-        ? []
-        : await this.buildProviderSetupActions(provider, address, stageable)
-    const stagedTypes = new Set(staged.map((action) => action.action))
-    return pending.find(
-      (d) => d.kind === 'preference' || stagedTypes.has(d.type)
-    )
-  }
-
   /**
    * Sign and submit one pre-staged setup `ActionStep` end-to-end.
    *
@@ -991,8 +996,7 @@ export class PerpsClient {
    * retries with a fresh step.
    *
    * @throws {PerpsError} When the step's action is not in the provider's
-   *   `setup` descriptors, or when a lower-`sequence` step on the same
-   *   checklist is still unsatisfied.
+   *   `setup` descriptors.
    * @public
    */
   async executeProviderSetupAction(params: {
@@ -1011,18 +1015,6 @@ export class PerpsClient {
       )
     }
 
-    const blocking = await this.findBlockingSetupStep(
-      provider,
-      address,
-      descriptor
-    )
-    if (blocking) {
-      throw new PerpsError(
-        PerpsErrorCode.SDKError,
-        `Setup step '${step.action}' for '${provider}' is blocked: '${blocking.type}' runs first and is not satisfied.`
-      )
-    }
-
     const signed = await this.signProviderSetupAction(provider, address, step)
 
     // A client-executed setup action (Lighter SET_REFERRAL) produces no
@@ -1041,19 +1033,19 @@ export class PerpsClient {
   }
 
   /**
-   * Sign and submit a single preference change (a `preference` setup step such
-   * as Lighter `ACCOUNT_TYPE` or Hyperliquid `ACCOUNT_MODE`) end-to-end,
-   * throwing on a venue rejection.
+   * Sign and submit a single provider-option change (a `Provider.options`
+   * tunable such as Lighter `ACCOUNT_TYPE` or Hyperliquid `ACCOUNT_MODE`)
+   * end-to-end, throwing on a venue rejection.
    *
-   * Preferences are dispatched through the same {@link execute} pipeline as
-   * trades, but unlike a trade a preference change is a single mandatory
-   * action: a per-action `success: false` (returned as a 200 OK) means the
-   * user's selection was rejected and must surface, not be silently dropped.
-   * This wrapper inspects the result and throws a {@link PerpsError} carrying
-   * the venue `error`, giving a preference the same throw contract that setup
-   * has via {@link executeProviderSetupAction}. The only structural difference
-   * is that a preference carries `params` (the selected value) rather than a
-   * pre-staged step.
+   * Options are dispatched through the same {@link execute} pipeline as
+   * trades, but unlike a trade an option change is a single mandatory action:
+   * a per-action `success: false` (returned as a 200 OK) means the user's
+   * selection was rejected and must surface, not be silently dropped. This
+   * wrapper inspects the result and throws a {@link PerpsError} carrying the
+   * venue `error`, giving options the same throw contract that setup has via
+   * {@link executeProviderSetupAction}. The only structural difference is that
+   * an option carries `params` (the selected value) rather than a pre-staged
+   * step.
    *
    * `execute` itself is unchanged — it still returns results without throwing,
    * which the trade hooks rely on for partial-fill handling.

package/src/index.ts

@@ -19,7 +19,11 @@ export { PerpsClient } from './client/PerpsClient.js'
 export { PerpsErrorMessage } from './errors/constants.js'
 export { PerpsError } from './errors/PerpsError.js'
 // Registries
-export { AssetRegistry, getAssetRegistry } from './registry/assetRegistry.js'
+export {
+  AssetRegistry,
+  getAssetRegistry,
+  toAssetDisplay,
+} from './registry/assetRegistry.js'
 export type { DefaultMarketProvider } from './registry/marketRegistry.js'
 export {
   DEFAULT_MARKET_ID,
@@ -152,6 +156,7 @@ export type {
   ProviderAccountExistsParams,
   ProviderGetAccountParams,
   ProviderGetActivityParams,
+  ProviderGetAvailableToTradeParams,
   ProviderGetDepositFlowParams,
   ProviderGetFillsParams,
   ProviderGetMarketSettingsParams,

package/src/registry/assetRegistry.ts

@@ -1,4 +1,4 @@
-import type { Asset, AssetsResponse } from '@lifi/perps-types'
+import type { Asset, AssetDisplay, AssetsResponse } from '@lifi/perps-types'
 import { PerpsErrorCode } from '@lifi/perps-types'
 import { PerpsError } from '../errors/PerpsError.js'
 import { buildUrl, request } from '../transport/request.js'
@@ -59,6 +59,21 @@ export class AssetRegistry extends ReferenceDataRegistry<Asset> {
   }
 }
 
+/**
+ * Project an {@link Asset} to the identity and labels a display needs.
+ *
+ * @public
+ */
+export const toAssetDisplay = (asset: Asset): AssetDisplay => ({
+  providerId: asset.providerId,
+  id: asset.id,
+  displaySymbol: asset.displaySymbol,
+  logoURI: asset.logoURI,
+  ...(asset.displayName === undefined
+    ? {}
+    : { displayName: asset.displayName }),
+})
+
 const registries = new WeakMap<PerpsSDKClient, Map<string, AssetRegistry>>()
 
 /**

package/src/types/api.ts

@@ -15,7 +15,7 @@ import type {
   OrderSide,
   OrderType,
   PortfolioHistoryRange,
-  SetupAction,
+  ProviderAction,
   SignedActionStep,
   TimeInForce,
   TriggerOrderInput,
@@ -318,7 +318,7 @@ export interface GetPortfolioHistoryParams {
  */
 export interface SetupChecklistItem {
   /** The `Provider.setup` descriptor for this step. */
-  descriptor: SetupAction
+  descriptor: ProviderAction
   /** Whether the step is already satisfied for this account. */
   satisfied: boolean
 }
@@ -331,10 +331,8 @@ export interface SetupChecklistItem {
  * to the provider's `setup` descriptor, which declares the step's signer and
  * scheme), so no signer-role partition is exposed here.
  *
- * `automatic` setup steps are NEVER included here — the SDK drains them
- * itself. A `preference` step is listed on `checklist` but never staged: it
- * does not gate trading, and the user re-enters it through
- * `PerpsClient.executeProviderOption`.
+ * `Provider.options` items are NEVER included here — they don't gate trading
+ * and are surfaced separately via `getAccount().settings`.
  *
  * @public
  */
@@ -351,9 +349,9 @@ export interface ProviderSetup {
   /** Whether all setup items are already satisfied (ready to trade) */
   isReady: boolean
   /**
-   * The renderable onboarding list: every `approval` and `preference` setup
-   * descriptor with its satisfied state, ordered by `sequence`. `automatic`
-   * steps and conditional steps that staged no work for this account (see
+   * The renderable onboarding list: every USER-signed setup descriptor with
+   * its satisfied state, ordered by `sequence`. SDK-internal steps and
+   * conditional steps that staged no work for this account (see
    * `PerpsProviderPlugin.conditionalSetupActions`) are omitted. Consumers
    * render this list directly instead of joining `Provider.setup` metadata
    * with the staged `setup` steps.
@@ -385,14 +383,14 @@ export interface ExecuteProviderSetupResult {
  * backend's `AccountResponse` with a single SDK-projected `settings` array.
  *
  * `settings` contains exactly one `AccountConfigSetting` per descriptor on
- * `Provider.setup`, in that order. Index the projection by
- * `setting.type === descriptor.type` and read `setting.values[i].value` for
- * each `Param` the descriptor declared.
+ * `Provider.setup` + `Provider.options` (in that order). Index the
+ * projection by `setting.type === descriptor.type` and read
+ * `setting.values[i].value` for each `Param` the descriptor declared.
  *
  * @public
  */
 export interface GetAccountResult extends AccountResponse {
-  /** SDK-projected current state of every `Provider.setup` descriptor. */
+  /** SDK-projected current state of every setup + options descriptor. */
   settings: AccountConfigSetting[]
 }
 

package/src/types/provider.ts

@@ -8,6 +8,7 @@ import type {
   ActionType,
   ActivitiesResponse,
   ActivityType,
+  AvailableToTrade,
   FillsResponse,
   Market,
   MarketRef,
@@ -22,9 +23,9 @@ import type {
   Position,
   PositionMarginConstraints,
   PositionsResponse,
+  ProviderAction,
   Quote,
   QuoteSide,
-  SetupAction,
   SignedActionStep,
   SigningMethod,
   TradeType,
@@ -216,6 +217,17 @@ export interface ProviderGetMarketSettingsParams {
   market: MarketRef
 }
 
+/**
+ * Read params for {@link PerpsProviderPlugin.getAvailableToTrade}.
+ *
+ * @public
+ */
+export interface ProviderGetAvailableToTradeParams {
+  address: Address
+  /** The market's opaque `Market.id` (not a display symbol). */
+  marketId: string
+}
+
 /**
  * Read params for {@link PerpsProvider.getOrders}.
  *
@@ -349,6 +361,17 @@ export interface PerpsProviderPlugin {
    */
   readonly type: string
 
+  /**
+   * Setup actions the provider completes on its own, without surfacing a card
+   * to the caller. `PerpsClient.checkSetup` drains each such pending step in
+   * place — building, signing, and executing it with the provider's own
+   * credentials — and omits it from the returned `setup` list. A descriptor
+   * whose `signers` include {@link PerpsSigner.USER} is never treated as
+   * internal, even when named here. Omit when the provider has no
+   * self-completed setup steps.
+   */
+  readonly internalSetupActions?: readonly ActionType[]
+
   /**
    * Setup actions that stage work only when the account needs remediation
    * (e.g. Hyperliquid's REVOKE_AGENT frees an agent slot only when every
@@ -431,6 +454,19 @@ export interface PerpsProviderPlugin {
     options?: SDKRequestOptions
   ): Promise<MarketSettings | undefined>
 
+  /**
+   * The amounts the account can still buy and sell on one market, in that
+   * market's margin asset. Optional because venues expose this unevenly:
+   * Hyperliquid reads it directly (`activeAssetData`), other venues publish
+   * only an account-scoped figure. `undefined` means the venue has nothing
+   * to read for this market, and the caller falls back to the account
+   * summary.
+   */
+  getAvailableToTrade?(
+    params: ProviderGetAvailableToTradeParams,
+    options?: SDKRequestOptions
+  ): Promise<AvailableToTrade | undefined>
+
   getOrders(
     params: ProviderGetOrdersParams,
     options?: SDKRequestOptions
@@ -540,11 +576,9 @@ export interface PerpsProviderPlugin {
 
   /**
    * Project a typed {@link AccountConfig} against the provider's `setup`
-   * descriptors into `AccountConfigSetting[]`. Used by
+   * + `options` descriptors into `AccountConfigSetting[]`. Used by
    * `PerpsClient.getAccount` to attach a `settings` array to the response —
-   * one entry per descriptor, in `setup` order. Every `preference` descriptor
-   * carries a boolean `satisfied`, because `PerpsClient.checkSetup` reads a
-   * preference's satisfied state from this projection alone.
+   * one entry per descriptor, in `setup`-then-`options` order.
    *
    * Implementations receive the union-typed `AccountConfig` and narrow on
    * `config.provider` themselves; the dispatcher in `PerpsClient` does not
@@ -552,7 +586,8 @@ export interface PerpsProviderPlugin {
    */
   projectConfig(
     config: AccountConfig,
-    setup: SetupAction[]
+    setup: ProviderAction[],
+    options: ProviderAction[]
   ): AccountConfigSetting[]
 
   /**

package/src/version.ts

@@ -10,4 +10,4 @@ export const name = '@lifi/perps-sdk'
  *
  * @public
  */
-export const version = '0.0.0-preview-5cdfc44'
+export const version = '0.0.0-preview-b49efcc'