@0xmonaco/core 0.8.7 → 0.8.10

package/dist/api/base.d.ts

@@ -20,13 +20,18 @@
  * }
  * ```
  */
+import type { SessionCredentials } from "@0xmonaco/types";
+import { type SessionKeypair } from "../crypto/session";
 export interface RetryOptions {
     maxRetries?: number;
     baseDelayMs?: number;
 }
 export declare abstract class BaseAPI {
     protected readonly apiUrl: string;
-    protected accessToken?: string;
+    /** Active session keypair (raw bytes) used to sign authenticated requests. */
+    protected sessionKeypair?: SessionKeypair;
+    /** Application secret key (`sk_...`) sent in the `x-server-key` header for backend-authenticated requests. */
+    protected serverKey?: string;
     protected retryOptions: Required<RetryOptions>;
     /**
      * Creates a new BaseAPI instance.
@@ -36,17 +41,24 @@ export declare abstract class BaseAPI {
      */
     constructor(apiUrl: string, retryOptions?: RetryOptions);
     /**
-     * Set the access token for authenticated requests.
+     * Set (or clear) the session keypair used to sign authenticated requests.
      *
-     * @param token - JWT access token
+     * @param credentials - Hex-encoded session keypair, or `undefined` to clear.
      */
-    setAccessToken(token: string): void;
+    setSessionKeypair(credentials: SessionCredentials | undefined): void;
     /**
-     * Get the current access token.
+     * Set (or clear) the application secret key used for backend-authenticated
+     * requests.
      *
-     * @returns The current access token or undefined if not set
+     * Backend endpoints (those annotated `#[require_backend]` on the gateway)
+     * authenticate with a static application secret key rather than a session
+     * signature. When set, the raw key is sent verbatim in the `x-server-key`
+     * header on every {@link makeBackendRequest}. This is independent of the
+     * session keypair — a client may hold both.
+     *
+     * @param serverKey - The application secret key (`sk_...`), or `undefined` to clear.
      */
-    protected getAccessToken(): string | undefined;
+    setServerKey(serverKey: string | undefined): void;
     /**
      * Parse request body for error logging
      *
@@ -93,6 +105,35 @@ export declare abstract class BaseAPI {
      * ```
      */
     protected makeAuthenticatedRequest<T>(endpoint: string, options?: RequestInit): Promise<T>;
+    /**
+     * Compute the per-request ed25519 signature headers.
+     *
+     * The signed payload is `METHOD\nPATH_WITH_QUERY\nTIMESTAMP_MS\nSHA256_BODY_HEX`,
+     * matching the server (`handlers::auth::compose_signing_string`). `endpoint`
+     * is the path-with-query exactly as sent; the body hash covers the raw bytes
+     * so a request can't be replayed with a different body.
+     */
+    private buildSignatureHeaders;
+    /**
+     * Makes a backend-authenticated API request using the application secret key.
+     *
+     * Sends the raw `sk_...` key (set via {@link setServerKey}) in the
+     * `x-server-key` header. The gateway hashes and matches it against the
+     * application on every request — there is no signing and no token exchange.
+     * Use this for endpoints annotated `#[require_backend]`.
+     *
+     * @param endpoint - The API endpoint to call (should start with /)
+     * @param options - Request options (method, body, headers, etc.)
+     * @returns Promise resolving to the response data
+     * @throws {APIError} When the server key is not set or the API request fails
+     *
+     * @example
+     * ```typescript
+     * this.setServerKey("sk_live_...");
+     * const orders = await this.makeBackendRequest<ListAppOrdersResponse>('/api/v1/applications/orders');
+     * ```
+     */
+    protected makeBackendRequest<T>(endpoint: string, options?: RequestInit): Promise<T>;
     /**
      * Makes an unauthenticated API request.
      *

package/dist/api/base.js

@@ -20,11 +20,16 @@
  * }
  * ```
  */
+import { bytesToHex, utf8ToBytes } from "@noble/hashes/utils";
 import { StatusCodes } from "http-status-codes";
