@0xmonaco/core 1.0.94 → 1.0.97

package/dist/api/websocket/websocket.js

@@ -1109,6 +1109,13 @@ export function createMonacoWebSocket(baseUrl, options = {}, serverClock = new S
     // with nothing confirmed and re-requests what is wanted.
     const confirmedChannels = new Set();
     let pendingRequests = [];
+    // First subscribers of the current tick on the open socket, in call order,
+    // not yet sent. The server reads one command at a time, so a Subscribe per
+    // channel would hold each later channel's first frame behind the earlier
+    // ones' snapshot reads; they go out together as one Subscribe instead. A
+    // request enters `pendingRequests` only when its frame is sent.
+    let queuedSubscribes = [];
+    let subscribeFlushScheduled = false;
     // Wanted channels the server rejected with AUTH_REQUIRED on this socket,
     // re-requested once when the connection next authenticates.
     const authRejectedChannels = new Set();
@@ -1283,13 +1290,50 @@ export function createMonacoWebSocket(baseUrl, options = {}, serverClock = new S
         pendingRequests.push({ kind: "unsubscribe", channels });
         send({ type: "Unsubscribe", channels });
     };
+    /** Send the channels queued this tick as one Subscribe. */
+    const flushQueuedSubscribes = () => {
+        const channels = queuedSubscribes;
+        queuedSubscribes = [];
+        sendSubscribe(channels);
+    };
+    /**
+     * Queue a first subscriber's Subscribe for the end of the current tick.
+     * Only on an open socket: otherwise the next open's resubscribe sends it.
+     */
+    const queueSubscribe = (channel) => {
+        if (ws?.readyState !== WebSocket.OPEN)
+            return;
+        queuedSubscribes.push(channel);
+        if (subscribeFlushScheduled)
+            return;
+        subscribeFlushScheduled = true;
+        queueMicrotask(() => {
+            subscribeFlushScheduled = false;
+            flushQueuedSubscribes();
+        });
+    };
+    /**
+     * Drop a channel released before its queued Subscribe went out. Returns
+     * whether it was queued: the server was never asked for it, so there is
+     * nothing to unsubscribe.
+     */
+    const unqueueSubscribe = (channel) => {
+        const index = queuedSubscribes.indexOf(channel);
+        if (index === -1)
+            return false;
+        queuedSubscribes.splice(index, 1);
+        return true;
+    };
     /** Forget everything the server confirmed or was asked on the old socket. */
     const resetSubscriptionAcks = () => {
         confirmedChannels.clear();
         pendingRequests = [];
+        queuedSubscribes = [];
         authRejectedChannels.clear();
     };
-    const isRequested = (kind, channel) => pendingRequests.some((request) => request.kind === kind && request.channels.includes(channel));
+    // A queued Subscribe counts as requested: it goes out this tick.
+    const isRequested = (kind, channel) => (kind === "subscribe" && queuedSubscribes.includes(channel)) ||
+        pendingRequests.some((request) => request.kind === kind && request.channels.includes(channel));
     const getSubscriptionState = (channel) => {
         if (handlers.has(channel)) {
             if (isRequested("subscribe", channel))
@@ -1687,7 +1731,7 @@ export function createMonacoWebSocket(baseUrl, options = {}, serverClock = new S
         }
         // Only send Subscribe message on first subscriber for this channel
         if (isFirstSubscriber) {
-            sendSubscribe([channel]);
+            queueSubscribe(channel);
         }
         // Return unsubscribe function
         return () => {
@@ -1704,7 +1748,9 @@ export function createMonacoWebSocket(baseUrl, options = {}, serverClock = new S
                 // Only send Unsubscribe on last subscriber for this channel
                 if (channelHandlers.size === 0) {
                     handlers.delete(channel);
-                    sendUnsubscribe([channel]);
+                    if (!unqueueSubscribe(channel)) {
+                        sendUnsubscribe([channel]);
+                    }
                 }
             }
         };

package/dist/crypto/http-signatures.js

@@ -1,5 +1,5 @@
 /** Monaco's RFC 9421 Ed25519 profile; key registration remains wallet-authorized. */
-import { ed25519 } from "@noble/curves/ed25519";
+import { ed25519 } from "@noble/curves/ed25519.js";
 import { sha256 } from "@noble/hashes/sha2.js";
 import { bytesToHex, utf8ToBytes } from "@noble/hashes/utils.js";
 function base64(bytes) {

package/dist/crypto/session.js

@@ -7,7 +7,7 @@
  * private key. The server verifies the signature against the stored public
  * key — it never sees the private key, so it cannot mint requests as the user.
  */
-import { ed25519 } from "@noble/curves/ed25519";
+import { ed25519 } from "@noble/curves/ed25519.js";
 import { sha256 } from "@noble/hashes/sha2.js";
 import { bytesToHex, hexToBytes, utf8ToBytes } from "@noble/hashes/utils.js";
 /**
@@ -21,7 +21,7 @@ export function generateSessionKeypair() {
     if (typeof globalThis.crypto?.getRandomValues !== "function") {
         throw new Error("Secure randomness (crypto.getRandomValues) is unavailable; cannot generate a session keypair.");
     }
-    const privateKey = ed25519.utils.randomPrivateKey();
+    const privateKey = ed25519.utils.randomSecretKey();
     const publicKey = ed25519.getPublicKey(privateKey);
     return { publicKey, privateKey };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@0xmonaco/core",
-	"version": "1.0.94",
+	"version": "1.0.97",
 	"type": "module",
 	"homepage": "https://docs.0xmonaco.com/sdk/typescript",
 	"main": "./dist/index.js",
@@ -19,15 +19,15 @@
 		"viem": "^2.45.2"
 	},
 	"dependencies": {
-		"@0xmonaco/contracts": "1.0.94",
-		"@0xmonaco/types": "1.0.94",
-		"@noble/curves": "^1.9.1",
+		"@0xmonaco/contracts": "1.0.97",
+		"@0xmonaco/types": "1.0.97",
+		"@noble/curves": "^2.4.0",
 		"@noble/hashes": "^2.4.0",
 		"http-status-codes": "^2.3.0"
 	},
 	"devDependencies": {
-		"dotenv": "^17.1.0",
-		"ws": "^8.18.3"
+		"dotenv": "^18.0.8",
+		"ws": "^8.22.0"
 	},
 	"exports": {
 		".": {