@0xmonaco/core 0.7.7 → 0.7.8

package/dist/errors/index.d.ts

@@ -0,0 +1 @@
+export * from "./errors";

package/dist/errors/index.js

@@ -0,0 +1 @@
+export * from "./errors";

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { createMonacoWebSocket, type MonacoWebSocket, type MonacoWebSocketOptions } from "./api/websocket";
+export { APIError, ContractError, InvalidConfigError, InvalidStateError, MonacoCoreError } from "./errors";
+export { resolveApiUrl, resolveWsUrl } from "./networks";
+export { createMonacoSDK, MonacoSDKImpl as MonacoSDK } from "./sdk";
+export { ALL_MAGNITUDES, calculateValidMagnitudes, MAX_BUCKETS_ALLOWED, MIN_BUCKETS_ALLOWED, } from "./utils";

package/dist/index.js

@@ -0,0 +1,5 @@
+export { createMonacoWebSocket } from "./api/websocket";
+export { APIError, ContractError, InvalidConfigError, InvalidStateError, MonacoCoreError } from "./errors";
+export { resolveApiUrl, resolveWsUrl } from "./networks";
+export { createMonacoSDK, MonacoSDKImpl as MonacoSDK } from "./sdk";
+export { ALL_MAGNITUDES, calculateValidMagnitudes, MAX_BUCKETS_ALLOWED, MIN_BUCKETS_ALLOWED, } from "./utils";

package/dist/networks/index.d.ts

@@ -0,0 +1 @@
+export * from "./networks";

package/dist/networks/index.js

@@ -0,0 +1 @@
+export * from "./networks";

package/dist/networks/networks.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Monaco SDK Network Configuration
+ *
+ * Network configuration and endpoints with hardcoded defaults.
+ * No environment variables are required - all configuration is provided at runtime.
+ */
+import type { Network } from "@0xmonaco/types";
+/**
+ * Resolve the API URL based on network
+ *
+ * @param network - Network preset name
+ * @returns The resolved API URL
+ */
+export declare function resolveApiUrl(network: Network): string;
+/**
+ * Resolve the WebSocket URL based on network
+ *
+ * @param network - Network preset name
+ * @returns The resolved WebSocket URL
+ */
+export declare function resolveWsUrl(network: Network): string;

package/dist/networks/networks.js

@@ -0,0 +1,46 @@
+/**
+ * Monaco SDK Network Configuration
+ *
+ * Network configuration and endpoints with hardcoded defaults.
+ * No environment variables are required - all configuration is provided at runtime.
+ */
+/**
+ * Default API URLs for preset networks
+ */
+const LOCAL_URL = "http://localhost:8080";
+const DEVELOPMENT_URL = "https://develop.apimonaco.xyz";
+const STAGING_URL = "https://staging.apimonaco.xyz";
+const MAINNET_URL = "https://api.monaco.xyz";
+const DEFAULT_API_URLS = {
+    local: LOCAL_URL,
+    development: DEVELOPMENT_URL,
+    staging: STAGING_URL,
+    mainnet: MAINNET_URL,
+};
+/**
+ * Default WebSocket URLs for preset networks
+ */
+const DEFAULT_WS_URLS = {
+    local: "ws://localhost:8085/ws",
+    development: "wss://develop.apimonaco.xyz/ws",
+    staging: "wss://staging.apimonaco.xyz/ws",
+    mainnet: "wss://api.monaco.xyz/ws",
+};
+/**
+ * Resolve the API URL based on network
+ *
+ * @param network - Network preset name
+ * @returns The resolved API URL
+ */
+export function resolveApiUrl(network) {
+    return DEFAULT_API_URLS[network];
+}
+/**
+ * Resolve the WebSocket URL based on network
+ *
+ * @param network - Network preset name
+ * @returns The resolved WebSocket URL
+ */
+export function resolveWsUrl(network) {
+    return DEFAULT_WS_URLS[network];
+}

