@effectstream/frontend-sdk 0.100.12 → 0.100.14

package/dist/mod.js

@@ -1412,7 +1412,7 @@ __export(exports_util, {
   callbackify: () => callbackify,
   _extend: () => _extend,
   TextEncoder: () => TextEncoder2,
-  TextDecoder: () => TextDecoder
+  TextDecoder: () => TextDecoder2
 });
 function format(f, ...args) {
   if (!isString(f)) {
@@ -1723,7 +1723,7 @@ function callbackify(original) {
   }
   return Object.setPrototypeOf(callbackified, Object.getPrototypeOf(original)), Object.defineProperties(callbackified, Object.getOwnPropertyDescriptors(original)), callbackified;
 }
-var formatRegExp, debuglog, inspect, types = () => {}, months, promisify, TextEncoder2, TextDecoder, util_default;
+var formatRegExp, debuglog, inspect, types = () => {}, months, promisify, TextEncoder2, TextDecoder2, util_default;
 var init_util = __esm(() => {
   formatRegExp = /%[sdj%]/g;
   debuglog = ((debugs = {}, debugEnvRegex = {}, debugEnv) => ((debugEnv = typeof process < "u" && false) && (debugEnv = debugEnv.replace(/[|\\{}()[\]^$+?.]/g, "\\$&").replace(/\*/g, ".*").replace(/,/g, "$|^").toUpperCase()), debugEnvRegex = new RegExp("^" + debugEnv + "$", "i"), (set) => {
@@ -1787,8 +1787,8 @@ var init_util = __esm(() => {
       Object.defineProperty(fn, kCustomPromisifiedSymbol, { value: fn, enumerable: false, writable: false, configurable: true });
     return Object.defineProperties(fn, Object.getOwnPropertyDescriptors(original));
   });
-  ({ TextEncoder: TextEncoder2, TextDecoder } = globalThis);
-  util_default = { TextEncoder: TextEncoder2, TextDecoder, promisify, log, inherits, _extend, callbackifyOnRejected, callbackify };
+  ({ TextEncoder: TextEncoder2, TextDecoder: TextDecoder2 } = globalThis);
+  util_default = { TextEncoder: TextEncoder2, TextDecoder: TextDecoder2, promisify, log, inherits, _extend, callbackifyOnRejected, callbackify };
 });
 
 // node:events
@@ -20640,7 +20640,7 @@ function addHashes(event) {
   return {
     name: event.name,
     fields: event.fields.flatMap((field) => {
-      if (field.indexed === false)
+      if (field.indexed !== true)
         return field;
       const isString2 = Type5.Extends(field.type, Type5.String(), Type5.Literal(true), Type5.Literal(false)).const;
       const isNumber2 = Type5.Extends(field.type, Type5.Number(), Type5.Literal(true), Type5.Literal(false)).const;
@@ -20664,7 +20664,13 @@ function addHashes(event) {
 }
 
 // ../effectstream-sdk/events/src/app-events.ts
+import { Type as Type6 } from "@sinclair/typebox";
 import sha32 from "js-sha3";
+var BLOCK_HEIGHT_FIELD = {
+  name: "blockHeight",
+  type: Type6.Integer(),
+  indexed: true
+};
 // ../effectstream-sdk/events/src/utils.ts
 function fillPath(path, args) {
   const keys = new Set(Object.keys(args));
@@ -20723,11 +20729,8 @@ function keysForPath(path) {
   return path.filter((p) => typeof p !== "string").map((p) => p.name);
 }
 
-// ../effectstream-sdk/events/src/event-connect.ts
-import mqtt from "mqtt";
-
 // ../effectstream-sdk/events/src/builtin-events.ts
-import { Type as Type6 } from "@sinclair/typebox";
+import { Type as Type7 } from "@sinclair/typebox";
 var BatcherStatus;
 ((BatcherStatus2) => {
   BatcherStatus2["Posting"] = "posting";
@@ -20740,21 +20743,21 @@ var BatcherHash = genEvent({
   fields: [
     {
       name: "batch",
-      type: Type6.String(),
+      type: Type7.String(),
       indexed: true
     },
     {
       name: "status",
-      type: Type6.Enum(BatcherStatus),
+      type: Type7.Enum(BatcherStatus),
       indexed: true
     },
     {
       name: "blockHeight",
-      type: Type6.Optional(Type6.Integer())
+      type: Type7.Optional(Type7.Integer())
     },
     {
       name: "transactionHash",
-      type: Type6.String()
+      type: Type7.String()
     }
   ]
 });
@@ -20763,12 +20766,12 @@ var RollupBlock = genEvent({
   fields: [
     {
       name: "block",
-      type: Type6.Integer(),
+      type: Type7.Integer(),
       indexed: true
     },
     {
       name: "timestamp",
-      type: Type6.Optional(Type6.Integer())
+      type: Type7.Optional(Type7.Integer())
     }
   ]
 });
@@ -20777,17 +20780,17 @@ var SyncChains = genEvent({
   fields: [
     {
       name: "chain",
-      type: Type6.String(),
+      type: Type7.String(),
       indexed: true
     },
     {
       name: "block",
-      type: Type6.Integer(),
+      type: Type7.Integer(),
       indexed: true
     },
     {
       name: "rollup",
-      type: Type6.Integer(),
+      type: Type7.Integer(),
       indexed: false
     }
   ]
@@ -20827,69 +20830,115 @@ async function setupInitialListeners(_broker) {
 
 // ../effectstream-sdk/events/src/event-connect.ts
 import { extract, matches } from "mqtt-pattern";
+var utf8Encoder = new TextEncoder;
+var utf8Decoder = new TextDecoder;
+function dispatchMessage(topic, payload) {
+  const message = utf8Decoder.decode(payload);
+  for (const [_broker, info] of Object.entries(EventManager.Instance.callbacksForTopic)) {
+    for (const [pattern, callbacks] of Object.entries(info)) {
+      if (matches(pattern, topic)) {
+        for (const callbackInfo of Object.getOwnPropertySymbols(callbacks).map((sym) => callbacks[sym])) {
+          const data = JSON.parse(message);
+          const resolved = extract(toPattern(callbackInfo.event.path), topic);
+          callbackInfo.callback({
+            val: data,
+            resolvedPath: resolved
+          });
+        }
+      }
+    }
+  }
+}
+async function createOpifexClient(url) {
+  const opifexPath = "@seriousme/opifex" + "/tcpClient";
+  const { TcpClient } = await import(opifexPath);
+  const client = new TcpClient;
+  await client.connect({ url: new URL(url), numberOfRetries: 3 });
+  (async () => {
+    for await (const msg of client.messages()) {
+      dispatchMessage(msg.topic, new Uint8Array(msg.payload));
+    }
+  })();
+  const adapter = {
+    connected: true,
+    async subscribe(topic, qos) {
+      await client.subscribe({
+        subscriptions: [{ topicFilter: topic, qos }]
+      });
+    },
+    async publish(topic, payload, qos) {
+      await client.publish({
+        topic,
+        payload: utf8Encoder.encode(payload),
+        qos
+      });
+    }
+  };
+  client.onConnected = () => {
+    adapter.connected = true;
+  };
+  client.onDisconnected = () => {
+    adapter.connected = false;
+  };
+  return adapter;
+}
+async function createMqttJsClient(url) {
+  const mqtt = await import("mqtt");
+  const client = await mqtt.default.connectAsync(url);
+  client.on("message", (topic, message) => {
+    dispatchMessage(topic, new Uint8Array(message));
+  });
+  return {
+    get connected() {
+      return client.connected;
+    },
+    async subscribe(topic, qos) {
+      await client.subscribeAsync(topic, { qos });
+    },
+    async publish(topic, payload, qos) {
+      await client.publishAsync(topic, payload, { qos });
+    }
+  };
+}
 var ENV = {
-  MQTT_ENGINE_BROKER_URL: "ws://localhost:8883",
-  MQTT_BATCHER_BROKER_URL: "ws://localhost:8884"
+  MQTT_ENGINE_BROKER_URL: "mqtt://localhost:8883",
+  MQTT_BATCHER_BROKER_URL: "mqtt://localhost:8884",
+  MQTT_ENGINE_BROKER_WS_URL: "ws://localhost:9883",
+  MQTT_BATCHER_BROKER_WS_URL: "ws://localhost:9884"
 };
 
 class EventConnect {
   static clients = {};
-  constructor() {
-    this.getClient.bind(this);
-    this.setupClient.bind(this);
-    this.connectEngine.bind(this);
-    this.connectBatcher.bind(this);
-  }
-  static _bunMqttWarned = false;
   async getClient(broker) {
-    if (getRuntime().runtime === "bun") {
-      if (!EventConnect._bunMqttWarned) {
-        EventConnect._bunMqttWarned = true;
-        console.warn("[MQTT] WebSocket-based MQTT is not supported in Bun (ws.createWebSocketStream is unimplemented). " + "See: https://github.com/oven-sh/bun/pull/24304");
-      }
-      return null;
-    }
     switch (broker) {
-      case "effectstream-engine" /* Engine */: {
+      case "effectstream-engine" /* Engine */:
         return await this.connectEngine();
-      }
       case "batcher" /* Batcher */:
         return await this.connectBatcher();
     }
   }
   async setupClient(url) {
-    const client = await mqtt.connectAsync(url);
-    client.on("message", (topic, message) => {
-      for (const [_broker, info] of Object.entries(EventManager.Instance.callbacksForTopic)) {
-        for (const [pattern, callbacks] of Object.entries(info)) {
-          if (matches(pattern, topic)) {
-            for (const callbackInfo of Object.getOwnPropertySymbols(callbacks).map((sym) => callbacks[sym])) {
-              const data = JSON.parse(message.toString());
-              const resolved = extract(toPattern(callbackInfo.event.path), topic);
-              callbackInfo.callback({
-                val: data,
-                resolvedPath: resolved
-              });
-            }
-          }
-        }
-      }
-    });
-    return client;
+    const runtime2 = getRuntime();
+    if (runtime2.environment === "frontend") {
+      return await createMqttJsClient(url);
+    }
+    return await createOpifexClient(url);
   }
   async connectEngine() {
     if (!EventConnect.clients.engine) {
-      const broker = "effectstream-engine" /* Engine */;
-      EventConnect.clients.engine = await this.setupClient(ENV.MQTT_ENGINE_BROKER_URL);
-      await setupInitialListeners(broker);
+      const runtime2 = getRuntime();
+      const url = runtime2.environment === "frontend" ? ENV.MQTT_ENGINE_BROKER_WS_URL : ENV.MQTT_ENGINE_BROKER_URL;
+      EventConnect.clients.engine = await this.setupClient(url);
+      await setupInitialListeners("effectstream-engine" /* Engine */);
     }
     return EventConnect.clients.engine;
   }
   async connectBatcher() {
     if (!EventConnect.clients.batcher) {
-      const broker = "batcher" /* Batcher */;
-      EventConnect.clients.batcher = await this.setupClient(ENV.MQTT_BATCHER_BROKER_URL);
-      await setupInitialListeners(broker);
+      const runtime2 = getRuntime();
+      const url = runtime2.environment === "frontend" ? ENV.MQTT_BATCHER_BROKER_WS_URL : ENV.MQTT_BATCHER_BROKER_URL;
+      EventConnect.clients.batcher = await this.setupClient(url);
+      await setupInitialListeners("batcher" /* Batcher */);
     }
     return EventConnect.clients.batcher;
   }
@@ -20903,13 +20952,6 @@ class EventManager {
   };
   symbolToSubscription = {};
   static Instance = new EventManager;
-  constructor() {
-    this.subscribe.bind(this);
-    this.subscribeExplicit.bind(this);
-    this.unsubscribe.bind(this);
-    this.sendMessage.bind(this);
-    this.sendMessageExplicit.bind(this);
-  }
   async subscribe(args, callback) {
     return await this.subscribeExplicit({
       topic: args.topic,
@@ -20921,22 +20963,11 @@ class EventManager {
     if (!client)
       return Symbol("noop");
     const topic = fillPath(args.topic.path, args.filter);
-    const clientSubscribe = async () => {
-      try {
-        await client.subscribeAsync(topic, { qos: 2 });
-      } catch (err) {
-        console.log(`MQTT[${args.topic.broker}] ERROR`, err);
-      }
-    };
-    if (client.connected)
-      await clientSubscribe();
-    else
-      await new Promise((resolve) => {
-        client.on("connect", async () => {
-          await clientSubscribe();
-          resolve();
-        });
-      });
+    try {
+      await client.subscribe(topic, 2);
+    } catch (err) {
+      console.log(`MQTT[${args.topic.broker}] ERROR`, err);
+    }
     const symbol = Symbol(topic);
     this.symbolToSubscription[symbol] = {
       broker: args.topic.broker,
@@ -20961,26 +20992,7 @@ class EventManager {
     delete callbacks[event];
     const numCallbacks = Object.keys(callbacks).length - 1;
     if (numCallbacks === 0) {
-      const client = await new EventConnect().getClient(broker);
       delete this.callbacksForTopic[broker][topic];
-      if (!client)
-        return;
-      const clientUnsubscribe = async () => {
-        try {
-          await client.unsubscribeAsync(topic);
-        } catch (err) {
-          console.log(`MQTT[${broker}] ERROR`, err);
-        }
-      };
-      if (client.connected)
-        await clientUnsubscribe();
-      else
-        await new Promise((resolve) => {
-          client.on("connect", async () => {
-            await clientUnsubscribe();
-            resolve();
-          });
-        });
     }
   }
   async sendMessage(topic, event) {
@@ -20994,11 +21006,11 @@ class EventManager {
     if (!client)
       return;
     const topicPath = fillPath(args.topic.path, args.filter);
-    await client.publishAsync(topicPath, JSON.stringify(message), { qos: 2 });
+    await client.publish(topicPath, JSON.stringify(message), 2);
   }
 }
 // ../effectstream-sdk/events/src/evm.ts
-import { Kind, Type as Type7 } from "@sinclair/typebox";
+import { Kind, Type as Type8 } from "@sinclair/typebox";
 // ../effectstream-sdk/wallets/src/effectstream.ts
 class EffectstreamConfig {
   appName;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effectstream/frontend-sdk",
-  "version": "0.100.12",
+  "version": "0.100.14",
   "license": "MIT",
   "homepage": "https://effectstream.github.io/docs/",
   "repository": {
@@ -27,7 +27,7 @@
     "build": "bun run build.ts"
   },
   "dependencies": {
-    "@effectstream/wallets": "0.100.12"
+    "@effectstream/wallets": "0.100.14"
   },
   "description": "React frontend SDK for EffectStream"
 }