@0xmonaco/core 0.8.7-develop.34bd452 → 0.8.7-develop.a107b34

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.
@@ -51,4 +54,65 @@ export class ApplicationsAPIImpl extends BaseAPI {
             clientId: data.client_id,
         };
     }
+    /**
+     * 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,24 +138,6 @@ 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.
      *

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";
@@ -216,41 +215,6 @@ 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.
      *

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
      *
@@ -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.
      *

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,
@@ -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.
      *

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,18 @@
-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, SimulateOrderRiskRequest, SimulateOrderRiskResponse, SimulateRiskBucketOrderRiskRequest, TransferCollateralFromParentMarginAccountRequest, TransferCollateralRequest, TransferCollateralResponse, TransferCollateralToParentMarginAccountRequest, TransferCollateralToRiskBucketRequest } 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>;
+    getParentMarginAccountSummary(params?: GetMarginAccountSummaryParams): Promise<MarginAccountSummary>;
     getAvailableCollateral(params?: GetAvailableCollateralParams): Promise<GetAvailableCollateralResponse>;
     transferCollateralToMarginAccount(marginAccountId: string, request: TransferCollateralRequest): Promise<TransferCollateralResponse>;
-    transferCollateralToAutoMarginAccount(request: TransferCollateralToAutoMarginAccountRequest): Promise<TransferCollateralResponse>;
+    transferCollateralToParentMarginAccount(request: TransferCollateralToParentMarginAccountRequest): Promise<TransferCollateralResponse>;
+    transferCollateralToRiskBucket(request: TransferCollateralToRiskBucketRequest): Promise<TransferCollateralResponse>;
     transferCollateralFromMarginAccount(marginAccountId: string, request: TransferCollateralRequest): Promise<TransferCollateralResponse>;
+    transferCollateralFromParentMarginAccount(request: TransferCollateralFromParentMarginAccountRequest): Promise<TransferCollateralResponse>;
     getMarginAccountMovements(marginAccountId: string, params?: GetMarginAccountMovementsParams): Promise<GetMarginAccountMovementsResponse>;
+    getParentMarginAccountMovements(params?: GetMarginAccountMovementsParams): Promise<GetMarginAccountMovementsResponse>;
     simulateOrderRisk(marginAccountId: string, request: SimulateOrderRiskRequest): Promise<SimulateOrderRiskResponse>;
-    simulateAutoMarginOrderRisk(request: SimulateOrderRiskRequest): Promise<SimulateOrderRiskResponse>;
+    simulateParentMarginOrderRisk(request: SimulateOrderRiskRequest): Promise<SimulateOrderRiskResponse>;
+    simulateRiskBucketOrderRisk(request: SimulateRiskBucketOrderRiskRequest): Promise<SimulateOrderRiskResponse>;
 }