package/dist/sdk.d.ts

@@ -0,0 +1,134 @@
+import type { ApplicationsAPI, AuthAPI, AuthState, FeesAPI, MarginAccountsAPI, MarketAPI, MonacoSDK, Network, PositionsAPI, ProfileAPI, SDKConfig, TradingAPI, VaultAPI } from "@0xmonaco/types";
+import { type PublicClient, type TransactionReceipt, type WalletClient } from "viem";
+import { type MonacoWebSocket, OrderbookAPIImpl, TradesAPIImpl } from "./api";
+export declare class MonacoSDKImpl implements MonacoSDK {
+    auth: AuthAPI;
+    applications: ApplicationsAPI;
+    fees: FeesAPI;
+    vault: VaultAPI;
+    trading: TradingAPI;
+    market: MarketAPI;
+    marginAccounts: MarginAccountsAPI;
+    positions: PositionsAPI;
+    profile: ProfileAPI;
+    orderbook: OrderbookAPIImpl;
+    trades: TradesAPIImpl;
+    ws: MonacoWebSocket;
+    walletClient: WalletClient | undefined;
+    publicClient: PublicClient;
+    private authState?;
+    private readonly network;
+    private readonly chain;
+    /**
+     * Propagate the access token to all APIs and WebSocket
+     */
+    private propagateAccessToken;
+    constructor(cfg: SDKConfig);
+    /**
+     * Authenticate the user
+     *
+     * Returns an AuthState object containing:
+     * - `accessToken`: For making authenticated API requests
+     * - `refreshToken`: For refreshing tokens AND revoking (logout)
+     * - `expiresAt`: When the access token expires
+     * - `user`: User information
+     *
+     * Note: Use `sdk.logout()` to revoke the token and clean up, or call
+     * `sdk.auth.revokeToken()` directly to just revoke.
+     *
+     * @param clientId - The client ID for authentication
+     * @param options - Optional configuration
+     * @param options.connectWebSocket - Auto-connect WebSocket after login (default: false)
+     *
+     * @example
+     * ```typescript
+     * // Login only
+     * const authState = await sdk.login(clientId);
+     *
+     * // Login and auto-connect WebSocket
+     * const authState = await sdk.login(clientId, { connectWebSocket: true });
+     *
+     * // Manual WebSocket connection
+     * await sdk.ws.connect();
+     *
+     * // Later, to revoke:
+     * await sdk.auth.revokeToken(); // ✅
+     * // Or revoke and disconnect WebSocket:
+     * await sdk.logout(); // ✅ Calls revokeToken internally and disconnects WebSocket
+     * ```
+     */
+    login(clientId: string, options?: {
+        connectWebSocket?: boolean;
+    }): Promise<AuthState>;
+    /**
+     * Get the current authentication state
+     *
+     * @returns The current authentication state or undefined if not authenticated
+     */
+    getAuthState(): AuthState | undefined;
+    /**
+     * Set the authentication state directly
+     * Useful for sharing authentication across multiple SDK instances (e.g., in tests)
+     *
+     * @param authState - The authentication state to set
+     */
+    setAuthState(authState: AuthState): void;
+    /**
+     * Log the user out
+     *
+     * This method revokes the refresh token (if available), disconnects all authenticated
+     * WebSocket channels, and clears the local auth state.
+     * It internally calls `auth.revokeToken()` to invalidate the token on the server.
+     *
+     * @example
+     * ```typescript
+     * await sdk.logout();
+     * // Token is revoked, authenticated WebSockets disconnected, and local state cleared
+     * ```
+     */
+    logout(): Promise<void>;
+    /**
+     * Refresh the access token
+     * @returns The updated authentication state
+     */
+    refreshAuth(): Promise<AuthState>;
+    /**
+     * Check if the user is authenticated
+     */
+    isAuthenticated(): boolean;
+    /**
+     * Check connection status
+     */
+    isConnected(): boolean;
+    /**
+     * Set the wallet client
+     * Used by React SDK to update the wallet when wagmi becomes available
+     */
+    setWalletClient(walletClient: WalletClient): void;
+    /**
+     * Get the current account address
+     */
+    getAccountAddress(): string;
+    /**
+     * Get the current network
+     */
+    getNetwork(): Network;
+    /**
+     * Get the current chain ID
+     */
+    getChainId(): number;
+    /**
+     * Wait for a transaction to be confirmed
+     * @param hash - The transaction hash
+     * @param confirmations - Number of confirmations to wait for (optional)
+     * @param timeout - Timeout in milliseconds (optional)
+     * @returns The transaction receipt
+     */
+    waitForTransaction(hash: string, confirmations?: number, timeout?: number): Promise<TransactionReceipt>;
+}
+/**
+ * Create a new Monaco SDK instance
+ * @param config - SDK configuration
+ * @returns Monaco SDK instance
+ */
+export declare function createMonacoSDK(config: SDKConfig): MonacoSDK;

