@0xmonaco/core 0.7.7 → 0.7.9

package/dist/api/vault/api.js

@@ -0,0 +1,506 @@
+/**
+ * Vault API Implementation
+ *
+ * Handles vault operations including deposits, withdrawals, and ERC20 approvals.
+ * Implements the signature flow for deposit/withdraw operations via API Gateway.
+ *
+ * This class provides a complete interface for interacting with the Monaco vault contract,
+ * including token approvals, deposits, withdrawals, and balance queries. All operations
+ * use EIP-712 signatures for security and go through the API Gateway for validation.
+ *
+ * @example
+ * ```typescript
+ * const vaultAPI = new VaultAPIImpl(
+ *   publicClient,
+ *   walletClient,
+ *   vaultAddress,
+ *   apiUrl,
+ *   chain
+ * );
+ *
+ * // Deposit tokens
+ * const result = await vaultAPI.deposit(tokenAddress, parseEther("100"));
+ * console.log(`Deposit transaction: ${result.hash}`);
+ * ```
+ */
+import { CONTRACT_ABIS } from "@0xmonaco/contracts";
+import { ApproveTokenSchema, DepositSchema, validate, WithdrawSchema } from "@0xmonaco/types";
+import { erc20Abi, zeroAddress } from "viem";
+import { APIError, ContractError, InvalidConfigError } from "../../errors";
+import { BaseAPI } from "../base";
+export class VaultAPIImpl extends BaseAPI {
+    publicClient;
+    chain;
+    applicationsAPI;
+    profileAPI;
+    walletClient;
+    /**
+     * Creates a new VaultAPI instance.
+     *
+     * @param publicClient - The viem public client for reading blockchain state
+     * @param walletClient - The viem wallet client for signing transactions (optional)
+     * @param chain - The blockchain network configuration
+     * @param applicationsAPI - The applications API instance for fetching vault address
+     * @param profileAPI - The profile API instance for fetching asset information
+     * @param apiUrl - The base URL for the Monaco API Gateway
+     */
+    constructor(publicClient, walletClient, chain, applicationsAPI, profileAPI, apiUrl) {
+        super(apiUrl);
+        this.publicClient = publicClient;
+        this.chain = chain;
+        this.walletClient = walletClient;
+        this.applicationsAPI = applicationsAPI;
+        this.profileAPI = profileAPI;
+    }
+    /**
+     * Sets the wallet client for signing transactions.
+     * Used when the wallet becomes available after SDK initialization.
+     */
+    setWalletClient(walletClient) {
+        this.walletClient = walletClient;
+    }
+    /**
+     * Fetches the vault contract address from the applications API.
+     *
+     * @returns Promise resolving to the vault contract address
+     * @throws {APIError} When vault address cannot be retrieved
+     * @private
+     */
+    async getVaultAddress() {
+        const config = await this.applicationsAPI.getApplicationConfig();
+        return config.vaultContractAddress;
+    }
+    /**
+     * Fetches the application's client ID from the applications API.
+     * The client ID is embedded in on-chain deposit calls so the indexer can
+     * attribute the deposit to the correct application.
+     *
+     * @returns Promise resolving to the application client ID
+     * @private
+     */
+    async getClientId() {
+        const config = await this.applicationsAPI.getApplicationConfig();
+        return config.clientId;
+    }
+    /**
+     * Resolves an asset ID to its token address and determines if it's a native token.
+     *
+     * @param assetId - The asset identifier (UUID) to resolve
+     * @returns Promise resolving to object with tokenAddress and isNativeToken flag
+     * @throws {ContractError} When asset ID cannot be resolved
+     * @private
+     */
+    async resolveAsset(assetId) {
+        let tokenAddress;
+        try {
+            const assetBalance = await this.profileAPI.getUserBalanceByAssetId(assetId);
+            tokenAddress = assetBalance.token;
+        }
+        catch (error) {
+            // Differentiate between network errors and asset not found
+            if (error instanceof APIError) {
+                if (error.statusCode === 404) {
+                    throw new ContractError(`Asset ID '${assetId}' does not exist`, {
+                        revertReason: "ASSET_NOT_FOUND",
+                        cause: error,
+                    });
+                }
+                // Network or other API errors - preserve retry-ability context
+                throw new ContractError(`Failed to resolve asset ID '${assetId}': ${error.retryable ? "Network error occurred" : "API request failed"}`, {
+                    revertReason: error.retryable ? "NETWORK_ERROR" : "API_ERROR",
+                    cause: error,
+                });
+            }
+            // Unknown error type
+            throw new ContractError(`Failed to resolve asset ID '${assetId}': Unexpected error`, {
+                revertReason: "UNKNOWN_ERROR",
+                cause: error instanceof Error ? error : undefined,
+            });
+        }
+        const isNativeToken = tokenAddress === zeroAddress;
+        return { tokenAddress, isNativeToken };
+    }
+    /**
+     * Approves the vault contract to spend tokens on behalf of the user.
+     *
+     * This method creates and sends an ERC20 approve transaction to allow the vault
+     * to transfer tokens from the user's wallet. Approval is required before any
+     * deposit operations can be performed.
+     *
+     * @param assetId - The asset identifier (UUID) to approve
+     * @param amount - The maximum amount of tokens the vault can spend (as bigint)
+     * @param autoWait - Whether to automatically wait for transaction confirmation (defaults to true)
+     * @returns Promise resolving to TransactionResult with transaction details
+     * @throws {ContractError} When approval transaction fails or asset not found
+     * @throws {InvalidConfigError} When wallet account is not available
+     *
+     * @example
+     * ```typescript
+     * // Approve vault to spend up to 1000 USDC (auto-waits by default)
+     * const result = await vaultAPI.approve(
+     *   "123e4567-e89b-12d3-a456-426614174000",
+     *   parseUnits("1000", 6)
+     * );
+     * console.log(`Approval transaction: ${result.hash}`);
+     * console.log(`Status: ${result.status}`); // "confirmed" if successful
+     *
+     * // Or skip auto-waiting
+     * const result = await vaultAPI.approve(
+     *   "123e4567-e89b-12d3-a456-426614174000",
+     *   parseUnits("1000", 6),
+     *   false
+     * );
+     * // Then manually wait later if needed
+     * const receipt = await sdk.waitForTransaction(result.hash);
+     * ```
+     */
+    async approve(assetId, amount, autoWait = true) {
+        if (!this.walletClient) {
+            throw new InvalidConfigError("Wallet client not set. Connect a wallet first.", "walletClient");
+        }
+        // Validate inputs
+        validate(ApproveTokenSchema, { assetId, amount, autoWait });
+        const vaultAddress = await this.getVaultAddress();
+        const { tokenAddress } = await this.resolveAsset(assetId);
+        const account = this.walletClient.account;
+        if (!account) {
+            throw new InvalidConfigError("No account available in wallet client", "account");
+        }
+        const nonce = account.getNonce ? await account.getNonce() : 0n;
+        // Use writeContract - handles nonce, gas estimation, signing, and sending automatically
+        const hash = await this.walletClient.writeContract({
+            address: tokenAddress,
+            abi: erc20Abi,
+            functionName: "approve",
+            args: [vaultAddress, amount],
+            chain: this.chain,
+            account,
+        });
+        const txResult = {
+            nonce,
+            hash,
+            status: "pending",
+        };
+        // Handle auto-waiting for transaction confirmation
+        return await this.waitForTransaction(txResult, autoWait);
+    }
+    /**
+     * Deposits tokens into the Monaco vault.
+     *
+     * Deposits the specified amount of tokens into the vault contract. The method
+     * first checks if sufficient approval exists, then obtains a signature from the
+     * API Gateway, and finally executes the deposit transaction on-chain.
+     *
+     * Note: This method requires prior approval via the `approve()` method.
+     *
+     * @param assetId - The asset identifier (UUID) to deposit
+     * @param amount - The amount of tokens to deposit (as bigint)
+     * @param autoWait - Whether to automatically wait for transaction confirmation (defaults to true)
+     * @returns Promise resolving to TransactionResult with transaction details
+     * @throws {ContractError} When deposit fails or approval is insufficient
+     * @throws {APIError} When the asset is not found or the assetId is invalid
+     * @throws {InvalidConfigError} When wallet account is not available
+     *
+     * @example
+     * ```typescript
+     * // Deposit 100 USDC into the vault (auto-waits by default)
+     * const result = await vaultAPI.deposit(
+     *   "123e4567-e89b-12d3-a456-426614174000",
+     *   parseUnits("100", 6)
+     * );
+     * console.log(`Deposit transaction: ${result.hash}`);
+     * console.log(`Status: ${result.status}`); // "confirmed" if successful
+     *
+     * // Or skip auto-waiting
+     * const result = await vaultAPI.deposit(
+     *   "123e4567-e89b-12d3-a456-426614174000",
+     *   parseUnits("100", 6),
+     *   false
+     * );
+     * // Then manually wait later if needed
+     * const receipt = await sdk.waitForTransaction(result.hash);
+     * ```
+     */
+    async deposit(assetId, amount, autoWait = true) {
+        if (!this.walletClient) {
+            throw new InvalidConfigError("Wallet client not set. Connect a wallet first.", "walletClient");
+        }
+        // Validate inputs
+        validate(DepositSchema, { assetId, amount, autoWait });
+        const vaultAddress = await this.getVaultAddress();
+        const clientId = await this.getClientId();
+        const { tokenAddress, isNativeToken } = await this.resolveAsset(assetId);
+        if (!isNativeToken) {
+            // Check if approval is needed before proceeding
+            const needsApproval = await this.needsApproval(assetId, amount);
+            if (needsApproval) {
+                throw new ContractError(`Approval required before deposit. Please invoke approve() first for asset ${assetId} (token address: ${tokenAddress}).`, {
+                    revertReason: "APPROVAL_REQUIRED",
+                });
+            }
+        }
+        const walletAccount = this.walletClient.account;
+        if (!walletAccount) {
+            throw new InvalidConfigError("No account available in wallet client", "account");
+        }
+        // For native SEI (zero address), use depositNative (payable); for ERC20 tokens, use depositERC20
+        let hash;
+        if (isNativeToken) {
+            hash = await this.walletClient.writeContract({
+                address: vaultAddress,
+                abi: CONTRACT_ABIS.vault,
+                functionName: "depositNative",
+                args: [walletAccount.address, clientId],
+                account: walletAccount,
+                chain: this.chain,
+                value: amount,
+            });
+        }
+        else {
+            hash = await this.walletClient.writeContract({
+                address: vaultAddress,
+                abi: CONTRACT_ABIS.vault,
+                functionName: "depositERC20",
+                args: [walletAccount.address, clientId, tokenAddress, amount],
+                account: walletAccount,
+                chain: this.chain,
+            });
+        }
+        const nonce = walletAccount.getNonce ? await walletAccount.getNonce() : 0n;
+        const txResult = {
+            hash,
+            status: "pending",
+            nonce,
+        };
+        return await this.waitForTransaction(txResult, autoWait);
+    }
+    /**
+     * Initiates a withdrawal through the API Gateway and submits the resulting
+     * pre-signed calldata on-chain via the connected wallet.
+     *
+     * The gateway allocates a `withdrawalIndex` via the matching engine and returns
+     * ABI-encoded calldata for `executeSignedWithdrawal(...)` signed by the
+     * server-side `WITHDRAWAL_SIGNER`. The user's wallet pays gas to submit it,
+     * but the contract authenticates against the embedded signature — not the
+     * `msg.sender`. The connected wallet's address is sent as the on-chain
+     * `destination`.
+     *
+     * @param assetId - The asset identifier (UUID) to withdraw
+     * @param amount - The raw token amount to withdraw (as bigint)
+     * @param autoWait - Whether to automatically wait for transaction confirmation (defaults to true)
+     * @returns Promise resolving to `{ withdrawalIndex, transaction }`
+     * @throws {APIError} When the asset is not found or the request is rejected
+     * @throws {ContractError} When the on-chain submission fails
+     * @throws {InvalidConfigError} When wallet account is not available
+     *
+     * @example
+     * ```typescript
+     * // Withdraw 50 USDC, wait for on-chain confirmation
+     * const result = await vaultAPI.withdraw(
+     *   "123e4567-e89b-12d3-a456-426614174000",
+     *   parseUnits("50", 6),
+     * );
+     * console.log(`Withdrawal index: ${result.withdrawalIndex}`);
+     * console.log(`Tx hash: ${result.hash}, status: ${result.status}`);
+     *
+     * // Or skip auto-waiting and finalise later
+     * const result = await vaultAPI.withdraw(
+     *   "123e4567-e89b-12d3-a456-426614174000",
+     *   parseUnits("50", 6),
+     *   false,
+     * );
+     * const receipt = await sdk.waitForTransaction(result.hash);
+     * ```
+     */
+    async withdraw(assetId, amount, autoWait = true) {
+        if (!this.walletClient) {
+            throw new InvalidConfigError("Wallet client not set. Connect a wallet first.", "walletClient");
+        }
+        const walletAccount = this.walletClient.account;
+        if (!walletAccount) {
+            throw new InvalidConfigError("No account available in wallet client", "account");
+        }
+        const destination = walletAccount.address.toLowerCase();
+        validate(WithdrawSchema, { assetId, amount, destination, autoWait });
+        // 1. Gateway allocates withdrawal_index + returns pre-signed
+        // executeSignedWithdrawal calldata along with the vault address to send
+        // it to. Sourcing the vault address from this response (instead of
+        // GET /applications/config) keeps the calldata + target contract in
+        // lockstep and avoids an extra round-trip.
+        const { withdrawal_index: withdrawalIndex, vault_address: vaultAddress, calldata, } = await this.makeAuthenticatedRequest("/api/v1/withdrawals", {
+            method: "POST",
+            body: JSON.stringify({
+                asset_id: assetId,
+                amount: amount.toString(),
+                destination,
+            }),
+        });
+        // 2. Submit the calldata on-chain through the connected wallet.
+        let hash;
+        try {
+            hash = await this.walletClient.sendTransaction({
+                to: vaultAddress,
+                data: calldata,
+                account: walletAccount,
+                chain: this.chain,
+            });
+        }
+        catch (error) {
+            throw new ContractError(`Failed to submit executeSignedWithdrawal for withdrawal ${withdrawalIndex}: ${error instanceof Error ? error.message : "unknown error"}`, { cause: error instanceof Error ? error : undefined });
+        }
+        const nonce = walletAccount.getNonce ? await walletAccount.getNonce() : 0n;
+        const txResult = {
+            hash,
+            status: "pending",
+            nonce,
+        };
+        const settled = await this.waitForTransaction(txResult, autoWait);
+        return { ...settled, withdrawalIndex };
+    }
+    /**
+     * Retries a previously-initiated withdrawal whose on-chain submission never
+     * landed — e.g. the wallet rejected the tx, the page reloaded before the
+     * receipt came back, or a stuck mempool entry needs resending.
+     *
+     * Re-fetches the same `executeSignedWithdrawal` calldata the gateway
+     * generated when the withdrawal was initiated, then submits it through the
+     * connected wallet. Does NOT initiate a new withdrawal — the matching engine
+     * already debited the balance and allocated the index. The contract is
+     * idempotent against double-submission of a settled withdrawal: it will
+     * revert once the index is consumed on-chain.
+     *
+     * @param withdrawalIndex - The index returned by the original `withdraw()` call
+     * @param autoWait - Whether to await on-chain confirmation (defaults to true)
+     * @returns Promise resolving to `{ withdrawalIndex, ...transaction }`
+     * @throws {APIError} When the index doesn't exist
+     * @throws {ContractError} When the on-chain submission fails
+     * @throws {InvalidConfigError} When wallet account is not available
+     */
+    async retryWithdrawal(withdrawalIndex, autoWait = true) {
+        if (!this.walletClient) {
+            throw new InvalidConfigError("Wallet client not set. Connect a wallet first.", "walletClient");
+        }
+        const walletAccount = this.walletClient.account;
+        if (!walletAccount) {
+            throw new InvalidConfigError("No account available in wallet client", "account");
+        }
+        const { vault_address: vaultAddress, calldata } = await this.makePublicRequest(`/api/v1/withdrawals/${withdrawalIndex}`);
+        let hash;
+        try {
+            hash = await this.walletClient.sendTransaction({
+                to: vaultAddress,
+                data: calldata,
+                account: walletAccount,
+                chain: this.chain,
+            });
+        }
+        catch (error) {
+            throw new ContractError(`Failed to resubmit executeSignedWithdrawal for withdrawal ${withdrawalIndex}: ${error instanceof Error ? error.message : "unknown error"}`, { cause: error instanceof Error ? error : undefined });
+        }
+        const nonce = walletAccount.getNonce ? await walletAccount.getNonce() : 0n;
+        const txResult = {
+            hash,
+            status: "pending",
+            nonce,
+        };
+        const settled = await this.waitForTransaction(txResult, autoWait);
+        return { ...settled, withdrawalIndex };
+    }
+    /**
+     * Retrieves the user's token balance in the vault.
+     *
+     * @param _assetId - The asset identifier (UUID) to check balance for
+     * @returns Promise that always rejects with deprecation error
+     * @throws {APIError} Always throws - this method is deprecated
+     * @deprecated Use `profileAPI.getUserBalances()` or `profileAPI.getUserBalanceByAssetId()` instead.
+     */
+    async getBalance(_assetId) {
+        throw new APIError("getBalance() is deprecated and no longer supported. Please use profileAPI.getUserBalances() or profileAPI.getUserBalanceByAssetId() instead for balance data.", { statusCode: 410 });
+    }
+    /**
+     * Retrieves the current allowance for a token.
+     *
+     * Queries the ERC20 token contract to get the current allowance granted to the
+     * vault contract for spending tokens on behalf of the user.
+     *
+     * @param assetId - The asset identifier (UUID) to check allowance for
+     * @returns Promise resolving to the current allowance amount as bigint
+     * @throws {ContractError} When allowance retrieval fails or asset not found
+     *
+     * @example
+     * ```typescript
+     * const allowance = await vaultAPI.getAllowance("123e4567-e89b-12d3-a456-426614174000");
+     * console.log(`Current allowance: ${formatUnits(allowance, 6)} USDC`);
+     * ```
+     */
+    async getAllowance(assetId) {
+        if (!this.walletClient) {
+            throw new InvalidConfigError("Wallet client not set. Connect a wallet first.", "walletClient");
+        }
+        const vaultAddress = await this.getVaultAddress();
+        const addresses = await this.walletClient.getAddresses();
+        const account = addresses[0];
+        if (!account) {
+            throw new InvalidConfigError("No account found in wallet client.", "walletClient");
+        }
+        const { tokenAddress } = await this.resolveAsset(assetId);
+        return (await this.publicClient.readContract({
+            address: tokenAddress,
+            abi: erc20Abi,
+            functionName: "allowance",
+            args: [account, vaultAddress],
+        }));
+    }
+    /**
+     * Checks if approval is needed for a specific amount.
+     *
+     * Compares the current allowance with the requested amount to determine if
+     * the user needs to approve more tokens before performing operations.
+     *
+     * @param assetId - The asset identifier (UUID) to check for
+     * @param amount - The amount to check approval for (as bigint)
+     * @returns Promise resolving to true if approval is needed, false otherwise
+     * @throws {ContractError} When approval check fails or asset not found
+     *
+     * @example
+     * ```typescript
+     * const needsApproval = await vaultAPI.needsApproval(
+     *   "123e4567-e89b-12d3-a456-426614174000",
+     *   parseUnits("100", 6)
+     * );
+     *
+     * if (needsApproval) {
+     *   console.log("Approval required before deposit");
+     *   await vaultAPI.approve("123e4567-e89b-12d3-a456-426614174000", parseUnits("100", 6));
+     * }
+     * ```
+     */
+    async needsApproval(assetId, amount) {
+        const allowance = await this.getAllowance(assetId);
+        return allowance < amount;
+    }
+    async waitForTransaction(txResult, autoWait = true, options = {}) {
+        if (!autoWait) {
+            return txResult;
+        }
+        const { confirmations = 1, timeout = 60000 } = options;
+        try {
+            const receipt = await this.publicClient.waitForTransactionReceipt({
+                hash: txResult.hash,
+                confirmations,
+                timeout,
+            });
+            return {
+                ...txResult,
+                status: receipt.status === "success" ? "confirmed" : "failed",
+                receipt,
+            };
+        }
+        catch {
+            return {
+                ...txResult,
+                status: "failed",
+            };
+        }
+    }
+}

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

