@0xmonaco/core 0.8.7-develop.0e951a5 → 0.8.7-develop.0f12336

package/README.md

@@ -62,26 +62,17 @@ npm install viem@^2.31.7
 
 ## Network Support
 
-The SDK supports the following preset networks. Configure the network by providing the `network` and `seiRpcUrl` parameters:
+The SDK supports the following documented preset networks. Configure the network by providing the `network` and `seiRpcUrl` parameters:
 
 **Preset Networks:**
-- `"development"` - Development environment (https://develop.apimonaco.xyz)
 - `"staging"` - Staging environment (https://staging.apimonaco.xyz)
 - `"mainnet"` - Production environment (https://api.monaco.xyz)
-- `"local"` - Local development (http://localhost:8080)
 
 WebSocket URLs are automatically resolved per network.
 
 ```typescript
 import { MonacoSDK } from "@0xmonaco/core";
 
-// Development configuration
-const devSdk = new MonacoSDK({
-  walletClient,
-  network: "development",
-  seiRpcUrl: "https://evm-rpc-testnet.sei-apis.com",
-});
-
 // Staging configuration
 const stagingSdk = new MonacoSDK({
   walletClient,
@@ -114,7 +105,7 @@ const walletClient = createWalletClient({
 
 const monaco = new MonacoSDK({
   walletClient,
-  network: "development", // or "staging", "mainnet", "local"
+  network: "staging", // or "mainnet"
   seiRpcUrl: "https://evm-rpc-testnet.sei-apis.com", // or https://evm-rpc.sei-apis.com for mainnet
 });
 
@@ -251,7 +242,7 @@ interface SDKConfig {
   /** Wallet client for signing operations (optional - can be set later via setWalletClient) */
   walletClient?: WalletClient;
   
-  /** Network preset: "local", "development", "staging", or "mainnet" */
+  /** Use "staging" for public testnet or "mainnet" for production. */
   network: Network;
   
   /** RPC URL for Sei blockchain interactions */

package/dist/api/applications/api.d.ts

@@ -1,23 +1,25 @@
 /**
  * Applications API Implementation
  *
- * Handles application configuration operations. All operations go through
- * the API Gateway and require valid authentication.
- *
- * This class provides an interface for retrieving application configuration
- * on the Monaco protocol.
+ * Handles application configuration and reporting operations. This is a
+ * mixed-auth domain: `getApplicationConfig` is session-authenticated, while
+ * the reporting methods are backend-authenticated via the application secret
+ * key (set with {@link BaseAPI.setServerKey}, sent as `x-server-key`).
  *
  * @example
  * ```typescript
  * const applicationsAPI = new ApplicationsAPIImpl(apiUrl);
  *
- * // Get application configuration
+ * // Get application configuration (session auth)
  * const config = await applicationsAPI.getApplicationConfig();
  * console.log(`App name: ${config.name}`);
- * console.log(`Allowed origins: ${config.allowedOrigins.join(', ')}`);
+ *
+ * // Reporting endpoints (backend auth)
+ * applicationsAPI.setServerKey("sk_live_...");
+ * const orders = await applicationsAPI.listApplicationOrders({ status: "FILLED" });
  * ```
  */
-import type { ApplicationConfigResponse, ApplicationsAPI } from "@0xmonaco/types";
+import type { ApplicationConfigResponse, ApplicationsAPI, GetAppStatsParams, GetAppStatsResponse, ListAppBalancesParams, ListAppBalancesResponse, ListAppMovementsParams, ListAppMovementsResponse, ListAppOrdersParams, ListAppOrdersResponse, ListAppUsersParams, ListAppUsersResponse } from "@0xmonaco/types";
 import { BaseAPI } from "../base";
 export declare class ApplicationsAPIImpl extends BaseAPI implements ApplicationsAPI {
     /**
@@ -40,4 +42,55 @@ export declare class ApplicationsAPIImpl extends BaseAPI implements Applications
      * ```
      */
     getApplicationConfig(): Promise<ApplicationConfigResponse>;
+    /**
+     * Lists orders placed by the application's users.
+     *
+     * Backend-authenticated — call {@link BaseAPI.setServerKey} first.
+     *
+     * @param params - Pagination and filter options
+     * @returns Promise resolving to a paginated list of orders
+     * @throws {APIError} When the server key is unset or the request fails
+     */
+    listApplicationOrders(params?: ListAppOrdersParams): Promise<ListAppOrdersResponse>;
+    /**
+     * Lists the application's users.
+     *
+     * Backend-authenticated — call {@link BaseAPI.setServerKey} first.
+     *
+     * @param params - Pagination and filter options
+     * @returns Promise resolving to a paginated list of users
+     * @throws {APIError} When the server key is unset or the request fails
+     */
+    listApplicationUsers(params?: ListAppUsersParams): Promise<ListAppUsersResponse>;
+    /**
+     * Lists ledger movements for the application's users.
+     *
+     * Backend-authenticated — call {@link BaseAPI.setServerKey} first.
+     *
+     * @param params - Pagination and filter options
+     * @returns Promise resolving to a paginated list of movements
+     * @throws {APIError} When the server key is unset or the request fails
+     */
+    listApplicationMovements(params?: ListAppMovementsParams): Promise<ListAppMovementsResponse>;
+    /**
+     * Lists user balances held within the application.
+     *
+     * Backend-authenticated — call {@link BaseAPI.setServerKey} first.
+     *
+     * @param params - Pagination and filter options
+     * @returns Promise resolving to a paginated list of balances
+     * @throws {APIError} When the server key is unset or the request fails
+     */
+    listApplicationBalances(params?: ListAppBalancesParams): Promise<ListAppBalancesResponse>;
+    /**
+     * Gets aggregate volume and fee stats for the application.
+     *
+     * Stats are scoped to trades where the application's users were the taker.
+     * Backend-authenticated — call {@link BaseAPI.setServerKey} first.
+     *
+     * @param params - Optional `since` filter
+     * @returns Promise resolving to the application stats
+     * @throws {APIError} When the server key is unset or the request fails
+     */
+    getApplicationStats(params?: GetAppStatsParams): Promise<GetAppStatsResponse>;
 }

package/dist/api/applications/api.js

@@ -1,23 +1,26 @@
 /**
  * Applications API Implementation
  *
- * Handles application configuration operations. All operations go through
- * the API Gateway and require valid authentication.
- *
- * This class provides an interface for retrieving application configuration
- * on the Monaco protocol.
+ * Handles application configuration and reporting operations. This is a
+ * mixed-auth domain: `getApplicationConfig` is session-authenticated, while
+ * the reporting methods are backend-authenticated via the application secret
+ * key (set with {@link BaseAPI.setServerKey}, sent as `x-server-key`).
  *
  * @example
  * ```typescript
  * const applicationsAPI = new ApplicationsAPIImpl(apiUrl);
  *
- * // Get application configuration
+ * // Get application configuration (session auth)
  * const config = await applicationsAPI.getApplicationConfig();
  * console.log(`App name: ${config.name}`);
- * console.log(`Allowed origins: ${config.allowedOrigins.join(', ')}`);
+ *
+ * // Reporting endpoints (backend auth)
+ * applicationsAPI.setServerKey("sk_live_...");
+ * const orders = await applicationsAPI.listApplicationOrders({ status: "FILLED" });
  * ```
  */
 import { BaseAPI } from "../base";
+import { perpRoutes } from "../perp/routes";
 export class ApplicationsAPIImpl extends BaseAPI {
     /**
      * Gets the configuration for the authenticated application.
@@ -45,10 +48,71 @@ export class ApplicationsAPIImpl extends BaseAPI {
         return {
             id: data.id,
             name: data.name,
-            allowedOrigins: data.allowed_origins,
-            webhookUrl: data.webhook_url,
-            vaultContractAddress: data.vault_contract_address,
-            clientId: data.client_id,
+            allowedOrigins: data.allowedOrigins,
+            webhookUrl: data.webhookUrl,
+            vaultContractAddress: data.vaultContractAddress,
+            clientId: data.clientId,
         };
     }
+    /**
+     * Lists orders placed by the application's users.
+     *
+     * Backend-authenticated — call {@link BaseAPI.setServerKey} first.
+     *
+     * @param params - Pagination and filter options
+     * @returns Promise resolving to a paginated list of orders
+     * @throws {APIError} When the server key is unset or the request fails
+     */
+    async listApplicationOrders(params) {
+        return await this.makeBackendRequest(perpRoutes.applications.orders(params));
+    }
+    /**
+     * Lists the application's users.
+     *
+     * Backend-authenticated — call {@link BaseAPI.setServerKey} first.
+     *
+     * @param params - Pagination and filter options
+     * @returns Promise resolving to a paginated list of users
+     * @throws {APIError} When the server key is unset or the request fails
+     */
+    async listApplicationUsers(params) {
+        return await this.makeBackendRequest(perpRoutes.applications.users(params));
+    }
+    /**
+     * Lists ledger movements for the application's users.
+     *
+     * Backend-authenticated — call {@link BaseAPI.setServerKey} first.
+     *
+     * @param params - Pagination and filter options
+     * @returns Promise resolving to a paginated list of movements
+     * @throws {APIError} When the server key is unset or the request fails
+     */
+    async listApplicationMovements(params) {
+        return await this.makeBackendRequest(perpRoutes.applications.movements(params));
+    }
+    /**
+     * Lists user balances held within the application.
+     *
+     * Backend-authenticated — call {@link BaseAPI.setServerKey} first.
+     *
+     * @param params - Pagination and filter options
+     * @returns Promise resolving to a paginated list of balances
+     * @throws {APIError} When the server key is unset or the request fails
+     */
+    async listApplicationBalances(params) {
+        return await this.makeBackendRequest(perpRoutes.applications.balances(params));
+    }
+    /**
+     * Gets aggregate volume and fee stats for the application.
+     *
+     * Stats are scoped to trades where the application's users were the taker.
+     * Backend-authenticated — call {@link BaseAPI.setServerKey} first.
+     *
+     * @param params - Optional `since` filter
+     * @returns Promise resolving to the application stats
+     * @throws {APIError} When the server key is unset or the request fails
+     */
+    async getApplicationStats(params) {
+        return await this.makeBackendRequest(perpRoutes.applications.stats(params));
+    }
 }

package/dist/api/auth/api.d.ts

@@ -1,11 +1,13 @@
 /**
  * Auth API Implementation
  *
- * Handles authentication operations including challenge creation, signature verification,
- * and backend authentication. All operations go through the API Gateway.
+ * Handles wallet authentication operations including challenge creation, signature
+ * verification, and session lifecycle. All operations go through the API Gateway.
  *
- * This class provides a complete interface for authentication on the Monaco protocol,
- * including frontend wallet authentication and backend service authentication.
+ * This class provides a complete interface for wallet-based authentication on the
+ * Monaco protocol. Backend services authenticate separately by setting their
+ * application secret key (`sk_...`) via {@link BaseAPI.setServerKey}, which is sent
+ * in the `x-server-key` header on backend requests — there is no token exchange.
  *
  * @example
  * ```typescript
@@ -23,12 +25,9 @@
  *   challenge.nonce,
  *   clientId
  * );
- *
- * // Authenticate backend service
- * const backendAuth = await authAPI.authenticateBackend(secretKey);
  * ```
  */
-import type { AuthAPI, AuthState, BackendAuthResponse, ChallengeResponse, SessionCredentials, SessionRefreshResponse } from "@0xmonaco/types";
+import type { AuthAPI, AuthState, ChallengeResponse, SessionCredentials, SessionRefreshResponse } from "@0xmonaco/types";
 import type { Chain, WalletClient } from "viem";
 import { BaseAPI } from "../base";
 export declare class AuthAPIImpl extends BaseAPI implements AuthAPI {
@@ -139,29 +138,11 @@ export declare class AuthAPIImpl extends BaseAPI implements AuthAPI {
      * ```
      */
     verifySignature(address: string, signature: string, nonce: string, clientId: string, session: SessionCredentials): Promise<AuthState>;
-    /**
-     * Authenticates a backend service using a secret key.
-     *
-     * Returns JWT tokens for API access. This method is used for backend services
-     * that need to authenticate with the Monaco API Gateway.
-     *
-     * @param secretKey - Secret key of the application
-     * @returns Promise resolving to the backend auth response with JWT tokens
-     * @throws {APIError} When backend authentication fails
-     *
-     * @example
-     * ```typescript
-     * const backendAuth = await authAPI.authenticateBackend("my-secret-key");
-     * console.log(`Backend access token: ${backendAuth.accessToken}`);
-     * console.log(`Application: ${backendAuth.application.name}`);
-     * ```
-     */
-    authenticateBackend(secretKey: string): Promise<BackendAuthResponse>;
     /**
      * Extends the current session's expiry.
      *
      * The request is signed with the active session key (set via
-     * {@link setSessionKeypair}); the server bumps the session's `expires_at`.
+     * {@link setSessionKeypair}); the server bumps the session's `expiresAt`.
      * No new credential is issued — the same keypair keeps working.
      *
      * @returns Promise resolving to the new expiry

package/dist/api/auth/api.js

@@ -1,11 +1,13 @@
 /**
  * Auth API Implementation
  *
- * Handles authentication operations including challenge creation, signature verification,
- * and backend authentication. All operations go through the API Gateway.
+ * Handles wallet authentication operations including challenge creation, signature
+ * verification, and session lifecycle. All operations go through the API Gateway.
  *
- * This class provides a complete interface for authentication on the Monaco protocol,
- * including frontend wallet authentication and backend service authentication.
+ * This class provides a complete interface for wallet-based authentication on the
+ * Monaco protocol. Backend services authenticate separately by setting their
+ * application secret key (`sk_...`) via {@link BaseAPI.setServerKey}, which is sent
+ * in the `x-server-key` header on backend requests — there is no token exchange.
  *
  * @example
  * ```typescript
@@ -23,9 +25,6 @@
  *   challenge.nonce,
  *   clientId
  * );
- *
- * // Authenticate backend service
- * const backendAuth = await authAPI.authenticateBackend(secretKey);
  * ```
  */
 import { generateSessionKeypair, privateKeyHex, publicKeyHex } from "../../crypto/session";
@@ -158,15 +157,15 @@ export class AuthAPIImpl extends BaseAPI {
             method: "POST",
             body: JSON.stringify({
                 address,
-                client_id: clientId,
-                chain_id: this.chain.id,
-                session_public_key: sessionPublicKey,
+                clientId: clientId,
+                chainId: this.chain.id,
+                sessionPublicKey: sessionPublicKey,
             }),
         });
         return {
             nonce: responseBody.nonce,
             message: responseBody.message,
-            expiresAt: responseBody.expires_at,
+            expiresAt: responseBody.expiresAt,
         };
     }
     /**
@@ -200,15 +199,15 @@ export class AuthAPIImpl extends BaseAPI {
                 address,
                 signature,
                 nonce,
-                client_id: clientId,
-                chain_id: this.chain.id,
-                session_public_key: session.publicKey,
+                clientId: clientId,
+                chainId: this.chain.id,
+                sessionPublicKey: session.publicKey,
             }),
         });
         return {
             sessionPublicKey: session.publicKey,
             sessionPrivateKey: session.privateKey,
-            expiresAt: responseBody.expires_at,
+            expiresAt: responseBody.expiresAt,
             user: {
                 id: responseBody.user.id,
                 address: responseBody.user.address,
@@ -216,46 +215,11 @@ export class AuthAPIImpl extends BaseAPI {
             },
         };
     }
-    /**
-     * Authenticates a backend service using a secret key.
-     *
-     * Returns JWT tokens for API access. This method is used for backend services
-     * that need to authenticate with the Monaco API Gateway.
-     *
-     * @param secretKey - Secret key of the application
-     * @returns Promise resolving to the backend auth response with JWT tokens
-     * @throws {APIError} When backend authentication fails
-     *
-     * @example
-     * ```typescript
-     * const backendAuth = await authAPI.authenticateBackend("my-secret-key");
-     * console.log(`Backend access token: ${backendAuth.accessToken}`);
-     * console.log(`Application: ${backendAuth.application.name}`);
-     * ```
-     */
-    async authenticateBackend(secretKey) {
-        const responseBody = await this.makePublicRequest("/api/v1/auth/backend", {
-            method: "POST",
-            body: JSON.stringify({
-                secret_key: secretKey,
-                chain_id: this.chain.id,
-            }),
-        });
-        return {
-            accessToken: responseBody.access_token,
-            expiresAt: responseBody.expires_at,
-            application: {
-                id: responseBody.application.id,
-                name: responseBody.application.name,
-                clientId: responseBody.application.client_id,
-            },
-        };
-    }
     /**
      * Extends the current session's expiry.
      *
      * The request is signed with the active session key (set via
-     * {@link setSessionKeypair}); the server bumps the session's `expires_at`.
+     * {@link setSessionKeypair}); the server bumps the session's `expiresAt`.
      * No new credential is issued — the same keypair keeps working.
      *
      * @returns Promise resolving to the new expiry
@@ -272,7 +236,7 @@ export class AuthAPIImpl extends BaseAPI {
             method: "POST",
         });
         return {
-            expiresAt: responseBody.expires_at,
+            expiresAt: responseBody.expiresAt,
         };
     }
     /**

package/dist/api/base.d.ts

@@ -30,6 +30,8 @@ export declare abstract class BaseAPI {
     protected readonly apiUrl: 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.
@@ -44,6 +46,19 @@ export declare abstract class BaseAPI {
      * @param credentials - Hex-encoded session keypair, or `undefined` to clear.
      */
     setSessionKeypair(credentials: SessionCredentials | undefined): void;
+    /**
+     * Set (or clear) the application secret key used for backend-authenticated
+     * requests.
+     *
+     * 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.
+     */
+    setServerKey(serverKey: string | undefined): void;
     /**
      * Parse request body for error logging
      *
@@ -84,7 +99,7 @@ export declare abstract class BaseAPI {
      *   '/api/v1/orders',
      *   {
      *     method: 'POST',
-     *     body: JSON.stringify({ trading_pair: 'ETH-USD', side: 'BUY' })
+     *     body: JSON.stringify({ tradingPair: 'ETH-USD', side: 'BUY' })
      *   }
      * );
      * ```
@@ -99,6 +114,26 @@ export declare abstract class BaseAPI {
      * 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.
      *
@@ -120,7 +155,7 @@ export declare abstract class BaseAPI {
      *   '/api/v1/auth/challenge',
      *   {
      *     method: 'POST',
-     *     body: JSON.stringify({ address, client_id: clientId })
+     *     body: JSON.stringify({ address, clientId: clientId })
      *   }
      * );
      * ```

package/dist/api/base.js

@@ -28,6 +28,8 @@ export class BaseAPI {
     apiUrl;
     /** 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.
@@ -50,6 +52,21 @@ export class BaseAPI {
     setSessionKeypair(credentials) {
         this.sessionKeypair = credentials ? keypairFromHex(credentials.publicKey, credentials.privateKey) : undefined;
     }
+    /**
+     * Set (or clear) the application secret key used for backend-authenticated
+     * requests.
+     *
+     * 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.
+     */
+    setServerKey(serverKey) {
+        this.serverKey = serverKey;
+    }
     /**
      * Parse request body for error logging
      *
@@ -170,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,
@@ -218,7 +241,7 @@ export class BaseAPI {
      *   '/api/v1/orders',
      *   {
      *     method: 'POST',
-     *     body: JSON.stringify({ trading_pair: 'ETH-USD', side: 'BUY' })
+     *     body: JSON.stringify({ tradingPair: 'ETH-USD', side: 'BUY' })
      *   }
      * );
      * ```
@@ -269,6 +292,43 @@ export class BaseAPI {
             "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,
+            });
+        }
+        const url = `${this.apiUrl}${endpoint}`;
+        const requestBody = this.parseRequestBody(options.body);
+        return this.executeRequest(url, endpoint, {
+            ...options,
+            headers: {
+                "Content-Type": "application/json",
+                "x-server-key": this.serverKey,
+                ...options.headers,
+            },
+        }, requestBody);
+    }
     /**
      * Makes an unauthenticated API request.
      *
@@ -290,7 +350,7 @@ export class BaseAPI {
      *   '/api/v1/auth/challenge',
      *   {
      *     method: 'POST',
-     *     body: JSON.stringify({ address, client_id: clientId })
+     *     body: JSON.stringify({ address, clientId: clientId })
      *   }
      * );
      * ```

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

@@ -5,23 +5,26 @@ export class DelegatedAgentsAPIImpl extends BaseAPI {
         return this.makeAuthenticatedRequest(perpRoutes.delegatedAgents.list(), {
             method: "POST",
             body: JSON.stringify({
-                agent_address: request.agentAddress,
+                agentAddress: request.agentAddress,
                 name: request.name,
-                expires_at: request.expiresAt,
-                allowed_actions: request.allowedActions,
-                allowed_trading_pair_ids: request.allowedTradingPairIds,
-                allowed_margin_account_ids: request.allowedMarginAccountIds,
-                allowed_order_types: request.allowedOrderTypes,
-                allowed_time_in_force: request.allowedTimeInForce,
-                max_leverage: request.maxLeverage,
-                max_order_notional: request.maxOrderNotional,
-                max_open_orders: request.maxOpenOrders,
+                expiresAt: request.expiresAt,
+                allowedActions: request.allowedActions,
+                allowedTradingPairIds: request.allowedTradingPairIds,
+                allowedMarginAccountIds: request.allowedMarginAccountIds,
+                allowedOrderTypes: request.allowedOrderTypes,
+                allowedTimeInForce: request.allowedTimeInForce,
+                maxLeverage: request.maxLeverage,
+                maxOrderNotional: request.maxOrderNotional,
+                maxOpenOrders: request.maxOpenOrders,
             }),
         });
     }
     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",
@@ -31,7 +34,8 @@ export class DelegatedAgentsAPIImpl extends BaseAPI {
         return this.makeAuthenticatedRequest(perpRoutes.delegatedAgents.sessions(), {
             method: "POST",
             body: JSON.stringify({
-                owner_user_id: request.ownerUserId,
+                ownerUserId: request.ownerUserId,
+                sessionPublicKey: request.sessionPublicKey,
             }),
         });
     }