package/dist/sdk.js

@@ -0,0 +1,294 @@
+import { StatusCodes } from "http-status-codes";
+import { createPublicClient, http } from "viem";
+import { sei, seiTestnet } from "viem/chains";
+import { ApplicationsAPIImpl, createMonacoWebSocket, OrderbookAPIImpl, TradesAPIImpl } from "./api";
+import { AuthAPIImpl } from "./api/auth";
+import { FeesAPIImpl } from "./api/fees";
+import { MarginAccountsAPIImpl } from "./api/margin-accounts";
+import { MarketAPIImpl } from "./api/market";
+import { PositionsAPIImpl } from "./api/positions";
+import { ProfileAPIImpl } from "./api/profile";
+import { TradingAPIImpl } from "./api/trading";
+import { VaultAPIImpl } from "./api/vault";
+import { APIError, InvalidConfigError, InvalidStateError } from "./errors";
+import { resolveApiUrl, resolveWsUrl } from "./networks";
+export class MonacoSDKImpl {
+    auth;
+    applications;
+    fees;
+    vault;
+    trading;
+    market;
+    marginAccounts;
+    positions;
+    profile;
+    orderbook;
+    trades;
+    ws;
+    walletClient;
+    publicClient;
+    authState;
+    network;
+    chain;
+    /**
+     * Propagate the access token to all APIs and WebSocket
+     */
+    propagateAccessToken(accessToken) {
+        this.auth.setAccessToken(accessToken);
+        this.applications.setAccessToken(accessToken);
+        this.fees.setAccessToken(accessToken);
+        this.vault.setAccessToken(accessToken);
+        this.trading.setAccessToken(accessToken);
+        this.market.setAccessToken(accessToken);
+        this.marginAccounts.setAccessToken(accessToken);
+        this.positions.setAccessToken(accessToken);
+        this.profile.setAccessToken(accessToken);
+        this.orderbook.setAccessToken(accessToken);
+        this.trades.setAccessToken(accessToken);
+        this.ws.setToken(accessToken);
+    }
+    constructor(cfg) {
+        // Validate network - must be a preset
+        const presetNetworks = ["mainnet", "development", "staging", "local"];
+        if (!cfg.network || !presetNetworks.includes(cfg.network)) {
+            throw new InvalidConfigError(`network must be one of: ${presetNetworks.join(", ")}. Got: ${cfg.network}`, "network");
+        }
+        this.network = cfg.network;
+        // Validate seiRpcUrl is provided
+        if (!cfg.seiRpcUrl) {
+            throw new InvalidConfigError("seiRpcUrl is required", "seiRpcUrl");
+        }
+        try {
+            new URL(cfg.seiRpcUrl);
+        }
+        catch (_e) {
+            throw new InvalidConfigError(`seiRpcUrl must be a valid URL, got: ${cfg.seiRpcUrl}`, "seiRpcUrl");
+        }
+        // Infer WebSocket URL from network
+        const wsUrl = resolveWsUrl(this.network);
+        // Use Sei mainnet chain only for "mainnet" network, testnet for everything else
+        const chain = this.network === "mainnet" ? sei : seiTestnet;
+        this.chain = chain;
+        // Create public client with provided RPC URL
+        const transport = http(cfg.seiRpcUrl);
+        this.publicClient = createPublicClient({
+            chain,
+            transport,
+        });
+        // Resolve the API URL (from preset or custom URL)
+        const apiUrl = resolveApiUrl(this.network);
+        // Validate wallet client chain if provided
+        if (cfg.walletClient) {
+            if (cfg.walletClient.chain?.id !== chain.id) {
+                throw new InvalidConfigError(`Wallet client chain mismatch. Expected ${chain.id}, got ${cfg.walletClient.chain?.id}`, "walletClient");
+            }
+            this.walletClient = cfg.walletClient;
+        }
+        // Instantiate APIs (wallet-dependent APIs will be initialized lazily or error if wallet not set)
+        this.applications = new ApplicationsAPIImpl(apiUrl);
+        this.market = new MarketAPIImpl(apiUrl);
+        this.marginAccounts = new MarginAccountsAPIImpl(apiUrl);
+        this.positions = new PositionsAPIImpl(apiUrl);
+        this.auth = new AuthAPIImpl(this.walletClient, this.chain, apiUrl);
+        this.fees = new FeesAPIImpl(apiUrl);
+        this.profile = new ProfileAPIImpl(apiUrl);
+        this.vault = new VaultAPIImpl(this.publicClient, this.walletClient, this.chain, this.applications, this.profile, apiUrl);
+        this.trading = new TradingAPIImpl(apiUrl);
+        this.orderbook = new OrderbookAPIImpl(apiUrl);
+        this.trades = new TradesAPIImpl(apiUrl);
+        this.ws = createMonacoWebSocket(wsUrl);
+        // Auto-connect WebSocket, log errors
+        this.ws.connect().catch(console.error);
+    }
+    /**
+     * Authenticate the user
+     *
+     * Returns an AuthState object containing:
+     * - `accessToken`: For making authenticated API requests
+     * - `refreshToken`: For refreshing tokens AND revoking (logout)
+     * - `expiresAt`: When the access token expires
+     * - `user`: User information
+     *
+     * Note: Use `sdk.logout()` to revoke the token and clean up, or call
+     * `sdk.auth.revokeToken()` directly to just revoke.
+     *
+     * @param clientId - The client ID for authentication
+     * @param options - Optional configuration
+     * @param options.connectWebSocket - Auto-connect WebSocket after login (default: false)
+     *
+     * @example
+     * ```typescript
+     * // Login only
+     * const authState = await sdk.login(clientId);
+     *
+     * // Login and auto-connect WebSocket
+     * const authState = await sdk.login(clientId, { connectWebSocket: true });
+     *
+     * // Manual WebSocket connection
+     * await sdk.ws.connect();
+     *
+     * // Later, to revoke:
+     * await sdk.auth.revokeToken(); // ✅
+     * // Or revoke and disconnect WebSocket:
+     * await sdk.logout(); // ✅ Calls revokeToken internally and disconnects WebSocket
+     * ```
+     */
+    async login(clientId, options) {
+        const response = await this.auth.authenticate(clientId);
+        this.authState = {
+            accessToken: response.accessToken,
+            refreshToken: response.refreshToken,
+            expiresAt: response.expiresAt,
+            user: response.user,
+        };
+        this.propagateAccessToken(this.authState.accessToken);
+        // Auto-connect WebSocket if requested
+        if (options?.connectWebSocket) {
+            await this.ws.connect();
+        }
+        return this.authState;
+    }
+    /**
+     * Get the current authentication state
+     *
+     * @returns The current authentication state or undefined if not authenticated
+     */
+    getAuthState() {
+        return this.authState;
+    }
+    /**
+     * Set the authentication state directly
+     * Useful for sharing authentication across multiple SDK instances (e.g., in tests)
+     *
+     * @param authState - The authentication state to set
+     */
+    setAuthState(authState) {
+        this.authState = authState;
+        this.propagateAccessToken(authState.accessToken);
+    }
+    /**
+     * Log the user out
+     *
+     * This method revokes the refresh token (if available), disconnects all authenticated
+     * WebSocket channels, and clears the local auth state.
+     * It internally calls `auth.revokeToken()` to invalidate the token on the server.
+     *
+     * @example
+     * ```typescript
+     * await sdk.logout();
+     * // Token is revoked, authenticated WebSockets disconnected, and local state cleared
+     * ```
+     */
+    async logout() {
+        if (this.authState?.refreshToken) {
+            try {
+                await this.auth.revokeToken();
+            }
+            catch (error) {
+                // Log but don't throw - we want to clear the local state regardless
+                console.warn("Failed to revoke token on logout:", error);
+            }
+        }
+        this.authState = undefined;
+        this.propagateAccessToken("");
+        this.ws.disconnect();
+    }
+    /**
+     * Refresh the access token
+     * @returns The updated authentication state
+     */
+    async refreshAuth() {
+        if (!this.authState?.refreshToken) {
+            throw new APIError("No refresh token available", {
+                endpoint: "auth/refresh",
+                statusCode: StatusCodes.UNAUTHORIZED,
+            });
+        }
+        try {
+            const response = await this.auth.refreshToken(this.authState.refreshToken);
+            this.authState = {
+                ...this.authState,
+                accessToken: response.accessToken,
+                expiresAt: response.expiresAt,
+            };
+            this.propagateAccessToken(this.authState.accessToken);
+            return this.authState;
+        }
+        catch (error) {
+            // If refresh fails, set the auth state to undefined
+            this.authState = undefined;
+            throw error;
+        }
+    }
+    /**
+     * Check if the user is authenticated
+     */
+    isAuthenticated() {
+        return !!this.authState;
+    }
+    /**
+     * Check connection status
+     */
+    isConnected() {
+        return !!this.walletClient && !!this.publicClient;
+    }
+    /**
+     * Set the wallet client
+     * Used by React SDK to update the wallet when wagmi becomes available
+     */
+    setWalletClient(walletClient) {
+        if (walletClient.chain?.id !== this.chain.id) {
+            throw new InvalidConfigError(`Wallet client chain mismatch. Expected ${this.chain.id}, got ${walletClient.chain?.id}`, "walletClient");
+        }
+        this.walletClient = walletClient;
+        // Update APIs that depend on wallet client
+        this.auth.setWalletClient(walletClient);
+        this.vault.setWalletClient(walletClient);
+    }
+    /**
+     * Get the current account address
+     */
+    getAccountAddress() {
+        if (!this.walletClient) {
+            throw new InvalidStateError("Wallet client not set", "walletClient");
+        }
+        if (this.walletClient.account) {
+            return this.walletClient.account.address;
+        }
+        throw new InvalidStateError("No account available", "account");
+    }
+    /**
+     * Get the current network
+     */
+    getNetwork() {
+        return this.network;
+    }
+    /**
+     * Get the current chain ID
+     */
+    getChainId() {
+        return this.chain.id;
+    }
+    /**
+     * Wait for a transaction to be confirmed
+     * @param hash - The transaction hash
+     * @param confirmations - Number of confirmations to wait for (optional)
+     * @param timeout - Timeout in milliseconds (optional)
+     * @returns The transaction receipt
+     */
+    async waitForTransaction(hash, confirmations, timeout) {
+        return this.publicClient.waitForTransactionReceipt({
+            hash: hash,
+            confirmations,
+            timeout,
+        });
+    }
+}
+/**
+ * Create a new Monaco SDK instance
+ * @param config - SDK configuration
+ * @returns Monaco SDK instance
+ */
+export function createMonacoSDK(config) {
+    return new MonacoSDKImpl(config);
+}