@@ -0,0 +1,4 @@
+/**
+ * Vault API Module
+ */
+export { VaultAPIImpl } from "./api";

package/dist/api/vault/index.js

@@ -0,0 +1,4 @@
+/**
+ * Vault API Module
+ */
+export { VaultAPIImpl } from "./api";

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

@@ -0,0 +1,3 @@
+export * from "./types";
+export * from "./utils";
+export * from "./websocket";

package/dist/api/websocket/index.js

@@ -0,0 +1,3 @@
+export * from "./types";
+export * from "./utils";
+export * from "./websocket";

package/dist/api/websocket/types.d.ts

@@ -0,0 +1,41 @@
+import type { ConditionalOrderEvent, Interval, OHLCVEvent, OrderbookEvent, OrderbookQuotationMode, OrderEvent, TradeEvent, TradingMode, UserBalanceEvent, UserMovementEvent, WebSocketStatus } from "@0xmonaco/types";
+export type StatusHandler = (status: WebSocketStatus) => void;
+export type MessageHandler<T> = (data: T) => void;
+export interface MonacoWebSocketOptions {
+    /** JWT access token for authenticated channels (orders) */
+    token?: string;
+    /** Enable auto-reconnect on disconnect (default: true) */
+    autoReconnect?: boolean;
+    /** Maximum reconnection attempts (default: 5) */
+    maxReconnectAttempts?: number;
+    /** Callback for connection status changes */
+    onStatusChange?: StatusHandler;
+}
+export interface MonacoWebSocket {
+    /** Connect to the WebSocket server */
+    connect: () => Promise<void>;
+    /** Disconnect from the WebSocket server */
+    disconnect: () => void;
+    /** Check if currently connected */
+    isConnected: () => boolean;
+    /** Get current websocket connection status */
+    getStatus: () => WebSocketStatus;
+    /** Update the access token (for re-auth) */
+    setToken: (token: string) => void;
+    /** Subscribe to order events (requires authentication) */
+    orders: (tradingPairId: string, tradingMode: TradingMode, handler: MessageHandler<OrderEvent>) => () => void;
+    /** Subscribe to orderbook events (public) */
+    orderbook: (tradingPairId: string, tradingMode: TradingMode, magnitude: number, quotationMode: OrderbookQuotationMode, handler: MessageHandler<OrderbookEvent>) => () => void;
+    /** Subscribe to OHLCV candlestick events (public) */
+    ohlcv: (tradingPairId: string, tradingMode: TradingMode, interval: Interval, handler: MessageHandler<OHLCVEvent>) => () => void;
+    /** Subscribe to trade events (public) */
+    trades: (tradingPairId: string, handler: MessageHandler<TradeEvent>) => () => void;
+    /** Subscribe to user movement events (requires authentication) */
+    movements: (handler: MessageHandler<UserMovementEvent>) => () => void;
+    /** Subscribe to user order events for all trading pairs (requires authentication) */
+    userOrders: (handler: MessageHandler<OrderEvent>) => () => void;
+    /** Subscribe to user balance events (requires authentication) */
+    balances: (handler: MessageHandler<UserBalanceEvent>) => () => void;
+    /** Subscribe to conditional TP/SL lifecycle events (requires authentication) */
+    conditionalOrders: (handler: MessageHandler<ConditionalOrderEvent>, tradingPairId?: string) => () => void;
+}

