@ostium/builder-sdk 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Hex, Address } from 'viem';
+import { Address, Hex } from 'viem';
 
 declare enum OrderType$1 {
     Market = "market",
@@ -11,8 +11,11 @@ declare enum CancelOrderType {
     PendingClose = "pendingClose"
 }
 interface OpenTradeParams {
-    /** Trading pair index (e.g. 0 for BTC/USD). */
-    pairIndex: number;
+    /**
+     * Trading pair id — same value as `Pair.pairId` returned by `getPairs()`.
+     * Accepts both the numeric string (e.g. `"0"`) and a plain `number`.
+     */
+    pairId: string | number;
     /** true = long, false = short. */
     buy: boolean;
     /** Entry price as a decimal string (e.g. "65000.50"). */
@@ -158,7 +161,28 @@ interface SubmissionResult {
     /** Set for gasless submissions — the Safe smart account address that sent the UserOp. */
     smartAccountAddress?: Address;
 }
+interface BuiltSafeTxCall {
+    to: Address;
+    data: Hex;
+    value: bigint;
+}
+interface BuiltEoaTxRequest {
+    kind: 'eoa';
+    to: Address;
+    data: Hex;
+    value: bigint;
+    from: Address;
+    traderAddress: Address;
+}
+interface BuiltSafeTxRequest {
+    kind: 'safe';
+    safeAddress: Address;
+    traderAddress: Address;
+    calls: [BuiltSafeTxCall];
+}
+type BuiltTxRequest = BuiltEoaTxRequest | BuiltSafeTxRequest;
 
+type ClientMode = 'self-self' | 'self-gasless' | 'delegated-self' | 'delegated-gasless';
 /** Shared optional settings available in every mode. */
 interface CommonParams {
     /** Use Arbitrum Sepolia testnet. Defaults to false (mainnet). */
@@ -185,47 +209,26 @@ interface CommonParams {
      */
     builderApiUrl?: string;
 }
-/**
- * **Self + Self** — simplest mode.
- *
- * Your EOA is the trader: it holds USDC, owns all positions, and pays gas
- * for every transaction directly.
- *
- * ```ts
- * const client = await OstiumClient.createSelfAndSelf({
- *   traderPrivateKey: '0x...',
- *   rpcUrl: 'https://arb-mainnet.g.alchemy.com/v2/...',
- * });
- * await client.openTrade({ ... });
- * ```
- */
-interface SelfSelfParams extends CommonParams {
+interface SelfSelfSubmitParams extends CommonParams {
     /** Private key of the trader's EOA. This account holds USDC, owns all positions, and pays gas. */
     traderPrivateKey: Hex;
     /** Arbitrum One (or Sepolia) RPC URL. */
     rpcUrl: string;
 }
+interface SelfSelfBuildParams extends CommonParams {
+    /** Trader EOA address. Used to build unsigned transactions without SDK submission. */
+    traderAddress: Address;
+    /** Optional Arbitrum RPC URL for reads/simulation. Defaults to the chain public RPC. */
+    rpcUrl?: string;
+}
 /**
- * **Self + Gasless** — your EOA owns everything; a Safe acts as a transparent gasless relay.
- *
- * Your EOA holds USDC and owns all positions. A Safe smart account is derived
- * deterministically from your private key and registered as your delegate.
- * After a one-time setup (approve USDC + register Safe via `setupGaslessDelegation()`),
- * all subsequent trades are submitted as sponsored UserOperations — no ETH needed.
+ * **Self + Self** — simplest mode.
  *
- * ```ts
- * const client = await OstiumClient.createSelfAndGasless({
- *   traderPrivateKey: '0x...',
- *   pimlicoUrl: 'https://builder.ostium.io/v1/pimlico/sponsor?chainId=42161',
- * });
- * // One-time setup (EOA pays gas once for each):
- * await client.approveUsdc('max');
- * await client.setupGaslessDelegation();
- * // All subsequent trading is free:
- * await client.openTrade({ ... });
- * ```
+ * Your EOA is the trader: it holds USDC, owns all positions, and pays gas
+ * for every transaction directly.
  */
-interface SelfGaslessParams extends CommonParams {
+type SelfSelfParams = SelfSelfSubmitParams | SelfSelfBuildParams;
+interface SelfGaslessSubmitParams extends CommonParams {
     /** Private key of the trader's EOA. This account holds USDC and owns all positions. A Safe is derived from this key to relay trades gaslessly. */
     traderPrivateKey: Hex;
     /** Pimlico-compatible bundler/paymaster RPC URL. Defaults to `https://builder.ostium.io/v1/pimlico/sponsor?chainId=42161`. */
@@ -235,23 +238,22 @@ interface SelfGaslessParams extends CommonParams {
     /** Pimlico sponsorship policy ID. */
     sponsorshipPolicyId?: string;
 }
+interface SelfGaslessBuildParams extends CommonParams {
+    /** Trader EOA address that owns USDC and positions. */
+    traderAddress: Address;
+    /** Safe smart-account address that will submit delegated calls. */
+    safeAddress: Address;
+    /** Optional Arbitrum RPC URL for reads/simulation. Defaults to the chain public RPC. */
+    rpcUrl?: string;
+}
 /**
- * **Delegated + Self** — a dedicated delegate EOA signs and pays gas on behalf of a separate trader address.
- *
- * The trader account keeps custody of USDC and positions. The delegate account
- * only needs ETH for gas. The trader must have called `setDelegate(delegateAddress)`
- * on the trading contract before this client can submit trades.
+ * **Self + Gasless** — your EOA owns everything; a Safe acts as a transparent gasless relay.
  *
- * ```ts
- * const client = await OstiumClient.createDelegatedAndSelf({
- *   delegatePrivateKey: '0xDelegateKey',
- *   traderAddress: '0xTraderAddress',
- *   rpcUrl: 'https://arb-mainnet.g.alchemy.com/v2/...',
- * });
- * await client.openTrade({ ... }); // submitted as delegatedAction(traderAddress, ...)
- * ```
+ * Submit-capable clients derive the Safe from `traderPrivateKey`. Build-only
+ * clients provide both `traderAddress` and `safeAddress`.
  */
-interface DelegatedSelfParams extends CommonParams {
+type SelfGaslessParams = SelfGaslessSubmitParams | SelfGaslessBuildParams;
+interface DelegatedSelfSubmitParams extends CommonParams {
     /** Private key of the delegate EOA. This account signs and pays gas for all transactions. */
     delegatePrivateKey: Hex;
     /**
@@ -262,30 +264,25 @@ interface DelegatedSelfParams extends CommonParams {
     /** Arbitrum One (or Sepolia) RPC URL. */
     rpcUrl: string;
 }
+interface DelegatedSelfBuildParams extends CommonParams {
+    /** Address of the trader this delegate acts for. */
+    traderAddress: Address;
+    /** Delegate EOA address that will submit the transaction. */
+    delegateAddress: Address;
+    /** Optional Arbitrum RPC URL for reads/simulation. Defaults to the chain public RPC. */
+    rpcUrl?: string;
+}
 /**
- * **Delegated + Gasless** — a Safe derived from the delegate key submits sponsored UserOperations on behalf of the trader.
- *
- * The trader keeps custody of USDC and positions. The delegate's Safe submits
- * trades as UserOperations via Pimlico — no ETH needed after the trader calls
- * `setDelegate(safeAddress)` once.
- *
- * ```ts
- * const client = await OstiumClient.createDelegatedAndGasless({
- *   delegatePrivateKey: '0xDelegateKey',
- *   traderAddress: '0xTraderAddress',
- *   pimlicoUrl: 'https://builder.ostium.io/v1/pimlico/sponsor?chainId=42161',
- * });
- * await client.openTrade({ ... }); // submitted as sponsored delegatedAction UserOp
- * ```
+ * **Delegated + Self** — a dedicated delegate EOA signs and pays gas on behalf of a separate trader address.
  */
-interface DelegatedGaslessParams extends CommonParams {
+type DelegatedSelfParams = DelegatedSelfSubmitParams | DelegatedSelfBuildParams;
+interface DelegatedGaslessSubmitParams extends CommonParams {
     /** Private key of the delegate EOA. A Safe smart account is derived from this key and submits UserOperations via Pimlico. */
     delegatePrivateKey: Hex;
     /**
      * Address of the trader this delegate acts for.
      * The trader must have called `setDelegate(safeAddress)` on the trading contract,
      * where `safeAddress` is the Safe derived from `delegatePrivateKey`.
-     * Use `client.getSmartAccountAddress()` to retrieve this address.
      */
     traderAddress: Address;
     /** Pimlico-compatible bundler/paymaster RPC URL. Defaults to `https://builder.ostium.io/v1/pimlico/sponsor?chainId=42161`. */
@@ -295,34 +292,29 @@ interface DelegatedGaslessParams extends CommonParams {
     /** Pimlico sponsorship policy ID. */
     sponsorshipPolicyId?: string;
 }
+interface DelegatedGaslessBuildParams extends CommonParams {
+    /** Address of the trader this delegate acts for. */
+    traderAddress: Address;
+    /** Delegate EOA address that owns the Safe. */
+    delegateAddress: Address;
+    /** Safe smart-account address that will submit delegated calls. */
+    safeAddress: Address;
+    /** Optional Arbitrum RPC URL for reads/simulation. Defaults to the chain public RPC. */
+    rpcUrl?: string;
+}
 /**
- * Generic config object used by the legacy `OstiumClient.create()` method.
- * Prefer the named constructors (`createSelfAndSelf`, `createSelfAndGasless`,
- * `createDelegatedAndSelf`, `createDelegatedAndGasless`) for clearer intent.
- *
- * The SDK infers the operational mode from the shape of this object:
- *
- * | `traderAddress` | `pimlicoUrl` | Mode                |
- * |:---:|:---:|:---|
- * | ✓ | ✓ | Delegated + Gasless |
- * | ✓ | — | Delegated + Self    |
- * | — | ✓ | Self + Gasless      |
- * | — | — | Self + Self         |
+ * **Delegated + Gasless** — a Safe derived from the delegate key submits sponsored UserOperations on behalf of the trader.
  */
-interface OstiumClientConfig {
-    privateKey: Hex;
+type DelegatedGaslessParams = DelegatedGaslessSubmitParams | DelegatedGaslessBuildParams;
+interface OstiumClientConfig extends CommonParams {
+    mode?: ClientMode;
+    privateKey?: Hex;
     traderAddress?: Address;
+    delegateAddress?: Address;
+    safeAddress?: Address;
     rpcUrl?: string;
     pimlicoUrl?: string;
     sponsorshipPolicyId?: string;
-    testnet?: boolean;
-    builder?: {
-        address: Address;
-        feeBps: number;
-    };
-    slippageBps?: number;
-    subgraphUrl?: string;
-    builderApiUrl?: string;
 }
 
 /** Mainnet (Arbitrum One) Ostium subgraph endpoint. */
@@ -481,11 +473,11 @@ interface Position {
     isDayTrade: boolean;
     /** Max leverage for the trade/pair/group **/
     maxLeverage: string;
+    /** Max collateral removable from this position without breaching min leverage, in USD. */
+    maxWithdrawable: string;
 }
 interface PairPosition {
     position: Position;
-    /** Max collateral removable from this position without breaching min leverage, in USD. */
-    maxWithdrawable: string;
 }
 interface MarginSummary {
     /** Sum of `(collateral + netPnl)` across all open positions (USD). */
@@ -496,17 +488,16 @@ interface MarginSummary {
     totalNtlPos: string;
     /** Sum of unrealized PnL (after rollover) across all open positions (USD). */
     totalRawPnlUsd: string;
+    /** Sum of cumulative rollover across all open positions (USD, negative = trader pays). */
+    totalCumRollover: string;
+    /** Sum of per-position max-removable collateral across all open positions (USD). */
+    totalWithdrawable: string;
 }
 interface OpenPositionsResponse {
     /** All open positions for the requested trader, sorted newest first. */
     pairPositions: PairPosition[];
     /** Aggregated margin metrics across all open positions. */
     marginSummary: MarginSummary;
-    /**
-     * Sum of per-position max-removable collateral, computed from the leverage
-     * constraint: `collateral × (1 − currentLeverage / maxLeverage)`.
-     */
-    withdrawable: string;
     /** Server time (Unix milliseconds). */
     time: number;
 }
@@ -719,6 +710,8 @@ interface GetSimOrderbookParams {
 }
 /** Live price tick received from the builder API price stream. */
 interface PriceTick {
+    /** Numeric string pair identifier — same as `Pair.pairId`, when resolvable from the SDK cache. */
+    pairId?: string;
     /** Upstream feed identifier. */
     feedId: string;
     /** Pair in `"BASE-QUOTE"` format (e.g. `"BTC-USD"`). */
@@ -811,6 +804,8 @@ declare class OstiumPriceStream {
     private readonly snapshotHandlers;
     /** pairId (string) → raw "FROM-TO" name for the WS API. */
     private readonly pairRawNameCache;
+    /** raw "FROM-TO" name → pairId (string) for mapping incoming ticks back to SDK ids. */
+    private readonly rawNamePairIdCache;
     private constructor();
     /**
      * Open a WebSocket connection to the live price stream.
@@ -863,6 +858,34 @@ declare class OstiumPriceStream {
     private send;
 }
 
+type UpdateHandler = (positions: OpenPositionsResponse) => void;
+type TickSource = Pick<OstiumPriceStream, 'onTick' | 'onSnapshot' | 'onOpen' | 'onError' | 'onClose' | 'close'>;
+declare class OstiumPositionUpdatesStream {
+    private readonly priceStream?;
+    private readonly updateHandlers;
+    private current;
+    private readonly trackedPairIds;
+    constructor(initial: OpenPositionsResponse, trackedPairIds: string[], priceStream?: TickSource);
+    onUpdate(handler: UpdateHandler): () => void;
+    onOpen(handler: () => void): this;
+    onError(handler: (event: Error) => void): this;
+    onClose(handler: (code: number, reason: string) => void): this;
+    getCurrent(): OpenPositionsResponse;
+    /**
+     * Apply a single externally sourced price tick to the tracked positions.
+     *
+     * Use this when your app already has its own websocket connection and you want
+     * the SDK to handle only the position recalculation logic.
+     */
+    ingestTick(tick: PriceTick): void;
+    /**
+     * Apply a batch of externally sourced ticks, such as a websocket snapshot.
+     */
+    ingestSnapshot(ticks: PriceTick[]): void;
+    close(): void;
+    private emit;
+}
+
 declare class OstiumSubgraphClient {
     private readonly gql;
     private readonly builderApiUrl;
@@ -1001,6 +1024,18 @@ declare class OstiumSubgraphClient {
      * `WebSocket` may fail some `https://` upgrades (e.g. CloudFront); use Node if so.
      */
     streamPrices(pairIds?: Array<string | number>): OstiumPriceStream;
+    /**
+     * Stream price-driven updates for an existing `getOpenPositions()` response.
+     *
+     * The SDK subscribes only to the unique pairs present in `initial.pairPositions`,
+     * recalculates price-sensitive fields for affected positions on each tick, and
+     * emits the full updated response.
+     *
+     * Pass an existing `priceStream` to reuse a websocket connection your app has
+     * already opened. Omit it to let the SDK open and manage a dedicated
+     * connection for the tracked pair ids.
+     */
+    streamPositionUpdates(initial: OpenPositionsResponse, priceStream?: OstiumPriceStream): OstiumPositionUpdatesStream;
     private fetchRawPairs;
     private refreshPairIdCache;
     private ensurePairIdCache;
@@ -1013,6 +1048,8 @@ declare class OstiumSubgraphClient {
 declare class OstiumClient {
     private readonly signer?;
     private readonly submitter?;
+    private readonly traderAddress?;
+    private readonly effectiveSender?;
     private readonly contracts;
     private readonly publicClient;
     private readonly defaultSlippageBps;
@@ -1038,7 +1075,7 @@ declare class OstiumClient {
      * });
      * await client.openTrade({ ... });
      * ```
-     */
+    */
     static createSelfAndSelf(params: SelfSelfParams): Promise<OstiumClient>;
     /**
      * **Self + Gasless** — your EOA owns everything; a Safe relays trades for free.
@@ -1130,8 +1167,12 @@ declare class OstiumClient {
      * - Self + Gasless: EOA derived from privateKey (NOT the Safe — USDC lives here).
      */
     getTraderAddress(): Address;
-    /** True when the client was created via `createReadOnly` and cannot submit transactions. */
+    /** True when the client cannot submit transactions directly. */
     isReadOnly(): boolean;
+    /** True when the client can build mode-correct unsigned transaction requests. */
+    canBuildTransactions(): boolean;
+    /** True when the client has the credentials needed for SDK-managed submission. */
+    canSubmitTransactions(): boolean;
     /**
      * Returns the Safe smart-account address used for gasless submission.
      * Returns undefined when not in gasless mode.
@@ -1161,6 +1202,7 @@ declare class OstiumClient {
      * ```
      */
     setupGaslessDelegation(): Promise<SubmissionResult>;
+    getSetupGaslessDelegationTx(): BuiltTxRequest;
     /**
      * Check whether the trader's USDC allowance covers the required amount.
      * The allowance is always checked against signer.traderAddress (the EOA in
@@ -1187,6 +1229,7 @@ declare class OstiumClient {
      * @param amount USD amount as decimal string (e.g. "1000"), or "max" for MaxUint256.
      */
     approveUsdc(amount: string): Promise<SubmissionResult>;
+    getApproveUsdcTx(amount: string): BuiltTxRequest;
     /**
      * Set a delegate on the trading contract.
      *
@@ -1196,11 +1239,13 @@ declare class OstiumClient {
      *   update the trader's delegation on their behalf.
      */
     setDelegate(delegateAddress: Address): Promise<SubmissionResult>;
+    getSetDelegateTx(delegateAddress: Address): BuiltTxRequest;
     /**
      * Remove the current delegate on the trading contract.
      * Follows the same delegation-wrapping rules as setDelegate().
      */
     removeDelegate(): Promise<SubmissionResult>;
+    getRemoveDelegateTx(): BuiltTxRequest;
     /**
      * Open a new trade position.
      *
@@ -1209,6 +1254,8 @@ declare class OstiumClient {
      * the current allowance.
      */
     openTrade(params: OpenTradeParams): Promise<SubmissionResult>;
+    getOpenTradeTx(params: OpenTradeParams): BuiltTxRequest;
+    private getOpenTradeEncoded;
     /**
      * Close an open position (full or partial).
      *
@@ -1222,6 +1269,8 @@ declare class OstiumClient {
      * ```
      */
     closeTrade(params: CloseTradeParams): Promise<SubmissionResult>;
+    getCloseTradeTx(params: CloseTradeParams): BuiltTxRequest;
+    private getCloseTradeEncoded;
     /**
      * Cancel a pending order.
      *
@@ -1243,6 +1292,8 @@ declare class OstiumClient {
      * ```
      */
     cancelOrder(params: CancelOrderParams): Promise<SubmissionResult>;
+    getCancelOrderTx(params: CancelOrderParams): BuiltTxRequest;
+    private getCancelOrderEncoded;
     /**
      * Modify an open trade or a pending limit order.
      *
@@ -1266,6 +1317,8 @@ declare class OstiumClient {
      * - Both `takeProfit` and `stopLoss` without `price` → throws (send two calls).
      */
     modifyOrder(params: ModifyOrderParams): Promise<SubmissionResult>;
+    getModifyOrderTx(params: ModifyOrderParams): BuiltTxRequest;
+    private getModifyOrderEncoded;
     /**
      * Update collateral on an open position (isolated margin).
      *
@@ -1284,6 +1337,8 @@ declare class OstiumClient {
      * Checks USDC allowance before top-up operations.
      */
     updateCollateral(params: UpdateCollateralParams): Promise<SubmissionResult>;
+    getUpdateCollateralTx(params: UpdateCollateralParams): Promise<BuiltTxRequest>;
+    private getUpdateCollateralEncoded;
     /**
      * All trading pairs with computed `minSz`/`maxBSz`/`maxSSz`, live prices, and
      * market-status flags. Pass `pairIds` to restrict to a subset.
@@ -1372,15 +1427,27 @@ declare class OstiumClient {
      */
     streamPrices(pairIds?: Array<string | number>): OstiumPriceStream;
     /**
-     * Core execution pipeline:
-     * 1. signer.prepare()  — optionally wraps in delegatedAction.
-     * 2. submitter.submit() — sends via EOA walletClient or Pimlico UserOp.
-     */
-    private execute;
-    /** Throws if the client is read-only; otherwise returns the signer + submitter. */
-    private requireWriter;
+     * Stream price-driven updates for an existing `getOpenPositions()` response.
+     *
+     * Subscribes only to the unique pairs referenced by the response and emits the
+     * full updated positions payload on each relevant price update. Pass an
+     * existing `priceStream` to reuse a websocket your app already owns, or omit
+     * it to let the SDK create a dedicated connection.
+     */
+    streamPositionUpdates(initial: OpenPositionsResponse, priceStream?: OstiumPriceStream): OstiumPositionUpdatesStream;
+    private getSetupGaslessDelegationEncoded;
+    private getApproveUsdcEncoded;
+    private getSetDelegateEncoded;
+    private getRemoveDelegateEncoded;
+    private prepareEncoded;
+    private buildPreparedTx;
+    private buildDirectEoaTx;
+    private toBuiltTxRequest;
+    private submitPrepared;
     /** Direct EOA submission — used only in Self + Gasless for approveUsdc and setupGaslessDelegation. */
-    private submitDirectFromEoa;
+    private submitDirectEoa;
+    private requireBuildCapability;
+    private requireSubmitCapability;
     private resolveSlippage;
 }
 
@@ -1446,4 +1513,4 @@ declare class OstiumSubgraphError extends Error {
     constructor(message: string, code: OstiumSubgraphErrorCode, cause?: unknown | undefined);
 }
 
-export { type AllPricesResponse, type AllTraders, type AllowanceStatus, type Balances, type CancelLimitOrderParams, type CancelOrderParams, CancelOrderType, type CancelPendingCloseParams, type CancelPendingOpenParams, type Candle, type CandleResolution, type CloseTradeParams, DEFAULT_BUILDER_API_URL, DEFAULT_SLIPPAGE_PERCENTAGE, DEFAULT_SUBGRAPH_ENDPOINT, DEFAULT_SUBGRAPH_ENDPOINT_TESTNET, type DelegatedGaslessParams, type DelegatedSelfParams, type Fill, type FillFees, type OrderType as FillOrderType, type GetCandlesParams, type GetFillsByTimeParams, type GetFillsParams, type GetOpenPositionsParams, type GetOrdersParams, type GetPairsParams, type GetSimOrderbookParams, type GetSimSlippageParams, type GetUserParams, MAX_COLLATERAL_USD, MIN_COLLATERAL_USD, type MarginSummary, type ModifyOrderParams, type OpenOrder, type OpenPositionsResponse, type OpenTradeParams, type Order, type OrderAction, OrderType$1 as OrderType, OstiumClient, type OstiumClientConfig, OstiumError, OstiumErrorCode, OstiumPriceStream, OstiumSubgraphClient, type OstiumSubgraphClientConfig, OstiumSubgraphError, OstiumSubgraphErrorCode, PRECISION_18, PRECISION_6, type Pair, type PairPosition, type PairsResponse, type Position, type PriceData, type PriceTick, type SelfGaslessParams, type SelfSelfParams, type SimOrderbookLevel, type SimOrderbookResponse, type SimSlippageByPairId, type SimSlippageForPair, type SimSlippageRow, type SubmissionResult, type UpdateCollateralParams, parseLeverage, parsePrice, parseUsdc };
+export { type AllPricesResponse, type AllTraders, type AllowanceStatus, type Balances, type BuiltEoaTxRequest, type BuiltSafeTxCall, type BuiltSafeTxRequest, type BuiltTxRequest, type CancelLimitOrderParams, type CancelOrderParams, CancelOrderType, type CancelPendingCloseParams, type CancelPendingOpenParams, type Candle, type CandleResolution, type ClientMode, type CloseTradeParams, DEFAULT_BUILDER_API_URL, DEFAULT_SLIPPAGE_PERCENTAGE, DEFAULT_SUBGRAPH_ENDPOINT, DEFAULT_SUBGRAPH_ENDPOINT_TESTNET, type DelegatedGaslessBuildParams, type DelegatedGaslessParams, type DelegatedGaslessSubmitParams, type DelegatedSelfBuildParams, type DelegatedSelfParams, type DelegatedSelfSubmitParams, type Fill, type FillFees, type OrderType as FillOrderType, type GetCandlesParams, type GetFillsByTimeParams, type GetFillsParams, type GetOpenPositionsParams, type GetOrdersParams, type GetPairsParams, type GetSimOrderbookParams, type GetSimSlippageParams, type GetUserParams, MAX_COLLATERAL_USD, MIN_COLLATERAL_USD, type MarginSummary, type ModifyOrderParams, type OpenOrder, type OpenPositionsResponse, type OpenTradeParams, type Order, type OrderAction, OrderType$1 as OrderType, OstiumClient, type OstiumClientConfig, OstiumError, OstiumErrorCode, OstiumPositionUpdatesStream, OstiumPriceStream, OstiumSubgraphClient, type OstiumSubgraphClientConfig, OstiumSubgraphError, OstiumSubgraphErrorCode, PRECISION_18, PRECISION_6, type Pair, type PairPosition, type PairsResponse, type Position, type PriceData, type PriceTick, type SelfGaslessBuildParams, type SelfGaslessParams, type SelfGaslessSubmitParams, type SelfSelfBuildParams, type SelfSelfParams, type SelfSelfSubmitParams, type SimOrderbookLevel, type SimOrderbookResponse, type SimSlippageByPairId, type SimSlippageForPair, type SimSlippageRow, type SubmissionResult, type UpdateCollateralParams, parseLeverage, parsePrice, parseUsdc };