package/dist/utils/index.d.ts

@@ -0,0 +1 @@
+export * from "./magnitude";

package/dist/utils/index.js

@@ -0,0 +1 @@
+export * from "./magnitude";

package/dist/utils/magnitude.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Minimum number of price buckets allowed for a magnitude
+ */
+export declare const MIN_BUCKETS_ALLOWED = 10;
+/**
+ * Maximum number of price buckets allowed for a magnitude
+ */
+export declare const MAX_BUCKETS_ALLOWED = 10000000;
+/**
+ * All possible magnitude values we support (from 0.0001 to 10000)
+ */
+export declare const ALL_MAGNITUDES: number[];
+/**
+ * Calculate which magnitude levels are valid for a given price.
+ *
+ * A magnitude is valid if it creates between MIN_BUCKETS_ALLOWED and MAX_BUCKETS_ALLOWED price buckets.
+ *
+ * @param currentPrice - The current market price (e.g., 50000 for BTC/USDC)
+ * @returns Array of valid magnitude values
+ *
+ * @example
+ * calculateValidMagnitudes(112000);  // [0.1, 1, 10, 100, 1000, 10000]
+ * calculateValidMagnitudes(4200);    // [0.001, 0.01, 0.1, 1, 10, 100]
+ * calculateValidMagnitudes(0.5);     // [0.0001, 0.001, 0.01]
+ */
+export declare const calculateValidMagnitudes: (currentPrice: number) => number[];