+import { composeSigningString, keypairFromHex, sha256Hex, signMessage } from "../crypto/session";
 import { APIError } from "../errors";
 export class BaseAPI {
     apiUrl;
-    accessToken;
+    /** Active session keypair (raw bytes) used to sign authenticated requests. */
+    sessionKeypair;
+    /** Application secret key (`sk_...`) sent in the `x-server-key` header for backend-authenticated requests. */
+    serverKey;
     retryOptions;
     /**
      * Creates a new BaseAPI instance.
@@ -40,20 +45,27 @@ export class BaseAPI {
         };
     }
     /**
-     * Set the access token for authenticated requests.
+     * Set (or clear) the session keypair used to sign authenticated requests.
      *
-     * @param token - JWT access token
+     * @param credentials - Hex-encoded session keypair, or `undefined` to clear.
      */
-    setAccessToken(token) {
-        this.accessToken = token;
+    setSessionKeypair(credentials) {
+        this.sessionKeypair = credentials ? keypairFromHex(credentials.publicKey, credentials.privateKey) : undefined;
     }
     /**
-     * Get the current access token.
+     * Set (or clear) the application secret key used for backend-authenticated
+     * requests.
      *
-     * @returns The current access token or undefined if not set
+     * Backend endpoints (those annotated `#[require_backend]` on the gateway)
+     * authenticate with a static application secret key rather than a session
+     * signature. When set, the raw key is sent verbatim in the `x-server-key`
+     * header on every {@link makeBackendRequest}. This is independent of the
+     * session keypair — a client may hold both.
+     *
+     * @param serverKey - The application secret key (`sk_...`), or `undefined` to clear.
      */
-    getAccessToken() {
-        return this.accessToken;
+    setServerKey(serverKey) {
+        this.serverKey = serverKey;
     }
     /**
      * Parse request body for error logging
@@ -175,6 +187,12 @@ export class BaseAPI {
                     retryAfter,
                 });
             }
+            // A successful response with an empty body (e.g. 204 No Content from a
+            // DELETE) is not an error — there is simply nothing to parse. Return
+            // `undefined` so void-returning methods resolve cleanly.
+            if (responseText.trim() === "") {
+                return undefined;
+            }
             // If response is OK but not JSON, throw a more specific error
             throw new APIError(`Expected JSON response but received ${contentType}`, {
                 endpoint: url,
@@ -229,8 +247,73 @@ export class BaseAPI {
      * ```
      */
     async makeAuthenticatedRequest(endpoint, options = {}) {
-        if (!this.accessToken) {
-            throw new APIError("Access token not set. Call setAccessToken() first.", {
+        if (!this.sessionKeypair) {
+            throw new APIError("Session keypair not set. Authenticate (login) first.", {
+                endpoint: `${this.apiUrl}${endpoint}`,
+                statusCode: StatusCodes.UNAUTHORIZED,
+            });
+        }
+        const url = `${this.apiUrl}${endpoint}`;
+        const requestBody = this.parseRequestBody(options.body);
+        const signatureHeaders = this.buildSignatureHeaders(endpoint, options);
+        return this.executeRequest(url, endpoint, {
+            ...options,
+            headers: {
+                "Content-Type": "application/json",
+                ...signatureHeaders,
+                ...options.headers,
+            },
+        }, requestBody);
+    }
+    /**
+     * Compute the per-request ed25519 signature headers.
+     *
+     * The signed payload is `METHOD\nPATH_WITH_QUERY\nTIMESTAMP_MS\nSHA256_BODY_HEX`,
+     * matching the server (`handlers::auth::compose_signing_string`). `endpoint`
+     * is the path-with-query exactly as sent; the body hash covers the raw bytes
+     * so a request can't be replayed with a different body.
+     */
+    buildSignatureHeaders(endpoint, options) {
+        if (!this.sessionKeypair) {
+            throw new APIError("Session keypair not set. Authenticate (login) first.", {
+                endpoint: `${this.apiUrl}${endpoint}`,
+                statusCode: StatusCodes.UNAUTHORIZED,
+            });
+        }
+        const method = (options.method ?? "GET").toUpperCase();
+        const timestampMs = Date.now();
+        const bodyBytes = typeof options.body === "string" ? utf8ToBytes(options.body) : new Uint8Array(0);
+        const bodyHash = sha256Hex(bodyBytes);
+        const signingString = composeSigningString(method, endpoint, timestampMs, bodyHash);
+        const signature = signMessage(this.sessionKeypair.privateKey, signingString);
+        return {
+            "X-Monaco-PublicKey": bytesToHex(this.sessionKeypair.publicKey),
+            "X-Monaco-Timestamp": String(timestampMs),
+            "X-Monaco-Signature": signature,
+        };
+    }
+    /**
+     * Makes a backend-authenticated API request using the application secret key.
+     *
+     * Sends the raw `sk_...` key (set via {@link setServerKey}) in the
+     * `x-server-key` header. The gateway hashes and matches it against the
+     * application on every request — there is no signing and no token exchange.
+     * Use this for endpoints annotated `#[require_backend]`.
+     *
+     * @param endpoint - The API endpoint to call (should start with /)
+     * @param options - Request options (method, body, headers, etc.)
+     * @returns Promise resolving to the response data
+     * @throws {APIError} When the server key is not set or the API request fails
+     *
+     * @example
+     * ```typescript
+     * this.setServerKey("sk_live_...");
+     * const orders = await this.makeBackendRequest<ListAppOrdersResponse>('/api/v1/applications/orders');
+     * ```
+     */
+    async makeBackendRequest(endpoint, options = {}) {
+        if (!this.serverKey) {
+            throw new APIError("Server key not set. Call setServerKey(sk_...) first.", {
                 endpoint: `${this.apiUrl}${endpoint}`,
                 statusCode: StatusCodes.UNAUTHORIZED,
             });
@@ -241,7 +324,7 @@ export class BaseAPI {
             ...options,
             headers: {
                 "Content-Type": "application/json",
-                Authorization: `Bearer ${this.accessToken}`,
+                "x-server-key": this.serverKey,
                 ...options.headers,
             },
         }, requestBody);

package/dist/api/delegated-agents/api.d.ts

@@ -1,8 +1,9 @@
-import type { CreateDelegatedSessionRequest, CreateDelegatedSessionResponse, DelegatedAgent, DelegatedAgentsAPI, ListDelegatedAgentsResponse, UpsertDelegatedAgentRequest } from "@0xmonaco/types";
+import type { CreateDelegatedSessionRequest, CreateDelegatedSessionResponse, DelegatedAgent, DelegatedAgentsAPI, ListDelegatedAgentsResponse, ListDelegatedOwnersResponse, UpsertDelegatedAgentRequest } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 export declare class DelegatedAgentsAPIImpl extends BaseAPI implements DelegatedAgentsAPI {
     upsertDelegatedAgent(request: UpsertDelegatedAgentRequest): Promise<DelegatedAgent>;
     listDelegatedAgents(): Promise<ListDelegatedAgentsResponse>;
+    listDelegatedOwners(): Promise<ListDelegatedOwnersResponse>;
     revokeDelegatedAgent(delegatedAgentId: string): Promise<{
         status: "REVOKED";
     }>;

package/dist/api/delegated-agents/api.js

@@ -22,6 +22,9 @@ export class DelegatedAgentsAPIImpl extends BaseAPI {
     async listDelegatedAgents() {
         return this.makeAuthenticatedRequest(perpRoutes.delegatedAgents.list());
     }
+    async listDelegatedOwners() {
+        return this.makeAuthenticatedRequest(perpRoutes.delegatedAgents.owners());
+    }
     async revokeDelegatedAgent(delegatedAgentId) {
         return this.makeAuthenticatedRequest(perpRoutes.delegatedAgents.byId(delegatedAgentId), {
             method: "DELETE",
@@ -32,6 +35,7 @@ export class DelegatedAgentsAPIImpl extends BaseAPI {
             method: "POST",
             body: JSON.stringify({
                 owner_user_id: request.ownerUserId,
+                session_public_key: request.sessionPublicKey,
             }),
         });
     }

package/dist/api/faucet/api.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Faucet API Implementation
+ *
+ * Testnet token faucet. Session-authenticated. Performs real on-chain mints
+ * from a backend-operator-funded signer and is rate-limited per user
+ * (default 1 request / 24h). It is unavailable if the gateway operator has not
+ * configured a signer — the SDK caller has no control over that.
+ *
+ * @example
+ * ```typescript
+ * const { minted, failed, remaining_requests_24h } = await sdk.faucet.mint();
+ * ```
+ */
+import type { FaucetAPI, MintTokensResponse } from "@0xmonaco/types";
+import { BaseAPI } from "../base";
+export declare class FaucetAPIImpl extends BaseAPI implements FaucetAPI {
+    /**
+     * Mints the full set of testnet tokens to the authenticated user.
+     *
+     * Partial success is possible — inspect `minted` and `failed` in the response.
+     *
+     * @returns Promise resolving to the minted/failed tokens and remaining quota
+     */
+    mint(): Promise<MintTokensResponse>;
+}

package/dist/api/faucet/api.js

@@ -0,0 +1,29 @@
+/**
+ * Faucet API Implementation
+ *
+ * Testnet token faucet. Session-authenticated. Performs real on-chain mints
+ * from a backend-operator-funded signer and is rate-limited per user
+ * (default 1 request / 24h). It is unavailable if the gateway operator has not
+ * configured a signer — the SDK caller has no control over that.
+ *
+ * @example
+ * ```typescript
+ * const { minted, failed, remaining_requests_24h } = await sdk.faucet.mint();
+ * ```
+ */
+import { BaseAPI } from "../base";
+import { perpRoutes } from "../perp/routes";
+export class FaucetAPIImpl extends BaseAPI {
+    /**
+     * Mints the full set of testnet tokens to the authenticated user.
+     *
+     * Partial success is possible — inspect `minted` and `failed` in the response.
+     *
+     * @returns Promise resolving to the minted/failed tokens and remaining quota
+     */
+    async mint() {
+        return await this.makeAuthenticatedRequest(perpRoutes.faucet.mint(), {
+            method: "POST",
+        });
+    }
+}

package/dist/api/faucet/index.d.ts

@@ -0,0 +1 @@
+export { FaucetAPIImpl } from "./api";

package/dist/api/faucet/index.js

@@ -0,0 +1 @@
+export { FaucetAPIImpl } from "./api";

package/dist/api/index.d.ts

@@ -6,6 +6,7 @@
 export * from "./applications/index";
 export * from "./base";
 export * from "./delegated-agents";
+export * from "./faucet";
 export * from "./fees";
 export * from "./margin-accounts";
 export * from "./market";
@@ -13,7 +14,10 @@ export * from "./orderbook";
 export * from "./perp";
 export * from "./positions";
 export * from "./profile";
+export * from "./sub-accounts";
 export * from "./trades";
 export * from "./trading";
 export * from "./vault";
 export * from "./websocket";
+export * from "./whitelist";
+export * from "./withdrawals";

package/dist/api/index.js

@@ -6,6 +6,7 @@
 export * from "./applications/index";
 export * from "./base";
 export * from "./delegated-agents";
+export * from "./faucet";
 export * from "./fees";
 export * from "./margin-accounts";
 export * from "./market";
@@ -13,7 +14,10 @@ export * from "./orderbook";
 export * from "./perp";
 export * from "./positions";
 export * from "./profile";
+export * from "./sub-accounts";
 export * from "./trades";
 export * from "./trading";
 export * from "./vault";
 export * from "./websocket";
+export * from "./whitelist";
+export * from "./withdrawals";

package/dist/api/margin-accounts/api.d.ts

@@ -1,14 +1,13 @@
-import type { CreateMarginAccountRequest, CreateMarginAccountResponse, GetAvailableCollateralParams, GetAvailableCollateralResponse, GetMarginAccountMovementsParams, GetMarginAccountMovementsResponse, ListMarginAccountsParams, ListMarginAccountsResponse, MarginAccountSummary, MarginAccountsAPI, SimulateOrderRiskRequest, SimulateOrderRiskResponse, TransferCollateralRequest, TransferCollateralResponse, TransferCollateralToAutoMarginAccountRequest } from "@0xmonaco/types";
+import type { GetAvailableCollateralParams, GetAvailableCollateralResponse, GetMarginAccountMovementsParams, GetMarginAccountMovementsResponse, GetMarginAccountSummaryParams, ListMarginAccountsParams, ListMarginAccountsResponse, MarginAccountSummary, MarginAccountsAPI, SimulateAutoMarginOrderRiskRequest, SimulateOrderRiskRequest, SimulateOrderRiskResponse, TransferCollateralRequest, TransferCollateralResponse, TransferCollateralToAutoMarginAccountRequest } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 export declare class MarginAccountsAPIImpl extends BaseAPI implements MarginAccountsAPI {
     listMarginAccounts(params?: ListMarginAccountsParams): Promise<ListMarginAccountsResponse>;
-    createMarginAccount(request?: CreateMarginAccountRequest): Promise<CreateMarginAccountResponse>;
-    getMarginAccountSummary(marginAccountId: string): Promise<MarginAccountSummary>;
+    getMarginAccountSummary(marginAccountId: string, params?: GetMarginAccountSummaryParams): Promise<MarginAccountSummary>;
     getAvailableCollateral(params?: GetAvailableCollateralParams): Promise<GetAvailableCollateralResponse>;
     transferCollateralToMarginAccount(marginAccountId: string, request: TransferCollateralRequest): Promise<TransferCollateralResponse>;
     transferCollateralToAutoMarginAccount(request: TransferCollateralToAutoMarginAccountRequest): Promise<TransferCollateralResponse>;
     transferCollateralFromMarginAccount(marginAccountId: string, request: TransferCollateralRequest): Promise<TransferCollateralResponse>;
     getMarginAccountMovements(marginAccountId: string, params?: GetMarginAccountMovementsParams): Promise<GetMarginAccountMovementsResponse>;
     simulateOrderRisk(marginAccountId: string, request: SimulateOrderRiskRequest): Promise<SimulateOrderRiskResponse>;
-    simulateAutoMarginOrderRisk(request: SimulateOrderRiskRequest): Promise<SimulateOrderRiskResponse>;
+    simulateAutoMarginOrderRisk(request: SimulateAutoMarginOrderRiskRequest): Promise<SimulateOrderRiskResponse>;
 }

package/dist/api/margin-accounts/api.js

@@ -1,4 +1,4 @@
-import { CreateMarginAccountSchema, GetAvailableCollateralSchema, GetMarginAccountMovementsSchema, GetMarginAccountSummarySchema, ListMarginAccountsSchema, SimulateAutoMarginOrderRiskSchema, SimulateOrderRiskSchema, TransferCollateralSchema, TransferCollateralToAutoMarginAccountSchema, validate, } from "@0xmonaco/types";
+import { GetAvailableCollateralSchema, GetMarginAccountMovementsSchema, GetMarginAccountSummarySchema, ListMarginAccountsSchema, SimulateAutoMarginOrderRiskSchema, SimulateOrderRiskSchema, TransferCollateralSchema, TransferCollateralToAutoMarginAccountSchema, validate, } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 import { perpRoutes } from "../perp";
 export class MarginAccountsAPIImpl extends BaseAPI {
@@ -15,19 +15,9 @@ export class MarginAccountsAPIImpl extends BaseAPI {
             }
             : undefined));
     }
-    async createMarginAccount(request) {
-        validate(CreateMarginAccountSchema, request);
-        return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.create(), {
-            method: "POST",
-            body: JSON.stringify({
-                label: request?.label,
-                collateral_asset: request?.collateralAsset,
-            }),
-        });
-    }
-    async getMarginAccountSummary(marginAccountId) {
-        validate(GetMarginAccountSummarySchema, { marginAccountId });
-        return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.summary(marginAccountId));
+    async getMarginAccountSummary(marginAccountId, params) {
+        validate(GetMarginAccountSummarySchema, { marginAccountId, ...params });
+        return await this.makeAuthenticatedRequest(perpRoutes.marginAccounts.summary(marginAccountId, { trading_pair_id: params?.tradingPairId }));
     }
     async getAvailableCollateral(params) {
         validate(GetAvailableCollateralSchema, params);
@@ -40,6 +30,8 @@ export class MarginAccountsAPIImpl extends BaseAPI {
             body: JSON.stringify({
                 asset: request.asset,
                 amount: request.amount,
+                trading_pair_id: request.tradingPairId,
+                strategy_key: request.strategyKey,
             }),
         });
     }
@@ -62,6 +54,8 @@ export class MarginAccountsAPIImpl extends BaseAPI {
             body: JSON.stringify({
                 asset: request.asset,
                 amount: request.amount,
+                trading_pair_id: request.tradingPairId,
+                strategy_key: request.strategyKey,
             }),
         });
     }
@@ -75,7 +69,6 @@ export class MarginAccountsAPIImpl extends BaseAPI {
             method: "POST",
             body: JSON.stringify({
                 trading_pair_id: request.tradingPairId,
-                strategy_key: request.strategyKey,
                 side: request.side,
                 position_side: request.positionSide,
                 order_type: request.orderType,

package/dist/api/market/api.d.ts

@@ -1,4 +1,4 @@
-import type { Candlestick, FundingState, GetCandlesticksParams, GetTradingPairsParams, GetTradingPairsResponse, IndexPrice, Interval, ListFundingHistoryParams, ListFundingHistoryResponse, MarketAPI, MarketMetadata, MarkPrice, OpenInterest, PerpMarketConfig, PerpMarketSummary, TradingPair } from "@0xmonaco/types";
+import type { Candlestick, FundingState, GetCandlesticksParams, GetScreenerParams, GetScreenerResponse, GetTradingPairsParams, GetTradingPairsResponse, IndexPrice, Interval, ListFundingHistoryParams, ListFundingHistoryResponse, MarketAPI, MarketMetadata, MarkPrice, OpenInterest, PerpMarketConfig, PerpMarketSummary, TradingPair } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 /**
  * Market API Implementation
@@ -7,6 +7,7 @@ import { BaseAPI } from "../base";
  */
 export declare class MarketAPIImpl extends BaseAPI implements MarketAPI {
     getPaginatedTradingPairs(params?: GetTradingPairsParams): Promise<GetTradingPairsResponse>;
+    getTradingPair(tradingPairId: string): Promise<TradingPair>;
     getTradingPairBySymbol(symbol: string): Promise<TradingPair | undefined>;
     getCandlesticks(tradingPairId: string, interval: Interval, params?: GetCandlesticksParams): Promise<Candlestick[]>;
     getMarketMetadata(tradingPairId: string): Promise<MarketMetadata>;
@@ -17,4 +18,5 @@ export declare class MarketAPIImpl extends BaseAPI implements MarketAPI {
     getFundingState(tradingPairId: string): Promise<FundingState>;
     listFundingHistory(tradingPairId: string, params?: ListFundingHistoryParams): Promise<ListFundingHistoryResponse>;
     getOpenInterest(tradingPairId: string): Promise<OpenInterest>;
+    getScreener(params?: GetScreenerParams): Promise<GetScreenerResponse>;
 }

package/dist/api/market/api.js

@@ -31,6 +31,11 @@ export class MarketAPIImpl extends BaseAPI {
         const url = queryString ? `/api/v1/market/pairs?${queryString}` : "/api/v1/market/pairs";
         return await this.makePublicRequest(url);
     }
+    async getTradingPair(tradingPairId) {
+        validate(GetMarketMetadataSchema, { tradingPairId });
+        const response = await this.makePublicRequest(perpRoutes.market.getTradingPair(tradingPairId));
+        return response.trading_pair;
+    }
     async getTradingPairBySymbol(symbol) {
         // Backend endpoint expects UUID, not symbol, so we fetch all pairs and filter
         const response = await this.getPaginatedTradingPairs({ page_size: 100 });
@@ -94,4 +99,7 @@ export class MarketAPIImpl extends BaseAPI {
         validate(GetMarketMetadataSchema, { tradingPairId });
         return await this.makePublicRequest(perpRoutes.market.getOpenInterest(tradingPairId));
     }
+    async getScreener(params) {
+        return await this.makePublicRequest(perpRoutes.market.getScreener(params));
+    }
 }

package/dist/api/orderbook/api.js

@@ -12,7 +12,8 @@ export class OrderbookAPIImpl extends BaseAPI {
             params.set("denomination", denomination.toLowerCase());
         const response = await this.makePublicRequest(`/api/v1/orderbook/${encodeURIComponent(tradingPairId)}?${params.toString()}`);
         return {
-            tradingPairId: response.symbol,
+            // `trading_pair_id` is the pair UUID; `symbol` is the display string.
+            tradingPairId: response.trading_pair_id,
             tradingMode: response.trading_mode,
             bids: response.data.bids.map((level) => ({
                 price: level.price,

package/dist/api/perp/routes.d.ts

@@ -17,7 +17,6 @@ export declare const perpRoutes: {
         readonly batchCancelAllByPair: (tradingPairId: string) => string;
         readonly batchCreate: () => string;
         readonly batchReplace: () => string;
-        readonly createConditional: () => string;
         readonly listConditional: (params?: {
             margin_account_id?: string;
             trading_pair_id?: string;
@@ -29,9 +28,14 @@ export declare const perpRoutes: {
     };
     readonly delegatedAgents: {
         readonly list: () => string;
+        readonly owners: () => string;
         readonly byId: (delegatedAgentId: string) => string;
         readonly sessions: () => string;
     };
+    readonly withdrawals: {
+        readonly initiate: () => string;
+        readonly byIndex: (withdrawalIndex: number) => string;
+    };
     readonly market: {
         readonly listTradingPairs: (params?: {
             page?: number;
@@ -60,6 +64,12 @@ export declare const perpRoutes: {
             page_size?: number;
         }) => string;
         readonly getOpenInterest: (tradingPairId: string) => string;
+        readonly getScreener: (params?: {
+            page?: number;
+            page_size?: number;
+            market_type?: string;
+            is_active?: boolean;
+        }) => string;
     };
     readonly orderbook: {
         readonly get: (tradingPairId: string, params?: {
@@ -74,6 +84,7 @@ export declare const perpRoutes: {
             skip?: number;
             limit?: number;
         }) => string;
+        readonly byId: (tradeId: string) => string;
         readonly user: (params?: {
             margin_account_id?: string;
             trading_pair_id?: string;
@@ -81,6 +92,53 @@ export declare const perpRoutes: {
             page_size?: number;
         }) => string;
     };
+    readonly applications: {
+        readonly orders: (params?: {
+            page?: number;
+            page_size?: number;
+            status?: string;
+            user_id?: string;
+            trading_pair_id?: string;
+            side?: string;
+            order_type?: string;
+        }) => string;
+        readonly users: (params?: {
+            page?: number;
+            page_size?: number;
+            is_active?: boolean;
+            account_type?: string;
+            address?: string;
+        }) => string;
+        readonly movements: (params?: {
+            page?: number;
+            page_size?: number;
+            user_id?: string;
+            transaction_type?: string;
+            entry_type?: string;
+            asset_id?: string;
+        }) => string;
+        readonly balances: (params?: {
+            page?: number;
+            page_size?: number;
+            user_id?: string;
+            asset_id?: string;
+        }) => string;
+        readonly stats: (params?: {
+            since?: string;
+        }) => string;
+    };
+    readonly subAccounts: {
+        readonly list: () => string;
+        readonly createLimit: () => string;
+        readonly getLimits: (subAccountId: string) => string;
+        readonly limit: (subAccountId: string, assetId: string) => string;
+    };
+    readonly faucet: {
+        readonly mint: () => string;
+    };
+    readonly whitelist: {
+        readonly submit: () => string;
+    };
     readonly positions: {
         readonly list: (params?: {
             margin_account_id?: string;
@@ -110,8 +168,9 @@ export declare const perpRoutes: {
             state?: string;
             trading_pair_id?: string;
         }) => string;
-        readonly create: () => string;
-        readonly summary: (marginAccountId: string) => string;
+        readonly summary: (marginAccountId: string, params?: {
+            trading_pair_id?: string;
+        }) => string;
         readonly availableCollateral: (params?: {
             asset?: string;
         }) => string;
@@ -134,7 +193,6 @@ export declare const perpRoutes: {
         readonly privateTrades: () => string;
         readonly orders: () => string;
         readonly positions: () => string;
-        readonly marginAccount: () => string;
         readonly funding: () => string;
         readonly liquidationAlerts: () => string;
     };