package/dist/api/websocket/utils.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Convert snake_case to camelCase
+ */
+export declare function toCamelCase(str: string): string;
+/**
+ * Recursively convert object keys from snake_case to camelCase
+ */
+export declare function keysToCamelCase<T>(obj: unknown): T;

package/dist/api/websocket/utils.js

@@ -0,0 +1,22 @@
+/**
+ * Convert snake_case to camelCase
+ */
+export function toCamelCase(str) {
+    return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+/**
+ * Recursively convert object keys from snake_case to camelCase
+ */
+export function keysToCamelCase(obj) {
+    if (obj === null || obj === undefined)
+        return obj;
+    if (typeof obj !== "object")
+        return obj;
+    if (Array.isArray(obj))
+        return obj.map((item) => keysToCamelCase(item));
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        result[toCamelCase(key)] = typeof value === "object" && value !== null ? keysToCamelCase(value) : value;
+    }
+    return result;
+}

package/dist/api/websocket/websocket.d.ts

@@ -0,0 +1,5 @@
+import type { MonacoWebSocket, MonacoWebSocketOptions } from "./types";
+/**
+ * Create a Monaco WebSocket client
+ */
+export declare function createMonacoWebSocket(baseUrl: string, options?: MonacoWebSocketOptions): MonacoWebSocket;