package/dist/utils/magnitude.js

@@ -0,0 +1,31 @@
+/**
+ * Minimum number of price buckets allowed for a magnitude
+ */
+export const MIN_BUCKETS_ALLOWED = 10;
+/**
+ * Maximum number of price buckets allowed for a magnitude
+ */
+export const MAX_BUCKETS_ALLOWED = 10_000_000;
+/**
+ * All possible magnitude values we support (from 0.0001 to 10000)
+ */
+export const ALL_MAGNITUDES = [0.0001, 0.001, 0.01, 0.1, 1, 10, 100, 1000, 10000];
+/**
+ * Calculate which magnitude levels are valid for a given price.
+ *
+ * A magnitude is valid if it creates between MIN_BUCKETS_ALLOWED and MAX_BUCKETS_ALLOWED price buckets.
+ *
+ * @param currentPrice - The current market price (e.g., 50000 for BTC/USDC)
+ * @returns Array of valid magnitude values
+ *
+ * @example
+ * calculateValidMagnitudes(112000);  // [0.1, 1, 10, 100, 1000, 10000]
+ * calculateValidMagnitudes(4200);    // [0.001, 0.01, 0.1, 1, 10, 100]
+ * calculateValidMagnitudes(0.5);     // [0.0001, 0.001, 0.01]
+ */
+export const calculateValidMagnitudes = (currentPrice) => {
+    return ALL_MAGNITUDES.filter((magnitude) => {
+        const bucketCount = Math.floor(currentPrice / magnitude);
+        return bucketCount >= MIN_BUCKETS_ALLOWED && bucketCount <= MAX_BUCKETS_ALLOWED;
+    });
+};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@0xmonaco/core",
-	"version": "0.7.7",
+	"version": "0.7.8",
 	"type": "module",
 	"repository": {
 		"type": "git",
@@ -23,8 +23,8 @@
 		"viem": "^2.45.2"
 	},
 	"dependencies": {
-		"@0xmonaco/contracts": "0.7.7",
-		"@0xmonaco/types": "0.7.7",
+		"@0xmonaco/contracts": "0.7.8",
+		"@0xmonaco/types": "0.7.8",
 		"http-status-codes": "^2.3.0"
 	},
 	"devDependencies": {